void stmt_list_parse(node* list) {
while(list) {
if(list && list->type == LIST_NODE) {
node* n = list->u.list.start;
if(n->type == ASSIGN_NODE) {
//printf("generating assignment quad in BB %s\n", currentBlock->name);
gen_assign(n);
} else if(n->type == BINOP_NODE) {
gen_rvalue(n, NULL);
} else if(n->type == UNOP_NODE) {
gen_rvalue(n, NULL);
} else if(n->type == IF_NODE || n->type == IFELSE_NODE) {
gen_if(n);
} else if(n->type == FOR_NODE) {
gen_for(n);
} else if(n->type == WHILE_NODE) {
gen_while(n);
} else if(n->type == JUMP_NODE) {
gen_jmp(n);
} else if(n->type == CALL_NODE) { //Function Call
int argnum = n->u.call.argnum;
qnode* num = qnode_new(Q_CONSTANT);
num->name = malloc(100);
sprintf(num->name, "%i", argnum);
num->u.value = argnum;
emit(O_ARGNUM, NULL, num, NULL);
if(argnum) { //Generate argument quad
node* argptr = n->u.call.args;
while(argptr) {
emit(O_ARGDEF, NULL, gen_rvalue(argptr->u.list.start, NULL), NULL);
if(argptr->next) {
argptr = argptr->next;
} else {
break;
}
}
}
emit(O_CALL, NULL, gen_rvalue(n->u.call.function, NULL), NULL);
} else if(n->type == IDENT_NODE || n->type == DEFAULT_NODE) {
//do nothing
} else {
fprintf(stderr, "QUAD ERROR: Unrecognized Node Type %i\n", n->type);
exit(1);
}
if(list->next) {
list = list->next;
} else {
break;
}
} else {
fprintf(stderr, "QUAD ERROR: Invalid Statement List\n");
break;
}
}
}
void genstmt(SNODE *stmt)
/*
* genstmt will generate a statement and follow the next pointer
* until the block is generated.
*/
{
while( stmt != 0 )
{
switch( stmt->stype )
{
case st_block:
genstmt(stmt->exp);
break;
case st_label:
gen_label((int)stmt->label);
break;
case st_goto:
gen_code(op_jmp,0,make_label((int)stmt->label),0);
break;
case st_expr:
initstack();
gen_expr(stmt->exp,F_ALL | F_NOVALUE,
natural_size(stmt->exp));
break;
case st_return:
genreturn(stmt,0);
break;
case st_if:
genif(stmt);
break;
case st_while:
genwhile(stmt);
break;
case st_do:
gendo(stmt);
break;
case st_for:
gen_for(stmt);
break;
case st_continue:
gen_code(op_jmp,0,make_label(contlab),0);
break;
case st_break:
gen_code(op_jmp,0,make_label(breaklab),0);
break;
case st_switch:
genxswitch(stmt);
break;
case st_line:
gen_line(stmt);
break;
case st_asm:
if (stmt->exp)
add_peep(stmt->exp);
break;
case st__genword:
gen_code(op_genword,0,make_immed((int)stmt->exp),0);
break;
default:
diag("unknown statement.");
break;
}
stmt = stmt->next;
}
}
void INT_CXX_action( const act* action, int column)
{
// Put leading braces where required
switch (action->act_type)
{
case ACT_for:
case ACT_insert:
case ACT_modify:
case ACT_store:
case ACT_s_fetch:
case ACT_s_start:
begin(column);
align(column);
}
switch (action->act_type)
{
case ACT_at_end:
gen_at_end(action, column);
return;
case ACT_b_declare:
case ACT_database:
gen_database();
return;
case ACT_endfor:
gen_endfor(action, column);
break;
case ACT_endmodify:
gen_emodify(action, column);
break;
case ACT_endstore:
gen_estore(action, column, false);
break;
case ACT_endstore_special:
gen_estore(action, column, true);
break;
case ACT_erase:
gen_erase(action, column);
return;
case ACT_for:
gen_for(action, column);
return;
case ACT_hctef:
break;
case ACT_insert:
case ACT_routine:
gen_routine(action, column);
return;
case ACT_s_end:
gen_s_end(action, column);
return;
case ACT_s_fetch:
gen_s_fetch(action, column);
return;
case ACT_s_start:
gen_s_start(action, column);
break;
case ACT_type_number:
gen_type(action, column);
return;
case ACT_variable:
gen_variable(action, column);
return;
default:
return;
}
// Put in a trailing brace for those actions still with us
endp(column);
}
static void gen_statement( qli_nod* node, qli_req* request)
{
/**************************************
*
* g e n _ s t a t e m e n t
*
**************************************
*
* Functional description
* Generate BLR for statement.
*
**************************************/
if (request)
CHECK_RLB(request->req_blr);
switch (node->nod_type)
{
case nod_abort:
if (node->nod_count)
gen_expression(node->nod_arg[0], 0);
return;
case nod_assign:
gen_assignment(node, request);
return;
case nod_commit_retaining:
return;
case nod_erase:
gen_erase(node, request);
return;
case nod_for:
case nod_report_loop:
gen_for(node, request);
return;
case nod_list:
{
qli_nod** ptr = node->nod_arg;
for (const qli_nod* const* const end = ptr + node->nod_count; ptr < end; ++ptr)
{
gen_statement(*ptr, request);
}
return;
}
case nod_modify:
gen_modify(node); //, request);
return;
case nod_output:
gen_statement(node->nod_arg[e_out_statement], request);
return;
case nod_print:
gen_print_list(node->nod_arg[e_prt_list], request);
return;
case nod_repeat:
gen_statement(node->nod_arg[e_rpt_statement], request);
return;
case nod_report:
gen_report(node, request);
return;
case nod_store:
gen_store(node, request);
return;
case nod_if:
gen_if(node, request);
return;
default:
ERRQ_bugcheck(354); // Msg354 gen_statement: not yet implemented
}
}
