![[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 / stackres|
Return to parse.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / dipress / src / bin / stackres |
1.1 root 1: /* parse.c
2: *
3: * Copyright (c) 1984, 1985 Xerox Corp.
4: *
5: * Eight items are left on the stack when execution finishes.
6: * See the RES manual.
7: *
8: *
9: * pop() can be used to remove items from the stack.
10: * Please remember to free() any item you pop off the stack.
11: *
12: *
13: *
14: */
15:
16: #include <stdio.h>
17: #include <iptokens.h>
18:
19: FILE *fp;
20: long filepos = 0;
21:
22:
23: #define len_RES_header 40
24:
25: #define token_id 0340
26: #define token_mask 0037
27: #define token_short_op 0200
28: #define token_long_op 0240
29: #define token_short_seq 0300
30: #define token_long_seq 0340
31:
32: parse(fpin)
33: FILE *fpin;
34: {
35: /* variables */
36: int c,
37: len;
38: char string[len_RES_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_RES_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: 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_do: op_do(); break;
105: case OP_pop: op_pop(); break;
106: case OP_copy: op_copy(); break;
107: case OP_dup: op_dup(); break;
108: case OP_roll: op_roll(); break;
109: case OP_exch: op_exch(); break;
110: case OP_nop: op_nop(); break;
111: case OP_translate: op_translate(); break;
112: case OP_rotate: op_rotate(); break;
113: case OP_scale: op_scale(); break;
114: case OP_scale2: op_scale2(); break;
115: case OP_concat: op_concat(); break;
116: case OP_makepixelarray: op_makepixelarray(); break;
117: case OP_extractpixelarray: op_extractpixelarray(); break;
118: case OP_finddecompressor: op_finddecompressor(); break;
119: case OP_makegray: op_makegray(); break;
120: case OP_findcolor: op_findcolor(); break;
121: case OP_findcoloroperator: op_findcoloroperator(); break;
122: case OP_findcolormodeloperator: op_findcolormodeloperator(); break;
123: case OP_beginBlock: op_beginblock(); break;
124: case OP_endBlock: op_endblock(); return(1);
125: default: op_unknown(op); break;
126: }
127: return (0);
128: }
129:
130: sequence(type, len, last)
131: int type, len, last;
132: {
133: switch (type)
134: {
135: case sequenceAdaptivePixelVector: seq_adaptivepixel(len); break;
136: case sequenceComment: seq_comment(len); break;
137: case sequenceCompressedPixelVector: seq_compressedpixel(len); break;
138: case sequenceContinued: seq_continued(len, last); break;
139: case sequenceIdentifier: seq_identifier(len); break;
140: case sequenceInsertFile: seq_insertfile(len); break;
141: case sequenceInteger: seq_integer(len); break;
142: case sequenceLargeVector: seq_largevector(len); break;
143: case sequencePackedPixelVector: seq_packedpixel(len); break;
144: case sequenceRational: seq_rational(len); break;
145: case sequenceString: seq_string(len); break;
146: default: seq_unknown(type, len); break;
147: }
148: }
149:
150: #else
151: operator(op)
152: int op;
153: {
154: switch (op)
155: {
156: case OP_makevec:
157: fprintf(stderr, "op_makevec\n");
158: op_makevec();
159: break;
160: case OP_do:
161: fprintf(stderr, "op_do\n");
162: op_do();
163: break;
164: case OP_pop:
165: fprintf(stderr, "op_pop\n");
166: op_pop();
167: break;
168: case OP_copy:
169: fprintf(stderr, "op_copy\n");
170: op_copy();
171: break;
172: case OP_dup:
173: fprintf(stderr, "op_dup\n");
174: op_dup();
175: break;
176: case OP_roll:
177: fprintf(stderr, "op_roll\n");
178: op_roll();
179: break;
180: case OP_exch:
181: fprintf(stderr, "op_exch\n");
182: op_exch();
183: break;
184: case OP_nop:
185: fprintf(stderr, "op_nop\n");
186: op_nop();
187: break;
188: case OP_translate:
189: fprintf(stderr, "op_translate\n");
190: op_translate();
191: break;
192: case OP_rotate:
193: fprintf(stderr, "op_rotate\n");
194: op_rotate();
195: break;
196: case OP_scale:
197: fprintf(stderr, "op_scale\n");
198: op_scale();
199: break;
200: case OP_scale2:
201: fprintf(stderr, "op_scale2\n");
202: op_scale2();
203: break;
204: case OP_concat:
205: fprintf(stderr, "op_concat\n");
206: op_concat();
207: break;
208: case OP_makepixelarray:
209: fprintf(stderr, "op_makepixelarray\n");
210: op_makepixelarray();
211: break;
212: case OP_extractpixelarray:
213: fprintf(stderr, "op_extractpixelarray\n");
214: op_extractpixelarray();
215: break;
216: case OP_finddecompressor:
217: fprintf(stderr, "op_finddecompressor\n");
218: op_finddecompressor();
219: break;
220: case OP_makegray:
221: fprintf(stderr, "op_makegray\n");
222: op_makegray();
223: break;
224: case OP_findcolor:
225: fprintf(stderr, "op_findcolor\n");
226: op_findcolor();
227: break;
228: case OP_findcoloroperator:
229: fprintf(stderr, "op_findcoloroperator\n");
230: op_findcoloroperator();
231: break;
232: case OP_findcolormodeloperator:
233: fprintf(stderr, "op_findcolormodeloperator\n");
234: op_findcolormodeloperator();
235: break;
236: case OP_beginBlock:
237: fprintf(stderr, "op_beginblock\n");
238: op_beginblock();
239: break;
240: case OP_endBlock:
241: fprintf(stderr, "op_endblock\n");
242: op_endblock();
243: return(1);
244: default:
245: fprintf(stderr, "op_unknown\n");
246: op_unknown(op);
247: break;
248: }
249: return (0);
250: }
251:
252: sequence(type, len, last)
253: int type, len, last;
254: {
255: switch (type)
256: {
257: case sequenceAdaptivePixelVector:
258: fprintf(stderr, "seq_adaptivepixel\n");
259: seq_adaptivepixel(len);
260: break;
261: case sequenceComment:
262: fprintf(stderr, "seq_comment\n");
263: seq_comment(len);
264: break;
265: case sequenceCompressedPixelVector:
266: fprintf(stderr, "seq_compressedpixel\n");
267: seq_compressedpixel(len);
268: break;
269: case sequenceContinued:
270: fprintf(stderr, "seq_continued\n");
271: seq_continued(len, last);
272: break;
273: case sequenceIdentifier:
274: fprintf(stderr, "seq_identifier\n");
275: seq_identifier(len);
276: break;
277: case sequenceInsertFile:
278: fprintf(stderr, "seq_insertfile\n");
279: seq_insertfile(len);
280: break;
281: case sequenceInteger:
282: fprintf(stderr, "seq_integer\n");
283: seq_integer(len);
284: break;
285: case sequenceLargeVector:
286: fprintf(stderr, "seq_largevector\n");
287: seq_largevector(len);
288: break;
289: case sequencePackedPixelVector:
290: fprintf(stderr, "seq_packedpixel\n");
291: seq_packedpixel(len);
292: break;
293: case sequenceRational:
294: fprintf(stderr, "seq_rational\n");
295: seq_rational(len);
296: break;
297: case sequenceString:
298: fprintf(stderr, "seq_string\n");
299: seq_string(len);
300: break;
301: default:
302: fprintf(stderr, "seq_unknown\n");
303: seq_unknown(type, len);
304: break;
305: }
306: }
307:
308: #endif
309:
310: /* Change Log
311: *
312: * K. Knox, 28-Mar-85 18:26:50, Created first version.
313: *
314: *
315: *
316: */
317:
318:
319:
320:
321:
322:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.