![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to makefonts.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / troff / devi10|
Return to makefonts.c CVS log | Up to [Research Unix] / researchv10no / cmd / troff / devi10 |
1.1 root 1:
2: /*
3: *
4: * This program was written with tabs set to every fourth column,
5: * so things will look funny unless you have your tabs set the same way.
6: * I haven't really finished the program, but it works and I doubt I'll
7: * do anything else with it.
8: *
9: */
10:
11:
12: #include <stdio.h>
13: #include <ctype.h>
14:
15: /*
16: #include "glyph.h"
17: */
18: #include "dev.h"
19:
20:
21: #define NON_FATAL 0
22: #define FATAL 1
23:
24: #define FALSE 0
25: #define TRUE 1
26:
27: #define NOT_SET -1 /* variable has not been initialized */
28:
29: #define RES 0 /* used in new_value() switch stmt */
30: #define UNIT 1
31: #define HOR 2
32: #define VERT 3
33: #define WIDTH 4
34: #define LENGTH 5
35:
36: #define BMASK 0377 /* mask for characters */
37:
38: #define CNAME 2 /* max length of special characters */
39: #define DNAME 10 /* max length of device name */
40: #define FNAME 10 /* max length of font name */
41: #define PNAME 50 /* longest allowed pathname */
42:
43: #define MAX_BUFF 30 /* input strings are put here */
44: #define LINE_LENGTH 100 /* longest allowed line */
45: #define MAX_CHARS 255 /* most allowed chars per font */
46:
47: #define SIZE_LENGTH 150 /* space allowed for new point sizes */
48: #define FONT_LENGTH 150 /* space for new default font list */
49:
50:
51:
52: int use_rast = FALSE; /* get widths from raster tables? */
53:
54: char path[PNAME+1]; /* path names built up here */
55:
56: char *srcdir = "/usr/lib/font"; /* ASCII font files are kept here */
57: char *fontdir = "/usr/lib/font"; /* binary font and device files */
58: char *bitdir = "/usr/lib/font"; /* raster tables are located here */
59: char *changes = "FONTCHANGES"; /* interpret this file */
60:
61: char mdev[DNAME+1] = ""; /* use this device's source files */
62: char tdev[DNAME+1] = ""; /* target device - for raster tables */
63: char cur_font[FNAME+1] = ""; /* font we are currently working on */
64:
65: int unitwidth = NOT_SET; /* widths hold for this point size */
66: int res = NOT_SET; /* and this target device resolution */
67: int hor = NOT_SET; /* minimum horizontal step */
68: int vert = NOT_SET; /* minimum vertical step */
69: char fonts[FONT_LENGTH] = {0}; /* new default font list */
70: char sizes[SIZE_LENGTH] = {0}; /* and point size list */
71:
72: float incr; /* add this to width after expansion */
73: float scale = NOT_SET; /* scale factor for width changes */
74: float dflt_chng = NOT_SET; /* default width change */
75: float font_chng = NOT_SET; /* width change for current font */
76: float dflt_incr = .5; /* add to width after expansion */
77:
78: int dcount; /* index into following arrays */
79: char names[MAX_CHARS][CNAME+1]; /* special character strings go here */
80: float deltas[MAX_CHARS]; /* corresponding width changes */
81: float incrs[MAX_CHARS]; /* character increments */
82:
83: struct dev dev; /* *mdev's DESC.out header goes here */
84:
85: int nchtab; /* number of special chars in chtab */
86: short *pstab; /* point size table - not needed */
87: short *chtab; /* char's index in chname array */
88: char *chname; /* special character strings */
89:
90:
91: FILE *fp_change; /* file pointer for *changes */
92: FILE *fp_rast; /* raster table used for widths */
93: FILE *fp_in; /* input file for current font */
94: FILE *fp_out; /* output file for current font */
95:
96: char **argv; /* let everyone use them */
97: int argc;
98:
99:
100:
101:
102: /*****************************************************************************/
103:
104:
105: main(agc, agv)
106:
107:
108: int agc;
109: char *agv[];
110:
111:
112: {
113:
114:
115: /********************************************************************
116: * *
117: * This program reads the file *changes in the current *
118: * directory which contains instructions on how to expand or *
119: * contract the character widths for each of the fonts mentioned *
120: * in the file. These changes will hopefully make the output for *
121: * *tdev more readable. Admittedly there's quite a bit of overkill *
122: * in this program, but I'm not going to change it. *
123: * *
124: * There are several different methods that can be used to *
125: * make the desired width changes. Probably the simplest is to *
126: * adjust the device resolution in the new DESC file up or down *
127: * an appropriate ammount and leave the widths in the font tables *
128: * unchanged. This approach results in a uniform width change for *
129: * all the characters on every available font. This type of change *
130: * can be obtained by specifying a default width change without *
131: * defining a new device resolution. *
132: * *
133: * Since a uniform expansion may not always be appropriate *
134: * you can also specify a width change for each for the new fonts. *
135: * This type of expansion will replace any default font change *
136: * that may have been specified. *
137: * *
138: ********************************************************************/
139:
140:
141:
142: argv = agv; /* global so everyone can use them */
143: argc = agc;
144:
145: get_options(); /* process any command line options */
146: startchanges(); /* start reading the *changes file */
147: checkvalues(); /* make sure everything's defined */
148: getdesc(); /* read *mdev's DESC.out file */
149: makedesc(); /* make *tdev's new DESC file */
150: finishchanges(); /* read rest of the *changes file */
151:
152: } /* End of main */
153:
154:
155: /******************************************************************************/
156:
157:
158: get_options()
159:
160:
161: {
162:
163:
164: /********************************************************************
165: * *
166: * Called from the main program to read and process any *
167: * command line options. *
168: * *
169: ********************************************************************/
170:
171:
172: while ( argc > 1 && argv[1][0] == '-' ) {
173:
174: switch ( argv[1][1] ) {
175:
176: case 'S': /* font source directory */
177: srcdir = &argv[1][2];
178: break;
179:
180: case 'F': /* binary font directory */
181: fontdir = &argv[1][2];
182: break;
183:
184: case 'R': /* raster table directory */
185: bitdir = &argv[1][2];
186: break;
187:
188: case 'm': /* get master device name */
189: if ( strlen(&argv[1][2]) > DNAME )
190: error(FATAL, "device name %s too long", &argv[1][2]);
191: strcpy(mdev, &argv[1][2]);
192: break;
193:
194: case 't': /* set target device name */
195: if ( strlen(&argv[1][2]) > DNAME )
196: error(FATAL, "device name %s too long", &argv[1][2]);
197: strcpy(tdev, &argv[1][2]);
198: break;
199:
200: default:
201: error(FATAL, "illegal option %c", argv[1][1]);
202:
203: } /* End switch */
204:
205: argv++; /* next argument */
206: argc--;
207:
208: } /* End while */
209:
210: } /* End of get_options */
211:
212:
213: /*****************************************************************************/
214:
215:
216: startchanges()
217:
218:
219: {
220:
221:
222: char buff[MAX_BUFF]; /* input buffer */
223: int ch; /* used to skip comments */
224:
225:
226: /********************************************************************
227: * *
228: * Called from the main program to read the font change file *
229: * *changes. If there's still one command line argument left when *
230: * we get here, we will use it as the name of the input file, *
231: * otherwise the default file *changes is used. *
232: * *
233: ********************************************************************/
234:
235:
236: if ( argc > 1 )
237: changes = &argv[1][0];
238:
239: if ( (fp_change = fopen(changes, "r")) == NULL )
240: error(FATAL, "can't open file %s", changes);
241:
242: while ( fscanf(fp_change, "%s", buff) != EOF ) {
243:
244: if ( strcmp(buff, "font") == 0 )
245: return;
246: else if ( strcmp(buff, "master") == 0 )
247: get_mdev();
248: else if ( strcmp(buff, "target") == 0 )
249: get_tdev();
250: else if ( strcmp(buff, "unitwidth") == 0 )
251: get_int(fp_change, &unitwidth);
252: else if ( strcmp(buff, "res") == 0 )
253: get_int(fp_change, &res);
254: else if ( strcmp(buff, "hor") == 0 )
255: get_int(fp_change, &hor);
256: else if ( strcmp(buff, "vert") == 0 )
257: get_int(fp_change, &vert);
258: else if ( strcmp(buff, "sizes") == 0 )
259: get_sizes();
260: else if ( strcmp(buff, "fonts") == 0 )
261: get_fonts();
262: else if ( strcmp(buff, "default") == 0 ) {
263: fscanf(fp_change, "%s", buff);
264: if ( strcmp(buff, "change") != 0 )
265: error(FATAL, "syntax error - bad default change statement");
266: get_float(fp_change, &dflt_chng);
267: } else if ( strcmp(buff, "round") == 0 ) {
268: fscanf(fp_change, "%s", buff);
269: if ( strcmp(buff, "up") == 0 )
270: dflt_incr = 1.0;
271: else if ( strcmp(buff, "down") == 0 )
272: dflt_incr = 0.0;
273: else error(FATAL, "syntax error - bad round statement");
274: } else if ( strcmp(buff, "use") == 0 ) {
275: fscanf(fp_change, "%s", buff);
276: if ( strcmp(buff, "raster") != 0 )
277: error(FATAL, "syntax error - bad use statement");
278: fscanf(fp_change, "%s", buff);
279: if ( strcmp(buff, "tables") == 0 )
280: error(FATAL, "syntax error - bad use statement");
281: use_rast = TRUE;
282: } else if ( buff[0] == '#' )
283: while ( (ch = getc(fp_change)) != EOF && ch != '\n' ) ;
284: else error(FATAL, "don't know command %s", buff);
285:
286: } /* End while */
287:
288: error(FATAL, "no font commands in file %s", changes);
289:
290: } /* End of startchanges */
291:
292:
293: /*****************************************************************************/
294:
295:
296: checkvalues()
297:
298:
299: {
300:
301:
302:
303: /********************************************************************
304: * *
305: * Called from the main program to make sure all the required *
306: * parameters have been properly defined. *
307: * *
308: ********************************************************************/
309:
310:
311: if ( *mdev == '\0' )
312: error(FATAL, "missing master device name");
313:
314: if ( use_rast == TRUE )
315: if ( *tdev == '\0' )
316: error(FATAL, "missing target device name");
317: else if ( res == NOT_SET )
318: error(FATAL, "missing target device resolution");
319:
320: } /* End of checkvalues */
321:
322:
323: /*****************************************************************************/
324:
325:
326: get_mdev()
327:
328:
329: {
330:
331:
332: char buff[MAX_BUFF]; /* put the device name here */
333:
334:
335: /********************************************************************
336: * *
337: * Read the name of the master device from *fp_change, and *
338: * save the name in array mdev[]. If *mdev has already been set, *
339: * possibly by an option, it won't be changed again. *
340: * *
341: ********************************************************************/
342:
343:
344: if ( fscanf(fp_change, " device %s", buff) != 1 )
345: error(FATAL, "missing master device name");
346:
347: if ( strlen(buff) > DNAME )
348: error(FATAL, "master device name %s too long", buff);
349:
350: if ( *mdev == '\0' )
351: strcpy(mdev, buff);
352:
353: } /* End of get_mdev */
354:
355:
356: /*****************************************************************************/
357:
358:
359: get_tdev()
360:
361:
362: {
363:
364:
365: char buff[MAX_BUFF]; /* target device name put here */
366:
367:
368: /********************************************************************
369: * *
370: * Called from startchanges() to read the name of the target *
371: * typesetter from *fp_change, and store the result in the array *
372: * tdev[]. If the device has already been specified nothing is *
373: * done. *
374: * *
375: ********************************************************************/
376:
377:
378: if ( fscanf(fp_change, " device %s", buff) != 1 )
379: error(FATAL, "missing target device name");
380:
381: if ( strlen(buff) > DNAME )
382: error(FATAL, "target device name %s too long", buff);
383:
384: if ( *tdev != '\0' )
385: strcpy(tdev, buff);
386:
387: } /* End of get_tdev */
388:
389:
390: /*****************************************************************************/
391:
392:
393: get_int(fp, num)
394:
395:
396: FILE *fp; /* read an integer from this file */
397: int *num; /* and store it here */
398:
399:
400: {
401:
402:
403: /********************************************************************
404: * *
405: * Called to read an integer from the input file and store the *
406: * result in num - this routine and get_float() really should be *
407: * macros. *
408: * *
409: ********************************************************************/
410:
411:
412: if ( fscanf(fp, "%d", num) != 1 )
413: error(FATAL, "syntax error - integer not found");
414:
415: } /* End of get_int */
416:
417:
418: /*****************************************************************************/
419:
420:
421: get_float(fp, num)
422:
423:
424: FILE *fp; /* read a float from this file */
425: float *num; /* and store it here */
426:
427:
428: {
429:
430:
431: /********************************************************************
432: * *
433: * Called to read a floating point number from *fp_change and *
434: * store the result in num. *
435: * *
436: ********************************************************************/
437:
438:
439: if ( fscanf(fp, "%f", num) != 1 )
440: error(FATAL, "syntax error - floating point number not found");
441:
442: } /* End of get_float */
443:
444:
445: /*****************************************************************************/
446:
447:
448: get_sizes()
449:
450:
451: {
452:
453:
454: int i; /* index into sizes[] array */
455:
456:
457: /********************************************************************
458: * *
459: * Called from startchanges() to read the new default point *
460: * size list for the DESC file. The format expected for the size *
461: * list in the *fp_change file is the same as in the ASCII DESC *
462: * file. *
463: * *
464: ********************************************************************/
465:
466:
467: i = 0;
468:
469: while ( i < SIZE_LENGTH ) {
470:
471: while ( isspace(sizes[i++] = getc(fp_change)) ) ;
472:
473: if ( !isdigit(sizes[i-1]) )
474: error(FATAL, "syntax error - bad point size list");
475:
476: if ( sizes[i-1] == '0' && (isspace(sizes[i++] = getc(fp_change))) ) {
477: sizes[i-1] = '\0';
478: return;
479: } /* End if */
480:
481: while ( isdigit(sizes[i++] = getc(fp_change)) ) ;
482:
483: } /* End while */
484:
485: error(FATAL, "point size list too long"); /* shouldn't get here */
486:
487: } /* End of get_sizes */
488:
489:
490: /*****************************************************************************/
491:
492:
493: get_fonts()
494:
495:
496: {
497:
498:
499: int count; /* number of default fonts */
500: int i; /* index used for fonts[] array */
501:
502:
503: /********************************************************************
504: * *
505: * Called from startchanges() to read a new default font list *
506: * for the new DESC file. Again the format expected for the font *
507: * list is the same as in the ASCII DESC file. *
508: * *
509: ********************************************************************/
510:
511:
512: count = -1; /* real value is the first string */
513: i = 0; /* next character goes here */
514:
515: do {
516:
517: while ( isspace(fonts[i++] = getc(fp_changes)) ) ;
518:
519: while ( !isspace(fonts[i++] = getc(fp_changes)) ) ;
520:
521: if ( count < 0 ) /* string is the default font count */
522: count = atoi(fonts);
523:
524: } while ( count-- > 0 );
525:
526: fonts[i-1] = '\0';
527:
528: } /* End of get_fonts */
529:
530:
531: /*****************************************************************************/
532:
533:
534: getdesc()
535:
536:
537: {
538:
539:
540: int fin; /* DESC.out's file descriptor */
541: char *filebase; /* memory block for DESC.out file */
542: char *malloc(); /* memory allocation routine */
543:
544:
545: /********************************************************************
546: * *
547: * Called from the main program to read the DESC.out file for *
548: * *mdev. Most of the file is only needed if we are going to do *
549: * the width lookups in the raster tables, but anyway we'll read *
550: * the whole thing in. *
551: * *
552: ********************************************************************/
553:
554:
555: sprintf(path, "%s/dev%s/DESC.out", fontdir, mdev);
556: if ( (fin = open(path, 0)) < 0 )
557: error(FATAL, "can't open file %s", path);
558:
559: read(fin, &dev, sizeof(struct dev)); /* struct dev comes first */
560:
561: nchtab = dev.nchtab;
562:
563: if ( (filebase = malloc(dev.filesize)) == NULL )
564: error(FATAL, "no memory available");
565:
566: read(fin, filebase, dev.filesize); /* get rest of the DESC.out file */
567: pstab = (short *) filebase; /* this table is never used */
568: chtab = pstab + dev.nsizes + 1;
569: chname = (char *) (chtab + dev.nchtab);
570:
571: close(fin); /* won't need this guy again */
572:
573: } /* End of getdesc */
574:
575:
576: /*****************************************************************************/
577:
578:
579: makedesc()
580:
581:
582: {
583:
584:
585: char buff[MAX_BUFF]; /* input strings are put here */
586: int ch; /* used in skipping over comments */
587: int temp; /* used to skip font and point sizes */
588:
589:
590: /********************************************************************
591: * *
592: * Called from the main program to make the new ASCII DESC *
593: * file for *tdev. *
594: * *
595: ********************************************************************/
596:
597:
598: sprintf(path, "%s/dev%s/DESC", srcdir, mdev);
599: if ( (fp_in = fopen(path, "r")) == NULL )
600: error(FATAL, "can't read file %s", path);
601:
602: if ( (fp_out = fopen("DESC", "w")) == NULL )
603: error(FATAL, "can't write new DESC file");
604:
605: while ( fscanf(fp_in, "%s", buff) != EOF ) {
606:
607: fprintf(fp_out, "%s", buff);
608: if ( strcmp(buff, "res") == 0 )
609: new_value(RES);
610: else if ( strcmp(buff, "hor") == 0 )
611: new_value(HOR);
612: else if ( strcmp(buff, "vert") == 0 )
613: new_value(VERT);
614: else if ( strcmp(buff, "unitwidth") == 0 )
615: new_value(UNIT);
616: else if ( strcmp(buff, "paperwidth") == 0 )
617: new_value(WIDTH);
618: else if ( strcmp(buff, "paperlength") == 0 )
619: new_value(LENGTH);
620: else if ( strcmp(buff, "fonts") == 0 && fonts[0] ) {
621: fprintf(fp_out, "%s\n", fonts);
622: get_int(fp_in, &temp);
623: while ( temp-- > 0 )
624: fscanf(fp_in, "%s", buff);
625: } else if ( strcmp(buff, "sizes") == 0 && sizes[0] ) {
626: fprintf(fp_out, "%s\n", sizes);
627: do {
628: get_int(fp_in, &temp);
629: } while ( temp != 0 );
630: } else if ( strcmp(buff, "charset") == 0 )
631: while ( (ch = getc(fp_in)) != EOF ) putc(ch, fp_out);
632: else copy_line();
633:
634: } /* End while */
635:
636: fclose(fp_in);
637: fclose(fp_out);
638:
639: } /* End of makedesc */
640:
641:
642: /*****************************************************************************/
643:
644:
645: new_value(value)
646:
647:
648: int value; /* used in the switch statement */
649:
650:
651: {
652:
653:
654: int temp; /* next number read from *fp_in */
655:
656:
657: /********************************************************************
658: * *
659: * Called from makedesc() to write a new value out to the DESC *
660: * file for the parameter specified by value. *
661: * *
662: ********************************************************************/
663:
664:
665: get_int(fp_in, &temp);
666:
667: switch ( value ) {
668:
669: case RES:
670: if ( res == NOT_SET )
671: if ( dflt_chng == NOT_SET ) {
672: res = temp;
673: dflt_chng = 0.0;
674: } else res = temp / (1 + dflt_chng);
675: temp = res;
676: break;
677:
678: case UNIT:
679: if ( unitwidth == NOT_SET )
680: unitwidth = temp;
681: temp = unitwidth;
682: break;
683:
684: case HOR:
685: if ( hor == NOT_SET )
686: hor = temp;
687: temp = hor;
688: break;
689:
690: case VERT:
691: if ( vert == NOT_SET )
692: vert = temp;
693: temp = vert;
694: break;
695:
696: case WIDTH:
697: case LENGTH:
698: temp = (temp * res) / dev.res;
699: break;
700:
701: } /* End switch */
702:
703: fprintf(fp_out, " %d\n", temp);
704:
705: } /* End of new_value */
706:
707:
708: /*****************************************************************************/
709:
710:
711: finishchanges()
712:
713:
714: {
715:
716:
717: char buff[MAX_BUFF];
718: int ch;
719: int i;
720:
721:
722: /********************************************************************
723: * *
724: * Called from startchanges() to process all the new font *
725: * commands. *
726: * *
727: ********************************************************************/
728:
729:
730: nextfont(); /* do initialization for next font */
731:
732: while ( fscanf(fp_change, "%s", buff ) != EOF ) {
733:
734: if ( strcmp(buff, "font") == 0 ) {
735: makefont();
736: nextfont();
737: } else if ( strcmp(buff, "increment") == 0 ) {
738: if ( fscanf(fp_change, "%s by ", buff) != 1 )
739: error(FATAL, "syntax error - bad file format");
740: if ( strlen(buff) > CNAME )
741: error(FATAL, "special char %s too long", buff);
742: i = lookup(buff);
743: get_float(fp_change, &incrs[i]);
744: if ( i == dcount ) {
745: deltas[dcount] = NOT_SET;
746: strcpy(&names[dcount++][0], buff);
747: } /* End if */
748: } else if ( strcmp(buff, "change") == 0 ) {
749: if ( fscanf(fp_change, "%s by ", buff) != 1 )
750: error(FATAL, "syntax error - bad file format");
751: if ( strcmp(buff, "widths") == 0 )
752: get_float(fp_change, &font_chng);
753: else {
754: if ( strlen(buff) > CNAME )
755: error(FATAL, "special char %s too long", buff);
756: i = lookup(buff);
757: get_float(fp_change, &deltas[i]);
758: if ( i == dcount ) {
759: incrs[dcount] = 0;
760: strcpy(&names[dcount++][0], buff);
761: } /* End if */
762: } /* End else */
763: } else if ( buff[0] == '#' )
764: while ( (ch = getc(fp_change)) != '\n' && ch != EOF ) ;
765:
766: } /* End while */
767:
768: makefont();
769:
770: } /* End of finishchanges */
771:
772:
773: /*****************************************************************************/
774:
775:
776: nextfont()
777:
778:
779: {
780:
781:
782: /********************************************************************
783: * *
784: * Called from finishchanges() to get the name of the next *
785: * font and do any other initialization that may be required. *
786: * *
787: ********************************************************************/
788:
789:
790: fscanf(fp_change, "%s", cur_font); /* name of the next font */
791:
792: font_chng = NOT_SET;
793: incr = dflt_incr;
794: dcount = 0;
795:
796: if ( scale == NOT_SET )
797: if ( use_rast == TRUE )
798: scale = 1.0;
799: else scale = ( float )(res * unitwidth) / (dev.res * dev.unitwidth);
800:
801: } /* End of nextfont */
802:
803:
804: /*****************************************************************************/
805:
806:
807: makefont()
808:
809:
810: {
811:
812:
813: char buff[MAX_BUFF]; /* temp buffer for *fp_change reads */
814:
815:
816: /********************************************************************
817: * *
818: * This routine makes all the new ASCII font files. *
819: * *
820: ********************************************************************/
821:
822:
823: sprintf(path, "%s/dev%s/%s", srcdir, mdev, cur_font);
824: if ( (fp_in = fopen(path, "r")) == NULL )
825: error(FATAL, "can't open font file %s", path);
826:
827: if ( (fp_out = fopen(cur_font, "w")) == NULL )
828: error(FATAL, "can't open output font file %s", cur_font);
829:
830: while ( fscanf(fp_in, "%s", buff) != EOF ) {
831:
832: fprintf(fp_out, "%s", buff); /* echo what we just read in */
833: if ( strcmp(buff, "charset") == 0 )
834: copy_chars();
835: else copy_line();
836:
837: } /* End while */
838:
839: fclose(fp_in); /* done with these files for now */
840: fclose(fp_out);
841:
842: } /* End of makefont */
843:
844:
845: /*****************************************************************************/
846:
847:
848: copy_chars()
849:
850:
851: {
852:
853:
854: char ch[10]; /* standard stuff from makedev */
855: char width[10];
856: char kern[10];
857: char code[10];
858: char buff[LINE_LENGTH]; /* next line from charset part */
859:
860:
861: /********************************************************************
862: * *
863: * Called from makefont() to copy the charset portion of the *
864: * current font file to the output file. The width entry for each *
865: * character will be adjusted by routine newwidth(). *
866: * *
867: ********************************************************************/
868:
869:
870: putc('\n', fp_out);
871:
872: while ( fgets(buff, sizeof(buff), fp_in) != NULL ) {
873:
874: if ( sscanf(buff, "%s %s %s %s", ch, width, kern, code) < 2 )
875: continue;
876:
877: if ( width[0] == '"' ) { /* it's a synonym */
878: fprintf(fp_out, "%s", buff);
879: continue;
880: } /* End if */
881:
882: newwidth(ch, width); /* calculate *ch's new width */
883:
884: fprintf(fp_out, "%s\t%s\t%s\t%s\n", ch, width, kern, code);
885:
886: } /* End while */
887:
888: } /* End of copy_chars */
889:
890:
891: /*****************************************************************************/
892:
893:
894: copy_line()
895:
896:
897: {
898:
899:
900: int ch;
901:
902:
903: /********************************************************************
904: * *
905: * Called from makefont() to copy the current line from fp_in *
906: * to fp_out. *
907: * *
908: ********************************************************************/
909:
910:
911: while ( (ch = putc(getc(fp_in), fp_out)) != '\n' && ch != EOF ) ;
912:
913: } /* End of copy_line */
914:
915:
916: /*****************************************************************************/
917:
918:
919: newwidth(ch, width)
920:
921:
922: char *ch; /* get the width for this character */
923: char *width; /* and store it here */
924:
925:
926: {
927:
928:
929: int newwidth; /* character's new width */
930: float cwidth; /* char's current width */
931: float delta; /* width change for the character */
932:
933: float getdelta();
934: float atof();
935:
936:
937: /********************************************************************
938: * *
939: * Called from copy_chars() to get the new width for character *
940: * ch, and store the ASCII representation for it in array width[]. *
941: * If we are supposed to be getting the character widths from the *
942: * raster tables we call getwidth() to do the work, otherwise we *
943: * use the value obtained from the ASCII font file. *
944: * *
945: ********************************************************************/
946:
947:
948: if ( use_rast == TRUE )
949: cwidth = getwidth(ch);
950: else cwidth = atof(width);
951:
952: delta = getdelta(ch);
953:
954: if ( (newwidth = cwidth * (1 + delta) * scale + incr) < 0 || newwidth > BMASK )
955: error(FATAL, "bad width %d for char %s", newwidth, ch);
956:
957: sprintf(width, "%d", newwidth);
958:
959: } /* End of newwidth */
960:
961:
962: /*****************************************************************************/
963:
964:
965: getwidth(ch)
966:
967:
968: char *ch; /* get raster width for this char */
969:
970:
971: {
972:
973:
974: /********************************************************************
975: * *
976: * Called from newwidth() to get the raster table width for *
977: * character ch form the raster table for the current font and in *
978: * size unitwidth. *
979: * *
980: ********************************************************************/
981:
982:
983: return(1);
984:
985: } /* End of getwidth */
986:
987:
988: /*****************************************************************************/
989:
990:
991: float getdelta(ch)
992:
993:
994: char *ch; /* get change for this char */
995:
996:
997: {
998:
999:
1000: int i;
1001: float change;
1002:
1003:
1004: /********************************************************************
1005: * *
1006: * This routine gets the appropriate change in width that we *
1007: * should use for character ch in the new font table. *
1008: * *
1009: ********************************************************************/
1010:
1011:
1012: change = font_chng == NOT_SET ? dflt_chng : font_chng;
1013: incr = dflt_incr;
1014:
1015: if ( (i = lookup(ch)) < dcount ) {
1016: change = ( deltas[i] == NOT_SET ) ? change : deltas[i];
1017: incr += incrs[i];
1018: } /* End if */
1019:
1020: return(change);
1021:
1022: } /* End of getdelta */
1023:
1024:
1025: /*****************************************************************************/
1026:
1027:
1028: lookup(ch)
1029:
1030:
1031: char *ch; /* look this character string up */
1032:
1033:
1034: {
1035:
1036:
1037: int i;
1038:
1039:
1040: /********************************************************************
1041: * *
1042: * Called from finishchanges() to find the character string *
1043: * *ch in array names[]. If it isn't found dcount is returnd. *
1044: * *
1045: ********************************************************************/
1046:
1047:
1048: for ( i = 0; i < dcount; i++ )
1049: if ( strcmp(ch, &names[i][0]) == 0 )
1050: break;
1051:
1052: return(i);
1053:
1054: } /* End of lookup */
1055:
1056:
1057: /*****************************************************************************/
1058:
1059:
1060: error(kind, mesg, arg1, arg2)
1061:
1062:
1063: int kind; /* FATAL or NON_FATAL error */
1064: char *mesg; /* error message to be printed */
1065:
1066:
1067: {
1068:
1069:
1070: /********************************************************************
1071: * *
1072: * Write out the error message *mesg, and quit the program if *
1073: * kind is FATAL. *
1074: * *
1075: ********************************************************************/
1076:
1077:
1078: fprintf(stderr, "makefonts: ");
1079: fprintf(stderr, mesg, arg1, arg2);
1080: fprintf(stderr, "\n");
1081:
1082: if ( kind == FATAL )
1083: exit(1);
1084:
1085: } /* End of error */
1086:
1087:
1088: /*****************************************************************************/
1089:
1090:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.