NODEPTR burm_child(NODEPTR p, int index) {
NODEPTR *kids;
burm_assert(p, PANIC("NULL tree in burm_child\n"));
kids=GET_KIDS(p);
burm_assert((0<=index && index<burm_arity[OP_LABEL(p)]),
PANIC("Bad index %d in burm_child\n", index));
return kids[index];
}
code_ptr *create_code(int type, code_ptr* left_child, code_ptr* right_child) {
code_ptr *c = (code_ptr *)malloc(sizeof(code_ptr));
OP_LABEL(c) = type;
LEFT_CHILD(c) = left_child;
RIGHT_CHILD(c) = right_child;
return c;
}
struct code* create_code (int type, struct code *left_child, struct code *right_child)
{
struct code *c = malloc (sizeof (struct code));
OP_LABEL (c) = type;
LEFT_CHILD (c) = left_child;
RIGHT_CHILD (c) = right_child;
return c;
}
static void burm_label1(NODEPTR_TYPE p) {
burm_assert(p, PANIC("NULL tree in burm_label\n"));
switch (burm_arity[OP_LABEL(p)]) {
case 0:
STATE_LABEL(p) = burm_state(OP_LABEL(p), 0, 0);
break;
case 1:
burm_label1(LEFT_CHILD(p));
STATE_LABEL(p) = burm_state(OP_LABEL(p),
STATE_LABEL(LEFT_CHILD(p)), 0);
break;
case 2:
burm_label1(LEFT_CHILD(p));
burm_label1(RIGHT_CHILD(p));
STATE_LABEL(p) = burm_state(OP_LABEL(p),
STATE_LABEL(LEFT_CHILD(p)),
STATE_LABEL(RIGHT_CHILD(p)));
break;
}
}
int burm_op_label(NODEPTR p) {
burm_assert(p, PANIC("NULL tree in burm_op_label\n"));
return OP_LABEL(p);
}
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;
}
