struct burm_state *burm_label1(NODEPTR u) {
int op, arity, i, immed_matched=0;
COST c=COST_ZERO;
struct burm_state *s,**k;
NODEPTR *children;
op=OP_LABEL(u);
arity=burm_arity[op];
switch(op){
case 0: /* BURP */
s=burm_alloc_state(u,op,arity);
SET_STATE(u,s);
k=s->kids;
/*immediate rule: stmt: BURP(_,_,_) */
if(burm_cost_code(&c,0,s) && COST_LESS(c,s->cost[burm_stmt_NT])) {
burm_trace(burm_np, 0, c); s->cost[burm_stmt_NT] = c ;
s->rule.burm_stmt = 1;
immed_matched=1;
}
if(immed_matched){
for(i=0;i<arity;i++)k[i]=0;
return s;
}
break;
case 1: /* ADDI */
s=burm_alloc_state(u,op,arity);
SET_STATE(u,s);
k=s->kids;
children=GET_KIDS(u);
for(i=0;i<arity;i++)
k[i]=burm_label1(children[i]);
if ( /* disp: ADDI(reg,con) */
k[0]->rule.burm_reg &&
k[1]->rule.burm_con
) {
if(burm_cost_code(&c,7,s) && COST_LESS(c,s->cost[burm_disp_NT])) {
burm_trace(burm_np, 7, c); s->cost[burm_disp_NT] = c ;
s->rule.burm_disp = 1;
burm_closure_disp(s, c );
}
}
if ( /* reg: ADDI(reg,rc) */
k[0]->rule.burm_reg &&
k[1]->rule.burm_rc
) {
if(burm_cost_code(&c,3,s) && COST_LESS(c,s->cost[burm_reg_NT])) {
burm_trace(burm_np, 3, c); s->cost[burm_reg_NT] = c ;
s->rule.burm_reg = 1;
burm_closure_reg(s, c );
}
}
break;
case 2: /* ADDRLP */
#ifdef LEAF_TRAP
if(s=LEAF_TRAP(u,op))
return s;
#endif
s=burm_alloc_state(u,op,arity);
SET_STATE(u,s);
k=0;
{ /* disp: ADDRLP */
if(burm_cost_code(&c,8,s) && COST_LESS(c,s->cost[burm_disp_NT])) {
burm_trace(burm_np, 8, c); s->cost[burm_disp_NT] = c ;
s->rule.burm_disp = 2;
burm_closure_disp(s, c );
}
}
break;
case 3: /* ASGNI */
s=burm_alloc_state(u,op,arity);
SET_STATE(u,s);
k=s->kids;
children=GET_KIDS(u);
for(i=0;i<arity;i++)
k[i]=burm_label1(children[i]);
if ( /* stmt: ASGNI(disp,reg) */
k[0]->rule.burm_disp &&
k[1]->rule.burm_reg
) {
if(burm_cost_code(&c,1,s) && COST_LESS(c,s->cost[burm_stmt_NT])) {
burm_trace(burm_np, 1, c); s->cost[burm_stmt_NT] = c ;
s->rule.burm_stmt = 2;
}
}
break;
case 4: /* CNSTI */
#ifdef LEAF_TRAP
if(s=LEAF_TRAP(u,op))
return s;
#endif
s=burm_alloc_state(u,op,arity);
SET_STATE(u,s);
k=0;
{ /* con: CNSTI */
if(burm_cost_code(&c,11,s) && COST_LESS(c,s->cost[burm_con_NT])) {
burm_trace(burm_np, 11, c); s->cost[burm_con_NT] = c ;
s->rule.burm_con = 1;
burm_closure_con(s, c );
}
}
break;
case 5: /* CVCI */
s=burm_alloc_state(u,op,arity);
SET_STATE(u,s);
k=s->kids;
children=GET_KIDS(u);
for(i=0;i<arity;i++)
k[i]=burm_label1(children[i]);
if ( /* reg: CVCI(INDIRC(disp)) */
k[0]->op == 7 && /* INDIRC */
k[0]->kids[0]->rule.burm_disp
) {
if(burm_cost_code(&c,4,s) && COST_LESS(c,s->cost[burm_reg_NT])) {
burm_trace(burm_np, 4, c); s->cost[burm_reg_NT] = c ;
s->rule.burm_reg = 2;
burm_closure_reg(s, c );
}
}
break;
case 6: /* I0I */
#ifdef LEAF_TRAP
if(s=LEAF_TRAP(u,op))
return s;
#endif
s=burm_alloc_state(u,op,arity);
SET_STATE(u,s);
k=0;
{ /* con: I0I */
if(burm_cost_code(&c,12,s) && COST_LESS(c,s->cost[burm_con_NT])) {
burm_trace(burm_np, 12, c); s->cost[burm_con_NT] = c ;
s->rule.burm_con = 2;
burm_closure_con(s, c );
}
}
{ /* reg: I0I */
if(burm_cost_code(&c,5,s) && COST_LESS(c,s->cost[burm_reg_NT])) {
burm_trace(burm_np, 5, c); s->cost[burm_reg_NT] = c ;
s->rule.burm_reg = 3;
burm_closure_reg(s, c );
}
}
break;
case 7: /* INDIRC */
s=burm_alloc_state(u,op,arity);
SET_STATE(u,s);
k=s->kids;
children=GET_KIDS(u);
for(i=0;i<arity;i++)
k[i]=burm_label1(children[i]);
break;
default:
burm_assert(0, PANIC("Bad operator %d in burm_state\n", op));
}
return s;
}
STATE_TYPE burm_state(int op, STATE_TYPE left, STATE_TYPE right) {
int c;
struct burm_state *p, *l = (struct burm_state *)left,
*r = (struct burm_state *)right;
assert(sizeof (STATE_TYPE) >= sizeof (void *));
if (burm_arity[op] > 0) {
p = ALLOC(sizeof *p);
burm_assert(p, PANIC("ALLOC returned NULL in burm_state\n"));
p->op = op;
p->left = l;
p->right = r;
p->rule.burm_stmt = 0;
p->cost[1] =
p->cost[2] =
p->cost[3] =
p->cost[4] =
p->cost[5] =
32767;
}
switch (op) {
case 21: /* CNSTI */
{
static struct burm_state z = { 21, 0, 0,
{ 0,
32767,
32767,
32767,
0, /* rc: con */
0, /* con: CNSTI */
},{
0,
0,
0,
1, /* rc: con */
1, /* con: CNSTI */
}
};
return (STATE_TYPE)&z;
}
case 53: /* ASGNI */
assert(l && r);
{ /* stmt: ASGNI(disp,reg) */
c = l->cost[burm_disp_NT] + r->cost[burm_reg_NT] + 1;
if (c + 0 < p->cost[burm_stmt_NT]) {
p->cost[burm_stmt_NT] = c + 0;
p->rule.burm_stmt = 1;
}
}
break;
case 67: /* INDIRC */
assert(l);
break;
case 85: /* CVCI */
assert(l);
if ( /* reg: CVCI(INDIRC(disp)) */
l->op == 67 /* INDIRC */
) {
c = l->left->cost[burm_disp_NT] + 1;
if (c + 0 < p->cost[burm_reg_NT]) {
p->cost[burm_reg_NT] = c + 0;
p->rule.burm_reg = 2;
burm_closure_reg(p, c + 0);
}
}
break;
case 295: /* ADDRLP */
{
static struct burm_state z = { 295, 0, 0,
{ 0,
1, /* stmt: reg */
0, /* disp: ADDRLP */
1, /* reg: disp */
1, /* rc: reg */
32767,
},{
2, /* stmt: reg */
2, /* disp: ADDRLP */
4, /* reg: disp */
2, /* rc: reg */
0,
}
};
return (STATE_TYPE)&z;
}
case 309: /* ADDI */
assert(l && r);
{ /* disp: ADDI(reg,con) */
c = l->cost[burm_reg_NT] + r->cost[burm_con_NT] + 0;
if (c + 0 < p->cost[burm_disp_NT]) {
p->cost[burm_disp_NT] = c + 0;
p->rule.burm_disp = 1;
burm_closure_disp(p, c + 0);
}
}
{ /* reg: ADDI(reg,rc) */
c = l->cost[burm_reg_NT] + r->cost[burm_rc_NT] + 1;
if (c + 0 < p->cost[burm_reg_NT]) {
p->cost[burm_reg_NT] = c + 0;
p->rule.burm_reg = 1;
burm_closure_reg(p, c + 0);
}
}
break;
case 661: /* I0I */
{
static struct burm_state z = { 661, 0, 0,
{ 0,
0, /* stmt: reg */
32767,
0, /* reg: I0I */
0, /* rc: con */
0, /* con: I0I */
},{
2, /* stmt: reg */
0,
3, /* reg: I0I */
1, /* rc: con */
2, /* con: I0I */
}
};
return (STATE_TYPE)&z;
}
default:
burm_assert(0, PANIC("Bad operator %d in burm_state\n", op));
}
return (STATE_TYPE)p;
}
