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