fltk
/
fltk
mirror of https://github.com/fltk/fltk.git
1
0
Fork 0
Code Issues Releases Activity
Browse Source

xutf8 files code conformance: 

o C files containing C++ "//" comments -> C style "/* */" comments
    o Converted unintended doxygen style comments to regular C comments
    o FLTK brace/indent coding standard conformance
    o Tested linux + sgi
    o Avoided mods to xutf8/lcUniConv [libiconv/FSF code]
      to avoid unwanted diffs with future updates of that lib
      as per Fabien's fltk.dev request 03/14/09.
      (Those files already compliant anyway)



git-svn-id: file:///fltk/svn/fltk/branches/branch-1.3@6698 ea41ed52-d2ee-0310-a9c1-e6b18d33e121
pull/49/head
Greg Ercolano 16 years ago
parent
5d601837b9
commit
6cbde8909b
14 changed files with 2110 additions and 2192 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 18
      src/xutf8/case.c
  2. 4
      src/xutf8/is_right2left.c
  3. 5
      src/xutf8/is_spacing.c
  4. 4
      src/xutf8/keysym2Ucs.c
  5. 59
      src/xutf8/test.c
  6. 37
      src/xutf8/test2.c
  7. 9
      src/xutf8/ucs2fontmap.c
  8. 63
      src/xutf8/utf8Input.c
  9. 47
      src/xutf8/utf8Utils.c
  10. 193
      src/xutf8/utf8Wrap.c
  11. 10
      src/xutf8/utils/conv_gen.c
  12. 22
      src/xutf8/utils/convert_map.c
  13. 47
      src/xutf8/utils/create_table.c
  14. 4
      src/xutf8/utils/euc_tw.c

18
src/xutf8/case.c
Unescape View File

@ -30,13 +30,9 @@
#include "headers/case.h" #include "headers/case.h"
#include <stdlib.h> #include <stdlib.h>
int int
XUtf8Tolower( XUtf8Tolower(int ucs) {
int ucs)
{
int ret; int ret;
if (ucs <= 0x02B6) { if (ucs <= 0x02B6) {
if (ucs >= 0x0041) { if (ucs >= 0x0041) {
ret = ucs_table_0041[ucs - 0x0041]; ret = ucs_table_0041[ucs - 0x0041];
@ -105,15 +101,12 @@ XUtf8Tolower(
} }
int int
XUtf8Toupper( XUtf8Toupper(int ucs) {
int ucs)
{
int i; int i;
static unsigned short *table = NULL; static unsigned short *table = NULL;
if (!table) { if (!table) {
table = (unsigned short*) malloc( table = (unsigned short*) malloc(sizeof(unsigned short) * 0x10000);
sizeof(unsigned short) * 0x10000);
for (i = 0; i < 0x10000; i++) { for (i = 0; i < 0x10000; i++) {
table[i] = (unsigned short) i; table[i] = (unsigned short) i;
} }
@ -122,12 +115,11 @@ XUtf8Toupper(
l = XUtf8Tolower(i); l = XUtf8Tolower(i);
if (l != i) table[l] = (unsigned short) i; if (l != i) table[l] = (unsigned short) i;
} }
} }
if (ucs >= 0x10000 || ucs < 0) return ucs; if (ucs >= 0x10000 || ucs < 0) return ucs;
return table[ucs]; return table[ucs];
} }
/* /*
* End of "$Id$". * End of "$Id$".
*/ */

4
src/xutf8/is_right2left.c
Unescape View File

@ -28,9 +28,7 @@
*/ */
unsigned short unsigned short
XUtf8IsRightToLeft( XUtf8IsRightToLeft(unsigned int ucs) {
unsigned int ucs)
{
#if 0 #if 0
/* for debug only */ /* for debug only */

5
src/xutf8/is_spacing.c
Unescape View File

@ -29,11 +29,8 @@
#include "headers/spacing.h" #include "headers/spacing.h"
unsigned short unsigned short
XUtf8IsNonSpacing( XUtf8IsNonSpacing(unsigned int ucs) {
unsigned int ucs)
{
if (ucs <= 0x0361) { if (ucs <= 0x0361) {
if (ucs >= 0x0300) return ucs_table_0300[ucs - 0x0300]; if (ucs >= 0x0300) return ucs_table_0300[ucs - 0x0300];

4
src/xutf8/keysym2Ucs.c
Unescape View File

@ -30,9 +30,7 @@
#include "../../FL/Xutf8.h" #include "../../FL/Xutf8.h"
#include "imKStoUCS.c" #include "imKStoUCS.c"
long XKeysymToUcs(KeySym keysym) {
long XKeysymToUcs(KeySym keysym)
{
return (long) KeySymToUcs4(keysym); return (long) KeySymToUcs4(keysym);
} }

59
src/xutf8/test.c
Unescape View File

@ -26,7 +26,9 @@
/* /*
* UTF-8 X test program (It contains MINIMAL code to support XIM !!!) * UTF-8 X test program (It contains MINIMAL code to support XIM !!!)
* *
To test it do : ****************
* To test it do:
****************
kinput2 -canna kinput2 -canna
XMODIFIERS="@im=kinput2"; export XMODIFIERS XMODIFIERS="@im=kinput2"; export XMODIFIERS
@ -51,7 +53,7 @@ export LANG=ko_KR; export XMODIFIERS="@im=Ami"
export LANG=zh_TW; export XMODIFIERS="@im=xcin-zh_TW" export LANG=zh_TW; export XMODIFIERS="@im=xcin-zh_TW"
export LANG=zh_TW; export XMODIFIERS="@im=xcin-zh_CN" export LANG=zh_TW; export XMODIFIERS="@im=xcin-zh_CN"
export LANG=C; export XMODIFIERS="@im=interxim" export LANG=C; export XMODIFIERS="@im=interxim"
*/ **********************************************************/
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -80,8 +82,7 @@ GC gc;
int x = 2; int x = 2;
int y = 40; int y = 40;
int main(int argc, char**argv) int main(int argc, char**argv) {
{
char **missing_charset_list; char **missing_charset_list;
int missing_charset_count; int missing_charset_count;
XGCValues xgcv; XGCValues xgcv;
@ -124,7 +125,10 @@ int main(int argc, char**argv)
DefaultDepth(dpy, DefaultScreen(dpy)), DefaultDepth(dpy, DefaultScreen(dpy)),
InputOutput, DefaultVisual(dpy, DefaultScreen(dpy)), InputOutput, DefaultVisual(dpy, DefaultScreen(dpy)),
CWEventMask | CWBackPixel | CWBorderPixel, &set_attr); CWEventMask | CWBackPixel | CWBorderPixel, &set_attr);
if (!w) { puts("cannot creat window.\n"); exit(-1); } if (!w) {
puts("cannot creat window.\n");
exit(-1);
}
class_hints.res_name = "test"; class_hints.res_name = "test";
class_hints.res_class = "Test"; class_hints.res_class = "Test";
@ -140,12 +144,14 @@ int main(int argc, char**argv)
puts("cannot Open Input Manager: Try default.\n"); puts("cannot Open Input Manager: Try default.\n");
XSetLocaleModifiers("@im="); XSetLocaleModifiers("@im=");
xim_im = XOpenIM(dpy, NULL, "test", "Test"); xim_im = XOpenIM(dpy, NULL, "test", "Test");
if (!xim_im) { puts("Failed exiting.\n"); exit(-1); } if (!xim_im) {
puts("Failed exiting.\n");
exit(-1);
}
} }
XGetIMValues (xim_im, XNQueryInputStyle, &xim_styles, NULL, NULL); XGetIMValues (xim_im, XNQueryInputStyle, &xim_styles, NULL, NULL);
for (i = 0, style = xim_styles->supported_styles; for (i = 0, style = xim_styles->supported_styles;
i < xim_styles->count_styles; i++, style++) i < xim_styles->count_styles; i++, style++) {
{
if (i == 0 && *style == (XIMStatusNone|XIMPreeditNone)) { if (i == 0 && *style == (XIMStatusNone|XIMPreeditNone)) {
printf("this is not a XIM server !!!\n"); printf("this is not a XIM server !!!\n");
no_xim = 1; no_xim = 1;
@ -159,16 +165,19 @@ int main(int argc, char**argv)
XNClientWindow, w, XNClientWindow, w,
XNFocusWindow, w, XNFocusWindow, w,
NULL); NULL);
if (!xim_ic) { puts("cannot create Input Context.\n"); exit(-1);} if (!xim_ic) {
puts("cannot create Input Context.\n");
exit(-1);
}
XFree(xim_styles); XFree(xim_styles);
XSetICFocus(xim_ic); XSetICFocus(xim_ic);
/***************************************************************/ /***************************************************************
/** I don't recommand to use a font base name list similar * I don't recommend to use a font base name list similar
* to the following one in a real application ;-) * to the following one in a real application ;-)
* You should use an iso8859-1 font, plus a single font for * You should use an iso8859-1 font, plus a single font for
* your language. */ * your language.
/***************************************************************/ ***************************************************************/
fontset = XCreateUtf8FontStruct(dpy, fontset = XCreateUtf8FontStruct(dpy,
"-*-*-*-*-*-*-*-*-*-*-*-*-iso8858-3," /* not valid */ "-*-*-*-*-*-*-*-*-*-*-*-*-iso8858-3," /* not valid */
"-*-*-medium-r-*-*-*-*-*-*-*-*-iso8859-1," "-*-*-medium-r-*-*-*-*-*-*-*-*-iso8859-1,"
@ -204,8 +213,10 @@ int main(int argc, char**argv)
xgcv.background = WhitePixel(dpy, DefaultScreen(dpy)); xgcv.background = WhitePixel(dpy, DefaultScreen(dpy));
gc = XCreateGC(dpy, w, mask, &xgcv); gc = XCreateGC(dpy, w, mask, &xgcv);
if (!gc) { puts("cannot create Graphic Context.\n"); exit(-1);} if (!gc) {
puts("cannot create Graphic Context.\n");
exit(-1);
}
/***************************************************************/ /***************************************************************/
while (1) { while (1) {
@ -226,8 +237,7 @@ int main(int argc, char**argv)
xim_im = XOpenIM(dpy, NULL, "test", "Test"); xim_im = XOpenIM(dpy, NULL, "test", "Test");
if (xim_im) { if (xim_im) {
xim_ic = XCreateIC(xim_im, xim_ic = XCreateIC(xim_im,
XNInputStyle, (XIMPreeditNothing | XNInputStyle, (XIMPreeditNothing | XIMStatusNothing),
XIMStatusNothing),
XNClientWindow, w, XNClientWindow, w,
XNFocusWindow, w, XNFocusWindow, w,
NULL); NULL);
@ -258,23 +268,16 @@ int main(int argc, char**argv)
x = 0; x = 0;
XCloseIM(xim_im); XCloseIM(xim_im);
} else { } else {
XUtf8DrawImageString(dpy, w, fontset, gc, XUtf8DrawImageString(dpy, w, fontset, gc, x, y, buf, len);
x, y, buf, len);
x += XUtf8TextWidth(fontset, buf, len); x += XUtf8TextWidth(fontset, buf, len);
} }
XUtf8DrawString(dpy, w, fontset, gc, 0, 20, jp_txt, strlen(jp_txt));
XUtf8DrawString(dpy, w, fontset, gc, 0, 20, XUtf8DrawString(dpy, w, fontset, gc, 50, 90, rtl_txt, strlen(rtl_txt));
jp_txt, strlen(jp_txt)); XUtf8DrawRtlString(dpy, w, fontset, gc, 50, 90, rtl_txt, strlen(rtl_txt));
XUtf8DrawString(dpy, w, fontset, gc, 50, 90,
rtl_txt, strlen(rtl_txt));
XUtf8DrawRtlString(dpy, w, fontset, gc,
50, 90, rtl_txt, strlen(rtl_txt));
buf[len] = 0; buf[len] = 0;
printf("'%s' %d %x\n", buf, keysym, keysym); printf("'%s' %d %x\n", buf, keysym, keysym);
buf[0] = 0; buf[0] = 0;
} }
if (filtered) { if (filtered) {
printf("Dead key\n"); printf("Dead key\n");

37
src/xutf8/test2.c
Unescape View File

@ -26,7 +26,9 @@
/* /*
* UTF-8 X test program * UTF-8 X test program
* *
To test it do : *****************
* To test it do :
*****************
kinput2 -canna kinput2 -canna
XMODIFIERS="@im=kinput2"; export XMODIFIERS XMODIFIERS="@im=kinput2"; export XMODIFIERS
@ -82,8 +84,7 @@ GC gc;
int x = 2; int x = 2;
int y = 40; int y = 40;
int main(int argc, char**argv) int main(int argc, char**argv) {
{
char **missing_charset_list; char **missing_charset_list;
int missing_charset_count; int missing_charset_count;
XGCValues xgcv; XGCValues xgcv;
@ -138,10 +139,9 @@ int main(int argc, char**argv)
XMapWindow(dpy, w); XMapWindow(dpy, w);
xim_im = XOpenIM(dpy, NULL, "test", "Test"); xim_im = XOpenIM(dpy, NULL, "test", "Test");
XGetIMValues (xim_im, XNQueryInputStyle, &xim_styles, NULL, NULL); XGetIMValues(xim_im, XNQueryInputStyle, &xim_styles, NULL, NULL);
for (i = 0, style = xim_styles->supported_styles; for (i = 0, style = xim_styles->supported_styles;
i < xim_styles->count_styles; i++, style++) i < xim_styles->count_styles; i++, style++) {
{
if (*style == (XIMStatusNone|XIMPreeditNone)) { if (*style == (XIMStatusNone|XIMPreeditNone)) {
printf("this is not a XIM server !!!\n"); printf("this is not a XIM server !!!\n");
no_xim = 1; no_xim = 1;
@ -157,10 +157,10 @@ int main(int argc, char**argv)
NULL); NULL);
XSetICFocus(xim_ic); XSetICFocus(xim_ic);
/***************************************************************/ /***************************************************************
/** I don't recommand to use a font base name list similar * I don't recommend to use a font base name list similar
* to the following one in a real application ;-) */ * to the following one in a real application ;-)
/***************************************************************/ ***************************************************************/
fontset = XCreateFontSet(dpy, fontset = XCreateFontSet(dpy,
"-*-*-*-*-*-*-*-*-*-*-*-*-iso8858-3," /* not valid */ "-*-*-*-*-*-*-*-*-*-*-*-*-iso8858-3," /* not valid */
"-*-*-medium-r-*-*-*-*-*-*-*-*-iso8859-1," "-*-*-medium-r-*-*-*-*-*-*-*-*-iso8859-1,"
@ -184,7 +184,6 @@ int main(int argc, char**argv)
gc = XCreateGC(dpy, w, mask, &xgcv); gc = XCreateGC(dpy, w, mask, &xgcv);
/***************************************************************/ /***************************************************************/
while (1) { while (1) {
int filtered; int filtered;
@ -202,18 +201,10 @@ int main(int argc, char**argv)
if (xevent.type == FocusIn) XSetICFocus(xim_ic); if (xevent.type == FocusIn) XSetICFocus(xim_ic);
if (xevent.type == KeyPress && !filtered) { if (xevent.type == KeyPress && !filtered) {
len = Xutf8LookupString(xim_ic, &xevent.xkey, len = Xutf8LookupString(xim_ic, &xevent.xkey, buf, 127, &keysym, &status);
buf, 127, &keysym, &status); Xutf8DrawImageString(dpy, w, fontset, gc, x, y, buf, len);
Xutf8DrawString(dpy, w, fontset, gc, 0, 20, jp_txt, strlen(jp_txt));
Xutf8DrawImageString(dpy, w, fontset, gc, Xutf8DrawString(dpy, w, fontset, gc, 50, 90, rtl_txt, strlen(rtl_txt));
x, y, buf, len);
Xutf8DrawString(dpy, w, fontset, gc, 0, 20,
jp_txt, strlen(jp_txt));
Xutf8DrawString(dpy, w, fontset, gc, 50, 90,
rtl_txt, strlen(rtl_txt));
buf[len] = 0; buf[len] = 0;
printf("'%s' %d\n", buf, keysym); printf("'%s' %d\n", buf, keysym);
buf[0] = 0; buf[0] = 0;

9
src/xutf8/ucs2fontmap.c
Unescape View File

@ -62,10 +62,10 @@ typedef struct {
#include "headers/symbol_.h" #include "headers/symbol_.h"
#include "headers/dingbats_.h" #include "headers/dingbats_.h"
/*************** conv_gen.c ************/ /*************** conv_gen.c ************/
/*const*/ /*const*/
int ucs2fontmap(char *s, unsigned int ucs, int enc) int ucs2fontmap(char *s, unsigned int ucs, int enc) {
{
switch(enc) { switch(enc) {
case 0: /* iso10646-1 */ case 0: /* iso10646-1 */
s[0] = (char) ((ucs & 0xFF00) >> 8); s[0] = (char) ((ucs & 0xFF00) >> 8);
@ -302,8 +302,7 @@ int ucs2fontmap(char *s, unsigned int ucs, int enc)
}; };
/*const*/ /*const*/
int encoding_number(const char *enc) int encoding_number(const char *enc) {
{
if (!enc || !strncmp(enc, "iso10646-1", 10)) { if (!enc || !strncmp(enc, "iso10646-1", 10)) {
return 0; return 0;
} else if (!strcmp(enc, "iso8859-1")) { } else if (!strcmp(enc, "iso8859-1")) {

63
src/xutf8/utf8Input.c
Unescape View File

@ -60,10 +60,7 @@ typedef struct {
#include "lcUniConv/ksc5601.h" #include "lcUniConv/ksc5601.h"
int int
XConvertEucTwToUtf8( XConvertEucTwToUtf8(char* buffer_return, int len) {
char* buffer_return,
int len)
{
/* FIXME */ /* FIXME */
#if HAVE_LIBC_ICONV #if HAVE_LIBC_ICONV
iconv_t cd; iconv_t cd;
@ -105,9 +102,7 @@ XConvertEucTwToUtf8(
b[0] = (unsigned char) buf[i + 2] - 0x80; b[0] = (unsigned char) buf[i + 2] - 0x80;
b[1] = (unsigned char) buf[i + 3] - 0x80; b[1] = (unsigned char) buf[i + 3] - 0x80;
if (c1 >= 0xa1 && c1 <= 0xb0) { if (c1 >= 0xa1 && c1 <= 0xb0) {
if (c2 >= 0xa1 && c2 < 0xff && c3 >= 0xa1 && if (c2 >= 0xa1 && c2 < 0xff && c3 >= 0xa1 && c3 < 0xff) {
c3 < 0xff)
{
ucs = ' '; i += 4; ucs = ' '; i += 4;
} else { } else {
ucs = '?'; i++; ucs = '?'; i++;
@ -127,10 +122,7 @@ XConvertEucTwToUtf8(
} }
int int
XConvertEucKrToUtf8( XConvertEucKrToUtf8(char* buffer_return, int len) {
char* buffer_return,
int len)
{
int i = 0, l = 0; int i = 0, l = 0;
char *buf; char *buf;
@ -170,10 +162,7 @@ XConvertEucKrToUtf8(
} }
int int
XConvertBig5ToUtf8( XConvertBig5ToUtf8(char* buffer_return, int len) {
char* buffer_return,
int len)
{
int i = 0, l = 0; int i = 0, l = 0;
char *buf; char *buf;
@ -202,10 +191,7 @@ XConvertBig5ToUtf8(
} }
int int
XConvertGb2312ToUtf8( XConvertGb2312ToUtf8(char* buffer_return, int len) {
char* buffer_return,
int len)
{
int i = 0, l = 0; int i = 0, l = 0;
char *buf; char *buf;
@ -234,10 +220,7 @@ XConvertGb2312ToUtf8(
} }
int int
XConvertEucCnToUtf8( XConvertEucCnToUtf8(char* buffer_return, int len) {
char* buffer_return,
int len)
{
int i = 0, l = 0; int i = 0, l = 0;
char *buf; char *buf;
@ -276,10 +259,7 @@ XConvertEucCnToUtf8(
} }
int int
XConvertEucJpToUtf8( XConvertEucJpToUtf8(char* buffer_return, int len) {
char* buffer_return,
int len)
{
int i = 0, l = 0; int i = 0, l = 0;
char *buf; char *buf;
@ -327,9 +307,7 @@ XConvertEucJpToUtf8(
unsigned char b[2]; unsigned char b[2];
b[0] = c - 0x80; b[0] = c - 0x80;
b[1] = c1 - 0x80; b[1] = c1 - 0x80;
if (jisx0212_mbtowc(NULL, &ucs, b, 2) if (jisx0212_mbtowc(NULL, &ucs, b, 2) < 1) {
< 1)
{
ucs = '?'; ucs = '?';
} }
} else { } else {
@ -337,8 +315,7 @@ XConvertEucJpToUtf8(
} }
} else { } else {
if (c1 >= 0xa1 && c1 < 0xff) { if (c1 >= 0xa1 && c1 < 0xff) {
ucs = 0xe3ac + 94 * (c - 0xF5) + ucs = 0xe3ac + 94 * (c - 0xF5) + (c1 - 0xA1);
(c1 - 0xA1);
} else { } else {
ucs = '?'; ucs = '?';
} }
@ -355,12 +332,11 @@ XConvertEucJpToUtf8(
} }
int int
XConvertEucToUtf8( XConvertEucToUtf8(const char* locale,
const char* locale,
char* buffer_return, char* buffer_return,
int len, int len,
int bytes_buffer) int bytes_buffer) {
{
if (!locale/* || strstr(locale, "UTF") || strstr(locale, "utf")*/) { if (!locale/* || strstr(locale, "UTF") || strstr(locale, "utf")*/) {
return len; return len;
} }
@ -371,9 +347,7 @@ XConvertEucToUtf8(
return XConvertBig5ToUtf8(buffer_return, len); return XConvertBig5ToUtf8(buffer_return, len);
} else if (strstr(locale, "zh") || strstr(locale, "chinese-")) { } else if (strstr(locale, "zh") || strstr(locale, "chinese-")) {
if (strstr(locale, "TW") || strstr(locale, "chinese-t")) { if (strstr(locale, "TW") || strstr(locale, "chinese-t")) {
if (strstr(locale, "EUC") || strstr(locale, "euc") || if (strstr(locale, "EUC") || strstr(locale, "euc") || strstr(locale, "chinese-t")) {
strstr(locale, "chinese-t"))
{
return XConvertEucTwToUtf8(buffer_return, len); return XConvertEucTwToUtf8(buffer_return, len);
} }
return XConvertBig5ToUtf8(buffer_return, len); return XConvertBig5ToUtf8(buffer_return, len);
@ -388,16 +362,14 @@ XConvertEucToUtf8(
return len; return len;
} }
int int
XUtf8LookupString( XUtf8LookupString(XIC ic,
XIC ic,
XKeyPressedEvent* event, XKeyPressedEvent* event,
char* buffer_return, char* buffer_return,
int bytes_buffer, int bytes_buffer,
KeySym* keysym, KeySym* keysym,
Status* status_return) Status* status_return) {
{
long ucs = -1; long ucs = -1;
int len; int len;
len = XmbLookupString(ic, event, buffer_return, bytes_buffer / 5, len = XmbLookupString(ic, event, buffer_return, bytes_buffer / 5,
@ -426,8 +398,7 @@ XUtf8LookupString(
if (!ic) return 0; if (!ic) return 0;
im = XIMOfIC(ic); im = XIMOfIC(ic);
if (!im) return 0; if (!im) return 0;
len = XConvertEucToUtf8(XLocaleOfIM(im), len = XConvertEucToUtf8(XLocaleOfIM(im), buffer_return, len, bytes_buffer);
buffer_return, len, bytes_buffer);
} }
return len; return len;
} }

47
src/xutf8/utf8Utils.c
Unescape View File

@ -39,11 +39,10 @@
* Returns -1 if the UTF-8 string is not valid * Returns -1 if the UTF-8 string is not valid
*/ */
int int
XConvertUtf8ToUcs( XConvertUtf8ToUcs(const unsigned char *buf,
const unsigned char *buf,
int len, int len,
unsigned int *ucs) unsigned int *ucs) {
{
if (buf[0] & 0x80) { if (buf[0] & 0x80) {
if (buf[0] & 0x40) { if (buf[0] & 0x40) {
if (buf[0] & 0x20) { if (buf[0] & 0x20) {
@ -59,8 +58,7 @@ XConvertUtf8ToUcs(
&& (buf[1] & 0xC0) == 0x80 && (buf[1] & 0xC0) == 0x80
&& (buf[2] & 0xC0) == 0x80 && (buf[2] & 0xC0) == 0x80
&& (buf[3] & 0xC0) == 0x80 && (buf[3] & 0xC0) == 0x80
&& (buf[4] & 0xC0) == 0x80) && (buf[4] & 0xC0) == 0x80) {
{
/* 0x00200000 - 0x03FFFFFF */ /* 0x00200000 - 0x03FFFFFF */
*ucs = ((buf[0] & ~0xF8) << 24) + *ucs = ((buf[0] & ~0xF8) << 24) +
((buf[1] & ~0x80) << 18) + ((buf[1] & ~0x80) << 18) +
@ -72,8 +70,7 @@ XConvertUtf8ToUcs(
} else if (len > 3 } else if (len > 3
&& (buf[1] & 0xC0) == 0x80 && (buf[1] & 0xC0) == 0x80
&& (buf[2] & 0xC0) == 0x80 && (buf[2] & 0xC0) == 0x80
&& (buf[3] & 0xC0) == 0x80) && (buf[3] & 0xC0) == 0x80) {
{
/* 0x00010000 - 0x001FFFFF */ /* 0x00010000 - 0x001FFFFF */
*ucs = ((buf[0] & ~0xF0) << 18) + *ucs = ((buf[0] & ~0xF0) << 18) +
((buf[1] & ~0x80) << 12) + ((buf[1] & ~0x80) << 12) +
@ -81,10 +78,9 @@ XConvertUtf8ToUcs(
(buf[3] & ~0x80); (buf[3] & ~0x80);
if (*ucs > 0x0000FFFF) return 4; if (*ucs > 0x0000FFFF) return 4;
} }
} else if (len > 2 && } else if (len > 2
(buf[1] & 0xC0) == 0x80 && && (buf[1] & 0xC0) == 0x80
(buf[2] & 0xC0) == 0x80) && (buf[2] & 0xC0) == 0x80) {
{
/* 0x00000800 - 0x0000FFFF */ /* 0x00000800 - 0x0000FFFF */
*ucs = ((buf[0] & ~0xE0) << 12) + *ucs = ((buf[0] & ~0xE0) << 12) +
((buf[1] & ~0x80) << 6) + ((buf[1] & ~0x80) << 6) +
@ -113,10 +109,9 @@ XConvertUtf8ToUcs(
* NOTE : the buffer (buf) must be at least 5 bytes long !!! * NOTE : the buffer (buf) must be at least 5 bytes long !!!
*/ */
int int
XConvertUcsToUtf8( XConvertUcsToUtf8(unsigned int ucs,
unsigned int ucs, char *buf) {
char *buf)
{
if (ucs < 0x000080) { if (ucs < 0x000080) {
buf[0] = ucs; buf[0] = ucs;
return 1; return 1;
@ -152,10 +147,8 @@ XConvertUcsToUtf8(
* (returns -1 if not valid) * (returns -1 if not valid)
*/ */
int int
XUtf8CharByteLen( XUtf8CharByteLen(const unsigned char *buf,
const unsigned char *buf, int len) {
int len)
{
unsigned int ucs; unsigned int ucs;
return XConvertUtf8ToUcs(buf, len, &ucs); return XConvertUtf8ToUcs(buf, len, &ucs);
} }
@ -164,10 +157,9 @@ XUtf8CharByteLen(
* returns the quantity of Unicode chars in the UTF-8 string * returns the quantity of Unicode chars in the UTF-8 string
*/ */
int int
XCountUtf8Char( XCountUtf8Char(const unsigned char *buf,
const unsigned char *buf, int len) {
int len)
{
int i = 0; int i = 0;
int nbc = 0; int nbc = 0;
while (i < len) { while (i < len) {
@ -183,11 +175,10 @@ XCountUtf8Char(
* Same as XConvertUtf8ToUcs but no sanity check is done. * Same as XConvertUtf8ToUcs but no sanity check is done.
*/ */
int int
XFastConvertUtf8ToUcs( XFastConvertUtf8ToUcs(const unsigned char *buf,
const unsigned char *buf,
int len, int len,
unsigned int *ucs) unsigned int *ucs) {
{
if (buf[0] & 0x80) { if (buf[0] & 0x80) {
if (buf[0] & 0x40) { if (buf[0] & 0x40) {
if (buf[0] & 0x20) { if (buf[0] & 0x20) {

193
src/xutf8/utf8Wrap.c
Unescape View File

@ -49,8 +49,7 @@
static int static int
get_font_list( get_font_list(
const char *base_font_name_list, const char *base_font_name_list,
char ***flist) char ***flist) {
{
const char *ptr; const char *ptr;
const char *p; const char *p;
int nb; int nb;
@ -95,9 +94,7 @@ get_font_list(
/** (mainly used for adobe-symbol and adobe-zapfdingbats) **/ /** (mainly used for adobe-symbol and adobe-zapfdingbats) **/
/*********************************************************************/ /*********************************************************************/
static int static int
font_spec_enc( font_spec_enc(char *font) {
char *font)
{
int ret; int ret;
char *enc; char *enc;
char *end; char *end;
@ -122,11 +119,10 @@ font_spec_enc(
/** get the sub range of a iso10646-1 font **/ /** get the sub range of a iso10646-1 font **/
/*********************************************************************/ /*********************************************************************/
static void static void
get_range( get_range(const char *enc,
const char *enc,
int *min, int *min,
int *max) int *max) {
{
const char *ptr = enc; const char *ptr = enc;
const char *ptr1; const char *ptr1;
@ -153,11 +149,10 @@ get_range(
/** get the internal encoding number of each fonts **/ /** get the internal encoding number of each fonts **/
/*********************************************************************/ /*********************************************************************/
static int * static int *
get_encodings( get_encodings(char **font_name_list,
char **font_name_list,
int *ranges, int *ranges,
int nb_font) int nb_font) {
{
int *font_encoding_list; int *font_encoding_list;
int i; int i;
i = 0; i = 0;
@ -180,8 +175,7 @@ get_encodings(
if (*ptr == '-') { if (*ptr == '-') {
ec++; ec++;
if (ec == 13) { if (ec == 13) {
font_encoding_list[i] = font_encoding_list[i] = encoding_number(ptr + 1);
encoding_number(ptr + 1);
if (font_encoding_list[i] == 0) { if (font_encoding_list[i] == 0) {
get_range(ptr + 1, get_range(ptr + 1,
ranges + i * 2, ranges + i * 2,
@ -202,10 +196,9 @@ get_encodings(
/** find the first font which matches the name and load it. **/ /** find the first font which matches the name and load it. **/
/*********************************************************************/ /*********************************************************************/
XFontStruct * XFontStruct *
find_best_font( find_best_font(Display *dpy,
Display *dpy, char **name) {
char **name)
{
char **list; char **list;
int cnt; int cnt;
XFontStruct *s; XFontStruct *s;
@ -225,21 +218,20 @@ find_best_font(
/** load all fonts **/ /** load all fonts **/
/*********************************************************************/ /*********************************************************************/
static void static void
load_fonts( load_fonts(Display *dpy,
Display *dpy, XUtf8FontStruct *font_set) {
XUtf8FontStruct *font_set)
{
int i; int i;
char **list; char **list;
i = 0; i = 0;
list = NULL; list = NULL;
font_set->fonts = (XFontStruct**) font_set->fonts = (XFontStruct**) malloc(sizeof(XFontStruct*) *
malloc(sizeof(XFontStruct*) * font_set->nb_font); font_set->nb_font);
font_set->ranges = (int*) font_set->ranges = (int*) malloc(sizeof(int) *
malloc(sizeof(int) * font_set->nb_font * 2); font_set->nb_font * 2);
font_set->descent = 0; font_set->descent = 0;
font_set->ascent = 0; font_set->ascent = 0;
@ -280,8 +272,7 @@ load_fonts(
font_set->ranges[2*j] == font_set->ranges[2*j] ==
font_set->ranges[2*i] && font_set->ranges[2*i] &&
font_set->ranges[(2*j)+1] && font_set->ranges[(2*j)+1] &&
font_set->ranges[(2*i)+1]) font_set->ranges[(2*i)+1]) {
{
XFreeFont(dpy, font_set->fonts[i]); XFreeFont(dpy, font_set->fonts[i]);
free(font_set->font_name_list[i]); free(font_set->font_name_list[i]);
font_set->font_name_list[i] = NULL; font_set->font_name_list[i] = NULL;
@ -297,14 +288,12 @@ load_fonts(
/** list of fonts. XLoad all fonts. **/ /** list of fonts. XLoad all fonts. **/
/*********************************************************************/ /*********************************************************************/
XUtf8FontStruct * XUtf8FontStruct *
XCreateUtf8FontStruct ( XCreateUtf8FontStruct(Display *dpy,
Display *dpy, const char *base_font_name_list) {
const char *base_font_name_list)
{
XUtf8FontStruct *font_set; XUtf8FontStruct *font_set;
font_set = (XUtf8FontStruct*) font_set = (XUtf8FontStruct*)malloc(sizeof(XUtf8FontStruct));
malloc(sizeof(XUtf8FontStruct));
if (!font_set) { if (!font_set) {
return NULL; return NULL;
@ -328,16 +317,15 @@ XCreateUtf8FontStruct (
/** draw a Right To Left UTF-8 string using multiple fonts as needed. **/ /** draw a Right To Left UTF-8 string using multiple fonts as needed. **/
/*****************************************************************************/ /*****************************************************************************/
void void
XUtf8DrawRtlString( XUtf8DrawRtlString(Display *display,
Display *display,
Drawable d, Drawable d,
XUtf8FontStruct *font_set, XUtf8FontStruct *font_set,
GC gc, GC gc,
int x, int x,
int y, int y,
const char *string, const char *string,
int num_bytes) int num_bytes) {
{
int *encodings; /* encodings array */ int *encodings; /* encodings array */
XFontStruct **fonts; /* fonts array */ XFontStruct **fonts; /* fonts array */
XChar2b buf[128]; /* drawing buffer */ XChar2b buf[128]; /* drawing buffer */
@ -376,8 +364,7 @@ XUtf8DrawRtlString(
while (num_bytes > 0) { while (num_bytes > 0) {
int ulen; /* byte length of the UTF-8 char */ int ulen; /* byte length of the UTF-8 char */
unsigned int ucs; /* Unicode value of the UTF-8 char */ unsigned int ucs; /* Unicode value of the UTF-8 char */
unsigned int no_spc; /* Spacing char equivalent of a unsigned int no_spc; /* Spacing char equivalent of a non-spacing char */
non-spacing char */
if (i > 120) { if (i > 120) {
/*** draw the buffer **/ /*** draw the buffer **/
@ -388,8 +375,7 @@ XUtf8DrawRtlString(
ptr = buf + 128; ptr = buf + 128;
} }
ulen = XFastConvertUtf8ToUcs((unsigned char*)string, ulen = XFastConvertUtf8ToUcs((unsigned char*)string, num_bytes, &ucs);
num_bytes, &ucs);
if (ulen < 1) ulen = 1; if (ulen < 1) ulen = 1;
@ -402,21 +388,18 @@ XUtf8DrawRtlString(
*/ */
fnum = first; fnum = first;
while (fnum < nb_font) { while (fnum < nb_font) {
if (fonts[fnum] && if (fonts[fnum] && ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) {
ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0)
{
if (encodings[fnum] != 0 || if (encodings[fnum] != 0 ||
(ucs >= ranges[fnum * 2] && (ucs >= ranges[fnum * 2] && ucs <= ranges[fnum * 2 + 1])) {
ucs <= ranges[fnum * 2 + 1]))
{
break; break;
} }
} }
fnum++; fnum++;
} }
if (fnum == nb_font) { if (fnum == nb_font) {
/** the char is not valid in all encodings -> /* the char is not valid in all encodings ->
* draw it using the first font :-( **/ * draw it using the first font :-(
*/
fnum = first; fnum = first;
ucs2fontmap(glyph, '?', encodings[fnum]); ucs2fontmap(glyph, '?', encodings[fnum]);
} }
@ -455,16 +438,15 @@ XUtf8DrawRtlString(
/** draw an UTF-8 string using multiple fonts as needed. **/ /** draw an UTF-8 string using multiple fonts as needed. **/
/*****************************************************************************/ /*****************************************************************************/
void void
XUtf8DrawString( XUtf8DrawString(Display *display,
Display *display,
Drawable d, Drawable d,
XUtf8FontStruct *font_set, XUtf8FontStruct *font_set,
GC gc, GC gc,
int x, int x,
int y, int y,
const char *string, const char *string,
int num_bytes) int num_bytes) {
{
int *encodings; /* encodings array */ int *encodings; /* encodings array */
XFontStruct **fonts; /* fonts array */ XFontStruct **fonts; /* fonts array */
XChar2b buf[128]; /* drawing buffer */ XChar2b buf[128]; /* drawing buffer */
@ -500,8 +482,7 @@ XUtf8DrawString(
while (num_bytes > 0) { while (num_bytes > 0) {
int ulen; /* byte length of the UTF-8 char */ int ulen; /* byte length of the UTF-8 char */
unsigned int ucs; /* Unicode value of the UTF-8 char */ unsigned int ucs; /* Unicode value of the UTF-8 char */
unsigned int no_spc; /* Spacing char equivalent of a unsigned int no_spc; /* Spacing char equivalent of a non-spacing char */
non-spacing char */
if (i > 120) { if (i > 120) {
/*** draw the buffer **/ /*** draw the buffer **/
@ -511,8 +492,7 @@ XUtf8DrawString(
i = 0; i = 0;
} }
ulen = XFastConvertUtf8ToUcs((unsigned char*)string, ulen = XFastConvertUtf8ToUcs((unsigned char*)string, num_bytes, &ucs);
num_bytes, &ucs);
if (ulen < 1) ulen = 1; if (ulen < 1) ulen = 1;
@ -525,21 +505,19 @@ XUtf8DrawString(
*/ */
fnum = first; fnum = first;
while (fnum < nb_font) { while (fnum < nb_font) {
if (fonts[fnum] && if (fonts[fnum] && ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) {
ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0)
{
if (encodings[fnum] != 0 || if (encodings[fnum] != 0 ||
(ucs >= ranges[fnum * 2] && (ucs >= ranges[fnum * 2] &&
ucs <= ranges[fnum * 2 + 1])) ucs <= ranges[fnum * 2 + 1])) {
{
break; break;
} }
} }
fnum++; fnum++;
} }
if (fnum == nb_font) { if (fnum == nb_font) {
/** the char is not valid in all encodings -> /* the char is not valid in all encodings ->
* draw it using the first font :-( **/ * draw it using the first font :-(
*/
fnum = first; fnum = first;
ucs2fontmap(glyph, '?', encodings[fnum]); ucs2fontmap(glyph, '?', encodings[fnum]);
} }
@ -574,11 +552,10 @@ XUtf8DrawString(
/** returns the pixel width of a UTF-8 string **/ /** returns the pixel width of a UTF-8 string **/
/*****************************************************************************/ /*****************************************************************************/
int int
XUtf8TextWidth( XUtf8TextWidth(XUtf8FontStruct *font_set,
XUtf8FontStruct *font_set,
const char *string, const char *string,
int num_bytes) int num_bytes) {
{
int x; int x;
int *encodings; /* encodings array */ int *encodings; /* encodings array */
XFontStruct **fonts; /* fonts array */ XFontStruct **fonts; /* fonts array */
@ -617,8 +594,7 @@ XUtf8TextWidth(
while (num_bytes > 0) { while (num_bytes > 0) {
int ulen; /* byte length of the UTF-8 char */ int ulen; /* byte length of the UTF-8 char */
unsigned int ucs; /* Unicode value of the UTF-8 char */ unsigned int ucs; /* Unicode value of the UTF-8 char */
unsigned int no_spc; /* Spacing char equivalent of a unsigned int no_spc; /* Spacing char equivalent of a non-spacing char */
non-spacing char */
if (i > 120) { if (i > 120) {
/*** measure the buffer **/ /*** measure the buffer **/
@ -626,8 +602,7 @@ XUtf8TextWidth(
i = 0; i = 0;
} }
ulen = XFastConvertUtf8ToUcs((unsigned char*)string, ulen = XFastConvertUtf8ToUcs((unsigned char*)string, num_bytes, &ucs);
num_bytes, &ucs);
if (ulen < 1) ulen = 1; if (ulen < 1) ulen = 1;
@ -642,21 +617,19 @@ XUtf8TextWidth(
*/ */
fnum = first; fnum = first;
while (fnum < nb_font) { while (fnum < nb_font) {
if (fonts[fnum] && if (fonts[fnum] && ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) {
ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0)
{
if (encodings[fnum] != 0 || if (encodings[fnum] != 0 ||
(ucs >= ranges[fnum * 2] && (ucs >= ranges[fnum * 2] &&
ucs <= ranges[fnum * 2 + 1])) ucs <= ranges[fnum * 2 + 1])) {
{
break; break;
} }
} }
fnum++; fnum++;
} }
if (fnum == nb_font) { if (fnum == nb_font) {
/** the char is not valid in all encodings -> /* the char is not valid in all encodings ->
* draw it using the first font :-( **/ * draw it using the first font :-(
*/
fnum = first; fnum = first;
ucs2fontmap(glyph, '?', encodings[fnum]); ucs2fontmap(glyph, '?', encodings[fnum]);
} }
@ -667,8 +640,7 @@ XUtf8TextWidth(
(*buf).byte1 = glyph[0]; (*buf).byte1 = glyph[0];
(*buf).byte2 = glyph[1]; (*buf).byte2 = glyph[1];
if (no_spc) { if (no_spc) {
/* go back to draw the non-spacing char over /* go back to draw the non-spacing char over the previous char */
* the previous char */
x -= XTextWidth16(fonts[fnum], buf, 1); x -= XTextWidth16(fonts[fnum], buf, 1);
} }
} else { } else {
@ -690,12 +662,11 @@ XUtf8TextWidth(
/** get the X font and glyph ID of a UCS char **/ /** get the X font and glyph ID of a UCS char **/
/*****************************************************************************/ /*****************************************************************************/
int int
XGetUtf8FontAndGlyph( XGetUtf8FontAndGlyph(XUtf8FontStruct *font_set,
XUtf8FontStruct *font_set,
unsigned int ucs, unsigned int ucs,
XFontStruct **fnt, XFontStruct **fnt,
unsigned short *id) unsigned short *id) {
{
int x; int x;
int *encodings; /* encodings array */ int *encodings; /* encodings array */
XFontStruct **fonts; /* fonts array */ XFontStruct **fonts; /* fonts array */
@ -736,20 +707,19 @@ XGetUtf8FontAndGlyph(
*/ */
fnum = first; fnum = first;
while (fnum < nb_font) { while (fnum < nb_font) {
if (fonts[fnum] && if (fonts[fnum] && ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) {
ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) if (encodings[fnum] != 0 ||
{ (ucs >= ranges[fnum * 2] &&
if (encodings[fnum] != 0 || (ucs >= ranges[fnum * 2] && ucs <= ranges[fnum * 2 + 1])) {
ucs <= ranges[fnum * 2 + 1]))
{
break; break;
} }
} }
fnum++; fnum++;
} }
if (fnum == nb_font) { if (fnum == nb_font) {
/** the char is not valid in all encodings -> /* the char is not valid in all encodings ->
* draw it using the first font :-( **/ * draw it using the first font :-(
*/
fnum = first; fnum = first;
ucs2fontmap(glyph, '?', encodings[fnum]); ucs2fontmap(glyph, '?', encodings[fnum]);
} }
@ -763,10 +733,9 @@ XGetUtf8FontAndGlyph(
/** returns the pixel width of a UCS char **/ /** returns the pixel width of a UCS char **/
/*****************************************************************************/ /*****************************************************************************/
int int
XUtf8UcsWidth( XUtf8UcsWidth(XUtf8FontStruct *font_set,
XUtf8FontStruct *font_set, unsigned int ucs) {
unsigned int ucs)
{
int x; int x;
int *encodings; /* encodings array */ int *encodings; /* encodings array */
XFontStruct **fonts; /* fonts array */ XFontStruct **fonts; /* fonts array */
@ -802,7 +771,6 @@ XUtf8UcsWidth(
first = fnum; first = fnum;
last_fnum = fnum; last_fnum = fnum;
ucs = XUtf8IsNonSpacing(ucs); ucs = XUtf8IsNonSpacing(ucs);
/* /*
@ -812,19 +780,18 @@ XUtf8UcsWidth(
fnum = first; fnum = first;
while (fnum < nb_font) { while (fnum < nb_font) {
if (fonts[fnum] && if (fonts[fnum] &&
ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) ucs2fontmap(glyph, ucs, encodings[fnum]) >= 0) {
{
if (encodings[fnum] != 0 || (ucs >= ranges[fnum * 2] && if (encodings[fnum] != 0 || (ucs >= ranges[fnum * 2] &&
ucs <= ranges[fnum * 2 + 1])) ucs <= ranges[fnum * 2 + 1])) {
{
break; break;
} }
} }
fnum++; fnum++;
} }
if (fnum == nb_font) { if (fnum == nb_font) {
/** the char is not valid in all encodings -> /* the char is not valid in all encodings ->
* draw it using the first font :-( **/ * draw it using the first font :-(
*/
fnum = first; fnum = first;
ucs2fontmap(glyph, '?', encodings[fnum]); ucs2fontmap(glyph, '?', encodings[fnum]);
} }
@ -841,16 +808,15 @@ XUtf8UcsWidth(
/** draw an UTF-8 string and clear the background. **/ /** draw an UTF-8 string and clear the background. **/
/*****************************************************************************/ /*****************************************************************************/
void void
XUtf8DrawImageString( XUtf8DrawImageString(Display *display,
Display *display,
Drawable d, Drawable d,
XUtf8FontStruct *font_set, XUtf8FontStruct *font_set,
GC gc, GC gc,
int x, int x,
int y, int y,
const char *string, const char *string,
int num_bytes) int num_bytes) {
{
/* FIXME: must be improved ! */ /* FIXME: must be improved ! */
int w; int w;
int fill_style; int fill_style;
@ -895,10 +861,9 @@ XUtf8DrawImageString(
/** free the XFontSet and others things created by XCreateUtf8FontSet **/ /** free the XFontSet and others things created by XCreateUtf8FontSet **/
/*****************************************************************************/ /*****************************************************************************/
void void
XFreeUtf8FontStruct( XFreeUtf8FontStruct(Display *dpy,
Display *dpy, XUtf8FontStruct *font_set) {
XUtf8FontStruct *font_set)
{
int i; int i;
i = 0; i = 0;
while (i < font_set->nb_font) { while (i < font_set->nb_font) {

10
src/xutf8/utils/conv_gen.c
Unescape View File

@ -30,8 +30,7 @@
#include <stdio.h> #include <stdio.h>
char buffer[1000000]; char buffer[1000000];
int main(int argc, char **argv) int main(int argc, char **argv) {
{
char buf[80]; char buf[80];
int len; int len;
char *encode[256]; char *encode[256];
@ -87,12 +86,10 @@ int main(int argc, char **argv)
printf(" int i = (ucs - 0x%s) * 2;\n", f); printf(" int i = (ucs - 0x%s) * 2;\n", f);
printf(" s[0] = %s_%s[i++];\n", ptr, f, f); printf(" s[0] = %s_%s[i++];\n", ptr, f, f);
printf(" s[1] = %s_%s[i];\n", ptr, f, f); printf(" s[1] = %s_%s[i];\n", ptr, f, f);
printf(" if (s[0] || s[1]) return %d;\n", printf(" if (s[0] || s[1]) return %d;\n", encode_number);
encode_number);
} else { } else {
printf(" s[0] = 0;\n"); printf(" s[0] = 0;\n");
printf(" s[1] = %s_%s[ucs - 0x%s];\n", printf(" s[1] = %s_%s[ucs - 0x%s];\n", ptr, f, f);
ptr, f, f);
printf(" if (s[1]) return %d;\n", encode_number); printf(" if (s[1]) return %d;\n", encode_number);
} }
printf(" }\n"); printf(" }\n");
@ -156,7 +153,6 @@ int main(int argc, char **argv)
printf(" return -1;\n"); printf(" return -1;\n");
printf("};\n\n"); printf("};\n\n");
printf("/*\n"); printf("/*\n");
printf("const char *encoding_name(int num)\n{\n"); printf("const char *encoding_name(int num)\n{\n");
printf(" switch (num) {\n"); printf(" switch (num) {\n");

22
src/xutf8/utils/convert_map.c
Unescape View File

@ -33,8 +33,7 @@
char buffer[1000000]; char buffer[1000000];
int JIS0208(unsigned char * ptr) int JIS0208(unsigned char * ptr) {
{
int i = 0; int i = 0;
unsigned int fmap; unsigned int fmap;
unsigned int ucs; unsigned int ucs;
@ -44,7 +43,8 @@ int JIS0208(unsigned char * ptr)
while(*ptr != '\0') { ptr++; i++; } while(*ptr != '\0') { ptr++; i++; }
i++; ptr++; *(ptr+6) = '\0'; i++; ptr++; *(ptr+6) = '\0';
ucs = (unsigned int)strtoul(ptr, NULL, 16); ucs = (unsigned int)strtoul(ptr, NULL, 16);
if (ucs) printf("/* U+%04X */ 0x%02X, 0x%02X,\n", ucs, if (ucs)
printf("/* U+%04X */ 0x%02X, 0x%02X,\n", ucs,
(fmap & 0xFF00) >> 8, fmap & 0xFF); (fmap & 0xFF00) >> 8, fmap & 0xFF);
while(*ptr != '\0') { ptr++; i++; } while(*ptr != '\0') { ptr++; i++; }
i++; ptr++; i++; ptr++;
@ -53,8 +53,7 @@ int JIS0208(unsigned char * ptr)
return i; return i;
} }
int JIS0201(unsigned char * ptr) int JIS0201(unsigned char * ptr) {
{
int i = 0; int i = 0;
unsigned int fmap; unsigned int fmap;
unsigned int ucs; unsigned int ucs;
@ -75,8 +74,7 @@ int JIS0201(unsigned char * ptr)
return i; return i;
} }
int ADOBE(unsigned char * ptr) int ADOBE(unsigned char * ptr) {
{
int i = 0; int i = 0;
unsigned int fmap; unsigned int fmap;
unsigned int ucs; unsigned int ucs;
@ -98,8 +96,7 @@ int ADOBE(unsigned char * ptr)
} }
int JIS0212(unsigned char * ptr) int JIS0212(unsigned char * ptr) {
{
int i = 0; int i = 0;
unsigned int fmap; unsigned int fmap;
unsigned int ucs; unsigned int ucs;
@ -115,7 +112,8 @@ int JIS0212(unsigned char * ptr)
printf("/* EOF */\n"); printf("/* EOF */\n");
abort(); abort();
} }
if (ucs) printf("/* U+%04X */ 0x%02X, 0x%02X,\n", ucs, if (ucs)
printf("/* U+%04X */ 0x%02X, 0x%02X,\n", ucs,
(fmap & 0xFF00) >> 8, fmap & 0xFF); (fmap & 0xFF00) >> 8, fmap & 0xFF);
while(*ptr != '\0') { ptr++; i++; } while(*ptr != '\0') { ptr++; i++; }
i++; ptr++; i++; ptr++;
@ -124,8 +122,7 @@ int JIS0212(unsigned char * ptr)
return i; return i;
} }
int main(int argc, char **argv) int main(int argc, char **argv) {
{
char buf[80]; char buf[80];
int len; int len;
int i; int i;
@ -146,7 +143,6 @@ int main(int argc, char **argv)
len--; len--;
} }
while (len > 0) { while (len > 0) {
nb = 0; nb = 0;
if (!strcmp("jisx0208.1983-0", argv[1])) { if (!strcmp("jisx0208.1983-0", argv[1])) {

47
src/xutf8/utils/create_table.c
Unescape View File

@ -1,3 +1,28 @@
/* "$Id: $"
*
* Author: Jean-Marc Lienher ( http://oksid.ch )
* Copyright 2000-2003 by O'ksi'D.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA.
*
* Please report all bugs and problems on the following page:
*
* http://www.fltk.org/str.php
*/
#include <wchar.h> #include <wchar.h>
#include <stdio.h> #include <stdio.h>
char buffer[1000000]; char buffer[1000000];
@ -5,8 +30,7 @@ char buffer[1000000];
/*** you can try to modifie this value to have better performences **/ /*** you can try to modifie this value to have better performences **/
#define MAX_DELTA 0x80 #define MAX_DELTA 0x80
int main(int argc, char **argv) int main(int argc, char **argv) {
{
char buf[80]; char buf[80];
int len; int len;
unsigned int i = 0; unsigned int i = 0;
@ -44,23 +68,18 @@ int main(int argc, char **argv)
if ((ucs - i) > MAX_DELTA || !i) { if ((ucs - i) > MAX_DELTA || !i) {
if (i) { if (i) {
printf("};\n"); printf("};\n");
fprintf(stderr, "\t/* end: U+%04X */\n", fprintf(stderr, "\t/* end: U+%04X */\n", i);
i);
} }
if (strcmp(argv[1], "spacing")) { if (strcmp(argv[1], "spacing")) {
printf("\nstatic const char" printf("\nstatic const char unicode_to_%s_%db_%04X[] = {\n",
" unicode_to_%s_%db_%04X[]" argv[1], nbb, ucs);
" = {\n", argv[1], nbb, ucs); fprintf(stderr, "unicode_to_%s_%db_%04X[]; ",
fprintf(stderr,
"unicode_to_%s_%db_%04X[]; ",
argv[1], nbb, ucs); argv[1], nbb, ucs);
} else { } else {
printf("\nstatic const unsigned short" printf("\nstatic const unsigned short"
" ucs_table_%04X[]" " ucs_table_%04X[]"
" = {\n", ucs); " = {\n", ucs);
fprintf(stderr, fprintf(stderr, "ucs_table_%04X[]; ", ucs);
"ucs_table_%04X[]; ",
ucs);
} }
} else { } else {
while (i < ucs - 1) { while (i < ucs - 1) {
@ -87,3 +106,7 @@ int main(int argc, char **argv)
fprintf(stderr, "\t/* end: U+%04X */\n", i); fprintf(stderr, "\t/* end: U+%04X */\n", i);
return 0; return 0;
} }
/*
* End of "$Id$".
*/

4
src/xutf8/utils/euc_tw.c
Unescape View File

@ -32,8 +32,7 @@
char uni[0x10000]; char uni[0x10000];
#include "../utf8Utils.c" #include "../utf8Utils.c"
int main(int argc, char **argv) int main(int argc, char **argv) {
{
iconv_t cd; iconv_t cd;
@ -58,7 +57,6 @@ int main(int argc, char **argv)
//XConvertUtf8ToUcs((unsigned char*)ob, 6 - l2, &ucs); //XConvertUtf8ToUcs((unsigned char*)ob, 6 - l2, &ucs);
printf ("%x --> %X\n", i, ucs & 0xFFFF); printf ("%x --> %X\n", i, ucs & 0xFFFF);
} }
} }
iconv_close(cd); iconv_close(cd);
return 0; return 0;

Write Preview
Loading…
Cancel
Save