int
yyparse(void)
{
struct
{
YYSTYPE yyv;
int yys;
} yys[YYMAXDEPTH], *yyp, *yypt;
short *yyxi;
int yyj, yym, yystate, yyn, yyg;
long yychar;
YYSTYPE save1, save2;
int save3, save4;
save1 = yylval;
save2 = yyval;
save3 = yynerrs;
save4 = yyerrflag;
yystate = 0;
yychar = -1;
yynerrs = 0;
yyerrflag = 0;
yyp = &yys[-1];
goto yystack;
ret0:
yyn = 0;
goto ret;
ret1:
yyn = 1;
goto ret;
ret:
yylval = save1;
yyval = save2;
yynerrs = save3;
yyerrflag = save4;
return yyn;
yystack:
/* put a state and value onto the stack */
if(yydebug >= 4)
fprint(2, "char %s in %s", yytokname(yychar), yystatname(yystate));
yyp++;
if(yyp >= &yys[YYMAXDEPTH]) {
yyerror("yacc stack overflow");
goto ret1;
}
yyp->yys = yystate;
yyp->yyv = yyval;
yynewstate:
yyn = yypact[yystate];
if(yyn <= YYFLAG)
goto yydefault; /* simple state */
if(yychar < 0)
yychar = yylex1();
yyn += yychar;
if(yyn < 0 || yyn >= YYLAST)
goto yydefault;
yyn = yyact[yyn];
if(yychk[yyn] == yychar) { /* valid shift */
yychar = -1;
yyval = yylval;
yystate = yyn;
if(yyerrflag > 0)
yyerrflag--;
goto yystack;
}
yydefault:
/* default state action */
yyn = yydef[yystate];
if(yyn == -2) {
if(yychar < 0)
yychar = yylex1();
/* look through exception table */
for(yyxi=yyexca;; yyxi+=2)
if(yyxi[0] == -1 && yyxi[1] == yystate)
break;
for(yyxi += 2;; yyxi += 2) {
yyn = yyxi[0];
if(yyn < 0 || yyn == yychar)
break;
}
yyn = yyxi[1];
if(yyn < 0)
goto ret0;
}
if(yyn == 0) {
/* error ... attempt to resume parsing */
switch(yyerrflag) {
case 0: /* brand new error */
yyerror("syntax error");
yynerrs++;
if(yydebug >= 1) {
fprint(2, "%s", yystatname(yystate));
fprint(2, "saw %s\n", yytokname(yychar));
}
case 1:
case 2: /* incompletely recovered error ... try again */
yyerrflag = 3;
/* find a state where "error" is a legal shift action */
while(yyp >= yys) {
yyn = yypact[yyp->yys] + YYERRCODE;
if(yyn >= 0 && yyn < YYLAST) {
yystate = yyact[yyn]; /* simulate a shift of "error" */
if(yychk[yystate] == YYERRCODE)
goto yystack;
}
/* the current yyp has no shift onn "error", pop stack */
if(yydebug >= 2)
fprint(2, "error recovery pops state %d, uncovers %d\n",
yyp->yys, (yyp-1)->yys );
yyp--;
}
/* there is no state on the stack with an error shift ... abort */
goto ret1;
case 3: /* no shift yet; clobber input char */
if(yydebug >= 2)
fprint(2, "error recovery discards %s\n", yytokname(yychar));
if(yychar == YYEOFCODE)
goto ret1;
yychar = -1;
goto yynewstate; /* try again in the same state */
}
}
/* reduction by production yyn */
if(yydebug >= 2)
fprint(2, "reduce %d in:\n\t%s", yyn, yystatname(yystate));
yypt = yyp;
yyp -= yyr2[yyn];
yyval = (yyp+1)->yyv;
yym = yyn;
/* consult goto table to find next state */
yyn = yyr1[yyn];
yyg = yypgo[yyn];
yyj = yyg + yyp->yys + 1;
if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
yystate = yyact[yyg];
switch(yym) {
case 3:
#line 40 "a.y"
{
if(yypt[-1].yyv.sym->value != pc)
yyerror("redeclaration of %s", yypt[-1].yyv.sym->name);
yypt[-1].yyv.sym->value = pc;
} break;
case 5:
#line 47 "a.y"
{
yypt[-1].yyv.sym->type = LLAB;
yypt[-1].yyv.sym->value = pc;
} break;
case 10:
#line 58 "a.y"
{
yypt[-2].yyv.sym->type = LVAR;
yypt[-2].yyv.sym->value = yypt[-0].yyv.lval;
} break;
case 11:
#line 63 "a.y"
{
if(yypt[-2].yyv.sym->value != yypt[-0].yyv.lval)
yyerror("redeclaration of %s", yypt[-2].yyv.sym->name);
yypt[-2].yyv.sym->value = yypt[-0].yyv.lval;
} break;
case 12:
#line 68 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 13:
#line 69 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 14:
#line 70 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 15:
#line 71 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 16:
#line 72 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 17:
#line 73 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 18:
#line 74 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 19:
#line 75 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 20:
#line 76 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 21:
#line 77 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 22:
#line 78 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 23:
#line 79 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 24:
#line 80 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 25:
#line 81 "a.y"
{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
case 26:
#line 84 "a.y"
{
yyval.gen2.from = nullgen;
yyval.gen2.to = nullgen;
} break;
case 27:
#line 89 "a.y"
{
yyval.gen2.from = nullgen;
yyval.gen2.to = nullgen;
} break;
case 28:
#line 96 "a.y"
{
yyval.gen2.from = yypt[-2].yyv.gen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 29:
#line 103 "a.y"
{
yyval.gen2.from = yypt[-2].yyv.gen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 30:
#line 110 "a.y"
{
yyval.gen2.from = yypt[-1].yyv.gen;
yyval.gen2.to = nullgen;
} break;
case 31:
#line 115 "a.y"
{
yyval.gen2.from = yypt[-0].yyv.gen;
yyval.gen2.to = nullgen;
} break;
case 32:
#line 122 "a.y"
{
yyval.gen2.from = nullgen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 33:
#line 127 "a.y"
{
yyval.gen2.from = nullgen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 34:
#line 134 "a.y"
{
yyval.gen2.from = nullgen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 35:
#line 139 "a.y"
{
yyval.gen2.from = nullgen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 36:
#line 146 "a.y"
{
yyval.gen2.from = yypt[-4].yyv.gen;
yyval.gen2.from.scale = yypt[-2].yyv.lval;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 37:
#line 154 "a.y"
{
yyval.gen2.from = yypt[-2].yyv.gen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 38:
#line 159 "a.y"
{
yyval.gen2.from = yypt[-4].yyv.gen;
yyval.gen2.from.scale = yypt[-2].yyv.lval;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 39:
#line 167 "a.y"
{
yyval.gen2.from = nullgen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 40:
#line 172 "a.y"
{
yyval.gen2.from = nullgen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 43:
#line 183 "a.y"
{
yyval.gen2.from = yypt[-2].yyv.gen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 44:
#line 188 "a.y"
{
yyval.gen2.from = yypt[-4].yyv.gen;
yyval.gen2.to = yypt[-2].yyv.gen;
if(yyval.gen2.from.index != D_NONE)
yyerror("dp shift with lhs index");
yyval.gen2.from.index = yypt[-0].yyv.lval;
} break;
case 45:
#line 198 "a.y"
{
yyval.gen2.from = yypt[-2].yyv.gen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 46:
#line 203 "a.y"
{
yyval.gen2.from = yypt[-4].yyv.gen;
yyval.gen2.to = yypt[-2].yyv.gen;
if(yyval.gen2.to.index != D_NONE)
yyerror("dp move with lhs index");
yyval.gen2.to.index = yypt[-0].yyv.lval;
} break;
case 47:
#line 213 "a.y"
{
yyval.gen2.from = yypt[-1].yyv.gen;
yyval.gen2.to = nullgen;
} break;
case 48:
#line 218 "a.y"
{
yyval.gen2.from = yypt[-0].yyv.gen;
yyval.gen2.to = nullgen;
} break;
case 49:
#line 223 "a.y"
{
yyval.gen2.from = yypt[-2].yyv.gen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 50:
#line 230 "a.y"
{
yyval.gen2.from = yypt[-2].yyv.gen;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 51:
#line 235 "a.y"
{
yyval.gen2.from = yypt[-4].yyv.gen;
yyval.gen2.from.scale = yypt[-2].yyv.lval;
yyval.gen2.to = yypt[-0].yyv.gen;
} break;
case 56:
#line 249 "a.y"
{
yyval.gen = yypt[-0].yyv.gen;
} break;
case 57:
#line 253 "a.y"
{
yyval.gen = yypt[-0].yyv.gen;
} break;
case 63:
#line 266 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_BRANCH;
yyval.gen.offset = yypt[-3].yyv.lval + pc;
} break;
case 64:
#line 272 "a.y"
{
yyval.gen = nullgen;
if(pass == 2)
yyerror("undefined label: %s", yypt[-1].yyv.sym->name);
yyval.gen.type = D_BRANCH;
yyval.gen.sym = yypt[-1].yyv.sym;
yyval.gen.offset = yypt[-0].yyv.lval;
} break;
case 65:
#line 281 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_BRANCH;
yyval.gen.sym = yypt[-1].yyv.sym;
yyval.gen.offset = yypt[-1].yyv.sym->value + yypt[-0].yyv.lval;
} break;
case 66:
#line 290 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = yypt[-0].yyv.lval;
} break;
case 67:
#line 295 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = yypt[-0].yyv.lval;
} break;
case 68:
#line 300 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = yypt[-0].yyv.lval;
} break;
case 69:
#line 305 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_SP;
} break;
case 70:
#line 310 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = yypt[-0].yyv.lval;
} break;
case 71:
#line 317 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_CONST;
yyval.gen.offset = yypt[-0].yyv.lval;
} break;
case 72:
#line 323 "a.y"
{
yyval.gen = yypt[-0].yyv.gen;
yyval.gen.index = yypt[-0].yyv.gen.type;
yyval.gen.type = D_ADDR;
/*
if($2.type == D_AUTO || $2.type == D_PARAM)
yyerror("constant cannot be automatic: %s",
$2.sym->name);
*/
} break;
case 73:
#line 334 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_SCONST;
memcpy(yyval.gen.sval, yypt[-0].yyv.sval, sizeof(yyval.gen.sval));
} break;
case 74:
#line 340 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_FCONST;
yyval.gen.dval = yypt[-0].yyv.dval;
} break;
case 75:
#line 346 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_FCONST;
yyval.gen.dval = yypt[-1].yyv.dval;
} break;
case 76:
#line 352 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_FCONST;
yyval.gen.dval = -yypt[-0].yyv.dval;
} break;
case 77:
#line 360 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_CONST2;
yyval.gen.offset = yypt[-0].yyv.con2.v1;
yyval.gen.offset2 = yypt[-0].yyv.con2.v2;
} break;
case 78:
#line 369 "a.y"
{
yyval.con2.v1 = yypt[-0].yyv.lval;
yyval.con2.v2 = 0;
} break;
case 79:
#line 374 "a.y"
{
yyval.con2.v1 = -yypt[-0].yyv.lval;
yyval.con2.v2 = 0;
} break;
case 80:
#line 379 "a.y"
{
yyval.con2.v1 = yypt[-2].yyv.lval;
yyval.con2.v2 = yypt[-0].yyv.lval;
} break;
case 81:
#line 384 "a.y"
{
yyval.con2.v1 = -yypt[-2].yyv.lval;
yyval.con2.v2 = yypt[-0].yyv.lval;
} break;
case 84:
#line 395 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_INDIR+D_NONE;
yyval.gen.offset = yypt[-0].yyv.lval;
} break;
case 85:
#line 401 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_INDIR+yypt[-1].yyv.lval;
yyval.gen.offset = yypt[-3].yyv.lval;
} break;
case 86:
#line 407 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_INDIR+D_SP;
yyval.gen.offset = yypt[-3].yyv.lval;
} break;
case 87:
#line 413 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_INDIR+D_NONE;
yyval.gen.offset = yypt[-5].yyv.lval;
yyval.gen.index = yypt[-3].yyv.lval;
yyval.gen.scale = yypt[-1].yyv.lval;
checkscale(yyval.gen.scale);
} break;
case 88:
#line 422 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_INDIR+yypt[-6].yyv.lval;
yyval.gen.offset = yypt[-8].yyv.lval;
yyval.gen.index = yypt[-3].yyv.lval;
yyval.gen.scale = yypt[-1].yyv.lval;
checkscale(yyval.gen.scale);
} break;
case 89:
#line 431 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_INDIR+yypt[-1].yyv.lval;
} break;
case 90:
#line 436 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_INDIR+D_SP;
} break;
case 91:
#line 441 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_INDIR+yypt[-1].yyv.lval;
yyval.gen.offset = yypt[-3].yyv.lval;
} break;
case 92:
#line 447 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_INDIR+D_NONE;
yyval.gen.index = yypt[-3].yyv.lval;
yyval.gen.scale = yypt[-1].yyv.lval;
checkscale(yyval.gen.scale);
} break;
case 93:
#line 455 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_INDIR+yypt[-6].yyv.lval;
yyval.gen.index = yypt[-3].yyv.lval;
yyval.gen.scale = yypt[-1].yyv.lval;
checkscale(yyval.gen.scale);
} break;
case 94:
#line 465 "a.y"
{
yyval.gen = yypt[-0].yyv.gen;
} break;
case 95:
#line 469 "a.y"
{
yyval.gen = yypt[-5].yyv.gen;
yyval.gen.index = yypt[-3].yyv.lval;
yyval.gen.scale = yypt[-1].yyv.lval;
checkscale(yyval.gen.scale);
} break;
case 96:
#line 478 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = yypt[-1].yyv.lval;
yyval.gen.sym = yypt[-4].yyv.sym;
yyval.gen.offset = yypt[-3].yyv.lval;
} break;
case 97:
#line 485 "a.y"
{
yyval.gen = nullgen;
yyval.gen.type = D_STATIC;
yyval.gen.sym = yypt[-6].yyv.sym;
yyval.gen.offset = yypt[-3].yyv.lval;
} break;
case 98:
#line 493 "a.y"
{
yyval.lval = 0;
} break;
case 99:
#line 497 "a.y"
{
yyval.lval = yypt[-0].yyv.lval;
} break;
case 100:
#line 501 "a.y"
{
yyval.lval = -yypt[-0].yyv.lval;
} break;
case 102:
#line 508 "a.y"
{
yyval.lval = D_AUTO;
} break;
case 105:
#line 516 "a.y"
{
yyval.lval = yypt[-0].yyv.sym->value;
} break;
case 106:
#line 520 "a.y"
{
yyval.lval = -yypt[-0].yyv.lval;
} break;
case 107:
#line 524 "a.y"
{
yyval.lval = yypt[-0].yyv.lval;
} break;
case 108:
#line 528 "a.y"
{
yyval.lval = ~yypt[-0].yyv.lval;
} break;
case 109:
#line 532 "a.y"
{
yyval.lval = yypt[-1].yyv.lval;
} break;
case 111:
#line 539 "a.y"
{
yyval.lval = yypt[-2].yyv.lval + yypt[-0].yyv.lval;
} break;
case 112:
#line 543 "a.y"
{
yyval.lval = yypt[-2].yyv.lval - yypt[-0].yyv.lval;
} break;
case 113:
#line 547 "a.y"
{
yyval.lval = yypt[-2].yyv.lval * yypt[-0].yyv.lval;
} break;
case 114:
#line 551 "a.y"
{
yyval.lval = yypt[-2].yyv.lval / yypt[-0].yyv.lval;
} break;
case 115:
#line 555 "a.y"
{
yyval.lval = yypt[-2].yyv.lval % yypt[-0].yyv.lval;
} break;
case 116:
#line 559 "a.y"
{
yyval.lval = yypt[-3].yyv.lval << yypt[-0].yyv.lval;
} break;
case 117:
#line 563 "a.y"
{
yyval.lval = yypt[-3].yyv.lval >> yypt[-0].yyv.lval;
} break;
case 118:
#line 567 "a.y"
{
yyval.lval = yypt[-2].yyv.lval & yypt[-0].yyv.lval;
} break;
case 119:
#line 571 "a.y"
{
yyval.lval = yypt[-2].yyv.lval ^ yypt[-0].yyv.lval;
} break;
case 120:
#line 575 "a.y"
{
yyval.lval = yypt[-2].yyv.lval | yypt[-0].yyv.lval;
} break;
}
goto yystack; /* stack new state and value */
}
int
yylex(void)
{
int r;
if (keep1.token != -47)
{
/*
* something in keep buffer. shift it out.
*/
r = keep1.token;
current_line = keep1.line;
yylval = keep1.lval;
keep1 = keep2;
keep2 = keep3;
keep3.token = -47;
return r;
}
yytext[0] = 0;
/*
* see if the next token is a string
*/
if ((r = yylex1()) == F_STRING)
{
keep4.lval = yylval;
keep4.line = current_line;
yytext[0] = 0;
r = yylex1();
for (;;)
{
keep1.line = current_line;
keep1.lval = yylval;
if (r != '+')
{
/*
* 1:string 2:non-'+'
* save 2, return 1
*/
keep1.token = r;
yylval = keep4.lval;
current_line = keep4.line;
return F_STRING;
}
yytext[0] = 0;
r = yylex1();
keep2.line = current_line;
keep2.lval = yylval;
if (r != F_STRING)
{
/*
* 1:string 2:'+' 3:non-string
* save 2 and 3, return 1
*/
keep1.token = '+';
keep2.token = r;
current_line = keep4.line;
yylval = keep4.lval;
return F_STRING;
}
yytext[0] = 0;
r = yylex1();
keep3.line = current_line;
keep3.lval = yylval;
if (r == '[' || r == F_ARROW)
{
/*
* 1:string 2:'+' 3:string 4:[->
* save 2, 3, 4, return 1
*/
keep1.token = '+';
keep2.token = F_STRING;
keep3.token = r;
current_line = keep4.line;
yylval = keep4.lval;
return F_STRING;
}
/*
* concatenate string constants
*/
keep3.lval.string = tmpalloc(strlen(keep4.lval.string) +
strlen(keep2.lval.string) + 1);
(void)strcpy(keep3.lval.string, keep4.lval.string);
(void)strcat(keep3.lval.string, keep2.lval.string);
keep4.line = keep2.line;
keep4.lval.string = keep3.lval.string;
}
}
/* (void)fprintf(stderr, "lex=%d(%s) ", r, yytext);*/
return r;
}
int
yyparse(void)
{
struct
{
YYSTYPE yyv;
int yys;
} yys[YYMAXDEPTH], *yyp, *yypt;
short *yyxi;
int yyj, yym, yystate, yyn, yyg;
long yychar;
YYSTYPE save1, save2;
int save3, save4;
save1 = yylval;
save2 = yyval;
save3 = yynerrs;
save4 = yyerrflag;
yystate = 0;
yychar = -1;
yynerrs = 0;
yyerrflag = 0;
yyp = &yys[-1];
goto yystack;
ret0:
yyn = 0;
goto ret;
ret1:
yyn = 1;
goto ret;
ret:
yylval = save1;
yyval = save2;
yynerrs = save3;
yyerrflag = save4;
return yyn;
yystack:
/* put a state and value onto the stack */
if(yydebug >= 4)
fprint(2, "char %s in %s", yytokname(yychar), yystatname(yystate));
yyp++;
if(yyp >= &yys[YYMAXDEPTH]) {
yyerror("yacc stack overflow");
goto ret1;
}
yyp->yys = yystate;
yyp->yyv = yyval;
yynewstate:
yyn = yypact[yystate];
if(yyn <= YYFLAG)
goto yydefault; /* simple state */
if(yychar < 0)
yychar = yylex1();
yyn += yychar;
if(yyn < 0 || yyn >= YYLAST)
goto yydefault;
yyn = yyact[yyn];
if(yychk[yyn] == yychar) { /* valid shift */
yychar = -1;
yyval = yylval;
yystate = yyn;
if(yyerrflag > 0)
yyerrflag--;
goto yystack;
}
yydefault:
/* default state action */
yyn = yydef[yystate];
if(yyn == -2) {
if(yychar < 0)
yychar = yylex1();
/* look through exception table */
for(yyxi=yyexca;; yyxi+=2)
if(yyxi[0] == -1 && yyxi[1] == yystate)
break;
for(yyxi += 2;; yyxi += 2) {
yyn = yyxi[0];
if(yyn < 0 || yyn == yychar)
break;
}
yyn = yyxi[1];
if(yyn < 0)
goto ret0;
}
if(yyn == 0) {
/* error ... attempt to resume parsing */
switch(yyerrflag) {
case 0: /* brand new error */
yyerror("syntax error");
yynerrs++;
if(yydebug >= 1) {
fprint(2, "%s", yystatname(yystate));
fprint(2, "saw %s\n", yytokname(yychar));
}
case 1:
case 2: /* incompletely recovered error ... try again */
yyerrflag = 3;
/* find a state where "error" is a legal shift action */
while(yyp >= yys) {
yyn = yypact[yyp->yys] + YYERRCODE;
if(yyn >= 0 && yyn < YYLAST) {
yystate = yyact[yyn]; /* simulate a shift of "error" */
if(yychk[yystate] == YYERRCODE)
goto yystack;
}
/* the current yyp has no shift onn "error", pop stack */
if(yydebug >= 2)
fprint(2, "error recovery pops state %d, uncovers %d\n",
yyp->yys, (yyp-1)->yys );
yyp--;
}
/* there is no state on the stack with an error shift ... abort */
goto ret1;
case 3: /* no shift yet; clobber input char */
if(yydebug >= 2)
fprint(2, "error recovery discards %s\n", yytokname(yychar));
if(yychar == YYEOFCODE)
goto ret1;
yychar = -1;
goto yynewstate; /* try again in the same state */
}
}
/* reduction by production yyn */
if(yydebug >= 2)
fprint(2, "reduce %d in:\n\t%s", yyn, yystatname(yystate));
yypt = yyp;
yyp -= yyr2[yyn];
yyval = (yyp+1)->yyv;
yym = yyn;
/* consult goto table to find next state */
yyn = yyr1[yyn];
yyg = yypgo[yyn];
yyj = yyg + yyp->yys + 1;
if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
yystate = yyact[yyg];
switch(yym) {
case 1:
#line 41 "asm.y"
{
assem(yypt[-0].yyv.inst);
} break;
case 2:
#line 47 "asm.y"
{ yyval.inst = nil; } break;
case 3:
#line 49 "asm.y"
{
if(yypt[-0].yyv.inst != nil) {
yypt[-0].yyv.inst->link = yypt[-1].yyv.inst;
yyval.inst = yypt[-0].yyv.inst;
}
else
yyval.inst = yypt[-1].yyv.inst;
} break;
case 4:
#line 60 "asm.y"
{
yypt[-0].yyv.inst->sym = yypt[-2].yyv.sym;
yyval.inst = yypt[-0].yyv.inst;
} break;
case 5:
#line 65 "asm.y"
{
heap(yypt[-3].yyv.ival, yypt[-1].yyv.ival, yypt[-0].yyv.string);
yyval.inst = nil;
} break;
case 6:
#line 70 "asm.y"
{
yyval.inst = nil;
} break;
case 8:
#line 77 "asm.y"
{
yyval.ival = yypt[-0].yyv.ival;
} break;
case 9:
#line 81 "asm.y"
{
yypt[-0].yyv.sym->value = heapid++;
yyval.ival = yypt[-0].yyv.sym->value;
} break;
case 10:
#line 88 "asm.y"
{ yyval.string = nil; } break;
case 11:
#line 90 "asm.y"
{
yyval.string = yypt[-0].yyv.string;
} break;
case 12:
#line 96 "asm.y"
{
yyval.list = newi(yypt[-0].yyv.ival, nil);
} break;
case 13:
#line 100 "asm.y"
{
yyval.list = newi(yypt[-0].yyv.ival, yypt[-2].yyv.list);
} break;
case 14:
#line 106 "asm.y"
{
yyval.inst = ai(yypt[-3].yyv.ival);
yyval.inst->src = yypt[-2].yyv.addr;
yyval.inst->dst = yypt[-0].yyv.addr;
} break;
case 15:
#line 112 "asm.y"
{
yyval.inst = ai(yypt[-5].yyv.ival);
yyval.inst->src = yypt[-4].yyv.addr;
yyval.inst->reg = yypt[-2].yyv.addr;
yyval.inst->dst = yypt[-0].yyv.addr;
} break;
case 16:
#line 119 "asm.y"
{
yyval.inst = ai(yypt[-3].yyv.ival);
yyval.inst->src = yypt[-2].yyv.addr;
yyval.inst->dst = yypt[-0].yyv.addr;
} break;
case 17:
#line 125 "asm.y"
{
yyval.inst = ai(yypt[-1].yyv.ival);
yyval.inst->dst = yypt[-0].yyv.addr;
} break;
case 18:
#line 130 "asm.y"
{
yyval.inst = ai(yypt[-0].yyv.ival);
} break;
case 19:
#line 136 "asm.y"
{
data(DEFB, yypt[-2].yyv.ival, yypt[-0].yyv.list);
} break;
case 20:
#line 140 "asm.y"
{
data(DEFW, yypt[-2].yyv.ival, yypt[-0].yyv.list);
} break;
case 21:
#line 144 "asm.y"
{
data(DEFL, yypt[-2].yyv.ival, yypt[-0].yyv.list);
} break;
case 22:
#line 148 "asm.y"
{
data(DEFF, yypt[-2].yyv.ival, newi(dtocanon((double)yypt[-0].yyv.ival), nil));
} break;
case 23:
#line 152 "asm.y"
{
data(DEFF, yypt[-2].yyv.ival, newi(dtocanon(yypt[-0].yyv.fval), nil));
} break;
case 24:
#line 156 "asm.y"
{
if(strcmp(yypt[-0].yyv.sym->name, "Inf") == 0 || strcmp(yypt[-0].yyv.sym->name, "Infinity") == 0) {
u.l = (uvlong)0x7ff00000<<32;
data(DEFF, yypt[-2].yyv.ival, newi(dtocanon(u.d), nil));
} else if(strcmp(yypt[-0].yyv.sym->name, "NaN") == 0) {
u.l = ((uvlong)0x7fffffff<<32) | (uvlong)0xffffffffUL;
data(DEFF, yypt[-2].yyv.ival, newi(dtocanon(u.d), nil));
} else
diag("bad value for real: %s", yypt[-0].yyv.sym->name);
} break;
case 25:
#line 167 "asm.y"
{
data(DEFF, yypt[-3].yyv.ival, newi(dtocanon(-(double)yypt[-0].yyv.ival), nil));
} break;
case 26:
#line 171 "asm.y"
{
data(DEFF, yypt[-3].yyv.ival, newi(dtocanon(-yypt[-0].yyv.fval), nil));
} break;
case 27:
#line 175 "asm.y"
{
if(strcmp(yypt[-0].yyv.sym->name, "Inf") == 0 || strcmp(yypt[-0].yyv.sym->name, "Infinity") == 0) {
u.l = (uvlong)0xfff00000<<32;
data(DEFF, yypt[-3].yyv.ival, newi(dtocanon(u.d), nil));
} else
diag("bad value for real: %s", yypt[-0].yyv.sym->name);
} break;
case 28:
#line 183 "asm.y"
{
data(DEFS, yypt[-2].yyv.ival, news(yypt[-0].yyv.string, nil));
} break;
case 29:
#line 187 "asm.y"
{
if(yypt[-2].yyv.sym->ds != 0)
diag("%s declared twice", yypt[-2].yyv.sym->name);
yypt[-2].yyv.sym->ds = yypt[-0].yyv.ival;
yypt[-2].yyv.sym->value = dseg;
dseg += yypt[-0].yyv.ival;
} break;
case 30:
#line 195 "asm.y"
{
ext(yypt[-4].yyv.ival, yypt[-2].yyv.ival, yypt[-0].yyv.string);
} break;
case 31:
#line 199 "asm.y"
{
mklink(yypt[-6].yyv.ival, yypt[-4].yyv.ival, yypt[-2].yyv.ival, yypt[-0].yyv.string);
} break;
case 32:
#line 203 "asm.y"
{
if(module != nil)
diag("this module already defined as %s", yypt[-0].yyv.sym->name);
else
module = yypt[-0].yyv.sym;
} break;
case 33:
#line 210 "asm.y"
{
if(pcentry >= 0)
diag("this module already has entry point %d, %d" , pcentry, dentry);
pcentry = yypt[-2].yyv.ival;
dentry = yypt[-0].yyv.ival;
} break;
case 34:
#line 217 "asm.y"
{
data(DEFA, yypt[-4].yyv.ival, newa(yypt[-2].yyv.ival, yypt[-0].yyv.ival));
} break;
case 35:
#line 221 "asm.y"
{
data(DIND, yypt[-2].yyv.ival, newa(yypt[-0].yyv.ival, 0));
} break;
case 36:
#line 225 "asm.y"
{
data(DAPOP, 0, newa(0, 0));
} break;
case 37:
#line 229 "asm.y"
{
ldts(yypt[-0].yyv.ival);
} break;
case 38:
#line 233 "asm.y"
{
excs(yypt[-0].yyv.ival);
} break;
case 39:
#line 237 "asm.y"
{
exc(yypt[-10].yyv.ival, yypt[-8].yyv.ival, yypt[-6].yyv.ival, yypt[-4].yyv.ival, yypt[-2].yyv.ival, yypt[-0].yyv.ival);
} break;
case 40:
#line 241 "asm.y"
{
etab(yypt[-2].yyv.string, yypt[-0].yyv.ival);
} break;
case 41:
#line 245 "asm.y"
{
etab(nil, yypt[-0].yyv.ival);
} break;
case 42:
#line 249 "asm.y"
{
source(yypt[-0].yyv.string);
} break;
case 43:
#line 255 "asm.y"
{
yyval.addr = aa(yypt[-0].yyv.ival);
yyval.addr->mode = AXIMM;
if(yyval.addr->val > 0x7FFF || yyval.addr->val < -0x8000)
diag("immediate %d too large for middle operand", yyval.addr->val);
} break;
case 44:
#line 262 "asm.y"
{
if(yypt[-0].yyv.addr->mode == AMP)
yypt[-0].yyv.addr->mode = AXINM;
else
yypt[-0].yyv.addr->mode = AXINF;
if(yypt[-0].yyv.addr->mode == AXINM && (ulong)yypt[-0].yyv.addr->val > 0xFFFF)
diag("register offset %d(mp) too large", yypt[-0].yyv.addr->val);
if(yypt[-0].yyv.addr->mode == AXINF && (ulong)yypt[-0].yyv.addr->val > 0xFFFF)
diag("register offset %d(fp) too large", yypt[-0].yyv.addr->val);
yyval.addr = yypt[-0].yyv.addr;
} break;
case 45:
#line 276 "asm.y"
{
yyval.addr = aa(yypt[-0].yyv.ival);
yyval.addr->mode = AIMM;
} break;
case 46:
#line 281 "asm.y"
{
yyval.addr = aa(0);
yyval.addr->sym = yypt[-0].yyv.sym;
} break;
case 48:
#line 289 "asm.y"
{
yypt[-0].yyv.addr->mode |= AIND;
yyval.addr = yypt[-0].yyv.addr;
} break;
case 49:
#line 294 "asm.y"
{
yypt[-1].yyv.addr->mode |= AIND;
if(yypt[-1].yyv.addr->val & 3)
diag("indirect offset must be word size");
if(yypt[-1].yyv.addr->mode == (AMP|AIND) && ((ulong)yypt[-1].yyv.addr->val > 0xFFFF || (ulong)yypt[-3].yyv.ival > 0xFFFF))
diag("indirect offset %d(%d(mp)) too large", yypt[-3].yyv.ival, yypt[-1].yyv.addr->val);
if(yypt[-1].yyv.addr->mode == (AFP|AIND) && ((ulong)yypt[-1].yyv.addr->val > 0xFFFF || (ulong)yypt[-3].yyv.ival > 0xFFFF))
diag("indirect offset %d(%d(fp)) too large", yypt[-3].yyv.ival, yypt[-1].yyv.addr->val);
yypt[-1].yyv.addr->off = yypt[-1].yyv.addr->val;
yypt[-1].yyv.addr->val = yypt[-3].yyv.ival;
yyval.addr = yypt[-1].yyv.addr;
} break;
case 51:
#line 310 "asm.y"
{
yyval.addr = aa(yypt[-3].yyv.ival);
yyval.addr->mode = AMP;
} break;
case 52:
#line 315 "asm.y"
{
yyval.addr = aa(yypt[-3].yyv.ival);
yyval.addr->mode = AFP;
} break;
case 54:
#line 323 "asm.y"
{
yyval.ival = yypt[-0].yyv.sym->value;
} break;
case 55:
#line 327 "asm.y"
{
yyval.ival = -yypt[-0].yyv.ival;
} break;
case 56:
#line 331 "asm.y"
{
yyval.ival = yypt[-0].yyv.ival;
} break;
case 57:
#line 335 "asm.y"
{
yyval.ival = ~yypt[-0].yyv.ival;
} break;
case 58:
#line 339 "asm.y"
{
yyval.ival = yypt[-1].yyv.ival;
} break;
case 60:
#line 346 "asm.y"
{
yyval.ival = yypt[-2].yyv.ival + yypt[-0].yyv.ival;
} break;
case 61:
#line 350 "asm.y"
{
yyval.ival = yypt[-2].yyv.ival - yypt[-0].yyv.ival;
} break;
case 62:
#line 354 "asm.y"
{
yyval.ival = yypt[-2].yyv.ival * yypt[-0].yyv.ival;
} break;
case 63:
#line 358 "asm.y"
{
yyval.ival = yypt[-2].yyv.ival / yypt[-0].yyv.ival;
} break;
case 64:
#line 362 "asm.y"
{
yyval.ival = yypt[-2].yyv.ival % yypt[-0].yyv.ival;
} break;
case 65:
#line 366 "asm.y"
{
yyval.ival = yypt[-3].yyv.ival << yypt[-0].yyv.ival;
} break;
case 66:
#line 370 "asm.y"
{
yyval.ival = yypt[-3].yyv.ival >> yypt[-0].yyv.ival;
} break;
case 67:
#line 374 "asm.y"
{
yyval.ival = yypt[-2].yyv.ival & yypt[-0].yyv.ival;
} break;
case 68:
#line 378 "asm.y"
{
yyval.ival = yypt[-2].yyv.ival ^ yypt[-0].yyv.ival;
} break;
case 69:
#line 382 "asm.y"
{
yyval.ival = yypt[-2].yyv.ival | yypt[-0].yyv.ival;
} break;
}
goto yystack; /* stack new state and value */
}
int
yyparse(void)
{
struct
{
YYSTYPE yyv;
int yys;
} yys[YYMAXDEPTH], *yyp, *yypt;
short *yyxi;
int yyj, yym, yystate, yyn, yyg;
long yychar;
YYSTYPE save1, save2;
int save3, save4;
save1 = yylval;
save2 = yyval;
save3 = yynerrs;
save4 = yyerrflag;
yystate = 0;
yychar = -1;
yynerrs = 0;
yyerrflag = 0;
yyp = &yys[-1];
goto yystack;
ret0:
yyn = 0;
goto ret;
ret1:
yyn = 1;
goto ret;
ret:
yylval = save1;
yyval = save2;
yynerrs = save3;
yyerrflag = save4;
return yyn;
yystack:
/* put a state and value onto the stack */
if(yydebug >= 4)
fprint(2, "char %s in %s", yytokname(yychar), yystatname(yystate));
yyp++;
if(yyp >= &yys[YYMAXDEPTH]) {
yyerror("yacc stack overflow");
goto ret1;
}
yyp->yys = yystate;
yyp->yyv = yyval;
yynewstate:
yyn = yypact[yystate];
if(yyn <= YYFLAG)
goto yydefault; /* simple state */
if(yychar < 0)
yychar = yylex1();
yyn += yychar;
if(yyn < 0 || yyn >= YYLAST)
goto yydefault;
yyn = yyact[yyn];
if(yychk[yyn] == yychar) { /* valid shift */
yychar = -1;
yyval = yylval;
yystate = yyn;
if(yyerrflag > 0)
yyerrflag--;
goto yystack;
}
yydefault:
/* default state action */
yyn = yydef[yystate];
if(yyn == -2) {
if(yychar < 0)
yychar = yylex1();
/* look through exception table */
for(yyxi=yyexca;; yyxi+=2)
if(yyxi[0] == -1 && yyxi[1] == yystate)
break;
for(yyxi += 2;; yyxi += 2) {
yyn = yyxi[0];
if(yyn < 0 || yyn == yychar)
break;
}
yyn = yyxi[1];
if(yyn < 0)
goto ret0;
}
if(yyn == 0) {
/* error ... attempt to resume parsing */
switch(yyerrflag) {
case 0: /* brand new error */
yyerror("syntax error");
yynerrs++;
if(yydebug >= 1) {
fprint(2, "%s", yystatname(yystate));
fprint(2, "saw %s\n", yytokname(yychar));
}
case 1:
case 2: /* incompletely recovered error ... try again */
yyerrflag = 3;
/* find a state where "error" is a legal shift action */
while(yyp >= yys) {
yyn = yypact[yyp->yys] + YYERRCODE;
if(yyn >= 0 && yyn < YYLAST) {
yystate = yyact[yyn]; /* simulate a shift of "error" */
if(yychk[yystate] == YYERRCODE)
goto yystack;
}
/* the current yyp has no shift onn "error", pop stack */
if(yydebug >= 2)
fprint(2, "error recovery pops state %d, uncovers %d\n",
yyp->yys, (yyp-1)->yys );
yyp--;
}
/* there is no state on the stack with an error shift ... abort */
goto ret1;
case 3: /* no shift yet; clobber input char */
if(yydebug >= 2)
fprint(2, "error recovery discards %s\n", yytokname(yychar));
if(yychar == YYEOFCODE)
goto ret1;
yychar = -1;
goto yynewstate; /* try again in the same state */
}
}
/* reduction by production yyn */
if(yydebug >= 2)
fprint(2, "reduce %d in:\n\t%s", yyn, yystatname(yystate));
yypt = yyp;
yyp -= yyr2[yyn];
yyval = (yyp+1)->yyv;
yym = yyn;
/* consult goto table to find next state */
yyn = yyr1[yyn];
yyg = yypgo[yyn];
yyj = yyg + yyp->yys + 1;
if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
yystate = yyact[yyg];
switch(yym) {
case 3:
#line 77 "cc.y"
{
dodecl(xdecl, lastclass, lasttype, Z);
} break;
case 5:
#line 82 "cc.y"
{
lastdcl = T;
firstarg = S;
dodecl(xdecl, lastclass, lasttype, yypt[-0].yyv.node);
if(lastdcl == T || lastdcl->etype != TFUNC) {
diag(yypt[-0].yyv.node, "not a function");
lastdcl = types[TFUNC];
}
thisfn = lastdcl;
markdcl();
firstdcl = dclstack;
argmark(yypt[-0].yyv.node, 0);
} break;
case 6:
#line 96 "cc.y"
{
argmark(yypt[-2].yyv.node, 1);
} break;
case 7:
#line 100 "cc.y"
{
Node *n;
n = revertdcl();
if(n)
yypt[-0].yyv.node = new(OLIST, n, yypt[-0].yyv.node);
if(!debug['a'] && !debug['Z'])
codgen(yypt[-0].yyv.node, yypt[-4].yyv.node);
} break;
case 8:
#line 112 "cc.y"
{
dodecl(xdecl, lastclass, lasttype, yypt[-0].yyv.node);
} break;
case 9:
#line 116 "cc.y"
{
yypt[-0].yyv.node = dodecl(xdecl, lastclass, lasttype, yypt[-0].yyv.node);
} break;
case 10:
#line 120 "cc.y"
{
doinit(yypt[-3].yyv.node->sym, yypt[-3].yyv.node->type, 0L, yypt[-0].yyv.node);
} break;
case 13:
#line 128 "cc.y"
{
yyval.node = new(OIND, yypt[-0].yyv.node, Z);
yyval.node->garb = simpleg(yypt[-1].yyv.lval);
} break;
case 15:
#line 136 "cc.y"
{
yyval.node = yypt[-1].yyv.node;
} break;
case 16:
#line 140 "cc.y"
{
yyval.node = new(OFUNC, yypt[-3].yyv.node, yypt[-1].yyv.node);
} break;
case 17:
#line 144 "cc.y"
{
yyval.node = new(OARRAY, yypt[-3].yyv.node, yypt[-1].yyv.node);
} break;
case 18:
#line 153 "cc.y"
{
yyval.node = dodecl(adecl, lastclass, lasttype, Z);
} break;
case 19:
#line 157 "cc.y"
{
yyval.node = yypt[-1].yyv.node;
} break;
case 20:
#line 163 "cc.y"
{
dodecl(adecl, lastclass, lasttype, yypt[-0].yyv.node);
yyval.node = Z;
} break;
case 21:
#line 168 "cc.y"
{
yypt[-0].yyv.node = dodecl(adecl, lastclass, lasttype, yypt[-0].yyv.node);
} break;
case 22:
#line 172 "cc.y"
{
long w;
w = yypt[-3].yyv.node->sym->type->width;
yyval.node = doinit(yypt[-3].yyv.node->sym, yypt[-3].yyv.node->type, 0L, yypt[-0].yyv.node);
yyval.node = contig(yypt[-3].yyv.node->sym, yyval.node, w);
} break;
case 23:
#line 180 "cc.y"
{
yyval.node = yypt[-2].yyv.node;
if(yypt[-0].yyv.node != Z) {
yyval.node = yypt[-0].yyv.node;
if(yypt[-2].yyv.node != Z)
yyval.node = new(OLIST, yypt[-2].yyv.node, yypt[-0].yyv.node);
}
} break;
case 26:
#line 197 "cc.y"
{
dodecl(pdecl, lastclass, lasttype, yypt[-0].yyv.node);
} break;
case 28:
#line 207 "cc.y"
{
lasttype = yypt[-0].yyv.type;
} break;
case 30:
#line 212 "cc.y"
{
lasttype = yypt[-0].yyv.type;
} break;
case 32:
#line 218 "cc.y"
{
lastfield = 0;
edecl(CXXX, lasttype, S);
} break;
case 34:
#line 226 "cc.y"
{
dodecl(edecl, CXXX, lasttype, yypt[-0].yyv.node);
} break;
case 36:
#line 233 "cc.y"
{
lastbit = 0;
firstbit = 1;
} break;
case 37:
#line 238 "cc.y"
{
yyval.node = new(OBIT, yypt[-2].yyv.node, yypt[-0].yyv.node);
} break;
case 38:
#line 242 "cc.y"
{
yyval.node = new(OBIT, Z, yypt[-0].yyv.node);
} break;
case 39:
#line 250 "cc.y"
{
yyval.node = (Z);
} break;
case 41:
#line 257 "cc.y"
{
yyval.node = new(OIND, (Z), Z);
yyval.node->garb = simpleg(yypt[-0].yyv.lval);
} break;
case 42:
#line 262 "cc.y"
{
yyval.node = new(OIND, yypt[-0].yyv.node, Z);
yyval.node->garb = simpleg(yypt[-1].yyv.lval);
} break;
case 45:
#line 271 "cc.y"
{
yyval.node = new(OFUNC, yypt[-3].yyv.node, yypt[-1].yyv.node);
} break;
case 46:
#line 275 "cc.y"
{
yyval.node = new(OARRAY, yypt[-3].yyv.node, yypt[-1].yyv.node);
} break;
case 47:
#line 281 "cc.y"
{
yyval.node = new(OFUNC, (Z), Z);
} break;
case 48:
#line 285 "cc.y"
{
yyval.node = new(OARRAY, (Z), yypt[-1].yyv.node);
} break;
case 49:
#line 289 "cc.y"
{
yyval.node = yypt[-1].yyv.node;
} break;
case 51:
#line 296 "cc.y"
{
yyval.node = new(OINIT, invert(yypt[-1].yyv.node), Z);
} break;
case 52:
#line 302 "cc.y"
{
yyval.node = new(OARRAY, yypt[-1].yyv.node, Z);
} break;
case 53:
#line 306 "cc.y"
{
yyval.node = new(OELEM, Z, Z);
yyval.node->sym = yypt[-0].yyv.sym;
} break;
case 56:
#line 315 "cc.y"
{
yyval.node = new(OLIST, yypt[-2].yyv.node, yypt[-1].yyv.node);
} break;
case 58:
#line 320 "cc.y"
{
yyval.node = new(OLIST, yypt[-1].yyv.node, yypt[-0].yyv.node);
} break;
case 61:
#line 328 "cc.y"
{
yyval.node = new(OLIST, yypt[-1].yyv.node, yypt[-0].yyv.node);
} break;
case 62:
#line 333 "cc.y"
{
yyval.node = Z;
} break;
case 63:
#line 337 "cc.y"
{
yyval.node = invert(yypt[-0].yyv.node);
} break;
case 65:
#line 345 "cc.y"
{
yyval.node = new(OPROTO, yypt[-0].yyv.node, Z);
yyval.node->type = yypt[-1].yyv.type;
} break;
case 66:
#line 350 "cc.y"
{
yyval.node = new(OPROTO, yypt[-0].yyv.node, Z);
yyval.node->type = yypt[-1].yyv.type;
} break;
case 67:
#line 355 "cc.y"
{
yyval.node = new(ODOTDOT, Z, Z);
} break;
case 68:
#line 359 "cc.y"
{
yyval.node = new(OLIST, yypt[-2].yyv.node, yypt[-0].yyv.node);
} break;
case 69:
#line 365 "cc.y"
{
yyval.node = invert(yypt[-1].yyv.node);
// if(yypt[-1].yyv.node != Z)
// yyval.node = new(OLIST, yypt[-1].yyv.node, yyval.node);
if(yyval.node == Z)
yyval.node = new(OLIST, Z, Z);
} break;
case 70:
#line 374 "cc.y"
{
yyval.node = Z;
} break;
case 71:
#line 378 "cc.y"
{
yyval.node = new(OLIST, yypt[-1].yyv.node, yypt[-0].yyv.node);
} break;
case 72:
#line 382 "cc.y"
{
yyval.node = new(OLIST, yypt[-1].yyv.node, yypt[-0].yyv.node);
} break;
case 74:
#line 389 "cc.y"
{
yyval.node = new(OLIST, yypt[-1].yyv.node, yypt[-0].yyv.node);
} break;
case 75:
#line 395 "cc.y"
{
yyval.node = new(OCASE, yypt[-1].yyv.node, Z);
} break;
case 76:
#line 399 "cc.y"
{
yyval.node = new(OCASE, Z, Z);
} break;
case 77:
#line 403 "cc.y"
{
yyval.node = new(OLABEL, dcllabel(yypt[-1].yyv.sym, 1), Z);
} break;
case 78:
#line 409 "cc.y"
{
yyval.node = Z;
} break;
case 80:
#line 414 "cc.y"
{
yyval.node = new(OLIST, yypt[-1].yyv.node, yypt[-0].yyv.node);
} break;
case 82:
#line 421 "cc.y"
{
yyval.node = yypt[-0].yyv.node;
} break;
case 84:
#line 427 "cc.y"
{
markdcl();
} break;
case 85:
#line 431 "cc.y"
{
yyval.node = revertdcl();
if(yyval.node)
yyval.node = new(OLIST, yyval.node, yypt[-0].yyv.node);
else
yyval.node = yypt[-0].yyv.node;
} break;
int
yyparse(void)
{
struct
{
YYSTYPE yyv;
int yys;
} yys[YYMAXDEPTH], *yyp, *yypt;
short *yyxi;
int yyj, yym, yystate, yyn, yyg;
YYSTYPE save1, save2;
int save3, save4;
long yychar;
save1 = yylval;
save2 = yyval;
save3 = yynerrs;
save4 = yyerrflag;
yystate = 0;
yychar = -1;
yynerrs = 0;
yyerrflag = 0;
yyp = &yys[-1];
goto yystack;
ret0:
yyn = 0;
goto ret;
ret1:
yyn = 1;
goto ret;
ret:
yylval = save1;
yyval = save2;
yynerrs = save3;
yyerrflag = save4;
return yyn;
yystack:
/* put a state and value onto the stack */
if(yydebug >= 4)
printf("char %s in %s", yytokname(yychar), yystatname(yystate));
yyp++;
if(yyp >= &yys[YYMAXDEPTH]) {
yyerror("yacc stack overflow");
goto ret1;
}
yyp->yys = yystate;
yyp->yyv = yyval;
yynewstate:
yyn = yypact[yystate];
if(yyn <= YYFLAG)
goto yydefault; /* simple state */
if(yychar < 0)
yychar = yylex1();
yyn += yychar;
if(yyn < 0 || yyn >= YYLAST)
goto yydefault;
yyn = yyact[yyn];
if(yychk[yyn] == yychar) { /* valid shift */
yychar = -1;
yyval = yylval;
yystate = yyn;
if(yyerrflag > 0)
yyerrflag--;
goto yystack;
}
yydefault:
/* default state action */
yyn = yydef[yystate];
if(yyn == -2) {
if(yychar < 0)
yychar = yylex1();
/* look through exception table */
for(yyxi=yyexca;; yyxi+=2)
if(yyxi[0] == -1 && yyxi[1] == yystate)
break;
for(yyxi += 2;; yyxi += 2) {
yyn = yyxi[0];
if(yyn < 0 || yyn == yychar)
break;
}
yyn = yyxi[1];
if(yyn < 0)
goto ret0;
}
if(yyn == 0) {
/* error ... attempt to resume parsing */
switch(yyerrflag) {
case 0: /* brand new error */
yyerror("syntax error");
if(yydebug >= 1) {
printf("%s", yystatname(yystate));
printf("saw %s\n", yytokname(yychar));
}
yyerrlab:
yynerrs++;
case 1:
case 2: /* incompletely recovered error ... try again */
yyerrflag = 3;
/* find a state where "error" is a legal shift action */
while(yyp >= yys) {
yyn = yypact[yyp->yys] + YYERRCODE;
if(yyn >= 0 && yyn < YYLAST) {
yystate = yyact[yyn]; /* simulate a shift of "error" */
if(yychk[yystate] == YYERRCODE)
goto yystack;
}
/* the current yyp has no shift onn "error", pop stack */
if(yydebug >= 2)
printf("error recovery pops state %d, uncovers %d\n",
yyp->yys, (yyp-1)->yys );
yyp--;
}
/* there is no state on the stack with an error shift ... abort */
goto ret1;
case 3: /* no shift yet; clobber input char */
if(yydebug >= YYEOFCODE)
printf("error recovery discards %s\n", yytokname(yychar));
if(yychar == YYEOFCODE)
goto ret1;
yychar = -1;
goto yynewstate; /* try again in the same state */
}
}
/* reduction by production yyn */
if(yydebug >= 2)
printf("reduce %d in:\n\t%s", yyn, yystatname(yystate));
yypt = yyp;
yyp -= yyr2[yyn];
yyval = (yyp+1)->yyv;
yym = yyn;
/* consult goto table to find next state */
yyn = yyr1[yyn];
yyg = yypgo[yyn];
yyj = yyg + yyp->yys + 1;
if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
yystate = yyact[yyg];
switch(yym) {
case 1:
#line 24 "/sys/src/cmd/eqn/eqn.y"
{ putout(yypt[-0].yyv); } break;
case 2:
#line 25 "/sys/src/cmd/eqn/eqn.y"
{ ERROR "syntax error" WARNING; } break;
case 3:
#line 26 "/sys/src/cmd/eqn/eqn.y"
{ eqnreg = 0; } break;
case 5:
#line 30 "/sys/src/cmd/eqn/eqn.y"
{ eqnbox(yypt[-1].yyv, yypt[-0].yyv, 0); } break;
case 6:
#line 31 "/sys/src/cmd/eqn/eqn.y"
{ eqnbox(yypt[-1].yyv, yypt[-0].yyv, 1); } break;
case 7:
#line 32 "/sys/src/cmd/eqn/eqn.y"
{ lineup(0); } break;
case 8:
#line 35 "/sys/src/cmd/eqn/eqn.y"
{ yyval = yypt[-0].yyv; lineup(1); } break;
case 9:
#line 38 "/sys/src/cmd/eqn/eqn.y"
{ yyval = yypt[-0].yyv; } break;
case 10:
#line 39 "/sys/src/cmd/eqn/eqn.y"
{ yyval = 0; } break;
case 11:
#line 42 "/sys/src/cmd/eqn/eqn.y"
{ yyval = yypt[-0].yyv; } break;
case 12:
#line 43 "/sys/src/cmd/eqn/eqn.y"
{ yyval = 0; } break;
case 13:
#line 46 "/sys/src/cmd/eqn/eqn.y"
{ yyval = yypt[-1].yyv; } break;
case 14:
#line 47 "/sys/src/cmd/eqn/eqn.y"
{ text(QTEXT, (char *) yypt[-0].yyv); } break;
case 15:
#line 48 "/sys/src/cmd/eqn/eqn.y"
{ text(CONTIG, (char *) yypt[-0].yyv); } break;
case 16:
#line 49 "/sys/src/cmd/eqn/eqn.y"
{ text(SPACE, (char *) 0); } break;
case 17:
#line 50 "/sys/src/cmd/eqn/eqn.y"
{ text(THIN, (char *) 0); } break;
case 18:
#line 51 "/sys/src/cmd/eqn/eqn.y"
{ text(TAB, (char *) 0); } break;
case 19:
#line 52 "/sys/src/cmd/eqn/eqn.y"
{ funny(SUM); } break;
case 20:
#line 53 "/sys/src/cmd/eqn/eqn.y"
{ funny(PROD); } break;
case 21:
#line 54 "/sys/src/cmd/eqn/eqn.y"
{ funny(UNION); } break;
case 22:
#line 55 "/sys/src/cmd/eqn/eqn.y"
{ funny(INTER); } break;
case 23:
#line 56 "/sys/src/cmd/eqn/eqn.y"
{ boverb(yypt[-2].yyv, yypt[-0].yyv); } break;
case 24:
#line 57 "/sys/src/cmd/eqn/eqn.y"
{ mark(yypt[-0].yyv); } break;
case 25:
#line 58 "/sys/src/cmd/eqn/eqn.y"
{ size(yypt[-1].yyv, yypt[-0].yyv); } break;
case 26:
#line 59 "/sys/src/cmd/eqn/eqn.y"
{ font(yypt[-1].yyv, yypt[-0].yyv); } break;
case 27:
#line 60 "/sys/src/cmd/eqn/eqn.y"
{ fatbox(yypt[-0].yyv); } break;
case 28:
#line 61 "/sys/src/cmd/eqn/eqn.y"
{ sqrt(yypt[-0].yyv); } break;
case 29:
#line 62 "/sys/src/cmd/eqn/eqn.y"
{ps -= deltaps;} break;
case 30:
#line 62 "/sys/src/cmd/eqn/eqn.y"
{ subsup(yypt[-4].yyv, yypt[-1].yyv, yypt[-0].yyv); } break;
case 31:
#line 63 "/sys/src/cmd/eqn/eqn.y"
{ps -= deltaps;} break;
case 32:
#line 63 "/sys/src/cmd/eqn/eqn.y"
{ subsup(yypt[-3].yyv, 0, yypt[-0].yyv); } break;
case 33:
#line 64 "/sys/src/cmd/eqn/eqn.y"
{ps -= deltaps;} break;
case 34:
#line 64 "/sys/src/cmd/eqn/eqn.y"
{ integral(yypt[-4].yyv, yypt[-1].yyv, yypt[-0].yyv); } break;
case 35:
#line 65 "/sys/src/cmd/eqn/eqn.y"
{ps -= deltaps;} break;
case 36:
#line 65 "/sys/src/cmd/eqn/eqn.y"
{ integral(yypt[-3].yyv, 0, yypt[-0].yyv); } break;
case 37:
#line 66 "/sys/src/cmd/eqn/eqn.y"
{ integral(yypt[-0].yyv, 0, 0); } break;
case 38:
#line 67 "/sys/src/cmd/eqn/eqn.y"
{ps -= deltaps;} break;
case 39:
#line 67 "/sys/src/cmd/eqn/eqn.y"
{ fromto(yypt[-4].yyv, yypt[-1].yyv, yypt[-0].yyv); } break;
case 40:
#line 68 "/sys/src/cmd/eqn/eqn.y"
{ps -= deltaps;} break;
case 41:
#line 68 "/sys/src/cmd/eqn/eqn.y"
{ fromto(yypt[-3].yyv, 0, yypt[-0].yyv); } break;
case 42:
#line 69 "/sys/src/cmd/eqn/eqn.y"
{ paren(yypt[-2].yyv, yypt[-1].yyv, yypt[-0].yyv); } break;
case 43:
#line 70 "/sys/src/cmd/eqn/eqn.y"
{ paren(yypt[-1].yyv, yypt[-0].yyv, 0); } break;
case 44:
#line 71 "/sys/src/cmd/eqn/eqn.y"
{ diacrit(yypt[-1].yyv, yypt[-0].yyv); } break;
case 45:
#line 72 "/sys/src/cmd/eqn/eqn.y"
{ move(FWD, yypt[-1].yyv, yypt[-0].yyv); } break;
case 46:
#line 73 "/sys/src/cmd/eqn/eqn.y"
{ move(UP, yypt[-1].yyv, yypt[-0].yyv); } break;
case 47:
#line 74 "/sys/src/cmd/eqn/eqn.y"
{ move(BACK, yypt[-1].yyv, yypt[-0].yyv); } break;
case 48:
#line 75 "/sys/src/cmd/eqn/eqn.y"
{ move(DOWN, yypt[-1].yyv, yypt[-0].yyv); } break;
case 49:
#line 76 "/sys/src/cmd/eqn/eqn.y"
{ pile(yypt[-0].yyv); ct = yypt[-0].yyv; } break;
case 50:
#line 77 "/sys/src/cmd/eqn/eqn.y"
{yyval=ct;} break;
case 51:
#line 77 "/sys/src/cmd/eqn/eqn.y"
{ matrix(yypt[-3].yyv); ct = yypt[-3].yyv; } break;
case 52:
#line 80 "/sys/src/cmd/eqn/eqn.y"
{ setintegral(); } break;
case 53:
#line 83 "/sys/src/cmd/eqn/eqn.y"
{ yyval = atoi((char *) yypt[-1].yyv); } break;
case 54:
#line 84 "/sys/src/cmd/eqn/eqn.y"
{ yyval = atoi((char *) yypt[-1].yyv); } break;
case 55:
#line 85 "/sys/src/cmd/eqn/eqn.y"
{ yyval = atoi((char *) yypt[-1].yyv); } break;
case 56:
#line 86 "/sys/src/cmd/eqn/eqn.y"
{ yyval = atoi((char *) yypt[-1].yyv); } break;
case 57:
#line 88 "/sys/src/cmd/eqn/eqn.y"
{ yyval = HAT; } break;
case 58:
#line 89 "/sys/src/cmd/eqn/eqn.y"
{ yyval = VEC; } break;
case 59:
#line 90 "/sys/src/cmd/eqn/eqn.y"
{ yyval = DYAD; } break;
case 60:
#line 91 "/sys/src/cmd/eqn/eqn.y"
{ yyval = BAR; } break;
case 61:
#line 92 "/sys/src/cmd/eqn/eqn.y"
{ yyval = LOWBAR; } break;
case 62:
#line 93 "/sys/src/cmd/eqn/eqn.y"
{ yyval = HIGHBAR; } break;
case 63:
#line 94 "/sys/src/cmd/eqn/eqn.y"
{ yyval = UNDER; } break;
case 64:
#line 95 "/sys/src/cmd/eqn/eqn.y"
{ yyval = DOT; } break;
case 65:
#line 96 "/sys/src/cmd/eqn/eqn.y"
{ yyval = TILDE; } break;
case 66:
#line 97 "/sys/src/cmd/eqn/eqn.y"
{ yyval = UTILDE; } break;
case 67:
#line 98 "/sys/src/cmd/eqn/eqn.y"
{ yyval = DOTDOT; } break;
case 68:
#line 101 "/sys/src/cmd/eqn/eqn.y"
{ yyval = ((char *)yypt[-0].yyv)[0]; } break;
case 69:
#line 102 "/sys/src/cmd/eqn/eqn.y"
{ yyval = '{'; } break;
case 70:
#line 105 "/sys/src/cmd/eqn/eqn.y"
{ yyval = ((char *)yypt[-0].yyv)[0]; } break;
case 71:
#line 106 "/sys/src/cmd/eqn/eqn.y"
{ yyval = '}'; } break;
case 74:
#line 113 "/sys/src/cmd/eqn/eqn.y"
{ column(yypt[-3].yyv, DEFGAP); } break;
case 75:
#line 114 "/sys/src/cmd/eqn/eqn.y"
{yyval=atoi((char*)yypt[-0].yyv);} break;
case 76:
#line 114 "/sys/src/cmd/eqn/eqn.y"
{ column(yypt[-5].yyv, yypt[-3].yyv); } break;
case 77:
#line 117 "/sys/src/cmd/eqn/eqn.y"
{ yyval = startcol(LCOL); } break;
case 78:
#line 118 "/sys/src/cmd/eqn/eqn.y"
{ yyval = startcol(CCOL); } break;
case 79:
#line 119 "/sys/src/cmd/eqn/eqn.y"
{ yyval = startcol(RCOL); } break;
case 80:
#line 120 "/sys/src/cmd/eqn/eqn.y"
{ yyval = startcol(COL); } break;
case 81:
#line 123 "/sys/src/cmd/eqn/eqn.y"
{ lp[ct++] = yypt[-0].yyv; } break;
case 82:
#line 124 "/sys/src/cmd/eqn/eqn.y"
{ lp[ct++] = yypt[-0].yyv; } break;
case 83:
#line 127 "/sys/src/cmd/eqn/eqn.y"
{ yyval = ps; setsize((char *) yypt[-0].yyv); } break;
case 84:
#line 130 "/sys/src/cmd/eqn/eqn.y"
{ static char R[]="R"; setfont(R); } break;
case 85:
#line 131 "/sys/src/cmd/eqn/eqn.y"
{ static char I[]="I"; setfont(I); } break;
case 86:
#line 132 "/sys/src/cmd/eqn/eqn.y"
{ static char B[]="B"; setfont(B); } break;
case 87:
#line 133 "/sys/src/cmd/eqn/eqn.y"
{ setfont((char *)yypt[-0].yyv); } break;
}
goto yystack; /* stack new state and value */
}