![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to readPCL.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / troff / etc|
Return to readPCL.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / troff / etc |
1.1 root 1: /*
2: * readPCL.c
3: * 3/31/93
4: *
5: * Usage: readPCL [ -n ] [ infile [ outfile ]]
6: * Option:
7: * -n Produce nroff output;
8: * e.g. "troff foo.r | readPCL -n | nroff -x | more"
9: * Exit status:
10: * 0 success
11: * 1 unrecognized escape sequences seen
12: * 2 fatal error, e.g. file not found
13: * Requires floating point output: cc readPCL.c -f
14: *
15: * Expand PCL commands into readable text.
16: * This currently handles a very small subset of PCL-5,
17: * including only commands which the troff PCL output writer writes.
18: * Reference: HP "LaserJet III Technical Reference Manual", App. B.
19: */
20:
21: #include <stdio.h>
22: #include <ctype.h>
23:
24: #define VERSION "1.2"
25: #define ESC '\033'
26: #define NVALUE 80 /* max parameter value length */
27:
28: /*
29: * Parameterized commands.
30: * Very small subset of those available.
31: * PVCMD command format depends on parameter value,
32: * PCMD command format does not;
33: * the PVCMD list gets searched first.
34: */
35: typedef struct pvcmd {
36: char pv_char;
37: char pv_group;
38: int pv_value;
39: char pv_param;
40: char *pv_fmt;
41: } PVCMD;
42: typedef struct pcmd {
43: char p_char;
44: char p_group;
45: char p_param;
46: char *p_fmt;
47: } PCMD;
48:
49: /* Parameterized commands with fixed values. */
50: PVCMD pvcmds[] = {
51: { '(', 's', 0, 'p', "fixed" },
52: { '(', 's', 1, 'p', "proportional" },
53: { '(', 's', 0, 's', "upright" },
54: { '(', 's', 1, 's', "italic" },
55: { '&', 'l', 0, 'h', "page eject" }
56: };
57: #define NPVCMDS (sizeof(pvcmds) / sizeof(pvcmds[0]))
58:
59: /* Parameterized commands with arbitrary values; format expects double arg. */
60: PCMD pcmds[] = {
61: { '&', 'a', 'h', "h=%g" },
62: { '&', 'a', 'v', "v=%g" },
63: { '&', 'l', 'e', "top margin=%g" },
64: { '(', '0', 'u', "symset=ASCII" },
65: { '(', 's', 'b', "weight=%g" },
66: { '(', 's', 'h', "pitch=%g" },
67: { '(', 's', 't', "typeface=%g" },
68: { '(', 's', 'v', "pointsize=%g" }
69: };
70: #define NPCMDS (sizeof(pcmds) / sizeof(pcmds[0]))
71:
72: /*
73: * Two-character commands.
74: * Small subset of those available.
75: */
76: typedef struct tcmd {
77: char t_char;
78: char *t_fmt;
79: } TCMD;
80: TCMD tcmds[] = {
81: { '9', "clear" },
82: { 'E', "reset" }
83: };
84: #define NTCMDS (sizeof(tcmds) / sizeof(tcmds[0]))
85:
86: /* External. */
87: extern double atof();
88:
89: /* Forward. */
90: extern void error( /* char *fmt, ... */ );
91: extern void escape( /* void */ );
92: extern void esc_param( /* int c */ );
93: extern void esc_two( /* int c */ );
94: extern void fatal( /* char *fmt, ... */ );
95: extern void lookup( /* int c, int group, double val, int param */ );
96: extern FILE *openfile( /* char *name, char *mode */ );
97: extern void usage( /* void */ );
98: extern double value( /* void */ );
99:
100: /* Globals. */
101: int nflag; /* nroff output */
102: int status; /* exit status */
103: FILE *ifp = stdin; /* input FILE */
104: FILE *ofp = stdout; /* output FILE */
105:
106: int
107: main(argc, argv) int argc; char *argv[];
108: {
109: register char *s;
110: register int c;
111:
112: /* Look for options. */
113: if (argc > 1 && argv[1][0] == '-') {
114: for (s = &argv[1][1]; *s != '\0'; s++) {
115: switch(*s) {
116: case 'n': ++nflag; break;
117: case 'V':
118: fprintf(stderr, "readPCL: V" VERSION "\n");
119: break;
120: default: usage(); break;
121: }
122: }
123: --argc;
124: ++argv;
125: }
126:
127: /* Open files. */
128: if (argc > 1)
129: ifp = openfile(argv[1], "rb");
130: if (argc > 2)
131: ofp = openfile(argv[2], "w");
132:
133: /* Process. */
134: if (nflag)
135: fprintf(ofp, ".nf\n");
136: while ((c = getc(ifp)) != EOF) {
137: if (c == ESC)
138: escape();
139: else
140: putc(c, ofp);
141: }
142:
143: /* Done. */
144: if (ifp != stdin)
145: fclose(ifp);
146: if (ofp != stdout)
147: fclose(ofp);
148: exit(status);
149: }
150:
151: /*
152: * Print an unrecognized escape sequence to the output text
153: * and an error message to stderr.
154: * Bump the error count.
155: */
156: /* VARARGS */
157: void
158: error(fmt) char *fmt;
159: {
160: status = 1;
161: fprintf(ofp, "ESC %r", &fmt);
162: fprintf(stderr, "readPCL: unrecognized ESC sequence: ESC %r", &fmt);
163: }
164:
165: /*
166: * Handle an escape sequence.
167: */
168: void
169: escape()
170: {
171: register int c;
172:
173: putc('\n', ofp);
174: if (nflag)
175: fprintf(ofp, "\\fB");
176: putc('{', ofp);
177: if ((c = getc(ifp)) >= 33 && c <= 47)
178: esc_param(c); /* parameterized */
179: else if (c >= 48 && c <= 126)
180: esc_two(c); /* two-character */
181: else
182: error("%c (0x%X)", c, c);
183: putc('}', ofp);
184: if (nflag)
185: fprintf(ofp, "\\fP");
186: }
187:
188: /*
189: * Parameterized escape sequence starting with c.
190: */
191: void
192: esc_param(c) register int c;
193: {
194: int group, param, done;
195: double val;
196:
197: group = getc(ifp);
198: for (done = 0; !done; ) {
199: val = value();
200: param = getc(ifp);
201: if (param >= 64 && param <= 94) {
202: ++done;
203: param += 32;
204: }
205: lookup(c, group, val, param);
206: if (!done)
207: putc(';', ofp);
208: }
209: }
210:
211: /*
212: * Two-character escape sequence starting with c.
213: */
214: void
215: esc_two(c) register int c;
216: {
217: register TCMD *p;
218:
219: for (p = tcmds; p < &tcmds[NPCMDS]; p++) {
220: if (c == p->t_char) {
221: fprintf(ofp, p->t_fmt);
222: return;
223: }
224: }
225: error("%c (0x%X)", c, c);
226: }
227:
228: /*
229: * Print a fatal error message and die.
230: */
231: /* VARARGS */
232: void
233: fatal(fmt) char *fmt;
234: {
235: fprintf(stderr, "readPCL: %r\n", &fmt);
236: exit(2);
237: }
238:
239: /*
240: * Look up a parameterized command.
241: * Print either a formatted message or an error message.
242: */
243: void
244: lookup(c, group, val, param) int c, group; double val; int param;
245: {
246: register PVCMD *pvp;
247: register PCMD *pcp;
248:
249: /* Look for commands with matching value first. */
250: for (pvp = pvcmds; pvp < &pvcmds[NPVCMDS]; pvp++) {
251: if (c == pvp->pv_char
252: && group == pvp->pv_group
253: && (int)val == pvp->pv_value
254: && param == pvp->pv_param) {
255: fprintf(ofp, pvp->pv_fmt);
256: return;
257: }
258: }
259:
260: /* Then look for commands with arbitrary value. */
261: for (pcp = pcmds; pcp < &pcmds[NPCMDS]; pcp++) {
262: if (c == pcp->p_char
263: && group == pcp->p_group
264: && param == pcp->p_param) {
265: fprintf(ofp, pcp->p_fmt, val);
266: return;
267: }
268: }
269:
270: /* Not found. */
271: error("%c %c %g %c", c, group, val, param);
272: }
273:
274: /*
275: * Open a FILE.
276: */
277: FILE *
278: openfile (name, mode) char *name; char *mode;
279: {
280: register FILE *fp;
281:
282: if ((fp = fopen(name, mode)) == NULL)
283: fatal("cannot open file \"%s\"", name);
284: return fp;
285: }
286:
287: /*
288: * Print a usage message and die.
289: */
290: void
291: usage()
292: {
293: fprintf(stderr,
294: "Usage: readPCL [ -n ] [ infile [ outfile ]]\n"
295: "Option:\n"
296: "\t-n\tProduce nroff output;\n"
297: "\t\te.g. \"troff foo.r | readPCL -n | nroff -x | more\"\n"
298: );
299: exit(1);
300: }
301:
302: /*
303: * Read a PCL value field:
304: * ASCII number consisting of optional sign, digits and optional decimal point.
305: * Return 0.0 if the value is missing.
306: */
307: double
308: value()
309: {
310: char buf[NVALUE];
311: register char *cp;
312: register int c, s, dotseen;
313: double d;
314:
315: /* Handle optional sign. */
316: dotseen = s = 0;
317: if ((c = getc(ifp)) == '-')
318: ++s;
319: else if (c != '+')
320: ungetc(c, ifp);
321:
322: /* Read the number into buf[]. */
323: for (cp = buf; isdigit(c = getc(ifp)) || (c=='.' && (dotseen++ == 0)); )
324: *cp++ = c;
325: *cp = '\0';
326: ungetc(c, ifp);
327:
328: /* Return converted value; note that atof("") returns 0.0. */
329: d = atof(buf);
330: return (s) ? -d : d;
331: }
332:
333: /* end of readPCL.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.