home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Programmer's Library 1.3 / Microsoft-Programers-Library-v1.3.iso / sampcode / alde_c / misc / comm / yaccunx / yypars.c < prev    next >
Encoding:
C/C++ Source or Header  |  1983-12-26  |  3.9 KB  |  163 lines
  1. # define YYFLAG -1000
  2. # define YYERROR goto yyerrlab
  3. # define YYACCEPT return(0)
  4. # define YYABORT return(1)
  5.  
  6. /*      parser for yacc output  */
  7.  
  8. int yydebug = 0; /* 1 for debugging */
  9. YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
  10. int yychar = -1; /* current input token number */
  11. int yynerrs = 0;  /* number of errors */
  12. short yyerrflag = 0;  /* error recovery flag */
  13.  
  14. yyparse()
  15.    {
  16.  
  17.    short yys[YYMAXDEPTH];
  18.    short yyj, yym;
  19.    register YYSTYPE *yypvt;
  20.    register short yystate, *yyps, yyn;
  21.    register YYSTYPE *yypv;
  22.    register short *yyxi;
  23.  
  24.    yystate = 0;
  25.    yychar = -1;
  26.    yynerrs = 0;
  27.    yyerrflag = 0;
  28.    yyps= &yys[-1];
  29.    yypv= &yyv[-1];
  30.  
  31. yystack:    /* put a state and value onto the stack */
  32.  
  33.    if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
  34.    if( ++yyps> &yys[YYMAXDEPTH] )
  35.       {
  36.       yyerror( "yacc stack overflow" );
  37.       return(1);
  38.       }
  39.    *yyps = yystate;
  40.    ++yypv;
  41. #ifdef UNION
  42.    yyunion(yypv, &yyval);
  43. #else
  44.    *yypv = yyval;
  45. #endif
  46. yynewstate:
  47.  
  48.    yyn = yypact[yystate];
  49.  
  50.    if( yyn<= YYFLAG ) goto yydefault; /* simple state */
  51.  
  52.    if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
  53.    if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
  54.  
  55.    if( yychk[ yyn=yyact[ yyn ] ] == yychar )
  56.       {
  57.       /* valid shift */
  58.       yychar = -1;
  59. #ifdef UNION
  60.       yyunion(&yyval, &yylval);
  61. #else
  62.       yyval = yylval;
  63. #endif
  64.       yystate = yyn;
  65.       if( yyerrflag > 0 ) --yyerrflag;
  66.       goto yystack;
  67.       }
  68. yydefault:
  69.    /* default state action */
  70.  
  71.    if( (yyn=yydef[yystate]) == -2 )
  72.       {
  73.       if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
  74.       /* look through exception table */
  75.  
  76.       for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
  77.  
  78.       for(yyxi+=2; *yyxi >= 0; yyxi+=2)
  79.          {
  80.          if( *yyxi == yychar ) break;
  81.          }
  82.       if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
  83.       }
  84.  
  85.    if( yyn == 0 )
  86.       {
  87.       /* error */
  88.       /* error ... attempt to resume parsing */
  89.  
  90.       switch( yyerrflag )
  91.          {
  92.  
  93.       case 0:   /* brand new error */
  94.  
  95.          yyerror( "syntax error" );
  96. yyerrlab:
  97.          ++yynerrs;
  98.  
  99.       case 1:
  100.       case 2: /* incompletely recovered error ... try again */
  101.  
  102.          yyerrflag = 3;
  103.  
  104.          /* find a state where "error" is a legal shift action */
  105.  
  106.          while ( yyps >= yys )
  107.             {
  108.             yyn = yypact[*yyps] + YYERRCODE;
  109.             if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE )
  110.                {
  111.                yystate = yyact[yyn];  /* simulate a shift of "error" */
  112.                goto yystack;
  113.                }
  114.             yyn = yypact[*yyps];
  115.  
  116.             /* the current yyps has no shift onn "error", pop stack */
  117.  
  118.             if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
  119.             --yyps;
  120.             --yypv;
  121.             }
  122.  
  123.          /* there is no state on the stack with an error shift ... abort */
  124.  
  125. yyabort:
  126.          return(1);
  127.  
  128.  
  129.       case 3:  /* no shift yet; clobber input char */
  130.          if( yydebug ) printf( "error recovery discards char %d\n", yychar );
  131.  
  132.          if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
  133.          yychar = -1;
  134.          goto yynewstate;   /* try again in the same state */
  135.  
  136.          }
  137.  
  138.       }
  139.  
  140.    /* reduction by production yyn */
  141.  
  142.    if( yydebug ) printf("reduce %d\n",yyn);
  143.    yyps -= yyr2[yyn];
  144.    yypvt = yypv;
  145.    yypv -= yyr2[yyn];
  146. #ifdef UNION
  147.    yyunion(&yyval, &yypv[1]);
  148. #else
  149.    yyval = yypv[1];
  150. #endif
  151.    yym=yyn;
  152.    /* consult goto table to find next state */
  153.    yyn = yyr1[yyn];
  154.    yyj = yypgo[yyn] + *yyps + 1;
  155.    if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
  156.    switch(yym)
  157.       {
  158.       $A
  159.       }
  160.    goto yystack;  /* stack new state and value */
  161.  
  162.    }
  163.