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]))