Return to bison.hairy CVS log

Up to [Apple XNU] / GNUtools / bison

Annotation of GNUtools/bison/bison.hairy, revision 1.1

1.1     ! root        1: 
        !             2: extern int timeclock;
        !             3: 
        !             4: 
        !             5: int yyerror;           /*  Yyerror and yycost are set by guards.       */
        !             6: int yycost;            /*  If yyerror is set to a nonzero value by a   */
        !             7:                        /*  guard, the reduction with which the guard   */
        !             8:                        /*  is associated is not performed, and the     */
        !             9:                        /*  error recovery mechanism is invoked.        */
        !            10:                        /*  Yycost indicates the cost of performing     */
        !            11:                        /*  the reduction given the attributes of the   */
        !            12:                        /*  symbols.                                    */
        !            13: 
        !            14: 
        !            15: /*  YYMAXDEPTH indicates the size of the parser's state and value      */
        !            16: /*  stacks.                                                            */
        !            17: 
        !            18: #ifndef        YYMAXDEPTH
        !            19: #define        YYMAXDEPTH      500
        !            20: #endif
        !            21: 
        !            22: /*  YYMAXRULES must be at least as large as the number of rules that   */
        !            23: /*  could be placed in the rule queue.  That number could be determined        */
        !            24: /*  from the grammar and the size of the stack, but, as yet, it is not.        */
        !            25: 
        !            26: #ifndef        YYMAXRULES
        !            27: #define        YYMAXRULES      100
        !            28: #endif
        !            29: 
        !            30: #ifndef        YYMAXBACKUP
        !            31: #define YYMAXBACKUP    100
        !            32: #endif
        !            33: 
        !            34: 
        !            35: short  yyss[YYMAXDEPTH];       /*  the state stack                     */
        !            36: YYSTYPE        yyvs[YYMAXDEPTH];       /*  the semantic value stack            */
        !            37: YYLTYPE yyls[YYMAXDEPTH];      /*  the location stack                  */
        !            38: short  yyrq[YYMAXRULES];       /*  the rule queue                      */
        !            39: int    yychar;                 /*  the lookahead symbol                */
        !            40: 
        !            41: YYSTYPE        yylval;                 /*  the semantic value of the           */
        !            42:                                /*  lookahead symbol                    */
        !            43: 
        !            44: YYSTYPE yytval;                        /*  the semantic value for the state    */
        !            45:                                /*  at the top of the state stack.      */
        !            46: 
        !            47: YYSTYPE yyval;                 /*  the variable used to return         */
        !            48:                                /*  semantic values from the action     */
        !            49:                                /*  routines                            */
        !            50: 
        !            51: YYLTYPE yylloc;                /*  location data for the lookahead     */
        !            52:                                /*  symbol                              */
        !            53: 
        !            54: YYLTYPE yytloc;                /*  location data for the state at the  */
        !            55:                                /*  top of the state stack              */
        !            56: 
        !            57: 
        !            58: int    yynunlexed;
        !            59: short  yyunchar[YYMAXBACKUP];
        !            60: YYSTYPE        yyunval[YYMAXBACKUP];
        !            61: YYLTYPE yyunloc[YYMAXBACKUP];
        !            62: 
        !            63: short *yygssp;                 /*  a pointer to the top of the state   */
        !            64:                                /*  stack; only set during error        */
        !            65:                                /*  recovery.                           */
        !            66: 
        !            67: YYSTYPE *yygvsp;               /*  a pointer to the top of the value   */
        !            68:                                /*  stack; only set during error        */
        !            69:                                /*  recovery.                           */
        !            70: 
        !            71: YYLTYPE *yyglsp;               /*  a pointer to the top of the         */
        !            72:                                /*  location stack; only set during     */
        !            73:                                /*  error recovery.                     */
        !            74: 
        !            75: 
        !            76: /*  Yyget is an interface between the parser and the lexical analyzer. */
        !            77: /*  It is costly to provide such an interface, but it avoids requiring */
        !            78: /*  the lexical analyzer to be able to back up the scan.               */
        !            79: 
        !            80: yyget()
        !            81: {
        !            82:   if (yynunlexed > 0)
        !            83:     {
        !            84:       yynunlexed--;
        !            85:       yychar = yyunchar[yynunlexed];
        !            86:       yylval = yyunval[yynunlexed];
        !            87:       yylloc = yyunloc[yynunlexed];
        !            88:     }
        !            89:   else if (yychar <= 0)
        !            90:     yychar = 0;
        !            91:   else
        !            92:     {
        !            93:       yychar = yylex();
        !            94:       if (yychar < 0)
        !            95:        yychar = 0;
        !            96:       else yychar = YYTRANSLATE(yychar);
        !            97:     }
        !            98: }
        !            99: 
        !           100: 
        !           101: 
        !           102: yyunlex(chr, val, loc)
        !           103: int chr;
        !           104: YYSTYPE val;
        !           105: YYLTYPE loc;
        !           106: {
        !           107:   yyunchar[yynunlexed] = chr;
        !           108:   yyunval[yynunlexed] = val;
        !           109:   yyunloc[yynunlexed] = loc;
        !           110:   yynunlexed++;
        !           111: }
        !           112: 
        !           113: 
        !           114: 
        !           115: yyrestore(first, last)
        !           116: register short *first;
        !           117: register short *last;
        !           118: {
        !           119:   register short *ssp;
        !           120:   register short *rp;
        !           121:   register int symbol;
        !           122:   register int state;
        !           123:   register int tvalsaved;
        !           124: 
        !           125:   ssp = yygssp;
        !           126:   yyunlex(yychar, yylval, yylloc);
        !           127: 
        !           128:   tvalsaved = 0;
        !           129:   while (first != last)
        !           130:     {
        !           131:       symbol = yystos[*ssp];
        !           132:       if (symbol < YYNTBASE)
        !           133:        {
        !           134:          yyunlex(symbol, yytval, yytloc);
        !           135:          tvalsaved = 1;
        !           136:          ssp--;
        !           137:        }
        !           138: 
        !           139:       ssp--;
        !           140: 
        !           141:       if (first == yyrq)
        !           142:        first = yyrq + YYMAXRULES;
        !           143: 
        !           144:       first--;
        !           145: 
        !           146:       for (rp = yyrhs + yyprhs[*first]; symbol = *rp; rp++)
        !           147:        {
        !           148:          if (symbol < YYNTBASE)
        !           149:            state = yytable[yypact[*ssp] + symbol];
        !           150:          else
        !           151:            {
        !           152:              state = yypgoto[symbol - YYNTBASE] + *ssp;
        !           153: 
        !           154:              if (state >= 0 && state <= YYLAST && yycheck[state] == *ssp)
        !           155:                state = yytable[state];
        !           156:              else
        !           157:                state = yydefgoto[symbol - YYNTBASE];
        !           158:            }
        !           159: 
        !           160:          *++ssp = state;
        !           161:        }
        !           162:     }
        !           163: 
        !           164:   if ( ! tvalsaved && ssp > yyss)
        !           165:     {
        !           166:       yyunlex(yystos[*ssp], yytval, yytloc);
        !           167:       ssp--;
        !           168:     }
        !           169: 
        !           170:   yygssp = ssp;
        !           171: }
        !           172: 
        !           173: 
        !           174: 
        !           175: int
        !           176: yyparse()
        !           177: {
        !           178:   register int yystate;
        !           179:   register int yyn;
        !           180:   register short *yyssp;
        !           181:   register short *yyrq0;
        !           182:   register short *yyptr;
        !           183:   register YYSTYPE *yyvsp;
        !           184: 
        !           185:   int yylen;
        !           186:   YYLTYPE *yylsp;
        !           187:   short *yyrq1;
        !           188:   short *yyrq2;
        !           189: 
        !           190:   yystate = 0;
        !           191:   yyssp = yyss - 1;
        !           192:   yyvsp = yyvs - 1;
        !           193:   yylsp = yyls - 1;
        !           194:   yyrq0 = yyrq;
        !           195:   yyrq1 = yyrq0;
        !           196:   yyrq2 = yyrq0;
        !           197: 
        !           198:   yychar = yylex();
        !           199:   if (yychar < 0)
        !           200:     yychar = 0;
        !           201:   else yychar = YYTRANSLATE(yychar);
        !           202: 
        !           203: yynewstate:
        !           204: 
        !           205:   if (yyssp >= yyss + YYMAXDEPTH - 1)
        !           206:     {
        !           207:       yyabort("Parser Stack Overflow");
        !           208:       YYABORT;
        !           209:     }
        !           210: 
        !           211:   *++yyssp = yystate;
        !           212: 
        !           213: yyresume:
        !           214: 
        !           215:   yyn = yypact[yystate];
        !           216:   if (yyn == YYFLAG)
        !           217:     goto yydefault;
        !           218: 
        !           219:   yyn += yychar;
        !           220:   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar)
        !           221:     goto yydefault;
        !           222: 
        !           223:   yyn = yytable[yyn];
        !           224:   if (yyn < 0)
        !           225:     {
        !           226:       yyn = -yyn;
        !           227:       goto yyreduce;
        !           228:     }
        !           229:   else if (yyn == 0)
        !           230:     goto yyerrlab;
        !           231: 
        !           232:   yystate = yyn;
        !           233: 
        !           234:   yyptr = yyrq2;
        !           235:   while (yyptr != yyrq1)
        !           236:     {
        !           237:       yyn = *yyptr++;
        !           238:       yylen = yyr2[yyn];
        !           239:       yyvsp -= yylen;
        !           240:       yylsp -= yylen;
        !           241: 
        !           242:       yyguard(yyn, yyvsp, yylsp);
        !           243:       if (yyerror)
        !           244:        goto yysemerr;
        !           245: 
        !           246:       yyaction(yyn, yyvsp, yylsp);
        !           247:       *++yyvsp = yyval;
        !           248: 
        !           249:       yylsp++;
        !           250:       if (yylen == 0)
        !           251:        {
        !           252:          yylsp->timestamp = timeclock;
        !           253:          yylsp->first_line = yytloc.first_line;
        !           254:          yylsp->first_column = yytloc.first_column;
        !           255:          yylsp->last_line = (yylsp-1)->last_line;
        !           256:          yylsp->last_column = (yylsp-1)->last_column;
        !           257:          yylsp->text = 0;
        !           258:        }
        !           259:       else
        !           260:        {
        !           261:          yylsp->last_line = (yylsp+yylen-1)->last_line;
        !           262:          yylsp->last_column = (yylsp+yylen-1)->last_column;
        !           263:        }
        !           264:          
        !           265:       if (yyptr == yyrq + YYMAXRULES)
        !           266:         yyptr = yyrq;
        !           267:     }
        !           268: 
        !           269:   if (yystate == YYFINAL)
        !           270:     YYACCEPT;
        !           271: 
        !           272:   yyrq2 = yyptr;
        !           273:   yyrq1 = yyrq0;
        !           274: 
        !           275:   *++yyvsp = yytval;
        !           276:   *++yylsp = yytloc;
        !           277:   yytval = yylval;
        !           278:   yytloc = yylloc;
        !           279:   yyget();
        !           280: 
        !           281:   goto yynewstate;
        !           282: 
        !           283: yydefault:
        !           284: 
        !           285:   yyn = yydefact[yystate];
        !           286:   if (yyn == 0)
        !           287:     goto yyerrlab;
        !           288: 
        !           289: yyreduce:
        !           290: 
        !           291:   *yyrq0++ = yyn;
        !           292: 
        !           293:   if (yyrq0 == yyrq + YYMAXRULES)
        !           294:     yyrq0 = yyrq;
        !           295: 
        !           296:   if (yyrq0 == yyrq2)
        !           297:     {
        !           298:       yyabort("Parser Rule Queue Overflow");
        !           299:       YYABORT;
        !           300:     }
        !           301: 
        !           302:   yyssp -= yyr2[yyn];
        !           303:   yyn = yyr1[yyn];
        !           304: 
        !           305:   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
        !           306:   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
        !           307:     yystate = yytable[yystate];
        !           308:   else
        !           309:     yystate = yydefgoto[yyn - YYNTBASE];
        !           310: 
        !           311:   goto yynewstate;
        !           312: 
        !           313: yysemerr:
        !           314:   *--yyptr = yyn;
        !           315:   yyrq2 = yyptr;
        !           316:   yyvsp += yyr2[yyn];
        !           317: 
        !           318: yyerrlab:
        !           319: 
        !           320:   yygssp = yyssp;
        !           321:   yygvsp = yyvsp;
        !           322:   yyglsp = yylsp;
        !           323:   yyrestore(yyrq0, yyrq2);
        !           324:   yyrecover();
        !           325:   yystate = *yygssp;
        !           326:   yyssp = yygssp;
        !           327:   yyvsp = yygvsp;
        !           328:   yyrq0 = yyrq;
        !           329:   yyrq1 = yyrq0;
        !           330:   yyrq2 = yyrq0;
        !           331:   goto yyresume;
        !           332: }
        !           333: 
        !           334: $

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