![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / fonts / compiler|
Return to fc.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / fonts / compiler |
1.1 root 1: /* $Header: fc.c,v 1.4 87/07/24 14:50:35 toddb Exp $ */
2:
3: #include <stdio.h>
4: #include <sys/file.h>
5: #include <errno.h>
6: /* #include <malloc.h> */ extern char *malloc(), *realloc();
7:
8: #include "misc.h"
9: #include "X.h"
10: #include "Xproto.h"
11: #include "fontstruct.h"
12: #include "font.h"
13:
14: #include "fc.h" /* used by converters only */
15:
16: /*
17: * DESCRIPTION
18: * pure filter; filename argument only
19: *
20: * DISCLAIMER
21: * not much thought has been given to error recovery.
22: */
23: #define INDICES 256
24: #define MAXENCODING 0xFFFF
25:
26: extern char *gets(), *index();
27:
28: static char *myname; /* initialized from argv[0] */
29: static char *currentfont;
30:
31: int linenum = 0; /* for error messages */
32: int or_glyphPad = 0; /* override glyphPading?? */
33: int or_bitorder = 0; /* override bitorder?? */
34:
35:
36: int glyphPad = DEFAULTGLPAD;
37: int bitorder = DEFAULTBITORDER;
38:
39: /*
40: * read the next line and keep a count for error messages
41: */
42: char *
43: getline(s)
44: char *s;
45: {
46: s = gets(s);
47: linenum++;
48: while (s) {
49: int len = strlen(s);
50: if (len && s[len-1] == '\015')
51: s[--len] = '\0';
52: if ((len==0) || prefix(s, "COMMENT")) {
53: s = gets(s);
54: linenum++;
55: } else break;
56: }
57: return(s);
58: }
59:
60: /*
61: * malloc and copy a string value. Handle quoted strings.
62: */
63: char *
64: remember(s)
65: char *s;
66: {
67: char *p, *pp;
68:
69: /* strip leading white space */
70: while (*s && (*s == ' ' || *s == '\t'))
71: s++;
72: if (*s == 0)
73: return "";
74: if (*s != '"') {
75: pp = s;
76: /* no white space in value */
77: for (pp=s; *pp; pp++)
78: if (*pp == ' ' || *pp == '\t' || *pp == '\015' || *pp == '\n') {
79: *pp = 0;
80: break;
81: }
82: p = malloc(strlen(s)+1);
83: strcpy(p, s);
84: return p;
85: }
86: /* quoted string: strip outer quotes and undouble inner quotes */
87: s++;
88: pp = p = malloc(strlen(s)+1);
89: while (*s) {
90: if (*s == '"') {
91: if (*(s+1) != '"') {
92: *p++ = 0;
93: return pp;
94: } else {
95: s++;
96: }
97: }
98: *p++ = *s++;
99: }
100: *p++ = 0; /* just in case; space for it allocated above */
101: return pp;
102: }
103:
104: /*
105: * Invert bit order within each BYTE of an array.
106: * "In" and "out" may point to the same array.
107: */
108: void
109: bitorderinvert( in, out, nbytes)
110: register unsigned char *in;
111: register unsigned char *out;
112: register int nbytes;
113: {
114: static int BOTableInitialized = 0;
115: static unsigned char BOTable[256];
116:
117:
118: if ( !BOTableInitialized)
119: {
120: int btabi;
121: int biti;
122:
123: for ( btabi=0; btabi<256; btabi++)
124: for ( biti=0; biti<8; biti++)
125: if (btabi & 1<<biti)
126: BOTable[btabi] |= (unsigned)0x80 >> biti;
127: BOTableInitialized++;
128: }
129: while ( nbytes--)
130: *out++ = BOTable[ *in++];
131:
132: }
133:
134: /*
135: * return TRUE if str is a prefix of buf
136: */
137: prefix(buf, str)
138: char *buf, *str;
139: {
140: return strncmp(buf, str, strlen(str))? FALSE : TRUE;
141: }
142:
143: /*
144: * return TRUE if strings are equal
145: */
146: streq(a, b)
147: char *a, *b;
148: {
149: return strcmp(a, b)? FALSE : TRUE;
150: }
151:
152: /*
153: * make a byte from the first two hex characters in s
154: */
155: unsigned char
156: hexbyte(s)
157: char *s;
158: {
159: unsigned char b = 0;
160: register char c;
161: int i;
162:
163: for (i=2; i; i--) {
164: c = *s++;
165: if ((c >= '0') && (c <= '9'))
166: b = (b<<4) + (c - '0');
167: else if ((c >= 'A') && (c <= 'F'))
168: b = (b<<4) + 10 + (c - 'A');
169: else if ((c >= 'a') && (c <= 'f'))
170: b = (b<<4) + 10 + (c - 'a');
171: else
172: return 0; /* bad data */
173: }
174: return b;
175: }
176:
177: /*
178: * fatal error. never returns.
179: */
180: fatal(msg, p1, p2, p3, p4)
181: char *msg;
182: {
183: fprintf(stderr, "%s: %s:", myname, currentfont);
184: fprintf(stderr, msg, p1, p2, p3, p4);
185: if (linenum)
186: fprintf(stderr, " at line %d\n", linenum);
187: else
188: fprintf(stderr, "\n");
189: exit(1);
190: }
191:
192: /*
193: * these properties will be generated if not already present.
194: */
195: #define NULLPROP (FontPropPtr)0;
196:
197: FontPropPtr pointSizeProp = NULLPROP;
198: FontPropPtr familyProp = NULLPROP;
199: FontPropPtr resolutionProp = NULLPROP;
200: FontPropPtr xHeightProp = NULLPROP;
201: FontPropPtr weightProp = NULLPROP;
202: FontPropPtr quadWidthProp = NULLPROP;
203: #define GENPROPS 6
204:
205: BOOL haveFontAscent = FALSE;
206: BOOL haveFontDescent = FALSE;
207:
208: /*
209: * check for known property values
210: */
211:
212: int
213: specialproperty(pfp, pfi)
214: FontPropPtr pfp;
215: FontInfoPtr pfi;
216: {
217: if (streq(pfp->name, "FONT_ASCENT") && !pfp->indirect)
218: {
219: pfi->fontAscent = pfp->value;
220: haveFontAscent = TRUE;
221: return 0;
222: }
223: else if (streq(pfp->name, "FONT_DESCENT") && !pfp->indirect)
224: {
225: pfi->fontDescent = pfp->value;
226: haveFontDescent = TRUE;
227: return 0;
228: }
229: else if (streq(pfp->name, "DEFAULT_CHAR") && !pfp->indirect)
230: {
231: pfi->chDefault = pfp->value;
232: return 0;
233: }
234: else if (streq(pfp->name , "POINT_SIZE"))
235: pointSizeProp = pfp;
236: else if (streq(pfp->name , "FAMILY_NAME"))
237: familyProp = pfp;
238: else if (streq(pfp->name , "RESOLUTION"))
239: resolutionProp = pfp;
240: else if (streq(pfp->name , "X_HEIGHT"))
241: xHeightProp = pfp;
242: else if (streq(pfp->name , "WEIGHT"))
243: weightProp = pfp;
244: else if (streq(pfp->name , "QUAD_WIDTH"))
245: quadWidthProp = pfp;
246: return 1;
247: }
248:
249: computeweight(font)
250: TempFont *font;
251: {
252: int i;
253: int width = 0, area, bits = 0;
254: register b;
255: register unsigned char *p;
256:
257: for (i=0; i<n1dChars(font->pFI); i++)
258: width += font->pCI[i].metrics.characterWidth;
259: area = width*(font->pFI->fontAscent+font->pFI->fontDescent);
260: for (i=0,p=font->pGlyphs; i<font->pFI->maxbounds.byteOffset; i++,p++)
261: for (b=(*p); b; b >>= 1)
262: bits += b & 1;
263: return (int)((bits*1000.0)/area);
264: }
265:
266: main(argc, argv)
267: int argc;
268: char * argv[];
269: {
270: TempFont font;
271: FontInfoRec fi;
272: CharInfoPtr cinfos[INDICES]; /* rows waiting to be allocated */
273: int bytesGlAlloced = 1024; /* amount now allocated for glyphs
274: (bytes) */
275: unsigned char *pGl = (unsigned char *)malloc( bytesGlAlloced);
276: int bytesGlUsed = 0;
277: int nGl = 0;
278: int nchars;
279: float pointSize;
280: int xRes, yRes;
281: char linebuf[BUFSIZ];
282: char namebuf[100];
283: char family[100];
284: char *bdffile = NULL;
285: unsigned int attributes;
286: int digitWidths = 0, digitCount = 0, ex = 0;
287: int char_row, char_col;
288: int i;
289: CharInfoRec emptyCharInfo;
290:
291: myname = argv[0];
292: argc--, argv++;
293: while (argc--) {
294: if (argv[0][0] == '-') {
295: switch (argv[0][1]) {
296: case 'p': /* Pad Glyphs to Word boundaries */
297: switch (argv[0][2]) {
298: default:
299: goto usage;
300: case '1':
301: case '2':
302: case '4':
303: case '8':
304: glyphPad = argv[0][2] - '0';
305: break;
306: }
307: or_glyphPad = 1;
308: break;
309: case 'm':
310: or_bitorder = 1;
311: bitorder = MSBFirst;
312: break;
313:
314: case 'l':
315: or_bitorder = 1;
316: bitorder = LSBFirst;
317: break;
318:
319: default:
320: fprintf(stderr, "bad flag -%c\n", argv[0][1]);
321: break;
322: }
323: } else {
324: if (bdffile)
325: usage:
326: fatal("usage: %s [-p#] [bdf file]", myname);
327: bdffile = argv[0];
328: if (freopen( bdffile, "r", stdin) == NULL)
329: fatal("could not open file %s\n", bdffile);
330: }
331: argv++;
332: }
333: emptyCharInfo.metrics.leftSideBearing = 0;
334: emptyCharInfo.metrics.rightSideBearing = 0;
335: emptyCharInfo.metrics.ascent = 0;
336: emptyCharInfo.metrics.descent = 0;
337: emptyCharInfo.metrics.characterWidth = 0;
338: emptyCharInfo.byteOffset = 0;
339: emptyCharInfo.exists = FALSE;
340: emptyCharInfo.metrics.attributes = 0;
341:
342: for (i = 0; i < INDICES; i++)
343: cinfos[i] = (CharInfoPtr)NULL;
344:
345: font.pFI = &fi;
346: fi.firstRow = INDICES;
347: fi.lastRow = 0;
348: fi.chFirst = INDICES;
349: fi.chLast = 0;
350: fi.pixDepth = 1;
351: fi.glyphSets = 1;
352: fi.chDefault = 0; /* may be overridden by a property */
353:
354: getline(linebuf);
355:
356: if ((sscanf(linebuf, "STARTFONT %s", namebuf) != 1) ||
357: !streq(namebuf, "2.1"))
358: fatal("bad 'STARTFONT'");
359: getline(linebuf);
360:
361: if (sscanf(linebuf, "FONT %s", family) != 1)
362: fatal("bad 'FONT'");
363: getline(linebuf);
364:
365: if (!prefix(linebuf, "SIZE"))
366: fatal("missing 'SIZE'");
367: if ((sscanf(linebuf, "SIZE %f%d%d", &pointSize, &xRes, &yRes) != 3))
368: fatal("bad 'SIZE'");
369: if (xRes != yRes)
370: fatal("x and y resolution must be equal");
371: getline(linebuf);
372:
373: if (!prefix(linebuf, "FONTBOUNDINGBOX"))
374: fatal("missing 'FONTBOUNDINGBOX'");
375: getline(linebuf);
376:
377: if (prefix(linebuf, "STARTPROPERTIES")) {
378: int nprops;
379: FontPropPtr pfp;
380:
381: sscanf(linebuf, "%*s%d", &nprops);
382: fi.nProps = nprops;
383: pfp = (FontPropPtr)malloc((nprops+GENPROPS) * sizeof(FontPropRec));
384: font.pFP = pfp;
385: getline(linebuf);
386: while((nprops-- > 0) && !prefix(linebuf, "ENDPROPERTIES")) {
387: if (sscanf(linebuf, "%s%d", namebuf, &pfp->value) == 2) {
388: /* integer value */
389: pfp->indirect = FALSE;
390: } else {
391: /* value is (possibly quoted) string */
392: pfp->indirect = TRUE;
393: pfp->value = (INT32)remember(linebuf+strlen(namebuf)+1);
394: }
395: pfp->name = (CARD32)remember(namebuf);
396: if (specialproperty(pfp, &fi))
397: pfp++;
398: else
399: fi.nProps--;
400: getline(linebuf);
401: }
402: if (!prefix(linebuf, "ENDPROPERTIES"))
403: fatal("missing 'ENDPROPERTIES'");
404: if (!haveFontAscent || !haveFontDescent)
405: fatal("must have 'FONT_ASCENT' and 'FONT_DESCENT' properties");
406: if (nprops != -1)
407: fatal("%d too few properties", nprops+1);
408: if (!familyProp) {
409: fi.nProps++;
410: pfp->name = (CARD32)("FAMILY_NAME");
411: pfp->value = (INT32)family;
412: pfp->indirect = TRUE;
413: familyProp = pfp++;
414: }
415: if (!pointSizeProp) {
416: fi.nProps++;
417: pfp->name = (CARD32)("POINT_SIZE");
418: pfp->value = (INT32)(pointSize*10.0);
419: pfp->indirect = FALSE;
420: pointSizeProp = pfp++;
421: }
422: if (!weightProp) {
423: fi.nProps++;
424: pfp->name = (CARD32)("WEIGHT");
425: pfp->value = -1; /* computed later */
426: pfp->indirect = FALSE;
427: weightProp = pfp++;
428: }
429: if (!resolutionProp) {
430: fi.nProps++;
431: pfp->name = (CARD32)("RESOLUTION");
432: pfp->value = (INT32)((xRes*100.0)/72.27);
433: pfp->indirect = FALSE;
434: resolutionProp = pfp++;
435: }
436: if (!xHeightProp) {
437: fi.nProps++;
438: pfp->name = (CARD32)("X_HEIGHT");
439: pfp->value = -1; /* computed later */
440: pfp->indirect = FALSE;
441: xHeightProp = pfp++;
442: }
443: if (!quadWidthProp) {
444: fi.nProps++;
445: pfp->name = (CARD32)("QUAD_WIDTH");
446: pfp->value = -1; /* computed later */
447: pfp->indirect = FALSE;
448: quadWidthProp = pfp++;
449: }
450: } else { /* no properties */
451: fatal("missing 'PROPERTIES'");
452: }
453: getline(linebuf);
454:
455: if (!prefix(linebuf, "CHARS"))
456: fatal("missing 'CHARS'");
457: sscanf(linebuf, "%*s%d", &nchars);
458: getline(linebuf);
459:
460: while ((nchars-- > 0) && prefix(linebuf, "STARTCHAR")) {
461: int t;
462: int ix; /* counts bytes in a glyph */
463: int wx; /* x component of width */
464: int bw; /* bounding-box width */
465: int bh; /* bounding-box height */
466: int bl; /* bounding-box left */
467: int bb; /* bounding-box bottom */
468: int enc, enc2; /* encoding */
469: char *p; /* temp pointer into linebuf */
470: int bytesperrow, row;
471: char charName[100];
472:
473: if (sscanf(linebuf, "STARTCHAR %s", charName) != 1)
474: fatal("bad character name");
475:
476: getline( linebuf);
477: if ((t=sscanf(linebuf, "ENCODING %d %d", &enc, &enc2)) < 1)
478: fatal("bad 'ENCODING'");
479: if (t == 2 && enc == -1)
480: enc = enc2;
481: if (enc == -1) {
482: fprintf(stderr,
483: "character '%s'with encoding = -1 ignored at line %d\n",
484: charName, linenum);
485: do {
486: char *s = getline(linebuf);
487: if (!s)
488: fatal("Unexpected EOF");
489: } while (!prefix(linebuf, "ENDCHAR"));
490: getline(linebuf);
491: continue;
492: }
493: if (enc > MAXENCODING)
494: fatal("character '%s' has encoding(=%d) too large", charName, enc);
495: char_row = (enc >> 8) & 0xFF;
496: char_col = enc & 0xFF;
497: fi.firstRow = MIN(fi.firstRow, char_row);
498: fi.lastRow = MAX(fi.lastRow, char_row);
499: fi.chFirst = MIN(fi.chFirst, char_col);
500: fi.chLast = MAX(fi.chLast, char_col);
501: if (!cinfos[char_row])
502: {
503: cinfos[char_row] =
504: (CharInfoPtr)malloc(sizeof(CharInfoRec)*INDICES);
505: bzero(cinfos[char_row], sizeof(CharInfoRec)*INDICES);
506: }
507:
508: getline( linebuf);
509: if (!prefix(linebuf, "SWIDTH"))
510: fatal("bad 'SWIDTH'");
511:
512: getline( linebuf);
513: sscanf( linebuf, "DWIDTH %d %*d", &wx);
514:
515: getline( linebuf);
516: sscanf( linebuf, "BBX %d %d %d %d", &bw, &bh, &bl, &bb);
517:
518: getline( linebuf);
519: if (prefix(linebuf, "ATTRIBUTES"))
520: {
521: for (p = linebuf + strlen("ATTRIBUTES ");
522: (*p == ' ') || (*p == '\t');
523: p ++)
524: /* empty for loop */ ;
525: attributes = hexbyte(p)<< 8 + hexbyte(p+2);
526: getline( linebuf); /* set up for BITMAP which follows */
527: }
528: else
529: attributes = 0;
530: if (!prefix(linebuf, "BITMAP"))
531: fatal("missing 'BITMAP'");
532:
533: /* collect data for generated properties */
534: if ((strlen(charName) == 1)){
535: if ((charName[0] >='0') && (charName[0] <= '9')) {
536: digitWidths += wx;
537: digitCount++;
538: } else if (charName[0] == 'x') {
539: ex = (bh+bb)<=0? bh : bh+bb ;
540: }
541: }
542:
543: cinfos[char_row][char_col].metrics.leftSideBearing = bl;
544: cinfos[char_row][char_col].metrics.rightSideBearing = bl+bw;
545: cinfos[char_row][char_col].metrics.ascent = bh+bb;
546: cinfos[char_row][char_col].metrics.descent = -bb;
547: cinfos[char_row][char_col].metrics.characterWidth = wx;
548: cinfos[char_row][char_col].byteOffset = bytesGlUsed;
549: cinfos[char_row][char_col].exists = FALSE; /* overwritten later */
550: cinfos[char_row][char_col].metrics.attributes = attributes;
551:
552: bytesperrow = GLWIDTHBYTESPADDED(bw,glyphPad);
553: for (row=0; row < bh; row++) {
554: getline(linebuf);
555: p = linebuf;
556: for ( ix=0; ix < bytesperrow; ix++)
557: {
558: if ( bytesGlUsed >= bytesGlAlloced)
559: pGl = (unsigned char *)realloc( pGl, (bytesGlAlloced *= 2));
560: pGl[bytesGlUsed] = hexbyte(p);
561: p += 2;
562: bytesGlUsed++;
563: }
564: /*
565: * Now pad the glyph row our pad boundary.
566: */
567: bytesGlUsed = GLWIDTHBYTESPADDED(bytesGlUsed<<3,glyphPad);
568: }
569: getline( linebuf);
570: if (!prefix(linebuf, "ENDCHAR"))
571: fatal("missing 'ENDCHAR'");
572: nGl++;
573: getline( linebuf); /* get STARTCHAR or ENDFONT */
574: }
575:
576: if (!prefix(linebuf, "ENDFONT"))
577: fatal("missing 'ENDFONT'");
578: if (nchars != -1)
579: fatal("%d too few characters", nchars+1);
580: if (nGl == 0)
581: fatal("No characters with valid encodings");
582:
583: fi.maxbounds.byteOffset = bytesGlUsed;
584: font.pGlyphs = pGl;
585:
586: font.pCI = (CharInfoPtr)malloc(sizeof(CharInfoRec)*n2dChars(font.pFI));
587: i = 0;
588: for (char_row = fi.firstRow; char_row <= fi.lastRow; char_row++)
589: {
590: if (!cinfos[char_row])
591: for (char_col = fi.chFirst; char_col <= fi.chLast; char_col++)
592: {
593: font.pCI[i] = emptyCharInfo;
594: i++;
595: }
596: else
597: for (char_col = fi.chFirst; char_col <= fi.chLast; char_col++)
598: {
599: font.pCI[i] = cinfos[char_row][char_col];
600: i++;
601: }
602: }
603: computeNaccelerators(&font);
604:
605: /* generate properties */
606: if (xHeightProp && (xHeightProp->value == -1))
607: xHeightProp->value = ex? ex : fi.minbounds.metrics.ascent;
608: if (quadWidthProp && (quadWidthProp->value == -1))
609: quadWidthProp->value = digitCount?
610: (INT32)((float)digitWidths/(float)digitCount) :
611: (fi.minbounds.metrics.characterWidth+fi.maxbounds.metrics.characterWidth)/2;
612: if (weightProp && (weightProp->value == -1))
613: weightProp->value = computeweight(&font);
614:
615: if (bitorder == LSBFirst)
616: bitorderinvert( pGl, pGl, bytesGlUsed);
617: #ifdef UNSPECIFIED
618: if (!or_glyphPad || !or_bitorder) {
619: fprintf(stderr, "%s: ", currentfont);
620: if (!or_glyphPad && !or_bitorder)
621: fprintf(stderr, "bit order/pad unspecified:\n\t");
622: else if (!or_glyphPad)
623: fprintf(stderr, "pad unspecified:\n\t");
624: else
625: fprintf(stderr, "bit order unspecified:\n\t");
626: fprintf(stderr, "using ");
627:
628: if (!or_bitorder)
629: fprintf(stderr, "order=%s",
630: bitorder == LSBFirst ? "LSBFirst" : "MSBFirst");
631: if (!or_glyphPad && !or_bitorder)
632: fprintf(stderr, ", ");
633: if (!or_glyphPad)
634: fprintf(stderr, "pad=%d", glyphPad);
635: fprintf(stderr, "\n");
636: }
637: #endif
638:
639: WriteNFont( stdout, &font);
640: exit(0);
641: }
642:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.