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