![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stackres.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 stackres.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / dipress / src / bin / stackres |
1.1 root 1: /* stackres.c
2: *
3: * Copyright (c) 1984, 1985, 1986 Xerox Corp.
4: *
5: * Module: stackres
6: * Owner: knox
7: * stdout: text description
8: * args:
9: * name (name of the input res file)
10: *
11: * Description:
12: * This program reads an RES file, executes it and produces a
13: * text description file. The name of the RES file is the
14: * the first argument of the command line. The text description
15: * written to the standard output describes the results left
16: * on the stack after the image has been executed.
17: *
18: * The image raster will be read from the file "name.res",
19: * where name is read from the command line. The ".res"
20: * extension will not be added if it is already present in the
21: * name.
22: *
23: * HISTORY
24: *
25: *
26: */
27:
28: #include "stack.h"
29: #include <stdio.h>
30: #include <strings.h>
31:
32: extern char *malloc();
33:
34: #define err0 "readres: No input RES file name!\n"
35: #define err1 "readres: RES file could not be found, %s!\n"
36:
37: FILE *fpin;
38: int fdout;
39:
40: main(argc, argv)
41: int argc;
42: char *argv[];
43: {
44: getargs(argc, argv);
45: parse(fpin);
46: writedata();
47: exit(0);
48: }
49:
50: getargs(argc, argv)
51: int argc;
52: char *argv[];
53: {
54: char *filename;
55:
56: if (argc < 2) {
57: fprintf(stderr, err0);
58: exit(2);
59: }
60:
61: /* Open input RES file. */
62: fdout = 1;
63: filename = (char *) malloc((unsigned) strlen(argv[1])+1+strlen(".res"));
64: (void) strcpy(filename, argv[1]);
65:
66: if (strcmp(".res", rindex(filename, '.')) != 0)
67: (void) strcat(filename, ".res");
68:
69: fpin = fopen(filename, "r");
70:
71: if (fpin == NULL) {
72: fprintf(stderr, err1, filename);
73: exit(2);
74: }
75: }
76:
77:
78:
79: writedata()
80: {
81: /* remove everything from the stack. */
82: int n;
83: unsigned char *ptr;
84: n = 0;
85: while (!stackempty())
86: {
87: n++;
88: ptr = pop(0);
89: printitem(ptr, n);
90: printf("\n");
91: free((char *) ptr);
92: }
93: }
94:
95: printitem(ptr, element)
96: unsigned char *ptr;
97: int element;
98: {
99: printf("Element: %d\n", element);
100: printf("Length: %d\n", getlength(ptr));
101: switch (gettype(ptr))
102: {
103: case type_number: printnumber(ptr); break;
104: case type_string: printstring(ptr); break;
105: case type_vector: printvector(ptr); break;
106: case type_operator: printoperator(ptr); break;
107: case type_color: printcolor(ptr); break;
108: case type_pixelarray: printpixelarray(ptr); break;
109: case type_transformation: printtransformation(ptr); break;
110: case type_integers: printintegers(ptr); break;
111: default: printf("Type: unknown\n"); break;
112: }
113: }
114:
115: printnumber(ptr)
116: unsigned char *ptr;
117: {
118: printf("Type: number\n");
119: switch (getsubtype(ptr))
120: {
121: case subtype_integer: printinteger(ptr); break;
122: case subtype_rational: printrational(ptr); break;
123: default: printf("Subtype: unknown\n"); break;
124: }
125: }
126:
127: printinteger(ptr)
128: unsigned char *ptr;
129: {
130: printf("Subtype: integer\n");
131: printf("Value: %d\n", getint(ptr));
132: }
133:
134: printrational(ptr)
135: unsigned char *ptr;
136: {
137: printf("Subtype: rational\n");
138: printf("Value: %f/%f\n", getnumerator(ptr), getdenominator(ptr));
139: }
140:
141: printstring(ptr)
142: unsigned char *ptr;
143: {
144: printf("Type: string\n");
145: switch (getsubtype(ptr))
146: {
147: case subtype_identifier: printidentifier(ptr); break;
148: case subtype_string: printsubstring(ptr); break;
149: default: printf("Subtype: unknown\n"); break;
150: }
151: }
152:
153: printidentifier(ptr)
154: unsigned char *ptr;
155: {
156: printf("Subtype: identifier\n");
157: printf("Identifier: %s\n", getstring(ptr, subtype_identifier));
158: }
159:
160: printsubstring(ptr)
161: unsigned char *ptr;
162: {
163: printf("Subtype: string\n");
164: printf("String: %s\n", getstring(ptr, subtype_string));
165: }
166:
167: printvector(ptr)
168: unsigned char *ptr;
169: {
170: printf("Type: vector\n");
171: switch (getsubtype(ptr))
172: {
173: case subtype_general: printvec(ptr, "general"); break;
174: case subtype_integers: printvec(ptr, "integers"); break;
175: case subtype_samples: printvec(ptr, "samples"); break;
176: default: printf("Subtype: unknown\n"); break;
177: }
178: }
179:
180: printvec(ptr, string)
181: unsigned char *ptr;
182: char *string;
183: {
184: int n, depth;
185: unsigned char **array;
186:
187: depth = getdepth(ptr);
188: printf("Subtype: %s\n", string);
189: printf("Depth: %d\n", depth);
190: array = getvector(ptr);
191:
192: for (n=0; n < depth; n++)
193: printitem(array[n], n);
194:
195: free((char *) array);
196: }
197:
198: printoperator(ptr)
199: unsigned char *ptr;
200: {
201: printf("Type: operator\n");
202: switch (getsubtype(ptr))
203: {
204: case subtype_decompressop: printop(ptr, "decompressop"); break;
205: case subtype_colorop: printop(ptr, "colorop"); break;
206: case subtype_colormodelop: printop(ptr, "colormodelop"); break;
207: default: printf("Subtype: unknown\n"); break;
208: }
209: }
210:
211: printop(ptr, string)
212: unsigned char *ptr;
213: char *string;
214: {
215: int n, depth;
216: unsigned char **array;
217: depth = getdepth(ptr);
218: printf("Subtype: %s\n", string);
219: printf("Depth: %d\n", depth);
220: array = getoperator(ptr);
221:
222: for (n=0; n < depth; n++)
223: printitem(array[n], n);
224:
225: free((char *) array);
226: }
227:
228: printcolor(ptr)
229: unsigned char *ptr;
230: {
231: printf("Type: color\n");
232: switch (getsubtype(ptr))
233: {
234: case subtype_value: printcol(ptr, "value"); break;
235: case subtype_name: printcol(ptr, "name"); break;
236: case subtype_operator: printcol(ptr, "operator"); break;
237: default: printf("Subtype: unknown\n"); break;
238: }
239: }
240:
241: printcol(ptr, string)
242: unsigned char *ptr;
243: char *string;
244: {
245: int n, depth;
246: unsigned char **array;
247: depth = getdepth(ptr);
248: printf("Subtype: %s\n", string);
249: printf("Depth: %d\n", depth);
250: array = getcolor(ptr);
251: for (n=0; n < depth; n++) printitem(array[n], n);
252: free((char *) array);
253: }
254:
255: printpixelarray(ptr)
256: unsigned char *ptr;
257: {
258: int n, depth;
259: unsigned char **array;
260: depth = getdepth(ptr);
261: printf("Type: pixelarray\n");
262: printf("Depth: %d\n", depth);
263: array = getcolor(ptr);
264:
265: for (n=0; n < depth; n++)
266: printitem(array[n], n);
267:
268: free((char *) array);
269: }
270:
271: printtransformation(ptr)
272: unsigned char *ptr;
273: {
274: double *array;
275: array = gettransformation(ptr);
276: printf("Type: transformation\n");
277: printf("A: %f\n", array[0]);
278: printf("B: %f\n", array[1]);
279: printf("C: %f\n", array[2]);
280: printf("D: %f\n", array[3]);
281: printf("E: %f\n", array[4]);
282: printf("F: %f\n", array[5]);
283: free((char *) array);
284: }
285:
286: printintegers(ptr)
287: unsigned char *ptr;
288: {
289: printf("Type: integers\n");
290: printf("Bytes/Integer: %d\n", getbytesPerInteger(ptr));
291: printf("Bytepos: %ld\n", getbytepos(ptr));
292: printf("ByteLength: %ld\n", getbytelength(ptr));
293: }
294:
295: /* Change Log
296: *
297: * K. Knox, 28-Mar-85 15:04:13, Created first version.
298: *
299: *
300: *
301: */
302:
303:
304:
305:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.