intercodes translate_Cond(struct Node *node,operand label_true,operand label_false) {
struct Node *child = node->child;
assert(child != NULL);
intercodes code1,code2,code3,code4;
//Exp1 RELOP Exp2
if (child->sibling != NULL && strcmp(child->sibling->type,"RELOP") == 0) {
operand t1 = new_tmp();
operand t2 = new_tmp();
code1 = translate_Exp(child,t1);
code2 = translate_Exp(child->sibling->sibling,t2);
relop_type type = get_relop(child->sibling);
code3 = gen_triop(type,t1,t2,label_true);
code4 = gen_one(GOTO_K,label_false);
code1 = link(code1,code2);
code1 = link(code1,code3);
code1 = link(code1,code4);
return code1;
}
//NOT Exp1
if (strcmp(child->type,"NOT") == 0)
return translate_Cond(child->sibling,label_true,label_false);
//Exp1 AND Exp2
if (child->sibling != NULL && strcmp(child->sibling->type,"AND") == 0) {
operand label1 = new_label();
code1 = translate_Cond(child,label1,label_false);
code2 = translate_Cond(child->sibling->sibling,label_true,label_false);
code3 = gen_one(LABEL_K,label1);
code1 = link(code1,code3);
code1 = link(code1,code2);
return code1;
}
//Exp1 OR Exp2
if (child->sibling != NULL && strcmp(child->sibling->type,"OR") == 0) {
operand label1 = new_label();
code1 = translate_Cond(child,label_true,label1);
code2 = translate_Cond(child->sibling->sibling,label_true,label_false);
code3 = gen_one(LABEL_K,label1);
code1 = link(code1,code3);
code1 = link(code1,code2);
return code1;
}
//other cases
operand t1 = new_tmp();
code1 = translate_Exp(node,t1);
operand c1 = new_constant(0);
code2 = gen_triop(NE,t1,c1,label_true);
code3 = gen_one(LABEL_K,label_false);
code1 = link(code1,code2);
code1 = link(code1,code3);
return code1;
}
intercodes translate_FunDec(struct Node *node) {
intercodes code1,code2;
struct Node *child = node->child;
assert(child != NULL);
char *func_name = child->text;
// struct funMes *func_node = getFunMes(child);
// assert(func_node != NULL);
operand f1 = new_function(func_name);
code1 = gen_one(FUNCTION_K,f1);
//ID LP VarList RP
if (child->sibling->sibling->sibling != NULL) {
/* struct argList *param = func_node->arg;
while (param != NULL) {
if (param->aType == varStruct) {
printf("Cannot translate: Code contains variables or parameters of structure type.\n");
exit(-1);
}
operand p1 = new_var(getVarIDbyName(param->name));
code2 = gen_one(PARAM_K,p1);
code1 = link(code1,code2);
param = param->next;
}*/
code2 = translate_VarList(child->sibling->sibling);
// code1 = link(code1,code2);
return code1;
}
//ID LP RP
return code1;
}
void c_typecastt::do_typecast(exprt &expr, const typet &type)
{
// special case: array -> pointer is actually
// something like address_of
const typet &expr_type=ns.follow(expr.type());
if(expr_type.id()==ID_array)
{
index_exprt index;
index.array()=expr;
index.index()=gen_zero(index_type());
index.type()=expr_type.subtype();
expr=address_of_exprt(index);
if(ns.follow(expr.type())!=ns.follow(type))
expr.make_typecast(type);
return;
}
if(expr_type!=type)
{
// C booleans are special: we compile to ?0:1
if(type.get(ID_C_c_type)==ID_bool)
{
if(expr_type.id()==ID_bool) // bool -> _Bool
{
exprt result=if_exprt(expr, gen_one(type), gen_zero(type));
expr.swap(result);
}
else // * -> _Bool
{
equal_exprt equal_zero(expr, gen_zero(expr_type));
exprt result=if_exprt(equal_zero, gen_zero(type), gen_one(type));
expr.swap(result);
}
}
else
{
expr.make_typecast(type);
}
}
}
exprt gen_one(const typet &type)
{
const irep_idt type_id=type.id();
exprt result=constant_exprt(type);
if(type_id==ID_bool ||
type_id==ID_rational ||
type_id==ID_real ||
type_id==ID_integer ||
type_id==ID_natural)
{
result.set(ID_value, ID_1);
}
else if(type_id==ID_unsignedbv ||
type_id==ID_signedbv ||
type_id==ID_c_enum)
{
std::string value;
unsigned width=to_bitvector_type(type).get_width();
for(unsigned i=0; i<width-1; i++)
value+='0';
value+='1';
result.set(ID_value, value);
}
else if(type_id==ID_fixedbv)
{
fixedbvt fixedbv;
fixedbv.spec=to_fixedbv_type(type);
fixedbv.from_integer(1);
result=fixedbv.to_expr();
}
else if(type_id==ID_floatbv)
{
ieee_floatt ieee_float;
ieee_float.spec=to_floatbv_type(type);
ieee_float.from_integer(1);
result=ieee_float.to_expr();
}
else if(type_id==ID_complex)
{
result=exprt(ID_complex, type);
result.operands().resize(2);
result.op0()=gen_one(type.subtype());
result.op1()=gen_zero(type.subtype());
}
else
result.make_nil();
return result;
}
void AzpLmSgd::_updateDelta(int d_num,
const AzpLmParam &p,
const M *m_x,
const AzPmat *m_deriv)
{
if (p.dont_update()) return;
AzX::no_support((grad_num != 0), "AzpLmSgd::_updateDelta", "Multiple updateDelta before flushing");
if (doing_partial()) {
if (do_gradpart) AzPs::prod(&m_w_grad, m_x, m_deriv, false, true);
else {
AzPmat m;
AzPs::prod(&m, m_x, m_deriv, false, true);
m_w_grad.zeroOut();
m_w_grad.add_s2d(&m, ia_p2w.point(), ia_p2w.size()); /* d2s -> s2d: 04/22/2015 */
}
}
else {
AzPs::prod(&m_w_grad, m_x, m_deriv, false, true);
}
if (!p.do_no_intercept) {
gen_one(m_x->colNum(), &m_one);
if (doing_partial()) {
if (do_gradpart) v_i_grad.prod(&m_one, m_deriv, false, true);
else {
AzPmat m; m.prod(&m_one, m_deriv, false, true);
v_i_grad.zeroOut();
v_i_grad.add_s2d(&m, ia_p2w.point(), ia_p2w.size()); /* d2s -> s2d: 04/22/2015 */
}
}
else v_i_grad.prod(&m_one, m_deriv, false, true);
}
if (p.do_count_regions) grad_num = m_x->colNum();
else grad_num = d_num;
}
void string_instrumentationt::do_format_string_write(
goto_programt &dest,
goto_programt::const_targett target,
const code_function_callt::argumentst &arguments,
unsigned format_string_inx,
unsigned argument_start_inx,
const std::string &function_name)
{
const exprt &format_arg = arguments[format_string_inx];
if(format_arg.id()=="address_of" &&
format_arg.op0().id()=="index" &&
format_arg.op0().op0().id()==ID_string_constant) // constant format
{
format_token_listt token_list;
parse_format_string(format_arg.op0().op0(), token_list);
unsigned args=0;
for(format_token_listt::const_iterator it=token_list.begin();
it!=token_list.end();
it++)
{
if(find(it->flags.begin(), it->flags.end(), format_tokent::ASTERISK)!=
it->flags.end())
continue; // asterisk means `ignore this'
switch(it->type)
{
case format_tokent::STRING:
{
const exprt &argument=arguments[argument_start_inx+args];
const typet &arg_type=ns.follow(argument.type());
goto_programt::targett assertion=dest.add_instruction();
assertion->location=target->location;
assertion->location.set("property", "string");
std::string comment("format string buffer overflow in ");
comment += function_name;
assertion->location.set("comment", comment);
if(it->field_width!=0)
{
exprt fwidth = from_integer(it->field_width, uint_type());
exprt fw_1("+", uint_type());
exprt one = gen_one(uint_type());
fw_1.move_to_operands(fwidth);
fw_1.move_to_operands(one); // +1 for 0-char
exprt fw_lt_bs;
if(arg_type.id()=="pointer")
fw_lt_bs=binary_relation_exprt(fw_1, "<=", buffer_size(argument));
else
{
index_exprt index;
index.array()=argument;
index.index()=gen_zero(uint_type());
address_of_exprt aof(index);
fw_lt_bs=binary_relation_exprt(fw_1, "<=", buffer_size(aof));
}
assertion->make_assertion(fw_lt_bs);
}
else
{
// this is a possible overflow.
assertion->make_assertion(false_exprt());
}
// now kill the contents
invalidate_buffer(dest, target, argument, arg_type, it->field_width);
args++;
break;
}
case format_tokent::TEXT:
case format_tokent::UNKNOWN:
{
// nothing
break;
}
default: // everything else
{
const exprt &argument=arguments[argument_start_inx+args];
const typet &arg_type=ns.follow(argument.type());
goto_programt::targett assignment=dest.add_instruction(ASSIGN);
assignment->location=target->location;
exprt lhs("dereference", arg_type.subtype());
lhs.copy_to_operands(argument);
exprt rhs=side_effect_expr_nondett(lhs.type());
rhs.location()=target->location;
assignment->code=code_assignt(lhs, rhs);
args++;
break;
}
}
}
}
else // non-const format string
{
for(unsigned i=argument_start_inx; i<arguments.size(); i++)
{
const typet &arg_type=ns.follow(arguments[i].type());
// Note: is_string_type() is a `good guess' here. Actually
// any of the pointers could point into an array. But it
// would suck if we had to invalidate all variables.
// Luckily this case isn't needed too often.
if(is_string_type(arg_type))
{
goto_programt::targett assertion=dest.add_instruction();
assertion->location=target->location;
assertion->location.set("property", "string");
std::string comment("format string buffer overflow in ");
comment += function_name;
assertion->location.set("comment", comment);
// as we don't know any field width for the %s that
// should be here during runtime, we just report a
// possibly false positive
assertion->make_assertion(false_exprt());
invalidate_buffer(dest, target, arguments[i], arg_type, 0);
}
else
{
goto_programt::targett assignment = dest.add_instruction(ASSIGN);
assignment->location=target->location;
exprt lhs("dereference", arg_type.subtype());
lhs.copy_to_operands(arguments[i]);
exprt rhs=side_effect_expr_nondett(lhs.type());
rhs.location()=target->location;
assignment->code=code_assignt(lhs, rhs);
}
}
}
}
void string_instrumentationt::invalidate_buffer(
goto_programt &dest,
goto_programt::const_targett target,
const exprt &buffer,
const typet &buf_type,
const mp_integer &limit)
{
irep_idt cntr_id="string_instrumentation::$counter";
if(context.symbols.find(cntr_id)==context.symbols.end())
{
symbolt new_symbol;
new_symbol.base_name="$counter";
new_symbol.pretty_name=new_symbol.base_name;
new_symbol.name=cntr_id;
new_symbol.mode="C";
new_symbol.type=uint_type();
new_symbol.is_statevar=true;
new_symbol.lvalue=true;
new_symbol.static_lifetime=true;
context.move(new_symbol);
}
const symbolt &cntr_sym=ns.lookup(cntr_id);
// create a loop that runs over the buffer
// and invalidates every element
goto_programt::targett init=dest.add_instruction(ASSIGN);
init->location=target->location;
init->code=code_assignt(symbol_expr(cntr_sym), gen_zero(cntr_sym.type));
goto_programt::targett check=dest.add_instruction();
check->location=target->location;
goto_programt::targett invalidate=dest.add_instruction(ASSIGN);
invalidate->location=target->location;
goto_programt::targett increment=dest.add_instruction(ASSIGN);
increment->location=target->location;
exprt plus("+", uint_type());
plus.copy_to_operands(symbol_expr(cntr_sym));
plus.copy_to_operands(gen_one(uint_type()));
increment->code=code_assignt(symbol_expr(cntr_sym), plus);
goto_programt::targett back=dest.add_instruction();
back->location=target->location;
back->make_goto(check);
back->guard=true_exprt();
goto_programt::targett exit=dest.add_instruction();
exit->location=target->location;
exit->make_skip();
exprt cnt_bs, bufp;
if(buf_type.id()=="pointer")
bufp = buffer;
else
{
index_exprt index;
index.array()=buffer;
index.index()=gen_zero(uint_type());
index.type()=buf_type.subtype();
bufp = address_of_exprt(index);
}
exprt deref("dereference", buf_type.subtype());
exprt b_plus_i("+", bufp.type());
b_plus_i.copy_to_operands(bufp);
b_plus_i.copy_to_operands(symbol_expr(cntr_sym));
deref.copy_to_operands(b_plus_i);
check->make_goto(exit);
if(limit==0)
check->guard=
binary_relation_exprt(symbol_expr(cntr_sym), ">=",
buffer_size(bufp));
else
check->guard=
binary_relation_exprt(symbol_expr(cntr_sym), ">",
from_integer(limit, uint_type()));
exprt nondet=side_effect_expr_nondett(buf_type.subtype());
invalidate->code=code_assignt(deref, nondet);
}
void goto_convertt::do_java_new_array(
const exprt &lhs,
const side_effect_exprt &rhs,
goto_programt &dest)
{
if(lhs.is_nil())
throw "do_java_new_array without lhs is yet to be implemented";
source_locationt location=rhs.source_location();
assert(rhs.operands().size()>=1); // one per dimension
if(rhs.type().id()!=ID_pointer)
throw "do_java_new_array returns pointer";
typet object_type=rhs.type().subtype();
// build size expression
exprt object_size=size_of_expr(object_type, ns);
if(object_size.is_nil())
throw "do_java_new_array got nil object_size";
// we produce a malloc side-effect, which stays
side_effect_exprt malloc_expr(ID_malloc);
malloc_expr.copy_to_operands(object_size);
malloc_expr.type()=pointer_typet(object_type);
goto_programt::targett t_n=dest.add_instruction(ASSIGN);
t_n->code=code_assignt(lhs, malloc_expr);
t_n->source_location=location;
// multi-dimensional?
assert(ns.follow(object_type).id()==ID_struct);
const struct_typet &struct_type=to_struct_type(ns.follow(object_type));
assert(struct_type.components().size()==3);
// if it's an array, we need to set the length field
dereference_exprt deref(lhs, object_type);
member_exprt length(deref, struct_type.components()[1].get_name(), struct_type.components()[1].type());
goto_programt::targett t_s=dest.add_instruction(ASSIGN);
t_s->code=code_assignt(length, rhs.op0());
t_s->source_location=location;
// we also need to allocate space for the data
member_exprt data(deref, struct_type.components()[2].get_name(), struct_type.components()[2].type());
side_effect_exprt data_cpp_new_expr(ID_cpp_new_array, data.type());
data_cpp_new_expr.set(ID_size, rhs.op0());
goto_programt::targett t_p=dest.add_instruction(ASSIGN);
t_p->code=code_assignt(data, data_cpp_new_expr);
t_p->source_location=location;
// zero-initialize the data
exprt zero_element=gen_zero(data.type().subtype());
codet array_set(ID_array_set);
array_set.copy_to_operands(data, zero_element);
goto_programt::targett t_d=dest.add_instruction(OTHER);
t_d->code=array_set;
t_d->source_location=location;
if(rhs.operands().size()>=2)
{
// produce
// for(int i=0; i<size; i++) tmp[i]=java_new(dim-1);
// This will be converted recursively.
goto_programt tmp;
symbol_exprt tmp_i=
new_tmp_symbol(index_type(), "index", tmp, location).symbol_expr();
code_fort for_loop;
side_effect_exprt sub_java_new=rhs;
sub_java_new.operands().erase(sub_java_new.operands().begin());
side_effect_exprt inc(ID_assign);
inc.operands().resize(2);
inc.op0()=tmp_i;
inc.op1()=plus_exprt(tmp_i, gen_one(tmp_i.type()));
dereference_exprt deref_expr(plus_exprt(data, tmp_i), data.type().subtype());
for_loop.init()=code_assignt(tmp_i, gen_zero(tmp_i.type()));
for_loop.cond()=binary_relation_exprt(tmp_i, ID_lt, rhs.op0());
for_loop.iter()=inc;
for_loop.body()=code_skipt();
for_loop.body()=code_assignt(deref_expr, sub_java_new);
convert(for_loop, tmp);
dest.destructive_append(tmp);
}
}
intercodes translate_Stmt(struct Node *node) {
struct Node *child = node->child;
assert(child != NULL);
intercodes code1,code2,code3,code4,code5,code6,code7;
//Exp SEMI
if (strcmp(child->type,"Exp") == 0) {
return translate_Exp(child,NULL);
}
//CompSt
if (strcmp(child->type,"CompSt") == 0) return translate_CompSt(child);
//RETURN Exp SEMI
if (strcmp(child->type,"RETURN") == 0) {
operand t1 = new_tmp();
code1 = translate_Exp(child->sibling,t1);
code2 = gen_one(RETURN_K,t1);
// code1 = link(code1,code2);
return code1;
}
if (strcmp(child->type,"IF") == 0) {
struct Node *brother = child->sibling->sibling->sibling->sibling->sibling;
//IF LP Exp RP Stmt1
if (brother == NULL) {
operand label1 = new_label();
operand label2 = new_label();
code1 = translate_Cond(child->sibling->sibling,label1,label2);
code2 = translate_Stmt(child->sibling->sibling->sibling->sibling);
code3 = gen_one(LABEL_K,label1);
code4 = gen_one(LABEL_K,label2);
code1 = link(code1,code3);
code1 = link(code1,code2);
code1 = link(code1,code4);
return code1;
}
//IF LP Exp RP Stmt1 ELSE Stmt2
else {
operand label1 = new_label();
operand label2 = new_label();
operand label3 = new_label();
code1 = translate_Cond(child->sibling->sibling,label1,label2);
code2 = translate_Stmt(child->sibling->sibling->sibling->sibling);
code3 = translate_Stmt(brother->sibling);
code4 = gen_one(LABEL_K,label1);
code5 = gen_one(LABEL_K,label2);
code6 = gen_one(LABEL_K,label3);
code7 = gen_one(GOTO_K,label3);
code1 = link(code1,code4);
code1 = link(code1,code2);
code1 = link(code1,code7);
code1 = link(code1,code5);
code1 = link(code1,code3);
code1 = link(code1,code6);
return code1;
}
}
//WHILE LP Exp RP Stmt1
if (strcmp(child->type,"WHILE") == 0) {
operand label1 = new_label();
operand label2 = new_label();
operand label3 = new_label();
code1 = translate_Cond(child->sibling->sibling,label2,label3);
code2 = translate_Stmt(child->sibling->sibling->sibling->sibling);
code3 = gen_one(LABEL_K,label1);
code4 = gen_one(LABEL_K,label2);
code5 = gen_one(LABEL_K,label3);
code6 = gen_one(GOTO_K,label1);
code1 = link(code3,code1);
code1 = link(code1,code4);
code1 = link(code1,code2);
code1 = link(code1,code6);
code1 = link(code1,code5);
return code1;
}
return NULL;
}
//translate
intercodes translate_Exp(struct Node *node, operand place) {
struct Node *child = node->child;
assert(child != NULL);
intercodes code1 = NULL;
intercodes code2 = NULL;
intercodes code3 = NULL;
intercodes code4 = NULL;
intercodes code5 = NULL;
//INT
if (strcmp(child->type,"INT") == 0) {
operand c1 = new_constant(atoi(child->text));
code1 = gen_assign(ASSIGN_K,place,c1);
return code1;
}
//ID
if (strcmp(child->type,"ID") == 0 && child->sibling == NULL) {
int id = getVarID(child);
operand v1 = new_var(id);
code1 = gen_assign(ASSIGN_K,place,v1);
return code1;
}
//Exp1 ASSINGOP Exp2
if (strcmp(child->type,"Exp") == 0 && strcmp(child->sibling->type,"ASSIGNOP") == 0) {
//Exp1 is ID (ID = Exp2)
// printf("%s\n",child->child->type);
if (strcmp(child->child->type,"ID") == 0) {
operand t1 = new_tmp();
int id = getVarID(child->child);
operand v1 = new_var(id);
code1 = translate_Exp(child->sibling->sibling,t1);
code2 = gen_assign(ASSIGN_K,v1,t1);
// code1 = link(code1,code2);
if (place != NULL) {
code3 = gen_assign(ASSIGN_K,place,v1);
code1 = link(code1,code3);
}
return code1;
}
//Exp[Exp] = Exp2
}
//Exp1 PLUS/MINUS/STAR/DIV Exp2
if (strcmp(child->type,"Exp") == 0 &&
(strcmp(child->sibling->type,"PLUS") == 0
|| strcmp(child->sibling->type,"MINUS") == 0
|| strcmp(child->sibling->type,"STAR") == 0
|| strcmp(child->sibling->type,"DIV") == 0)) {
operand t1 = new_tmp();
operand t2 = new_tmp();
code1 = translate_Exp(child,t1);
code2 = translate_Exp(child->sibling->sibling,t2);
//printf("%d %d\n", t1->u.tmp_no, t2 -> u.tmp_no);
if (strcmp(child->sibling->type,"PLUS") == 0) {
code3 = gen_binop(ADD_K,place,t1,t2);
}
else if (strcmp(child->sibling->type,"MINUS") == 0)
code3 = gen_binop(SUB_K,place,t1,t2);
else if (strcmp(child->sibling->type,"STAR") == 0)
code3 = gen_binop(MUL_K,place,t1,t2);
else if (strcmp(child->sibling->type,"DIV") == 0)
code3 = gen_binop(DIV_K,place,t1,t2);
//code1 = link(code1,code2);
//code1 = link(code1,code3);
return code1;
}
//MINUS Exp1
if (strcmp(child->type,"MINUS") == 0) {
operand t1 = new_tmp();
code1 = translate_Exp(child,t1);
operand c1 = new_constant(0);
code2 = gen_binop(SUB_K,place,c1,t1);
code1 = link(code1,code2);
return code1;
}
//Exp1 RELOP Exp2
//NOT Exp1
//Exp1 AND Exp2
//Exp1 OR Exp2
if (strcmp(child->type,"NOT") == 0
|| strcmp(child->sibling->type,"RELOP") == 0
|| strcmp(child->sibling->type,"AND") == 0
|| strcmp(child->sibling->type,"OR") == 0) {
operand label1 = new_label();
operand label2 = new_label();
operand c1 = new_constant(0);
operand c2 = new_constant(1);
code1 = gen_assign(ASSIGN_K,place,c1);
code2 = translate_Cond(node,label1,label2);
code3 = gen_one(LABEL_K,label1);
code4 = gen_assign(ASSIGN_K,place,c2);
code5 = gen_one(LABEL_K,label2);
code1 = link(code1,code2);
code1 = link(code1,code3);
code1 = link(code1,code4);
code1 = link(code1,code5);
return code1;
}
//ID LP RP
if (strcmp(child->sibling->sibling->type,"LP") == 0 && strcmp(child->sibling->sibling->type,"RP") == 0) {
char *func_name = child->text;
if (strcmp(func_name,"read") == 0) {
if (place == NULL) {
operand t1 = new_tmp();
code1 = gen_one(READ_K,t1);
}
else
code1 = gen_one(READ_K,place);
return code1;
}
struct funMes *func_node = getFunMes(child);
assert(func_node != NULL);
operand f1 = new_function(func_name);
if (place != NULL && place->kind != ADDRESS)
code1 = gen_assign(CALL_K,place,f1);
else if (place != NULL && place->kind == ADDRESS) {
operand t2 = new_tmp();
code1 = gen_assign(CALL_K,t2,f1);
code2 = gen_assign(ASSIGN_K,place,t2);
code1 = link(code1,code2);
}
else {
operand t2 = new_tmp();
code1 = gen_assign(CALL_K,t2,f1);
}
return code1;
}
//ID LP Args RP
if (strcmp(child->sibling->type,"LP") == 0 && strcmp(child->sibling->sibling->type,"Args") == 0) {
char *func_name = child->text;
operand *arg_list = (operand *)malloc(sizeof(operand) * 10);
int arg_num = 0;
code1 = translate_Args(child->sibling->sibling,arg_list,&arg_num);
if (strcmp(func_name,"write") == 0) {
assert(arg_num == 1);
operand t1;
if (arg_list[0]->kind == ADDRESS) {
t1 = new_tmp();
code2 = gen_assign(ASSIGN_K,t1,arg_list[0]);
code1 = link(code1,code2);
}
else
t1 = arg_list[0];
code3 = gen_one(WRITE_K,t1);
code1 = link(code1,code3);
return code1;
}
int i;
for (i = 0;i < arg_num;i++) {
code2 = gen_one(ARG_K,arg_list[i]);
code1 = link(code1,code2);
}
operand f1 = new_function(func_name);
if (place != NULL && place->kind != ADDRESS)
code3 = gen_assign(CALL_K,place,f1);
else if (place != NULL && place->kind == ADDRESS) {
operand t2 = new_tmp();
code1 = gen_assign(CALL_K,t2,f1);
code2 = gen_assign(ASSIGN_K,place,t2);
code1 = link(code1,code2);
}
else {
operand t2 = new_tmp();
code3 = gen_assign(CALL_K,t2,f1);
}
code1 = link(code1,code3);
return code1;
}
//LP Exp RP
if (strcmp(child->type,"LP") == 0) {
return translate_Exp(child->sibling,place);
}
//Exp1 LB Exp2 RB
if (strcmp(child->type,"LB") == 0) {
return translate_array(node,place,NULL,NULL);
}
//Exp DOT ID
return NULL;
}