![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to execute.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 execute.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / dipress / src / bin / stackres |
1.1 root 1: /* execute.c
2: *
3: * Copyright (c) 1984, 1985 Xerox Corp.
4: *
5: * Define the functions used in parse.c.
6: *
7: * Execute the RES file and leave the correct parameters on the stack.
8: *
9: */
10:
11: #include <math.h>
12: #include <stdio.h>
13: #include <iptokens.h>
14: #include "stack.h"
15:
16: #define RES_header "Interpress/Xerox/2.1/RasterEncoding/1.0 "
17: #define len_RES_header 40
18:
19: #define err0 "(%d) execute: Bad RES header, got %s\n"
20: #define err1 "(%d) execute: roll moveFirst > depth, %d > %d!\n"
21: #define err2 "(%d) execute: unknown operator subtype, got %d!\n"
22: #define err3 "(%d) execute: unknown operator, type=%d!\n"
23: #define err4 "(%d) execute: unknown sequence, type=%d, length=%d!\n"
24: #define err5 "(%d) execute: sequenceInsertFile not implemented!\n"
25:
26:
27: /* Defined elsewhere. */
28: extern unsigned char **malloc();
29: extern long filepos;
30: extern FILE *fp;
31:
32: /* Defined in this module. */
33: extern unsigned char *decompressID();
34: extern unsigned char *decompressOP();
35: extern unsigned char *imagedata();
36: extern unsigned char *popidentifier();
37: extern double popdouble();
38:
39:
40: /*
41: * Public procedures defined for "parse" module.
42: *
43: */
44:
45: header(string, resheader)
46: {
47: if (strcmp(string, RES_header) != 0) error(err0, filepos, string);
48: }
49:
50: op_makevec()
51: {
52: int n, depth;
53: unsigned char *ptr, **array;
54: depth = popint();
55: array = malloc((depth+1)*sizeof(unsigned char *)); /* null terminated array */
56: for (n=0; n < depth; n++) array[depth-n-1] = pop(0);
57: array[depth] = (unsigned char *) 0;
58: ptr = makevector(array, type_vector, subtype_general);
59: for (n=0; n < depth; n++) free(array[n]);
60: free(array);
61: push(ptr);
62: }
63:
64: op_pop()
65: {
66: free(pop(0));
67: }
68:
69: op_copy()
70: {
71: int n, depth;
72: unsigned char *ptr, **temp1, **temp2;
73: depth = popint();
74: temp1 = malloc(depth*sizeof(unsigned char *));
75: temp2 = malloc(depth*sizeof(unsigned char *));
76: for (n=0; n < depth; n++) temp1[depth-n-1] = pop(0);
77: for (n=0; n < depth; n++) temp2[n] = duplicate(temp1[n]);
78: for (n=0; n < depth; n++) push(temp1[n]);
79: for (n=0; n < depth; n++) push(temp2[n]);
80: free(temp1);
81: free(temp2);
82: }
83:
84: op_dup()
85: {
86: unsigned char *ptr, *newptr;
87: ptr = pop(0);
88: newptr = duplicate(ptr);
89: push(ptr);
90: push(newptr);
91: }
92:
93: op_roll()
94: {
95: int n, depth, moveFirst;
96: unsigned char *ptr, **temp;
97: moveFirst = popint();
98: depth = popint();
99: if (moveFirst > depth) error(err1, filepos, moveFirst, depth);
100: temp = malloc(depth*sizeof(unsigned char *));
101: for (n=0; n < depth; n++) temp[depth-n-1] = pop(0);
102: for (n=moveFirst; n < depth; n++) push(temp[n]);
103: for (n=0; n < moveFirst; n++) push(temp[n]);
104: free(temp);
105: }
106:
107: op_exch()
108: {
109: unsigned char *temp1, *temp2;
110: temp1 = pop(0);
111: temp2 = pop(0);
112: push(temp1);
113: push(temp2);
114: }
115:
116: op_nop()
117: {
118: }
119:
120: op_translate()
121: {
122: double x, y;
123: unsigned char *ptr;
124: y = popdouble();
125: x = popdouble();
126: ptr = maketransformation(1.0, 0.0, x, 0.0, 1.0, y);
127: push(ptr);
128: }
129:
130: op_rotate()
131: {
132: double angle, cosA, sinA, pi;
133: unsigned char *ptr;
134: angle = popdouble();
135: angle = 3.1415926*angle/180.;
136: cosA = cos(angle);
137: sinA = sin(angle);
138: ptr = maketransformation(cosA, -sinA, 0.0, sinA, cosA, 0.0);
139: push(ptr);
140: }
141:
142: op_scale()
143: {
144: unsigned char *ptr;
145: double s;
146: s = popdouble();
147: ptr = maketransformation(s, 0.0, 0.0, 0.0, s, 0.0);
148: push(ptr);
149: }
150:
151: op_scale2()
152: {
153: unsigned char *ptr;
154: double sx, sy;
155: sy = popdouble();
156: sx = popdouble();
157: ptr = maketransformation(sx, 0.0, 0.0, 0.0, sy, 0.0);
158: push(ptr);
159: }
160:
161: op_concat()
162: {
163: double a, b, c, d, e, f;
164: unsigned char *ptr, *nptr, *mptr;
165: double *m, *n;
166: nptr = pop(type_transformation, 0);
167: mptr = pop(type_transformation, 0);
168: n = gettransformation(nptr);
169: m = gettransformation(mptr);
170: a = m[0]*n[0]+m[3]*n[1];
171: b = m[1]*n[0]+m[4]*n[1];
172: c = m[2]*n[0]+m[5]*n[1]+n[2];
173: d = m[0]*n[3]+m[3]*n[4];
174: e = m[1]*n[3]+m[4]*n[4];
175: f = m[2]*n[3]+m[5]*n[4]+n[5];
176: ptr = maketransformation(a, b, c, d, e, f);
177: free(mptr);
178: free(nptr);
179: free(m);
180: free(n);
181: push(ptr);
182: }
183:
184: op_makepixelarray()
185: {
186: int n;
187: unsigned char *ptr, **array;
188: array = malloc(9*sizeof(unsigned char *));
189: array[6] = pop(type_vector, 0); /* samples */
190: array[5] = pop(type_transformation, 0); /* m */
191: array[4] = pop(type_number, 0); /* samplesInterleaved */
192: array[3] = pop(type_number | type_vector, 0); /* maxSampleValue */
193: array[2] = pop(type_number, 0); /* samplesPerPixel */
194: array[1] = pop(type_number, 0); /* yPixels */
195: array[0] = pop(type_number, 0); /* xPixels */
196: array[7] = makeselect(getint(array[2]), ~0); /* select == all samples */
197: array[8] = (unsigned char *) 0; /* null terminated list */
198: ptr = makepixelarray(array);
199: for (n=0; n < 9; n++) free(array[n]);
200: free(array);
201: push(ptr);
202: }
203:
204:
205: op_extractpixelarray()
206: {
207: int depth;
208: unsigned char *oldptr, *newptr, *select, **array;
209: select = pop(type_vector, 0);
210: oldptr = pop(type_pixelarray, 0);
211: array = getpixelarray(oldptr);
212: array[7] = select;
213: newptr = makepixelarray(array);
214: free(select);
215: free(oldptr);
216: free(array);
217: push(newptr);
218: }
219:
220: op_do()
221: {
222: unsigned char *ptr, **array;
223: int type, subtype;
224: array = malloc(3*sizeof(unsigned char *));
225: array[0] = pop(type_operator, 0); /* operator to do */
226: array[1] = pop(type_vector, 0); /* vector argument */
227: array[2] = (unsigned char *) 0;
228: switch (getsubtype(array[0]))
229: {
230: case subtype_decompressop:
231: type = type_vector;
232: subtype = subtype_samples;
233: break;
234: case subtype_colorop:
235: type = type_color;
236: subtype = subtype_operator;
237: break;
238: case subtype_colormodelop:
239: type = type_operator;
240: subtype = subtype_colorop;
241: break;
242: default:
243: error(err2, filepos, getsubtype(array[0]));
244: }
245: ptr = makevector(array, type, subtype);
246: free(array[0]);
247: free(array[1]);
248: free(array);
249: push(ptr);
250: }
251:
252: op_finddecompressor()
253: {
254: unsigned char *ptr, **array;
255: array = malloc(2*sizeof(unsigned char *));
256: array[0] = popidentifier("decompressionOps/");
257: array[1] = (unsigned char *) 0;
258: ptr = makeoperator(array, subtype_decompressop);
259: free(array[0]);
260: free(array);
261: push(ptr);
262: }
263:
264: op_makegray()
265: {
266: unsigned char *ptr, **array;
267: array = malloc(2*sizeof(unsigned char *));
268: array[0] = pop(type_number);
269: array[1] = (unsigned char *) 0;
270: ptr = makecolor(array, subtype_value);
271: push(ptr);
272: }
273:
274: op_findcolor()
275: {
276: unsigned char *ptr, **array;
277: array = malloc(2*sizeof(unsigned char *));
278: array[0] = popidentifier("colors/");
279: array[1] = (unsigned char *) 0;
280: ptr = makecolor(array, subtype_name);
281: free(array[0]);
282: free(array);
283: push(ptr);
284: }
285:
286: op_findcoloroperator()
287: {
288: unsigned char *ptr, **array;
289: array = malloc(2*sizeof(unsigned char *));
290: array[0] = popidentifier("colorOps/");
291: array[1] = (unsigned char *) 0;
292: ptr = makeoperator(array, subtype_colorop);
293: free(array[0]);
294: free(array);
295: push(ptr);
296: }
297:
298: op_findcolormodeloperator()
299: {
300: unsigned char *ptr, **array;
301: array = malloc(2*sizeof(unsigned char *));
302: array[0] = popidentifier("colorModelOps/");
303: array[1] = (unsigned char *) 0;
304: ptr = makeoperator(array, subtype_colormodelop);
305: free(array[0]);
306: free(array);
307: push(ptr);
308: }
309:
310: op_beginblock()
311: {
312: }
313:
314: op_endblock()
315: {
316: }
317:
318: op_unknown(op)
319: int op;
320: {
321: error(err3, filepos, op);
322: }
323:
324: seq_comment(nbytes)
325: int nbytes;
326: {
327: fseek(fp, (long) nbytes, 1);
328: }
329:
330: seq_continued(nbytes, last)
331: int nbytes, last;
332: {
333: switch (last)
334: {
335: case sequenceAdaptivePixelVector:
336: case sequenceCompressedPixelVector:
337: case sequencePackedPixelVector:
338: case sequenceLargeVector: extendpixel(nbytes); break;
339: case sequenceComment: fseek(fp, (long) nbytes, 1); break;
340: case sequenceInteger:
341: case sequenceRational: extendnumber(nbytes); break;
342: case sequenceString:
343: case sequenceIdentifier: extendstring(nbytes); break;
344: default: error(err4, filepos, last, nbytes);
345: }
346: }
347:
348: seq_insertfile(nbytes)
349: int nbytes;
350: {
351: error(err5, filepos);
352: }
353:
354: seq_largevector(nbytes)
355: int nbytes;
356: {
357: int b;
358: long bytepos, bytelength;
359: unsigned char *ptr, **array;
360: b = getc(fp) & 0377; /* read the number of bytes/integer. */
361: bytepos = ftell(fp);
362: bytelength = nbytes-1;
363: array = malloc(2*sizeof(unsigned char *));
364: array[0] = makeintegers(b, bytepos, bytelength);
365: array[1] = (unsigned char *) 0;
366: ptr = makevector(array, type_vector, subtype_integers);
367: fseek(fp, bytelength, 1);
368: free(array[0]);
369: free(array);
370: push(ptr);
371: }
372:
373:
374: seq_adaptivepixel(nbytes)
375: int nbytes;
376: {
377: pushpixel(nbytes, "adaptive");
378: }
379:
380: seq_compressedpixel(nbytes)
381: int nbytes;
382: {
383: pushpixel(nbytes, "compressed");
384: }
385:
386: seq_packedpixel(nbytes)
387: int nbytes;
388: {
389: pushpixel(nbytes, "packed");
390: }
391:
392: seq_identifier(nbytes)
393: int nbytes;
394: {
395: pushstring(nbytes, subtype_identifier);
396: }
397:
398: seq_string(nbytes)
399: int nbytes;
400: {
401: pushstring(nbytes, subtype_string);
402: }
403:
404: seq_unknown(type, nbytes)
405: int type, nbytes;
406: {
407: error(err4, filepos, type, nbytes);
408: }
409:
410: seq_integer(nbytes)
411: int nbytes;
412: {
413: pushinteger(nbytes, subtype_integer);
414: }
415:
416: seq_rational(nbytes)
417: int nbytes;
418: {
419: pushinteger(nbytes, subtype_rational);
420: }
421:
422: shortnum(number)
423: int number;
424: {
425: unsigned char value[2];
426: unsigned char *ptr;
427: value[0] = (number >> 8) & 0377;
428: value[1] = number & 0377;
429: ptr = makenumber(2, value, subtype_integer);
430: push(ptr);
431: }
432:
433:
434: /*
435: * Private procedures to this module.
436: *
437: */
438:
439: static pushinteger(nbytes, subtype)
440: int nbytes, subtype;
441: {
442: int n;
443: unsigned char *ptr;
444: unsigned char *array;
445: array = (unsigned char *) malloc(nbytes);
446: for (n=0; n < nbytes; n++) array[n] = getc(fp) & 0377;
447: ptr = makenumber(nbytes, array, subtype);
448: free(array);
449: push(ptr);
450: }
451:
452: static pushstring(nbytes, subtype)
453: int nbytes, subtype;
454: {
455: int n;
456: unsigned char *ptr;
457: char *string;
458: string = (char *) malloc(nbytes+1);
459: for (n=0; n < nbytes; n++) string[n] = getc(fp) & 0377;
460: string[nbytes] = (char) 0;
461: ptr = makestring(string, subtype);
462: free(string);
463: push(ptr);
464: }
465:
466: static pushpixel(nbytes, compression)
467: int nbytes;
468: char *compression;
469: {
470: extern unsigned char *decompressID();
471: extern unsigned char *decompressOP();
472: extern unsigned char *imagedata();
473: unsigned char *ptr, *idvec, **array;
474: idvec = decompressID(compression);
475: array = malloc(3*sizeof(unsigned char *));
476: array[0] = decompressOP(idvec);
477: array[1] = imagedata(nbytes);
478: array[2] = (unsigned char *) 0;
479: ptr = makevector(array, type_vector, subtype_samples);
480: free(idvec);
481: free(array[0]);
482: free(array[1]);
483: free(array);
484: push(ptr);
485: }
486:
487: static unsigned char *decompressID(compression)
488: char *compression;
489: {
490: unsigned char *ptr, **array;
491: array = malloc(3*sizeof(unsigned char *));
492: array[0] = makestring("xerox", subtype_identifier);
493: array[1] = makestring(compression, subtype_identifier);
494: array[2] = (unsigned char *) 0;
495: ptr = makevector(array, type_vector, subtype_general);
496: free(array[0]);
497: free(array[1]);
498: free(array);
499: return(ptr);
500: }
501:
502: static unsigned char *decompressOP(idvec)
503: unsigned char *idvec;
504: {
505: unsigned char *ptr, **array;
506: array = malloc(2*sizeof(unsigned char *));
507: array[0] = makeidentifier(idvec, "decompressionOps/");
508: array[1] = (unsigned char *) 0;
509: ptr = makeoperator(array, subtype_decompressop);
510: free(array[0]);
511: free(array);
512: return(ptr);
513: }
514:
515: static unsigned char *imagedata(nbytes)
516: int nbytes;
517: {
518: long bytepos, bytelength;
519: unsigned char *ptr, **array;
520: bytepos = ftell(fp);
521: bytelength = nbytes;
522: array = malloc(2*sizeof(unsigned char *));
523: array[0] = makeintegers(2, bytepos, bytelength);
524: array[1] = (unsigned char *) 0;
525: ptr = makevector(array, type_vector, subtype_integers);
526: fseek(fp, bytelength, 1);
527: free(array[0]);
528: free(array);
529: return(ptr);
530: }
531:
532: static popint()
533: {
534: int result;
535: unsigned char *ptr;
536: ptr = pop(type_number, 0);
537: result = getint(ptr);
538: free(ptr);
539: return(result);
540: }
541:
542: static double popdouble()
543: {
544: double result;
545: unsigned char *ptr;
546: ptr = pop(type_number, 0);
547: result = getdouble(ptr);
548: free(ptr);
549: return(result);
550: }
551:
552: static unsigned char *popidentifier(prefix)
553: char *prefix; /* should end with '/' character */
554: {
555: unsigned char *ptr, *composite;
556: ptr = pop(type_vector, subtype_general);
557: composite = makeidentifier(ptr, prefix);
558: free(ptr);
559: return(composite);
560: }
561:
562: static extendpixel(nbytes)
563: int nbytes;
564: {
565: int n, depth;
566: long bytepos, bytelength;
567: unsigned char *ptr, **samplesarray, **integersarray;
568: unsigned char *newptr, **newarray;
569: ptr = pop(type_vector, subtype_samples);
570: samplesarray = getvector(ptr);
571: depth = getdepth(samplesarray[1]);
572: integersarray = getvector(samplesarray[1]);
573: newarray = malloc((depth+2)*sizeof(unsigned char *));
574: for (n=0; n < depth; n++) newarray[n] = integersarray[n];
575: bytepos = ftell(fp);
576: bytelength = nbytes;
577: newarray[depth] = makeintegers(2, bytepos, bytelength);
578: newarray[depth+1] = (unsigned char *) 0;
579: samplesarray[1] = makevector(newarray, type_vector, subtype_integers);
580: newptr = makevector(samplesarray, type_vector, subtype_samples);
581: fseek(fp, bytelength, 1);
582: free(ptr);
583: free(newarray[depth]);
584: free(samplesarray[1]);
585: free(samplesarray);
586: free(integersarray);
587: free(newarray);
588: push(newptr);
589: }
590:
591: static extendnumber(nbytes)
592: int nbytes;
593: {
594: int n, len;
595: unsigned char *number, *newnumber;
596: unsigned char *ptr, *newptr;
597: ptr = pop(type_number, subtype_integer | subtype_rational);
598: number = getnumber(ptr);
599: len = getnumlen(ptr);
600: newnumber = (unsigned char *) malloc(len+nbytes);
601: for (n=0; n < len; n++) newnumber[n] = number[n];
602: for (n=0; n < nbytes; n++) newnumber[n+len] = getc(fp) & 0377;
603: newptr = makenumber(len+nbytes, newnumber, getsubtype(ptr));
604: free(ptr);
605: free(newnumber);
606: push(newptr);
607: }
608:
609: static extendstring(nbytes)
610: int nbytes;
611: {
612: int n, len;
613: char *string, *newstring;
614: unsigned char *ptr, *newptr;
615: ptr = pop(type_string, subtype_identifier | subtype_string);
616: string = getstring(ptr, 0);
617: len = strlen(string);
618: newstring = (char *) malloc(len+nbytes+1);
619: strcpy(newstring, string);
620: for (n=0; n < nbytes; n++) newstring[n+len] = getc(fp) & 0377;
621: newstring[len+nbytes] = (char) 0;
622: newptr = makestring(newstring, getsubtype(ptr));
623: free(ptr);
624: free(newstring);
625: push(newptr);
626: }
627:
628:
629:
630:
631:
632: /* Change Log
633: *
634: * K. Knox, 1-Apr-85 23:45:46, Created first version.
635: * K. Knox, 13-May-85 10:25:25, Fixed bugs in calls to maketransformation.
636: * K. Knox, 13-May-85 10:25:25, Fixed bug in angle calculation in op_rotate.
637: *
638: *
639: *
640: */
641:
642:
643:
644:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.