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