Return to yyparse.c CVS log

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

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

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

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