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