![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to postreverse.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 / postreverse|
Return to postreverse.c CVS log | Up to [Research Unix] / researchv10no / cmd / post.src / postreverse |
1.1 root 1: /*
2: *
3: * postreverse - reverse the page order in certain PostScript files.
4: *
5: * Page reversal relies on being able to locate sections of a document using file
6: * structuring comments defined by Adobe (ie. the 1.0 and now 2.0 conventions) and
7: * a few I've added. Among other things a minimally conforming document, according
8: * to the 1.0 conventions,
9: *
10: * 1) Marks the end of the prologue with an %%EndProlog comment.
11: *
12: * 2) Starts each page with a %%Page: comment.
13: *
14: * 3) Marks the end of all the pages %%Trailer comment.
15: *
16: * 4) Obeys page independence (ie. pages can be arbitrarily rearranged).
17: *
18: * The most important change (at least for this program) that Adobe made in going
19: * from the 1.0 to the 2.0 structuring conventions was in the prologue. They now
20: * say the prologue should only define things, and the global initialization that
21: * was in the prologue (1.0 conventions) should now come after the %%EndProlog
22: * comment but before the first %%Page: comment and be bracketed by %%BeginSetup
23: * and %%EndSetup comments. So a document that conforms to Adobe's 2.0 conventions,
24: *
25: * 1) Marks the end of the prologue (only definitions) with %%EndProlog.
26: *
27: * 2) Brackets global initialization with %%BeginSetup and %%EndSetup comments
28: * which come after the prologue but before the first %Page: comment.
29: *
30: * 3) Starts each page with a %%Page: comment.
31: *
32: * 4) Marks the end of all the pages with a %%Trailer comment.
33: *
34: * 5) Obeys page independence.
35: *
36: * postreverse can handle documents that follow the 1.0 or 2.0 conventions, but has
37: * also been extended slightly so it works properly with the translators (primarily
38: * dpost) supplied with this package. The page independence requirement has been
39: * relaxed some. In particular definitions exported to the global environment from
40: * within a page should be bracketed by %%BeginGlobal and %%EndGlobal comments.
41: * postreverse pulls them out of each page and inserts them in the setup section
42: * of the document, immediately before it writes the %%EndProlog (for version 1.0)
43: * or %%EndSetup (for version 2.0) comments.
44: *
45: * In addition postreverse accepts documents that choose to mark the end of each
46: * page with a %%EndPage: comment, which from a translator's point of view is often
47: * a more natural approach. Both page boundary comments (ie. Page: and %%EndPage:)
48: * are also accepted, but be warned that everything between consecutive %%EndPage:
49: * and %%Page: comments will be ignored.
50: *
51: * So a document that will reverse properly with postreverse,
52: *
53: * 1) Marks the end of the prologue with %%EndProlog.
54: *
55: * 2) May have a %%BeginSetup/%%EndSetup comment pair before the first %%Page:
56: * comment that brackets any global initialization.
57: *
58: * 3) Marks the start of each page with a %%Page: comment, or the end of each
59: * page with a %%EndPage: comment. Both page boundary comments are allowed.
60: *
61: * 4) Marks the end of all the pages with a %%Trailer comment.
62: *
63: * 5) Obeys page independence or violates it to a rather limited extent and
64: * marks the violations with %%BeginGlobal and %%EndGlobal comments.
65: *
66: * If no file arguments are given postreverse copies stdin to a temporary file and
67: * then processes that file. That means the input is read three times (rather than
68: * two) whenever we handle stdin. That's expensive, and shouldn't be too difficult
69: * to fix, but I haven't gotten around to it yet.
70: *
71: */
72:
73: #include <stdio.h>
74: #include <signal.h>
75: #include <fcntl.h>
76:
77: #include "comments.h" /* PostScript file structuring comments */
78: #include "gen.h" /* general purpose definitions */
79: #include "path.h" /* for temporary directory */
80: #include "ext.h" /* external variable declarations */
81: #include "postreverse.h" /* a few special definitions */
82:
83: int page = 1; /* current page number */
84: int forms = 1; /* forms per page in the input file */
85:
86: char *temp_dir = TEMPDIR; /* temp directory for copying stdin */
87:
88: Pages pages[1000]; /* byte offsets for all pages */
89: int next_page = 0; /* next page goes here */
90: long start; /* starting offset for next page */
91: long endoff = -1; /* offset where TRAILER was found */
92: int noreverse = FALSE; /* don't reverse pages if TRUE */
93: char *endprolog = ENDPROLOG; /* occasionally changed to ENDSETUP */
94:
95: double version = 3.3; /* of the input file */
96: int ignoreversion = FALSE; /* ignore possible forms.ps problems */
97:
98: char buf[2048]; /* line buffer for input file */
99:
100: FILE *fp_in; /* stuff is read from this file */
101: FILE *fp_out = stdout; /* and written here */
102:
103: /*****************************************************************************/
104:
105: main(agc, agv)
106:
107: int agc;
108: char *agv[];
109:
110: {
111:
112: /*
113: *
114: * A simple program that reverses the pages in specially formatted PostScript
115: * files. Will work with all the translators in this package, and should handle
116: * any document that conforms to Adobe's version 1.0 or 2.0 file structuring
117: * conventions. Only one input file is allowed, and it can either be a named (on
118: * the command line) file or stdin.
119: *
120: */
121:
122: argc = agc; /* other routines may want them */
123: argv = agv;
124:
125: prog_name = argv[0]; /* just for error messages */
126:
127: init_signals(); /* sets up interrupt handling */
128: options(); /* first get command line options */
129: arguments(); /* then process non-option arguments */
130: done(); /* and clean things up */
131:
132: exit(x_stat); /* not much could be wrong */
133:
134: } /* End of main */
135:
136: /*****************************************************************************/
137:
138: init_signals()
139:
140: {
141:
142: /*
143: *
144: * Makes sure we handle interrupts properly.
145: *
146: */
147:
148: if ( signal(SIGINT, interrupt) == SIG_IGN ) {
149: signal(SIGINT, SIG_IGN);
150: signal(SIGQUIT, SIG_IGN);
151: signal(SIGHUP, SIG_IGN);
152: } else {
153: signal(SIGHUP, interrupt);
154: signal(SIGQUIT, interrupt);
155: } /* End else */
156:
157: signal(SIGTERM, interrupt);
158:
159: } /* End of init_signals */
160:
161: /*****************************************************************************/
162:
163: options()
164:
165: {
166:
167: int ch; /* return value from getopt() */
168: char *optnames = "n:o:rvT:DI";
169:
170: extern char *optarg; /* used by getopt() */
171: extern int optind;
172:
173: /*
174: *
175: * Reads and processes the command line options. The -r option (ie. the one that
176: * turns page reversal off) is really only useful if you want to take dpost output
177: * and produce a page independent output file. In that case global definitions
178: * made within pages and bracketed by %%BeginGlobal/%%EndGlobal comments will be
179: * moved into the prologue or setup section of the document.
180: *
181: */
182:
183: while ( (ch = getopt(argc, argv, optnames)) != EOF ) {
184: switch ( ch ) {
185: case 'n': /* forms per page */
186: if ( (forms = atoi(optarg)) <= 0 )
187: error(FATAL, "illegal forms request %s", optarg);
188: break;
189:
190: case 'o': /* output page list */
191: out_list(optarg);
192: break;
193:
194: case 'r': /* don't reverse the pages */
195: noreverse = TRUE;
196: break;
197:
198: case 'v': /* ignore possible forms.ps problems */
199: ignoreversion = TRUE;
200: break;
201:
202: case 'T': /* temporary file directory */
203: temp_dir = optarg;
204: break;
205:
206: case 'D': /* debug flag */
207: debug = ON;
208: break;
209:
210: case 'I': /* ignore FATAL errors */
211: ignore = ON;
212: break;
213:
214: case '?': /* don't understand the option */
215: error(FATAL, "");
216: break;
217:
218: default: /* don't know what to do for ch */
219: error(FATAL, "missing case for option %c\n", ch);
220: break;
221: } /* End switch */
222: } /* End while */
223:
224: argc -= optind; /* get ready for non-option args */
225: argv += optind;
226:
227: } /* End of options */
228:
229: /*****************************************************************************/
230:
231: arguments()
232:
233: {
234:
235: char *name; /* name of the input file */
236:
237: /*
238: *
239: * postreverse only handles one input file at a time, so if there's more than one
240: * argument left when we get here we'll quit. If none remain we copy stdin to a
241: * temporary file and process that file.
242: *
243: */
244:
245: if ( argc > 1 ) /* can't handle more than one file */
246: error(FATAL, "too many arguments");
247:
248: if ( argc == 0 ) /* copy stdin to a temporary file */
249: name = copystdin();
250: else name = *argv;
251:
252: if ( (fp_in = fopen(name, "r")) == NULL )
253: error(FATAL, "can't open %s", name);
254:
255: reverse();
256:
257: } /* End of arguments */
258:
259: /*****************************************************************************/
260:
261: done()
262:
263: {
264:
265: /*
266: *
267: * Cleans things up after we've finished reversing the pages in the input file.
268: * All that's really left to do is remove the temp file, provided we used one.
269: *
270: */
271:
272: if ( temp_file != NULL )
273: unlink(temp_file);
274:
275: } /* End of done */
276:
277: /*****************************************************************************/
278:
279: char *copystdin()
280:
281: {
282:
283: int fd_out; /* for the temporary file */
284: int fd_in; /* for stdin */
285: int count; /* number of bytes put in buf[] */
286:
287: /*
288: *
289: * Copies stdin to a temporary file and returns the pathname of that file to the
290: * caller. It's an expensive way of doing things, because it means we end up
291: * reading the input file three times - rather than just twice. Could probably be
292: * fixed by creating the temporary file on the fly as we read the file the first
293: * time.
294: *
295: */
296:
297: if ( (temp_file = tempnam(temp_dir, "post")) == NULL )
298: error(FATAL, "can't generate temp file name");
299:
300: if ( (fd_out = creat(temp_file, 0660)) == -1 )
301: error(FATAL, "can't open %s", temp_file);
302:
303: fd_in = fileno(stdin);
304:
305: while ( (count = read(fd_in, buf, sizeof(buf))) > 0 )
306: if ( write(fd_out, buf, count) != count )
307: error(FATAL, "error writing to %s", temp_file);
308:
309: close(fd_out);
310:
311: return(temp_file);
312:
313: } /* End of copystdin */
314:
315: /*****************************************************************************/
316:
317: reverse()
318:
319: {
320:
321: /*
322: *
323: * Begins by looking for the ENDPROLOG comment in the input file. Everything up to
324: * that comment is copied to the output file. If the comment isn't found the entire
325: * input file is copied and moreprolog() returns FALSE. Otherwise readpages() reads
326: * the rest of the input file and remembers (in pages[]) where each page starts and
327: * ends. In addition everything bracketed by %%BeginGlobal and %%EndGlobal comments
328: * is immediately added to the new prologue (or setup section) and ends up being
329: * removed from the individual pages. When readpages() finds the TRAILER comment
330: * or gets to the end of the input file we go back to the pages[] array and use
331: * the saved offsets to write the pages out in reverse order. Finally everything
332: * from the TRAILER comment to the end of the input file is copied to the output
333: * file.
334: *
335: */
336:
337: if ( moreprolog(ENDPROLOG) == TRUE ) {
338: readpages();
339: writepages();
340: trailer();
341: } /* End if */
342:
343: } /* End of reverse */
344:
345: /*****************************************************************************/
346:
347: moreprolog(str)
348:
349: char *str; /* copy everything up to this string */
350:
351: {
352:
353: int len; /* length of FORMSPERPAGE string */
354: int vlen; /* length of VERSION string */
355:
356: /*
357: *
358: * Looks for string *str at the start of a line and copies everything up to that
359: * string to the output file. If *str isn't found the entire input file will end
360: * up being copied to the output file and FALSE will be returned to the caller.
361: * The first call (made from reverse()) looks for ENDPROLOG. Any other call comes
362: * from readpages() and will be looking for the ENDSETUP comment.
363: *
364: */
365:
366: len = strlen(FORMSPERPAGE);
367: vlen = strlen(VERSION);
368:
369: while ( fgets(buf, sizeof(buf), fp_in) != NULL ) {
370: if ( strcmp(buf, str) == 0 )
371: return(TRUE);
372: else if ( strncmp(buf, FORMSPERPAGE, len) == 0 )
373: forms = atoi(&buf[len+1]);
374: else if ( strncmp(buf, VERSION, vlen) == 0 )
375: version = atof(&buf[vlen+1]);
376: fprintf(fp_out, "%s", buf);
377: } /* End while */
378:
379: return(FALSE);
380:
381: } /* End of moreprolog */
382:
383: /*****************************************************************************/
384:
385: readpages()
386:
387: {
388:
389: int endpagelen; /* length of ENDPAGE */
390: int pagelen; /* and PAGE strings */
391: int sawendpage = TRUE; /* ENDPAGE equivalent marked last page */
392: int gotpage = FALSE; /* TRUE disables BEGINSETUP stuff */
393:
394: /*
395: *
396: * Records starting and ending positions of the requested pages (usually all of
397: * them), puts global definitions in the prologue, and remembers where the TRAILER
398: * was found.
399: *
400: * Page boundaries are marked by the strings PAGE, ENDPAGE, or perhaps both.
401: * Application programs will normally find one or the other more convenient, so
402: * in most cases only one kind of page delimiter will be found in a particular
403: * document.
404: *
405: */
406:
407: pages[0].start = ftell(fp_in); /* first page starts after ENDPROLOG */
408: endprolog = ENDPROLOG;
409:
410: endpagelen = strlen(ENDPAGE);
411: pagelen = strlen(PAGE);
412:
413: while ( fgets(buf, sizeof(buf), fp_in) != NULL )
414: if ( buf[0] != '%' )
415: continue;
416: else if ( strncmp(buf, ENDPAGE, endpagelen) == 0 ) {
417: if ( in_olist(page++) == ON ) {
418: pages[next_page].empty = FALSE;
419: pages[next_page++].stop = ftell(fp_in);
420: } /* End if */
421: pages[next_page].start = ftell(fp_in);
422: sawendpage = TRUE;
423: gotpage = TRUE;
424: } else if ( strncmp(buf, PAGE, pagelen) == 0 ) {
425: if ( sawendpage == FALSE && in_olist(page++) == ON ) {
426: pages[next_page].empty = FALSE;
427: pages[next_page++].stop = ftell(fp_in) - strlen(buf);
428: } /* End if */
429: pages[next_page].start = ftell(fp_in) - strlen(buf);
430: sawendpage = FALSE;
431: gotpage = TRUE;
432: } else if ( gotpage == FALSE && strcmp(buf, BEGINSETUP) == 0 ) {
433: fprintf(fp_out, "%s", endprolog);
434: fprintf(fp_out, "%s", BEGINSETUP);
435: moreprolog(ENDSETUP);
436: endprolog = ENDSETUP;
437: } else if ( strcmp(buf, BEGINGLOBAL) == 0 ) {
438: moreprolog(ENDGLOBAL);
439: } else if ( strcmp(buf, TRAILER) == 0 ) {
440: if ( sawendpage == FALSE )
441: pages[next_page++].stop = ftell(fp_in) - strlen(buf);
442: endoff = ftell(fp_in);
443: break;
444: } /* End if */
445:
446: } /* End of readpages */
447:
448: /*****************************************************************************/
449:
450: writepages()
451:
452: {
453:
454: int i, j, k; /* loop indices */
455:
456: /*
457: *
458: * Goes through the pages[] array, usually from the bottom up, and writes out all
459: * the pages. Documents that print more than one form per page cause things to get
460: * a little more complicated. Each physical page has to have its subpages printed
461: * in the correct order, and we have to build a few dummy subpages for the last
462: * (and now first) sheet of paper, otherwise things will only occasionally work.
463: *
464: */
465:
466: fprintf(fp_out, "%s", endprolog);
467:
468: if ( noreverse == FALSE ) /* fill out the first page */
469: for ( i = (forms - next_page % forms) % forms; i > 0; i--, next_page++ )
470: pages[next_page].empty = TRUE;
471: else forms = next_page; /* turns reversal off in next loop */
472:
473: for ( i = next_page - forms; i >= 0; i -= forms )
474: for ( j = i, k = 0; k < forms; j++, k++ )
475: if ( pages[j].empty == TRUE ) {
476: if ( ignoreversion == TRUE || version > 3.1 ) {
477: fprintf(fp_out, "%s 0 0\n", PAGE);
478: fprintf(fp_out, "/saveobj save def\n");
479: fprintf(fp_out, "showpage\n");
480: fprintf(fp_out, "saveobj restore\n");
481: fprintf(fp_out, "%s 0 0\n", ENDPAGE);
482: } else {
483: fprintf(fp_out, "%s 0 0\n", PAGE);
484: fprintf(fp_out, "save showpage restore\n");
485: fprintf(fp_out, "%s 0 0\n", ENDPAGE);
486: } /* End else */
487: } else copypage(pages[j].start, pages[j].stop);
488:
489: } /* End of writepages */
490:
491: /*****************************************************************************/
492:
493: copypage(start, stop)
494:
495: long start; /* starting from this offset */
496: long stop; /* and ending here */
497:
498: {
499:
500: /*
501: *
502: * Copies the page beginning at offset start and ending at stop to the output
503: * file. Global definitions are skipped since they've already been added to the
504: * prologue.
505: *
506: */
507:
508: fseek(fp_in, start, 0);
509:
510: while ( ftell(fp_in) < stop && fgets(buf, sizeof(buf), fp_in) != NULL )
511: if ( buf[0] == '%' && strcmp(buf, BEGINGLOBAL) == 0 )
512: while ( fgets(buf, sizeof(buf), fp_in) != NULL && strcmp(buf, ENDGLOBAL) != 0 ) ;
513: else fprintf(fp_out, "%s", buf);
514:
515: } /* End of copypage */
516:
517: /*****************************************************************************/
518:
519: trailer()
520:
521: {
522:
523: /*
524: *
525: * Makes sure everything from the TRAILER string to EOF is copied to the output
526: * file.
527: *
528: */
529:
530: if ( endoff > 0 ) {
531: fprintf(fp_out, "%s", TRAILER);
532: fseek(fp_in, endoff, 0);
533: while ( fgets(buf, sizeof(buf), fp_in) != NULL )
534: fprintf(fp_out, "%s", buf);
535: } /* End if */
536:
537: } /* End of trailer */
538:
539: /*****************************************************************************/
540:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.