w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

miscutil.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1991,1992,1993 NEC Corporation.
3  */
4 #ifndef lint
5 static char rcsid[] =
6  "$Id: miscutil.c,v 2.15 1994/04/19 10:16:50 uchida Exp $ (NEC)";
7 #endif
8 
9 #include <stdio.h>
10 #include "plain2.h"
11 #include "kanji.h"
12 #include <ctype.h>
13 #ifdef MSDOS
14 /*
15  * get option letter from argument vector
16  */
17 int opterr = 1, /* useless, never set or used */
18  optind = 1, /* index into parent argv vector */
19  optopt; /* character checked for validity */
20 char *optarg; /* argument associated with option */
21 
22 #define BADCH (int)'?'
23 #define EMSG ""
24 #define tell(s) fputs(*nargv,stderr);fputs(s,stderr); \
25  fputc(optopt,stderr);fputc('\n',stderr);return(BADCH);
26 getopt(nargc,nargv,ostr)
27 int nargc;
28 char **nargv,
29  *ostr;
30 {
31  static char *place = EMSG; /* option letter processing */
32  register char *oli; /* option letter list index */
33 
34  if(!*place) { /* update scanning pointer */
35  if(optind >= nargc || *(place = nargv[optind]) != '-' || !*++place) return(EOF);
36  if (*place == '-') { /* found "--" */
37  ++optind;
38  return(EOF);
39  }
40  } /* option letter okay? */
41  if ((optopt = (int)*place++) == (int)':' || !(oli = index(ostr,optopt))) {
42  if(!*place) ++optind;
43  tell(": illegal option -- ");
44  }
45  if (*++oli != ':') { /* don't need argument */
46  optarg = NULL;
47  if (!*place) ++optind;
48  }
49  else { /* need an argument */
50  if (*place) optarg = place; /* no white space */
51  else if (nargc <= ++optind) { /* no arg */
52  place = EMSG;
53  tell(": option requires an argument -- ");
54  }
55  else optarg = nargv[optind]; /* white space */
56  place = EMSG;
57  ++optind;
58  }
59  return(optopt); /* dump back option letter */
60 }
61 #endif
62 /*
63  * Value of number string(hankaku or Zenkaku)
64  * return rest of the string
65  */
66 char *
67 strNum(str, rval)
68 char *str;
69 int *rval;
70 {
71  *rval = 0;
72  while(1) {
73  if (
74 #ifdef KANJI
75  !isZenkaku(str) &&
76 #endif
77  isdigit(*str)){
78  *rval = *rval * 10 + (*str - '0');
79  str++;
80  }
81 #ifdef KANJI
82  else if (maybeZenkakuNum(str)) {
83  /* Zenkaku Number */
84  *rval = *rval * 10 + ZenkakuNumVal(str);
85  str += 2;
86  }
87 #endif
88  else {
89  /* search Next number */
90  while (*str) {
91 #ifdef KANJI
92  if (maybeZenkakuNum(str))
93  break;
94  if (isZenkaku(str))
95  str += 2;
96  else
97 #endif
98  if (isdigit(*str))
99  break;
100  else
101  str++;
102  }
103  return str;
104  }
105  }
106 }
107 #ifdef KANJI
108 char *
109 euc2jisStr(str, jstr)
110 char *str;
111 char *jstr;
112 {
113  char *t = jstr;
114  int inKanji = 0;
115  while(*str) {
116  if (t >= jstr + MAX_LINE_LEN) {
117  fprintf(stderr, "PANIC(buffer overflow in jis convert)\n");
118  exit(2);
119  }
120  if (!inKanji && isZenkaku(str)) {
121  (void)strncpy(t,"\033$B", 3);
122  t += 3;
123  inKanji = 1;
124  }
125  else if (inKanji && !isZenkaku(str)) {
126  (void)strncpy(t,"\033(B", 3);
127  t += 3;
128  inKanji = 0;
129  }
130  *t++ = *str++ & 0x7f;
131  if (t > jstr + MAX_LINE_LEN) {
132  fprintf(stderr, "PANIC(buffer overflow in jis convert)\n");
133  exit(2);
134  }
135  }
136  if (inKanji) {
137  (void)strncpy(t,"\033(B", 3);
138  t += 3;
139  }
140  *t = '\0';
141  return jstr;
142 }
143 char *
144 euc2sftjStr(str, sjstr)
145 char *str;
146 char *sjstr;
147 {
148  register char c1, c2;
149  char *t = sjstr;
150  while(*str) {
151  if (isZenkaku(str)) {
152  c2 = (*str++) & 0x7f;
153  c1 = (*str++) & 0x7f;
154  *t++ = ((c2 - 1) >> 1) + ((c2 <= 0x5e) ? 0x71 : 0xb1);
155  *t++ = c1 + ((c2 & 1) ? ((c1 < 0x60) ? 0x1f : 0x20) : 0x7e);
156  }
157  else {
158  *t++ = *str++;
159  }
160  }
161  *t = '\0';
162  return sjstr;
163 }
164 #define isSjKanji(c) (((c)>=0x80 && (c)<0xa0) || ((c)>=0xe0 && (c)<0xfd))
165 char *
166 sftj2eucStr(str, estr)
167 char *str;
168 char *estr;
169 {
170  int c1, c2;
171  char *t = estr;
172  while(*str) {
173  c1 = (unsigned char)*str++;
174  if (isSjKanji(c1)) {
175  c2 = (unsigned char)*str++;
176  if (c2 >= 0x9f) {
177  *t++ = (c1 >= 0xe0)?
178  c1*2 - 0xe0 : c1*2 - 0x60;
179  *t++ = c2 + 2;
180  } else {
181  *t++ = (c1 >= 0xe0)?
182  c1*2 - 0xe1 : c1*2 - 0x61;
183  *t++ = (c2 >= 0x7f)?
184  c2 + 0x60 : c2 + 0x61;
185  }
186  }
187  else {
188  *t++ = c1;
189  }
190  }
191  *t = '\0';
192  return estr;
193 }
194 #endif
195 char *
197 char *str;
198 {
199 #ifdef KANJI
200 #if INTERNAL_CODE == CODE_EUC
201  static char cvtBuf[MAX_LINE_LEN];
202  if (outputCode == CODE_JIS)
203  return euc2jisStr(str, cvtBuf);
204  else if (outputCode == CODE_SJIS)
205  return euc2sftjStr(str, cvtBuf);
206  else
207  return str;
208 #else
209 #if INTERNAL_CODE == CODE_SJIS
210  return str;
211 #else
212 unknown code;
213 #endif
214 #endif
215 #else
216  return str;
217 #endif
218 }
220 struct textBlock *tbp;
221 {
222  if (tbp->type == TB_LIST) {
223  return texts[tbp->rbegin]->indent;
224  }
225  return minIndent(tbp->rbegin + tbp->hinted, tbp->rend - tbp->hinted);
226 }
228 int begin;
229 int end;
230 {
231  register int i;
232  register int mini, indent;
233  mini = texts[begin]->indent;
234  for (i = begin; i < end; i++) {
235  indent = texts[i]->indent;
236  if (!texts[i]->blank && indent < mini)
237  if ((mini = indent) == 0)
238  return 0;
239  }
240  return mini;
241 }
243 int begin;
244 int end;
245 {
246  int maxl;
247  int i;
248  maxl = 0;
249  for (i = begin; i < end; i++) {
250  if (texts[i]->length > maxl)
251  maxl = texts[i]->length;
252  }
253  return maxl;
254 }
256 int begin;
257 int end;
258 {
259  int left, right;
260  left = minIndent(begin, end);
262  if (right < 0)
263  return (left <= MIN_INDENT);
264  if (left > MIN_INDENT && right < rightMargin/4)
265  return 1;
266  if ((left * 2) <= (right * 5) &&
267  (left * 5) >= (right * 2))
268  return 1;
269  return 0;
270 }
272 struct textBlock *tbp;
273 {
274  return isCenter(tbp->rbegin, tbp->rend);
275 }
276 char *
278 struct text *textp;
279 {
280  char *s;
281  s = textp->body + textp->indent + textp->headLen;
282  while (*s != '\0') {
283  if (*s != ' ')
284  break;
285  s++;
286  }
287  return s;
288 }
290 register char **top;
291 register char *s;
292 register struct transTable *trtp;
293 {
294  register char *tto;
295  for (; trtp->special_char != 0; trtp++) {
296  if (*s == trtp->special_char) {
297  for (tto=trtp->trans_to; *tto!= '\0'; tto++)
298  *(*top)++ = *tto;
299  return;
300  }
301  }
302  *(*top)++ = *s;
303 }
304 char *
305 textQuote(str, tr_table)
306 register char *str;
307 struct transTable *tr_table;
308 {
309  static char translated[MAX_LINE_LEN];
310  char *t;
311  if (rawOutput)
312  return str;
313  t = translated;
314  for(; *str != '\0'; str++) {
315 #ifdef KANJI
316  if (isZenkaku(str)) {
317  *t++ = *str++;
318  *t++ = *str;
319  }
320  else
321 #endif
322  textQuoteChar(&t, str, tr_table);
323  }
324  *t = '\0';
325  return translated;
326 }
327 /*
328  * Blank line structure (Blank:true, Length:0)
329  */
330 static struct text blank =
331 {
332  NULL, NULL, 1,
333  0, 0, 0, 0,
334  0
335 };
336 struct text *
337 prevLine(lnum)
338 int lnum;
339 {
340  if (lnum <= textBegin)
341  return &blank;
342  return (texts[lnum-1]);
343 }
344 struct text *
345 nextLine(lnum)
346 int lnum;
347 {
348  if (lnum+1 >= textLines)
349  return &blank;
350  return (texts[lnum+1]);
351 }
352 struct textBlock *
353 prevBlock(lnum, bound)
354 int lnum;
355 int bound;
356 {
357  while(--lnum >= bound) {
358  if (texts[lnum]->block) {
359  if (texts[lnum]->block->superBlock)
360  return texts[lnum]->block->superBlock;
361  else
362  return texts[lnum]->block;
363  }
364  }
365  return NULL;
366 }
367 struct textBlock *
368 nextBlock(lnum, bound)
369 int lnum;
370 int bound;
371 {
372  for( ;lnum < bound; lnum++) {
373  if (texts[lnum]->block) {
374  if (texts[lnum]->block->superBlock)
375  return texts[lnum]->block->superBlock;
376  else
377  return texts[lnum]->block;
378  }
379  }
380  return NULL;
381 }
382 #ifdef KANJI
383 /*
384  * Character at column "col" in string "s" is kanji character
385  */
386 isKanjiChar(textp, col)
387 register struct text *textp;
388 register short col;
389 {
390  register char *s;
391  if (col > textp->length || col < textp->indent)
392  return 0;
393  s = textp->body + textp->indent;
394  col -= textp->indent;
395  for (; *s && col > 0; s++, col--) {
396  if (isZenkaku(s)) {
397  s++;
398  col--;
399  }
400  }
401  if (col == 0 && isZenkaku(s))
402  return 1;
403  return 0;
404 }
405 #endif
406 struct textBlock *
408 int begin;
409 int end;
410 int type;
411 {
412  struct textBlock *tbp;
413  tbp = (struct textBlock *)malloc(sizeof(struct textBlock));
414  if (tbp == NULL) {
415  fprintf(stderr, "PANIC(malloc in newTextBlock)\n");
416  exit (2);
417  }
418  bzero((char *)tbp, sizeof(struct textBlock));
419  tbp->rbegin = begin;
420  tbp->rend = end;
421  tbp->hinted = 0;
422  tbp->type = type;
423  return tbp;
424 }
425 #define S_START 1
426 #define S_SPACED 2
427 #define S_INDENTED 3
428 /*
429  * phase-0: 1, 2, 3
430  * phase-1: 4, 5, 6
431  *
432  * +- + ------------------------
433  * 4 | ------------------------
434  * +- | ------------------------
435  * | + ----------------
436  * 1 2 3 --------
437  * | + ----------------
438  * +- + ------------------------
439  * 5 ------------------------
440  * +- ------------------------
441  *
442  * +- ------------------------
443  * 6 ------------------------
444  * +- ------------------------
445  */
447 int begin;
448 int end;
449 int phase;
450 int (*func)();
451 {
452  register int l;
453  register struct text *textp;
454  int rstat, indent;
455  int rbegin, ibegin, rend;
456  DBG3(8, "applyOnRegion-%d (%d-%d)\n", phase, begin, end);
457  rstat = S_START;
459  rbegin = begin;
460  for (l = begin; l <= end; l++) {
461  textp = texts[l];
462  switch (rstat) {
463  case S_START:
464  DBG1(11, "aor START %d\n", l);
465  if (l >= end)
466  break;
467  else if (!textp->blank
468  && textp->block == NULL) {
469  if (textp->indent >= indent + MIN_INDENT) {
470  ibegin = l;
471  rend = l + 1;
472  rstat = S_INDENTED;
473  }
474  else {
475  rbegin = l;
476  rstat = S_SPACED;
477  }
478  }
479  break;
480  case S_SPACED:
481  DBG2(11, "aor SPACED %d B:%d\n", l, rbegin);
482  if (l >= end
483  || textp->blank
484  || textp->block != NULL) {
485  if (phase == 1)
486  (*func)(rbegin, l<end?l:end);
487  rstat = S_START;
488  }
489  else if (textp->indent >= indent + MIN_INDENT) {
490  ibegin = l;
491  rend = l + 1;
492  rstat = S_INDENTED;
493  }
494  break;
495  case S_INDENTED:
496  DBG2(11, "aor INDENTED %d B:%d\n", l, rbegin);
497  if (l == end
498  || (!textp->blank
499  && textp->indent < indent + MIN_INDENT)){
500  if (phase == 0
501  && !texts[rbegin]->japanese) /* XXX */
502  (*func)(rbegin, (l+1)<end?(l+1):end-1);
503  if (phase == 0 && (*func)(ibegin, rend) == 0)
504  applyOnRegion(ibegin, rend, func);
505  rbegin = l;
506  rstat = S_SPACED;
507  }
508  else if (!isBlank(l))
509  rend = l + 1;
510  else if (!textp->blank
511  && textp->block == NULL)
512  return;
513  break;
514  default:
515  fprintf(stderr, "PANIC(undefined status)%d\n", rstat);
516  exit(2);
517  }
518  }
519 }
521 int begin;
522 int end;
523 int (*func)();
524 {
527 }
529 int begin;
530 int end;
531 int (*func)();
532 {
533  register struct text *textp;
534  register int l;
535  int rstat;
536  int rbegin;
537  DBG2(8, "applyOnSpaced (%d-%d)\n", begin, end);
538  rstat = S_START;
539  rbegin = begin;
540  for (l = begin; l <= end; l++) {
541  textp = texts[l];
542  switch (rstat) {
543  case S_START:
544  if (l >= end)
545  break;
546  else if (!textp->blank
547  && textp->block == NULL) {
548  rbegin = l;
549  rstat = S_SPACED;
550  }
551  break;
552  case S_SPACED:
553  if (l >= end
554  || textp->blank
555  || textp->block != NULL) {
556  (*func)(rbegin, l<end?l:end);
557  rstat = S_START;
558  }
559  break;
560  default:
561  fprintf(stderr, "PANIC(undefined status)%d\n", rstat);
562  exit(2);
563  }
564  }
565 }
566 /*
567  * join blocks
568  */
570 int begin;
571 int end;
572 int tbType;
573 {
574  struct textBlock *tbp;
575  struct textBlock *nextTbp;
576  int l, l2;
577  for (l = begin; l < end; l++) {
578  if ((tbp = texts[l]->block) && !tbp->hinted
579  && tbp->type == tbType) {
580  nextTbp = texts[tbp->rend]->block;
581  if (nextTbp
582  && !nextTbp->hinted && nextTbp->type == tbType){
583  /* join it */
584  DBG4(3, "Join [%d,%d]-[%d,%d]\n",
585  tbp->rbegin, tbp->rend,
586  nextTbp->rbegin, nextTbp->rend);
587  for (l2 = tbp->rend;
588  l2 < nextTbp->rend; l2++)
589  texts[l2]->block = tbp;
590  tbp->rend = nextTbp->rend;
591  free((char *)nextTbp);
592  }
593  }
594  }
595 }
int code
Definition: aftopl.c:52
#define type(a)
Definition: aptex-macros.h:171
#define free(a)
Definition: decNumber.cpp:310
#define CODE_JIS
Definition: virfont.c:102
char * strncpy()
static void
Definition: fpif.c:118
#define s
Definition: afcover.h:80
#define t
Definition: afcover.h:96
static FIELD_PTR begin
Definition: genind.c:37
int col
Definition: gsftopk.c:443
#define NULL
Definition: ftobjs.h:61
small capitals from c petite p scientific i
Definition: afcover.h:80
void exit()
#define EOF
Definition: afmparse.c:59
@ right
Definition: annotate.c:15
int int double double double char double char * top
Definition: gdfx.h:19
int getopt(int nargc, char *const nargv[], const char *ostr)
Definition: getopt.c:53
int optopt
Definition: getopt.c:40
#define EMSG
Definition: getopt.c:46
int optind
Definition: getopt.c:39
char * optarg
Definition: getopt.c:42
int opterr
Definition: getopt.c:38
static int phase
Definition: cs_type2.c:84
int indent
Definition: main.c:118
int japanese(char *buff)
Definition: sort.c:242
#define fprintf
Definition: mendex.h:64
#define bzero(p, n)
Definition: config.h:6
#define length(c)
Definition: ctangleboot.c:65
#define malloc
Definition: alloca.c:91
#define unknown
Definition: tie.c:133
long tell()
#define isdigit(c)
Definition: snprintf.c:177
static luaL_Reg func[]
Definition: except.c:32
struct text * nextLine(int lnum)
Definition: miscutil.c:345
applyOnRegion2(int begin, int end, int phase, int *func)
Definition: miscutil.c:446
maxLength(int begin, int end)
Definition: miscutil.c:242
static struct text blank
Definition: miscutil.c:330
applyOnRegion(int begin, int end, int *func)
Definition: miscutil.c:520
blockIsCenter(struct textBlock *tbp)
Definition: miscutil.c:271
applyOnSpaced(int begin, int end, int *func)
Definition: miscutil.c:528
minIndent(int begin, int end)
Definition: miscutil.c:227
#define S_START
Definition: miscutil.c:425
char * strNum(char *str, int *rval)
Definition: miscutil.c:67
struct text * prevLine(int lnum)
Definition: miscutil.c:337
struct textBlock * prevBlock(int lnum, int bound)
Definition: miscutil.c:353
char * listSecBody(struct text *textp)
Definition: miscutil.c:277
char * codeCvt(char *str)
Definition: miscutil.c:196
joinBlocks(int begin, int end, int tbType)
Definition: miscutil.c:569
#define S_INDENTED
Definition: miscutil.c:427
struct textBlock * nextBlock(int lnum, int bound)
Definition: miscutil.c:368
textQuoteChar(char **top, char *s, struct transTable *trtp)
Definition: miscutil.c:289
isCenter(int begin, int end)
Definition: miscutil.c:255
minIndentBlock(struct textBlock *tbp)
Definition: miscutil.c:219
char * textQuote(char *str, struct transTable *tr_table)
Definition: miscutil.c:305
static char rcsid[]
Definition: miscutil.c:5
#define S_SPACED
Definition: miscutil.c:426
struct textBlock * newTextBlock(int begin, int end, int type)
Definition: miscutil.c:407
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp *numpix else pixst endif endm macro pixld1_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl else error unsupported endif endm macro pixld2_s mem_operand if mov asr add asl add asl mov asr sub UNIT_X add asl mov asr add asl add asl mov asr add UNIT_X add asl else pixld1_s mem_operand pixld1_s mem_operand endif endm macro pixld0_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl endif endm macro pixld_s_internal mem_operand if mem_operand pixld2_s mem_operand pixdeinterleave basereg elseif mem_operand elseif mem_operand elseif mem_operand elseif mem_operand pixld0_s mem_operand else pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else error unsupported mem_operand if bpp mem_operand endif endm macro vuzp8 reg2 vuzp d d &reg2 endm macro vzip8 reg2 vzip d d &reg2 endm macro pixdeinterleave basereg basereg basereg basereg basereg endif endm macro pixinterleave basereg basereg basereg basereg basereg endif endm macro PF boost_increment endif if endif PF tst PF addne PF subne PF cmp ORIG_W if endif if endif if endif PF subge ORIG_W PF subges if endif if endif if endif endif endm macro cache_preload_simple endif if dst_r_bpp pld[DST_R, #(PREFETCH_DISTANCE_SIMPLE *dst_r_bpp/8)] endif if mask_bpp pld endif[MASK, #(PREFETCH_DISTANCE_SIMPLE *mask_bpp/8)] endif endif endm macro fetch_mask_pixblock pixld mask_basereg pixblock_size MASK endm macro ensure_destination_ptr_alignment process_pixblock_tail_head if beq irp skip1 beq endif SRC MASK if dst_r_bpp DST_R else add endif PF add sub src_basereg pixdeinterleave mask_basereg pixdeinterleave dst_r_basereg process_pixblock_head pixblock_size cache_preload_simple process_pixblock_tail pixinterleave dst_w_basereg irp beq endif process_pixblock_tail_head tst beq irp if pixblock_size chunk_size tst beq pixld_src SRC pixld MASK if DST_R else pixld DST_R endif if
int textLines
Definition: plain2.c:115
int rightMargin
Definition: plain2.c:117
struct text ** texts
Definition: plain2.c:112
int rawOutput
Definition: plain2.c:89
int outputCode
Definition: plain2.c:92
int textBegin
Definition: plain2.c:116
#define MAX_LINE_LEN
Definition: plain2.h:45
char * euc2sftjStr()
#define DBG2(level, format, val1, val2)
Definition: plain2.h:162
#define index(s, c)
Definition: plain2.h:351
#define DBG4(level, format, val1, val2, val3, val4)
Definition: plain2.h:164
char * euc2jisStr()
#define DBG3(level, format, val1, val2, val3)
Definition: plain2.h:163
#define DBG1(level, format, val)
Definition: plain2.h:161
#define TB_LIST
Definition: plain2.h:103
char * sftj2eucStr()
#define MIN_INDENT
Definition: plain2.h:40
#define isBlank(l)
Definition: plain2.h:174
#define CODE_SJIS
Definition: plain2.h:205
lft_cell * left
Definition: routines.h:73
#define str(s)
Definition: sh6.c:399
Definition: dvips.h:235
struct textBlock * superBlock
Definition: plain2.h:121
short hinted
Definition: plain2.h:118
short rend
Definition: plain2.h:117
short rbegin
Definition: plain2.h:116
short type
Definition: plain2.h:115
short length
Definition: plain2.h:55
char * body
Definition: plain2.h:52
short blank
Definition: plain2.h:54
short indent
Definition: plain2.h:56
struct textBlock * block
Definition: plain2.h:51
short headLen
Definition: plain2.h:85
char * trans_to
Definition: plain2.h:132
char special_char
Definition: plain2.h:131
#define c2
Definition: t1io.c:53
#define c1
Definition: t1io.c:52
return() int(((double) *(font_tbl[cur_fnt].wtbl+(int)(*(font_tbl[cur_fnt].char_wi+(int)(ch - font_tbl[cur_fnt].char_f)% 256)))/(double)(1L<< 20)) *(double) font_tbl[cur_fnt].scale)
#define KANJI
Definition: kanji.h:16
#define end(cp)
Definition: zic.c:71