sys/lib/yaccpar

   1 #define YYFLAG          -1000
   2 #define yyclearin       yychar = -1
   3 #define yyerrok         yyerrflag = 0
   4
   5 #ifdef  yydebug
   6 #include        "y.debug"
   7 #else
   8 #define yydebug         0
   9 char*   yytoknames[1];          /* for debugging */
  10 char*   yystates[1];            /* for debugging */
  11 #endif
  12
  13 /*      parser for yacc output  */
  14
  15 int     yynerrs = 0;            /* number of errors */
  16 int     yyerrflag = 0;          /* error recovery flag */
  17
  18 extern  int     fprint(int, char*, ...);
  19 extern  int     sprint(char*, char*, ...);
  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         sprint(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         sprint(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                 fprint(2, "lex %.4lux %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         long yychar;
  96         YYSTYPE save1, save2;
  97         int save3, save4;
  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                 fprint(2, "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                         yynerrs++;
 184                         if(yydebug >= 1) {
 185                                 fprint(2, "%s", yystatname(yystate));
 186                                 fprint(2, "saw %s\n", yytokname(yychar));
 187                         }
 188
 189                 case 1:
 190                 case 2: /* incompletely recovered error ... try again */
 191                         yyerrflag = 3;
 192
 193                         /* find a state where "error" is a legal shift action */
 194                         while(yyp >= yys) {
 195                                 yyn = yypact[yyp->yys] + YYERRCODE;
 196                                 if(yyn >= 0 && yyn < YYLAST) {
 197                                         yystate = yyact[yyn];  /* simulate a shift of "error" */
 198                                         if(yychk[yystate] == YYERRCODE)
 199                                                 goto yystack;
 200                                 }
 201
 202                                 /* the current yyp has no shift onn "error", pop stack */
 203                                 if(yydebug >= 2)
 204                                         fprint(2, "error recovery pops state %d, uncovers %d\n",
 205                                                 yyp->yys, (yyp-1)->yys );
 206                                 yyp--;
 207                         }
 208                         /* there is no state on the stack with an error shift ... abort */
 209                         goto ret1;
 210
 211                 case 3:  /* no shift yet; clobber input char */
 212                         if(yydebug >= 2)
 213                                 fprint(2, "error recovery discards %s\n", yytokname(yychar));
 214                         if(yychar == YYEOFCODE)
 215                                 goto ret1;
 216                         yychar = -1;
 217                         goto yynewstate;   /* try again in the same state */
 218                 }
 219         }
 220
 221         /* reduction by production yyn */
 222         if(yydebug >= 2)
 223                 fprint(2, "reduce %d in:\n\t%s", yyn, yystatname(yystate));
 224
 225         yypt = yyp;
 226         yyp -= yyr2[yyn];
 227         yyval = (yyp+1)->yyv;
 228         yym = yyn;
 229
 230         /* consult goto table to find next state */
 231         yyn = yyr1[yyn];
 232         yyg = yypgo[yyn];
 233         yyj = yyg + yyp->yys + 1;
 234
 235         if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
 236                 yystate = yyact[yyg];
 237         switch(yym) {
 238                 $A
 239         }
 240         goto yystack;  /* stack new state and value */
 241 }