![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dpost.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / post.src / dpost|
Return to dpost.c CVS log | Up to [Research Unix] / researchv10no / cmd / post.src / dpost |
1.1 root 1: /*
2: *
3: * dpost - troff post-processor for PostScript printers.
4: *
5: * A program that translates output generated by the device independent troff
6: * into PostScript. Much was borrowed from dimpress and dps (formally dlzw),
7: * and even though the code has changed, credit has to be given to Richard
8: * Flood for his early work on the PostScript driver.
9: *
10: * The big change is in the font table routines. The old binary format and
11: * makedev are gone. dpost and troff now read ASCII tables, and both skip
12: * unrecognized entries in the ASCII tables. That means problems, like where
13: * to put the real name of the PostScript font, have disappeared. The added
14: * flexibility means some overhead translating the ASCII tables, but the
15: * overhead isn't too bad.
16: *
17: * dpost can also now calculate a reasonably tight BoundingBox, which helps
18: * picture inclusion. The calculations, by default, are disabled. Couldn't
19: * justify the overhead for a comment, particularly one that's only needed
20: * occasionally. Use the -B option to get the comment.
21: *
22: * Output produced by dpost is still nonconforming. Definitions made in pages
23: * and exported to the job's global environment are the primary problem. It's
24: * an efficient approach, but means pages are not independent. Violations are
25: * bracketed by %%BeginGlobal and %%EndGlobal comments and can be pulled into
26: * the prologue by utility programs (like postreverse) that recognize the new
27: * comments.
28: *
29: * The program handles files formatted for any device, although the best and
30: * most efficient output is generated when the font and description files
31: * match PostScript's resident fonts. Emulation is relatively expensive, and
32: * can produce output files that are more than twice the size of the input
33: * files.
34: *
35: * Several different methods can be used to encode lines of text. What's done
36: * depends on the value assigned to encoding. Print time should decrease as
37: * encoding increases (up to MAXENCODING). Setting encoding to 3 (or higher)
38: * is not normally recommended. It's fast and produces very compact output,
39: * but rounding errors in troff's width tables can accumulate and lead to a
40: * ragged right margin. encoding can be changed on the command line using the
41: * -e option.
42: *
43: * PostScript fonts don't support all of troff's characters. Some are built
44: * by special PostScript procedures in directory *fontdir/devpost/charlib.
45: * The charlib approach is not meant to replace user defined fonts. It was
46: * a quick implementation designed to handle characters that aren't used
47: * often - charlib should not be overused! The charlib lookup is triggered
48: * when a character in a font table is assigned a code less than 32.
49: *
50: * Most defaults are set in the prologue, but can be changed by options. The
51: * -P option passes arbitrary PostScript into the setup section of the output
52: * file. It can be used to set (or change) values that can't be accessed by
53: * other options. For example,
54: *
55: * dpost -P'/useclippath false def' file > file.ps
56: *
57: * defines useclippath to be false. Everything passed through using the -P
58: * (-C to copy a file) options become part of the job's global environment.
59: * Definitions override defaults in the prologue.
60: *
61: * dpost expects to find the following procedures in the prologue:
62: *
63: * setup
64: *
65: * mark ... setup -
66: *
67: * Initialization procedure mainly responsible for setting up an
68: * appropriate coordinate system.
69: *
70: * pagesetup
71: *
72: * page pagesetup -
73: *
74: * Called at the start of each page, immediately after the page
75: * level save. Argument is the current page number.
76: *
77: * setdecoding
78: *
79: * num setdecoding -
80: *
81: * Select the decoding procedure used to print text strings encoded
82: * by dpost. num is whatever has been assigned to encoding.
83: *
84: * f
85: *
86: * size font f -
87: *
88: * Set the font and size used for character imaging. The font name
89: * argument is (normally) the name troff used. Mapping to the real
90: * PostScript font name is made using the fontname field in the
91: * ASCII width tables.
92: *
93: * m
94: *
95: * x y m -
96: *
97: * Move to point (x, y). Not used for positioning words in text
98: * strings.
99: *
100: * t
101: *
102: * mark text t mark
103: *
104: * Everything on the stack (up to the mark) is treated as a line
105: * of text to be decoded and printed. What's on the stack depends
106: * on encoding.
107: *
108: * w
109: *
110: * string x y w -
111: *
112: * Print a single word starting at position (x, y). Only used in
113: * the more complicated encoding schemes, like the ones based on
114: * widthshow.
115: *
116: * done
117: *
118: * Make sure the last page prints. Always called, but only needed
119: * when printing more than one page on each sheet of paper.
120: *
121: * output language from troff:
122: * all numbers are character strings
123: *
124: * sn size in points
125: * fn font as number from 1-n
126: * cx ascii character x
127: * Cxyz funny char xyz. terminated by white space
128: * Hn go to absolute horizontal position n
129: * Vn go to absolute vertical position n (down is positive)
130: * hn go n units horizontally (relative)
131: * vn ditto vertically
132: * nnc move right nn, then print c (exactly 2 digits!)
133: * (this wart is an optimization that shrinks output file size
134: * about 35% and run-time about 15% while preserving ascii-ness)
135: * Dt ...\n draw operation 't':
136: * Dl x y line from here by x,y
137: * Dc d circle of diameter d with left side here
138: * De x y ellipse of axes x,y with left side here
139: * Da x1 y1 x2 y2 arc counter-clockwise from current point (x, y) to
140: * (x + x1 + x2, y + y1 + y2)
141: * D~ x y x y ... wiggly line by x,y then x,y ...
142: * nb a end of line (information only -- no action needed)
143: * b = space before line, a = after
144: * p new page begins -- set v to 0
145: * #...\n comment
146: * x ...\n device control functions:
147: * x i init
148: * x T s name of device is s
149: * x r n h v resolution is n/inch
150: * h = min horizontal motion, v = min vert
151: * x p pause (can restart)
152: * x s stop -- done forever
153: * x t generate trailer
154: * x f n s font position n contains font s
155: * x H n set character height to n
156: * x S n set slant to N
157: *
158: * Subcommands like "i" are often spelled out like "init".
159: *
160: */
161:
162: #include <stdio.h>
163: #include <fcntl.h>
164: #include <signal.h>
165: #include <math.h>
166: #include <ctype.h>
167: #include <time.h>
168:
169: #include "comments.h" /* structuring comments */
170: #include "gen.h" /* general purpose definitions */
171: #include "path.h" /* prologue and a few other files */
172: #include "ext.h" /* external variable declarations */
173: #include "font.h" /* font table definitions */
174: #include "dpost.h" /* a few definitions just used here */
175: #include "motion.h" /* positioning macros */
176:
177: char *prologue = DPOST; /* the PostScript prologue */
178: char *colorfile = COLOR; /* color support */
179: char *drawfile = DRAW; /* drawing routines */
180: char *formfile = FORMFILE; /* multiple pages on each sheet */
181: char *baselinefile = BASELINE; /* for text along curved baseline */
182:
183: char *fontdir = FONTDIR; /* font table directories */
184: char *hostfontdir = NULL; /* host resident font directory */
185:
186: char *realdev = DEVNAME; /* use these width tables */
187: char devname[20] = ""; /* job formatted for this device */
188: Fontmap fontmap[] = FONTMAP; /* font translation table - emulation */
189: char *useencoding = NULL; /* text font encoding - from -E option */
190:
191: int copies = 1; /* copies of each sheet */
192: int printed = 0; /* pages processed and printed */
193: int formsperpage = 1; /* pages on each sheet of paper */
194: int picflag = ON; /* enable/disable picture inclusion */
195:
196: int encoding = DFLTENCODING; /* how text is translated to PostScript */
197: int realencoding = DFLTENCODING; /* where we started */
198: int maxencoding = MAXENCODING; /* max that users can select */
199:
200: int landscape = FALSE; /* for BoundingBox calculations only */
201: double magnification = 1.0;
202: double xoffset = 0.0;
203: double yoffset = 0.0;
204:
205: int smnt; /* special fonts start here */
206: int devres; /* device resolution */
207: int unitwidth; /* and unitwidth - from DESC file */
208:
209: char downloaded[MAXCH+32+ALPHABET]; /* status of charlib characters */
210:
211: int nfonts = 0; /* number of font positions */
212: int size = 10; /* current point size */
213: int font = 0; /* and font position */
214: int hpos = 0; /* where troff wants to be */
215: int vpos = 0;
216: float lastw = 0; /* width of the last input character */
217: int lastc = 0; /* its name (or index) - for charlib() */
218:
219: int fontheight = 0; /* points from x H ... */
220: int fontslant = 0; /* angle from x S ... */
221:
222: int res; /* resolution assumed in input file */
223: float widthfac = 1.0; /* for emulation = res/devres */
224:
225: int lastsize = -1; /* for tracking printer's current size */
226: int lastfont = -1; /* current font */
227: float lastx = -1; /* and current position */
228: int lasty = -1;
229: int lastend; /* where last character on this line was */
230:
231: int seenpage = FALSE; /* expect fonts are now all mounted */
232: int gotspecial = FALSE; /* append special fonts - emulation */
233:
234: float pointslop = SLOP; /* horizontal error in points */
235: int slop; /* and machine units */
236: int rvslop; /* to extend box in reverse video mode */
237:
238: int textcount = 0; /* strings accumulated so far */
239: int stringstart = 0; /* where the next one starts */
240: int spacecount = 0; /* spaces in current string */
241:
242: Line line[MAXSTACK+3]; /* data about words accumulated so far */
243: char strings[STRINGSPACE]; /* strings temporarily saved here */
244: char *strptr; /* next free slot in strings[] */
245:
246: FILE *tf = NULL; /* most output goes here */
247: FILE *fp_acct = NULL; /* accounting file */
248:
249: char *optnames = "a:c:e:m:n:o:p:tw:x:y:A:BC:E:J:F:H:L:OP:R:S:T:DI";
250:
251: extern int gotcolor; /* read *colorfile when TRUE */
252: extern Font fonts[]; /* data about every font we see */
253: extern Font *mount[]; /* troff mounts fonts here */
254:
255: /*****************************************************************************/
256:
257: main(agc, agv)
258:
259: int agc;
260: char *agv[];
261:
262: {
263:
264: /*
265: *
266: * Translates output from troff into PostScript. Input files must be formatted
267: * for the same device. Each input file begins on a new page.
268: *
269: */
270:
271: argc = agc; /* global so everyone can use them */
272: argv = agv;
273:
274: prog_name = argv[0]; /* for error messages */
275:
276: init_signals(); /* interrupt handling */
277: header(); /* structuring comments */
278: options(); /* command line options */
279: arguments(); /* translate the input files */
280: done(); /* add trailing comments etc. */
281: account(); /* job accounting data */
282:
283: exit(x_stat);
284:
285: } /* End of main */
286:
287: /*****************************************************************************/
288:
289: init_signals()
290:
291: {
292:
293: /*
294: *
295: * Make sure we handle interrupts.
296: *
297: */
298:
299: if ( signal(SIGINT, interrupt) == SIG_IGN ) {
300: signal(SIGINT, SIG_IGN);
301: signal(SIGQUIT, SIG_IGN);
302: signal(SIGHUP, SIG_IGN);
303: } else {
304: signal(SIGHUP, interrupt);
305: signal(SIGQUIT, interrupt);
306: } /* End else */
307:
308: signal(SIGTERM, interrupt);
309:
310: } /* End of init_signals */
311:
312: /*****************************************************************************/
313:
314: header()
315:
316: {
317:
318: int ch;
319: int old_optind = optind;
320:
321: /*
322: *
323: * Scan the option list for things needed now (e.g. prologue file), but could
324: * be changed from defaults. An attempt to follow to Adobe's 2.0 structuring
325: * conventions.
326: *
327: */
328:
329: while ( (ch = getopt(argc, argv, optnames)) != EOF )
330: if ( ch == 'L' )
331: setpaths(optarg);
332: else if ( ch == 'B' )
333: dobbox = TRUE;
334: else if ( ch == '?' )
335: error(FATAL, "");
336:
337: optind = old_optind; /* restored for options() */
338:
339: fprintf(stdout, "%s", NONCONFORMING);
340: fprintf(stdout, "%s %s\n", VERSION, PROGRAMVERSION);
341: fprintf(stdout, "%s %s\n", DOCUMENTFONTS, ATEND);
342: fprintf(stdout, "%s %s\n", PAGES, ATEND);
343: if ( dobbox == TRUE )
344: fprintf(stdout, "%s %s\n", BOUNDINGBOX, ATEND);
345: fprintf(stdout, "%s", ENDCOMMENTS);
346:
347: if ( cat(prologue) == FALSE )
348: error(FATAL, "can't read %s", prologue);
349:
350: if ( DOROUND )
351: cat(ROUNDPAGE);
352:
353: fprintf(stdout, "%s", ENDPROLOG);
354: fprintf(stdout, "%s", BEGINSETUP);
355: fprintf(stdout, "mark\n");
356:
357: } /* End of header */
358:
359: /*****************************************************************************/
360:
361: options()
362:
363: {
364:
365: int ch;
366:
367: extern char *optarg;
368: extern int optind;
369:
370: /*
371: *
372: * Command line options - there are too many!
373: *
374: */
375:
376: while ( (ch = getopt(argc, argv, optnames)) != EOF ) {
377: switch ( ch ) {
378: case 'a': /* aspect ratio */
379: fprintf(stdout, "/aspectratio %s def\n", optarg);
380: break;
381:
382: case 'c': /* number of copies */
383: copies = atoi(optarg);
384: fprintf(stdout, "/#copies %s store\n", optarg);
385: break;
386:
387: case 'e': /* select the encoding scheme */
388: if ( (encoding = atoi(optarg)) < 0 || encoding > MAXENCODING )
389: encoding = DFLTENCODING;
390: realencoding = encoding;
391: break;
392:
393: case 'm': /* magnification */
394: magnification = atof(optarg);
395: fprintf(stdout, "/magnification %s def\n", optarg);
396: break;
397:
398: case 'n': /* forms per page */
399: formsperpage = atoi(optarg);
400: fprintf(stdout, "%s %s\n", FORMSPERPAGE, optarg);
401: fprintf(stdout, "/formsperpage %s def\n", optarg);
402: break;
403:
404: case 'o': /* output page list */
405: out_list(optarg);
406: break;
407:
408: case 'p': /* landscape or portrait mode */
409: landscape = (*optarg == 'l') ? TRUE : FALSE;
410: if ( landscape == TRUE )
411: fprintf(stdout, "/landscape true def\n");
412: else fprintf(stdout, "/landscape false def\n");
413: break;
414:
415: case 't': /* compatibility */
416: break;
417:
418: case 'w': /* line width - for drawing */
419: fprintf(stdout, "/linewidth %s def\n", optarg);
420: break;
421:
422: case 'x': /* shift horizontally */
423: xoffset = atof(optarg);
424: fprintf(stdout, "/xoffset %s def\n", optarg);
425: break;
426:
427: case 'y': /* shift vertically */
428: yoffset = atof(optarg);
429: fprintf(stdout, "/yoffset %s def\n", optarg);
430: break;
431:
432: case 'A': /* job accounting */
433: case 'J':
434: if ( (fp_acct = fopen(optarg, "a")) == NULL )
435: error(FATAL, "can't open accounting file %s", optarg);
436: break;
437:
438: case 'B': /* enable BoundingBox calculations */
439: dobbox = TRUE;
440: fprintf(stdout, "/rotation 1 def\n");
441: fprintf(stdout, "/gotpagebbox true def\n");
442: break;
443:
444: case 'C': /* copy file to output */
445: if ( cat(optarg) == FALSE )
446: error(FATAL, "can't read %s", optarg);
447: break;
448:
449: case 'E': /* text font encoding - override DESC */
450: useencoding = optarg;
451: break;
452:
453: case 'F': /* font table directory */
454: fontdir = optarg;
455: break;
456:
457: case 'H': /* host resident font directory */
458: hostfontdir = optarg;
459: break;
460:
461: case 'L': /* prologue file */
462: setpaths(optarg); /* already been done in header() */
463: break;
464:
465: case 'O': /* disable picture inclusion */
466: picflag = OFF;
467: break;
468:
469: case 'P': /* copy string to output */
470: fprintf(stdout, "%s\n", optarg);
471: break;
472:
473: case 'R': /* global or page level request */
474: saverequest(optarg);
475: break;
476:
477: case 'S': /* horizontal position error */
478: if ( (pointslop = atof(optarg)) < 0 )
479: pointslop = 0;
480: break;
481:
482: case 'T': /* target printer */
483: realdev = optarg;
484: break;
485:
486: case 'D': /* debug flag */
487: debug = ON;
488: tf = stdout;
489: break;
490:
491: case 'I': /* ignore FATAL errors */
492: ignore = ON;
493: break;
494:
495: case '?': /* don't know the option */
496: error(FATAL, "");
497: break;
498:
499: default:
500: error(FATAL, "missing case for option %c", ch);
501: break;
502: } /* End switch */
503: } /* End while */
504:
505: argc -= optind;
506: argv += optind;
507:
508: } /* End of options */
509:
510: /*****************************************************************************/
511:
512: setpaths(name)
513:
514: char *name;
515:
516: {
517:
518: char *path;
519:
520: /*
521: *
522: * Extends the -L option to permit modification of more than just the prologue
523: * file pathname. Syntax is -Lpath or -Lname:path. For debugging and development
524: * only!
525: *
526: */
527:
528: for ( path = name; *path; path++ )
529: if ( *path == ':' || *path == ' ' ) {
530: while ( *path == ':' || *path == ' ' ) path++;
531: break;
532: } /* End if */
533:
534: if ( *path == '\0' ) /* didn't find "name:" prefix */
535: path = name;
536:
537: if ( path == name || strncmp(name, "prologue", strlen("prologue")) == 0 )
538: prologue = path;
539: else if ( strncmp(name, "draw", strlen("draw")) == 0 )
540: drawfile = path;
541: else if ( strncmp(name, "color", strlen("color")) == 0 )
542: colorfile = path;
543: else if ( strncmp(name, "form", strlen("form")) == 0 )
544: formfile = path;
545: else if ( strncmp(name, "baseline", strlen("baseline")) == 0 )
546: baselinefile = path;
547:
548: } /* End of setpaths */
549:
550: /*****************************************************************************/
551:
552: setup()
553:
554: {
555:
556: double t;
557:
558: /*
559: *
560: * Job and BoundingBox initialization. Called once from t_init() - must know
561: * the resolution before generating the PostScript call to setup. dpost only
562: * includes an encoding file if it's set in the DESC file or requested with
563: * the -E option.
564: *
565: */
566:
567: writerequest(0, stdout); /* global requests e.g. manual feed */
568: fprintf(stdout, "/resolution %d def\n", res);
569: if ( useencoding != NULL || fontencoding != NULL )
570: setencoding((useencoding != NULL) ? useencoding : fontencoding);
571: fprintf(stdout, "setup\n");
572: fprintf(stdout, "%d setdecoding\n", realencoding);
573:
574: if ( formsperpage > 1 ) { /* multiple pages */
575: if ( cat(formfile) == FALSE )
576: error(FATAL, "can't read %s", formfile);
577: fprintf(stdout, "%d setupforms\n", formsperpage);
578: } /* End if */
579:
580: fprintf(stdout, "%s", ENDSETUP);
581:
582: if ( dobbox == TRUE ) { /* ctm[] - must agree with prologue */
583: translate(pagewidth/2.0, pageheight/2.0);
584: if ( landscape == TRUE ) {
585: rotate(90.0);
586: t = pagewidth;
587: pagewidth = pageheight;
588: pageheight = t;
589: } /* End if */
590: translate(-pagewidth/2.0, pageheight/2.0);
591: translate(72.0 * xoffset, -72.0 * yoffset);
592: scale(magnification, magnification);
593: scale(72.0/devres, 72.0/devres);
594: } /* End if */
595:
596: } /* End of setup */
597:
598: /*****************************************************************************/
599:
600: arguments()
601:
602: {
603:
604: FILE *fp;
605:
606: /*
607: *
608: * Everything else is an input file. No arguments or '-' means stdin.
609: *
610: */
611:
612: if ( argc < 1 )
613: conv(stdin);
614: else
615: while ( argc > 0 ) {
616: if ( strcmp(*argv, "-") == 0 )
617: fp = stdin;
618: else if ( (fp = fopen(*argv, "r")) == NULL )
619: error(FATAL, "can't open %s", *argv);
620: conv(fp);
621: if ( fp != stdin )
622: fclose(fp);
623: argc--;
624: argv++;
625: } /* End while */
626:
627: } /* End of arguments */
628:
629: /*****************************************************************************/
630:
631: done()
632:
633: {
634:
635: int i;
636: int n;
637:
638: /*
639: *
640: * Force out the last page and add trailing comments.
641: *
642: */
643:
644: fprintf(stdout, "%s", TRAILER);
645: fprintf(stdout, "done\n");
646: fprintf(stdout, "%s %d\n", PAGES, printed);
647:
648: for ( i = 0, n = 0; i < MAXFONTS+1; i++ )
649: if ( (fonts[i].flags & USED) && fonts[i].fontname != NULL ) {
650: if ( n++ == 0 )
651: fprintf(stdout, "%s", DOCUMENTFONTS);
652: else if ( (n - 1) % 8 == 0 )
653: fprintf(stdout, "\n%s", CONTINUECOMMENT);
654: fprintf(stdout, " %s", fonts[i].fontname);
655: } /* End if */
656: if ( n > 0 )
657: putc('\n', stdout);
658:
659: if ( dobbox == TRUE )
660: writebbox(stdout, BOUNDINGBOX, 10);
661:
662: } /* End of done */
663:
664: /*****************************************************************************/
665:
666: account()
667:
668: {
669:
670: /*
671: *
672: * Accounting record to fp_acct - provided it's not NULL.
673: *
674: */
675:
676: if ( fp_acct != NULL )
677: fprintf(fp_acct, " print %d\n copies %d\n", printed, copies);
678:
679: } /* End of account */
680:
681: /*****************************************************************************/
682:
683: conv(fp)
684:
685: register FILE *fp;
686:
687: {
688:
689: register int c;
690: int m, n, n1, m1;
691: char str[50];
692:
693: /*
694: *
695: * Read troff output from file fp and translate it into PostScript. The final
696: * t_page() call means input files start on a new page.
697: *
698: */
699:
700: redirect(-1); /* do output only after a page command */
701: lineno = 1;
702:
703: while ((c = getc(fp)) != EOF) {
704: switch (c) {
705: case '\n': /* just count this line */
706: lineno++;
707: break;
708:
709: case ' ': /* when input is text */
710: case 0: /* occasional noise creeps in */
711: break;
712:
713: case '0': case '1': case '2': case '3': case '4':
714: case '5': case '6': case '7': case '8': case '9':
715: /* two motion digits plus a character */
716: hmot((c-'0')*10 + getc(fp)-'0');
717: put1(getc(fp));
718: break;
719:
720: case 'c': /* single ascii character */
721: put1(getc(fp));
722: break;
723:
724: case 'C': /* special character */
725: fscanf(fp, "%s", str);
726: put1(chindex(str));
727: break;
728:
729: case 'N': /* character at position n */
730: fscanf(fp, "%d", &m);
731: flushtext();
732: oput(m);
733: break;
734:
735: case 'D': /* drawing functions */
736: flushtext();
737: getdraw();
738: if ( size != lastsize )
739: t_sf();
740: switch ((c=getc(fp))) {
741: case 'p': /* draw a path */
742: while (fscanf(fp, "%d %d", &n, &m) == 2)
743: drawline(n, m);
744: lineno++;
745: break;
746:
747: case 'l': /* draw a line */
748: fscanf(fp, "%d %d %c", &n, &m, &n1);
749: drawline(n, m);
750: break;
751:
752: case 'c': /* circle */
753: fscanf(fp, "%d", &n);
754: drawcirc(n);
755: break;
756:
757: case 'e': /* ellipse */
758: fscanf(fp, "%d %d", &m, &n);
759: drawellip(m, n);
760: break;
761:
762: case 'a': /* counter-clockwise arc */
763: case 'A': /* clockwise arc */
764: fscanf(fp, "%d %d %d %d", &n, &m, &n1, &m1);
765: drawarc(n, m, n1, m1, c);
766: break;
767:
768: case 'q': /* spline without end points */
769: drawspline(fp, 1);
770: lineno++;
771: break;
772:
773: case '~': /* wiggly line */
774: drawspline(fp, 2);
775: lineno++;
776: break;
777:
778: default:
779: error(FATAL, "unknown drawing function %c", c);
780: break;
781: } /* End switch */
782: break;
783:
784: case 's': /* use this point size */
785: fscanf(fp, "%d", &size); /* ignore fractional sizes */
786: break;
787:
788: case 'f': /* use font mounted here */
789: fscanf(fp, "%s", str);
790: setfont(t_font(str));
791: break;
792:
793: case 'H': /* absolute horizontal motion */
794: fscanf(fp, "%d", &n);
795: hgoto(n);
796: break;
797:
798: case 'h': /* relative horizontal motion */
799: fscanf(fp, "%d", &n);
800: hmot(n);
801: break;
802:
803: case 'w': /* word space */
804: break;
805:
806: case 'V': /* absolute vertical position */
807: fscanf(fp, "%d", &n);
808: vgoto(n);
809: break;
810:
811: case 'v': /* relative vertical motion */
812: fscanf(fp, "%d", &n);
813: vmot(n);
814: break;
815:
816: case 'p': /* new page */
817: fscanf(fp, "%d", &n);
818: t_page(n);
819: break;
820:
821: case 'n': /* end of line */
822: while ( (c = getc(fp)) != '\n' && c != EOF ) ;
823: hgoto(0);
824: lineno++;
825: break;
826:
827: case '#': /* comment */
828: while ( (c = getc(fp)) != '\n' && c != EOF ) ;
829: lineno++;
830: break;
831:
832: case 'x': /* device control function */
833: devcntrl(fp);
834: lineno++;
835: break;
836:
837: default:
838: error(FATAL, "unknown input character %o %c", c, c);
839: done();
840: } /* End switch */
841: } /* End while */
842:
843: t_page(-1); /* print the last page */
844: flushtext();
845:
846: } /* End of conv */
847:
848: /*****************************************************************************/
849:
850: devcntrl(fp)
851:
852: FILE *fp;
853:
854: {
855:
856: char str[50], buf[256], str1[100];
857: int c, n;
858:
859: /*
860: *
861: * Interpret device control commands, ignoring any we don't recognize. The
862: * "x X ..." commands are a device dependent collection generated by troff's
863: * \X'...' request.
864: *
865: */
866:
867: fscanf(fp, "%s", str);
868:
869: switch ( str[0] ) {
870: case 'f': /* load font in a position */
871: fscanf(fp, "%d %s", &n, str);
872: fgets(buf, sizeof buf, fp); /* in case there's a filename */
873: ungetc('\n', fp); /* fgets() goes too far */
874: str1[0] = '\0'; /* in case there's nothing to come in */
875: sscanf(buf, "%s", str1);
876: loadfont(n, str, str1);
877: break;
878:
879: case 'i': /* initialize */
880: t_init();
881: break;
882:
883: case 'p': /* pause */
884: break;
885:
886: case 'r': /* resolution assumed when prepared */
887: fscanf(fp, "%d", &res);
888: break;
889:
890: case 's': /* stop */
891: case 't': /* trailer */
892: flushtext();
893: break;
894:
895: case 'H': /* char height */
896: fscanf(fp, "%d", &n);
897: t_charht(n);
898: break;
899:
900: case 'S': /* slant */
901: fscanf(fp, "%d", &n);
902: t_slant(n);
903: break;
904:
905: case 'T': /* device name */
906: fscanf(fp, "%s", devname);
907: break;
908:
909: case 'X': /* copy through - from troff */
910: fscanf(fp, " %[^: \n]:", str);
911: fgets(buf, sizeof(buf), fp);
912: ungetc('\n', fp);
913: if ( strcmp(str, "PI") == 0 || strcmp(str, "PictureInclusion") == 0 )
914: picture(buf);
915: else if ( strcmp(str, "InlinePicture") == 0 )
916: inlinepic(fp, buf);
917: else if ( strcmp(str, "BeginPath") == 0 )
918: beginpath(buf, FALSE);
919: else if ( strcmp(str, "DrawPath") == 0 )
920: drawpath(buf, FALSE);
921: else if ( strcmp(str, "BeginObject") == 0 )
922: beginpath(buf, TRUE);
923: else if ( strcmp(str, "EndObject") == 0 )
924: drawpath(buf, TRUE);
925: else if ( strcmp(str, "NewBaseline") == 0 )
926: newbaseline(buf);
927: else if ( strcmp(str, "DrawText") == 0 )
928: drawtext(buf);
929: else if ( strcmp(str, "SetText") == 0 )
930: settext(buf);
931: else if ( strcmp(str, "SetColor") == 0 ) {
932: newcolor(buf);
933: setcolor();
934: } else if ( strcmp(str, "INFO") == 0 ) {
935: flushtext();
936: fprintf(tf, "%%INFO%s", buf);
937: } else if ( strcmp(str, "PS") == 0 || strcmp(str, "PostScript") == 0 ) {
938: flushtext();
939: fprintf(tf, "%s", buf);
940: } else if ( strcmp(str, "ExportPS") == 0 ) { /* dangerous!! */
941: if ( tf == stdout ) {
942: restore();
943: fprintf(tf, "%s", buf);
944: save();
945: } /* End if */
946: } /* End else */
947: break;
948: } /* End switch */
949:
950: while ( (c = getc(fp)) != '\n' && c != EOF ) ;
951:
952: } /* End of devcntrl */
953:
954: /*****************************************************************************/
955:
956: loadfont(m, f, name)
957:
958: int m;
959: char *f;
960: char *name;
961:
962: {
963:
964: char path[150];
965:
966: /*
967: *
968: * Load position m with font f. Font file pathname is *fontdir/dev*realdev/*f
969: * or name, if name isn't empty. Use mapfont() to replace the missing font
970: * if we're emulating another device, name is empty, and the first mount
971: * fails.
972: *
973: */
974:
975: if ( name[0] == '\0' )
976: sprintf(path, "%s/dev%s/%s", fontdir, realdev, f);
977: else sprintf(path, "%s", name);
978:
979: if ( mountfont(path, m) == -1 ) {
980: if ( name[0] == '\0' ) {
981: sprintf(path, "%s/dev%s/%s", fontdir, realdev, mapfont(f));
982: if ( mountfont(path, m) == -1 ) {
983: sprintf(path, "%s/dev%s/%s", fontdir, realdev, f);
984: error(FATAL, "can't load %s at %d", path, m);
985: } /* End if */
986: } else error(FATAL, "can't load %s at %d", path, m);
987: } /* End if */
988:
989: if ( smnt == 0 && mount[m]->specfont )
990: smnt = m;
991:
992: if ( m == lastfont ) /* force a call to t_sf() */
993: lastfont = -1;
994:
995: if ( m > nfonts ) { /* got more positions */
996: nfonts = m;
997: gotspecial = FALSE;
998: } /* End if */
999:
1000: } /* End of loadfont */
1001:
1002: /*****************************************************************************/
1003:
1004: char *mapfont(name)
1005:
1006: char *name;
1007:
1008: {
1009:
1010: int i;
1011:
1012: /*
1013: *
1014: * Map a missing font name into one that should be available. Only used when
1015: * we're emulating another device and the first mount fails. Consider deleting
1016: * this routine.
1017: *
1018: */
1019:
1020: for ( i = 0; fontmap[i].name != NULL; i++ )
1021: if ( strcmp(name, fontmap[i].name) == 0 )
1022: return(fontmap[i].use);
1023:
1024: switch ( *++name ) {
1025: case 'I': return("I");
1026: case 'B': return("B");
1027: case 'X': return("BI");
1028: default: return("R");
1029: } /* End switch */
1030:
1031: } /* End of mapfont */
1032:
1033: /*****************************************************************************/
1034:
1035: loadspecial()
1036:
1037: {
1038:
1039: /*
1040: *
1041: * Fix - later.
1042: *
1043: */
1044:
1045: gotspecial = TRUE;
1046:
1047: } /* End of loadspecial */
1048:
1049: /*****************************************************************************/
1050:
1051: t_init()
1052:
1053: {
1054:
1055: char path[150];
1056: static int initialized = FALSE;
1057:
1058: /*
1059: *
1060: * Finish initialization - just read an "x init" command. Assumes we already
1061: * know the input file resolution.
1062: *
1063: */
1064:
1065: flushtext(); /* moved - for cat'ed troff files */
1066:
1067: if ( initialized == FALSE ) {
1068: if ( strcmp(devname, realdev) ) {
1069: sprintf(path, "%s/dev%s/DESC", fontdir, devname);
1070: if ( checkdesc(path) )
1071: realdev = devname;
1072: } /* End if */
1073:
1074: sprintf(path, "%s/dev%s/DESC", fontdir, realdev);
1075: if ( getdesc(path) == -1 )
1076: error(FATAL, "can't open %s", path);
1077: nfonts = 0;
1078: gotspecial = FALSE;
1079: widthfac = (float) res /devres;
1080: slop = pointslop * res / POINTS + .5;
1081: rvslop = res * .025;
1082: setup();
1083: initialized = TRUE;
1084: } /* End if */
1085:
1086: hpos = vpos = 0;
1087: size = 10;
1088: reset();
1089:
1090: } /* End of t_init */
1091:
1092: /*****************************************************************************/
1093:
1094: t_page(pg)
1095:
1096: int pg;
1097:
1098: {
1099:
1100: static int lastpg = 0;
1101:
1102: /*
1103: *
1104: * Finish the previous page and get ready for the next one. End page output
1105: * goes to /dev/null at the start of each input file. Start page output goes
1106: * to /dev/null at the end of each input file.
1107: *
1108: * Consider doing showpage after page level restore (as Adobe recommends). If
1109: * the order is changed use restore() and save(). forms.ps will likely also
1110: * need fixing.
1111: *
1112: */
1113:
1114: if ( tf == stdout )
1115: printed++;
1116:
1117: flushtext(); /* just in case */
1118:
1119: fprintf(tf, "cleartomark\n");
1120: fprintf(tf, "showpage\n");
1121: fprintf(tf, "saveobj restore\n");
1122: if ( dobbox == TRUE )
1123: writebbox(tf, PAGEBOUNDINGBOX, 10);
1124: fprintf(tf, "%s %d %d\n", ENDPAGE, lastpg, printed);
1125:
1126: redirect(pg);
1127:
1128: fprintf(tf, "%s %d %d\n", PAGE, pg, printed+1);
1129: if ( dobbox == TRUE )
1130: fprintf(tf, "%s %s\n", PAGEBOUNDINGBOX, ATEND);
1131: fprintf(tf, "/saveobj save def\n");
1132: fprintf(tf, "mark\n");
1133: writerequest(printed+1, tf);
1134: fprintf(tf, "%d pagesetup\n", printed+1);
1135:
1136: if ( encoding != realencoding )
1137: fprintf(tf, "%d setdecoding\n", encoding);
1138:
1139: if ( gotcolor == TRUE )
1140: setcolor();
1141:
1142: lastpg = pg; /* for the next ENDPAGE comment */
1143: hpos = vpos = 0; /* get ready for the next page */
1144: reset(); /* force position and font stuff - later */
1145:
1146: seenpage = TRUE;
1147:
1148: } /* End of t_page */
1149:
1150: /*****************************************************************************/
1151:
1152: t_font(s)
1153:
1154: char *s;
1155:
1156: {
1157:
1158: int n;
1159:
1160: /*
1161: *
1162: * Converts the string *s into an integer and checks to make sure it's a legal
1163: * font position. Also arranges to mount all the special fonts after the last
1164: * legitimate font (by calling loadspecial()), provided it hasn't already been
1165: * done.
1166: *
1167: */
1168:
1169: n = atoi(s);
1170:
1171: if ( seenpage == TRUE ) {
1172: if ( n < 0 || n > nfonts )
1173: error(FATAL, "illegal font position %d", n);
1174:
1175: if ( gotspecial == FALSE )
1176: loadspecial();
1177: } /* End if */
1178:
1179: return(n);
1180:
1181: } /* End of t_font */
1182:
1183: /*****************************************************************************/
1184:
1185: setfont(m)
1186:
1187: int m;
1188:
1189: {
1190:
1191: /*
1192: *
1193: * Use the font mounted at position m. Bounds checks are probably unnecessary.
1194: * Changing the font and size used by the printer is handled in t_sf().
1195: *
1196: */
1197:
1198: if ( m < 0 || m > MAXFONTS )
1199: error(FATAL, "illegal font %d", m);
1200: font = m;
1201:
1202: } /* End of setfont */
1203:
1204: /*****************************************************************************/
1205:
1206: t_sf()
1207:
1208: {
1209:
1210: Font *fpos;
1211: char temp[150];
1212:
1213: /*
1214: *
1215: * Force a new font or size. Generates name definitions for fonts that haven't
1216: * been named, grabs host resident font files and keeps track of the fonts used
1217: * by this job. When necessary also adjusts the font's height and slant. Should
1218: * only be called immediately before printing a character.
1219: *
1220: */
1221:
1222: if ( tf == stdout && mounted(font) ) {
1223: flushtext();
1224:
1225: fpos = mount[font];
1226: if ( (fpos->flags & USED) == 0 ) {
1227: if ( (fpos->flags & NAMED) == 0 && fpos->fontname != NULL ) {
1228: sprintf(temp, "/%s /%s def\n", fpos->name, fpos->fontname);
1229: exportstring(temp);
1230: fpos->flags |= NAMED; /* unnecessary */
1231: } /* End if */
1232:
1233: if ( hostfontdir != NULL ) {
1234: sprintf(temp, "%s/%s", hostfontdir, fpos->name);
1235: exportfile(temp);
1236: } /* End if */
1237: } /* End if */
1238:
1239: fprintf(tf, "%d %s f\n", size, fpos->name);
1240: if ( fontheight != 0 || fontslant != 0 )
1241: fprintf(tf, "%d %d changefont\n", fontslant, (fontheight != 0) ? fontheight : size);
1242:
1243: lastfont = font;
1244: lastsize = size;
1245: fpos->flags |= USED;
1246: } /* End if */
1247:
1248: } /* End of t_sf */
1249:
1250: /*****************************************************************************/
1251:
1252: t_charht(n)
1253:
1254: int n;
1255:
1256: {
1257:
1258: /*
1259: *
1260: * Set character height to n points. Disabled if n is 0 or the current size.
1261: *
1262: */
1263:
1264: fontheight = (n == size) ? 0 : n;
1265: lastfont = -1;
1266:
1267: } /* End of t_charht */
1268:
1269: /*****************************************************************************/
1270:
1271: t_slant(n)
1272:
1273: int n;
1274:
1275: {
1276:
1277: /*
1278: *
1279: * Set slant to n degrees. Disable slanting if n is 0.
1280: *
1281: */
1282:
1283: fontslant = n;
1284: lastfont = -1;
1285:
1286: } /* End of t_slant */
1287:
1288: /*****************************************************************************/
1289:
1290: xymove(x, y)
1291:
1292: int x, y;
1293:
1294: {
1295:
1296: /*
1297: *
1298: * Make the the printer and post-processor agree about the current position.
1299: *
1300: */
1301:
1302: flushtext();
1303:
1304: hgoto(x);
1305: vgoto(y);
1306:
1307: fprintf(tf, "%d %d m\n", hpos, vpos);
1308:
1309: lastx = hpos;
1310: lasty = vpos;
1311:
1312: } /* End of xymove */
1313:
1314: /*****************************************************************************/
1315:
1316: put1(c)
1317:
1318: register int c;
1319:
1320: {
1321:
1322: register int i;
1323: register int j;
1324: register int k;
1325: int code;
1326: int ofont;
1327:
1328: /*
1329: *
1330: * Print character c. ASCII if c < ALPHABET, otherwise it's special. Look for
1331: * c in the current font, then in others starting at the first special font.
1332: * Save c in lastc so it's available when oput() runs. Restore original font
1333: * before leaving.
1334: *
1335: */
1336:
1337: lastc = c; /* charlib() needs name not code */
1338: if ( (c -= 32) <= 0 )
1339: return;
1340:
1341: k = ofont = font;
1342:
1343: if ( (i = onfont(lastc, k)) == -1 && smnt > 0 )
1344: for ( k = smnt, j = 0; j < nfonts; j++, k = k % nfonts + 1 ) {
1345: if ( (i = onfont(lastc, k)) != -1 ) {
1346: setfont(k);
1347: break;
1348: } /* End if */
1349: } /* End for */
1350:
1351: if ( i != -1 && (code = mount[k]->wp[i].code) != 0 ) {
1352: lastw = widthfac * (((int)mount[k]->wp[i].wid * size + unitwidth/2) / unitwidth);
1353: oput(code);
1354: } /* End if */
1355:
1356: if ( font != ofont )
1357: setfont(ofont);
1358:
1359: } /* End of put1 */
1360:
1361: /*****************************************************************************/
1362:
1363: oput(c)
1364:
1365: int c;
1366:
1367: {
1368:
1369: double llx, lly, urx, ury; /* boundingbox corners */
1370:
1371: /*
1372: *
1373: * Arranges to print the character whose code is c in the current font. All the
1374: * actual positioning is done here, in charlib(), or in the drawing routines.
1375: *
1376: */
1377:
1378: if ( textcount > MAXSTACK ) /* don't put too much on the stack? */
1379: flushtext();
1380:
1381: if ( font != lastfont || size != lastsize )
1382: t_sf();
1383:
1384: if ( vpos != lasty )
1385: endline();
1386:
1387: starttext();
1388:
1389: if ( ABS(hpos - lastx) > slop )
1390: endstring();
1391:
1392: if ( isascii(c) && isprint(c) )
1393: switch ( c ) {
1394: case '(':
1395: case ')':
1396: case '\\':
1397: addchar('\\');
1398:
1399: default:
1400: addchar(c);
1401: } /* End switch */
1402: else if ( c > 040 )
1403: addoctal(c);
1404: else charlib(c);
1405:
1406: if ( dobbox == TRUE ) {
1407: llx = lastx;
1408: lly = -(vpos + 0.5 * (devres * size / 72.0));
1409: urx = lastx + lastw;
1410: ury = -(vpos - (devres * size / 72.0));
1411: cover(llx, lly);
1412: cover(urx, ury);
1413: } /* End if */
1414:
1415: lastx += lastw;
1416:
1417: } /* End of oput */
1418:
1419: /*****************************************************************************/
1420:
1421: starttext()
1422:
1423: {
1424:
1425: /*
1426: * Called whenever we want to be sure we're ready to start collecting characters
1427: * for the next call to PostScript procedure t (ie. the one that prints them). If
1428: * textcount is positive we've already started, so there's nothing to do. The more
1429: * complicated encoding schemes save text strings in the strings[] array and need
1430: * detailed information about the strings when they're written to the output file
1431: * in flushtext().
1432: *
1433: */
1434:
1435: if ( textcount < 1 ) {
1436: switch ( encoding ) {
1437: case 0:
1438: case 1:
1439: putc('(', tf);
1440: break;
1441:
1442: case 2:
1443: case 3:
1444: strptr = strings;
1445: spacecount = 0;
1446: line[1].str = strptr;
1447: line[1].dx = 0;
1448: line[1].spaces = 0;
1449: line[1].start = hpos;
1450: line[1].width = 0;
1451: break;
1452:
1453: case MAXENCODING+1: /* reverse video */
1454: if ( lastend == -1 )
1455: lastend = hpos;
1456: putc('(', tf);
1457: break;
1458:
1459: case MAXENCODING+2: /* follow a funny baseline */
1460: putc('(', tf);
1461: break;
1462: } /* End switch */
1463:
1464: textcount = 1;
1465: lastx = stringstart = hpos;
1466: } /* End if */
1467:
1468: } /* End of starttext */
1469:
1470: /*****************************************************************************/
1471:
1472: flushtext()
1473:
1474: {
1475:
1476: int i;
1477:
1478: /*
1479: *
1480: * Generates a call to the PostScript procedure that processes all the text we've
1481: * accumulated - provided textcount is positive.
1482: *
1483: */
1484:
1485: if ( textcount > 0 ) {
1486: switch ( encoding ) {
1487: case 0:
1488: fprintf(tf, ")%d t\n", stringstart);
1489: break;
1490:
1491: case 1:
1492: fprintf(tf, ")%d %d t\n", stringstart, lasty);
1493: break;
1494:
1495: case 2:
1496: *strptr = '\0';
1497: line[textcount].width = lastx - line[textcount].start;
1498: if ( spacecount != 0 || textcount != 1 ) {
1499: for ( i = textcount; i > 0; i-- )
1500: fprintf(tf, "(%s)%d %d", line[i].str, line[i].spaces, line[i].width);
1501: fprintf(tf, " %d %d %d t\n", textcount, stringstart, lasty);
1502: } else fprintf(tf, "(%s)%d %d w\n", line[1].str, stringstart, lasty);
1503: break;
1504:
1505: case 3:
1506: *strptr = '\0';
1507: if ( spacecount != 0 || textcount != 1 ) {
1508: for ( i = textcount; i > 0; i-- )
1509: fprintf(tf, "(%s)%d", line[i].str, line[i].dx);
1510: fprintf(tf, " %d %d %d t\n", textcount, stringstart, lasty);
1511: } else fprintf(tf, "(%s)%d %d w\n", line[1].str, stringstart, lasty);
1512: break;
1513:
1514: case MAXENCODING+1:
1515: fprintf(tf, ")%d ", stringstart);
1516: fprintf(tf, "%d %d drawrvbox ", lastend - rvslop, (int)(lastx + .5) + rvslop);
1517: fprintf(tf, "t\n", stringstart);
1518: lastend = (lastx + .5) + 2 * rvslop;
1519: break;
1520:
1521: case MAXENCODING+2:
1522: fprintf(tf, ")%d %d t\n", stringstart, lasty);
1523: break;
1524: } /* End switch */
1525: } /* End if */
1526:
1527: textcount = 0;
1528:
1529: } /* End of flushtext */
1530:
1531: /*****************************************************************************/
1532:
1533: endstring()
1534:
1535: {
1536:
1537: int dx;
1538:
1539: /*
1540: *
1541: * Horizontal positions are out of sync. End the last open string, adjust the
1542: * printer's position, and start a new string. Assumes we've already started
1543: * accumulating text.
1544: *
1545: */
1546:
1547: switch ( encoding ) {
1548: case 0:
1549: case 1:
1550: fprintf(tf, ")%d(", stringstart);
1551: textcount++;
1552: lastx = stringstart = hpos;
1553: break;
1554:
1555: case 2:
1556: case 3:
1557: dx = hpos - lastx;
1558: if ( spacecount++ == 0 )
1559: line[textcount].dx = dx;
1560: if ( line[textcount].dx != dx ) {
1561: *strptr++ = '\0';
1562: line[textcount].width = lastx - line[textcount].start;
1563: line[++textcount].str = strptr;
1564: *strptr++ = ' ';
1565: line[textcount].dx = dx;
1566: line[textcount].start = lastx;
1567: line[textcount].width = 0;
1568: line[textcount].spaces = 1;
1569: } else {
1570: *strptr++ = ' ';
1571: line[textcount].spaces++;
1572: } /* End else */
1573: lastx += dx;
1574: break;
1575:
1576: case MAXENCODING+1:
1577: fprintf(tf, ")%d(", stringstart);
1578: textcount++;
1579: lastx = stringstart = hpos;
1580: break;
1581:
1582: case MAXENCODING+2:
1583: flushtext();
1584: starttext();
1585: break;
1586: } /* End switch */
1587:
1588: } /* End of endstring */
1589:
1590: /*****************************************************************************/
1591:
1592: endline()
1593:
1594: {
1595:
1596: /*
1597: *
1598: * The vertical position has changed. Dump any accumulated text, then adjust
1599: * the printer's vertical position.
1600: *
1601: */
1602:
1603: flushtext();
1604:
1605: if ( encoding == 0 || encoding == MAXENCODING+1 )
1606: fprintf(tf, "%d %d m\n", hpos, vpos);
1607:
1608: lastx = stringstart = lastend = hpos;
1609: lasty = vpos;
1610:
1611: } /* End of endline */
1612:
1613: /*****************************************************************************/
1614:
1615: addchar(c)
1616:
1617: int c;
1618:
1619: {
1620:
1621: /*
1622: *
1623: * Does whatever is needed to add character c to the current string.
1624: *
1625: */
1626:
1627: switch ( encoding ) {
1628: case 0:
1629: case 1:
1630: putc(c, tf);
1631: break;
1632:
1633: case 2:
1634: case 3:
1635: *strptr++ = c;
1636: break;
1637:
1638: case MAXENCODING+1:
1639: case MAXENCODING+2:
1640: putc(c, tf);
1641: break;
1642: } /* End switch */
1643:
1644: } /* End of addchar */
1645:
1646: /*****************************************************************************/
1647:
1648: addoctal(c)
1649:
1650: int c;
1651:
1652: {
1653:
1654: /*
1655: *
1656: * Add c to the current string as an octal escape.
1657: *
1658: */
1659:
1660: switch ( encoding ) {
1661: case 0:
1662: case 1:
1663: fprintf(tf, "\\%o", c);
1664: break;
1665:
1666: case 2:
1667: case 3:
1668: sprintf(strptr, "\\%o", c);
1669: strptr += strlen(strptr);
1670: break;
1671:
1672: case MAXENCODING+1:
1673: case MAXENCODING+2:
1674: fprintf(tf, "\\%o", c);
1675: break;
1676: } /* End switch */
1677:
1678: } /* End of addoctal */
1679:
1680: /*****************************************************************************/
1681:
1682: charlib(code)
1683:
1684: int code; /* either 1 or 2 */
1685:
1686: {
1687:
1688: char *name; /* name of the character */
1689: char tname[10]; /* in case it's a single ASCII character */
1690: char temp[150];
1691:
1692: /*
1693: *
1694: * Called from oput() for characters having codes less than 040. Special files
1695: * that define PostScript procedures for certain characters can be found in
1696: * directory *fontdir/devpost/charlib. If there's a file that has the same name as
1697: * the character we're trying to print it's copied to the output file, otherwise
1698: * nothing, except some positioning, is done.
1699: *
1700: * All character definitions are only made once. Subsequent requests to print the
1701: * character generate a call to a procedure that begins with the prefix build_ and
1702: * ends with the character's name. Special characters that are assigned codes
1703: * other than 1 are assumed to have additional data files that should be copied
1704: * to the output file immediately after the build_ call. Those data files should
1705: * end in the suffix .map, and usually will be a hex representation of a bitmap.
1706: *
1707: */
1708:
1709: flushtext();
1710:
1711: if ( lastc < ALPHABET ) { /* ASCII character */
1712: sprintf(tname, "%.3o", lastc);
1713: name = tname;
1714: } else name = chname(lastc);
1715:
1716: if ( downloaded[lastc] == 0 ) {
1717: sprintf(temp, "%s/dev%s/charlib/%s", fontdir, realdev, name);
1718: if ( exportfile(temp) == TRUE ) {
1719: downloaded[lastc] = 1;
1720: t_sf();
1721: } /* End if */
1722: } /* End if */
1723:
1724: if ( downloaded[lastc] == 1 ) {
1725: xymove(hpos, vpos);
1726: fprintf(tf, "%d build_%s\n", (int) lastw, name);
1727: if ( code != 1 ) { /* get the bitmap or whatever */
1728: sprintf(temp, "%s/dev%s/charlib/%s.map", fontdir, realdev, name);
1729: if ( access(temp, 04) == 0 && tf == stdout )
1730: cat(temp);
1731: } /* End if */
1732: fprintf(tf, "%d %d m\n", stringstart = hpos + lastw, vpos);
1733: } /* End if */
1734:
1735: } /* End of charlib */
1736:
1737: /*****************************************************************************/
1738:
1739: reset()
1740:
1741: {
1742:
1743: /*
1744: *
1745: * Reset variables that keep track of the printer's current position, size and
1746: * font. Eventually forces things back in sync before oput() prints the next
1747: * character.
1748: *
1749: */
1750:
1751: lastx = -(slop + 1);
1752: lasty = -1;
1753: lastfont = lastsize = -1;
1754:
1755: } /* End of reset */
1756:
1757: /*****************************************************************************/
1758:
1759: resetpos()
1760:
1761: {
1762:
1763: /*
1764: *
1765: * Reset the position tracking variables. Forces oput() to get positions back
1766: * in sync before printing the next character.
1767: *
1768: */
1769:
1770: lastx = -(slop + 1);
1771: lasty = -1;
1772:
1773: } /* End of resetpos */
1774:
1775: /*****************************************************************************/
1776:
1777: save()
1778:
1779: {
1780:
1781: /*
1782: *
1783: * Save the current PostScript environment. Initialize things that may have
1784: * disappeared after the preceeding restore.
1785: *
1786: */
1787:
1788: fprintf(tf, "/saveobj save def\n");
1789: fprintf(tf, "mark\n");
1790:
1791: if ( encoding != realencoding )
1792: fprintf(tf, "%d setdecoding\n", encoding);
1793:
1794: if ( gotcolor == TRUE ) /* prevent getcolor() recursion */
1795: setcolor();
1796:
1797: } /* End of save */
1798:
1799: /*****************************************************************************/
1800:
1801: restore()
1802:
1803: {
1804:
1805: /*
1806: *
1807: * Restore the previous PostScript environment.
1808: *
1809: */
1810:
1811: flushtext();
1812: fprintf(tf, "cleartomark\n");
1813: fprintf(tf, "saveobj restore\n");
1814: reset();
1815:
1816: } /* End of restore */
1817:
1818: /*****************************************************************************/
1819:
1820: exportfile(path)
1821:
1822: char *path;
1823:
1824: {
1825:
1826: int val = FALSE;
1827:
1828: /*
1829: *
1830: * Exports the contents of file path to the global environment. Returns TRUE
1831: * if we're doing output (i.e. tf == stdout) and the copy worked.
1832: *
1833: */
1834:
1835: if ( tf == stdout && access(path, 04) == 0 ) {
1836: restore();
1837: fprintf(tf, "%s", BEGINGLOBAL);
1838: val = cat(path);
1839: fprintf(tf, "%s", ENDGLOBAL);
1840: save();
1841: } /* End if */
1842:
1843: return(val);
1844:
1845: } /* End of exportfile */
1846:
1847: /*****************************************************************************/
1848:
1849: exportstring(str)
1850:
1851: char *str;
1852:
1853: {
1854:
1855: /*
1856: *
1857: * Exports string str to the global environment. No return value needed yet.
1858: *
1859: */
1860:
1861: if ( tf == stdout && str != NULL && *str != '\0' ) {
1862: restore();
1863: fprintf(tf, "%s", BEGINGLOBAL);
1864: fprintf(tf, "%s", str);
1865: fprintf(tf, "%s", ENDGLOBAL);
1866: save();
1867: } /* End if */
1868:
1869: } /* End of exportstring */
1870:
1871: /*****************************************************************************/
1872:
1873: redirect(pg)
1874:
1875: int pg;
1876:
1877: {
1878:
1879: static FILE *fp_null = NULL;
1880:
1881: /*
1882: *
1883: * If we're not supposed to print page pg, tf will be directed to /dev/null,
1884: * otherwise output goes to stdout.
1885: *
1886: */
1887:
1888: if ( pg >= 0 && in_olist(pg) == ON )
1889: tf = stdout;
1890: else if ( (tf = fp_null) == NULL )
1891: tf = fp_null = fopen("/dev/null", "w");
1892:
1893: } /* End of redirect */
1894:
1895: /*****************************************************************************/
1896:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.