Return to parse.c CVS log

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

Annotation of 43BSDTahoe/new/dipress/src/bin/stackres/parse.c, revision 1.1

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.