def p_expression_1(p):
'''expression : unary_expression assignment_operator relational_expression'''
p[0] = {}
if p[2] == '=':
src = p[3]
elif p[2] == '+=':
src = cg.binary_operation({'id':p[1]['id'], 'code':''}, p[3], '+')
elif p[2] == '-=':
src = cg.binary_operation({'id':p[1]['id'], 'code':''}, p[3], '-')
elif p[2] == '*=':
src = cg.binary_operation({'id':p[1]['id'], 'code':''}, p[3], '*')
p[0]['code'] = p[1]['code'] + src['code'] + cg.assign(src, p[1]['id'], 'expression')
global left_var
left_var = p[1]['id']
def p_primary_expression_12(p):
'''primary_expression : MALLOC '(' argument_expression_list ')' '''
nb = p[3]['code']
if not m.symbols.modifiers(last_var_seen).startswith('**'):
m.error("cannot allocate memory for non pointer variable {0}".format(last_var_seen))
var_tmp = m.new_reg()
m.symbols.add(var_tmp, m.symbols.primary_type(last_var_seen), m.symbols.modifiers(last_var_seen))
tmp1 = "{0} = getelementptr {1} null, i32 1\t\t;malloc sizeof".format(m.symbols.var(var_tmp), m.symbols.type(var_tmp))
size = m.new_reg()
m.symbols.add(size, m._type_int)
tmp2 = "{0} = ptrtoint {1} {2} to i32\t\t;malloc sizeof".format(m.symbols.var(size), m.symbols.type(var_tmp), m.symbols.var(var_tmp))
p[3]['code'] =''
res = cg.binary_operation(p[3], {'code': '', 'id': size}, '*')
p[0] = {}
p[0]['id'] = m.new_reg()
m.symbols.add(p[0]['id'], m.symbols.primary_type('malloc'), m.symbols.modifiers('malloc'))
l = "{0} = call {1} @malloc({2} {3})".format(m.symbols.var(p[0]['id']),
m.symbols.return_type('malloc'), m.symbols.type(res['id']), m.symbols.var(res['id']))
index = m.reserve_alloc()
l2 = "call void @..set({0} {1}, {2})\t\t;malloc size".format(m._type_int, index, nb)
m.symbols.set_allocated(p[0]['id'], index)
p[0]['code'] = (p[3]['alloc'] + cg.indent(tmp1) + cg.indent(tmp2)
+ res['code'] + cg.indent(l) + cg.indent(l2))
def p_unary_expression_3(p):
'''unary_expression : DEC_OP unary_expression'''
p[0] = {}
res2 = cg.binary_operation(p[2], {'code': '', 'const': '', 'val': '1', 'type': m._type_int}, '-')
res3 = cg.assign(res2, p[2]['id'], "pre_decrement")
p[0]['code'] = res2['code'] + res3
p[0]['id'] = res2['id']
def p_primary_expression_11(p):
'''primary_expression : postfix_expression DEC_OP'''
p[0] = {}
res, tmp1 = cg.load(p[1]['id'], "post_decrement")
res2 = cg.binary_operation(p[1], {'code': '', 'const': '', 'val': '1', 'type': m._type_int}, '-')
res3 = cg.assign(res2, p[1]['id'], "post_increment")
p[0]['code'] = tmp1 + res2['code'] + res3
p[0]['id'] = res
def p_relational_expression_2(p):
'''relational_expression : additive_expression '<' additive_expression
| additive_expression '>' additive_expression
| additive_expression LE_OP additive_expression
| additive_expression GE_OP additive_expression
| additive_expression EQ_OP additive_expression
| additive_expression NE_OP additive_expression
additive_expression : additive_expression '+' multiplicative_expression
| additive_expression '-' multiplicative_expression
multiplicative_expression : multiplicative_expression '*' unary_expression
| multiplicative_expression '/' unary_expression'''
p[0] = {}
p[0] = cg.binary_operation(p[1], p[3], p[2])
