![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ipfe.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / dipress / src / bin / ipfe|
Return to ipfe.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / dipress / src / bin / ipfe |
1.1 ! root 1: /*** file = ipfe.c ********************************************/ ! 2: ! 3: /*** start of specifications ************************************ ! 4: * ! 5: * name = ipfe ! 6: * descriptive name = interpress file editor ! 7: * filename = ipfe.c ! 8: * module type = main ! 9: * subsystem name = interpress toolkit ! 10: * copyright = (c) 1985, 1986, xerox corporation ! 11: * author = mark l. rollins ! 12: * date written = 10/oct/85 ! 13: * ! 14: * change activity = ! 15: * 07/18/86 r1.05 mlr wrc: changed so Scale follows, rather than ! 16: * precedes, Rotate, BindingOffset, XOffset, ! 17: * and YOffset in output processing ! 18: * 06/16/86 r1.04 mlr wrc: add Scale processing ! 19: * 05/19/86 r1.03 mlr wrc: fixed bug in dsply of Y-offset values ! 20: * 04/22/86 r1.02 mlr wrc: fixed bug in pagerange parsing that gave ! 21: * error on terminating "]"; ! 22: * add vers display ! 23: * 03/14/86 r1.01 mlr wrc: major enhancements ! 24: * 10/10/85 r1.00 mlr wrc: original date ! 25: * ! 26: * release = r1.05 ! 27: * date = 18/jul/86 ! 28: * ! 29: * function = provide the following skeleton- and page-level functions ! 30: * for editing interpress masters: ! 31: * . concatenate masters ! 32: * . merge pages from multiple masters into one master ! 33: * . overlay selected pages as a single page (may be ! 34: * combined with merge function) ! 35: * . chapterize a master into multiple masters ! 36: * . satisfy sequenceInsertFile & sequenceInsertMaster ! 37: * references ! 38: * . resolve alias and binding offset printing instructions ! 39: * . return information about the properties of a set of ! 40: * masters ! 41: * ! 42: * function description = ! 43: * ! 44: * Usage: ipfe [ options ] file [ pagerange] ... [ file [pagerange] ...] ! 45: * Options: [-l logfile] [-dDiLqrRsS] [-a alias:actual [-a alias:actual] ! 46: * ...] [-b offset:unit] [-c count:unit] [-o outfile] ! 47: * [-p level:propfile] [-S factor] [-X offset:unit] ! 48: * [-Y offset:unit] ! 49: * ! 50: * -a alias:actual ! 51: * (alias). If the -s option is specified, ! 52: * replace any SIF matching the string "alias" ! 53: * with the string "actual" before attempting ! 54: * to satisfy the SIF. If "actual" cannot be ! 55: * opened or there is some error, the SIF ! 56: * "alias" is preserved, unless the -r option ! 57: * is also specified. ! 58: * -b offset:unit (binding offset). Shift the image offset units ! 59: * in the x-direction, where unit may be: none ! 60: * (default centimeters), c (centimeters), i ! 61: * (inches), p (points), P (Picas). If the -L ! 62: * (Landscape) switch is set, the image offset ! 63: * is in the y-direction. ! 64: * -c count:unit (chapterize) every count units, where unit may ! 65: * be p (pages), k (kilobytes), or m (megabytes). ! 66: * -d (duplex). For resolving binding offset. ! 67: * -D (Debug). If the -p option is specified, also ! 68: * write to the properties file the offsets of ! 69: * each skeleton-level token encountered. ! 70: * -i (insert SIF for overlay). Insert (create) a ! 71: * SIF for any unresolvable overlays. ! 72: * -l logfile (log). Keep a running log. ! 73: * -L (Landscape). Rotate every page 90 degrees ! 74: * counterclockwise and preserve the upper left ! 75: * corner. Intended for printing text in ! 76: * landscape orientation. ! 77: * -o outfile (output). Where the output goes. If there is ! 78: * no -o and there is a -p, only the properties ! 79: * are written, else if there is no -o ! 80: * "infile.ip" is used if it doesn't already ! 81: * exist, else "infileN.ip" is used, where N ! 82: * is the lowest ordinal number such that ! 83: * "infileN.ip" does not already exist. ! 84: * -p level:propfile ! 85: * (properties). Where the properties are ! 86: * written. Increasing levels provide increasing ! 87: * information details. ! 88: * -q (quiet). Don't write info & error msgs (to ! 89: * STDERR). ! 90: * -r (remove SIFS). If -s is also specified, it ! 91: * takes precedence and a SIF reference is ! 92: * removed only if it is unresolved or there is ! 93: * some other error. ! 94: * -R (Rotate). Rotate every page 90 degrees ! 95: * clockwise and preserve the center point. ! 96: * Intended for rotating an image created for ! 97: * a "landscape printer" to print in portrait ! 98: * orientation. ! 99: * -s (satisfy SIFS). Replace any SIF references ! 100: * tokens found in the referenced file. If the ! 101: * referenced file cannot be opened, the SIF ! 102: * reference is preserved unless -r is also ! 103: * specified. ! 104: * -S factor (scale). Scale the image by factor. ! 105: * -X offset:unit (X-imageShift). Shift the image offset units ! 106: * in the x-direction, where unit may be: none ! 107: * (default centimeters), c (centimeters), i ! 108: * (inches), p (points), P (Picas). The shift ! 109: * is independent of the -L and -R switches ! 110: * (i.e., the x-direction is the same as the ! 111: * unrotated image). ! 112: * -Y offset:unit (Y-imageShift). Shift the image offset units ! 113: * in the y-direction, where unit may be: none ! 114: * (default centimeters), c (centimeters), i ! 115: * (inches), p (points), P (Picas). The shift ! 116: * is independent of the -L and -R switches ! 117: * (i.e., the y-direction is the same as the ! 118: * unrotated image). ! 119: * infile [pagerange] ! 120: * See the manual page for syntax details. ! 121: * Example: ! 122: * [1,4-6,9[pic1],10-11,12[pic2:2(2P,4P)][pic3(-4P,-2P)],15-] ! 123: * include page 1. ! 124: * skip pages 2-3. ! 125: * include pages 4-6. ! 126: * skip pages 7-8. ! 127: * include page 9, overlaying it with pic1. ! 128: * include pages 10-11. ! 129: * include pages 12, overlaying it with page 2 of ! 130: * pic2 at an offset of 2 Picas to the right ! 131: * and 4 Picas up, and pic3 at an offset of ! 132: * 4 Picas to the left and 2 Picas down. ! 133: * skip pages 13-14. ! 134: * include pages 15 thru the end of the master. ! 135: * ! 136: * linkage = ! 137: * entry = exec ipfe ! 138: * input = see cmd line options above ! 139: * output = interpress master(s), STDERR, log file, property file ! 140: * exit = exit(exit_status) ! 141: * ! 142: * publics = ! 143: * ! 144: * dependencies = ! 145: * src = iptokens.h, ipnames.h ! 146: * obj = ! 147: * lnk = ! 148: * ! 149: * environment = ! 150: * runtime = vax/masscomp unix/4.23bsd ! 151: * development = vax unix/4.23bsd ! 152: * processor = cc ! 153: * code = unix c mnemonics & linkages ! 154: * ! 155: *** end of specifications **************************************/ ! 156: ! 157: #ifdef vax11c ! 158: # include stdio ! 159: # include setjmp ! 160: # include ctype ! 161: #else ! 162: # include <stdio.h> ! 163: /*** ! 164: # include <sys/time.h> ! 165: # include <sys/resource.h> ! 166: ***/ ! 167: # include <setjmp.h> ! 168: # include <ctype.h> ! 169: #endif ! 170: ! 171: #include "iptokens.h" ! 172: #include "ipnames.h" ! 173: ! 174: ! 175: #define IPFE_VERS "1.05" ! 176: #define IPFE_DATE "18 JUL 86" ! 177: ! 178: #define FALSE 0 ! 179: #define TRUE 1 ! 180: #define FLAG_OFF 0 ! 181: #define FLAG_ON 1 ! 182: ! 183: #define CR 13 ! 184: #define BEL 07 ! 185: #define BS 08 ! 186: #define TAB 09 ! 187: #define LF 10 ! 188: #define FF 12 ! 189: #define TOF 12 ! 190: #define SPC 32 ! 191: #define ESC 27 ! 192: #define DEL 127 ! 193: ! 194: #define STDIN stdin ! 195: #define STDOUT stdout ! 196: #define STDERR stderr ! 197: #define STDIN_DEV 0 ! 198: #define STDOUT_DEV 1 ! 199: #define STDERR_DEV 2 ! 200: #define DEF_LOGFILENAME "ipfe.log" ! 201: #define DEF_OUTFILENAME "ipfe.ip" ! 202: #define DEF_PROPFILENAME "ipfe.prop" ! 203: #define DEF_WORKFILENAME "ipfe.wrk" ! 204: #define BUFSIZE 2048 ! 205: #define OP_Mask 0xe0 ! 206: #define OK 0 ! 207: #define ERROR (-1) ! 208: #define DONT_FORMAT 0 ! 209: #define FORMAT 1 ! 210: #define MX_NO_INFILES 64 ! 211: #define MX_NO_OUTFILES 64 ! 212: #define MX_NO_OVLY_FILES 64 ! 213: #define IP_HDR_CHKLEN 17 ! 214: #define IP_VERS_OFFSET 17 ! 215: #define IP_HDR_MASTERLEN 21 ! 216: #define MX_HDR_BUFLEN 255 ! 217: #define MX_NO_ALIASES 128 ! 218: #define MX_NO_MPG_ENTRIES 128 ! 219: #define MX_BLOCK_DEPTH 8 ! 220: #define MX_BODY_DEPTH 8 ! 221: #define MX_BOP_DEPTH 16 /* max # of nested body_operators */ ! 222: #define MX_SIF_DEPTH 8 /* max sif nesting depth */ ! 223: #define INDENT_INCR 3 /* # cols to incr indent each nesting depth */ ! 224: ! 225: /* ! 226: * defines for ipfe fn types ! 227: */ ! 228: #define CONCAT 0 ! 229: #define CHAPTERIZE 1 ! 230: #define SATISFY_SIFS 2 ! 231: #define REMOVE_SIFS 3 ! 232: #define PROPERTIES 4 ! 233: #define INSERT_OVLY 5 ! 234: #define DEBUG 6 ! 235: #define PROC_LOG 7 ! 236: #define FORCE_STDOUT 8 ! 237: #define BINDING_OFFSET 9 ! 238: #define DUPLEX 10 ! 239: #define QUIET 11 ! 240: #define LANDSCAPE 12 ! 241: #define ROTATE 13 ! 242: #define SCALE 14 ! 243: #define X_OFFSET 15 ! 244: #define Y_OFFSET 16 ! 245: #define NUM_FNS 17 ! 246: ! 247: /* ! 248: * defines for chapterization type ! 249: */ ! 250: #define CH_PAGES 1 ! 251: #define CH_KBYTES 2 ! 252: #define CH_MBYTES 3 ! 253: ! 254: #ifdef lcv2 /* if Lattice C vers 2.15 or earlier */ ! 255: #define void int ! 256: #endif ! 257: ! 258: /* ! 259: * lattice C defines for fopen file types (binary & text) ! 260: */ ! 261: #define BINARY_FILE 0x8000 ! 262: #define TEXT_FILE 0 ! 263: ! 264: FILE *input; ! 265: FILE *output; ! 266: FILE *workfile; /* work file for testing input file opens & storing ! 267: hdr/preamble for chapterizing */ ! 268: FILE *ovly_file; ! 269: FILE *sif_file[MX_SIF_DEPTH]; ! 270: FILE *siffile; ! 271: FILE *logfile; ! 272: FILE *propfile; ! 273: ! 274: jmp_buf next_file; ! 275: ! 276: extern int errno; ! 277: ! 278: ! 279: int _fmode = TEXT_FILE; /* lattice C file_mode */ ! 280: int abort_flag, debug_flag; ! 281: int terrno; ! 282: int exit_status; ! 283: ! 284: long pos, in_offset, out_offset; ! 285: long out_beg_offset[MX_BLOCK_DEPTH], ! 286: out_end_offset[MX_BLOCK_DEPTH]; ! 287: long chap_val; ! 288: long boff_num, boff_den; /* binding offset numerator, denominator */ ! 289: long xoff_num, xoff_den; /* xOffset numerator, denominator */ ! 290: long yoff_num, yoff_den; /* yOffset numerator, denominator */ ! 291: long rxoff_num, rxoff_den, /* rotation xOffset numerator, denominator */ ! 292: ryoff_num, ryoff_den; /* yOffset numerator, denominator */ ! 293: long scale_num, scale_den; /* scale factor numerator, denominator */ ! 294: long blk_num_bytes[MX_BLOCK_DEPTH]; ! 295: long pg_num_bytes; ! 296: ! 297: int num_infiles, out_filnum; ! 298: int input_indx, output_indx, sif_indx; ! 299: int prop_level; ! 300: ! 301: int cur_indent, off_indent, cur_col; ! 302: int ovly_flag; ! 303: int proc_flag[NUM_FNS]; ! 304: int chap_type; ! 305: int ipwrite_flag; ! 306: int rot_deg; /* rotation degrees */ ! 307: int num_aliases; ! 308: int alias_indx; ! 309: ! 310: int begBody_flag; ! 311: int preamble_expected, endpreamble_expected, frstpg_flag, ! 312: bop_preamble_expected[MX_BOP_DEPTH]; ! 313: /* ! 314: * MERGE & OVERLAY ARRAYS ! 315: * There are 2 second order arrays, one for merge pages and one for ! 316: * overlay files. The 1st order of both is indexed by input_indx, and ! 317: * the 2nd order by merge_indx. For overlay files, there are 3 ! 318: * additional arrays, one for an overlay pagenum, one for page offset ! 319: * numerators, and one for page offset denominators. These 3 arrays ! 320: * are indexed by ovly_indx (the 1st order indexing for the numerator ! 321: * and denominator arrays is 0 for the x-offset and 1 for the y-offset). ! 322: * ! 323: * Each 2nd order vector of the merge_pg[][] array is initialized to ! 324: * (-1),0,0,... which indicates to include all pages, and each vector ! 325: * of the ovly_pg[][] array is initialized to (-1),(-1),(-1),... which ! 326: * indicates no overlay files. ! 327: * As IPFE scans the command line, an entry is put into the merge_pg[][] ! 328: * array for each pageNum specified in a pagerange for an infile (the ! 329: * value put into the entry is pageNum). If there is an overlay file ! 330: * specified for pageNum, the (-1) in the ovly_pg[][merge_indx] entry ! 331: * is replaced with the current value of ovly_indx and ovly_indx is ! 332: * incremented. If there is another overlay file specified for pageNum, ! 333: * the value pageNum is repeated in the next merge_pg[][] entry and the ! 334: * incremented ovly_indx is placed in the next ovly_pg[][] entry. ! 335: * Example: ! 336: * ipfe infile "[2,4-6,9[ovly1],12[ovly2][ovly3],15-]" ! 337: * will yield the following merge_pg[input_indx][] & ! 338: * ovly_pg[input_indx][] vectors: ! 339: * 0 1 2 3 4 5 6 7 8 9 10 ! 340: * ----|----|----|----|----|----|----|----|----|----|---- ! 341: * merge_pg: 2 , 4 ,(-1), 6 , 9 , 12 , 12 , 15 ,(-1), 0 , 0 ,... ! 342: * ovly_pg: (-1),(-1),(-1),(-1), 0 , 1 , 2 ,(-1),(-1),(-1),(-1),... ! 343: * ! 344: * The algorithm used to decode the merge_pg vector for each infile is ! 345: * as follows: ! 346: * Initialize merge_indx to 0; ! 347: * Loop: ! 348: * Current_entry = merge_pg[input_indx][merge_indx]; ! 349: * If Current_entry = 0, we're all done with this infile; ! 350: * Else if Current_entry = (-1), look at next merge_indx entry; ! 351: * Next_entry = merge_pg[input_indx][merge_indx+1]; ! 352: * If Next_entry = 0, include all pages to the end of infile; ! 353: * Else include all pages until the value of Next_entry is ! 354: * reached in infile; when it is, increment merge_indx (making ! 355: * Current_entry = Next_entry, and goto Loop; ! 356: * Else exclude all pages until Current_entry is reached in infile ! 357: * (it may already be reached); when it is, include that page and ! 358: * check the ovly_pg[][] entry; ! 359: * Ovly_entry = ovly_pg[input_indx][merge_indx]; ! 360: * If Ovly_entry != (-1) do overlay processing; ! 361: * Increment merge_indx, and goto Loop; ! 362: */ ! 363: int merge_indx, merge_pg[MX_NO_INFILES][MX_NO_MPG_ENTRIES]; ! 364: int ovly_indx, ovly_pg[MX_NO_INFILES][MX_NO_MPG_ENTRIES]; ! 365: int ovly_pgnum[MX_NO_OVLY_FILES]; ! 366: long ovly_num[2][MX_NO_OVLY_FILES], ! 367: ovly_den[2][MX_NO_OVLY_FILES]; ! 368: ! 369: int block_indx; ! 370: int block_flag; ! 371: int bproc_indx, bop_indx, bop_iindx[MX_BOP_DEPTH]; ! 372: int bproc_flag, bop_flag; ! 373: int num_blocks, num_pages, num_sifs, ! 374: tnum_blocks, tnum_pages, tnum_sifs; ! 375: int out_numpages; ! 376: ! 377: int infile_flag[MX_NO_INFILES]; ! 378: ! 379: int hdr_len; ! 380: char hdr_buf[MX_HDR_BUFLEN+1], hdr_workbuf[MX_HDR_BUFLEN+1]; ! 381: ! 382: char input_name[MX_NO_INFILES][128], input_fnm[128], input_ext[128], ! 383: output_name[128], output_fnm[128], output_ext[128], ! 384: work_fname[128], sif_name[MX_SIF_DEPTH][128], prop_fname[128]; ! 385: char ovly_fname[MX_NO_OVLY_FILES][128]; ! 386: char alias_ref[MX_NO_ALIASES][128], alias_act[MX_NO_ALIASES][128]; ! 387: char *inputname, *outputname, *sifname, *propfname; ! 388: char *logfilename = "ipfe.log"; ! 389: ! 390: char *itostr(), lcase(), *op_name(), *strcat(), *strcpy(); ! 391: ! 392: /**************************************************************** ! 393: * ! 394: * main(argc, argv): ipfe mainline: ! 395: * main: interpress file editor ! 396: * ! 397: ****************************************************************/ ! 398: ! 399: main(argc, argv) ! 400: ! 401: int argc; ! 402: char *argv[]; ! 403: { ! 404: char msg[128]; ! 405: ! 406: ! 407: (void)sprintf(msg, ! 408: "\nIPFE Version %s, %s -- Interpress File Editor\n", ! 409: IPFE_VERS, IPFE_DATE); ! 410: pip_error(msg); ! 411: pip_error("Copyright (c) 1985,1986 Xerox Corporation\n\n"); ! 412: init_ipfe(); ! 413: get_cmd_args(argc, argv); ! 414: init1_ipfe(); /* initialization after getting cmd args */ ! 415: ! 416: ! 417: for (input_indx=0; input_indx < num_infiles; input_indx++) ! 418: { ! 419: init_proc_file(); ! 420: inputname = input_name[input_indx]; ! 421: (void)sprintf(msg, "-- File: %s--\n", inputname); ! 422: pip_error(msg); ! 423: pip_prop(msg); ! 424: ! 425: _fmode = BINARY_FILE; ! 426: input = fopen(inputname, "r"); ! 427: if (input == NULL) ! 428: { ! 429: (void)sprintf(msg, "\nError opening input file: %s\n", ! 430: inputname); ! 431: pip_error(msg); ! 432: pip_prop(msg); ! 433: } ! 434: else ! 435: { ! 436: proc_file(); /* do the real work */ ! 437: (void)fclose(input); ! 438: } ! 439: } ! 440: ! 441: if ((abort_flag == FLAG_OFF) && ! 442: (proc_flag[CONCAT] == FLAG_ON)) ! 443: { ! 444: ipwrite_flag = FLAG_ON; /* in case it was turned off by ! 445: last file processed */ ! 446: put_op(OP_endBlock); ! 447: } ! 448: ! 449: cleanup(); ! 450: exit(exit_status); ! 451: } ! 452: ! 453: ! 454: /**************************************************************** ! 455: * ! 456: * cleanup: housecleaning ! 457: * ! 458: ****************************************************************/ ! 459: ! 460: cleanup() ! 461: { ! 462: char msg[128]; ! 463: ! 464: ! 465: if (proc_flag[CONCAT] == FLAG_ON) ! 466: { ! 467: (void)sprintf(msg, "\n--Total Number of Blocks:%4d\n", tnum_blocks); ! 468: pip_prop(msg); ! 469: (void)sprintf(msg, "--Total Number of Pages :%4d\n", tnum_pages); ! 470: pip_prop(msg); ! 471: (void)sprintf(msg, "--Total Number of SIFs :%4d\n", tnum_sifs); ! 472: pip_prop(msg); ! 473: } ! 474: mputc_prop('\n'); ! 475: ! 476: (void)sprintf(msg, "\n-- Total Number of Input Pages :%4d\n", ! 477: tnum_pages); ! 478: pip_error(msg); ! 479: if ((output != NULL) || (out_numpages > 0)) ! 480: { ! 481: (void)sprintf(msg, "-- Total Number of Output Pages:%4d\n", ! 482: out_numpages); ! 483: pip_error(msg); ! 484: } ! 485: pip_error("\n"); ! 486: ! 487: if (logfile != NULL) ! 488: (void)fclose(logfile); ! 489: ! 490: if (propfile != NULL) ! 491: (void)fclose(propfile); ! 492: ! 493: if (output != NULL) ! 494: (void)fclose(output); ! 495: ! 496: } ! 497: ! 498: ! 499: /**************************************************************** ! 500: * ! 501: * int count_int_bytes(val): ! 502: * int count_int_bytes: return the number of bytes in the ! 503: * specified int val ! 504: * ! 505: ****************************************************************/ ! 506: ! 507: int count_int_bytes(val) ! 508: ! 509: long val; ! 510: { ! 511: long mask; ! 512: int i; ! 513: ! 514: ! 515: if ((val == 0) || (val == (-1))) ! 516: i = 1; /* avoid infinite looping */ ! 517: else ! 518: { ! 519: if (val < 0) ! 520: val = ~(val); /* same # of bytes as one's complement */ ! 521: ! 522: mask = 0xff800000; ! 523: for (i=4; ((val & mask) == 0); i--) ! 524: mask = mask >> 8; ! 525: ! 526: } ! 527: ! 528: return(i); ! 529: } ! 530: ! 531: ! 532: /**************************************************************** ! 533: * ! 534: * create_SIF(fname): ! 535: * create_SIF: create a new SIF (for ovly handling) ! 536: * ! 537: ****************************************************************/ ! 538: ! 539: create_SIF(fname) ! 540: ! 541: char *fname; ! 542: { ! 543: int not_created_flag; ! 544: char msg[128]; ! 545: ! 546: ! 547: not_created_flag = FLAG_OFF; ! 548: if (proc_flag[INSERT_OVLY] == FLAG_ON) ! 549: { ! 550: if (ovly_pgnum[ovly_indx] < 2) ! 551: { ! 552: (void)sprintf(msg, ! 553: " --Creating SIF: %s\n", fname); ! 554: pip_error(msg); ! 555: put_seq_type_len(sequenceInsertFile, (long)strlen(fname)); ! 556: ip_puts(fname); ! 557: } ! 558: else ! 559: { ! 560: pip_error( ! 561: " --Cannot create SIF for overlay with pageNum > 1\n"); ! 562: not_created_flag = FLAG_ON; ! 563: } ! 564: } ! 565: else ! 566: { ! 567: pip_error( ! 568: " -i switch (Insert SIF for overlay) not specified\n"); ! 569: not_created_flag = FLAG_ON; ! 570: } ! 571: if (not_created_flag == FLAG_ON) ! 572: { ! 573: (void)sprintf(msg, ! 574: " --SIF Not Created for: %s\n", ! 575: fname); ! 576: pip_error(msg); ! 577: } ! 578: ! 579: } ! 580: ! 581: ! 582: /**************************************************************** ! 583: * ! 584: * get_cmd_args(argc, argv): ! 585: * get_cmd_args: get cmd_line arguments ! 586: * gca: label for editing ! 587: * ! 588: ****************************************************************/ ! 589: ! 590: get_cmd_args(argc, argv) ! 591: ! 592: int argc; ! 593: char *argv[]; ! 594: { ! 595: long val, val1, d; ! 596: int arg, opt, opt_len, ch_ctr, neg_flag, sep_flag, retcd; ! 597: int err_flag = FLAG_OFF; ! 598: char ch, sep_char, msg[128]; ! 599: ! 600: ! 601: for (arg=1; arg < argc; arg++) /* look for cmd_arguments */ ! 602: { ! 603: switch ! 604: (argv[arg][0]) ! 605: { ! 606: case ('-'): ! 607: opt_len = strlen(argv[arg]); /* because arg can be */ ! 608: /* modified below */ ! 609: for (opt=1; opt < opt_len; opt++) ! 610: { ! 611: switch ! 612: (argv[arg][opt]) ! 613: { ! 614: case ('-'): ! 615: opt = opt_len; /* to handle '--' switch */ ! 616: break; ! 617: ! 618: case ('a'): ! 619: if (strlen(&(argv[arg][opt])) > 1) ! 620: ++opt; ! 621: else ! 622: { ! 623: ++arg; ! 624: opt = 0; ! 625: opt_len = strlen(argv[arg]); ! 626: } ! 627: proc_alias(&(argv[arg][opt])); ! 628: opt = opt_len; /* to get out of loop */ ! 629: break; ! 630: ! 631: case ('b'): ! 632: if (strlen(&(argv[arg][opt])) > 1) ! 633: ++opt; ! 634: else ! 635: { ! 636: ++arg; ! 637: opt = 0; ! 638: opt_len = strlen(argv[arg]); ! 639: } ! 640: /* ! 641: * binding offset:unit ! 642: */ ! 643: val = val1 = d = ch_ctr = 0; ! 644: neg_flag = FLAG_OFF; ! 645: while ! 646: (opt < opt_len) ! 647: { ! 648: ch = argv[arg][opt++]; ! 649: if ((ch == '-') && (ch_ctr == 0)) ! 650: neg_flag = FLAG_ON; ! 651: else ! 652: if ((ch >= '0') && (ch <= '9')) ! 653: { ! 654: ch = ch - '0'; ! 655: if (d == 0) ! 656: val = (val * 10) + ch; ! 657: else ! 658: if (d <= 1000) /* prec = 10**(-3) ! 659: truncated */ ! 660: { ! 661: val1 = (val1 * 10) + ch; ! 662: d = d * 10; ! 663: } ! 664: } ! 665: else ! 666: if (ch == '.') ! 667: d = 1; ! 668: else ! 669: { ! 670: if ((ch == ':') && (opt < opt_len)) ! 671: ch = argv[arg][opt++]; ! 672: break; /* exit loop */ ! 673: } ! 674: ++ch_ctr; ! 675: } ! 676: /* end while (opt < opt_len) */ ! 677: ! 678: if (d == 0) ! 679: d = 1; ! 680: else ! 681: val = (val * d) + val1; ! 682: ! 683: if (val != 0) ! 684: { ! 685: if (neg_flag == FLAG_ON) ! 686: val = -(val); ! 687: switch ! 688: (ch) ! 689: { ! 690: case ('c'): ! 691: d = d * 100; ! 692: break; ! 693: case ('i'): ! 694: val = val * 254; ! 695: d = d * 10000; ! 696: break; ! 697: case ('p'): ! 698: val = val * 254; ! 699: d = ((d * 720000) & 0x7fffffff); ! 700: break; ! 701: case ('P'): ! 702: val = val * 254; ! 703: d = ((d * 60000) & 0x7fffffff); ! 704: break; ! 705: default: ! 706: d = d * 100; /* def=cm */ ! 707: break; ! 708: } ! 709: /* end switch (ch) */ ! 710: ! 711: if (d != 0) /* last chk for div ! 712: by 0 just in case ! 713: of ovflw */ ! 714: { ! 715: boff_num = val; ! 716: boff_den = d; ! 717: proc_flag[BINDING_OFFSET] = ! 718: FLAG_ON; ! 719: } ! 720: } ! 721: else ! 722: { ! 723: (void)sprintf(msg, ! 724: "--ipfe: No binding offset value specified in (%s)\n", ! 725: argv[arg]); ! 726: pip_error(msg); ! 727: err_flag = FLAG_ON; ! 728: } ! 729: --opt; /* to parse cur ch at cmd line */ ! 730: break; ! 731: ! 732: case ('c'): ! 733: if (strlen(&(argv[arg][opt])) > 1) ! 734: ++opt; ! 735: else ! 736: { ! 737: ++arg; ! 738: opt = 0; ! 739: opt_len = strlen(argv[arg]); ! 740: } ! 741: ch = val = 0; ! 742: while ! 743: (opt < opt_len) ! 744: { ! 745: ch = argv[arg][opt]; ! 746: if ((ch >= '0') && (ch <= '9')) ! 747: { ! 748: ch = ch - '0'; ! 749: val = (val * 10) + ch; ! 750: ++opt; ! 751: } ! 752: else ! 753: break; ! 754: } ! 755: if (val == 0) ! 756: { ! 757: (void)sprintf(msg, ! 758: "--ipfe: No length specified for chapterize in %s\n", ! 759: argv[arg]); ! 760: pip_error(msg); ! 761: err_flag = FLAG_ON; ! 762: } ! 763: else ! 764: { ! 765: if ((ch == ':') && (opt < opt_len)) ! 766: ch = argv[arg][++opt]; ! 767: ! 768: switch ! 769: (ch) ! 770: { ! 771: case ('p'): ! 772: proc_flag[CHAPTERIZE] = FLAG_ON; ! 773: chap_type = CH_PAGES; ! 774: chap_val = val; ! 775: break; ! 776: case ('k'): ! 777: proc_flag[CHAPTERIZE] = FLAG_ON; ! 778: chap_type = CH_KBYTES; ! 779: chap_val = val * 1024; ! 780: break; ! 781: case ('m'): ! 782: proc_flag[CHAPTERIZE] = FLAG_ON; ! 783: chap_type = CH_MBYTES; ! 784: chap_val = ((val * 1048576) & ! 785: 0x7fffffff); ! 786: break; ! 787: default: ! 788: (void)sprintf(msg, ! 789: "--ipfe: No unit specified for chapterize in %s\n", ! 790: argv[arg]); ! 791: pip_error(msg); ! 792: err_flag = FLAG_ON; ! 793: --opt; /* parse opt again */ ! 794: break; ! 795: } ! 796: } ! 797: break; ! 798: ! 799: case ('d'): ! 800: proc_flag[DUPLEX] = FLAG_ON; ! 801: break; ! 802: ! 803: case ('D'): ! 804: proc_flag[DEBUG] = FLAG_ON; ! 805: break; ! 806: ! 807: case ('i'): ! 808: proc_flag[INSERT_OVLY] = FLAG_ON; ! 809: break; ! 810: ! 811: case ('l'): ! 812: proc_flag[PROC_LOG] = FLAG_ON; ! 813: if (strlen(&(argv[arg][opt])) > 1) ! 814: ++opt; ! 815: else ! 816: { ! 817: ++arg; ! 818: opt = 0; ! 819: opt_len = strlen(argv[arg]); ! 820: } ! 821: ch = argv[arg][opt]; ! 822: if ((ch != ':') && (ch != '-')) ! 823: { ! 824: logfilename = &(argv[arg][opt]); ! 825: opt = opt_len; /* to get out of lp */ ! 826: } ! 827: open_logfile(argc, argv); ! 828: break; ! 829: ! 830: case ('L'): ! 831: rot_deg = 90; ! 832: rxoff_num = rxoff_den = 0; ! 833: ryoff_num = -(2794); ! 834: ryoff_den = 10000; ! 835: proc_flag[LANDSCAPE] = FLAG_ON; ! 836: break; ! 837: ! 838: case ('o'): ! 839: if (strlen(&(argv[arg][opt])) > 1) ! 840: outputname = &(argv[arg][opt+1]); ! 841: else ! 842: outputname = argv[++arg]; ! 843: opt = opt_len; /* to get out of loop */ ! 844: break; ! 845: ! 846: case ('p'): ! 847: proc_flag[PROPERTIES] = FLAG_ON; ! 848: if (strlen(&(argv[arg][opt])) > 1) ! 849: ++opt; ! 850: else ! 851: { ! 852: ++arg; ! 853: opt = 0; ! 854: opt_len = strlen(argv[arg]); ! 855: } ! 856: ch = argv[arg][opt]; ! 857: if ((ch != ':') && (ch != '-')) ! 858: { ! 859: if ((ch >= '0') && (ch <= '9')) ! 860: { ! 861: prop_level = ch - '0'; ! 862: ++opt; ! 863: if (argv[arg][opt] == ':') ! 864: ++opt; ! 865: if (opt < opt_len) ! 866: propfname = &(argv[arg][opt]); ! 867: opt = opt_len; /* to exit loop */ ! 868: } ! 869: else ! 870: { ! 871: (void)sprintf(msg, ! 872: "--ipfe: *** warning -- property level not specified in %s\n", ! 873: argv[arg]); ! 874: pip_error(msg); ! 875: err_flag = FLAG_ON; ! 876: propfname = &(argv[arg][opt]); ! 877: opt = opt_len; /* to exit loop */ ! 878: } ! 879: } ! 880: break; ! 881: ! 882: case ('q'): ! 883: proc_flag[QUIET] = FLAG_ON; ! 884: break; ! 885: ! 886: case ('r'): ! 887: proc_flag[REMOVE_SIFS] = FLAG_ON; ! 888: break; ! 889: ! 890: case ('R'): ! 891: rot_deg = -(90); ! 892: rxoff_num = -(2477); /* xOff = -(9 3/4") */ ! 893: ryoff_num = -(318); /* yOff = -(1 1/4") */ ! 894: rxoff_den = ryoff_den = 10000; ! 895: proc_flag[ROTATE] = FLAG_ON; ! 896: break; ! 897: ! 898: case ('s'): ! 899: proc_flag[SATISFY_SIFS] = FLAG_ON; ! 900: break; ! 901: ! 902: case ('S'): ! 903: if (strlen(&(argv[arg][opt])) > 1) ! 904: ++opt; ! 905: else ! 906: { ! 907: ++arg; ! 908: opt = 0; ! 909: opt_len = strlen(argv[arg]); ! 910: } ! 911: /* ! 912: * scale ! 913: */ ! 914: val = val1 = d = ch_ctr = 0; ! 915: neg_flag = sep_flag = FLAG_OFF; ! 916: while ! 917: (opt < opt_len) ! 918: { ! 919: ch = argv[arg][opt++]; ! 920: if ((ch == '-') && (ch_ctr == 0)) ! 921: neg_flag = FLAG_ON; ! 922: else ! 923: if ((ch >= '0') && (ch <= '9')) ! 924: { ! 925: ch = ch - '0'; ! 926: if (d == 0) ! 927: val = (val * 10) + ch; ! 928: else ! 929: if (d <= 1000) /* prec = 10**(-3) ! 930: truncated */ ! 931: { ! 932: val1 = (val1 * 10) + ch; ! 933: d = d * 10; ! 934: } ! 935: } ! 936: else ! 937: if ((ch == '.') || (ch == '/')) ! 938: { ! 939: if (sep_flag == FLAG_OFF) ! 940: { ! 941: d = 1; ! 942: sep_char = ch; ! 943: sep_flag = FLAG_ON; ! 944: } ! 945: else ! 946: { ! 947: (void)sprintf(msg, ! 948: "--ipfe: Scale factor cannot have BOTH a '.' AND a '/' in (%s)\n", ! 949: argv[arg]); ! 950: pip_error(msg); ! 951: err_flag = FLAG_ON; ! 952: break; /* exit loop */ ! 953: } ! 954: } ! 955: else ! 956: { ! 957: if ((ch == ':') && (opt < opt_len)) ! 958: ch = argv[arg][opt++]; ! 959: break; /* exit loop */ ! 960: } ! 961: ++ch_ctr; ! 962: } ! 963: /* end while (opt < opt_len) */ ! 964: ! 965: if (d == 0) ! 966: d = 1; ! 967: else ! 968: if (sep_char == '/') ! 969: d = val1; ! 970: else ! 971: val = (val * d) + val1; ! 972: ! 973: if ((val != 0) && (err_flag == FLAG_OFF)) ! 974: { ! 975: if (neg_flag == FLAG_ON) ! 976: val = -(val); ! 977: ! 978: if (d != 0) /* last chk for div ! 979: by 0 just in case ! 980: of ovflw */ ! 981: { ! 982: scale_num = val; ! 983: scale_den = d; ! 984: proc_flag[SCALE] = FLAG_ON; ! 985: } ! 986: } ! 987: else ! 988: { ! 989: (void)sprintf(msg, ! 990: "--ipfe: No scale factor value specified in (%s)\n", ! 991: argv[arg]); ! 992: pip_error(msg); ! 993: err_flag = FLAG_ON; ! 994: } ! 995: --opt; /* to parse cur ch at cmd line */ ! 996: break; ! 997: ! 998: case ('X'): ! 999: if (strlen(&(argv[arg][opt])) > 1) ! 1000: ++opt; ! 1001: else ! 1002: { ! 1003: ++arg; ! 1004: opt = 0; ! 1005: opt_len = strlen(argv[arg]); ! 1006: } ! 1007: /* ! 1008: * xOffset:unit ! 1009: */ ! 1010: val = val1 = d = ch_ctr = 0; ! 1011: neg_flag = FLAG_OFF; ! 1012: while ! 1013: (opt < opt_len) ! 1014: { ! 1015: ch = argv[arg][opt++]; ! 1016: if ((ch == '-') && (ch_ctr == 0)) ! 1017: neg_flag = FLAG_ON; ! 1018: else ! 1019: if ((ch >= '0') && (ch <= '9')) ! 1020: { ! 1021: ch = ch - '0'; ! 1022: if (d == 0) ! 1023: val = (val * 10) + ch; ! 1024: else ! 1025: if (d <= 1000) /* prec = 10**(-3) ! 1026: truncated */ ! 1027: { ! 1028: val1 = (val1 * 10) + ch; ! 1029: d = d * 10; ! 1030: } ! 1031: } ! 1032: else ! 1033: if (ch == '.') ! 1034: { ! 1035: d = 1; ! 1036: val1 = 0; ! 1037: } ! 1038: else ! 1039: { ! 1040: if ((ch == ':') && (opt < opt_len)) ! 1041: ch = argv[arg][opt++]; ! 1042: break; /* exit loop */ ! 1043: } ! 1044: ++ch_ctr; ! 1045: } ! 1046: /* end while (opt < opt_len) */ ! 1047: ! 1048: if (d == 0) ! 1049: d = 1; ! 1050: else ! 1051: val = (val * d) + val1; ! 1052: ! 1053: if (val != 0) ! 1054: { ! 1055: if (neg_flag == FLAG_ON) ! 1056: val = -(val); ! 1057: switch ! 1058: (ch) ! 1059: { ! 1060: case ('c'): ! 1061: d = d * 100; ! 1062: break; ! 1063: case ('i'): ! 1064: val = val * 254; ! 1065: d = d * 10000; ! 1066: break; ! 1067: case ('p'): ! 1068: val = val * 254; ! 1069: d = ((d * 720000) & 0x7fffffff); ! 1070: break; ! 1071: case ('P'): ! 1072: val = val * 254; ! 1073: d = ((d * 60000) & 0x7fffffff); ! 1074: break; ! 1075: default: ! 1076: d = d * 100; /* def=cm */ ! 1077: break; ! 1078: } ! 1079: /* end switch (ch) */ ! 1080: ! 1081: if (d != 0) /* last chk for div ! 1082: by 0 just in case ! 1083: of ovflw */ ! 1084: { ! 1085: xoff_num = val; ! 1086: xoff_den = d; ! 1087: proc_flag[X_OFFSET] = FLAG_ON; ! 1088: } ! 1089: } ! 1090: else ! 1091: { ! 1092: (void)sprintf(msg, ! 1093: "--ipfe: No xOffset value specified in (%s)\n", ! 1094: argv[arg]); ! 1095: pip_error(msg); ! 1096: err_flag = FLAG_ON; ! 1097: } ! 1098: --opt; /* to parse cur ch at cmd line */ ! 1099: break; ! 1100: ! 1101: case ('Y'): ! 1102: if (strlen(&(argv[arg][opt])) > 1) ! 1103: ++opt; ! 1104: else ! 1105: { ! 1106: ++arg; ! 1107: opt = 0; ! 1108: opt_len = strlen(argv[arg]); ! 1109: } ! 1110: /* ! 1111: * yOffset:unit ! 1112: */ ! 1113: val = val1 = d = ch_ctr = 0; ! 1114: neg_flag = FLAG_OFF; ! 1115: while ! 1116: (opt < opt_len) ! 1117: { ! 1118: ch = argv[arg][opt++]; ! 1119: if ((ch == '-') && (ch_ctr == 0)) ! 1120: neg_flag = FLAG_ON; ! 1121: else ! 1122: if ((ch >= '0') && (ch <= '9')) ! 1123: { ! 1124: ch = ch - '0'; ! 1125: if (d == 0) ! 1126: val = (val * 10) + ch; ! 1127: else ! 1128: if (d <= 1000) /* prec = 10**(-3) ! 1129: truncated */ ! 1130: { ! 1131: val1 = (val1 * 10) + ch; ! 1132: d = d * 10; ! 1133: } ! 1134: } ! 1135: else ! 1136: if (ch == '.') ! 1137: { ! 1138: d = 1; ! 1139: val1 = 0; ! 1140: } ! 1141: else ! 1142: { ! 1143: if ((ch == ':') && (opt < opt_len)) ! 1144: ch = argv[arg][opt++]; ! 1145: break; /* exit loop */ ! 1146: } ! 1147: ++ch_ctr; ! 1148: } ! 1149: /* end while (opt < opt_len) */ ! 1150: ! 1151: if (d == 0) ! 1152: d = 1; ! 1153: else ! 1154: val = (val * d) + val1; ! 1155: ! 1156: if (val != 0) ! 1157: { ! 1158: if (neg_flag == FLAG_ON) ! 1159: val = -(val); ! 1160: switch ! 1161: (ch) ! 1162: { ! 1163: case ('c'): ! 1164: d = d * 100; ! 1165: break; ! 1166: case ('i'): ! 1167: val = val * 254; ! 1168: d = d * 10000; ! 1169: break; ! 1170: case ('p'): ! 1171: val = val * 254; ! 1172: d = ((d * 720000) & 0x7fffffff); ! 1173: break; ! 1174: case ('P'): ! 1175: val = val * 254; ! 1176: d = ((d * 60000) & 0x7fffffff); ! 1177: break; ! 1178: default: ! 1179: d = d * 100; /* def=cm */ ! 1180: break; ! 1181: } ! 1182: /* end switch (ch) */ ! 1183: ! 1184: if (d != 0) /* last chk for div ! 1185: by 0 just in case ! 1186: of ovflw */ ! 1187: { ! 1188: yoff_num = val; ! 1189: yoff_den = d; ! 1190: proc_flag[Y_OFFSET] = FLAG_ON; ! 1191: } ! 1192: } ! 1193: else ! 1194: { ! 1195: (void)sprintf(msg, ! 1196: "--ipfe: No yOffset value specified in (%s)\n", ! 1197: argv[arg]); ! 1198: pip_error(msg); ! 1199: err_flag = FLAG_ON; ! 1200: } ! 1201: --opt; /* to parse cur ch at cmd line */ ! 1202: break; ! 1203: ! 1204: default: ! 1205: (void)sprintf(msg, ! 1206: "--ipfe: Invalid option in %s (%s)\n", ! 1207: argv[arg], &(argv[arg][opt])); ! 1208: pip_error(msg); ! 1209: err_flag = FLAG_ON; ! 1210: break; ! 1211: } ! 1212: } ! 1213: break; ! 1214: ! 1215: case ('['): ! 1216: break; ! 1217: ! 1218: case ('>'): ! 1219: break; ! 1220: ! 1221: default: ! 1222: /* ! 1223: * the current arg is an input file; try to open it ! 1224: */ ! 1225: if (input_indx < MX_NO_INFILES) ! 1226: { ! 1227: _fmode = BINARY_FILE; ! 1228: workfile = fopen(argv[arg], "r"); ! 1229: if (workfile == NULL) ! 1230: { ! 1231: (void)sprintf(msg, ! 1232: "--ipfe: Error opening input file: %s\n", ! 1233: argv[arg]); ! 1234: pip_error(msg); ! 1235: err_flag = FLAG_ON; ! 1236: } ! 1237: else ! 1238: { ! 1239: /* ! 1240: * check for valid hdr ! 1241: */ ! 1242: retcd = get_ip_hdr(workfile, argv[arg]); ! 1243: if (retcd == OK) ! 1244: { ! 1245: (void)strcpy(input_name[input_indx], ! 1246: argv[arg]); ! 1247: /* ! 1248: * check for page range ! 1249: */ ! 1250: if (((arg + 1) < argc) && ! 1251: ((argv[arg+1][0] == '[') || ! 1252: (argv[arg+1][0] == '+') || ! 1253: (argv[arg+1][0] == '#'))) ! 1254: { ! 1255: ++arg; ! 1256: get_pagerange(arg, argv); ! 1257: } ! 1258: else ! 1259: merge_pg[input_indx][0] = (-1); ! 1260: infile_flag[input_indx] = FLAG_ON; ! 1261: ++input_indx; ! 1262: ++num_infiles; ! 1263: } ! 1264: else ! 1265: err_flag = FLAG_ON; ! 1266: (void)fclose(workfile); ! 1267: } ! 1268: } ! 1269: else ! 1270: { ! 1271: (void)sprintf(msg, ! 1272: "--ipfe: Maximum # of input files = %d; File: %s not processed\n", ! 1273: MX_NO_INFILES, argv[arg]); ! 1274: pip_error(msg); ! 1275: err_flag = FLAG_ON; ! 1276: } ! 1277: break; ! 1278: } ! 1279: /* end switch (argv[arg][0]) */ ! 1280: } ! 1281: /* end for (arg=1; arg < argc; arg++) */ ! 1282: if (err_flag == FLAG_ON) ! 1283: pip_error("\n"); ! 1284: ! 1285: } ! 1286: ! 1287: ! 1288: /**************************************************************** ! 1289: * ! 1290: * int get_ip_hdr(file, filename): ! 1291: * int get_ip_hdr: get the ip_hdr from the specified ! 1292: * file into a work_buf & return a ! 1293: * ptr to the buf ! 1294: * ! 1295: ****************************************************************/ ! 1296: ! 1297: int get_ip_hdr(file, filename) ! 1298: ! 1299: FILE *file; ! 1300: char *filename; ! 1301: { ! 1302: int i, retcd, hdr_flag; ! 1303: int c; /* must be int for stdio EOF compare */ ! 1304: char *ptr, msg[128]; ! 1305: ! 1306: ! 1307: retcd = OK; ! 1308: /* ! 1309: * get the header ! 1310: */ ! 1311: ptr = hdr_workbuf; ! 1312: hdr_flag = FLAG_OFF; ! 1313: for (i=0; i < MX_HDR_BUFLEN; i++) ! 1314: { ! 1315: c = getc_testeof(file, filename); /* get a char, */ ! 1316: *ptr++ = c; /* & stick it in the buffer */ ! 1317: if (c == ' ') /* if c=ip_hdr_terminate_char, */ ! 1318: { ! 1319: hdr_flag = FLAG_ON; /* set hdr_ok flag, */ ! 1320: break; /* & exit the loop */ ! 1321: } ! 1322: } ! 1323: *ptr = '\0'; ! 1324: /* ! 1325: * ... & check its validity ! 1326: */ ! 1327: if (hdr_flag == FLAG_OFF) ! 1328: { ! 1329: (void)sprintf(msg, "--ipfe: Hdr length > %d chars in file: %s\n", ! 1330: MX_HDR_BUFLEN, filename); ! 1331: pip_error(msg); ! 1332: retcd = ERROR; ! 1333: } ! 1334: if (mstrncmp(hdr_workbuf, IP_Header, IP_HDR_CHKLEN) != 0) ! 1335: { ! 1336: (void)sprintf(msg, "--ipfe: INVALID HEADER! in file: %s\n", ! 1337: filename); ! 1338: pip_error(msg); ! 1339: retcd = ERROR; ! 1340: } ! 1341: ! 1342: return(retcd); ! 1343: } ! 1344: ! 1345: ! 1346: /**************************************************************** ! 1347: * ! 1348: * get_pagerange(arg, argv): ! 1349: * get_pagerange: get cmd_line page range argument ! 1350: * for current input_indx from ! 1351: * specified argument ! 1352: * ! 1353: ****************************************************************/ ! 1354: ! 1355: get_pagerange(arg, argv) ! 1356: ! 1357: int arg; ! 1358: char *argv[]; ! 1359: { ! 1360: int i, opt, opt_len, d, val, val1, lp_ctr, ch_ctr, ! 1361: prv_mpg_num, err_flag, neg_flag; ! 1362: char ch, nc; ! 1363: char msg[128], name_buf[128]; ! 1364: ! 1365: ! 1366: merge_indx = val = 0; ! 1367: prv_mpg_num = 0; ! 1368: opt_len = strlen(argv[arg]); ! 1369: err_flag = FLAG_OFF; ! 1370: for (opt=1; ((opt < opt_len) && (err_flag == FLAG_OFF)); opt++) ! 1371: { ! 1372: switch ! 1373: (argv[arg][opt]) ! 1374: { ! 1375: case ('-'): ! 1376: merge_pg[input_indx][merge_indx] = (-1); ! 1377: ++merge_indx; ! 1378: break; ! 1379: /* ! 1380: * all of the following can just be ignored at this level ! 1381: */ ! 1382: case (','): ! 1383: case (']'): ! 1384: case (')'): ! 1385: case (SPC): ! 1386: case ('\n'): ! 1387: break; ! 1388: ! 1389: case ('['): ! 1390: case ('+'): ! 1391: /* ! 1392: * overlay filename ! 1393: */ ! 1394: if (strlen(&(argv[arg][opt])) > 1) ! 1395: { ! 1396: ch = '\0'; ! 1397: i = 0; ! 1398: ++opt; ! 1399: while ! 1400: (opt < opt_len) ! 1401: { ! 1402: ch = argv[arg][opt]; ! 1403: if ((ch == ':') || (ch == '(') || (ch == '@') || ! 1404: (ch == '+')) ! 1405: { ! 1406: --opt; /* reparse opt at switch level */ ! 1407: break; ! 1408: } ! 1409: else ! 1410: if ((ch == ']') || (ch == ',')) ! 1411: break; /* don't bother reparsing */ ! 1412: else ! 1413: { ! 1414: name_buf[i++] = ch; ! 1415: ++opt; ! 1416: } ! 1417: } ! 1418: name_buf[i] = '\0'; ! 1419: if (i > 0) ! 1420: { ! 1421: if (merge_indx == 0) ! 1422: { ! 1423: merge_pg[input_indx][0] = 1; ! 1424: ++merge_indx; ! 1425: } ! 1426: if (merge_pg[input_indx][(merge_indx-1)] > 0) ! 1427: { ! 1428: if (ovly_pg[input_indx][(merge_indx-1)] != ! 1429: (-1)) ! 1430: { ! 1431: merge_pg[input_indx][merge_indx] = ! 1432: merge_pg[input_indx][(merge_indx-1)]; ! 1433: ++merge_indx; ! 1434: } ! 1435: ovly_pg[input_indx][(merge_indx-1)] = ! 1436: ovly_indx; ! 1437: (void)strcpy(ovly_fname[ovly_indx], name_buf); ! 1438: ++ovly_indx; ! 1439: } ! 1440: else ! 1441: err_flag = FLAG_ON; ! 1442: } ! 1443: else ! 1444: err_flag = FLAG_ON; ! 1445: } ! 1446: else ! 1447: err_flag = FLAG_ON; ! 1448: break; ! 1449: ! 1450: case (':'): ! 1451: /* ! 1452: * overlay pagenum ! 1453: */ ! 1454: if ((ovly_indx == 0) || ! 1455: (ovly_pg[input_indx][merge_indx-1] == (-1)) || ! 1456: (ovly_pgnum[ovly_indx-1] != 0)) ! 1457: err_flag = FLAG_ON; ! 1458: else ! 1459: if (strlen(&(argv[arg][opt])) > 1) ! 1460: { ! 1461: val = 0; ! 1462: ++opt; ! 1463: while ! 1464: (opt < opt_len) ! 1465: { ! 1466: ch = argv[arg][opt]; ! 1467: if ((ch >= '0') && (ch <= '9')) ! 1468: { ! 1469: ch = ch - '0'; ! 1470: val = (val * 10) + ch; ! 1471: ++opt; ! 1472: } ! 1473: else ! 1474: { ! 1475: --opt; /* reparse everything else at the ! 1476: switch level */ ! 1477: break; ! 1478: } ! 1479: } ! 1480: /* ! 1481: * if the pagenum is good, process it ! 1482: */ ! 1483: if (val > 0) ! 1484: ovly_pgnum[ovly_indx-1] = val; ! 1485: } ! 1486: else ! 1487: err_flag = FLAG_ON; ! 1488: break; ! 1489: ! 1490: case ('('): ! 1491: case ('@'): ! 1492: /* ! 1493: * overlay page offset ! 1494: */ ! 1495: if ((ovly_indx == 0) || ! 1496: (ovly_pg[input_indx][merge_indx-1] == (-1))) ! 1497: err_flag = FLAG_ON; ! 1498: else ! 1499: if (strlen(&(argv[arg][opt])) > 1) ! 1500: { ! 1501: val = val1 = d = lp_ctr = ch_ctr = 0; ! 1502: neg_flag = FLAG_OFF; ! 1503: ++opt; ! 1504: while ! 1505: ((opt < opt_len) && (lp_ctr < 2)) ! 1506: { ! 1507: ch = argv[arg][opt++]; ! 1508: if ((ch == '-') && (ch_ctr == 0)) ! 1509: neg_flag = FLAG_ON; ! 1510: else ! 1511: if ((ch >= '0') && (ch <= '9')) ! 1512: { ! 1513: ch = ch - '0'; ! 1514: if (d == 0) ! 1515: val = (val * 10) + ch; ! 1516: else ! 1517: if (d <= 1000) /* precision = 10**(-3) ! 1518: truncated */ ! 1519: { ! 1520: val1 = (val1 * 10) + ch; ! 1521: d = d * 10; ! 1522: } ! 1523: } ! 1524: else ! 1525: if (ch == '.') ! 1526: { ! 1527: d = 1; ! 1528: val1 = 0; ! 1529: } ! 1530: else ! 1531: { ! 1532: if (d != 0) ! 1533: val = (val * d) + val1; ! 1534: else ! 1535: d = 1; ! 1536: if (val != 0) ! 1537: { ! 1538: if (neg_flag == FLAG_ON) ! 1539: val = -(val); ! 1540: switch ! 1541: (ch) ! 1542: { ! 1543: case ('c'): ! 1544: d = d * 100; ! 1545: break; ! 1546: case ('i'): ! 1547: val = val * 254; ! 1548: d = d * 10000; ! 1549: break; ! 1550: case ('p'): ! 1551: val = val * 254; ! 1552: d = ((d * 720000) & 0x7fffffff); ! 1553: break; ! 1554: case ('P'): ! 1555: val = val * 254; ! 1556: d = ((d * 60000) & 0x7fffffff); ! 1557: break; ! 1558: default: ! 1559: d = d * 100; /* assume cm */ ! 1560: break; ! 1561: } ! 1562: if (d != 0) /* last chk for div by 0 ! 1563: just in case of ovflw */ ! 1564: { ! 1565: ovly_num[lp_ctr][ovly_indx-1] = val; ! 1566: ovly_den[lp_ctr][ovly_indx-1] = d; ! 1567: } ! 1568: if (lp_ctr == 0) ! 1569: { ! 1570: nc = argv[arg][opt]; ! 1571: if (((nc < '0') && (nc != '-')) || ! 1572: (nc > '9')) ! 1573: ++opt; /* assume only 1 separator ! 1574: after scale char */ ! 1575: } ! 1576: } ! 1577: val = d = 0; ! 1578: neg_flag = FLAG_OFF; ! 1579: ++lp_ctr; ! 1580: ch_ctr = (-1); ! 1581: if ((lp_ctr == 2) && ! 1582: ((ch == '+') || (ch == '[') || ! 1583: (ch == '-'))) ! 1584: --opt; /* reparse at switch level */ ! 1585: } ! 1586: ++ch_ctr; ! 1587: } ! 1588: --opt; /* to undo the automatic incr above */ ! 1589: } ! 1590: else ! 1591: err_flag = FLAG_ON; ! 1592: break; ! 1593: ! 1594: default: ! 1595: /* ! 1596: * current opt should be a pageNum ! 1597: */ ! 1598: val = 0; ! 1599: while ! 1600: (opt < opt_len) ! 1601: { ! 1602: ch = argv[arg][opt]; ! 1603: if ((ch >= '0') && (ch <= '9')) ! 1604: { ! 1605: ch = ch - '0'; ! 1606: val = (val * 10) + ch; ! 1607: ++opt; ! 1608: } ! 1609: else ! 1610: if ((ch == '-') || (ch == ',') || (ch == '[') || ! 1611: (ch == ']') || (ch == '+')) ! 1612: { ! 1613: --opt; /* reparse opt at switch level */ ! 1614: break; ! 1615: } ! 1616: else ! 1617: if ((ch == SPC) || (ch == '\n')) ! 1618: break; /* don't bother to reparse */ ! 1619: else ! 1620: { ! 1621: err_flag = FLAG_ON; ! 1622: break; ! 1623: } ! 1624: } ! 1625: /* ! 1626: * if the val is good, process it ! 1627: */ ! 1628: if (val > prv_mpg_num) ! 1629: { ! 1630: merge_pg[input_indx][merge_indx] = val; ! 1631: prv_mpg_num = val; ! 1632: ++merge_indx; ! 1633: } ! 1634: else ! 1635: err_flag = FLAG_ON; ! 1636: break; ! 1637: } ! 1638: /* end of switch (argv[arg][opt]) */ ! 1639: ! 1640: if (err_flag == FLAG_ON) ! 1641: { ! 1642: (void)sprintf(msg, ! 1643: "--ipfe: Invalid pagerange specification in %s (%s)\n", ! 1644: argv[arg], &(argv[arg][opt])); ! 1645: pip_error(msg); ! 1646: exit_status = 5; ! 1647: } ! 1648: } ! 1649: /* end of for (opt=1; ((opt < opt_len) && (err_flag == FLAG_OFF)); ! 1650: ++ opt) */ ! 1651: ! 1652: } ! 1653: ! 1654: ! 1655: /**************************************************************** ! 1656: * ! 1657: * int getc_testeof(file, filename): ! 1658: * int getc_testeof: get a char from input file; ! 1659: * if we get an EOF here, ! 1660: * it's an error; ! 1661: * else, ! 1662: * return the char as an int ! 1663: * ! 1664: ****************************************************************/ ! 1665: ! 1666: int getc_testeof(file, filename) ! 1667: ! 1668: FILE *file; ! 1669: char *filename; ! 1670: { ! 1671: int val; ! 1672: char msg[128]; ! 1673: ! 1674: ! 1675: val = mgetc(file); ! 1676: if (feof(file)) ! 1677: { ! 1678: (void)sprintf(msg, "\nUnexpected EOF! in file: %s\n", filename); ! 1679: pip_error(msg); ! 1680: longjmp(next_file, 1); ! 1681: } ! 1682: ! 1683: return(val); ! 1684: } ! 1685: ! 1686: ! 1687: /**************************************************************** ! 1688: * ! 1689: * indent(cnt, file): ! 1690: * indent: put <cnt> spcs to specified file ! 1691: * ! 1692: ****************************************************************/ ! 1693: ! 1694: indent(cnt, file) ! 1695: ! 1696: FILE *file; ! 1697: int cnt; ! 1698: { ! 1699: if (file != NULL) ! 1700: { ! 1701: if ((file == propfile) && (cnt > 0)) ! 1702: cur_col = cur_col + cnt; ! 1703: ! 1704: while ! 1705: (cnt-- > 0) ! 1706: { ! 1707: putc(' ', file); ! 1708: } ! 1709: } ! 1710: } ! 1711: ! 1712: ! 1713: /**************************************************************** ! 1714: * ! 1715: * init: ! 1716: * init_ipfe: initialization ! 1717: * ! 1718: ****************************************************************/ ! 1719: ! 1720: init_ipfe() ! 1721: { ! 1722: int i, j; ! 1723: ! 1724: ! 1725: abort_flag = debug_flag = FLAG_OFF; ! 1726: exit_status = 0; ! 1727: ovly_flag = FLAG_OFF; ! 1728: frstpg_flag = FLAG_OFF; ! 1729: num_infiles = out_filnum = 0; ! 1730: input_indx = output_indx = sif_indx = 0; ! 1731: num_aliases = 0; ! 1732: alias_indx = 0; ! 1733: prop_level = 0; ! 1734: hdr_len = 0; ! 1735: pos = in_offset = 0; ! 1736: block_indx = 0; ! 1737: block_flag = FLAG_OFF; ! 1738: out_beg_offset[block_indx] = 0; ! 1739: tnum_blocks = tnum_pages = tnum_sifs = 0; ! 1740: for (i=0; i < NUM_FNS; i++) ! 1741: proc_flag[i] = FLAG_OFF; ! 1742: chap_type = chap_val = 0; ! 1743: ipwrite_flag = FLAG_ON; ! 1744: merge_indx = ovly_indx = 0; ! 1745: ! 1746: for (i=0; i < MX_NO_INFILES; i++) ! 1747: { ! 1748: merge_pg[i][0] = (-1); /* init to all pages */ ! 1749: ovly_pg[i][0] = (-1); /* init to no overlay */ ! 1750: for (j=1; j < MX_NO_MPG_ENTRIES; j++) ! 1751: { ! 1752: merge_pg[i][j] = 0; ! 1753: ovly_pg[i][j] = (-1); ! 1754: } ! 1755: } ! 1756: ! 1757: for (i=0; i < MX_BLOCK_DEPTH; i++) ! 1758: blk_num_bytes[i] = 0; ! 1759: pg_num_bytes = 0; ! 1760: ! 1761: for (i=0; i < MX_NO_INFILES; i++) ! 1762: infile_flag[i] = 0; ! 1763: ! 1764: outputname = propfname = 0; ! 1765: ! 1766: /* ! 1767: * make the beginBlock & endBlock names upper case ! 1768: */ ! 1769: op_names[OP_beginBlock] = "BEGIN"; ! 1770: op_names[OP_endBlock] = "END"; ! 1771: ! 1772: } ! 1773: ! 1774: ! 1775: /**************************************************************** ! 1776: * ! 1777: * init_proc_file: initialize proc_file() loop ! 1778: * ! 1779: ****************************************************************/ ! 1780: ! 1781: init_proc_file() ! 1782: { ! 1783: ! 1784: sif_indx = 0; ! 1785: cur_indent = cur_col = 0; ! 1786: in_offset = 0; ! 1787: num_blocks = num_pages = num_sifs = 0; ! 1788: preamble_expected = FLAG_OFF; ! 1789: merge_indx = 0; ! 1790: bproc_indx = bop_indx = 0; ! 1791: bproc_flag = bop_flag = FLAG_OFF; ! 1792: ipwrite_flag = FLAG_ON; ! 1793: ! 1794: } ! 1795: ! 1796: ! 1797: /**************************************************************** ! 1798: * ! 1799: * init1: ! 1800: * init1_ipfe: initialization after getting cmd args ! 1801: * ! 1802: ****************************************************************/ ! 1803: ! 1804: init1_ipfe() ! 1805: ! 1806: { ! 1807: int i, tval, procflag, exit_flag; ! 1808: char msg[128]; ! 1809: ! 1810: ! 1811: if (num_infiles == 0) /* input_name req'd for now */ ! 1812: Usage(); ! 1813: else ! 1814: { ! 1815: /* ! 1816: * split the 1st input_name into input_fnm & input_ext ! 1817: */ ! 1818: i = mrstrichr(input_name[0], '.'); ! 1819: if (i != (-1)) ! 1820: { ! 1821: (void)mstrncpy(input_fnm, input_name[0], i); ! 1822: (void)strcpy(input_ext, (input_name[0] + i)); ! 1823: } ! 1824: else ! 1825: (void)strcpy(input_fnm, input_name[0]); ! 1826: /* ! 1827: * Open properties file ! 1828: */ ! 1829: if (proc_flag[PROPERTIES] == FLAG_ON) ! 1830: open_propfile(); ! 1831: /* ! 1832: * Tell about rotate, xOffset, yOffset, binding offset, duplex, and scale ! 1833: */ ! 1834: if ((proc_flag[LANDSCAPE] == FLAG_ON) || ! 1835: (proc_flag[ROTATE] == FLAG_ON)) ! 1836: { ! 1837: (void)sprintf(msg, "--ipfe: Rotate %d degrees\n", ! 1838: rot_deg); ! 1839: pip_error(msg); ! 1840: } ! 1841: if (proc_flag[X_OFFSET] == FLAG_ON) ! 1842: { ! 1843: (void)sprintf(msg, "--ipfe: xOffset = %ld/%ld meters\n", ! 1844: xoff_num, xoff_den); ! 1845: pip_error(msg); ! 1846: } ! 1847: if (proc_flag[Y_OFFSET] == FLAG_ON) ! 1848: { ! 1849: (void)sprintf(msg, "--ipfe: yOffset = %ld/%ld meters\n", ! 1850: yoff_num, yoff_den); ! 1851: pip_error(msg); ! 1852: } ! 1853: if (proc_flag[BINDING_OFFSET] == FLAG_ON) ! 1854: { ! 1855: (void)sprintf(msg, ! 1856: "--ipfe: Binding offset = %ld/%ld meters\n", ! 1857: boff_num, boff_den); ! 1858: pip_error(msg); ! 1859: if (proc_flag[DUPLEX] == FLAG_ON) ! 1860: pip_error("--ipfe: Duplex processing set\n"); ! 1861: } ! 1862: if (proc_flag[SCALE] == FLAG_ON) ! 1863: { ! 1864: (void)sprintf(msg, "--ipfe: Scale = %ld/%ld\n", ! 1865: scale_num, scale_den); ! 1866: pip_error(msg); ! 1867: } ! 1868: /* ! 1869: * Tell about chapterizing ! 1870: */ ! 1871: if (proc_flag[CHAPTERIZE] == FLAG_ON) ! 1872: { ! 1873: (void)sprintf(msg, "--ipfe: Chapterize every %d ", chap_val); ! 1874: pip_error(msg); ! 1875: switch ! 1876: (chap_type) ! 1877: { ! 1878: case (CH_PAGES): ! 1879: pip_error("pages"); ! 1880: break; ! 1881: case (CH_KBYTES): ! 1882: (void)sprintf(msg, "bytes (%d kbytes)", ! 1883: (chap_val / 1024)); ! 1884: pip_error(msg); ! 1885: break; ! 1886: case (CH_MBYTES): ! 1887: (void)sprintf(msg, "bytes (%d mbytes)", ! 1888: (chap_val / 1048576)); ! 1889: pip_error(msg); ! 1890: break; ! 1891: } ! 1892: pip_error("\n"); ! 1893: } ! 1894: /* ! 1895: * Show any aliases ! 1896: */ ! 1897: for (i=0; i < num_aliases; i++) ! 1898: { ! 1899: if (i == 0) ! 1900: pip_error("--ipfe: "); ! 1901: else ! 1902: pip_error("-- "); ! 1903: (void)sprintf(msg, "Alias: %s=%s\n", ! 1904: alias_ref[i], alias_act[i]); ! 1905: pip_error(msg); ! 1906: } ! 1907: ! 1908: if (num_infiles > 1) ! 1909: proc_flag[CONCAT] = FLAG_ON; ! 1910: ! 1911: if (proc_flag[DEBUG] == FLAG_ON) ! 1912: off_indent = 10; ! 1913: else ! 1914: off_indent = 0; ! 1915: ! 1916: /* ! 1917: * For now, IF the properties option flag is SET AND there is no output ! 1918: * file specified, ! 1919: * THEN set the environment for properties only (don't open output) ! 1920: */ ! 1921: if ((proc_flag[PROPERTIES] == FLAG_ON) && ! 1922: (outputname == 0)) ! 1923: ; /* process properties only; no output */ ! 1924: else ! 1925: { ! 1926: /* ! 1927: * open the output file ! 1928: */ ! 1929: if (outputname == 0) ! 1930: { ! 1931: /* ! 1932: * construct a default output filename by concatenating ".ip" to the ! 1933: * fnm component of the 1st input filename, making sure the resulting ! 1934: * filename doesn't already exist; if it does exist, append "1" to ! 1935: * the fnm, then "2" to the fnm, etc. until the filename doesn't exist ! 1936: */ ! 1937: tval = 0; ! 1938: exit_flag = procflag = FLAG_OFF; ! 1939: while ! 1940: (exit_flag == FLAG_OFF) ! 1941: { ! 1942: (void)strcpy(work_fname, input_fnm); ! 1943: if (procflag == FLAG_ON) ! 1944: (void)strcat(work_fname, itostr(tval)); ! 1945: (void)strcat(work_fname, ".ip"); ! 1946: _fmode = BINARY_FILE; ! 1947: workfile = fopen(work_fname, "r"); ! 1948: if (workfile == NULL) ! 1949: { ! 1950: outputname = work_fname; ! 1951: exit_flag = FLAG_ON; ! 1952: } ! 1953: else ! 1954: { ! 1955: (void)fclose(workfile); ! 1956: ++tval; ! 1957: procflag = FLAG_ON; ! 1958: } ! 1959: } ! 1960: } ! 1961: ! 1962: (void)strcpy(output_name, outputname); ! 1963: outputname = output_name; ! 1964: i = mrstrichr(outputname, '.'); ! 1965: if (i != (-1)) ! 1966: { ! 1967: (void)mstrncpy(output_fnm, outputname, i); ! 1968: (void)strcpy(output_ext, (outputname + i)); ! 1969: } ! 1970: else ! 1971: (void)strcpy(output_fnm, outputname); ! 1972: ! 1973: if (proc_flag[CHAPTERIZE] == FLAG_ON) ! 1974: { ! 1975: (void)strcpy(output_name, output_fnm); ! 1976: out_filnum = 1; ! 1977: (void)strcat(output_name, itostr(out_filnum)); ! 1978: (void)strcat(output_name, output_ext); ! 1979: } ! 1980: ! 1981: open_output(); ! 1982: } ! 1983: } ! 1984: ! 1985: } ! 1986: ! 1987: ! 1988: /**************************************************************** ! 1989: * ! 1990: * iocopyn(length, file, filename): ! 1991: * iocopyn: copy <length> bytes from specified ! 1992: * file to output, checking for ! 1993: * unexpected EOF ! 1994: * ! 1995: ****************************************************************/ ! 1996: ! 1997: iocopyn(length, file, filename) ! 1998: ! 1999: FILE *file; ! 2000: long length; ! 2001: char *filename; ! 2002: { ! 2003: ! 2004: while ! 2005: (length-- > 0) ! 2006: { ! 2007: ip_putc(getc_testeof(file, filename)); ! 2008: } ! 2009: } ! 2010: ! 2011: ! 2012: /**************************************************************** ! 2013: * ! 2014: * iogetn(length, file, filename, buf): ! 2015: * iogetn: read <length> bytes from specified ! 2016: * file into specified buf, checking ! 2017: * for unexpected EOF ! 2018: * -- throw the bytes away, for now ! 2019: * ! 2020: ****************************************************************/ ! 2021: ! 2022: iogetn(length, file, filename, buf) ! 2023: ! 2024: FILE *file; ! 2025: long length; ! 2026: char *filename, *buf; ! 2027: { ! 2028: while ! 2029: (length-- > 0) ! 2030: { ! 2031: *buf++ = getc_testeof(file, filename); ! 2032: } ! 2033: *buf = '\0'; ! 2034: } ! 2035: ! 2036: ! 2037: /**************************************************************** ! 2038: * ! 2039: * ioputn(length, buf): ! 2040: * ioputn: put <length> bytes from specified ! 2041: * buf to output ! 2042: * ! 2043: ****************************************************************/ ! 2044: ! 2045: ioputn(length, buf) ! 2046: ! 2047: long length; ! 2048: char *buf; ! 2049: { ! 2050: while ! 2051: (length-- > 0) ! 2052: { ! 2053: ip_putc(*buf++); ! 2054: } ! 2055: } ! 2056: ! 2057: ! 2058: /**************************************************************** ! 2059: * ! 2060: * ioreadn(length, file, filename): ! 2061: * ioreadn: read <length> bytes from specified ! 2062: * file, checking for unexpected EOF ! 2063: * -- throw the bytes away, for now ! 2064: * ! 2065: ****************************************************************/ ! 2066: ! 2067: ioreadn(length, file, filename) ! 2068: ! 2069: FILE *file; ! 2070: long length; ! 2071: char *filename; ! 2072: { ! 2073: ! 2074: while ! 2075: (length-- > 0) ! 2076: { ! 2077: (void)getc_testeof(file, filename); /* throw it away */ ! 2078: } ! 2079: } ! 2080: ! 2081: ! 2082: /**************************************************************** ! 2083: * ! 2084: * ip_putc(ch): ! 2085: * ip_putc: put char to (interpress) output & ! 2086: * bump out_offset ! 2087: * ! 2088: ****************************************************************/ ! 2089: ! 2090: ip_putc(ch) ! 2091: ! 2092: char ch; ! 2093: { ! 2094: if ((output != NULL) && (ipwrite_flag == FLAG_ON)) ! 2095: { ! 2096: putc(ch, output); ! 2097: ++out_offset; ! 2098: } ! 2099: } ! 2100: ! 2101: ! 2102: ! 2103: /**************************************************************** ! 2104: * ! 2105: * ip_puts(string): ! 2106: * ip_puts: put string to (interpress) output ! 2107: * & add strlen(string) to out_offset ! 2108: * ! 2109: ****************************************************************/ ! 2110: ! 2111: ip_puts(string) ! 2112: ! 2113: char *string; ! 2114: { ! 2115: if ((output != NULL) && (ipwrite_flag == FLAG_ON)) ! 2116: { ! 2117: fprintf(output, string); ! 2118: out_offset = out_offset + strlen(string); ! 2119: } ! 2120: ! 2121: } ! 2122: ! 2123: ! 2124: /**************************************************************** ! 2125: * ! 2126: * char *itostr(ival): ! 2127: * char *itostr: cvt int to ascii string; return ptr ! 2128: * ! 2129: ****************************************************************/ ! 2130: ! 2131: char *itostr(ival) ! 2132: ! 2133: int ival; ! 2134: { ! 2135: int i, digit, digit_flag; ! 2136: char num_buf[17], *s; ! 2137: ! 2138: ! 2139: s = num_buf; ! 2140: digit_flag = FLAG_OFF; ! 2141: for (i=10000; i > 0; i=i/10) ! 2142: { ! 2143: digit = ival / i; ! 2144: if ((digit == 0) && (digit_flag == FLAG_OFF) && (i > 1)) ! 2145: ; /* do nothing */ ! 2146: else ! 2147: { ! 2148: *s = digit + '0'; ! 2149: ++s; ! 2150: ival = ival - (digit * i); ! 2151: digit_flag = FLAG_ON; ! 2152: } ! 2153: } ! 2154: *s = '\0'; ! 2155: ! 2156: return(num_buf); ! 2157: } ! 2158: ! 2159: ! 2160: /**************************************************************** ! 2161: * ! 2162: * mgetc(file): ! 2163: * mgetc: get char from input & bump ! 2164: * appropriate counters ! 2165: * ! 2166: ****************************************************************/ ! 2167: ! 2168: int mgetc(file) ! 2169: ! 2170: FILE *file; ! 2171: { ! 2172: int val; ! 2173: ! 2174: ! 2175: val = getc(file); ! 2176: if (!(feof(file))) ! 2177: { ! 2178: val = val & 0xff; ! 2179: ++in_offset; ! 2180: ++blk_num_bytes[block_indx]; ! 2181: ++pg_num_bytes; ! 2182: } ! 2183: ! 2184: return(val); ! 2185: } ! 2186: ! 2187: ! 2188: /**************************************************************** ! 2189: * ! 2190: * mputc_prop(ch): ! 2191: * mputc_prop: put char to propfile ! 2192: * ! 2193: ****************************************************************/ ! 2194: ! 2195: mputc_prop(ch) ! 2196: { ! 2197: if ((propfile != NULL) && (ovly_flag == FLAG_OFF)) ! 2198: { ! 2199: putc(ch, propfile); ! 2200: if (ch == '\n') ! 2201: cur_col = 0; ! 2202: } ! 2203: ! 2204: } ! 2205: ! 2206: /**************************************************************** ! 2207: * ! 2208: * int mrstrichr(str, ch): ! 2209: * int mrstrichr: reverse srch for char in string; ! 2210: * if fnd, ! 2211: * return its pos (indexed from 0); ! 2212: * else ! 2213: * return (-1) ! 2214: * ! 2215: ****************************************************************/ ! 2216: ! 2217: int mrstrichr(str, ch) ! 2218: ! 2219: char *str, ch; ! 2220: { ! 2221: int i, indx, retcd; ! 2222: ! 2223: ! 2224: retcd = (-1); ! 2225: indx = strlen(str) - 1; ! 2226: str = str + indx; ! 2227: for (i=indx; i >= 0; i--, str--) ! 2228: { ! 2229: if (*str == ch) ! 2230: { ! 2231: retcd = i; ! 2232: break; ! 2233: } ! 2234: } ! 2235: ! 2236: return(retcd); ! 2237: } ! 2238: ! 2239: ! 2240: /**************************************************************** ! 2241: * ! 2242: * int mstrncmp(s1, s2, len): ! 2243: * int mstrncmp: cmp s1 to s2 for max of len bytes ! 2244: * (byte-wise compare, left to right); ! 2245: * if *s1 != *s2, ! 2246: * return (int)(*s1 - *s2) ! 2247: * (i.e., <0 if s1<s2, >0 if s1>s2) ! 2248: * else ! 2249: * return 0 ! 2250: * ! 2251: ****************************************************************/ ! 2252: ! 2253: int mstrncmp(s1, s2, len) ! 2254: ! 2255: int len; ! 2256: char *s1, *s2; ! 2257: { ! 2258: int i, retcd; ! 2259: ! 2260: ! 2261: retcd = 0; ! 2262: for (i=0; i < len; i++, s1++, s2++) ! 2263: { ! 2264: if (*s1 != *s2) ! 2265: { ! 2266: retcd = (int)(*s1 - *s2); ! 2267: break; ! 2268: } ! 2269: } ! 2270: ! 2271: return(retcd); ! 2272: } ! 2273: ! 2274: ! 2275: /**************************************************************** ! 2276: * ! 2277: * int mstrncpy(to, from, len): ! 2278: * int mstrncpy: copy from -> to for len; return ! 2279: * actual # bytes copied (will be ! 2280: * < len if <from> is null-terminated ! 2281: * shorter than len); ! 2282: * guarantees not overwriting allocated ! 2283: * space for <to> if sizeof(to) is at ! 2284: * least len + 1 (i.e., if len = ! 2285: * sizeof(to) - 1; ! 2286: * destination <to> is always null- ! 2287: * terminated ! 2288: * ! 2289: ****************************************************************/ ! 2290: ! 2291: int mstrncpy(to, from, len) ! 2292: ! 2293: int len; ! 2294: char *to, *from; ! 2295: { ! 2296: int cnt; ! 2297: ! 2298: ! 2299: cnt = 0; ! 2300: while ! 2301: ((len-- > 0) && (*from != '\0')) ! 2302: { ! 2303: *to++ = *from++; ! 2304: ++cnt; ! 2305: } ! 2306: *to = '\0'; ! 2307: ! 2308: return(cnt); ! 2309: } ! 2310: ! 2311: ! 2312: /**************************************************************** ! 2313: * ! 2314: * open_logfile(argc, argv): ! 2315: * open_logfile: open the logfile for processing ! 2316: * ! 2317: ****************************************************************/ ! 2318: ! 2319: open_logfile(argc, argv) ! 2320: ! 2321: int argc; ! 2322: char *argv[]; ! 2323: { ! 2324: int i; ! 2325: ! 2326: ! 2327: _fmode = TEXT_FILE; ! 2328: logfile = fopen(logfilename, "w"); ! 2329: if (logfile == NULL) ! 2330: { ! 2331: fprintf(STDERR, ! 2332: "--ipfe: Can't open log file: %s\n", logfilename); ! 2333: *logfilename = '\0'; ! 2334: } ! 2335: else ! 2336: { ! 2337: fprintf(STDERR, "--ipfe: Log file: %s is open\n", logfilename); ! 2338: ! 2339: fprintf(logfile, "\n"); ! 2340: for (i=0; i < argc; i++) ! 2341: fprintf(logfile, "%s ", argv[i]); ! 2342: fprintf(logfile, "\n\n"); ! 2343: } ! 2344: ! 2345: } ! 2346: ! 2347: ! 2348: /**************************************************************** ! 2349: * ! 2350: * open_output: open the output for processing ! 2351: * ! 2352: ****************************************************************/ ! 2353: ! 2354: open_output() ! 2355: { ! 2356: char msg[128]; ! 2357: ! 2358: ! 2359: _fmode = BINARY_FILE; ! 2360: output = fopen(outputname, "w"); ! 2361: if (output == NULL) ! 2362: { ! 2363: terrno = errno; /* save errno */ ! 2364: (void)sprintf(msg, ! 2365: "--ipfe: Error opening output file: %s, retcd=%d\n", ! 2366: outputname, errno); ! 2367: pip_error(msg); ! 2368: errno = terrno; ! 2369: exit(2); ! 2370: } ! 2371: ! 2372: } ! 2373: ! 2374: ! 2375: /**************************************************************** ! 2376: * ! 2377: * open_propfile: open the properties file for processing ! 2378: * ! 2379: ****************************************************************/ ! 2380: ! 2381: open_propfile() ! 2382: { ! 2383: char msg[128]; ! 2384: ! 2385: ! 2386: _fmode = TEXT_FILE; ! 2387: if (propfname == 0) ! 2388: { ! 2389: (void)strcpy(prop_fname, input_fnm); ! 2390: (void)strcat(prop_fname, ".prop"); ! 2391: propfname = prop_fname; ! 2392: ! 2393: (void)sprintf(msg, ! 2394: "--ipfe: No properties filename specified. Using: %s\n", ! 2395: propfname); ! 2396: pip_error(msg); ! 2397: } ! 2398: ! 2399: propfile = fopen(propfname, "w"); ! 2400: if (propfile == NULL) ! 2401: { ! 2402: (void)sprintf(msg, ! 2403: "--ipfe: Can't open properties file: %s\n", propfname); ! 2404: pip_error(msg); ! 2405: *propfname = '\0'; ! 2406: } ! 2407: else ! 2408: { ! 2409: (void)sprintf(msg, ! 2410: "--ipfe: Properties file: %s is open\n", propfname); ! 2411: pip_error(msg); ! 2412: } ! 2413: ! 2414: } ! 2415: ! 2416: ! 2417: /**************************************************************** ! 2418: * ! 2419: * char *op_name(op): ! 2420: * char *op_name: check op_names[] table of op_code ! 2421: * name strings for non-null entry; ! 2422: * if non_null, ! 2423: * return ptr to the string, ! 2424: * else, ! 2425: * return ptr to string ! 2426: * "--Unknown op: <op>" ! 2427: * ! 2428: ****************************************************************/ ! 2429: ! 2430: char *op_name(op) ! 2431: ! 2432: int op; ! 2433: { ! 2434: char buf[20]; ! 2435: ! 2436: if (op_names[op] == NULL) ! 2437: { ! 2438: (void)sprintf(buf, "--Unknown op: %d --", op); ! 2439: return(buf); ! 2440: } ! 2441: else ! 2442: return(op_names[op]); ! 2443: } ! 2444: ! 2445: ! 2446: /**************************************************************** ! 2447: * ! 2448: * pip_error(msg): ! 2449: * pip_error: put error msg to stdout & logfile ! 2450: * ! 2451: ****************************************************************/ ! 2452: ! 2453: pip_error(msg) ! 2454: ! 2455: char *msg; ! 2456: { ! 2457: if (proc_flag[QUIET] != FLAG_ON) ! 2458: fprintf(STDERR, msg); ! 2459: if (logfile != NULL) ! 2460: fprintf(logfile, msg); ! 2461: } ! 2462: ! 2463: ! 2464: ! 2465: /**************************************************************** ! 2466: * ! 2467: * pip_prop(msg): ! 2468: * pip_prop: put msg to propfile ! 2469: * ! 2470: ****************************************************************/ ! 2471: ! 2472: pip_prop(msg) ! 2473: ! 2474: char *msg; ! 2475: { ! 2476: if ((propfile != NULL) && (ovly_flag == FLAG_OFF)) ! 2477: { ! 2478: fprintf(propfile, msg); ! 2479: if (*(msg + strlen(msg) - 1) == '\n') ! 2480: cur_col = 0; ! 2481: else ! 2482: cur_col = cur_col + strlen(msg); ! 2483: ! 2484: } ! 2485: ! 2486: } ! 2487: ! 2488: ! 2489: /**************************************************************** ! 2490: * ! 2491: * preserve_SIF_copy(type_byte, length, file, filename): ! 2492: * preserve_SIF_copy: preserve SIF reference by copying ! 2493: * from specified input file to output ! 2494: * ! 2495: ****************************************************************/ ! 2496: ! 2497: copy_preserve_SIF(type_byte, length, file, filename) ! 2498: ! 2499: FILE *file; ! 2500: long length; ! 2501: int type_byte; ! 2502: char *filename; ! 2503: { ! 2504: put_seq_type_len(type_byte, length); ! 2505: iocopyn(length, file, filename); ! 2506: } ! 2507: ! 2508: ! 2509: ! 2510: /**************************************************************** ! 2511: * ! 2512: * preserve_SIF_put(type_byte, length, buf): ! 2513: * preserve_SIF_put: preserve SIF reference by copying ! 2514: * from specified buffer to output ! 2515: * ! 2516: ****************************************************************/ ! 2517: ! 2518: put_preserve_SIF(type_byte, length, buf) ! 2519: ! 2520: long length; ! 2521: int type_byte; ! 2522: char *buf; ! 2523: { ! 2524: put_seq_type_len(type_byte, length); ! 2525: ioputn(length, buf); ! 2526: } ! 2527: ! 2528: ! 2529: /**************************************************************** ! 2530: * ! 2531: * proc_alias(alias_string): ! 2532: * proc_alias: process alias argument ! 2533: * ! 2534: ****************************************************************/ ! 2535: ! 2536: proc_alias(alias_string) ! 2537: ! 2538: char *alias_string; ! 2539: { ! 2540: int indx, len; ! 2541: char msg[128]; ! 2542: ! 2543: ! 2544: len = strlen(alias_string); ! 2545: indx = mrstrichr(alias_string, ':'); ! 2546: if ((indx > 0) && (indx < (len - 1))) /* past beg & before end */ ! 2547: { ! 2548: (void)mstrncpy(alias_ref[alias_indx], alias_string, indx); ! 2549: ++indx; ! 2550: (void)mstrncpy(alias_act[alias_indx], (alias_string + indx), ! 2551: (len - indx)); ! 2552: ++alias_indx; ! 2553: ++num_aliases; ! 2554: } ! 2555: else ! 2556: { ! 2557: (void)sprintf(msg, ! 2558: "--ipfe: *** warning -- invalid alias specification (%s)\n", ! 2559: alias_string); ! 2560: pip_error(msg); ! 2561: exit_status = 4; ! 2562: } ! 2563: ! 2564: } ! 2565: ! 2566: ! 2567: /**************************************************************** ! 2568: * ! 2569: * proc_chapterize: test for & process chapterizing ! 2570: * ! 2571: ****************************************************************/ ! 2572: ! 2573: proc_chapterize() ! 2574: { ! 2575: long len, temp_end_offset; ! 2576: int i, op, terrno, tblock_indx, proc_op_flag, eof_flag, proc_type; ! 2577: int type_byte; /* must be int for stdio EOF */ ! 2578: char msg[128]; ! 2579: ! 2580: ! 2581: if ((proc_flag[CHAPTERIZE] == FLAG_ON) && ! 2582: (((chap_type == CH_PAGES) && (out_numpages == chap_val)) || ! 2583: (((chap_type == CH_KBYTES) || (chap_type == CH_MBYTES)) && ! 2584: (out_offset >= chap_val)))) ! 2585: { ! 2586: ! 2587: /* ! 2588: * Eventually, the next two lines should be rewritten to check to see ! 2589: * if we might somehow be nested in a body before putting the ! 2590: * OP_endblock(s) ! 2591: */ ! 2592: ! 2593: for (i=0; i < block_indx; i++) ! 2594: put_op(OP_endBlock); ! 2595: ! 2596: (void)fclose(output); ! 2597: ! 2598: /* ! 2599: * Now, check for OP_endBlock(s) appearing immediately in the input ! 2600: * file. If so, skip them: they were already put out above. In looking, ! 2601: * if we get an EOF and there are no more input files, don't open a ! 2602: * new output file. ! 2603: */ ! 2604: ! 2605: proc_op_flag = eof_flag = FLAG_OFF; ! 2606: tblock_indx = block_indx; /* because the actual block_indx can ! 2607: be dcr'd in the loop */ ! 2608: for (i=0; i <= tblock_indx; i++) ! 2609: { ! 2610: type_byte = mgetc(input); ! 2611: if (feof(input)) ! 2612: { ! 2613: /* ! 2614: * set eof_flag only if there are no more input files ! 2615: */ ! 2616: if (input_indx >= (num_infiles - 1)) ! 2617: eof_flag = FLAG_ON; ! 2618: break; ! 2619: } ! 2620: else ! 2621: if ((type_byte & OP_Mask) == (LONG_OP & OP_Mask)) ! 2622: { ! 2623: op = ((type_byte & 0x1f) << 8) + ! 2624: getc_testeof(input, inputname); ! 2625: if ((op == OP_endBlock) && (i < block_indx)) ! 2626: --block_indx; ! 2627: else ! 2628: { ! 2629: proc_op_flag = FLAG_ON; /* set flag for use below */ ! 2630: proc_type = LONG_OP; ! 2631: break; ! 2632: } ! 2633: } ! 2634: else ! 2635: { ! 2636: proc_op_flag = FLAG_ON; /* set flag for use below */ ! 2637: proc_type = ~(LONG_OP); ! 2638: break; ! 2639: } ! 2640: } ! 2641: if (eof_flag == FLAG_OFF) ! 2642: { ! 2643: (void)strcpy(work_fname, outputname); ! 2644: workfile = fopen(work_fname, "r"); ! 2645: if (workfile == NULL) ! 2646: { ! 2647: terrno = errno; /* save errno */ ! 2648: pip_error( ! 2649: "Chapterize error opening previous output file as input\n"); ! 2650: (void)sprintf(msg, " file=%s, retcd=%d\n", ! 2651: outputname, errno); ! 2652: pip_error(msg); ! 2653: pip_error(" Can't complete chapterization --\n\n"); ! 2654: pip_error(" *** ABORTING ***\n"); ! 2655: errno = terrno; ! 2656: exit(3); ! 2657: } ! 2658: else ! 2659: { ! 2660: ++out_filnum; ! 2661: (void)strcpy(output_name, output_fnm); ! 2662: (void)strcat(output_name, itostr(out_filnum)); ! 2663: (void)strcat(output_name, output_ext); ! 2664: (void)sprintf(msg, ! 2665: "--ipfe: Processing output file: %s\n", ! 2666: outputname); ! 2667: pip_error(msg); ! 2668: ! 2669: _fmode = BINARY_FILE; ! 2670: output = fopen(outputname, "w"); ! 2671: if (output == NULL) ! 2672: { ! 2673: terrno = errno; /* save errno */ ! 2674: (void)sprintf(msg, ! 2675: "--ipfe: Error opening output file=%s, retcd=%d\n", ! 2676: outputname, errno); ! 2677: pip_error(msg); ! 2678: errno = terrno; ! 2679: exit(4); ! 2680: } ! 2681: else ! 2682: { ! 2683: /* ! 2684: * Then, copy Hdr & BEGIN/Preamble(s) to new output ! 2685: */ ! 2686: out_numpages = 0; ! 2687: out_offset = 0; ! 2688: for (i=0; i <= block_indx; i++) ! 2689: { ! 2690: len = out_end_offset[i] - out_beg_offset[i] + 1; ! 2691: out_beg_offset[i] = out_offset; ! 2692: iocopyn(len, workfile, work_fname); ! 2693: temp_end_offset = out_end_offset[i]; ! 2694: out_end_offset[i] = out_offset - 1; ! 2695: if (i < block_indx) /* if there is more to do */ ! 2696: { ! 2697: len = out_beg_offset[i+1] - ! 2698: temp_end_offset - 1; ! 2699: ioreadn(len, workfile, work_fname); ! 2700: } ! 2701: } ! 2702: } ! 2703: (void)fclose(workfile); ! 2704: /* ! 2705: * Finally, if a token other than OP_endBlock token was read above, ! 2706: * process it ! 2707: */ ! 2708: if (proc_op_flag == FLAG_ON) ! 2709: { ! 2710: if (proc_type == LONG_OP) ! 2711: proc_long_op(op); ! 2712: else ! 2713: proc_ip_token(type_byte, input, inputname); ! 2714: } ! 2715: } ! 2716: } ! 2717: } ! 2718: ! 2719: } ! 2720: ! 2721: ! 2722: /**************************************************************** ! 2723: * ! 2724: * proc_file: process the input file ! 2725: * ! 2726: ****************************************************************/ ! 2727: ! 2728: proc_file() ! 2729: ! 2730: { ! 2731: long offset; ! 2732: int i, op, retcd, exit_flag; ! 2733: int type_byte; /* must be int for stdio EOF */ ! 2734: char msg[128]; ! 2735: ! 2736: ! 2737: if (setjmp(next_file) != 0) /* for error recovery of */ ! 2738: { /* unexpected EOF */ ! 2739: return; ! 2740: } ! 2741: ! 2742: ! 2743: offset = in_offset; ! 2744: retcd = get_ip_hdr(input, inputname); /* get the hdr */ ! 2745: if (retcd == OK) ! 2746: { ! 2747: (void)sprintf(msg, "-- Hdr : %s--\n", hdr_workbuf); ! 2748: pip_error(msg); ! 2749: mputc_prop('\n'); ! 2750: put_offset_msg_to_prop(offset, hdr_workbuf); ! 2751: pip_prop("--\n"); ! 2752: ! 2753: if (input_indx == 0) /* if 1st file, */ ! 2754: { ! 2755: if (proc_flag[CONCAT] == FLAG_ON) ! 2756: (void)strcpy((hdr_workbuf+IP_VERS_OFFSET), "2.1 "); ! 2757: (void)strcpy(hdr_buf, hdr_workbuf); /* save hdr */ ! 2758: if (output != NULL) ! 2759: { ! 2760: (void)sprintf(msg, "\nProcessing output file: %s\n", ! 2761: outputname); ! 2762: pip_error(msg); ! 2763: (void)sprintf(msg, "-- Output Hdr: %s--\n", hdr_workbuf); ! 2764: pip_error(msg); ! 2765: ip_puts(hdr_workbuf); /* copy hdr & add len to ! 2766: out_offset */ ! 2767: } ! 2768: ! 2769: /* ! 2770: * copy everything up to, but NOT including (will include later), ! 2771: * OP_beginBlock ! 2772: */ ! 2773: exit_flag = FLAG_OFF; ! 2774: while ! 2775: (exit_flag == FLAG_OFF) ! 2776: { ! 2777: type_byte = getc_testeof(input, inputname); ! 2778: if ((type_byte & OP_Mask) == (LONG_OP & OP_Mask)) ! 2779: { ! 2780: op = ((type_byte & 0x1f) << 8) + ! 2781: getc_testeof(input, inputname); ! 2782: if (op == OP_beginBlock) ! 2783: exit_flag = FLAG_ON; ! 2784: else ! 2785: { ! 2786: ip_putc(type_byte); ! 2787: ip_putc(op); ! 2788: } ! 2789: } ! 2790: else ! 2791: proc_ip_token(type_byte, input, inputname); ! 2792: } ! 2793: out_end_offset[0] = out_offset - 1; ! 2794: /* ! 2795: * if concatenating, wrap a BEGIN empty_preamble END after the hdr & ! 2796: * instructionsBody and around the rest of the output ! 2797: */ ! 2798: if (proc_flag[CONCAT] == FLAG_ON) ! 2799: { ! 2800: ++block_indx; ! 2801: out_beg_offset[block_indx] = out_offset; ! 2802: put_op(OP_beginBlock); ! 2803: put_op(OP_beginBody); ! 2804: put_op(OP_endBody); ! 2805: out_end_offset[block_indx] = out_offset - 1; ! 2806: } ! 2807: /* ! 2808: * NOW include the OP_beginBlock, & process the rest of the master ! 2809: */ ! 2810: proc_long_op(OP_beginBlock); ! 2811: } ! 2812: prc_ip_tokens(input, inputname); ! 2813: ! 2814: mputc_prop('\n'); ! 2815: indent(off_indent, propfile); ! 2816: (void)sprintf(msg, "--Number of Blocks:%4d\n", num_blocks); ! 2817: pip_prop(msg); ! 2818: indent(off_indent, propfile); ! 2819: (void)sprintf(msg, "--Number of Pages :%4d\n", num_pages); ! 2820: pip_prop(msg); ! 2821: indent(off_indent, propfile); ! 2822: (void)sprintf(msg, "--Number of SIFs :%4d\n", num_sifs); ! 2823: pip_prop(msg); ! 2824: ! 2825: for (i=0; merge_pg[input_indx][i] != 0; i++) ! 2826: { ! 2827: if (merge_pg[input_indx][i] > num_pages) ! 2828: { ! 2829: (void)sprintf(msg, ! 2830: "\n--ipfe: *** Page %d selected > # of pages in %s (%d)\n", ! 2831: merge_pg[input_indx][i], inputname, ! 2832: num_pages); ! 2833: pip_error(msg); ! 2834: break; ! 2835: } ! 2836: } ! 2837: } ! 2838: /*** ! 2839: else ! 2840: { ! 2841: (void)sprintf(msg, "(*** PROCESSING ABORTED ***)\n"); ! 2842: pip_error(msg); ! 2843: input_indx = num_infiles; ! 2844: abort_flag = FLAG_ON; ! 2845: } ! 2846: ***/ ! 2847: } ! 2848: ! 2849: ! 2850: /**************************************************************** ! 2851: * ! 2852: * prc_IF_bof(ifile, ifilename): ! 2853: * prc_IF_bof: read specified Interpress file & ! 2854: * discard everything up to, and ! 2855: * including, first OP_beginBlock ! 2856: * ! 2857: ****************************************************************/ ! 2858: ! 2859: prc_IF_bof(ifile, ifilename) ! 2860: ! 2861: FILE *ifile; ! 2862: char *ifilename; ! 2863: { ! 2864: int op, exit_flag; ! 2865: int type_byte; /* must be int for stdio EOF */ ! 2866: ! 2867: ! 2868: exit_flag = FLAG_OFF; ! 2869: while ! 2870: (exit_flag == FLAG_OFF) ! 2871: { ! 2872: type_byte = getc_testeof(ifile, ifilename); ! 2873: if ((type_byte & OP_Mask) == (LONG_OP & OP_Mask)) ! 2874: { ! 2875: op = ((type_byte & 0x1f) << 8) + ! 2876: getc_testeof(ifile, ifilename); ! 2877: if (op == OP_beginBlock) ! 2878: exit_flag = FLAG_ON; ! 2879: } ! 2880: } ! 2881: } ! 2882: ! 2883: ! 2884: /**************************************************************** ! 2885: * ! 2886: * prc_IF_fragment(ifile, ifilename): ! 2887: * prc_IF_fragment: process specified Interpress fragment ! 2888: * (i.e., skip everything up to, and ! 2889: * including the first OP_beginBlock; ! 2890: * then include everything up to, but ! 2891: * not including, the next OP_endBlock) ! 2892: * ! 2893: ****************************************************************/ ! 2894: ! 2895: prc_IF_fragment(ifile, ifilename) ! 2896: ! 2897: FILE *ifile; ! 2898: char *ifilename; ! 2899: { ! 2900: int op, exit_flag; ! 2901: int type_byte; /* must be int for stdio EOF */ ! 2902: ! 2903: ! 2904: /* ! 2905: * read & discard everything up to, and including, OP_beginBlock ! 2906: */ ! 2907: prc_IF_bof(ifile, ifilename); ! 2908: ! 2909: /* ! 2910: * read & copy everything up to, but NOT including OP_endBlock ! 2911: */ ! 2912: exit_flag = FLAG_OFF; ! 2913: while ! 2914: (exit_flag == FLAG_OFF) ! 2915: { ! 2916: type_byte = getc_testeof(ifile, ifilename); ! 2917: if ((type_byte & OP_Mask) == (LONG_OP & OP_Mask)) ! 2918: { ! 2919: op = ((type_byte & 0x1f) << 8) + ! 2920: getc_testeof(ifile, ifilename); ! 2921: if (op == OP_endBlock) ! 2922: exit_flag = FLAG_ON; ! 2923: else ! 2924: put_op(op); ! 2925: } ! 2926: else ! 2927: proc_ip_token(type_byte, ifile, ifilename); ! 2928: } ! 2929: } ! 2930: ! 2931: ! 2932: /**************************************************************** ! 2933: * ! 2934: * prc_IF_master(ifile, ifilename, pg): ! 2935: * prc_IF_master: process specified page of the ! 2936: * specified Interpress master ! 2937: * (i.e., skip everything up to, and ! 2938: * including the first OP_beginBlock; ! 2939: * then include the contents of the ! 2940: * preamble and the specified page, ! 2941: * without including the body tokens) ! 2942: * ! 2943: ****************************************************************/ ! 2944: ! 2945: prc_IF_master(ifile, ifilename, pg) ! 2946: ! 2947: FILE *ifile; ! 2948: int pg; ! 2949: char *ifilename; ! 2950: { ! 2951: int op, exit_flag, wrt_flag, blk_indx, pg_cnt; ! 2952: int level[MX_BLOCK_DEPTH], ctr[MX_BLOCK_DEPTH]; ! 2953: int type_byte; /* must be int for stdio EOF */ ! 2954: ! 2955: ! 2956: /* ! 2957: * read & discard everything up to, and including, OP_beginBlock ! 2958: */ ! 2959: prc_IF_bof(ifile, ifilename); ! 2960: ! 2961: /* ! 2962: * read & copy the contents of the preamble; then, copy only the ! 2963: * contents of the specified page ! 2964: */ ! 2965: blk_indx = pg_cnt = 0; ! 2966: level[blk_indx] = ctr[blk_indx] = 0; ! 2967: wrt_flag = FLAG_OFF; ! 2968: exit_flag = FLAG_OFF; ! 2969: while ! 2970: (exit_flag == FLAG_OFF) ! 2971: { ! 2972: type_byte = getc_testeof(ifile, ifilename); ! 2973: if ((type_byte & OP_Mask) == (LONG_OP & OP_Mask)) ! 2974: { ! 2975: op = ((type_byte & 0x1f) << 8) + ! 2976: getc_testeof(ifile, ifilename); ! 2977: if (op == OP_beginBlock) ! 2978: { ! 2979: ++blk_indx; ! 2980: level[blk_indx] = ctr[blk_indx] = 0; ! 2981: } ! 2982: else ! 2983: if (op == OP_endBlock) ! 2984: { ! 2985: if (blk_indx > 0) ! 2986: --blk_indx; ! 2987: else ! 2988: exit_flag = FLAG_ON; ! 2989: } ! 2990: else ! 2991: if (op == OP_beginBody) ! 2992: { ! 2993: if (level[blk_indx] == 0) ! 2994: { ! 2995: if (ctr[blk_indx] == 0) ! 2996: wrt_flag = FLAG_ON; /* processing preamble */ ! 2997: else ! 2998: { ! 2999: ++pg_cnt; ! 3000: if (pg == pg_cnt) ! 3001: wrt_flag = FLAG_ON; /* got the right pg */ ! 3002: } ! 3003: ++ctr[blk_indx]; ! 3004: } ! 3005: else ! 3006: if (wrt_flag == FLAG_ON) ! 3007: put_op(op); ! 3008: ++level[blk_indx]; ! 3009: } ! 3010: else ! 3011: if (op == OP_endBody) ! 3012: { ! 3013: --level[blk_indx]; ! 3014: if (level[blk_indx] == 0) ! 3015: { ! 3016: wrt_flag = FLAG_OFF; ! 3017: if (pg == pg_cnt) ! 3018: exit_flag = FLAG_ON; ! 3019: } ! 3020: else ! 3021: if (wrt_flag == FLAG_ON) ! 3022: put_op(op); ! 3023: } ! 3024: else ! 3025: if (wrt_flag == FLAG_ON) ! 3026: put_op(op); ! 3027: } ! 3028: else ! 3029: if (wrt_flag == FLAG_ON) ! 3030: proc_ip_token(type_byte, ifile, ifilename); ! 3031: } ! 3032: } ! 3033: ! 3034: ! 3035: /**************************************************************** ! 3036: * ! 3037: * proc_ip_token(type_byte, file, filename): ! 3038: * proc_ip_token: process interpress token of specified ! 3039: * type from specified file ! 3040: * ! 3041: ****************************************************************/ ! 3042: ! 3043: proc_ip_token(type_byte, file, filename) ! 3044: ! 3045: FILE *file; ! 3046: int type_byte; ! 3047: char *filename; ! 3048: { ! 3049: long len; ! 3050: int op; ! 3051: ! 3052: ! 3053: if (type_byte != EOF) ! 3054: { ! 3055: if ((type_byte & 0x80) == 0) /* token is a SHORT NUMBER */ ! 3056: { ! 3057: ip_putc(type_byte); /* 2-byte token */ ! 3058: ip_putc(getc_testeof(file, filename)); ! 3059: } ! 3060: else /* token is something else */ ! 3061: { ! 3062: switch ! 3063: (type_byte & OP_Mask) ! 3064: { ! 3065: case (SHORT_OP & OP_Mask): ! 3066: ip_putc(type_byte); /* 1-byte token */ ! 3067: break; ! 3068: ! 3069: case (LONG_OP & OP_Mask): ! 3070: op = ((type_byte & 0x1f) << 8) + ! 3071: getc_testeof(file, filename); /* 2-byte token */ ! 3072: proc_long_op(op); ! 3073: break; ! 3074: ! 3075: case (SHORT_SEQUENCE & OP_Mask): ! 3076: len = getc_testeof(file, filename); ! 3077: proc_sequence(type_byte, len, file, filename); ! 3078: break; ! 3079: ! 3080: case (LONG_SEQUENCE & OP_Mask): ! 3081: len = getc_testeof(file, filename) << 16; ! 3082: len = len + (getc_testeof(file, filename) << 8); ! 3083: len = len + getc_testeof(file, filename); ! 3084: proc_sequence(type_byte, len, file, filename); ! 3085: break; ! 3086: } ! 3087: } ! 3088: } ! 3089: ! 3090: } ! 3091: ! 3092: ! 3093: /**************************************************************** ! 3094: * ! 3095: * prc_ip_tokens(file, filename): ! 3096: * prc_ip_tokens: process interpress tokens ! 3097: * specified file ! 3098: * ! 3099: ****************************************************************/ ! 3100: ! 3101: prc_ip_tokens(file, filename) ! 3102: ! 3103: FILE *file; ! 3104: char *filename; ! 3105: { ! 3106: int type_byte; /* must be int for stdio EOF */ ! 3107: ! 3108: ! 3109: while ! 3110: ((type_byte = mgetc(file)) != EOF) ! 3111: { ! 3112: proc_ip_token(type_byte, file, filename); ! 3113: } ! 3114: ! 3115: } ! 3116: ! 3117: ! 3118: /**************************************************************** ! 3119: * ! 3120: * proc_long_op(op): ! 3121: * proc_long_op: process long_op ! 3122: * ! 3123: ****************************************************************/ ! 3124: ! 3125: proc_long_op(op) ! 3126: ! 3127: int op; ! 3128: { ! 3129: long val; ! 3130: int i, nesting_level; ! 3131: ! 3132: ! 3133: switch ! 3134: (op) ! 3135: { ! 3136: case (OP_beginBlock): ! 3137: put_op(op); ! 3138: ++num_blocks; ! 3139: ++tnum_blocks; ! 3140: if (block_indx == 0) ! 3141: out_end_offset[block_indx] = out_offset - 3; ! 3142: ++block_indx; ! 3143: out_beg_offset[block_indx] = out_offset - 2; ! 3144: blk_num_bytes[block_indx] = 2; ! 3145: put_opname_to_prop(op); ! 3146: preamble_expected = FLAG_ON; ! 3147: break; ! 3148: case (OP_endBlock): ! 3149: put_op(op); ! 3150: put_opname_to_prop(op); ! 3151: --block_indx; ! 3152: break; ! 3153: case (OP_beginBody): ! 3154: put_opname_to_prop(op); ! 3155: if (preamble_expected == FLAG_ON) ! 3156: { ! 3157: put_op(op); ! 3158: preamble_expected = FLAG_OFF; ! 3159: endpreamble_expected = FLAG_ON; ! 3160: } ! 3161: else ! 3162: if (bop_flag == FLAG_ON) ! 3163: { ! 3164: put_op(op); ! 3165: if (bop_iindx[bop_indx] == 0) ! 3166: bop_preamble_expected[bop_indx] = FLAG_ON; ! 3167: else ! 3168: if ((bop_iindx[bop_indx] == 1) && ! 3169: (bop_preamble_expected[bop_indx] == FLAG_ON)) ! 3170: bop_preamble_expected[bop_indx] = FLAG_OFF; ! 3171: ! 3172: ++bop_iindx[bop_indx]; ! 3173: } ! 3174: else /* we have a righteous pageBody */ ! 3175: { ! 3176: ++num_pages; ! 3177: ++tnum_pages; ! 3178: frstpg_flag = FLAG_ON; ! 3179: pg_num_bytes = 2; ! 3180: ! 3181: if ((merge_pg[input_indx][merge_indx] == 0) || ! 3182: (num_pages < merge_pg[input_indx][merge_indx])) ! 3183: ipwrite_flag = FLAG_OFF; ! 3184: else ! 3185: { ! 3186: ipwrite_flag = FLAG_ON; /* it should already be on */ ! 3187: put_op(op); ! 3188: if ((proc_flag[LANDSCAPE] == FLAG_ON) || ! 3189: (proc_flag[ROTATE] == FLAG_ON)) ! 3190: { ! 3191: put_Integer((long)rot_deg); ! 3192: put_op(OP_rotate); ! 3193: put_op(OP_concatt); ! 3194: if ((rxoff_den == 0) || (rxoff_den == 1)) ! 3195: put_Integer(rxoff_num); ! 3196: else ! 3197: put_seqRational(rxoff_num, rxoff_den); ! 3198: if ((ryoff_den == 0) || (ryoff_den == 1)) ! 3199: put_Integer(ryoff_num); ! 3200: else ! 3201: put_seqRational(ryoff_num, ryoff_den); ! 3202: put_op(OP_translate); ! 3203: put_op(OP_concatt); ! 3204: } ! 3205: if (proc_flag[BINDING_OFFSET] == FLAG_ON) ! 3206: { ! 3207: if ((proc_flag[DUPLEX] == FLAG_ON) && ! 3208: ((num_pages % 2) == 0)) ! 3209: val = -(boff_num); ! 3210: else ! 3211: val = boff_num; ! 3212: if (proc_flag[LANDSCAPE] == FLAG_ON) ! 3213: { ! 3214: put_Integer(0L); /* no xShift */ ! 3215: if ((boff_den == 0) || (boff_den == 1)) ! 3216: put_Integer(-(val)); /* -(yShift) */ ! 3217: else ! 3218: put_seqRational(-(val), boff_den); ! 3219: } ! 3220: else ! 3221: { ! 3222: if ((boff_den == 0) || (boff_den == 1)) ! 3223: put_Integer(val); ! 3224: else ! 3225: put_seqRational(val, boff_den); ! 3226: put_Integer(0L); /* no yShift */ ! 3227: } ! 3228: put_op(OP_translate); ! 3229: put_op(OP_concatt); ! 3230: } ! 3231: if ((proc_flag[X_OFFSET] == FLAG_ON) || ! 3232: (proc_flag[Y_OFFSET] == FLAG_ON)) ! 3233: { ! 3234: if ((xoff_den == 0) || (xoff_den == 1)) ! 3235: put_Integer(xoff_num); ! 3236: else ! 3237: put_seqRational(xoff_num, xoff_den); ! 3238: ! 3239: if ((yoff_den == 0) || (yoff_den == 1)) ! 3240: put_Integer(yoff_num); ! 3241: else ! 3242: put_seqRational(yoff_num, yoff_den); ! 3243: put_op(OP_translate); ! 3244: put_op(OP_concatt); ! 3245: } ! 3246: if (proc_flag[SCALE] == FLAG_ON) ! 3247: { ! 3248: if ((scale_den == 0) | (scale_den == 1)) ! 3249: put_Integer(scale_num); ! 3250: else ! 3251: put_seqRational(scale_num, scale_den); ! 3252: put_op(OP_scale); ! 3253: put_op(OP_concatt); ! 3254: } ! 3255: ! 3256: if ((merge_pg[input_indx][merge_indx] == (-1)) && ! 3257: (num_pages == ! 3258: merge_pg[input_indx][(merge_indx+1)])) ! 3259: ++merge_indx; ! 3260: if ((num_pages == ! 3261: merge_pg[input_indx][merge_indx]) && ! 3262: (ovly_pg[input_indx][merge_indx] != (-1))) ! 3263: { ! 3264: put_op(OP_dosavesimplebody); ! 3265: put_op(OP_beginBody); ! 3266: } ! 3267: } ! 3268: } ! 3269: begBody_flag = FLAG_ON; ! 3270: break; ! 3271: case (OP_endBody): ! 3272: put_opname_to_prop(op); ! 3273: if (bop_flag == FLAG_ON) ! 3274: { ! 3275: put_op(op); ! 3276: --bop_iindx[bop_indx]; ! 3277: if ((bop_iindx[bop_indx] == 0) && (bop_indx > 0)) ! 3278: --bop_indx; ! 3279: if ((bop_indx == 0) && (bop_iindx[bop_indx] == 0)) ! 3280: bop_flag = FLAG_OFF; ! 3281: } ! 3282: else /* bop_flag == FLAG_OFF */ ! 3283: { ! 3284: if (endpreamble_expected == FLAG_ON) ! 3285: /* then processing preamble -- can't chapterize */ ! 3286: { ! 3287: put_op(op); ! 3288: endpreamble_expected = FLAG_OFF; ! 3289: /* ! 3290: * this next code determines the length of each BEGIN/Preamble to copy ! 3291: * for chapterizing as part of handling nested blocks ! 3292: */ ! 3293: out_end_offset[block_indx] = out_offset - 1; ! 3294: } ! 3295: else /* we have a righteous endBody */ ! 3296: { ! 3297: if (ipwrite_flag == FLAG_ON) ! 3298: { ! 3299: put_op(op); ! 3300: ++out_numpages; ! 3301: ovly_flag = FLAG_OFF; ! 3302: while ! 3303: (num_pages == ! 3304: merge_pg[input_indx][merge_indx]) ! 3305: { ! 3306: if (ovly_pg[input_indx][merge_indx] != (-1)) ! 3307: { ! 3308: ovly_flag = FLAG_ON; ! 3309: proc_overlay(); ! 3310: } ! 3311: ++merge_indx; ! 3312: } ! 3313: if (ovly_flag == FLAG_ON) ! 3314: { ! 3315: put_op(OP_endBody); ! 3316: ovly_flag = FLAG_OFF; ! 3317: } ! 3318: proc_chapterize(); ! 3319: } ! 3320: if (merge_pg[input_indx][merge_indx] == 0) ! 3321: { ! 3322: if (proc_flag[CONCAT] == FLAG_ON) ! 3323: nesting_level = block_indx - 1; ! 3324: else ! 3325: nesting_level = block_indx; ! 3326: ! 3327: for (i=0; i < nesting_level; i++) ! 3328: put_op(OP_endBlock); ! 3329: ipwrite_flag = FLAG_OFF; ! 3330: } ! 3331: else ! 3332: ipwrite_flag = FLAG_ON; ! 3333: } ! 3334: } ! 3335: break; ! 3336: case (OP_makesimpleco): ! 3337: case (OP_dosavesimplebody): ! 3338: case (OP_if): ! 3339: case (OP_ifelse): ! 3340: case (OP_ifcopy): ! 3341: case (OP_correct): ! 3342: put_op(op); ! 3343: put_opname_to_prop(op); ! 3344: if (bop_flag == FLAG_OFF) ! 3345: { ! 3346: bop_indx = 0; ! 3347: bop_flag = FLAG_ON; ! 3348: } ! 3349: else ! 3350: ++bop_indx; ! 3351: bop_iindx[bop_indx] = 0; ! 3352: bop_preamble_expected[bop_indx] = FLAG_OFF; ! 3353: break; ! 3354: default: ! 3355: put_op(op); ! 3356: break; ! 3357: } ! 3358: } ! 3359: ! 3360: ! 3361: /**************************************************************** ! 3362: * ! 3363: * proc_overlay: process the current ! 3364: * ovly_pg[input_indx][merge_indx] ! 3365: * ! 3366: ****************************************************************/ ! 3367: ! 3368: proc_overlay() ! 3369: { ! 3370: ! 3371: put_op(OP_dosavesimplebody); ! 3372: put_op(OP_beginBody); ! 3373: ovly_indx = ovly_pg[input_indx][merge_indx]; ! 3374: if ((ovly_den[0][ovly_indx] != 0) || ! 3375: (ovly_den[1][ovly_indx] != 0)) ! 3376: { ! 3377: if ((ovly_den[0][ovly_indx] == 0) || ! 3378: (ovly_den[0][ovly_indx] == 1)) ! 3379: put_Integer(ovly_num[0][ovly_indx]); ! 3380: else ! 3381: put_seqRational(ovly_num[0][ovly_indx], ! 3382: ovly_den[0][ovly_indx]); ! 3383: if ((ovly_den[1][ovly_indx] == 0) || ! 3384: (ovly_den[1][ovly_indx] == 1)) ! 3385: put_Integer(ovly_num[1][ovly_indx]); ! 3386: else ! 3387: put_seqRational(ovly_num[1][ovly_indx], ! 3388: ovly_den[1][ovly_indx]); ! 3389: put_op(OP_translate); ! 3390: put_op(OP_concatt); ! 3391: } ! 3392: proc_ovly_file(ovly_fname[ovly_indx]); ! 3393: put_op(OP_endBody); ! 3394: ! 3395: } ! 3396: ! 3397: ! 3398: /**************************************************************** ! 3399: * ! 3400: * prc_ovly_file(fname): ! 3401: * proc_ovly_file: try to open specified filename; ! 3402: * if open_err, ! 3403: * create a SIF reference ! 3404: * else, ! 3405: * process as a SIF ! 3406: * ! 3407: ****************************************************************/ ! 3408: ! 3409: proc_ovly_file(fname) ! 3410: ! 3411: char *fname; ! 3412: { ! 3413: int retcd, pgnum; ! 3414: char msg[128]; ! 3415: ! 3416: ! 3417: ovly_file = fopen(fname, "r"); ! 3418: if (ovly_file == NULL) ! 3419: { ! 3420: (void)sprintf(msg, ! 3421: " --Error opening overlay file: %s\n", ! 3422: fname); ! 3423: pip_error(msg); ! 3424: create_SIF(fname); ! 3425: } ! 3426: else ! 3427: { ! 3428: retcd = get_ip_hdr(ovly_file, fname); ! 3429: if (retcd == ERROR) ! 3430: create_SIF(fname); ! 3431: else ! 3432: { ! 3433: /*** ! 3434: The following assumes we're not already nested in a body_operator ! 3435: (i.e., that we were at a real endBody when invoked) ! 3436: ***/ ! 3437: bop_flag = FLAG_ON; ! 3438: bop_indx = 0; ! 3439: bop_iindx[0] = 0; ! 3440: bop_preamble_expected[0] = FLAG_ON; ! 3441: if (strlen(hdr_workbuf) > IP_HDR_MASTERLEN) ! 3442: prc_IF_fragment(ovly_file, fname); ! 3443: else ! 3444: { ! 3445: if (ovly_pgnum[ovly_indx] == 0) ! 3446: pgnum = 1; ! 3447: else ! 3448: pgnum = ovly_pgnum[ovly_indx]; ! 3449: prc_IF_master(ovly_file, fname, pgnum); ! 3450: } ! 3451: bop_flag = FLAG_OFF; ! 3452: } ! 3453: (void)fclose(ovly_file); ! 3454: } ! 3455: ! 3456: } ! 3457: ! 3458: ! 3459: /**************************************************************** ! 3460: * ! 3461: * proc_sequence(type_byte, length, file, filename): ! 3462: * proc_sequence: process Interpress tokens of type ! 3463: * <sequence> ! 3464: * ! 3465: ****************************************************************/ ! 3466: ! 3467: proc_sequence(type_byte, length, file, filename) ! 3468: ! 3469: FILE *file; ! 3470: long length; ! 3471: int type_byte; ! 3472: char *filename; ! 3473: { ! 3474: ! 3475: if ((type_byte & 0x1f) == sequenceInsertFile) ! 3476: proc_SIF_token(type_byte, length, file, filename); ! 3477: else ! 3478: { ! 3479: put_seq_type_len(type_byte, length); ! 3480: iocopyn(length, file, filename); ! 3481: } ! 3482: } ! 3483: ! 3484: ! 3485: /**************************************************************** ! 3486: * ! 3487: * prc_SIF_file(sfile, sfilename): ! 3488: * prc_SIF_file: process sequenceInsertFile ! 3489: * ! 3490: ****************************************************************/ ! 3491: ! 3492: prc_SIF_file(sfile, sfilename) ! 3493: ! 3494: FILE *sfile; ! 3495: char *sfilename; ! 3496: { ! 3497: ! 3498: /* ! 3499: * if the IP_HDR indicates the SIF is a fragment, process as such; ! 3500: * else, for a regular SIF, just process the first page of a master ! 3501: */ ! 3502: if (strlen(hdr_workbuf) > IP_HDR_MASTERLEN) ! 3503: prc_IF_fragment(sfile, sfilename); ! 3504: else ! 3505: prc_IF_master(sfile, sfilename, 1); ! 3506: } ! 3507: ! 3508: ! 3509: /**************************************************************** ! 3510: * ! 3511: * proc_SIF_token(type, length, file, filename): ! 3512: * proc_SIF_token: process sequenceInsertFile token ! 3513: * ! 3514: ****************************************************************/ ! 3515: ! 3516: proc_SIF_token(type_byte, length, file, filename) ! 3517: ! 3518: FILE *file; ! 3519: long length; ! 3520: int type_byte; ! 3521: char *filename; ! 3522: { ! 3523: int i, retcd; ! 3524: char msg[128], buf[MX_HDR_BUFLEN], open_buf[MX_HDR_BUFLEN]; ! 3525: static char *preserve_msg = ! 3526: " --(Preserving the SIF reference)\n", ! 3527: *remove_msg = ! 3528: " --(Removing the SIF reference)\n"; ! 3529: ! 3530: ! 3531: ++num_sifs; ! 3532: ++tnum_sifs; ! 3533: test_newline(); ! 3534: put_offset_msg_to_prop((in_offset-1), "--SIF: "); ! 3535: ! 3536: if ((length == 0) || (length > MX_HDR_BUFLEN)) ! 3537: { ! 3538: (void)sprintf(msg, ! 3539: "--Warning: sequenceInsertFile token encountered with\n"); ! 3540: pip_error(msg); ! 3541: (void)sprintf(msg, " descriptor length = %d\n", ! 3542: length); ! 3543: pip_error(msg); ! 3544: (void)sprintf(msg, "(ERROR: Descriptor length = %d)\n", length); ! 3545: pip_prop(msg); ! 3546: if (proc_flag[REMOVE_SIFS] == FLAG_ON) ! 3547: { ! 3548: pip_error(remove_msg); ! 3549: ioreadn(length, file, filename); ! 3550: } ! 3551: else ! 3552: { ! 3553: pip_error(preserve_msg); ! 3554: /* ! 3555: * preserve the SIF reference ! 3556: */ ! 3557: copy_preserve_SIF(type_byte, length, file, filename); ! 3558: } ! 3559: } ! 3560: else ! 3561: { ! 3562: iogetn(length, file, filename, buf); ! 3563: (void)strcpy(open_buf, buf); ! 3564: ! 3565: (void)sprintf(msg, " --SIF: %s (nesting depth=%d)\n", ! 3566: buf, sif_indx); ! 3567: pip_error(msg); ! 3568: (void)sprintf(msg, "%s\n", buf); ! 3569: pip_prop(msg); ! 3570: /* ! 3571: * Check for alias ! 3572: */ ! 3573: for (i=0; i < num_aliases; i++) ! 3574: { ! 3575: if (strcmp(buf, alias_ref[i]) == 0) ! 3576: { ! 3577: (void)strcpy(open_buf, alias_act[i]); ! 3578: (void)sprintf(msg, " --Alias: %s=%s\n", ! 3579: buf, open_buf); ! 3580: pip_error(msg); ! 3581: indent((off_indent + cur_indent + 8), propfile); ! 3582: (void)sprintf(msg,"--Alias: %s=%s\n", buf, open_buf); ! 3583: pip_prop(msg); ! 3584: break; ! 3585: } ! 3586: } ! 3587: ! 3588: if (proc_flag[SATISFY_SIFS] == FLAG_OFF) ! 3589: { ! 3590: if (proc_flag[REMOVE_SIFS] == FLAG_ON) ! 3591: pip_error(remove_msg); ! 3592: else ! 3593: { ! 3594: pip_error( ! 3595: " -s switch (Satisfy SIFS option) not specified\n"); ! 3596: pip_error(preserve_msg); ! 3597: put_preserve_SIF(type_byte, length, buf); ! 3598: } ! 3599: } ! 3600: else ! 3601: if (sif_indx >= MX_SIF_DEPTH) ! 3602: { ! 3603: (void)sprintf(msg, ! 3604: "*** warning: maximum SIF nesting depth allowed in IPFE=%d\n", ! 3605: MX_SIF_DEPTH); ! 3606: pip_error(msg); ! 3607: if (proc_flag[REMOVE_SIFS] == FLAG_ON) ! 3608: pip_error(remove_msg); ! 3609: else ! 3610: { ! 3611: pip_error(preserve_msg); ! 3612: /* ! 3613: * preserve the SIF reference ! 3614: */ ! 3615: put_preserve_SIF(type_byte, length, buf); ! 3616: } ! 3617: } ! 3618: else ! 3619: { ! 3620: sif_file[sif_indx] = fopen(open_buf, "r"); ! 3621: if (sif_file[sif_indx] == NULL) ! 3622: { ! 3623: pip_error(" "); ! 3624: (void)sprintf(msg, "--Error opening SIF file: %s\n", ! 3625: open_buf); ! 3626: pip_error(msg); ! 3627: indent((off_indent + cur_indent + 8), propfile); ! 3628: pip_prop(msg); ! 3629: if (proc_flag[REMOVE_SIFS] == FLAG_ON) ! 3630: pip_error(remove_msg); ! 3631: else ! 3632: { ! 3633: pip_error(preserve_msg); ! 3634: /* ! 3635: * preserve the SIF reference ! 3636: */ ! 3637: put_preserve_SIF(type_byte, length, buf); ! 3638: } ! 3639: } ! 3640: else ! 3641: { ! 3642: /* ! 3643: * check the validity of the SIF hdr ! 3644: */ ! 3645: retcd = get_ip_hdr(sif_file[sif_indx], open_buf); ! 3646: if (retcd == ERROR) ! 3647: { ! 3648: if (proc_flag[REMOVE_SIFS] == FLAG_ON) ! 3649: pip_error(remove_msg); ! 3650: else ! 3651: { ! 3652: pip_error(preserve_msg); ! 3653: /* ! 3654: * preserve the SIF reference ! 3655: */ ! 3656: put_preserve_SIF(type_byte, length, buf); ! 3657: } ! 3658: } ! 3659: else ! 3660: { ! 3661: (void)strcpy(sif_name[sif_indx], open_buf); ! 3662: sifname = sif_name[sif_indx]; ! 3663: siffile = sif_file[sif_indx]; ! 3664: ! 3665: pip_error( ! 3666: " -- Processing SIF content --\n"); ! 3667: ! 3668: ++sif_indx; ! 3669: prc_SIF_file(siffile, sifname); ! 3670: --sif_indx; ! 3671: } ! 3672: (void)fclose(sif_file[sif_indx]); ! 3673: } ! 3674: } ! 3675: } ! 3676: ! 3677: } ! 3678: ! 3679: ! 3680: /**************************************************************** ! 3681: * ! 3682: * put_Integer(val): ! 3683: * put_Integer: if ((val > INTEGER_MAX) || ! 3684: * (val < INTEGER_MIN)) ! 3685: * put val out as seqInteger ! 3686: * else ! 3687: * put val out as Short Number ! 3688: * token (biased by 4000 (0xfa0)) ! 3689: * ! 3690: ****************************************************************/ ! 3691: ! 3692: put_Integer(val) ! 3693: ! 3694: long val; ! 3695: { ! 3696: int len; ! 3697: ! 3698: ! 3699: if ((val < INTEGER_MIN) || (val > INTEGER_MAX)) ! 3700: { ! 3701: len = count_int_bytes(val); ! 3702: put_seq_type_len(sequenceInteger, (long)len); ! 3703: put_intn(val, len); ! 3704: } ! 3705: else ! 3706: { ! 3707: val = val + INTEGER_ZERO; /* add bias */ ! 3708: ip_putc((char)((val >> 8) & 0x7f)); ! 3709: ip_putc((char)val); ! 3710: } ! 3711: ! 3712: } ! 3713: ! 3714: ! 3715: /**************************************************************** ! 3716: * ! 3717: * put_intn(val, len): ! 3718: * put_intn: put specified val out as len bytes ! 3719: * ! 3720: ****************************************************************/ ! 3721: ! 3722: put_intn(val, len) ! 3723: ! 3724: long val; ! 3725: int len; /* measured in bytes */ ! 3726: { ! 3727: int i; ! 3728: ! 3729: ! 3730: if (len > 0) ! 3731: { ! 3732: --len; ! 3733: for (i=len*8; i >= 0; i=i-8) ! 3734: ip_putc((char)(val >> i)); ! 3735: } ! 3736: ! 3737: } ! 3738: ! 3739: ! 3740: /**************************************************************** ! 3741: * ! 3742: * put_offset_msg_to_prop(off, msg): ! 3743: * put_offset_msg_to_prop: put specified in_offset (formatted) ! 3744: * + <: > + <cur_indent> + msg ! 3745: * to propfile ! 3746: * ! 3747: ****************************************************************/ ! 3748: ! 3749: put_offset_msg_to_prop(off, msg) ! 3750: ! 3751: long off; ! 3752: char *msg; ! 3753: { ! 3754: ! 3755: if (cur_col == 0) ! 3756: { ! 3757: if (proc_flag[DEBUG] == FLAG_ON) ! 3758: put_offp_to_prop(off); ! 3759: indent(cur_indent, propfile); ! 3760: } ! 3761: pip_prop(msg); ! 3762: ! 3763: } ! 3764: ! 3765: ! 3766: /**************************************************************** ! 3767: * ! 3768: * put_off_to_prop(off, format_flag): ! 3769: * put_off_to_prop: put specified in_offset (formatted) ! 3770: * to propfile ! 3771: * ! 3772: ****************************************************************/ ! 3773: ! 3774: put_off_to_prop(off, format_flag) ! 3775: ! 3776: long off; ! 3777: int format_flag; ! 3778: { ! 3779: int i, procflag; ! 3780: char digit; ! 3781: ! 3782: ! 3783: if (propfile != NULL) ! 3784: { ! 3785: procflag = FLAG_OFF; ! 3786: for (i=20; i >= 0; i=i-4) ! 3787: { ! 3788: digit = (off >> i) & 0x0f; ! 3789: if ((digit == 0) && (procflag == FLAG_OFF) && (i > 4)) ! 3790: { ! 3791: if (format_flag == FORMAT) ! 3792: mputc_prop(SPC); ! 3793: } ! 3794: else ! 3795: { ! 3796: if (digit > 9) ! 3797: digit = digit + 7; ! 3798: mputc_prop(digit + 0x30); ! 3799: procflag = FLAG_ON; ! 3800: } ! 3801: if ((i == 16) && ! 3802: ((format_flag == FORMAT) || (procflag == FLAG_ON))) ! 3803: mputc_prop(SPC); ! 3804: } ! 3805: } ! 3806: ! 3807: } ! 3808: ! 3809: ! 3810: /**************************************************************** ! 3811: * ! 3812: * put_offp_to_prop(off): ! 3813: * put_offp_to_prop: put specified in_offset (formatted ! 3814: * plus "+ " or ": " to propfile ! 3815: * ! 3816: ****************************************************************/ ! 3817: ! 3818: put_offp_to_prop(off) ! 3819: ! 3820: long off; ! 3821: { ! 3822: put_off_to_prop(off, FORMAT); ! 3823: if (off > 0xffffff) ! 3824: pip_prop("+ "); ! 3825: else ! 3826: pip_prop(": "); ! 3827: ! 3828: } ! 3829: ! 3830: ! 3831: /**************************************************************** ! 3832: * ! 3833: * put_op(op): ! 3834: * put_op: put specified op to output ! 3835: * ! 3836: ****************************************************************/ ! 3837: ! 3838: put_op(op) ! 3839: ! 3840: int op; ! 3841: { ! 3842: if (op <= SHORT_OP_LIMIT) ! 3843: ip_putc(op | SHORT_OP); ! 3844: else ! 3845: { ! 3846: ip_putc((op >> 8) | LONG_OP); ! 3847: ip_putc(op); ! 3848: } ! 3849: } ! 3850: ! 3851: ! 3852: /**************************************************************** ! 3853: * ! 3854: * put_opname_to_prop(op): ! 3855: * put_opname_to_prop: put specified op_name to propfile ! 3856: * ! 3857: ****************************************************************/ ! 3858: ! 3859: put_opname_to_prop(op) ! 3860: ! 3861: int op; ! 3862: { ! 3863: char msg[128]; ! 3864: ! 3865: ! 3866: if (op != OP_endBody) ! 3867: test_begBody(); ! 3868: begBody_flag = FLAG_OFF; /* reset because we're ALWAYS putting ! 3869: SOMETHING to propfile here */ ! 3870: ! 3871: switch ! 3872: (op) ! 3873: { ! 3874: case (OP_beginBlock): ! 3875: test_newline(); ! 3876: (void)sprintf(msg, "%s\n", op_name(op)); ! 3877: put_offset_msg_to_prop((in_offset-2), msg); ! 3878: cur_indent = cur_indent + INDENT_INCR; ! 3879: break; ! 3880: case (OP_endBlock): ! 3881: cur_indent = cur_indent - INDENT_INCR; ! 3882: test_newline(); ! 3883: put_offset_msg_to_prop((in_offset-2), op_name(op)); ! 3884: if (proc_flag[DEBUG] == FLAG_ON) ! 3885: { ! 3886: indent((INDENT_INCR - 1), propfile); ! 3887: mputc_prop('('); ! 3888: put_off_to_prop((in_offset-1), DONT_FORMAT); ! 3889: mputc_prop(')'); ! 3890: } ! 3891: mputc_prop('\n'); ! 3892: break; ! 3893: case (OP_beginBody): ! 3894: put_offset_msg_to_prop((in_offset-2), op_name(op)); ! 3895: indent((INDENT_INCR - 1), propfile); ! 3896: if ((proc_flag[PROPERTIES] == FLAG_ON) && (prop_level > 0)) ! 3897: { ! 3898: if ((preamble_expected == FLAG_OFF) && ! 3899: (endpreamble_expected == FLAG_OFF) && ! 3900: (bop_flag == FLAG_OFF)) ! 3901: { /* we have a righteous pageBody */ ! 3902: (void)sprintf(msg, "Pg%d", (tnum_pages + 1)); ! 3903: pip_prop(msg); ! 3904: indent((INDENT_INCR - 1), propfile); ! 3905: } ! 3906: } ! 3907: cur_indent = cur_indent + INDENT_INCR; ! 3908: break; ! 3909: case (OP_endBody): ! 3910: cur_indent = cur_indent - INDENT_INCR; ! 3911: if (cur_col == 0) ! 3912: indent((cur_indent + off_indent), propfile); ! 3913: pip_prop(op_name(op)); ! 3914: if ((proc_flag[PROPERTIES] == FLAG_ON) && (prop_level > 0)) ! 3915: { ! 3916: if ((endpreamble_expected == FLAG_OFF) && ! 3917: (bop_flag == FLAG_OFF)) ! 3918: { /* we have a righteous endBody */ ! 3919: indent((INDENT_INCR - 1), propfile); ! 3920: (void)sprintf(msg, "endPg%d", tnum_pages); ! 3921: pip_prop(msg); ! 3922: } ! 3923: } ! 3924: if (proc_flag[DEBUG] == FLAG_ON) ! 3925: { ! 3926: indent((INDENT_INCR - 1), propfile); ! 3927: mputc_prop('('); ! 3928: put_off_to_prop((in_offset-1), DONT_FORMAT); ! 3929: mputc_prop(')'); ! 3930: } ! 3931: if (debug_flag == FLAG_ON) ! 3932: { ! 3933: indent((INDENT_INCR - 1), propfile); ! 3934: (void)sprintf(msg,"[%d %d %d %d]", ! 3935: bop_indx, ! 3936: bop_iindx[bop_indx], ! 3937: bop_iindx[0], ! 3938: endpreamble_expected); ! 3939: pip_prop(msg); ! 3940: } ! 3941: mputc_prop('\n'); ! 3942: break; ! 3943: case (OP_makesimpleco): ! 3944: case (OP_dosavesimplebody): ! 3945: case (OP_if): ! 3946: case (OP_ifelse): ! 3947: case (OP_ifcopy): ! 3948: put_offset_msg_to_prop((in_offset-2), op_name(op)); ! 3949: mputc_prop('\n'); ! 3950: break; ! 3951: case (OP_correct): ! 3952: /* ! 3953: * don't do all those nasty CORRECT's unless the user forces us to ! 3954: */ ! 3955: if (prop_level > 1) ! 3956: { ! 3957: put_offset_msg_to_prop((in_offset-2), op_name(op)); ! 3958: mputc_prop('\n'); ! 3959: } ! 3960: break; ! 3961: default: ! 3962: break; ! 3963: } ! 3964: } ! 3965: ! 3966: ! 3967: /**************************************************************** ! 3968: * ! 3969: * put_seqRational(num, den): ! 3970: * put_seqRational: put specified numerator & denominator ! 3971: * out as a sequenceRational ! 3972: * ! 3973: ****************************************************************/ ! 3974: ! 3975: put_seqRational(num, den) ! 3976: ! 3977: long num, den; ! 3978: { ! 3979: int len, num_len, den_len; ! 3980: ! 3981: ! 3982: num_len = count_int_bytes(num); ! 3983: den_len = count_int_bytes(den); ! 3984: if (num_len > den_len) ! 3985: len = num_len; ! 3986: else ! 3987: len = den_len; ! 3988: put_seq_type_len(sequenceRational, (long)(len * 2)); ! 3989: put_intn(num, len); ! 3990: put_intn(den, len); ! 3991: ! 3992: } ! 3993: ! 3994: ! 3995: /**************************************************************** ! 3996: * ! 3997: * put_seq_type_len(type_byte, length): ! 3998: * put_seq_type_len: put specified type_byte & length ! 3999: * to output ! 4000: * ! 4001: ****************************************************************/ ! 4002: ! 4003: put_seq_type_len(type_byte, length) ! 4004: ! 4005: long length; ! 4006: int type_byte; ! 4007: { ! 4008: if (length > SHORT_SEQUENCE_LIMIT) ! 4009: { ! 4010: ip_putc((char)(LONG_SEQUENCE | (type_byte & 0x1f))); ! 4011: ip_putc((char)(length >> 16)); ! 4012: ip_putc((char)(length >> 8)); ! 4013: ip_putc((char)length); ! 4014: } ! 4015: else ! 4016: { ! 4017: ip_putc((char)(SHORT_SEQUENCE | (type_byte & 0x1f))); ! 4018: ip_putc((char)length); ! 4019: } ! 4020: ! 4021: } ! 4022: ! 4023: ! 4024: /**************************************************************** ! 4025: * ! 4026: * test_begBody: if beBody flag is set, ! 4027: * put a newline to propfile ! 4028: * ! 4029: ****************************************************************/ ! 4030: ! 4031: test_begBody() ! 4032: { ! 4033: if (begBody_flag == FLAG_ON) ! 4034: { ! 4035: mputc_prop('\n'); ! 4036: begBody_flag = FLAG_OFF; ! 4037: } ! 4038: } ! 4039: ! 4040: ! 4041: ! 4042: /**************************************************************** ! 4043: * ! 4044: * test_newline: if cur_col != 0, ! 4045: * put a newline to propfile ! 4046: * ! 4047: ****************************************************************/ ! 4048: ! 4049: test_newline() ! 4050: { ! 4051: if (cur_col != 0) ! 4052: mputc_prop('\n'); ! 4053: ! 4054: } ! 4055: ! 4056: ! 4057: /**************************************************************** ! 4058: * ! 4059: * usage: dsply the cmd_line interface ! 4060: * ! 4061: ****************************************************************/ ! 4062: ! 4063: Usage() ! 4064: { ! 4065: fprintf(STDERR, ! 4066: "Usage:\n"); ! 4067: fprintf(STDERR, ! 4068: " ipfe [ options ] file [pagerange ... [file [pagerange]...]\n"); ! 4069: fprintf(STDERR, ! 4070: "Options:\n"); ! 4071: fprintf(STDERR, ! 4072: " [-l logfile] [-dDiLqrRs] [-a alias:actual [-a alias:actual]\n"); ! 4073: fprintf(STDERR, ! 4074: " ...] [-b offset:unit] [-c count:unit] [-o outfile]\n"); ! 4075: fprintf(STDERR, ! 4076: " [-p level:propfile] [-S factor] [-X offset:unit]\n"); ! 4077: fprintf(STDERR, ! 4078: " [-Y offset:unit]\n\n"); ! 4079: ! 4080: fprintf(STDERR, ! 4081: " -a alias:actual (alias). If the -s option is specified,\n"); ! 4082: fprintf(STDERR, ! 4083: " replace any SIF matching the string \"alias\"\n"); ! 4084: fprintf(STDERR, ! 4085: " with the string \"actual\" before attempting\n"); ! 4086: fprintf(STDERR, ! 4087: " to satisfy the SIF. If \"actual\" cannot be\n"); ! 4088: fprintf(STDERR, ! 4089: " opened or there is some error, the SIF\n"); ! 4090: fprintf(STDERR, ! 4091: " \"alias\" is preserved, unless the -r option\n"); ! 4092: fprintf(STDERR, ! 4093: " is also specified.\n"); ! 4094: fprintf(STDERR, ! 4095: " -b offset:unit (binding offset). Shift the image offset units\n"); ! 4096: fprintf(STDERR, ! 4097: " in the x-direction, where unit may be: none\n"); ! 4098: fprintf(STDERR, ! 4099: " (default centimeters), c (centimeters), i\n"); ! 4100: fprintf(STDERR, ! 4101: " (inches), p (points), P (Picas). If the -L\n"); ! 4102: fprintf(STDERR, ! 4103: " (Landscape) switch is set, the image shift\n"); ! 4104: fprintf(STDERR, ! 4105: " is in the y-direction.\n"); ! 4106: fprintf(STDERR, ! 4107: " -c count:unit (chapterize) every count units, where unit\n"); ! 4108: fprintf(STDERR, ! 4109: " be: p (pages), k (kilobytes), m (megabytes).\n"); ! 4110: fprintf(STDERR, ! 4111: " -d (duplex). For resolving binding offset.\n"); ! 4112: fprintf(STDERR, ! 4113: " -D (debug). If the -p option is specified, also\n"); ! 4114: fprintf(STDERR, ! 4115: " write to the properties file the offsets of\n"); ! 4116: fprintf(STDERR, ! 4117: " each skeleton-level token encountered.\n"); ! 4118: fprintf(STDERR, ! 4119: " -i (insert SIF for overlay). Insert (create) a\n"); ! 4120: fprintf(STDERR, ! 4121: " SIF for any unresolvable overlays.\n"); ! 4122: fprintf(STDERR, ! 4123: " -l logfile (log). Keep a running log.\n"); ! 4124: fprintf(STDERR, ! 4125: " -L (Landscape). Rotate every page 90 degrees\n"); ! 4126: fprintf(STDERR, ! 4127: " counterclockwise and preserve the upper left\n"); ! 4128: fprintf(STDERR, ! 4129: " corner. Intended for printing text in\n"); ! 4130: fprintf(STDERR, ! 4131: " landscape orientation.\n"); ! 4132: fprintf(STDERR, ! 4133: " -o outfile (output). Where the output goes. If there is\n"); ! 4134: fprintf(STDERR, ! 4135: " no -o and there is a -p, only the properties\n"); ! 4136: fprintf(STDERR, ! 4137: " are written, else if there is no -o,\n"); ! 4138: fprintf(STDERR, ! 4139: " \"infile.ip\" is used if it doesn't already\n"); ! 4140: fprintf(STDERR, ! 4141: " exist, else \"infileN.ip\" is used, where N\n"); ! 4142: fprintf(STDERR, ! 4143: " is the lowest integer such that \"infileN.ip\"\n"); ! 4144: fprintf(STDERR, ! 4145: " does not already exist.\n"); ! 4146: fprintf(STDERR, ! 4147: " -p level:propfile\n"); ! 4148: fprintf(STDERR, ! 4149: " (properties). Where the properties are\n"); ! 4150: fprintf(STDERR, ! 4151: " written. Increasing levels provide increasing\n"); ! 4152: fprintf(STDERR, ! 4153: " information details.\n"); ! 4154: fprintf(STDERR, ! 4155: " -q (quiet). Don't write info and error msgs (to\n"); ! 4156: fprintf(STDERR, ! 4157: " STDERR).\n"); ! 4158: fprintf(STDERR, ! 4159: " -r (remove SIFS). If -s is also specified, it\n"); ! 4160: fprintf(STDERR, ! 4161: " takes precedence and a SIF reference is\n"); ! 4162: fprintf(STDERR, ! 4163: " removed only if it is unresolved or there is\n"); ! 4164: fprintf(STDERR, ! 4165: " some other error.\n"); ! 4166: fprintf(STDERR, ! 4167: " -R (Rotate). Rotate every page 90 degrees\n"); ! 4168: fprintf(STDERR, ! 4169: " clockwise and preserve the center point.\n"); ! 4170: fprintf(STDERR, ! 4171: " Intended for rotating an image created for a\n"); ! 4172: fprintf(STDERR, ! 4173: " \"landscape printer\" to print in portrait\n"); ! 4174: fprintf(STDERR, ! 4175: " orientation.\n"); ! 4176: fprintf(STDERR, ! 4177: " -s (satisfy SIFS). Replace any SIF reference\n"); ! 4178: fprintf(STDERR, ! 4179: " with the tokens found in the referenced file.\n"); ! 4180: fprintf(STDERR, ! 4181: " If the referenced file cannot be opened, the\n"); ! 4182: fprintf(STDERR, ! 4183: " SIF reference is preserved unless -r is also\n"); ! 4184: fprintf(STDERR, ! 4185: " specified.\n"); ! 4186: fprintf(STDERR, ! 4187: " -S factor (scale). Scale the image by factor.\n"); ! 4188: fprintf(STDERR, ! 4189: " -X offset:unit (X-imageShift). Shift the image offset units\n"); ! 4190: fprintf(STDERR, ! 4191: " in the x-direction, where unit may be: none\n"); ! 4192: fprintf(STDERR, ! 4193: " (default centimeters), c (centimeters), i\n"); ! 4194: fprintf(STDERR, ! 4195: " (inches), p (points), P (Picas). The shift\n"); ! 4196: fprintf(STDERR, ! 4197: " is independent of the -L and -R switches\n"); ! 4198: fprintf(STDERR, ! 4199: " (i.e., the x-direction is the same as the\n"); ! 4200: fprintf(STDERR, ! 4201: " unrotated image).\n"); ! 4202: fprintf(STDERR, ! 4203: " -Y offset:unit (Y-imageShift). Shift the image offset units\n"); ! 4204: fprintf(STDERR, ! 4205: " in the y-direction, where unit may be: none\n"); ! 4206: fprintf(STDERR, ! 4207: " (default centimeters), c (centimeters), i\n"); ! 4208: fprintf(STDERR, ! 4209: " (inches), p (points), P (Picas). The shift\n"); ! 4210: fprintf(STDERR, ! 4211: " is independent of the -L and -R switches\n"); ! 4212: fprintf(STDERR, ! 4213: " (i.e., the y-direction is the same as the\n"); ! 4214: fprintf(STDERR, ! 4215: " unrotated image).\n"); ! 4216: fprintf(STDERR, ! 4217: " infile [pagerange]\n"); ! 4218: fprintf(STDERR, ! 4219: " See the manual page for syntax details.\n"); ! 4220: fprintf(STDERR, ! 4221: " Example:\n"); ! 4222: fprintf(STDERR, ! 4223: " [1,4-6,9[pic1],10-11,12[pic2:2(2P,4P)][pic3(-4P,-2P)],15-]\n\n"); ! 4224: ! 4225: exit(1); ! 4226: } ! 4227: ! 4228: /*** end of file = IPFE.C *************************************/
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.