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