sys/lib/yaccpars

   1 #define YYFLAG          -1000
   2 #define YYERROR         goto yyerrlab
   3 #define YYACCEPT        return(0)
   4 #define YYABORT         return(1)
   5 #define yyclearin       yychar = -1
   6 #define yyerrok         yyerrflag = 0
   7
   8 #ifdef  yydebug
   9 #include        "y.debug"
  10 #else
  11 #define yydebug         0
  12 char*   yytoknames[1];          /* for debugging */
  13 char*   yystates[1];            /* for debugging */
  14 #endif
  15
  16 /*      parser for yacc output  */
  17
  18 int     yynerrs = 0;            /* number of errors */
  19 int     yyerrflag = 0;          /* error recovery flag */
  20
  21 char*
  22 yytokname(int yyc)
  23 {
  24         static char x[16];
  25
  26         if(yyc > 0 && yyc <= sizeof(yytoknames)/sizeof(yytoknames[0]))
  27         if(yytoknames[yyc-1])
  28                 return yytoknames[yyc-1];
  29         sprintf(x, "<%d>", yyc);
  30         return x;
  31 }
  32
  33 char*
  34 yystatname(int yys)
  35 {
  36         static char x[16];
  37
  38         if(yys >= 0 && yys < sizeof(yystates)/sizeof(yystates[0]))
  39         if(yystates[yys])
  40                 return yystates[yys];
  41         sprintf(x, "<%d>\n", yys);
  42         return x;
  43 }
  44
  45 long
  46 yylex1(void)
  47 {
  48         long yychar;
  49         long *t3p;
  50         int c;
  51
  52         yychar = yylex();
  53         if(yychar <= 0) {
  54                 c = yytok1[0];
  55                 goto out;
  56         }
  57         if(yychar < sizeof(yytok1)/sizeof(yytok1[0])) {
  58                 c = yytok1[yychar];
  59                 goto out;
  60         }
  61         if(yychar >= YYPRIVATE)
  62                 if(yychar < YYPRIVATE+sizeof(yytok2)/sizeof(yytok2[0])) {
  63                         c = yytok2[yychar-YYPRIVATE];
  64                         goto out;
  65                 }
  66         for(t3p=yytok3;; t3p+=2) {
  67                 c = t3p[0];
  68                 if(c == yychar) {
  69                         c = t3p[1];
  70                         goto out;
  71                 }
  72                 if(c == 0)
  73                         break;
  74         }
  75         c = 0;
  76
  77 out:
  78         if(c == 0)
  79                 c = yytok2[1];  /* unknown char */
  80         if(yydebug >= 3)
  81                 printf("lex %.4lX %s\n", yychar, yytokname(c));
  82         return c;
  83 }
  84
  85 int
  86 yyparse(void)
  87 {
  88         struct
  89         {
  90                 YYSTYPE yyv;
  91                 int     yys;
  92         } yys[YYMAXDEPTH], *yyp, *yypt;
  93         short *yyxi;
  94         int yyj, yym, yystate, yyn, yyg;
  95         YYSTYPE save1, save2;
  96         int save3, save4;
  97         long yychar;
  98
  99         save1 = yylval;
 100         save2 = yyval;
 101         save3 = yynerrs;
 102         save4 = yyerrflag;
 103
 104         yystate = 0;
 105         yychar = -1;
 106         yynerrs = 0;
 107         yyerrflag = 0;
 108         yyp = &yys[-1];
 109         goto yystack;
 110
 111 ret0:
 112         yyn = 0;
 113         goto ret;
 114
 115 ret1:
 116         yyn = 1;
 117         goto ret;
 118
 119 ret:
 120         yylval = save1;
 121         yyval = save2;
 122         yynerrs = save3;
 123         yyerrflag = save4;
 124         return yyn;
 125
 126 yystack:
 127         /* put a state and value onto the stack */
 128         if(yydebug >= 4)
 129                 printf("char %s in %s", yytokname(yychar), yystatname(yystate));
 130
 131         yyp++;
 132         if(yyp >= &yys[YYMAXDEPTH]) {
 133                 yyerror("yacc stack overflow");
 134                 goto ret1;
 135         }
 136         yyp->yys = yystate;
 137         yyp->yyv = yyval;
 138
 139 yynewstate:
 140         yyn = yypact[yystate];
 141         if(yyn <= YYFLAG)
 142                 goto yydefault; /* simple state */
 143         if(yychar < 0)
 144                 yychar = yylex1();
 145         yyn += yychar;
 146         if(yyn < 0 || yyn >= YYLAST)
 147                 goto yydefault;
 148         yyn = yyact[yyn];
 149         if(yychk[yyn] == yychar) { /* valid shift */
 150                 yychar = -1;
 151                 yyval = yylval;
 152                 yystate = yyn;
 153                 if(yyerrflag > 0)
 154                         yyerrflag--;
 155                 goto yystack;
 156         }
 157
 158 yydefault:
 159         /* default state action */
 160         yyn = yydef[yystate];
 161         if(yyn == -2) {
 162                 if(yychar < 0)
 163                         yychar = yylex1();
 164
 165                 /* look through exception table */
 166                 for(yyxi=yyexca;; yyxi+=2)
 167                         if(yyxi[0] == -1 && yyxi[1] == yystate)
 168                                 break;
 169                 for(yyxi += 2;; yyxi += 2) {
 170                         yyn = yyxi[0];
 171                         if(yyn < 0 || yyn == yychar)
 172                                 break;
 173                 }
 174                 yyn = yyxi[1];
 175                 if(yyn < 0)
 176                         goto ret0;
 177         }
 178         if(yyn == 0) {
 179                 /* error ... attempt to resume parsing */
 180                 switch(yyerrflag) {
 181                 case 0:   /* brand new error */
 182                         yyerror("syntax error");
 183                         if(yydebug >= 1) {
 184                                 printf("%s", yystatname(yystate));
 185                                 printf("saw %s\n", yytokname(yychar));
 186                         }
 187 yyerrlab:
 188                         yynerrs++;
 189
 190                 case 1:
 191                 case 2: /* incompletely recovered error ... try again */
 192                         yyerrflag = 3;
 193
 194                         /* find a state where "error" is a legal shift action */
 195                         while(yyp >= yys) {
 196                                 yyn = yypact[yyp->yys] + YYERRCODE;
 197                                 if(yyn >= 0 && yyn < YYLAST) {
 198                                         yystate = yyact[yyn];  /* simulate a shift of "error" */
 199                                         if(yychk[yystate] == YYERRCODE)
 200                                                 goto yystack;
 201                                 }
 202
 203                                 /* the current yyp has no shift onn "error", pop stack */
 204                                 if(yydebug >= 2)
 205                                         printf("error recovery pops state %d, uncovers %d\n",
 206                                                 yyp->yys, (yyp-1)->yys );
 207                                 yyp--;
 208                         }
 209                         /* there is no state on the stack with an error shift ... abort */
 210                         goto ret1;
 211
 212                 case 3:  /* no shift yet; clobber input char */
 213                         if(yydebug >= YYEOFCODE)
 214                                 printf("error recovery discards %s\n", yytokname(yychar));
 215                         if(yychar == YYEOFCODE)
 216                                 goto ret1;
 217                         yychar = -1;
 218                         goto yynewstate;   /* try again in the same state */
 219                 }
 220         }
 221
 222         /* reduction by production yyn */
 223         if(yydebug >= 2)
 224                 printf("reduce %d in:\n\t%s", yyn, yystatname(yystate));
 225
 226         yypt = yyp;
 227         yyp -= yyr2[yyn];
 228         yyval = (yyp+1)->yyv;
 229         yym = yyn;
 230
 231         /* consult goto table to find next state */
 232         yyn = yyr1[yyn];
 233         yyg = yypgo[yyn];
 234         yyj = yyg + yyp->yys + 1;
 235
 236         if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
 237                 yystate = yyact[yyg];
 238         switch(yym) {
 239                 $A
 240         }
 241         goto yystack;  /* stack new state and value */
 242 }