![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iptotext.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 / iptotext|
Return to iptotext.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / dipress / src / bin / iptotext |
1.1 root 1: /*
2: * Interpress utility
3: *
4: * Written for Xerox Corporation by William LeFebvre
5: *
6: * 7-June-1984
7: *
8: * Copyright (c) 1984, 1985, 1986 Xerox Corp.
9: *
10: * HISTORY
11: * 20-Mar-86 Lee Moore (lee) at Xerox Webster Research Center
12: * Changed the output comment for sequencePackedPixel to print out the
13: * number of bits per sample and the number of samples per scan line.
14: *
15: * 13-Jan-86 lee at Xerox, WRC
16: * Changed a call to strmpn to strncmp.
17: *
18: * 01-Dec-85 lee at Xerox, WRC
19: * Linted
20: *
21: * 11-oct-85 ed flint
22: * don't worry about version # in Interpress header
23: * look only for 'Interpress/Xerox/'
24: *
25: * 23-may-85 ed flint
26: * fixed bug in print_string_from_file & print_string
27: * that would strip off high byte of ch in isprint
28: *
29: * 8-apr-85 ed flint
30: * add -d option to dump pixel arrays
31: * conditional compilation for vax-11c (vms)
32: */
33:
34: /*
35: * iptotext - convert an encoded interpress file into readable text
36: */
37:
38: #ifdef vax11c
39: # include stdio
40: # include setjmp
41: # include ctype
42: # include "iptokens.h"
43: # include "ipnames.h"
44: #else
45: # include <stdio.h>
46: # include <setjmp.h>
47: # include <ctype.h>
48: # include "iptokens.h"
49: # include "ipnames.h"
50: #endif
51:
52: int hlen;
53: jmp_buf next_file;
54: FILE *file;
55: FILE *output;
56:
57: int errno; /* imported value */
58:
59: char *op_name();
60: int dump_pixel= 0;
61:
62: main(argc, argv)
63:
64: int argc;
65: char *argv[];
66:
67: {
68: int arg;
69: int temp;
70: char *outputname;
71:
72: hlen = strlen(IP_Header);
73:
74: outputname= 0;
75:
76: /* look for options */
77: for ( arg= 1; arg < argc; arg++ )
78: {
79: if ( argv[arg][0] == '-' )
80: {
81: switch(argv[arg][1])
82: {
83: case('o'):
84: case('O'):
85: if ( strlen(argv[arg]) > 2 )
86: outputname= &(argv[arg][2]);
87: else
88: outputname= argv[++arg];
89: break;
90:
91: case('d'):
92: case('D'):
93: dump_pixel= 1;
94: break;
95:
96: default:
97: fprintf(stderr,"invalid option %s\n",argv[arg]);
98: break;
99: }
100: }
101: else
102: {
103: break;
104: }
105: }
106:
107: /* open the output file */
108: if ( outputname != 0 )
109: {
110: if ((output = fopen(outputname, "w")) == NULL)
111: {
112: /* save errno value */
113: temp = errno;
114: fputs("iptotext: ", stderr);
115: errno = temp;
116: perror(outputname);
117: exit(1);
118: }
119: }
120: else
121: {
122: /* default output -- use stdout */
123: output = stdout;
124: }
125:
126: if (argc == 1)
127: {
128: file = stdin;
129: do_file();
130: (void) putc('\n', output);
131: }
132:
133: /* make the begin- and end-block names be upper case */
134: op_names[OP_beginBlock] = "BEGIN";
135: op_names[OP_endBlock] = "END";
136:
137: for ( ; arg < argc; arg++) /* assume arg is index of first file name */
138: {
139: if ((file = fopen(argv[arg], "r")) == NULL)
140: {
141: perror(argv[arg]);
142: continue; /* on to the next file */
143: }
144:
145: /* print pretty banner */
146: fprintf(output, "(File: \"%s\")\n", argv[arg]);
147:
148: do_file();
149: (void) fclose(file);
150: (void) putc('\n', output);
151: }
152: }
153:
154: do_file()
155:
156: {
157: # define Buffsize 256
158: unsigned char buff[Buffsize];
159: unsigned char *ptr;
160: int val;
161: int len;
162: int byte; /* has to be "int" for stdio EOF detection */
163: /* stdio is a pile! */
164:
165: /* for error recovery */
166: if (setjmp(next_file) != 0)
167: {
168: return;
169: }
170:
171: /* get the header */
172: for (hlen = 0, ptr = buff; hlen < Buffsize; hlen++)
173: {
174: if ((*ptr++ = getnoeofc(file)) == ' ')
175: break;
176: }
177: *ptr = '\0';
178:
179: /* display the header */
180: fputs("Header: ", output);
181: print_string(buff);
182:
183: /* check the validity of the header */
184: if (strncmp((char *)buff, IP_Header, 17) != 0)
185: {
186: fprintf(output, " (INVALID HEADER!)");
187: }
188: (void) putc('\n', output);
189:
190: /* main loop */
191: while ((byte = getc(file)) != EOF)
192: {
193: if ((byte & 0200) == 0)
194: {
195: /* a short number */
196: val = (byte << 8) + getnoeofc(file) - INTEGER_ZERO;
197: fprintf(output, "%d\n", val);
198: }
199: else
200: {
201: /* something else */
202: switch(byte >> 5)
203: {
204: case (SHORT_OP >> 5):
205: fprintf(output, "%s\n", op_name(byte & 037));
206: break;
207:
208: case (LONG_OP >> 5):
209: val = ((byte & 037) << 8) + getnoeofc(file);
210: fprintf(output, "%s%s\n", op_name(val),
211: val == OP_beginBlock || val == OP_endBlock ?
212: " (block)" : "");
213: break;
214:
215: case (SHORT_SEQUENCE >> 5):
216: len = getnoeofc(file);
217: fputs("> ", output);
218: do_sequence(byte & 037, len);
219: break;
220:
221: case (LONG_SEQUENCE >> 5):
222: len = getnoeofc(file) << 16;
223: len += (getnoeofc(file) << 8);
224: len += getnoeofc(file);
225: fputs(">>", output);
226: do_sequence(byte & 037, len);
227: break;
228: }
229: }
230: }
231: }
232:
233: do_sequence(type, length)
234:
235: int type;
236: int length;
237:
238: {
239: int val;
240: int val2;
241:
242: switch(type)
243: {
244: case sequenceAdaptivePixelVector:
245: fprintf(output, "Adaptive Pixel Vector: (%d words) [\n", length/2);
246: print_words_from_file(file, length);
247: fputs("]\n", file);
248: break;
249:
250: case sequenceComment:
251: fputs("Comment: ", output);
252: print_string_from_file(file, length);
253: (void) putc('\n', output);
254: break;
255:
256: case sequenceCompressedPixelVector:
257: fprintf(output, "Compressed Pixel Vector: (%d words) [\n", length/2);
258: print_words_from_file(file, length);
259: fputs("]\n", file);
260: break;
261:
262: case sequenceContinued:
263: fprintf(output, "Continuing last sequence: ");
264: break;
265:
266: case sequenceIdentifier:
267: fprintf(output, "Identifier: ");
268: iocopy(length);
269: fputs("\n", output);
270: break;
271:
272: case sequenceInsertFile:
273: fputs("Insert file: ", output);
274: print_string_from_file(file, length);
275: (void) putc('\n', output);
276: break;
277:
278: case sequenceInteger:
279: val = getint(length);
280: fprintf(output, "Integer: %d\n", val);
281: (void) putc('\n', output);
282: break;
283:
284: case sequenceLargeVector:
285: #ifdef notdef
286: val = getnoeofc(file);
287: fprintf(output, "Large Pixel Vector: (%d words of %d bytes) [\n"
288: (length - 1) / val, val);
289: #endif
290: break;
291:
292: case sequencePackedPixelVector:
293: val = getint(2);
294: val2 = getint(2);
295: fprintf(output, "Packed Pixel Vector: (%d + 2 = %d words, %d bit(s) per sample, %d sample(s) per scanline) [\n",
296: length/2 -2, length/2, val, val2);
297: print_words_from_file(file, length - 4);
298: fputs("]\n", output);
299: break;
300:
301: case sequenceRational:
302: length >>= 1;
303: val = getint(length);
304: val2 = getint(length);
305: fprintf(output, "Rational: %d/%d ", val, val2);
306: if (val2 != 0)
307: {
308: fprintf(output, "(%f)\n", (float)val / (float)val2);
309: }
310: else
311: {
312: fputs("(???)\n", output);
313: }
314: break;
315:
316: case sequenceString:
317: fputs("String: ", output);
318: print_string_from_file(file, length);
319: (void) putc('\n', output);
320: break;
321: }
322: }
323:
324: iocopy(length)
325:
326: int length;
327:
328: {
329: int byte;
330:
331: while(length-- > 0)
332: {
333: byte = getnoeofc(file);
334: (void) putc(byte, output);
335: }
336: }
337:
338: getint(length)
339:
340: int length;
341:
342: {
343: int val;
344:
345: val = getnoeofc(file);
346:
347: if ((val & 0x80) != 0) {
348: /* this is a negative number -- extend the sign */
349: val |= (-1 & ~(0xFF));
350: }
351:
352: while (--length > 0) {
353: val <<= 8;
354: val |= getnoeofc(file);
355: }
356:
357: return(val);
358: }
359:
360: char *op_name(op_code)
361:
362: int op_code;
363:
364: {
365: static char nbuff[10];
366:
367: if (op_names[op_code] == NULL)
368: {
369: (void) sprintf(nbuff, "--Unknown op: %d--", op_code);
370: return(nbuff);
371: }
372: else
373: {
374: return(op_names[op_code]);
375: }
376: }
377:
378: getnoeofc(file)
379:
380: FILE *file;
381:
382: {
383: int val;
384:
385: #ifdef vax11c
386: val= getc(file);
387: if ( feof(file) )
388: #else
389: if ((val = getc(file)) == EOF)
390: #endif
391: {
392: fprintf(output, "Unexpected EOF!");
393: longjmp(next_file, 1);
394: }
395: return(val);
396: }
397:
398: print_string_from_file(file, length)
399:
400: FILE *file;
401: int length;
402:
403: {
404: register int ch;
405: register int val;
406:
407: (void) putc('"', output);
408: for (val = 0; val < length; val++)
409: {
410: ch = getnoeofc(file);
411: if ( ((ch & 0x80) == 0) && (isprint(ch)) )
412: {
413: if (ch == '"' || ch == '\\')
414: {
415: (void) putc('\\', output);
416: }
417: (void) putc(ch, output);
418: }
419: else
420: {
421: fprintf(output, "\\%03o", ch);
422: }
423: }
424: (void) putc('"', output);
425: }
426:
427: print_string(string)
428:
429: unsigned char *string;
430:
431: {
432: register unsigned char *ptr;
433: register unsigned char ch;
434:
435: (void) putc('"', output);
436: ptr = string;
437: while ((ch = *ptr++) != '\0')
438: {
439: if ( ((ch & 0x80) == 0) && (isprint(ch)) )
440: {
441: if (ch == '"')
442: {
443: (void) putc('\\', output);
444: }
445: (void) putc(ch, output);
446: }
447: else
448: {
449: fprintf(output, "\\%03o", ch);
450: }
451: }
452: (void) putc('"', output);
453: }
454:
455: print_words_from_file(file, length)
456:
457: FILE *file;
458: int length;
459:
460: {
461: int val;
462: int cnt = 0;
463:
464: if ( dump_pixel == 1 )
465: {
466: while (length > 0)
467: {
468: val = getnoeofc(file) << 8;
469: val += getnoeofc(file);
470:
471: fprintf(output, "%04x ", val);
472: if (++cnt > 12)
473: {
474: (void) fputc('\n',output);
475: cnt = 0;
476: }
477:
478: length -= 2;
479: }
480: }
481: else
482: {
483: while ( length > 0 )
484: {
485: val= getnoeofc(file);
486: length--;
487: }
488: }
489: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.