![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to parse.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 / ipmetrics|
Return to parse.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / dipress / src / bin / ipmetrics |
1.1 root 1: /* parse.c
2: *
3: * Copyright (c) 1984, 1985 Xerox Corp.
4: *
5: * Items are left on the stack when execution finishes.
6: *
7: * pop() can be used to remove items from the stack.
8: * Please remember to free() any item you pop off the stack.
9: *
10: *
11: * HISTORY
12: *
13: * K. Knox, 28-Mar-85 18:26:50, Created first version.
14: *
15: */
16:
17: #include <stdio.h>
18: #include <iptokens.h>
19:
20: FILE *fp;
21: long filepos = 0;
22:
23:
24: #define len_IP_header 40
25:
26: #define token_id 0340
27: #define token_mask 0037
28: #define token_short_op 0200
29: #define token_long_op 0240
30: #define token_short_seq 0300
31: #define token_long_seq 0340
32:
33: parse(fpin)
34: FILE *fpin;
35: {
36: /* variables */
37: int c, len;
38: char string[len_IP_header+1],
39: *ptr;
40: int last = 0;
41: int seq,
42: hlen;
43:
44: fp = fpin;
45:
46: /* get the header */
47: for (hlen = 0, ptr = string; hlen < len_IP_header; hlen++)
48: if ( (*ptr++ = getc(fp)) == ' ' )
49: break;
50:
51: *ptr = '\0';
52:
53: header(string);
54:
55: /* Analyze every token in the file. */
56: while ((c = getc(fp)) != EOF)
57: {
58: filepos = ftell(fp)-1;
59: switch (c & token_id)
60: {
61: case token_short_op: /* Only allowed short op is "nop". */
62: len = c & token_mask;
63: (void) operator(len);
64: last = 0;
65: break;
66: case token_long_op:
67: len = getc(fp)+((c & token_mask) << 8);
68: if (operator(len)) return; /* Quit when you hit endBlock. */
69: last = 0;
70: break;
71: case token_short_seq:
72: len = getc(fp);
73: seq = c & token_mask;
74: sequence(seq, len, last);
75: if (seq != sequenceContinued) last = seq;
76: break;
77: case token_long_seq:
78: len = getc(fp) << 16;
79: len = len+(getc(fp) << 8);
80: len = len+getc(fp);
81: seq = c & token_mask;
82: sequence(seq, len, last);
83: if (seq != sequenceContinued) last = seq;
84: break;
85: default:
86: shortnum((c << 8)+getc(fp)-INTEGER_ZERO);
87: last = 0;
88: break;
89: }
90: }
91: /* Shouldn't get here if file ends properly! */
92: fprintf(stderr, "(%d) Unexpected EOF\n", filepos);
93: exit(2);
94: }
95:
96:
97: #ifndef debug
98: operator(op)
99: int op;
100: {
101: switch (op)
102: {
103: case OP_makevec: op_makevec(); break;
104: case OP_makeveclu: op_makeveclu(); break;
105: case OP_rotate: op_rotate(); break;
106: case OP_scale: op_scale(); break;
107: case OP_scale2: op_scale2(); break;
108: case OP_concat: op_concat(); break;
109: case OP_beginBlock: op_beginblock(); break;
110: case OP_endBlock: op_endblock(); return(1);
111: case OP_beginBody: op_beginbody(); break;
112: case OP_endBody: op_endbody(); break;
113: default: op_unknown(op); break;
114: }
115: return (0);
116: }
117:
118: sequence(type, len, last)
119: int type, len, last;
120: {
121: switch (type)
122: {
123: case sequenceComment: seq_comment(len); break;
124: case sequenceIdentifier: seq_identifier(len); break;
125: case sequenceInteger: seq_integer(len); break;
126: case sequenceLargeVector: seq_largevector(len); break;
127: case sequenceRational: seq_rational(len); break;
128: case sequenceString: seq_string(len); break;
129: default: seq_unknown(type, len); break;
130: }
131: }
132:
133: #else
134: operator(op)
135: int op;
136: {
137: switch (op)
138: {
139: case OP_makevec:
140: fprintf(stderr, "op_makevec\n");
141: op_makevec();
142: break;
143: case OP_do:
144: fprintf(stderr, "op_do\n");
145: op_do();
146: break;
147: case OP_pop:
148: fprintf(stderr, "op_pop\n");
149: op_pop();
150: break;
151: case OP_copy:
152: fprintf(stderr, "op_copy\n");
153: op_copy();
154: break;
155: case OP_dup:
156: fprintf(stderr, "op_dup\n");
157: op_dup();
158: break;
159: case OP_roll:
160: fprintf(stderr, "op_roll\n");
161: op_roll();
162: break;
163: case OP_exch:
164: fprintf(stderr, "op_exch\n");
165: op_exch();
166: break;
167: case OP_nop:
168: fprintf(stderr, "op_nop\n");
169: op_nop();
170: break;
171: case OP_translate:
172: fprintf(stderr, "op_translate\n");
173: op_translate();
174: break;
175: case OP_rotate:
176: fprintf(stderr, "op_rotate\n");
177: op_rotate();
178: break;
179: case OP_scale:
180: fprintf(stderr, "op_scale\n");
181: op_scale();
182: break;
183: case OP_scale2:
184: fprintf(stderr, "op_scale2\n");
185: op_scale2();
186: break;
187: case OP_concat:
188: fprintf(stderr, "op_concat\n");
189: op_concat();
190: break;
191: case OP_makepixelarray:
192: fprintf(stderr, "op_makepixelarray\n");
193: op_makepixelarray();
194: break;
195: case OP_extractpixelarray:
196: fprintf(stderr, "op_extractpixelarray\n");
197: op_extractpixelarray();
198: break;
199: case OP_finddecompressor:
200: fprintf(stderr, "op_finddecompressor\n");
201: op_finddecompressor();
202: break;
203: case OP_makegray:
204: fprintf(stderr, "op_makegray\n");
205: op_makegray();
206: break;
207: case OP_findcolor:
208: fprintf(stderr, "op_findcolor\n");
209: op_findcolor();
210: break;
211: case OP_findcoloroperator:
212: fprintf(stderr, "op_findcoloroperator\n");
213: op_findcoloroperator();
214: break;
215: case OP_findcolormodeloperator:
216: fprintf(stderr, "op_findcolormodeloperator\n");
217: op_findcolormodeloperator();
218: break;
219: case OP_beginBlock:
220: fprintf(stderr, "op_beginblock\n");
221: op_beginblock();
222: break;
223: case OP_endBlock:
224: fprintf(stderr, "op_endblock\n");
225: op_endblock();
226: return(1);
227: case OP_beginBody: ; break;
228: case OP_endBody: ; break;
229: default:
230: fprintf(stderr, "op_unknown\n");
231: op_unknown(op);
232: break;
233: }
234: return (0);
235: }
236:
237: sequence(type, len, last)
238: int type, len, last;
239: {
240: switch (type)
241: {
242: case sequenceAdaptivePixelVector:
243: fprintf(stderr, "seq_adaptivepixel\n");
244: seq_adaptivepixel(len);
245: break;
246: case sequenceComment:
247: fprintf(stderr, "seq_comment\n");
248: seq_comment(len);
249: break;
250: case sequenceCompressedPixelVector:
251: fprintf(stderr, "seq_compressedpixel\n");
252: seq_compressedpixel(len);
253: break;
254: case sequenceContinued:
255: fprintf(stderr, "seq_continued\n");
256: break;
257: case sequenceIdentifier:
258: fprintf(stderr, "seq_identifier\n");
259: seq_identifier(len);
260: break;
261: case sequenceInsertFile:
262: fprintf(stderr, "seq_insertfile\n");
263: seq_insertfile(len);
264: break;
265: case sequenceInteger:
266: fprintf(stderr, "seq_integer\n");
267: seq_integer(len);
268: break;
269: case sequenceLargeVector:
270: fprintf(stderr, "seq_largevector\n");
271: seq_largevector(len);
272: break;
273: case sequencePackedPixelVector:
274: fprintf(stderr, "seq_packedpixel\n");
275: seq_packedpixel(len);
276: break;
277: case sequenceRational:
278: fprintf(stderr, "seq_rational\n");
279: seq_rational(len);
280: break;
281: case sequenceString:
282: fprintf(stderr, "seq_string\n");
283: seq_string(len);
284: break;
285: default:
286: fprintf(stderr, "seq_unknown\n");
287: seq_unknown(type, len);
288: break;
289: }
290: }
291:
292: #endif
293:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.