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_primary_expression_1(p):
'''primary_expression : IDENTIFIER'''
p[0] = {}
p[0]['id'] = p[1]
p[0]['src'] = p[1]
p[0]['code'] = ''
if p[0]['id'] not in m.symbols :
m.error("use of undeclared identifier '{0}'".format(p[0]['id']))
def do_login():
username = html.escape(request.forms.get('username'))
if len(username) > 10:
return model.error()
password = html.escape(request.forms.get('password'))
if len(password) > 20:
return model.error()
#response.set_cookie("username",username, secret='m14AGroup6')
return model.login_check(username, password)
def get_post(subject):
if request.get_cookie("username", secret='m14AGroup6'):
title = html.escape(request.forms.get('title'))
if len(title) > 100:
return model.error("Length Error")
content = html.escape(request.forms.get('content'))
print(content)
if len(content) > 250:
return model.error("Length Error")
username = request.get_cookie("username", secret='m14AGroup6')
return model.new_post(subject, title, content, username)
else:
return model.login()
def add_comment(subject, value):
if request.get_cookie("username", secret='m14AGroup6'):
comment = html.escape(request.forms.get("comment"))
username = request.get_cookie("username", secret='m14AGroup6')
title = html.escape(request.forms.get("title"))
unit = html.escape(request.forms.get("unit"))
if len(title) > 100 or len(username) > 10 or len(comment) > 250:
return model.error("Length Error")
if unit != subject:
return model.error("Length Error")
return model.new_comment(subject, title, comment, username)
else:
return model.login()
def do_sign_up():
username = html.escape(request.forms.get('username'))
if len(username) > 10:
return model.error("Length Error")
password = html.escape(request.forms.get('password'))
if len(password) > 20:
return model.error("Length Error")
email = html.escape(request.forms.get('email'))
if len(email) > 50:
return model.error("Length Error")
#Need to remove
if email is None:
email = "*****@*****.**"
return model.signup_check(username, password, email)
def assign(src, dest, comment=""):
"""assign principle is type => type*"""
tmp = ''
if 'const' in src: # we have a const
if m.symbols.dereference(dest) != src['type']:
src, tmp = cast(src, m.symbols.dereference(dest), 'assign const')
type_var = src['type']
id_var = src['val']
else: # dest is a variable
if m.symbols.is_constant(src['id']): # handle strings constants
type_var = m.symbols.dereference(dest)
id_var = "getelementptr inbounds ({0} {1}, i32 0, i32 0)".format(m.symbols.type(src['id']), m.symbols.var(src['id']))
elif m.symbols.is_array(src['id']) and not m.symbols.is_array(dest): # assign an array in ptr
new, tmp = getelementptr(src['id'], 0, comment)
type_var = m.symbols.type(new)
id_var = m.symbols.var(new)
elif m.symbols.modifiers(dest) == '*' and m.symbols.modifiers(dest) == m.symbols.modifiers(src['id']): #we have to store temporary src content
if m.symbols.type(dest) != m.symbols.type(src['id']):
new, tmp2 = cast(src, m.symbols.dereference(dest), 'assign var')
tmp = tmp + tmp2
type_var = m.symbols.type(new)
id_var = m.symbols.var(new)
else:
new, tmp = load(src['id'], comment)
type_var = m.symbols.type(new)
id_var = m.symbols.var(new)
else : #src is already of type dest*
if m.symbols.dereference(dest) != m.symbols.type(src['id']) or m.symbols.is_function(src['id']):
new, tmp2 = cast(src, m.symbols.dereference(dest), 'assign var')
tmp = tmp + tmp2
type_var = m.symbols.type(new)
id_var = m.symbols.var(new)
else:
type_var = m.symbols.type(src['id'])
id_var = m.symbols.var(src['id'])
if src['id'] in m.symbols and m.symbols.is_allocated(src['id']):
m.symbols.set_allocated(dest, m.symbols.allocated(src['id']))
if src['id'] in m.symbols and m.symbols.is_function(src['id']):
m.symbols.set_args(dest, m.symbols.args(src['id']), m.symbols.has_ellipsis(src['id']), primary=m.symbols.primary_type(src['id']))
if m.symbols.dereference(dest) != type_var:
if m.symbols.primary_type(dest) != m._type_ptr or not type_var.startswith(m._type_ptr):
m.error("assignement type incompatible", 2)
l = "store {0} {1}, {2} {3}\t\t;assign {4}".format(type_var, id_var,
m.symbols.type(dest), m.symbols.var(dest), comment)
return tmp + indent(l)
def p_primary_expression_13(p):
'''primary_expression : FREE '(' argument_expression_list ')' '''
var_tmp = m.new_reg()
#print p[3]
m.symbols.add(var_tmp, m._type_int)
l = "{0} = call i32 ({1}, ...)* bitcast (i32 (...)* @free to i32 ({1}, ...)*)({1} {2})".format(m.symbols.var(var_tmp),
m.symbols.type(p[3]['id']), m.symbols.var(p[3]['id']))
#print m.symbols
if m.symbols.is_allocated(p[3]['id']):
m.release_alloc(m.symbols.allocated(p[3]['id']))
else:
m.error("invalid free on unalocated variable")
p[0] = {}
p[0]['code'] = p[3]['alloc'] + cg.indent(l)
def length(var):
res = {}
if m.symbols.is_array(var['id']):
res['type'] = m._type_int
res['val'] = m.symbols.size(var['id'])[-1]
res['const'] = "{0} {1}".format(res['type'], res['val'])
res['code'] = ''
elif m.symbols.is_allocated(var['id']):
res['id'] = m.new_reg()
m.symbols.add(res['id'], m._type_int)
l = "{0} = call i32 @..get(i32 {1})\t\t;len".format(m.symbols.var(res['id']), m.symbols.allocated(var['id']))
res['code'] = var['code'] + indent(l)
else:
m.error("{0} has no len()".format(var['id']))
return res
def topic(subject, value):
if request.get_cookie("username", secret='m14AGroup6'):
title = html.escape(request.forms.get('title'))
if len(title) > 100:
return model.error("Length Error")
username = request.get_cookie("username", secret='m14AGroup6')
return model.content(subject, title, username)
else:
return model.login()
def unit_add():
if request.get_cookie("username"):
username = request.get_cookie("username", secret='m14AGroup6')
unit_add = html.escape(request.forms.get('unit'))
if len(unit_add) != 8:
return model.error()
return model.addUnit(unit_add, username)
else:
return model.login()
def p_primary_expression_7(p):
'''primary_expression : MAP '(' postfix_expression ',' postfix_expression ')' '''
if m.symbols.is_function(p[3]['id']):
type1 = m.symbols.args(p[3]['id'])[0]
type2 = m.symbols.primary_type(p[3]['id'], src=True)
if type1 not in [m._type_int, m._type_float] or type2 not in [m._type_int, m._type_float]:
m.error('map type unsuported {0}, {1}'.format(type1, type2))
else:
m.error('map first argument must be a function, or a function pointer')
if m.symbols.is_function(p[3]['id']) and not m.symbols.modifiers(p[3]['id']) :
var, tmp = cg.cast(p[3], m._type_ptr+'*')
func = m.new_reg()
m.symbols.add(func, m._type_ptr, '**')
tmp1 = "{0} = alloca {1}".format(m.symbols.var(func), m.symbols.dereference(func))
tmp2 = "store {0} {1}, {2} {3}".format(m.symbols.type(var),
m.symbols.var(var), m.symbols.type(func), m.symbols.var(func))
funcl = tmp + cg.indent(tmp1) + cg.indent(tmp2)
else :
func = p[3]['id']
funcl =''
if m.symbols.is_array(p[5]['id']) :
tab, tabl = cg.getelementptr(p[5]['id'], 0, 'argument_expression_list')
else:
tab = p[5]['id']
tabl = ''
p[0] = {}
p[0]['id'] = m.new_reg()
size = cg.length(p[5])
if 'const' in size:
tab_size = size['const']
else:
tab_size = "{0} {1}".format(m.symbols.type(size['id']), m.symbols.var(size['id']))
m.symbols.add(p[0]['id'], type2, '*')
l = "{0} = call {2}* (i8**, {1}*, i32)* @..{1}.{2}.map({3} {4}, {5} {6}, {7})".format(
m.symbols.var(p[0]['id']), type1, type2, m.symbols.type(func), m.symbols.var(func),
m.symbols.type(tab), m.symbols.var(tab), tab_size)
m.symbols.set_allocated(p[0]['id'], m.last_alloc())
p[0]['code'] = funcl + tabl + size['code'] + cg.indent(l)
def view_chat(user):
print("view chat")
if request.get_cookie("username", secret='m14AGroup6'):
username = request.get_cookie("username", secret='m14AGroup6')
user_to_chat = html.escape(request.forms.get("message_user"))
if len(user_to_chat) > 10:
return model.error("Length Error")
return model.get_messages(username, user_to_chat)
else:
return model.login()
def new_message():
print("Enter controller for messages post")
if request.get_cookie("username", secret='m14AGroup6'):
username = request.get_cookie("username", secret='m14AGroup6')
user_to_chat = html.escape(request.forms.get("message_user"))
message = html.escape(request.forms.get("message"))
if len(message) > 100 or len(user_to_chat) > 10:
return model.error("Length Error")
print("Going to model")
return model.new_message(username, user_to_chat, message)
else:
return model.login()
def func2(x):
return error(exp_dyn(x),
exp_mix(results[v, c]["C_mix"]),
Atwood,
v,
L,
c,
this['delta'],
y0,
times,
heights,
mix,
reg_param=0.1 * res_slsqp.fun)
def p_primary_expression_9(p):
'''primary_expression : IDENTIFIER '(' ')'
| IDENTIFIER '(' argument_expression_list ')' '''
if p[1] not in m.symbols :
m.error("use of undeclared function '{0}'".format(p[1]))
p[1] = 'empty_func'
p[0] = {}
if len(p) == 5:
#TODO check type
code = p[3]['alloc']
args = p[3]['code']
else :
code = ''
args = ''
#print m.symbols
type = m.symbols.return_type(p[1])
if m.symbols.has_ellipsis(p[1]):
type = "{0} {1}".format(type, m.symbols.reference(p[1]))
p[0]['id'] = m.new_reg()
m.symbols.add(p[0]['id'], m.symbols.return_type(p[1]))
l = "{0} = call {1} @{2}({3})".format(m.symbols.var(p[0]['id']), type, p[1], args)
p[0]['code'] = code + cg.indent(l)
def func2(x):
return error(exp_dyn(x), exp_mix(results[v,c]["C_mix"]), Atwood, v, L, c, this['delta'], y0, times, heights, mix,
reg_param = 0.1 * res_slsqp.fun)
def p_direct_declarator_4(p):
'''direct_declarator : direct_declarator '[' ']' '''
m.error("definition of variable '{0}' with array type needs an explicit size".format(p[1]['code']))
def error404(error):
print(error)
return model.error("")
def p_error(t):
if t:
m.error("syntax error '{0}'".format(t.value))
parser.errok()
else:
m.error("syntax error, unexpected end of file")
def binary_operation(left, right, operator):
res = {}
if 'const' in left and 'const' in right:
res['type'] = m.type_table(left['type'], right['type'], operator)
if res['type'] is None:
print('error: invalid operation')
if operator == '<':
res['val'] = int(left['val'] < right['val'])
elif operator == '>':
res['val'] = int(left['val'] > right['val'])
elif operator == '<=':
res['val'] = int(left['val'] <= right['val'])
elif operator == '>=':
res['val'] = int(left['val'] >= right['val'])
elif operator == '==':
res['val'] = int(left['val'] == right['val'])
elif operator == '!=':
res['val'] = int(left['val'] != right['val'])
elif operator == '+':
res['val'] = left['val'] + right['val']
elif operator == '-':
res['val'] = left['val'] - right['val']
elif operator == '*':
res['val'] = left['val'] * right['val']
elif operator == '/':
res['val'] = left['val'] / right['val']
res['const'] = "{0} {1}".format(res['type'], res['val'])
res['code'] = ''
else:
if 'const' in left:
type1 = left['type']
var1 = left
c1 = ''
else:
if m.symbols.is_pointer(left['id']):
type1 = m.symbols.dereference(left['id'])
var1, c1 = load(left['id'], 'relational_expression')
var1 = {'id' : var1}
else:
type1 = m.symbols.type(left['id'])
var1 = left
c1 = ''
if 'const' in right:
type2= right['type']
var2 = right
c2 = ''
else:
if m.symbols.is_pointer(right['id']):
type2 = m.symbols.dereference(right['id'])
var2, c2 = load(right['id'], 'relational_expression')
var2 = {'id' : var2}
else:
type2 = m.symbols.type(right['id'])
var2 = right
c2 = ''
res_type = m.type_table(type1, type2, operator)
if res_type is None:
if operator in ['+', '-', '*', '/']:
m.error('invalid operation {0}'.format(operator))
else:
m.error('invalid comparaison {0}'.format(operator))
if operator in ['+', '-', '*', '/']:
tmp = ''
if type1 != res_type:
var1, tmp = cast(var1, res_type, 'relational_expression')
if not 'const' in var1:
var1 = {'id': var1}
if type2 != res_type:
var2, tmp = cast(var2, res_type, 'relational_expression')
if not 'const' in var2:
var2 = {'id': var2}
if 'const' in var1:
var1 = var1['val']
else:
var1 = m.symbols.var(var1['id'])
if 'const' in var2:
var2 = var2['val']
else:
var2 = m.symbols.var(var2['id'])
if operator == '+':
op = 'add'
elif operator == '-':
op = 'sub'
elif operator == '*':
op = 'mul'
elif operator == '/':
op = 'div'
op = 'f'+op if res_type == m._type_float else op
if op == 'div':
op = 'udiv'
res['id'] = m.new_reg()
m.symbols.add(res['id'], res_type)
l = "{0} = {1} {2} {3}, {4}".format(m.symbols.var(res['id']), op, res_type, var1, var2)
res['code'] = left['code'] + right['code'] + c1 + c2 + tmp + indent(l)
else:
if 'const' in var1:
var1 = var1['val']
else:
var1 = m.symbols.var(var1['id'])
if 'const' in var2:
var2 = var2['val']
else:
var2 = m.symbols.var(var2['id'])
if operator == '<':
cmp = 'lt'
elif operator == '>':
cmp = 'gt'
elif operator == '<=':
cmp = 'le'
elif operator == '>=':
cmp = 'ge'
elif operator == '==':
cmp = 'eq'
elif operator == '!=':
cmp = 'ne'
if res_type == m._type_float:
op = "fcmp"
cmp = "o"+cmp
elif cmp not in ['ne', 'eq']:
op = "icmp"
cmp = "s"+cmp
else :
op = "icmp"
res['id'] = m.new_reg()
m.symbols.add(res['id'], res_type)
l = "{0} = {1} {2} {3} {4}, {5}".format(m.symbols.var(res['id']), op, cmp, type1, var1, var2)
res['code'] = left['code'] + right['code'] + c1 + c2 + indent(l)
return res
def cast(src, type, comment=""):
var = {}
if 'const' in src:
if type in [m._type_int, m._type_char, m._type_bool]:
var['val'] = int(src['val'])
elif type == m._type_float:
var['val'] = float(src['val'])
var['type'] = type
var['code'] = src['code']
var['const'] = "{0} {1}".format(var['type'], var['val'])
l = ''
else:
op = None
if (type[len(m.symbols.modifiers(src['id'])):] == m.symbols.modifiers(src['id'])) or (m.symbols.is_pointer(src['id']) and not type.endswith('*')):#type == m.symbols.type(src['id']) or m.symbols.is_pointer(src['id']):
new, l1 = load(src['id'], 'cast '+comment)
elif m.symbols.is_pointer(src['id']) and type.endswith('*'):
if m.symbols.primary_type(src['id']) != m._type_ptr and m.symbols.is_function(src['id']) or not src['code']:
new, l1 = load(src['id'], 'cast '+comment)
else:
new, l1 = src['id'], ''
else:
new, l1 = src['id'], ''
if m.symbols.type(new) == m._type_ptr+'*' and type.endswith('*'):
op = 'bitcast'
elif m.symbols.is_function(new) and type == m._type_ptr+'*':
op = 'bitcast'
elif m.symbols.is_pointer(new) and type.endswith('*'):
op = 'bitcast'
elif m.symbols.primary_type(new) == m._type_float and type in [m._type_int, m._type_char]:
op = 'fptosi'
elif m.symbols.primary_type(new) in [m._type_int, m._type_char] and type == m._type_float:
op = 'sitofp'
elif m.symbols.primary_type(new) == m._type_bool and type == m._type_int:
op = 'zext'
elif m.symbols.primary_type(new) == m._type_char and type == m._type_int:
op = 'sext'
elif m.symbols.primary_type(new) == m._type_int and type == m._type_char:
op = 'trunc'
if op is None:
m.error("Invalid cast from {0} to {1}".format(m.symbols.primary_type(new), type))
var = m.new_reg()
m.symbols.add(var, type.split('*')[0], type.count('*')*'*')
if m.symbols.is_allocated(new):
m.symbols.set_allocated(var, m.symbols.allocated(new))
if m.symbols.is_function(new):
m.symbols.set_args(var, m.symbols.args(new), m.symbols.has_ellipsis(new), primary=m.symbols.primary_type(src['id']))
args = [] + m.symbols.args(new)
if m.symbols.has_ellipsis(new):
args.append('...')
tmp = ', '.join(args)
new_type = "{0} ({1})*".format(m.symbols.return_type(new), tmp)
else:
new_type = m.symbols.type(new)
# print m.symbols
l2 = "{0} = {1} {2} {3} to {4}\t\t;cast {5}".format(m.symbols.var(var), op, new_type, m.symbols.var(new), type, comment)
l = l1 + indent(l2)
return var,l
def reset_pass():
email = html.escape(request.forms.get("email"))
if len(email) > 50:
return model.error("")
return model.reset_pass(email)
def func1(x):
#return dyn_error(exp_dyn(x), Atwood, v, L, y0, times, heights, m_spline)
return error(exp_dyn(x), exp_mix(results[v, c]["C_mix"]), Atwood, v, L,
c, this['delta'], y0, times, heights, mix)
def error404(error):
return model.error()
def func1(x):
#return dyn_error(exp_dyn(x), Atwood, v, L, y0, times, heights, m_spline)
return error(exp_dyn(x), exp_mix(results[v,c]["C_mix"]), Atwood, v, L, c, this['delta'], y0, times, heights, mix)
def squared_error_ridge(x_i, y_i, beta, alpha):
"""esitmate error plus ridge penalty on beta"""
return error(x_i, y_i, beta)**2 + ridge_penalty(beta, alpha)
def squared_error_ridge(x_i, y_i, beta, alpha):
"""esitmate error plus ridge penalty on beta"""
return error(x_i, y_i, beta) ** 2 + ridge_penalty(beta, alpha)
m.error("syntax error, unexpected end of file")
if __name__ == '__main__':
parser = yacc.yacc()
if len(sys.argv) > 1 :
filename = sys.argv[1]
with open(filename, 'r') as f:
res = None
try:
res = parser.parse(f.read())
except:
pass
if m.error_level == 0 and res is not None:
if 'main' in m.symbols :
if len(sys.argv) > 2:
with open(sys.argv[2], 'w') as out:
out.write(m.symbols.dump())
out.write(m.header)
out.write(res['code'])
else :
print m.symbols.dump()
print m.header
print res['code']
else:
m.error('no main function found')
else:
sys.exit(1)
else :
print("Usage: ./{0} <file.c> [file.ll]".format(sys.argv[0]))
