Return to yyparse.c CVS log

Up to [MW Coherent from dump] / coherent / b / lib

Annotation of coherent/b/lib/yyparse.c, revision 1.1

1.1     ! root        1: #define        YYACTSH         13
        !             2: #define        YYAMASK         017777
        !             3: #define        YYSHIFTACT      0
        !             4: #define        YYREDACT        1
        !             5: #define        YYACCEPTACT     2
        !             6: #define        YYERRACT        3
        !             7: #define        YYGOTO          4
        !             8: #define        YYPACTION       5
        !             9: #define        YYEOFVAL        (-1)
        !            10: #define        YYERRVAL        (-2)
        !            11: #define        YYOTHERS        (-1000)
        !            12: 
        !            13: $D
        !            14: 
        !            15: #define YYNOCHAR (-1000)
        !            16: #define        yyerrok yyerrflag=0
        !            17: #define        yyclearin       yylval=YYNOCHAR
        !            18: int yystack[YYMAXDEPTH];
        !            19: YYSTYPE yyvstack[YYMAXDEPTH], *yyv;
        !            20: int yychar;
        !            21: 
        !            22: #ifdef YYDEBUG
        !            23: int yydebug = 1;       /* No sir, not in the BSS */
        !            24: #include <stdio.h>
        !            25: #endif
        !            26: 
        !            27: short yyerrflag;
        !            28: int *yys;
        !            29: 
        !            30: yyparse()
        !            31: {
        !            32:        register YYSTYPE *yypvt;
        !            33:        int act;
        !            34:        register unsigned *ip, yystate;
        !            35:        int pno;
        !            36:        yystate = 0;
        !            37:        yychar = YYNOCHAR;
        !            38:        yyv = &yyvstack[-1];
        !            39:        yys = &yystack[-1];
        !            40: 
        !            41: stack:
        !            42:        if( ++yys >= &yystack[YYMAXDEPTH] ) {
        !            43:                write(2, "Stack overflow\n", 15);
        !            44:                exit(1);
        !            45:        }
        !            46:        *yys = yystate;
        !            47:        *++yyv = yyval;
        !            48: #ifdef YYDEBUG
        !            49:        if( yydebug )
        !            50:                fprintf(stdout, "Stack state %d, char %d\n", yystate, yychar);
        !            51: #endif
        !            52: 
        !            53: read:
        !            54:        ip = &yyact[yypa[yystate]];
        !            55:        if( ip[1] != YYNOCHAR ) {
        !            56:                if( yychar == YYNOCHAR ) {
        !            57:                        yychar = yylex();
        !            58: #ifdef YYDEBUG
        !            59:                        if( yydebug )
        !            60:                                fprintf(stdout, "lex read char %d, val %d\n", yychar, yylval);
        !            61: #endif
        !            62:                }
        !            63:                while (ip[1]!=YYNOCHAR) {
        !            64:                        if (ip[1]==yychar)
        !            65:                                break;
        !            66:                        ip += 2;
        !            67:                }
        !            68:        }
        !            69:        act = ip[0];
        !            70:        switch( act>>YYACTSH ) {
        !            71:        case YYSHIFTACT:
        !            72:                if( ip[1]==YYNOCHAR )
        !            73:                        goto YYerract;
        !            74:                if( yychar != -1 )
        !            75:                        yychar = YYNOCHAR; /* dont throw away EOF */
        !            76:                yystate = act&YYAMASK;
        !            77:                yyval = yylval;
        !            78: #ifdef YYDEBUG
        !            79:                if( yydebug )
        !            80:                        fprintf(stdout, "shift %d\n", yystate);
        !            81: #endif
        !            82:                if( yyerrflag )
        !            83:                        --yyerrflag;
        !            84:                goto stack;
        !            85: 
        !            86:        case YYACCEPTACT:
        !            87: #ifdef YYDEBUG
        !            88:                if( yydebug )
        !            89:                        fprintf(stdout, "accept\n");
        !            90: #endif
        !            91:                return(0);
        !            92: 
        !            93:        case YYERRACT:
        !            94:        YYerract:
        !            95:                switch (yyerrflag) {
        !            96:                case 0:
        !            97:                        yyerror("Syntax error");
        !            98: 
        !            99:                case 1:
        !           100:                case 2:
        !           101: 
        !           102:                        yyerrflag = 3;
        !           103:                        while( yys >= & yystack[0] ) {
        !           104:                                ip = &yyact[yypa[*yys]];
        !           105:                                while( ip[1]!=YYNOCHAR )
        !           106:                                        ip += 2;
        !           107:                                if( (*ip&~YYAMASK) == (YYSHIFTACT<<YYACTSH) ) {
        !           108:                                        yystate = *ip&YYAMASK;
        !           109:                                        goto stack;
        !           110:                                }
        !           111: #ifdef YYDEBUG
        !           112:                                if( yydebug )
        !           113:                                        fprintf(stderr, "error recovery leaves state %d, uncovers %d\n", *yys, yys[-1]);
        !           114: #endif
        !           115:                                yys--;
        !           116:                                yyv--;
        !           117:                        }
        !           118: #ifdef YYDEBUG
        !           119:                        if( yydebug )
        !           120:                                fprintf(stderr, "no shift on error; abort\n");
        !           121: #endif
        !           122:                        return(1);
        !           123: 
        !           124:                case 3:
        !           125: #ifdef YYDEBUG
        !           126:                        if( yydebug )
        !           127:                                fprintf(stderr, "Error recovery clobbers char %o\n", yychar);
        !           128: #endif
        !           129:                        if( yychar==YYEOFVAL )
        !           130:                                return(1);
        !           131:                        yychar = YYNOCHAR;
        !           132:                        goto read;
        !           133:                }
        !           134: 
        !           135:        case YYREDACT:
        !           136:                pno = act&YYAMASK;
        !           137: #ifdef YYDEBUG
        !           138:                if( yydebug )
        !           139:                        fprintf(stdout, "reduce %d\n", pno);
        !           140: #endif
        !           141:                yypvt = yyv;
        !           142:                yyv -= yypn[pno];
        !           143:                yys -= yypn[pno];
        !           144:                yyval = yyv[1];
        !           145:                switch(pno) {
        !           146: $A
        !           147:                }
        !           148:                ip = &yygo[ yypgo[yypdnt[pno]] ];
        !           149:                while( *ip!=*yys && *ip!=YYNOCHAR )
        !           150:                        ip += 2;
        !           151:                yystate = ip[1];
        !           152:                goto stack;
        !           153:        }
        !           154: }
        !           155: 
        !           156: 
        !           157: 
        !           158: 

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