Return to stackres.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / dipress / src / bin / stackres

Annotation of 43BSD/contrib/dipress/src/bin/stackres/stackres.c, revision 1.1

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.