![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to buildrast.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / dimpress|
Return to buildrast.c CVS log | Up to [Research Unix] / researchv10no / cmd / dimpress |
1.1 root 1:
2:
3: /*
4: *
5: * Reads specially formatted ASCII files, called control files, and uses
6: * them to build raster and font files that can be used by troff and its
7: * post-processors. The program reads raster files in Imagen's format from
8: * directory *rastdir and uses them, along with the information in the
9: * the control files to build new raster files and also font and device
10: * files for troff. The ASCII control files must list a target device.
11: * The new raster files will be put in directory *nrastdir/"rast"*device
12: * and the new font files will go in *fontdir/"dev"*device.
13: *
14: * Individual fonts or sizes can be selected using the -f and -s options.
15: * If they're not used all the font 'build' sections in the ASCII control
16: * files will be processed for all the sizes listed under 'sizes'. ASCII
17: * files will only be built when the current size is equal to the value
18: * set in unitwidth.
19: *
20: * The raster source, new raster, and new font directories can be selected
21: * using options -S, -R, and -F respectively. By default they're all set to
22: * ".".
23: *
24: * As an example I used this program and the RASTi300 file to build the
25: * tables in this package. The command line was,
26: *
27: *
28: * buildrast -S /usr/spool/imagen_src/fonts/raster/300 RASTi300
29: *
30: *
31: * The original raster files that we got from Imagen were kept in directory
32: * /usr/spool/imagen_src/fonts/raster/300.
33: *
34: */
35:
36:
37: #include <stdio.h>
38: #include <ctype.h>
39: #include <fcntl.h>
40:
41: #include "gen.h" /* general purpose definitions */
42: #include "ext.h" /* external variable declarations */
43: #include "init.h" /* printer and system definitions */
44: #include "rast.h" /* raster file definitions */
45: #include "buildrast.h" /* definitions for building files */
46:
47:
48: char *nrastdir = "."; /* new raster files go here - sort of */
49:
50: FILE *fp_in; /* current ASCII control file */
51: char buff[100]; /* buffer for reads from fp_in */
52:
53: int dodesc = ON; /* build troff's DESC file? */
54: int gotspecial = FALSE; /* recorded all special characters */
55: int dofont = ON; /* same but for ASCII font files */
56:
57: char device[20] = ""; /* everything's built for this printer */
58:
59: Charset charset[256]; /* records all special character names */
60: char *fontlist[50]; /* only do stuff for these fonts */
61: int sizelist[50]; /* and these point sizes */
62: int unitwidth = -1; /* troff tables built from this size */
63: int res = -1; /* target device's resolution */
64: char ligatures[50]; /* ligatures strings stored here */
65: char comment[100]; /* comments for each font */
66: int internalname = 1; /* for troff's ASCII font files */
67: int isspecial = FALSE; /* is this a special font */
68: char ascender[10]; /* used to get ascender data */
69: char spacechar[10]; /* spacewidth = width of this character */
70: int spacewidth = -1; /* it's index in charinfo[] */
71:
72: int above; /* has an ascender if yref > above */
73: int below; /* used to set descender value */
74:
75: int charcount = 0; /* number of chars in charset[] */
76: int fontcount = 0; /* number of entries in fonts[] */
77: int sizecount = 0; /* same but for sizelist[] */
78:
79: int first = 1; /* glyph number endpoints */
80: int last = 0;
81:
82: int fontoutput; /* process current font if ON */
83:
84: char glyphdir[GLYDIR_SIZE]; /* new raster file glyph directory */
85: Charinfo charinfo[MAX_INDEX+1]; /* data about characters in new font */
86:
87:
88: /*****************************************************************************/
89:
90:
91: main(agc, agv)
92:
93:
94: int agc;
95: char *agv[];
96:
97:
98: {
99:
100:
101: /*
102: *
103: * Builds raster tables and troff's ASCII files from Imagen supplied raster
104: * files in directory *rastdir. All this stuff is done under the control of
105: * specially formatted ASCII files which are named as command line arguments.
106: * The source raster files are found in *rastdir, which can be changed using
107: * the -S option.
108: *
109: */
110:
111:
112: argc = agc; /* other routines may want them */
113: argv = agv;
114:
115: prog_name = argv[0]; /* really just for error messages */
116:
117: rastdir = "."; /* source raster file directory */
118: nrastdir = "."; /* new raster file directory */
119: fontdir = "."; /* font directory for new files */
120:
121: options(); /* first get command line options */
122: arguments(); /* then process non-option arguments */
123:
124: exit(x_stat); /* everything probably went OK */
125:
126: } /* End of main */
127:
128:
129: /*****************************************************************************/
130:
131:
132: options()
133:
134:
135: {
136:
137:
138: int ch; /* return value from getopt() */
139: char *names = "DIF:R:S:s:r:u:f:d";
140:
141: extern char *optarg; /* used by getopt() */
142: extern int optind;
143:
144:
145: /*
146: *
147: * Reads and processes the command line options. Right now the recognized
148: * options are,
149: *
150: */
151:
152:
153: while ( (ch = getopt(argc, argv, names)) != EOF ) {
154:
155: switch ( ch ) {
156:
157: case 'r': /* set device resolution */
158: res = atoi(optarg);
159: break;
160:
161: case 'u': /* font table unitwidth */
162: unitwidth = atoi(optarg);
163: break;
164:
165: case 's': /* do stuff for these sizes only */
166: get_sizes(optarg);
167: break;
168:
169: case 'f': /* and these fonts */
170: get_fonts(optarg);
171: break;
172:
173: case 'd': /* don't build troff's DESC file */
174: dodesc = OFF;
175: break;
176:
177: case 'F': /* new troff font directory */
178: fontdir = optarg;
179: break;
180:
181: case 'R': /* directory for new raster files */
182: nrastdir = optarg;
183: break;
184:
185: case 'S': /* source raster files found here */
186: rastdir = optarg;
187: break;
188:
189: case 'D': /* debug flag */
190: debug = ON;
191: break;
192:
193: case 'I': /* ignore FATAL errors */
194: ignore = ON;
195: break;
196:
197: case '?': /* don't understand the option */
198: error(FATAL, "");
199: break;
200:
201: default: /* don't know what to do for ch */
202: error(FATAL, "missing case for option %c\n", ch);
203: break;
204:
205: } /* End switch */
206:
207: } /* End while */
208:
209: argc -= optind; /* get ready for non-option args */
210: argv += optind;
211:
212: } /* End of options */
213:
214:
215: /*****************************************************************************/
216:
217:
218: get_sizes(str)
219:
220:
221: char *str; /* comma or blank spearated size list */
222:
223:
224: {
225:
226:
227: char *tok; /* next token in *str */
228:
229: char *strtok();
230:
231:
232: /*
233: *
234: * Converts a comma or blank separated list of point sizes to integers
235: * and stores the results in sizelist[]. Used to control how many of the
236: * raster files are built. If the -s options isn't used to select point
237: * sizes, raster files for all the sizes listed in the ASCII control files
238: * will be built.
239: *
240: */
241:
242:
243: while ( (tok = strtok(str, " ,")) != NULL ) {
244: sizelist[sizecount++] = atoi(tok);
245: str = NULL;
246: } /* End while */
247:
248: } /* End of get_sizes */
249:
250:
251: /*****************************************************************************/
252:
253:
254: get_fonts(str)
255:
256:
257: char *str; /* list of fonts to process */
258:
259:
260: {
261:
262:
263: char *tok; /* next font name from *str */
264:
265:
266: /*
267: *
268: * Called from options() to convert a comma or blank separated list of
269: * font names into pointers that can be stored in fontlist[]. Overrides
270: * the selection of fonts listed in the ASCII control files.
271: *
272: */
273:
274:
275: while ( (tok = strtok(str, " ,")) != NULL ) {
276: fontlist[fontcount++] = tok;
277: str = NULL;
278: } /* End while */
279:
280: } /* End of get_fonts */
281:
282:
283: /*****************************************************************************/
284:
285:
286: arguments()
287:
288:
289: {
290:
291:
292: /*
293: *
294: * All the rest of the comand line arguments are the names of ASCII control
295: * files. If there are no arguments left when we get here stdin will be
296: * read.
297: *
298: * Although the program accepts more than one control file name, I haven't
299: * really tested things using several control files. Probably needs more
300: * some more work.
301: *
302: */
303:
304:
305: if ( argc < 1 ) {
306: fp_in = stdin;
307: readcontrol();
308: } else {
309: while ( argc > 0 ) {
310: if ( (fp_in = fopen(*argv, "r")) == NULL )
311: error(FATAL, "can't open %s", *argv);
312: readcontrol();
313: fclose(fp_in);
314: argc--;
315: argv++;
316: } /* End while */
317: } /* End else */
318:
319: } /* End of arguments */
320:
321:
322: /*****************************************************************************/
323:
324:
325: readcontrol()
326:
327:
328: {
329:
330:
331: long pos; /* where build section starts in fp_in */
332: int i; /* loop index for sizelist[] */
333:
334:
335: /*
336: *
337: * Starts reading the ASCII description file fp_in. The stuff at the
338: * beginning is primarily for the DESC file and is just skipped, although
339: * the sizes, res, and unitwidth fields are used if the values haven't been
340: * set by options. Lines are read and processed by this routine until
341: * EOF is reached or the first build command is found. If we process the
342: * first part of the file and don't have res, unitwidth, and sizecount set
343: * an error message will be printed and we'll quit.
344: *
345: * After we break out of the first while loop, usually because a 'build'
346: * command was read, we record our position in file *fp_in and then enter
347: * a for loop that processes the rest of the file - once for each of the
348: * requested sizes. gotspecial controls whether we record special character
349: * names for the DESC file. We only need to do it on the first complete read
350: * of file *fp_in.
351: *
352: */
353:
354:
355: while ( fscanf(fp_in, "%s", buff) != EOF )
356: if ( sizecount <= 0 && strcmp(buff, "sizes") == 0 ) {
357: while ( fscanf(fp_in, "%d", &sizelist[sizecount]) == 1 && sizelist[sizecount] != 0 )
358: sizecount++;
359: } else if ( unitwidth <= 0 && strcmp(buff, "unitwidth") == 0 )
360: fscanf(fp_in, "%d", &unitwidth);
361: else if ( res <= 0 && strcmp(buff, "res") == 0 )
362: fscanf(fp_in, "%d", &res);
363: else if ( strcmp(buff, "device") == 0 )
364: fscanf(fp_in, "%s", device);
365: else if ( strcmp(buff, "build") == 0 )
366: break;
367: else skipline(fp_in);
368:
369: if ( res <= 0 || unitwidth <= 0 || sizecount <= 0 )
370: error(FATAL, "Missing res, unitwidth, or size specification");
371:
372: if ( device[0] == '\0' )
373: error(FATAL, "no device name given");
374:
375: pos = (long) ftell(fp_in); /* probably want to get back here */
376:
377: for ( i = 0; i < sizecount; i++ ) {
378: build(sizelist[i]);
379: fseek(fp_in, pos, 0);
380: gotspecial = TRUE;
381: } /* End for */
382:
383: builddesc();
384: rastdata();
385:
386: } /* End of readcontrol */
387:
388:
389: /*****************************************************************************/
390:
391:
392: build(size)
393:
394:
395: int size; /* building files for this size */
396:
397:
398: {
399:
400:
401: char name[40]; /* name of font we're building */
402: char *ptr; /* used to pick up font comment field */
403: int i, n; /* used for font size selection */
404: int lsize; /* last valid size in font size list */
405: int osize; /* original size - reset in the loop */
406:
407:
408: /*
409: *
410: * Called from readcontrol() when we want to build font and raster files. At the
411: * top of the main loop we've read a 'build' command but haven't processed the
412: * name of the font yet. Once we get the name we initialize some variables,
413: * throw out all raster files we may already have read, skip the rest of the
414: * current line in *fp_in, and then enter a loop that processes all the
415: * allowed commands in a build section. The most important of these commands
416: * is 'using', which allows us to select particular characters from named
417: * raster files. It's assumed that we're finished with the current build
418: * section when we return from using() or when we read another 'build'
419: * command. When we exit the inner loop we're ready to build the new
420: * raster file. If size == unitwidth we'll also want to construct an ASCII
421: * font file for font *name.
422: *
423: * Actually that's not quite right. I've added code, that's really not very
424: * clear, that handles fonts with less than a complete set of raster files.
425: * Although much of the stuff can be done by hand, I think it's important
426: * to have buildrast handle everything. Logos will usually come in only
427: * one size and we may eventually want to add more logos to the raster file.
428: * That in itself would be difficult to do by hand, and adding more font
429: * font positions isn't all that clean either. There are a bunch of other
430: * ways it could have been handled, but I think adding the code to buildrast
431: * was the best choice. Fonts that don't come in all the sizes are described
432: * in the 'build' section by a command that looks like,
433: *
434: * sizes 12 18 36 0
435: *
436: * This lists the point sizes that are available for building the font.
437: * All output will only be turned OFF unless the size that we're currently
438: * working on is in the list. The sizes can come in any order as long as
439: * the list is terminated by 0. The ASCII font files are built when the
440: * current size is equal to the first size in the list. Widths are properly
441: * scaled to the correct unitwidth. The ascender and descender stuff also
442: * had to be changed.
443: *
444: * Turning the output OFF when a given size wasn't available turned out
445: * to be tricky, and that's where lsize is used. If the size isn't available
446: * we'll still have work to do in addition to reading the file, especially
447: * the first time through. So all the stuff works properly I set size to
448: * lsize before going on to the 'using' section. It's a kludge but the
449: * raster files should be available in lsize even if we're not building
450: * any files. Anyway that's sort of what's happening in the new stuff.
451: *
452: */
453:
454:
455: osize = size; /* in case we change size */
456:
457: while ( fscanf(fp_in, "%s", name) != EOF ) {
458: fontoutput = wantfont(name);
459: size = osize;
460: first = 1;
461: last = 0;
462: comment[0] = '\0';
463: ligatures[0] = '\0';
464: ascender[0] = '\0';
465: spacechar[0] = '\0';
466: spacewidth = -1;
467: isspecial = FALSE;
468: dofont = (size == unitwidth) ? ON : OFF;
469: resetrast();
470: skipline(fp_in);
471: while ( fscanf(fp_in, "%s", buff) != EOF )
472: if ( strcmp(buff, "using") == 0 ) {
473: using(name, size);
474: break;
475: } else if ( strcmp(buff, "build") == 0 )
476: break;
477: else if ( strcmp(buff, "special") == 0 )
478: isspecial = TRUE;
479: else if ( strcmp(buff, "ascender") == 0 )
480: fscanf(fp_in, "%s", ascender);
481: else if ( strcmp(buff, "spacewidth") == 0 )
482: fscanf(fp_in, "%s", spacechar);
483: else if ( strcmp(buff, "start") == 0 ) {
484: fscanf(fp_in, "%d", &first);
485: last = first - 1;
486: } else if ( strcmp(buff, "sizes") == 0 ) {
487: for ( i = 0, lsize = 0; fscanf(fp_in, "%d", &n) == 1 && n != 0 && n != size; i++, lsize = n ) ;
488: lsize = (lsize == 0 ) ? n : lsize;
489: fontoutput = (fontoutput == ON && n == size) ? ON : OFF;
490: dofont = (fontoutput == ON && i == 0 ) ? ON : OFF;
491: size = (fontoutput == ON) ? size : lsize;
492: skipline(fp_in);
493: } else if ( strcmp(buff, "comment") == 0 ) {
494: for ( ptr = comment; (*ptr = getc(fp_in)) != '\n' && *ptr != EOF; ptr++ ) ;
495: *ptr = '\0';
496: } else if ( buff[0] == '#' )
497: skipline(fp_in);
498: else error(FATAL, "don't understand command %s", buff);
499: writerast(name, size);
500: buildfont(name, size);
501: } /* End while */
502:
503: } /* End of build */
504:
505:
506: /*****************************************************************************/
507:
508:
509: using(name, size)
510:
511:
512: char name[]; /* building things for this font */
513: int size; /* and in this size */
514:
515:
516: {
517:
518:
519: char chname[10]; /* special character name */
520:
521:
522: /*
523: *
524: * Called after we've read a 'using' command. The input file is read until
525: * we reach EOF of find another build command. The format of a 'using' command
526: * can be either,
527: *
528: * using name take ascii characters n to m
529: *
530: * or,
531: *
532: * using name take characters
533: * 12 fl
534: * 13 ff
535: * 103 *a
536: *
537: *
538: * where name refers to one of the raster files in *rastdir. It's assumed
539: * that the ascii characters n to m are in positions n to m in raster file
540: * name. If that's not the case the more general form given in the second
541: * example should be used. That's also the form that will be needed for troff's
542: * special characters.
543: *
544: * Synonyms are also allowed and can be specified by having the character
545: * '"' in the first index field as the following example illustrates.
546: *
547: * using name take characters
548: * 38 &
549: * 39 aa
550: * " '
551: * 119 14
552: * " 34
553: * " 12
554: * 91 [
555: *
556: * The list of synonyms for a particular character is recorded in the
557: * Charinfo structure for that character and is only used when we build the
558: * ASCII font files.
559: *
560: * There can be as many 'using' commands for a particular font as you want
561: * and you can intermix the two formats. We'll continue building the current
562: * raster file up until we find another 'build' command or reach EOF.
563: *
564: */
565:
566:
567: if ( fontoutput == ON )
568: fprintf(stdout, "Building tables for %s size %d\n", name, size);
569:
570: while ( fscanf(fp_in, "%s", buff) != EOF ) {
571: getrastdata(buff, size);
572:
573: if ( fscanf(fp_in, " take %s", buff) != 1 )
574: error(FATAL, "syntax error in using()");
575:
576: if ( strcmp(buff, "ascii") == 0 )
577: getascii();
578:
579: skipline(fp_in);
580: while ( fscanf(fp_in, "%s", buff) != EOF ) {
581: if ( isdigit(buff[0]) ) {
582: fscanf(fp_in, "%s", chname);
583: recordchar(chname, atoi(buff));
584: } else if ( buff[0] == '"' )
585: getsynonym();
586: else if ( strcmp(buff, "using") == 0 )
587: break;
588: else if ( strcmp(buff, "build") == 0 )
589: return;
590: else if ( strcmp(buff, "edit") == 0 ) {
591: skipline(fp_in);
592: edit(fp_in);
593: return;
594: } else if ( buff[0] == '#' )
595: skipline(fp_in);
596: else error(FATAL, "don't understand command %s", buff);
597: } /* End while */
598: } /* End while */
599:
600: } /* End of using */
601:
602:
603: /*****************************************************************************/
604:
605:
606: getascii()
607:
608:
609: {
610:
611:
612: int start; /* first character's ASCII code */
613: int stop; /* last character's code */
614: char name[2]; /* name of the character - string */
615:
616:
617: /*
618: *
619: * Called when we want to take a bunch of ASCII characters from the current
620: * raster file. As I mentioned before the expected format is,
621: *
622: * using name take ascii characters start to stop
623: *
624: * where name is the name of the raster file we want to use, while start
625: * and stop and the indices of the ASCII characters we want to steal from
626: * font name. Obviously start should be less than or equal to stop otherwise
627: * nothing will be done.
628: *
629: */
630:
631:
632: if ( fscanf(fp_in, "%*s %d to %d", &start, &stop) != 2 )
633: error(FATAL, "syntax error in getascii()");
634:
635: name[1] = '\0'; /* terminate the string */
636:
637: for ( ; start <= stop; start++ ) {
638: name[0] = start;
639: recordchar(name, start);
640: } /* End for */
641:
642: } /* End of getascii */
643:
644:
645: /*****************************************************************************/
646:
647:
648: recordchar(name, index)
649:
650:
651: char *name; /* name of the character */
652: int index; /* its glyph number in *fam */
653:
654:
655: {
656:
657:
658: char *gptr1, *gptr2; /* glyph directory pointers */
659: int height, width; /* of the bitmap */
660: int i; /* used to copy directory entry */
661:
662:
663: /*
664: *
665: * Called when we want to record information about character *name. Its
666: * number in the current raster file is index. Most of the information about
667: * the character is stored in charinfo[++last]. We'll need to remember its
668: * name, pointer to its bitmap, size of the bitmap, and pointer to the new
669: * glyph directory entry. Data about the bitmap comes directly from the glyph
670: * directory entry for character index. The pointer to the new glyph directory
671: * entry is figured out from the current values of first and last. Each entry
672: * in the directory is 15 bytes long, and all we do is copy index's entry
673: * over to the new character's entry. All that really has to be fixed up
674: * is the bitmap pointer, and this guy is figured out in writerast() when
675: * we're creating the new raster file.
676: *
677: */
678:
679:
680: if ( ++last > MAX_INDEX )
681: error(FATAL, "too many characters in current raster file");
682:
683: height = getvalue(G_HEIGHT, index);
684: width = getvalue(G_WIDTH, index);
685: gptr1 = fam->rst + GLYPH_PTR(index);
686: gptr2 = glyphdir + (15 * (last - first));
687:
688: strcpy(charinfo[last].name, name);
689: strcpy(charinfo[last].rastname, fam->name);
690: charinfo[last].index = index;
691: charinfo[last].mapsize = ((width + BYTE - 1) / BYTE) * height;
692: charinfo[last].map = fam->rst + getvalue(G_BPTR, index);
693: charinfo[last].glydir = gptr2;
694: charinfo[last].synonyms[0] = '\0';
695: charinfo[last].chwidth = -1;
696:
697: for ( i = 0; i < 15; i++, gptr1++, gptr2++ )
698: *gptr2 = *gptr1;
699:
700: if ( gotspecial == FALSE && dodesc == ON && name[1] != '\0' )
701: specialchar(name);
702:
703: if ( spacechar[0] != '\0' && strcmp(name, spacechar) == 0 )
704: spacewidth = last;
705:
706: } /* End of recordchar */
707:
708:
709: /*****************************************************************************/
710:
711:
712: getsynonym()
713:
714:
715: {
716:
717:
718: char chname[10]; /* character's name built up here */
719:
720:
721: /*
722: *
723: * Called from using() when we've found a '"' in the index field. The
724: * character named next in the input file is a synonym for the one we
725: * just defined (ie. charinfo[last]). We'll add the name to the list of
726: * synonyms for the character and use that list when we build the ASCII
727: * font file.
728: *
729: */
730:
731:
732: if ( last < first ) /* haven't defined anything yet */
733: error(FATAL, "bad synonym request - no characters defined");
734:
735: fscanf(fp_in, "%s", chname);
736:
737: strcat(strcat(charinfo[last].synonyms, " "), chname);
738:
739: if ( gotspecial == FALSE && dodesc == ON && chname[1] != '\0' )
740: specialchar(chname);
741:
742: } /* End of getsynonym */
743:
744:
745: /*****************************************************************************/
746:
747:
748: specialchar(name)
749:
750:
751: char *name; /* keep track of special characters */
752:
753:
754: {
755:
756:
757: int i; /* loop index */
758:
759:
760: /*
761: *
762: * Called to record the special characters we find in the charset[] array.
763: * It's used later on when we build the DESC file. We also keep track of
764: * the ligatures defined on this font (if any), and we'll use this info
765: * when we build the new ASCII font file.
766: *
767: */
768:
769:
770: for ( i = 0; i < charcount; i++ )
771: if ( strcmp(name, charset[i].name) == 0 )
772: break;
773:
774: if ( i >= charcount ) {
775: strcpy(charset[charcount++].name, name);
776: if ( strcmp(name, "fi") == 0 )
777: strcat(ligatures, " fi");
778: else if ( strcmp(name, "ff") == 0 )
779: strcat(ligatures, " ff");
780: else if ( strcmp(name, "fl") == 0 )
781: strcat(ligatures, " fl");
782: else if ( strcmp(name, "Fi") == 0 )
783: strcat(ligatures, " ffi");
784: else if ( strcmp(name, "Fl") == 0 )
785: strcat(ligatures, " ffl");
786: } /* End if */
787:
788: } /* End of specialchar */
789:
790:
791: /*****************************************************************************/
792:
793:
794: writerast(name, size)
795:
796:
797: char *name; /* name of the font */
798: int size; /* in this point size */
799:
800:
801: {
802:
803:
804: int fd; /* new raster file */
805: int presize; /* really preamble + file mark */
806: int dirsize; /* size of glyph directory */
807: int totsize; /* total size of preamble and direc */
808: char *ptr; /* used to change new directory */
809: int offset; /* adjust bitmap pointers */
810: int i; /* loop index */
811:
812:
813: /*
814: *
815: * All the raster file data for *name.size has been collected. This routine
816: * puts it all together and writes everything out to the new raster file.
817: *
818: */
819:
820:
821: if ( fontoutput == OFF ) return; /* not doing output for this font */
822:
823: fam = &fam_data[0];
824: cur_fam = 0;
825:
826: sprintf(buff, "%s/rast%s/%s.%d", nrastdir, device, name, size);
827: if ( (fd = creat(buff, 0644)) == -1)
828: error(FATAL, "can't open %s", buff);
829:
830: presize = 8 + rst[P_LENGTH].size + getvalue(P_LENGTH);
831: dirsize = (last - first + 1) * 15;
832: totsize = presize + dirsize;
833:
834: writevalue(first, P_FIRSTGLY, fam->rst + rst[P_FIRSTGLY].offset);
835: writevalue(last, P_LASTGLY, fam->rst + rst[P_LASTGLY].offset);
836: writevalue(presize, P_GLYDIR, fam->rst + rst[P_GLYDIR].offset);
837:
838: write(fd, fam->rst, presize);
839:
840: for ( ptr = glyphdir + rst[G_BPTR].offset, offset = 0, i = first; i <= last; i++, ptr += 15 ) {
841: writevalue(totsize + offset, G_BPTR, ptr);
842: offset += charinfo[i].mapsize;
843: } /* End for */
844:
845: write(fd, glyphdir, (last - first + 1) * 15);
846:
847: for ( i = first; i <= last; i++ )
848: write(fd, charinfo[i].map, charinfo[i].mapsize);
849:
850: close(fd);
851:
852: } /* End of writerast */
853:
854:
855: /*****************************************************************************/
856:
857:
858: buildfont(font, size)
859:
860:
861: char *font; /* name of troff's font file */
862: int size; /* have data for this point size */
863:
864:
865: {
866:
867:
868: FILE *fp; /* new font file */
869: int i; /* loop index */
870: int chwidth; /* next character's font table width */
871: char *ptr; /* the whole synonym string */
872: char *syn; /* next synonym for current character */
873:
874: char *strtok();
875:
876:
877: /*
878: *
879: * Called to build the ascii font file for the current font. Things are
880: * only done if if the current size is equal to unitwidth.
881: *
882: */
883:
884:
885: if ( fontoutput == OFF || dofont == OFF )
886: return;
887:
888: sprintf(buff, "%s/dev%s/%s", fontdir, device, font);
889: if ( (fp = fopen(buff, "w")) == NULL )
890: error(FATAL, "can't open font file %s", buff);
891:
892: if ( comment[0] != '\0' )
893: fprintf(fp, "#%s\n", comment);
894:
895: fprintf(fp, "name %s\n", font);
896: fprintf(fp, "internalname %d\n", internalname++);
897:
898: if ( isspecial == TRUE )
899: fprintf(fp, "special\n");
900:
901: if ( ligatures[0] != '\0' )
902: fprintf(fp, "ligatures %s 0\n", ligatures);
903:
904: fprintf(fp, "charset\n");
905:
906: if ( isspecial == FALSE ) {
907: fprintf(fp, "\\| %d 0 0\n", (res * unitwidth)/(72 * 6));
908: fprintf(fp, "\\^ %d 0 0\n", (res * unitwidth)/(72 * 12));
909: } /* End if */
910:
911: setascender(size);
912:
913: for ( i = first; i <= last; i++ ) {
914: if ( (chwidth = charinfo[i].chwidth) < 0 ) {
915: chwidth = readvalue(charinfo[i].glydir + rst[G_CHWIDTH].offset, rst[G_CHWIDTH].size, UNSIGNED);
916: chwidth = (PIXEL_WIDTH(chwidth, res) * unitwidth) / size;
917: } /* End if */
918: fprintf(fp, "%s %d %d %d\n", charinfo[i].name, chwidth, getascender(i), i);
919: ptr = charinfo[i].synonyms;
920: while ( (syn = strtok(ptr, " ")) != NULL ) {
921: fprintf(fp, "%s \"\n", syn);
922: ptr = NULL;
923: } /* End while */
924: } /* End for */
925:
926: fclose(fp);
927:
928: } /* End of buildfont */
929:
930:
931: /*****************************************************************************/
932:
933:
934: builddesc()
935:
936:
937: {
938:
939:
940: FILE *fp; /* new desc file */
941: int ch; /* for copying first part of fp_in */
942: int i; /* for loop index for copying charset */
943:
944:
945: /*
946: *
947: * Builds the new DESC file from the data contained in the first part of
948: * the ASCII control file *fp_in and the special characters saved in the
949: * charset[] array.
950: *
951: */
952:
953:
954: if ( dodesc == OFF ) /* don't build new DESC file */
955: return;
956:
957: sprintf(buff, "%s/dev%s/DESC", fontdir, device);
958: if ( (fp = fopen(buff, "w")) == NULL )
959: error(FATAL, "can't open file %s", buff);
960:
961: fseek(fp_in, 0L, 0); /* back to start of control file */
962:
963: while ( fscanf(fp_in, "%s", buff) != EOF )
964: if ( strcmp(buff, "build") == 0 )
965: break;
966: else if ( buff[0] == '#' || strcmp(buff, "device") == 0 )
967: skipline(fp_in);
968: else {
969: fprintf(fp, "%s", buff);
970: while ( (ch = putc(getc(fp_in), fp)) != '\n' && ch != EOF ) ;
971: } /* End else */
972:
973: fprintf(fp, "charset\n");
974: fprintf(fp, "\\| \\^");
975:
976: for ( i = 0; i < charcount; i++ )
977: fprintf(fp, "%c%s", (i % 15 == 13) ? '\n' : ' ', charset[i].name);
978: putc('\n', fp);
979:
980: fclose(fp);
981:
982: } /* End of builddesc */
983:
984:
985: /*****************************************************************************/
986:
987:
988: rastdata()
989:
990:
991: {
992:
993:
994: FILE *fp; /* "RASTDATA" file */
995:
996:
997: /*
998: *
999: * The post-processor and possibly others will need to know the resolution
1000: * and format of the raster files. It's looked for in file "RASTDATA", which
1001: * is defined in file init.h. Anyway this routine makes sure a reasonable
1002: * data file goes along with all the raster files we just built.
1003: *
1004: */
1005:
1006:
1007: sprintf(buff, "%s/rast%s/%s", nrastdir, device, RASTDATA);
1008: if ( (fp = fopen(buff, "w")) == NULL )
1009: error(FATAL, "can't write file %s", buff);
1010:
1011: fprintf(fp, "#\n# Format and resolution data\n#\n");
1012: fprintf(fp, "format new\nresolution %d\n", res);
1013:
1014: fclose(fp);
1015:
1016: } /* End of rastdata */
1017:
1018:
1019: /*****************************************************************************/
1020:
1021:
1022: setascender(size)
1023:
1024:
1025: int size; /* for this size - usually unitwidth */
1026:
1027:
1028: {
1029:
1030:
1031: int i; /* just a loop index */
1032:
1033:
1034: /*
1035: *
1036: * Called to set reasonable values for the ascender/descender values above
1037: * and below. If *ascender != '\0' we'll look the character up in charinfo[]
1038: * and use it's height and yref to set values for above and below. If we
1039: * don't find the character or it hasn't been set we'll use size and res
1040: * to pick reasonable values.
1041: *
1042: */
1043:
1044:
1045: for ( i = first; i <= last; i++ )
1046: if ( strcmp(ascender, charinfo[i].name) == 0 )
1047: break;
1048:
1049: if ( i > last )
1050: above = (size * res) / (72.27 * 2);
1051: else above = readvalue(charinfo[i].glydir + rst[G_YREF].offset, rst[G_YREF].size, INTEGER);
1052:
1053: above = above + .30 * above + .5;
1054: below = .20 * above + .5;
1055:
1056: } /* End of setascender */
1057:
1058:
1059: /*****************************************************************************/
1060:
1061:
1062: getascender(n)
1063:
1064:
1065: int n; /* character's index in charinfo[] */
1066:
1067:
1068: {
1069:
1070:
1071: int height; /* raster height of n's bitmap */
1072: int yref; /* y reference point */
1073: int value; /* ascender value for character n */
1074:
1075:
1076: /*
1077: *
1078: * Figures out an appropriate value for the ascender/descender field in
1079: * troff's ASCII font files for character n.
1080: *
1081: */
1082:
1083:
1084: value = 0;
1085:
1086: yref = readvalue(charinfo[n].glydir + rst[G_YREF].offset, rst[G_YREF].size, INTEGER);
1087: height = readvalue(charinfo[n].glydir + rst[G_HEIGHT].offset, rst[G_HEIGHT].size, UNSIGNED);
1088:
1089: if ( yref >= above )
1090: value |= 02;
1091:
1092: if ( height - yref > below )
1093: value |= 01;
1094:
1095: return(value);
1096:
1097: } /* End of getascender */
1098:
1099:
1100: /*****************************************************************************/
1101:
1102:
1103: skipline(fp)
1104:
1105:
1106: FILE *fp; /* skip rest of line in this file */
1107:
1108:
1109: {
1110:
1111:
1112: int ch; /* next character from *fp_in */
1113:
1114:
1115: /*
1116: *
1117: * Skips the rest of the current line in file *fp.
1118: *
1119: */
1120:
1121:
1122: while ( (ch = getc(fp)) != '\n' && ch != EOF ) ;
1123:
1124: } /* End of skipline */
1125:
1126:
1127: /*****************************************************************************/
1128:
1129:
1130: writevalue(val, field, p)
1131:
1132:
1133: unsigned val; /* write this value out */
1134: int field; /* as next rst[field].size bytes */
1135: char *p; /* starting right here */
1136:
1137:
1138: {
1139:
1140:
1141: int n; /* size in bytes of field */
1142: int i; /* just a loop index */
1143:
1144:
1145: /*
1146: *
1147: * Writes val out as the nextrst[field].sizebytes starting at address *p.
1148: * It's used to build entries in the preamble and glyph directory for the
1149: * new raster file we're currently working on.
1150: *
1151: */
1152:
1153:
1154: n = rst[field].size; /* number of bytes to write out */
1155:
1156: for ( i = 1; i <= n; i++, p++ )
1157: *p = (val >> (n - i) * BYTE) & BMASK;
1158:
1159: } /* End of writevalue */
1160:
1161:
1162: /*****************************************************************************/
1163:
1164:
1165: unsigned readvalue(p, n, kind)
1166:
1167:
1168: register char *p; /* start here */
1169: register int n; /* and get this many bytes */
1170: int kind; /* type of field - INTEGER or UNSIGNED */
1171:
1172:
1173: {
1174:
1175:
1176: register unsigned value; /* result after decoding the field */
1177:
1178:
1179: /*
1180: *
1181: * Does essentially the same thing as getvalue() in rast.c except that we
1182: * supply different information as parameters.
1183: *
1184: */
1185:
1186:
1187: value = (kind == INTEGER && (*p & 0200)) ? ~0 : 0;
1188:
1189: for ( ; n > 0; n--, p++ )
1190: value = (value << BYTE) | (*p & BMASK);
1191:
1192: return(value);
1193:
1194: } /* End of readvalue */
1195:
1196:
1197: /*****************************************************************************/
1198:
1199:
1200: wantfont(name)
1201:
1202:
1203: char *name; /* do work for this font? */
1204:
1205:
1206: {
1207:
1208:
1209: int i; /* loop index */
1210:
1211:
1212: /*
1213: *
1214: * If we've just asked to process a few fonts (using -f option) fontcount
1215: * will be non-zero and pointers to the requested font names will be stored
1216: * in array fontlist[]. This routine returns ON if *name is one of the
1217: * requested fonts or if fontcount is 0. Otherwise OFF will be returned to
1218: * the caller, which should stop all output for *name.
1219: *
1220: */
1221:
1222:
1223: if ( fontcount == 0 ) /* didn't ask for any fonts */
1224: return(ON);
1225:
1226: for ( i = 0; i < fontcount; i++ )
1227: if ( strcmp(name, fontlist[i]) == 0 )
1228: return(ON);
1229:
1230: return(OFF);
1231:
1232: } /* End of wantfont */
1233:
1234:
1235: /*****************************************************************************/
1236:
1237:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.