Return to y.tab.c CVS log

Up to [Research Unix] / researchv10no / cmd / twig

Annotation of researchv10no/cmd/twig/y.tab.c, revision 1.1

1.1     ! root        1: # define ERROR 257
        !             2: 
        !             3: # line 3 "twig.y"
        !             4: #include "common.h"
        !             5: #include "code.h"
        !             6: #include "sym.h"
        !             7: #define UNDEFINED -1
        !             8: #define GIVENUP        -2
        !             9: 
        !            10: int debug_flag = 0;
        !            11: int Dflag = 0;
        !            12: int tflag = 0;
        !            13: int line_xref_flag = 0;
        !            14: int ntrees = 0;
        !            15: int nerrors = 0;
        !            16: int fatalerrors = 0;
        !            17: int tree_lineno;
        !            18: FILE *outfile;
        !            19: FILE *symfile;
        !            20: Code *epilogue;
        !            21: 
        !            22: SymbolEntry ErrorSymbol;
        !            23: 
        !            24: # line 23 "twig.y"
        !            25: typedef union  {
        !            26:        Node *y_nodep;
        !            27:        SymbolEntry *y_symp;
        !            28:        Code *y_code;
        !            29:        int y_int;
        !            30: } YYSTYPE;
        !            31: # define K_NODE 258
        !            32: # define K_LABEL 259
        !            33: # define K_PROLOGUE 260
        !            34: # define K_CONST 261
        !            35: # define K_INSERT 262
        !            36: # define K_COST 263
        !            37: # define K_ACTION 264
        !            38: # define ID 265
        !            39: # define NUMBER 266
        !            40: # define CBLOCK 267
        !            41: #define yyclearin yychar = -1
        !            42: #define yyerrok yyerrflag = 0
        !            43: extern int yychar;
        !            44: extern short yyerrflag;
        !            45: #ifndef YYMAXDEPTH
        !            46: #define YYMAXDEPTH 150
        !            47: #endif
        !            48: YYSTYPE yylval, yyval;
        !            49: # define YYERRCODE 256
        !            50: 
        !            51: # line 255 "twig.y"
        !            52: 
        !            53: 
        !            54: extern char *process_suffix();
        !            55: 
        !            56: set_arity(symp, arityp, count)
        !            57:        SymbolEntry *symp;
        !            58:        int *arityp;
        !            59:        int count;
        !            60: {
        !            61:        if(*arityp!=GIVENUP) {
        !            62:                if (*arityp==UNDEFINED)
        !            63:                        *arityp = count;
        !            64:                else if (*arityp!=count) {
        !            65:                        sem_error("inconsistent arity for %s", symp->name);
        !            66:                        *arityp = GIVENUP;
        !            67:                }
        !            68:        }
        !            69: }
        !            70: 
        !            71: is_node(symp)
        !            72:        SymbolEntry *symp;
        !            73: { return(symp->attr==A_NODE); }
        !            74: 
        !            75: is_label(symp)
        !            76:        SymbolEntry *symp;
        !            77: { return(symp->attr==A_LABEL); }
        !            78: 
        !            79: CheckIsNodeOrPred (symp)
        !            80:        SymbolEntry *symp;
        !            81: {
        !            82:        if (symp->attr==A_ERROR)
        !            83:                return;
        !            84:        if (symp->attr!=A_NODE)
        !            85:                sem_error ("non-node identifier %s", symp->name);
        !            86: }
        !            87: 
        !            88: CheckIsUndefined(symp)
        !            89:        SymbolEntry *symp;
        !            90: {
        !            91:        if (symp->attr==A_ERROR)
        !            92:                return(0);
        !            93:        if (symp->attr!=A_UNDEFINED) {
        !            94:                sem_error ("multiple declaration: %s", symp->name);
        !            95:                return(0);
        !            96:        } else return(1);
        !            97: }
        !            98: 
        !            99: CheckIsDefined(symp)
        !           100:        SymbolEntry *symp;
        !           101: {
        !           102:        if (symp->attr==A_ERROR)
        !           103:                return(0);
        !           104:        if (symp->attr==A_UNDEFINED) {
        !           105:                sem_error ("undefined identifier: %s", symp->name);
        !           106:                symp->attr=A_ERROR;
        !           107:                return(0);
        !           108:        } else return(1);
        !           109: }
        !           110: 
        !           111: 
        !           112: 
        !           113: /*VARARGS*/
        !           114: yyerror(fmt, s1, s2, s3)
        !           115:        char *fmt, *s1, *s2, *s3;
        !           116: {
        !           117:        fprintf(stderr, "line %d: ", yyline);
        !           118:        fprintf(stderr, fmt, s1, s2, s3);
        !           119:        if (token_buffer[0]!=0)
        !           120:                fprintf(stderr, " at \"%s\"\n", token_buffer);
        !           121: }
        !           122: 
        !           123: /*VARARGS*/
        !           124: yyerror2 (fmt, s1, s2, s3)
        !           125:        char *fmt, *s1, *s2, *s3;
        !           126: {
        !           127:        fprintf(stderr, "line %d: ", yyline);
        !           128:        fprintf(stderr, fmt, s1, s2, s3);
        !           129:        putchar('\n');
        !           130: }
        !           131: 
        !           132: char *cmdnam;
        !           133: char *inFileName;
        !           134: char *outFileName;
        !           135: char prefixFile[100];
        !           136: static char usage[] = "usage: mt [-d] file";
        !           137: #define USAGE  error(1, usage)
        !           138: char *prefix_base = PREFIX_BASE;
        !           139: char *suffix = "c1";
        !           140: 
        !           141: main(argc, argv)
        !           142:        int argc;
        !           143:        char **argv;
        !           144: {
        !           145:        int i;
        !           146:        char *cp;
        !           147: 
        !           148: #ifndef PREFIX_BASE
        !           149:        error(1,"PREFIX_BASE has not been defined; recompile twig");
        !           150: #endif
        !           151: 
        !           152:        cmdnam = argv[0];
        !           153:        argv++;
        !           154:        inFileName = NULL;
        !           155: 
        !           156:        while(--argc > 0) {
        !           157:                if (*argv[0]=='-')
        !           158:                        switch(argv[0][1]) {
        !           159:                        /* to see what each of these flags mean...
        !           160:                         * see common.h */
        !           161:                        case 'd': {
        !           162:                                char *cp;
        !           163:                                for(cp = &argv[0][2]; *cp!='\0'; cp++) 
        !           164:                                        switch(*cp) {
        !           165:                                        case 'l': debug_flag |= DB_LEX; break;
        !           166:                                        case 'm': debug_flag |= DB_MACH; break;
        !           167:                                        case 's': debug_flag |= DB_SYM; break;
        !           168:                                        case 't': debug_flag |= DB_TREE; break;
        !           169:                                        case 'M': debug_flag |= DB_MEM; break;
        !           170:                                        }
        !           171:                                }
        !           172:                                break;
        !           173:                        case 'D': Dflag++; break;
        !           174:                        case 't': tflag++; break;
        !           175:                        case 'w': suffix = process_suffix(&argv[0][2]); break;
        !           176:                        case 'l': prefix_base = &argv[0][2]; break;
        !           177:                        case 'x': line_xref_flag++; break;
        !           178:                        default:
        !           179:                                USAGE;
        !           180:                        }
        !           181:                else inFileName = argv[0];
        !           182:                argv++;
        !           183:        }
        !           184:        if(inFileName==NULL)
        !           185:                USAGE;
        !           186:                        
        !           187:        if(freopen(inFileName, "r", stdin)==NULL)
        !           188:                error(1, "can't open %s", inFileName);
        !           189:        if((cp=strrchr(inFileName, '.'))!=NULL && strcmp(cp,".mt")==0) {
        !           190:                if ((outfile = fopen("walker.c" , "w"))==NULL)
        !           191:                        error(1, "can't write %s", outFileName);
        !           192:                if ((symfile = fopen("symbols.h", "w"))==NULL)
        !           193:                        error(1, "can't write %s", outFileName);
        !           194:        } else error(1, "input file must have suffix .mt");
        !           195: 
        !           196:        ErrorSymbol.attr = A_LABEL;
        !           197:        TreeInit();
        !           198:        SymbolInit();
        !           199:        LexInit();
        !           200:        yyparse();
        !           201: 
        !           202:        SymbolDump();
        !           203:        if(nerrors == 0) {
        !           204:                if(!tflag) {
        !           205:                        FILE *prefix;
        !           206:                        char c;
        !           207:                        sprintf(prefixFile, "%s.%s", prefix_base, suffix);
        !           208:                        prefix = fopen(prefixFile, "r");
        !           209:                        assert(prefix!=NULL);
        !           210:                        if(Dflag)
        !           211:                                fputs("#define DEBUG 1\n", outfile);
        !           212:                        if(line_xref_flag)
        !           213:                                fputs("#define LINE_XREF 1\n", outfile);
        !           214:                        fprintf(outfile,"# line 1 \"%s\"\n", prefixFile);
        !           215:                        while((c=getc(prefix))!=EOF) putc(c, outfile);
        !           216:                }
        !           217:                MachineGen();
        !           218:                SymbolGenerateWalkerCode();
        !           219:                CodeWrite(outfile, epilogue);
        !           220:                CodeFreeBlock(epilogue);
        !           221:        }
        !           222: 
        !           223:        /* cleanup */
        !           224:        cleanup(0);
        !           225: }
        !           226: 
        !           227: cleanup(retcode)
        !           228:        int retcode;
        !           229: {
        !           230:        lexCleanup();
        !           231:        if(retcode==0) {
        !           232:                SymbolFinish();
        !           233:        }
        !           234:        exit(retcode);
        !           235: }
        !           236: 
        !           237: /*VARARGS*/
        !           238: error(rc, fmt, a1, a2, a3)
        !           239:        int rc;
        !           240:        char *fmt, *a1, *a2, *a3;
        !           241: {
        !           242:        fprintf(stderr, "%s: ", cmdnam);
        !           243:        fprintf(stderr, fmt, a1, a2, a3);
        !           244:        putc ('\n', stderr);
        !           245:        if(rc)
        !           246:                exit (rc);
        !           247: }
        !           248: 
        !           249: /*VARARGS*/
        !           250: sem_error (fmt, a1, a2, a3)
        !           251:        char *fmt, *a1, *a2, *a3;
        !           252: {
        !           253:        fprintf (stderr, "line %d: ", yyline);
        !           254:        sem_error2(fmt, a1, a2, a3);
        !           255:        nerrors++;
        !           256:        fatalerrors++;
        !           257: }
        !           258: 
        !           259: /*VARARGS*/
        !           260: sem_error2(fmt, a1, a2, a3)
        !           261:        char *fmt, *a1, *a2, *a3;
        !           262: {
        !           263:        fprintf (stderr, fmt, a1, a2, a3);
        !           264:        putc('\n', stderr);
        !           265:        nerrors++;
        !           266: }
        !           267: 
        !           268: char *
        !           269: process_suffix(suf)
        !           270:        char *suf;
        !           271: {
        !           272:        extern int gen_table2;
        !           273:        if(strcmp(suf,"exper")==0) {
        !           274:                /* experimental walker */
        !           275:                /* expect this to change alot */
        !           276:                gen_table2++;
        !           277:        }
        !           278:        return(suf);
        !           279: }
        !           280: short yyexca[] ={
        !           281: -1, 1,
        !           282:        0, -1,
        !           283:        -2, 0,
        !           284: -1, 10,
        !           285:        0, 1,
        !           286:        -2, 0,
        !           287: -1, 66,
        !           288:        40, 49,
        !           289:        -2, 51,
        !           290:        };
        !           291: # define YYNPROD 56
        !           292: # define YYLAST 261
        !           293: short yyact[]={
        !           294: 
        !           295:   16,  71,   4,   6,   7,   5,  14,   8,   9,  17,
        !           296:    4,   6,   7,   5,  37,   8,   9,  29,  89,  79,
        !           297:   88,  78,  73,  72,  54,  36,  61,  59,  28,  50,
        !           298:   44,  40,  16,  92,  33,  31,  66,  27,  14,  25,
        !           299:   22,  17,  66,  32,  30,  93,  65,  70,  94,  85,
        !           300:   69,  53,  87,  76,  75,  64,  63,  62,  60,  58,
        !           301:   57,  39,  48,  38,  83,  82,  86,  49,  24,  21,
        !           302:   12,  20,  13,   3,  80,  10,  11,   2,  77,  84,
        !           303:   23,  35,  19,  34,  18,  15,  26,  90,   1,  45,
        !           304:   41,   0,  51,   0,   0,   0,   0,   0,   0,   0,
        !           305:    0,  74,   0,   0,   0,   0,  67,   0,   0,   0,
        !           306:   68,   0,   0,   0,   0,   0,   0,  81,   0,   0,
        !           307:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           308:    0,   0,   0,  91,   0,   0,   0,   0,   0,   0,
        !           309:    0,  96,   0,   0,   0,   0,   0,   0,   0,   0,
        !           310:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           311:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           312:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           313:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           314:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           315:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           316:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           317:    0,  56,   0,   0,  73,  72,  52,  46,  42,   0,
        !           318:   55,   0,   0,   0,   0,  25,  47,  43,   0,   0,
        !           319:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           320:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           321:   95 };
        !           322: short yypact[]={
        !           323: 
        !           324: -248,-1000,-256,-1000,-225,-226,-228,-239,-221,-222,
        !           325: -224,-1000,-1000,-1000,-242,   5,   2,-1000, -28, -29,
        !           326: -1000,-1000,  27, -30,-1000, -10, -35,-1000,   1,   0,
        !           327: -240,  -1,-241,  -2,-1000,-1000,  -3,  -4,-229,-1000,
        !           328: -1000,-1000,-1000,  27,-1000,-1000,-1000,  27, -11, -41,
        !           329: -1000,-1000,-1000,-243,-1000,-1000,-1000,-1000,-1000,  -5,
        !           330: -1000,  -6,-1000,-1000,-1000,-246,-1000,-1000, -11,-243,
        !           331:   24,  23,-1000,-1000,-1000,-1000,-1000, -12,-1000,-1000,
        !           332:   26,-1000,-1000,-1000,  -7,-247,-223,-1000,-1000,-1000,
        !           333:    4,-1000,-1000,-1000,-229,-1000,-1000 };
        !           334: short yypgo[]={
        !           335: 
        !           336:    0,  88,  46,  87,  86,  85,  84,  71,  82,  69,
        !           337:   80,  68,  62,  47,  79,  78,  77,  75,  73,  72,
        !           338:   70,  74 };
        !           339: short yyr1[]={
        !           340: 
        !           341:    0,   1,  16,  16,  18,  18,  18,  18,  18,  18,
        !           342:   18,  18,  18,  18,   4,   4,   4,   8,   8,   8,
        !           343:    6,   6,   6,   7,   9,  12,  12,  12,  10,  10,
        !           344:   10,  11,  13,  13,  17,  17,  17,  17,  20,  20,
        !           345:   19,  19,  14,  14,  14,  15,  15,  15,   5,  21,
        !           346:    2,   2,   3,   3,   3,   3 };
        !           347: short yyr2[]={
        !           348: 
        !           349:    0,   2,   2,   1,   3,   3,   3,   3,   3,   4,
        !           350:    4,   3,   3,   3,   2,   1,   2,   2,   1,   2,
        !           351:    2,   1,   2,   2,   4,   3,   3,   0,   2,   1,
        !           352:    2,   3,   1,   1,   2,   2,   1,   1,   3,   3,
        !           353:    6,   2,   2,   2,   0,   1,   1,   0,   1,   0,
        !           354:    5,   1,   3,   1,   1,   2 };
        !           355: short yychk[]={
        !           356: 
        !           357: -1000,  -1, -16, -18, 258, 261, 259, 260, 263, 264,
        !           358:  -17, -18, -20, -19, 262,  -5, 256, 265,  -6,  -8,
        !           359:   -7,  -9, 265, -10, -11, 265,  -4, 265, 267, 256,
        !           360:  265, 256, 265, 256, -19, -20, 267, 256,  58,  59,
        !           361:   59,  -7, 256, 265,  59,  -9, 256, 265, -12,  40,
        !           362:   59, -11, 256,  61,  59, 265, 256,  59,  59, 267,
        !           363:   59, 267,  59,  59,  59,  -2, 265, -12, -12,  61,
        !           364:  -13,  42, 266, 265, -13,  59,  59, -15, 267, 265,
        !           365:  -21, -13,  41,  41, -14,  61,  40,  59, 267, 265,
        !           366:   -3,  -2, 256,  41,  44, 256,  -2 };
        !           367: short yydef[]={
        !           368: 
        !           369:    0,  -2,   0,   3,   0,   0,   0,   0,   0,   0,
        !           370:   -2,   2,  36,  37,   0,   0,   0,  48,   0,   0,
        !           371:   21,  18,  27,   0,  29,   0,   0,  15,   0,   0,
        !           372:    0,   0,   0,   0,  34,  35,   0,   0,   0,  41,
        !           373:    4,  20,  22,  27,   5,  17,  19,  27,  23,   0,
        !           374:    6,  28,  30,   0,   7,  14,  16,   8,  11,   0,
        !           375:   13,   0,  12,  38,  39,  47,  -2,  23,   0,   0,
        !           376:    0,   0,  32,  33,  31,   9,  10,  44,  45,  46,
        !           377:    0,  24,  25,  26,   0,   0,   0,  40,  42,  43,
        !           378:    0,  53,  54,  50,   0,  55,  52 };
        !           379: # ifdef YYDEBUG
        !           380: # include "y.debug"
        !           381: # endif
        !           382: 
        !           383: # define YYFLAG -1000
        !           384: # define YYERROR goto yyerrlab
        !           385: # define YYACCEPT return(0)
        !           386: # define YYABORT return(1)
        !           387: 
        !           388: /*     parser for yacc output  */
        !           389: 
        !           390: #ifdef YYDEBUG
        !           391: int yydebug = 0; /* 1 for debugging */
        !           392: #endif
        !           393: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
        !           394: int yychar = -1; /* current input token number */
        !           395: int yynerrs = 0;  /* number of errors */
        !           396: short yyerrflag = 0;  /* error recovery flag */
        !           397: 
        !           398: yyparse()
        !           399: {      short yys[YYMAXDEPTH];
        !           400:        int yyj, yym;
        !           401:        register YYSTYPE *yypvt;
        !           402:        register int yystate, yyn;
        !           403:        register short *yyps;
        !           404:        register YYSTYPE *yypv;
        !           405:        register short *yyxi;
        !           406: 
        !           407:        yystate = 0;
        !           408:        yychar = -1;
        !           409:        yynerrs = 0;
        !           410:        yyerrflag = 0;
        !           411:        yyps= &yys[-1];
        !           412:        yypv= &yyv[-1];
        !           413: 
        !           414: yystack:    /* put a state and value onto the stack */
        !           415: #ifdef YYDEBUG
        !           416:        if(yydebug >= 3)
        !           417:                if(yychar < 0 || yytoknames[yychar] == 0)
        !           418:                        printf("char %d in %s", yychar, yystates[yystate]);
        !           419:                else
        !           420:                        printf("%s in %s", yytoknames[yychar], yystates[yystate]);
        !           421: #endif
        !           422:        if( ++yyps >= &yys[YYMAXDEPTH] ) { 
        !           423:                yyerror( "yacc stack overflow" ); 
        !           424:                return(1); 
        !           425:        }
        !           426:        *yyps = yystate;
        !           427:        ++yypv;
        !           428:        *yypv = yyval;
        !           429: yynewstate:
        !           430:        yyn = yypact[yystate];
        !           431:        if(yyn <= YYFLAG) goto yydefault; /* simple state */
        !           432:        if(yychar<0) {
        !           433:                yychar = yylex();
        !           434: #ifdef YYDEBUG
        !           435:                if(yydebug >= 2) {
        !           436:                        if(yychar <= 0)
        !           437:                                printf("lex EOF\n");
        !           438:                        else if(yytoknames[yychar])
        !           439:                                printf("lex %s\n", yytoknames[yychar]);
        !           440:                        else
        !           441:                                printf("lex (%c)\n", yychar);
        !           442:                }
        !           443: #endif
        !           444:                if(yychar < 0)
        !           445:                        yychar = 0;
        !           446:        }
        !           447:        if((yyn += yychar) < 0 || yyn >= YYLAST)
        !           448:                goto yydefault;
        !           449:        if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
        !           450:                yychar = -1;
        !           451:                yyval = yylval;
        !           452:                yystate = yyn;
        !           453:                if( yyerrflag > 0 ) --yyerrflag;
        !           454:                goto yystack;
        !           455:        }
        !           456: yydefault:
        !           457:        /* default state action */
        !           458:        if( (yyn=yydef[yystate]) == -2 ) {
        !           459:                if(yychar < 0) {
        !           460:                        yychar = yylex();
        !           461: #ifdef YYDEBUG
        !           462:                        if(yydebug >= 2)
        !           463:                                if(yychar < 0)
        !           464:                                        printf("lex EOF\n");
        !           465:                                else
        !           466:                                        printf("lex %s\n", yytoknames[yychar]);
        !           467: #endif
        !           468:                        if(yychar < 0)
        !           469:                                yychar = 0;
        !           470:                }
        !           471:                /* look through exception table */
        !           472:                for(yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate);
        !           473:                        yyxi += 2 ) ; /* VOID */
        !           474:                while( *(yyxi+=2) >= 0 ){
        !           475:                        if( *yyxi == yychar ) break;
        !           476:                }
        !           477:                if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
        !           478:        }
        !           479:        if( yyn == 0 ){ /* error */
        !           480:                /* error ... attempt to resume parsing */
        !           481:                switch( yyerrflag ){
        !           482:                case 0:   /* brand new error */
        !           483: #ifdef YYDEBUG
        !           484:                        yyerror("syntax error\n%s", yystates[yystate]);
        !           485:                        if(yytoknames[yychar])
        !           486:                                yyerror("saw %s\n", yytoknames[yychar]);
        !           487:                        else if(yychar >= ' ' && yychar < '\177')
        !           488:                                yyerror("saw `%c'\n", yychar);
        !           489:                        else if(yychar == 0)
        !           490:                                yyerror("saw EOF\n");
        !           491:                        else
        !           492:                                yyerror("saw char 0%o\n", yychar);
        !           493: #else
        !           494:                        yyerror( "syntax error" );
        !           495: #endif
        !           496: yyerrlab:
        !           497:                        ++yynerrs;
        !           498:                case 1:
        !           499:                case 2: /* incompletely recovered error ... try again */
        !           500:                        yyerrflag = 3;
        !           501:                        /* find a state where "error" is a legal shift action */
        !           502:                        while ( yyps >= yys ) {
        !           503:                                yyn = yypact[*yyps] + YYERRCODE;
        !           504:                                if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
        !           505:                                        yystate = yyact[yyn];  /* simulate a shift of "error" */
        !           506:                                        goto yystack;
        !           507:                                }
        !           508:                                yyn = yypact[*yyps];
        !           509:                                /* the current yyps has no shift onn "error", pop stack */
        !           510: #ifdef YYDEBUG
        !           511:                                if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
        !           512: #endif
        !           513:                                --yyps;
        !           514:                                --yypv;
        !           515:                        }
        !           516:                        /* there is no state on the stack with an error shift ... abort */
        !           517: yyabort:
        !           518:                        return(1);
        !           519:                case 3:  /* no shift yet; clobber input char */
        !           520: #ifdef YYDEBUG
        !           521:                        if( yydebug ) {
        !           522:                                printf("error recovery discards ");
        !           523:                                if(yytoknames[yychar])
        !           524:                                        printf("%s\n", yytoknames[yychar]);
        !           525:                                else if(yychar >= ' ' && yychar < '\177')
        !           526:                                        printf("`%c'\n", yychar);
        !           527:                                else if(yychar == 0)
        !           528:                                        printf("EOF\n");
        !           529:                                else
        !           530:                                        printf("char 0%o\n", yychar);
        !           531:                        }
        !           532: #endif
        !           533:                        if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
        !           534:                        yychar = -1;
        !           535:                        goto yynewstate;   /* try again in the same state */
        !           536:                }
        !           537:        }
        !           538:        /* reduction by production yyn */
        !           539: #ifdef YYDEBUG
        !           540:        if(yydebug) {   char *s;
        !           541:                printf("reduce %d in:\n\t", yyn);
        !           542:                for(s = yystates[yystate]; *s; s++) {
        !           543:                        putchar(*s);
        !           544:                        if(*s == '\n' && *(s+1))
        !           545:                                putchar('\t');
        !           546:                }
        !           547:        }
        !           548: #endif
        !           549:        yyps -= yyr2[yyn];
        !           550:        yypvt = yypv;
        !           551:        yypv -= yyr2[yyn];
        !           552:        yyval = yypv[1];
        !           553:        yym=yyn;
        !           554:        /* consult goto table to find next state */
        !           555:        yyn = yyr1[yyn];
        !           556:        yyj = yypgo[yyn] + *yyps + 1;
        !           557:        if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
        !           558:        switch(yym){
        !           559:                
        !           560: case 1:
        !           561: # line 42 "twig.y"
        !           562:  
        !           563:        { if (nerrors==0) machine_build(); } break;
        !           564: case 4:
        !           565: # line 48 "twig.y"
        !           566:  { SymbolEnterList (yypvt[-1].y_symp, A_NODE); } break;
        !           567: case 5:
        !           568: # line 51 "twig.y"
        !           569:  {
        !           570:                        SymbolEnterList(yypvt[-1].y_symp, A_NODE);
        !           571:                        SymbolCheckNodeValues();
        !           572:                } break;
        !           573: case 6:
        !           574: # line 56 "twig.y"
        !           575:  { SymbolEnterList (yypvt[-1].y_symp, A_CONST); } break;
        !           576: case 7:
        !           577: # line 58 "twig.y"
        !           578:  { SymbolEnterList (yypvt[-1].y_symp, A_LABEL); } break;
        !           579: case 8:
        !           580: # line 60 "twig.y"
        !           581:  { CodeWrite(outfile, yypvt[-1].y_code); CodeFreeBlock(yypvt[-1].y_code); } break;
        !           582: case 9:
        !           583: # line 63 "twig.y"
        !           584:  { yypvt[-2].y_symp->sd.ca.code = yypvt[-1].y_code; yypvt[-2].y_symp->sd.ca.assoc = NULL;
        !           585:                 SymbolEnter (yypvt[-2].y_symp, A_COST); } break;
        !           586: case 10:
        !           587: # line 67 "twig.y"
        !           588:  { yypvt[-2].y_symp->sd.ca.code = yypvt[-1].y_code; yypvt[-2].y_symp->sd.ca.assoc = NULL;
        !           589:                 SymbolEnter (yypvt[-2].y_symp, A_ACTION); } break;
        !           590: case 14:
        !           591: # line 83 "twig.y"
        !           592:  {
        !           593:                                if(CheckIsUndefined(yypvt[-0].y_symp)) {
        !           594:                                        yypvt[-0].y_symp->next = yypvt[-1].y_symp;
        !           595:                                        yyval.y_symp = yypvt[-0].y_symp;
        !           596:                                } else yyval.y_symp = yypvt[-1].y_symp;
        !           597:                        } break;
        !           598: case 15:
        !           599: # line 89 "twig.y"
        !           600: { if(CheckIsUndefined(yypvt[-0].y_symp)) yyval.y_symp = yypvt[-0].y_symp; else yyval.y_symp = NULL; } break;
        !           601: case 17:
        !           602: # line 97 "twig.y"
        !           603:  {
        !           604:                        if(yypvt[-0].y_symp->attr==A_ERROR)
        !           605:                                yyval.y_symp = yypvt[-1].y_symp;
        !           606:                        else { yypvt[-0].y_symp->next = yypvt[-1].y_symp; yyval.y_symp = yypvt[-0].y_symp; }
        !           607:                } break;
        !           608: case 18:
        !           609: # line 102 "twig.y"
        !           610: { yyval.y_symp = yypvt[-0].y_symp->attr==A_ERROR ? NULL : yypvt[-0].y_symp; } break;
        !           611: case 20:
        !           612: # line 106 "twig.y"
        !           613:  { 
        !           614:                                        if(yypvt[-0].y_symp->attr==A_ERROR) yyval.y_symp = yypvt[-1].y_symp;
        !           615:                                        else { yypvt[-0].y_symp->next = yypvt[-1].y_symp; yyval.y_symp = yypvt[-0].y_symp; }
        !           616:                                } break;
        !           617: case 21:
        !           618: # line 110 "twig.y"
        !           619: { yyval.y_symp = yypvt[-0].y_symp->attr==A_ERROR ? NULL : yypvt[-0].y_symp; } break;
        !           620: case 23:
        !           621: # line 114 "twig.y"
        !           622:  {
        !           623:                        if (CheckIsUndefined(yypvt[-1].y_symp)) {
        !           624:                                yypvt[-1].y_symp->sd.arity = yypvt[-0].y_int; yyval.y_symp = yypvt[-1].y_symp;
        !           625:                        } else yyval.y_symp = &ErrorSymbol;
        !           626:                } break;
        !           627: case 24:
        !           628: # line 121 "twig.y"
        !           629: {
        !           630:                                if(CheckIsUndefined(yypvt[-3].y_symp)) {
        !           631:                                        yypvt[-3].y_symp->unique = yypvt[-0].y_int; yypvt[-3].y_symp->sd.arity = yypvt[-2].y_int;
        !           632:                                        yyval.y_symp = yypvt[-3].y_symp;
        !           633:                                } else yyval.y_symp = &ErrorSymbol;
        !           634:                        } break;
        !           635: case 25:
        !           636: # line 129 "twig.y"
        !           637:  { yyval.y_int = yypvt[-1].y_int; } break;
        !           638: case 26:
        !           639: # line 130 "twig.y"
        !           640:  { yyval.y_int=GIVENUP; } break;
        !           641: case 27:
        !           642: # line 131 "twig.y"
        !           643:  { yyval.y_int = UNDEFINED; } break;
        !           644: case 28:
        !           645: # line 134 "twig.y"
        !           646:  {
        !           647:                                if (yypvt[-0].y_symp->attr==A_ERROR) yyval.y_symp = yypvt[-1].y_symp;
        !           648:                                else { yypvt[-0].y_symp->next = yypvt[-1].y_symp; yyval.y_symp = yypvt[-0].y_symp; }
        !           649:                        } break;
        !           650: case 29:
        !           651: # line 138 "twig.y"
        !           652: { yyval.y_symp = yypvt[-0].y_symp->attr==A_ERROR ? NULL : yypvt[-0].y_symp; } break;
        !           653: case 31:
        !           654: # line 142 "twig.y"
        !           655:  {
        !           656:                                if(CheckIsUndefined(yypvt[-2].y_symp)) {
        !           657:                                        yypvt[-2].y_symp->sd.cvalue = yypvt[-0].y_int; yyval.y_symp = yypvt[-2].y_symp;
        !           658:                                } else yyval.y_symp = &ErrorSymbol;
        !           659:                } break;
        !           660: case 33:
        !           661: # line 150 "twig.y"
        !           662:  {
        !           663:                if(!CheckIsDefined(yypvt[-0].y_symp)) yyval.y_int = UNDEFINED;
        !           664:                else if(yypvt[-0].y_symp->attr!=A_CONST) {
        !           665:                        sem_error("non-constant id used");
        !           666:                        yyval.y_int = -1;
        !           667:                } else yyval.y_int = yypvt[-0].y_symp->sd.cvalue;
        !           668:        } break;
        !           669: case 38:
        !           670: # line 164 "twig.y"
        !           671:  { epilogue = CodeAppend(epilogue, yypvt[-1].y_code); } break;
        !           672: case 40:
        !           673: # line 169 "twig.y"
        !           674:  {
        !           675:                    if (yypvt[-5].y_symp->attr==A_ERROR) {
        !           676:                        error(0, "\"label: tree\" pair ignored");
        !           677:                        TreeFree(yypvt[-3].y_nodep);
        !           678:                    } else {
        !           679:                        if(nerrors==0)
        !           680:                                cgotofn(SymbolEnterTreeIntoLabel(yypvt[-5].y_symp,
        !           681:                                        yypvt[-3].y_nodep, yypvt[-2].y_symp, yypvt[-1].y_symp, tree_lineno));
        !           682:                        if(debug_flag&DB_TREE)
        !           683:                                TreePrint(yypvt[-3].y_nodep, 1);
        !           684:                    }
        !           685:                } break;
        !           686: case 42:
        !           687: # line 183 "twig.y"
        !           688: { SymbolEntry *sp = SymbolAllocate (SymbolGenUnique());
        !           689:                sp->sd.ca.code = yypvt[-0].y_code; sp->sd.ca.assoc = NULL;
        !           690:                SymbolEnter(sp, A_ACTION); yyval.y_symp = sp; } break;
        !           691: case 43:
        !           692: # line 186 "twig.y"
        !           693: { if(CheckIsDefined(yypvt[-0].y_symp)) {
        !           694:                        if (yypvt[-0].y_symp->attr!=A_ACTION) {
        !           695:                                sem_error ("non action id: %s", yypvt[-0].y_symp->name);
        !           696:                                yyval.y_symp = &ErrorSymbol;
        !           697:                        } else yyval.y_symp = yypvt[-0].y_symp;
        !           698:                } else yyval.y_symp = &ErrorSymbol; } break;
        !           699: case 44:
        !           700: # line 192 "twig.y"
        !           701: { yyval.y_symp = NULL;} break;
        !           702: case 45:
        !           703: # line 194 "twig.y"
        !           704: { SymbolEntry *sp = SymbolAllocate (SymbolGenUnique());
        !           705:                sp->sd.ca.code = yypvt[-0].y_code; sp->sd.ca.assoc = NULL;
        !           706:                SymbolEnter (sp, A_COST); yyval.y_symp = sp;
        !           707:                } break;
        !           708: case 46:
        !           709: # line 198 "twig.y"
        !           710: { if (CheckIsDefined(yypvt[-0].y_symp)) {
        !           711:                        if (yypvt[-0].y_symp->attr!=A_COST) {
        !           712:                                sem_error ("non cost id: %s", yypvt[-0].y_symp->name);
        !           713:                                yyval.y_symp = &ErrorSymbol;
        !           714:                        } else yyval.y_symp = yypvt[-0].y_symp;
        !           715:                } else yyval.y_symp = &ErrorSymbol; } break;
        !           716: case 47:
        !           717: # line 204 "twig.y"
        !           718: { yyval.y_symp = NULL; } break;
        !           719: case 48:
        !           720: # line 207 "twig.y"
        !           721:  {
        !           722:                tree_lineno = yyline;   /* record line no */
        !           723:                if(!CheckIsDefined(yypvt[-0].y_symp))
        !           724:                        yypvt[-0].y_symp->attr = A_ERROR;
        !           725:                else if(!is_label(yypvt[-0].y_symp)) {
        !           726:                        sem_error("non label id: %s", yypvt[-0].y_symp->name);
        !           727:                        yypvt[-0].y_symp->attr = A_ERROR;
        !           728:                }
        !           729:                yyval.y_symp = yypvt[-0].y_symp;
        !           730:        } break;
        !           731: case 49:
        !           732: # line 218 "twig.y"
        !           733: {CheckIsNodeOrPred(yypvt[-0].y_symp);} break;
        !           734: case 50:
        !           735: # line 219 "twig.y"
        !           736:  {
        !           737:                int count;
        !           738:                Node *ap; 
        !           739:                /* check the arity of the node */
        !           740:                for(count=0, ap = yypvt[-1].y_nodep; ap!=NULL; ap=ap->siblings) count++;
        !           741:                switch(yypvt[-4].y_symp->attr) {
        !           742:                        case A_NODE:
        !           743:                                set_arity(yypvt[-4].y_symp, &yypvt[-4].y_symp->sd.arity, count);
        !           744:                                break;
        !           745:                }
        !           746: 
        !           747:                yyval.y_nodep = TreeBuild (yypvt[-4].y_symp, yypvt[-1].y_nodep);
        !           748:        } break;
        !           749: case 51:
        !           750: # line 233 "twig.y"
        !           751:  {
        !           752:                CheckIsDefined(yypvt[-0].y_symp);
        !           753:                switch (yypvt[-0].y_symp->attr) {
        !           754:                        case A_NODE:
        !           755:                                set_arity(yypvt[-0].y_symp, &yypvt[-0].y_symp->sd.arity, 0);
        !           756:                                break;
        !           757:                }
        !           758:                yyval.y_nodep = TreeBuild (yypvt[-0].y_symp, NULL);
        !           759:        } break;
        !           760: case 52:
        !           761: # line 243 "twig.y"
        !           762:  {
        !           763:                        /*
        !           764:                         * build sibling list in reverse order TreeBuild will
        !           765:                         * put it right later.
        !           766:                         */
        !           767:                        yypvt[-0].y_nodep->siblings = yypvt[-2].y_nodep;
        !           768:                        yyval.y_nodep = yypvt[-0].y_nodep;
        !           769:                } break;
        !           770: case 53:
        !           771: # line 251 "twig.y"
        !           772:  { yypvt[-0].y_nodep->siblings = NULL; yyval.y_nodep = yypvt[-0].y_nodep; } break;
        !           773: case 54:
        !           774: # line 252 "twig.y"
        !           775: { yyval.y_nodep = NULL; } break;
        !           776:        }
        !           777:        goto yystack;  /* stack new state and value */
        !           778: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.