def __init__(self): self.tempCount = 0 self.tempCountBool = 0 self.codeGenerator = CodeGenerator() self.symbolTable = SymbolTable() self.array_length = 0 self.var_stack = [] self.latest_bool = None
def __continue_process(self, text_nodes, shape_nodes, image_path, window): if window != None: window.destroy() window.update() graph = Graph(text_nodes, shape_nodes) flow = graph.generate_graph() #call function to traslate to code and flowchart results_path = self.__get_results_path() os.mkdir(self.RESULTS_PATH + results_path) cg = CodeGenerator(graph, results_path) cg.generate_code(graph.find_first_state(), -1) fg = FlowchartGenerator(graph, flow, results_path) fg.generate_flowchart() self.show_results(results_path)
def parse_code(code): try: lexer = lex.lex(module=tokRules) parser = yacc.yacc() result = parser.parse(code) if result: symbolTable = {} flags = defaultdict(set) analyse(symbolTable, result, flags) cg = CodeGenerator(symbolTable, registers, flags) code = cg.generate(result) return code except (e.SemanticException, e.NoMatchException, e.SyntaxException, e.LexicalException, e.DivisionByZeroException) as exception: print exception.value print "(Paragraph : %d Clause: %d)" %(exception.lineno, exception.clauseno) sys.exit(1)
def parse(filename): """ Parse the given file and write the result of conversion into output (default to stdout) """ # read source file with open(filename, "r") as pyfile: source = pyfile.read() # Build the abstract syntax tree tree = compile(source, filename, "exec", ast.PyCF_ONLY_AST) formatter = CodeFormatter() generator = CodeGenerator(formatter) generator.visit(tree) generator.printIncludes() formatter.flush()
class Parser: tokens = Lexer().tokens def __init__(self): self.tempCount = 0 self.codeGenerator = CodeGenerator() def p_program(self, p): "program : exp" pass def p_exp_sum(self, p): "exp : exp SUM exp" self.codeGenerator.generate_arithmetic_code(p, self.new_temp()) def p_exp_sub(self, p): "exp : exp SUB exp" self.codeGenerator.generate_arithmetic_code(p, self.new_temp()) def p_exp_mul(self, p): "exp : exp MUL exp" self.codeGenerator.generate_arithmetic_code(p, self.new_temp()) def p_exp_div(self, p): "exp : exp DIV exp" self.codeGenerator.generate_arithmetic_code(p, self.new_temp()) def p_exp_integer(self, p): "exp : INTEGER" p[0] = NonTerminal() p[0].value = p[1] def new_temp(self): temp = "T" + str(self.tempCount) self.tempCount += 1 return temp precedence = (('left', 'SUM', 'SUB'), ('left', 'MUL', 'DIV')) def p_error(self, p): print(p.value) raise Exception('ParsingError: invalid grammar at ', p) def build(self, **kwargs): """build the parser""" self.parser = yacc.yacc(module=self, **kwargs) return self.parser
def __init__(self): self.tempCount = 0 self.quad = 0 self.codeGenerator = CodeGenerator()
class Parser: tokens = Lexer().tokens def __init__(self): self.tempCount = 0 self.quad = 0 self.codeGenerator = CodeGenerator() # part 1 ---------------------------------------------------------------------------------------- def p_program(self, p): "program : declist MAIN LRB RRB block" self.codeGenerator.generate_main_code(p, self.next_quad(), self.next_quad()) def p_declist_empty(self, p): """ declist : """ self.codeGenerator.generate_declist_empty_code(p) def p_declist(self, p): """ declist : declist dec """ self.codeGenerator.generate_declist_code(p, self.next_quad()) def p_dec_vardec(self, p): """ dec : vardec """ self.codeGenerator.generate_dec_vardec_code(p) def p_vardec(self, p): """ vardec : idlist COLON type SEMICOLON """ self.codeGenerator.generate_vardec_code(p) def p_type(self, p): """ type : INTEGER type : FLOAT type : BOOLEAN """ pass def p_iddec_ID(self, p): """ iddec : ID """ self.codeGenerator.generate_iddec_ID_code(p) def p_iddec_assign(self, p): """ iddec : ID ASSIGN exp """ self.codeGenerator.generate_iddec_assign_code(p, self.next_quad(), self.next_quad(), self.next_quad()) def p_iddec_array(self, p): """ iddec : ID LSB exp RSB """ self.codeGenerator.generate_iddec_array_code(p, self.new_temp()) def p_idlist(self, p): """ idlist : iddec """ self.codeGenerator.generate_idlist_code(p) def p_idlist_comma(self, p): """ idlist : idlist COMMA iddec """ self.codeGenerator.generate_idlist_comma_code(p, self.next_quad()) def p_exp_assign(self, p): "exp : ID ASSIGN exp" self.codeGenerator.generate_exp_assign_code(p, self.next_quad(), self.next_quad(), self.next_quad()) def p_exp_arithmetic(self, p): """ exp : exp SUM exp exp : exp SUB exp exp : exp DIV exp exp : exp MOD exp exp : exp MUL exp """ self.codeGenerator.generate_exp_arithmetic_code(p, self.new_temp(), self.new_temp(), self.new_temp(), self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad()) def p_exp_const(self, p): "exp : const" self.codeGenerator.generate_exp_const_code(p) def p_exp_ID(self, p): "exp : ID" self.codeGenerator.generate_exp_ID_code(p) def p_exp_array(self, p): "exp : ID LSB exp RSB" self.codeGenerator.generate_exp_array_code(p, self.new_temp(), self.new_temp(), self.new_temp()) def p_lvalue(self, p): "exp : ID LSB exp RSB ASSIGN exp" self.codeGenerator.generate_lvalue_code(p, self.new_temp(), self.new_temp(), self.new_temp(), self.next_quad(), self.next_quad(), self.next_quad()) def p_exp_sub(self, p): "exp : SUB exp" self.codeGenerator.generate_exp_sub_code(p, self.new_temp(), self.new_temp(), self.next_quad(), self.next_quad(), self.next_quad()) def p_exp_par(self, p): "exp : LRB exp RRB" self.codeGenerator.generate_exp_par_code(p) def p_const_arithmetic(self, p): """ const : FLOATNUMBER const : INTEGERNUMBER """ self.codeGenerator.generate_const_arithmetic_code(p) def p_block(self, p): """ block : LCB stmtlist RCB """ self.codeGenerator.generate_block_code(p) def p_stmtlist(self, p): """ stmtlist : stmtlist stmt """ self.codeGenerator.generate_stmtlist_code(p, self.next_quad()) def p_stmtlist_empty(self, p): "stmtlist :" self.codeGenerator.generate_stmtlist_empty_code(p) def p_stmt_sem(self, p): """ stmt : exp SEMICOLON """ self.codeGenerator.generate_stmt_sem_code(p) def p_stmt_block(self, p): """ stmt : block """ self.codeGenerator.generate_stmt_block_code(p) def p_stmt_var(self, p): """ stmt : vardec """ self.codeGenerator.generate_stmt_var_code(p) def p_stmt_print(self, p): """ stmt : PRINT LRB ID RRB SEMICOLON """ self.codeGenerator.generate_stmt_print_code(p) # part 2 ---------------------------------------------------------------------------------------- def p_stmt_if(self, p): "stmt : IF LRB exp RRB stmt elseiflist %prec IFREDUCE" self.codeGenerator.generate_stmt_if_code(p, self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad()) def p_stmt_while(self, p): "stmt : WHILE LRB exp RRB stmt" self.codeGenerator.generate_stmt_while_code(p, self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad()) def p_stmt_if_else(self, p): "stmt : IF LRB exp RRB stmt elseiflist ELSE stmt" self.codeGenerator.generate_stmt_if_else_code(p, self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad()) def p_stmt_for(self, p): "stmt : FOR LRB exp SEMICOLON exp SEMICOLON exp RRB stmt" self.codeGenerator.generate_stmt_for_code(p, self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad()) def p_stmt_foreach(self, p): "stmt : FOR LRB ID IN ID RRB stmt" self.codeGenerator.generate_stmt_foreach_code(p, self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad(), self.new_temp(), self.new_temp(), self.new_temp(), self.new_temp()) def p_stmt_case(self, p): "stmt : ON LRB exp RRB LCB cases RCB SEMICOLON" self.codeGenerator.generate_stmt_case_code(p) def p_case(self, p): """ case : WHERE const COLON stmtlist """ self.codeGenerator.generate_case_code(p, self.next_quad(), self.next_quad(), self.next_quad()) def p_cases(self, p): "cases : cases case" self.codeGenerator.generate_cases_code(p, self.next_quad(), self.next_quad()) def p_cases_empty(self, p): "cases :" self.codeGenerator.generate_cases_empty_code(p) def p_elseiflist(self, p): """ elseiflist : elseiflist ELSEIF LRB exp RRB stmt """ self.codeGenerator.generate_elseiflist_code(p, self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad()) def p_elseiflist_empty(self, p): "elseiflist :" self.codeGenerator.generate_elseiflist_empty_code(p) def p_exp_relop(self, p): "exp : relopexp %prec EXP" self.codeGenerator.generate_exp_relop_code(p) def p_relopexp(self, p): """ relopexp : exp GT exp relopexp : exp LT exp relopexp : exp NE exp relopexp : exp EQ exp relopexp : exp LE exp relopexp : exp GE exp """ self.codeGenerator.generate_relopexp_code(p, self.next_quad(), self.next_quad()) def p_relopexp_rel(self, p): """ relopexp : relopexp GT exp relopexp : relopexp LT exp relopexp : relopexp NE exp relopexp : relopexp EQ exp relopexp : relopexp LE exp relopexp : relopexp GE exp """ self.codeGenerator.generate_relopexp_rel_code(p, self.next_quad(), self.next_quad(), self.next_quad()) def p_exp_and(self, p): "exp : exp AND exp" self.codeGenerator.generate_exp_and_code(p, self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad()) def p_exp_or(self, p): "exp : exp OR exp" self.codeGenerator.generate_exp_or_code(p, self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad(), self.next_quad()) def p_exp_not(self, p): "exp : NOT exp" self.codeGenerator.generate_exp_not_code(p, self.next_quad(), self.next_quad()) def p_const(self, p): """ const : TRUE const : FALSE """ self.codeGenerator.generate_stmt_const_code(p, self.next_quad()) # part 3 ---------------------------------------------------------------------------------------- def p_paramdecs(self, p): """ paramdecs : paramdecslist """ self.codeGenerator.generate_paramdecs_code(p) def p_paramdecs_empty(self, p): """ paramdecs : """ self.codeGenerator.generate_paramdecs_empty_code(p) def p_paramdecslist(self, p): """ paramdecslist : paramdec """ self.codeGenerator.generate_paramdeclist_code(p) def p_paramdecslist_comma(self, p): """ paramdecslist : paramdecslist COMMA paramdec """ self.codeGenerator.generate_paramdeclist_comma_code(p) def p_paramdec(self, p): """ paramdec : ID COLON type paramdec : ID LSB RSB COLON type """ self.codeGenerator.generate_paramdec_code(p) def p_exp_fun(self, p): """ exp : ID LRB RRB """ self.codeGenerator.generate_exp_fun_code(p, self.new_temp(), self.new_temp(), self.next_quad(), self.next_quad()) def p_exp_fun_explist(self, p): "exp : ID LRB explist RRB" self.codeGenerator.generate_exp_fun_explist_code(p, self.new_temp(), self.new_temp(), self.next_quad(), self.next_quad(), self.next_quad()) def p_funcdec(self, p): """ funcdec : FUNCTION ID LRB paramdecs RRB block """ self.codeGenerator.generate_funcdec_code(p, self.next_quad(), self.next_quad(), self.next_quad(), self.new_temp()) def p_funcdec_return(self, p): """ funcdec : FUNCTION ID LRB paramdecs RRB COLON type block """ self.codeGenerator.generate_funcdec_return_code(p, self.next_quad(), self.next_quad(), self.next_quad(), self.new_temp(), self.new_temp()) def p_explist(self, p): """ explist : exp """ self.codeGenerator.generate_explist_code(p) def p_explist_comma(self, p): """ explist : explist COMMA exp """ self.codeGenerator.generate_explist_comma_code(p, self.next_quad()) def p_dec_funcdec(self, p): """ dec : funcdec """ self.codeGenerator.generate_dec_fundec_code(p) def p_stmt_return(self, p): """ stmt : RETURN exp SEMICOLON """ self.codeGenerator.generate_stmt_return_code(p) precedence = ( ('right', "ASSIGN"), ('left', "OR"), ('left', "AND"), ('left', "NOT"), ('left', 'EXP'), ('left', "GT", "LT", "NE", "EQ", "LE", "GE"), ('left', "MOD"), ('left', "SUM", "SUB"), ('left', "MUL", "DIV"), ('left', "IFREDUCE"), ('left', "ELSE", "ELSEIF"), ) def new_temp(self): temp = "T" + str(self.tempCount) self.tempCount += 1 return temp def next_quad(self): temp = 'L' + str(self.quad) self.quad += 1 return temp def p_error (self, p): print ('>> Syntax error at', p.value) # raise Exception('Syntax error at', p.value) def build(self, **kwargs): self.parser = yacc.yacc(module=self, **kwargs) return self.parser
class Parser: tokens = Lexer().tokens def __init__(self): self.tempCount = 0 self.tempCountBool = 0 self.codeGenerator = CodeGenerator() self.symbolTable = SymbolTable() self.array_length = 0 self.var_stack = [] self.latest_bool = None def p_program(self, p): """program : declist MAIN LRB RRB block""" print("program : declist MAIN LRB RRB block") self.symbolTable.end() self.symbolTable.print_symbolTable() self.codeGenerator.end() print(NonTerminal.nonTerminals_list) def p_program_simple(self, p): """program : MAIN LRB RRB block""" print("program : MAIN LRB RRB block") self.symbolTable.end() self.symbolTable.print_symbolTable() self.codeGenerator.end() print(NonTerminal.nonTerminals_list) def p_declist_dec(self, p): """declist : dec""" print("declist : dec") def p_declist_declist(self, p): """declist : declist dec""" print("declist : declist dec") def p_dec_vardec(self, p): """dec : vardec""" print("dec : vardec") def p_dec_funcdec(self, p): """dec : funcdec""" print("dec : funcdec") def p_type_integer(self, p): """type : INTEGER""" print("type : INTEGER") self.var_stack.clear() self.symbolTable.set_var_type('Int') def p_type_float(self, p): """type : FLOAT""" print("type : FLOAT") self.var_stack.clear() self.symbolTable.set_var_type('Float') def p_type_boolean(self, p): """type : BOOLEAN""" print("type : BOOLEAN") self.var_stack.clear() self.symbolTable.set_var_type('Boolean') def p_iddec_lvalue(self, p): """iddec : lvalue""" print("iddec : lvalue") def p_iddec_lvalue_assign(self, p): """iddec : lvalue ASSIGN exp""" print("iddec : lvalue ASSIGN exp") print(p[1]) print(p[3]) place = self.new_temp() exp_place = '' if p[3] is None: exp_place = self.find_place() self.symbolTable.add_place(self.var_stack.pop(), place) self.codeGenerator.assign(p, place, exp_place=exp_place) def p_idlist_iddec(self, p): """idlist : iddec""" print("idlist : iddec") def p_idlist_idlist(self, p): """idlist : idlist COMMA iddec""" print("idlist : idlist COMMA iddec") def p_vardec_idlist(self, p): """vardec : idlist COLON type SEMICOLON""" print("vardec : idlist COLON type SEMICOLON") def p_funcdec_type_block(self, p): """funcdec : FUNCTION ID LRB paramdecs RRB COLON type block""" print("funcdec : FUNCTION ID LRB paramdecs RRB COLON type block") self.symbolTable.new_scope_end(p[2]) def p_funcdec_block(self, p): """funcdec : FUNCTION ID LRB paramdecs RRB block""" print("funcdec : FUNCTION ID LRB paramdecs RRB block") self.symbolTable.new_scope_end(p[2]) def p_paramdecs_paramdecslist(self, p): """paramdecs : paramdecslist""" print("paramdecs : paramdecslist") def p_paramdecs_lambda(self, p): """paramdecs : """ print("paramdecs : ") def p_paramdecslist_paramdec(self, p): """paramdecslist : paramdec""" print("paramdecslist : paramdec") self.symbolTable.new_scope_begin() def p_paramdecslist_paramdecslist(self, p): """paramdecslist : paramdecslist COMMA paramdec""" print("paramdecslist : paramdecslist COMMA paramdec") self.symbolTable.new_scope_begin() def p_paramdec_id(self, p): """paramdec : ID COLON type""" print("paramdec : ID COLON type") self.symbolTable.add_param_var(p[1]) # TODO def p_paramdec_id_array(self, p): """paramdec : ID LSB RSB COLON type""" print("paramdec : ID LSB RSB COLON type") def p_block_stmtlist(self, p): """block : LCB stmtlist RCB""" print("block : LCB stmtlist RCB") def p_stmtlist_stmt(self, p): """stmtlist : stmt""" print("stmtlist : stmt") def p_stmtlist_stmtlist(self, p): """stmtlist : stmtlist stmt""" print("stmtlist : stmtlist") def p_lvalue_id(self, p): """lvalue : ID""" print("lvalue : ID") print(p[1]) self.var_stack.append(p[1]) if not self.symbolTable.already_defined(p[1]): self.symbolTable.add_variable(p[1]) self.array_length = self.find_place(p[1]) def p_lvalue_id_array(self, p): """lvalue : ID array""" print("lvalue : ID array") index = self.array_length if type(index) == str: index = NonTerminal.nonTerminals_list[index] name = p[1] + '[' + str(index) + ']' print("!!!!!!!!!!!!!") else: print("@@@@@@@@@@") name = p[1] + '[' + str(index) + ']' print(name) self.var_stack.append(name) if not self.symbolTable.already_defined(p[1] + '[' + str(0) + ']'): self.symbolTable.add_array(p[1], index) def p_array(self, p): """array : LSB exp RSB""" print("array : LSB exp RSB") def p_case_where(self, p): """case : WHERE exp COLON stmtlist""" print("case : WHERE exp COLON stmtlist") def p_cases_case(self, p): """cases : case""" print("cases : case") def p_cases_cases(self, p): """cases : cases case""" print("cases : cases case") def p_stmt_return(self, p): """stmt : RETURN exp SEMICOLON""" print("stmt : RETURN exp SEMICOLON") def p_stmt_exp(self, p): """stmt : exp SEMICOLON""" print("stmt : exp SEMICOLON") self.symbolTable.stack.clear() def p_stmt_block(self, p): """stmt : block""" print("stmt : block") def p_stmt_vardec(self, p): """stmt : vardec""" print("stmt : vardec") def p_stmt_while(self, p): """stmt : WHILE LRB exp RRB stmt""" print("stmt : WHILE LRB exp RRB stmt") def p_stmt_on(self, p): """stmt : ON LRB exp RRB LCB cases RCB SEMICOLON""" print("stmt : ON LRB exp RRB LCB cases RCB SEMICOLON") def p_stmt_for_exp(self, p): """stmt : FOR LRB exp SEMICOLON exp SEMICOLON exp RRB stmt""" print("stmt : FOR LRB exp SEMICOLON exp SEMICOLON exp RRB stmt") def p_stmt_for_id(self, p): """stmt : FOR LRB ID IN ID RRB stmt""" print("stmt : FOR LRB ID IN ID RRB stmt") def p_stmt_print(self, p): """stmt : PRINT LRB ID RRB SEMICOLON""" print("stmt : PRINT LRB ID RRB SEMICOLON") self.codeGenerator.print(self.find_place(name=p[3])) def p_stmt_IF(self, p): """stmt : IF LRB exp RRB stmt elseiflist elsestmt""" print("stmt : IF LRB exp RRB stmt elseiflist elsestmt") def p_elsestmt(self, p): """elsestmt : ELSE stmt""" print("elsestmt : ELSE stmt") def p_elsestmt_Lambda(self, p): """elsestmt : %prec IF""" print("elsestmt : ") def p_elseiflist(self, p): """elseiflist : elseiflist ELSEIF LRB exp RRB stmt""" print("""elseiflist : elseiflist ELSEIF LRB exp RRB stmt""") def p_elseiflist_Lambda(self, p): """elseiflist : """ print("elseiflist : ") def p_exp_lvalue_assign(self, p): """exp : lvalue ASSIGN exp""" print("exp : lvalue ASSIGN exp") place = self.new_temp() exp_place = '' if p[3] is None: exp_place = self.find_place() self.symbolTable.add_place(self.var_stack.pop(), place) self.codeGenerator.assign(p, place, exp_place=exp_place) def p_exp_lvalue(self, p): """exp : lvalue""" print("exp : lvalue") def p_exp_id_explist(self, p): """exp : ID LRB explist RRB""" print("exp : ID LRB explist RRB") # TODO care, may cause problem in future def p_exp_parenthesis_exp(self, p): """exp : LRB exp RRB""" print("exp : LRB exp RRB") print(p[2]) p[0] = NonTerminal() if p[2] is None: p[0].place = self.find_place() else: p[0].place = p[2].get_value() def p_exp_id(self, p): """exp : ID LRB RRB""" print("exp : ID LRB RRB") def p_exp_SUB_exp(self, p): """exp : SUB exp""" print("exp : SUB exp") place = self.new_temp() exp_place = '' if p[2] is None: exp_place = self.find_place() self.symbolTable.add_place(self.var_stack.pop(), place) self.codeGenerator.not_assign(p, place, exp_place=exp_place) self.var_stack.append(place) def p_exp_not_exp(self, p): """exp : NOT exp""" print("exp : NOT exp") def p_exp_or(self, p): """exp : exp OR exp""" print("exp : OR") def p_exp_and(self, p): """exp : exp AND exp""" print("exp : exp AND exp") def p_exp_sum(self, p): "exp : exp SUM exp" print("exp : exp SUM exp") # TODO place1 = '' place3 = '' if p[1] is None: place1 = self.find_place() if p[3] is None: place3 = self.find_place() self.codeGenerator.generate_arithmetic_code(p, self.new_temp(), place1=place1, place3=place3) self.array_length = p[0].get_value() def p_exp_sub(self, p): "exp : exp SUB exp" print("exp : exp SUB exp") place1 = '' place3 = '' if p[1] is None: place1 = self.find_place() if p[3] is None: place3 = self.find_place() if p[1] is None and p[3] is None: self.codeGenerator.generate_arithmetic_code(p, self.new_temp(), place1=place3, place3=place1) else: self.codeGenerator.generate_arithmetic_code(p, self.new_temp(), place1=place1, place3=place3) self.array_length = p[0].place def p_exp_mul(self, p): "exp : exp MUL exp" print("exp : exp MUL exp") place1 = '' place3 = '' if p[1] is None: place1 = self.find_place() if p[3] is None: place3 = self.find_place() self.codeGenerator.generate_arithmetic_code(p, self.new_temp(), place1=place1, place3=place3) self.array_length = p[0].place def p_exp_div(self, p): "exp : exp DIV exp" print("exp : exp DIV exp") place1 = '' place3 = '' if p[1] is None: place1 = self.find_place() if p[3] is None: place3 = self.find_place() if p[1] is None and p[3] is None: self.codeGenerator.generate_arithmetic_code(p, self.new_temp(), place1=place3, place3=place1) else: self.codeGenerator.generate_arithmetic_code(p, self.new_temp(), place1=place1, place3=place3) self.array_length = p[0].place def p_exp_mod(self, p): """exp : exp MOD exp""" print("exp : exp MOD exp") place1 = '' place3 = '' if p[1] is None: place1 = self.find_place() if p[3] is None: place3 = self.find_place() if p[1] is None and p[3] is None: self.codeGenerator.generate_arithmetic_code(p, self.new_temp(), place1=place3, place3=place1) else: self.codeGenerator.generate_arithmetic_code(p, self.new_temp(), place1=place1, place3=place3) self.array_length = p[0].place def p_exp_gt_exp(self, p): """exp : exp GT exp""" print("exp : exp GT exp") print("*****************") print(p[1]) print(p[2]) print(p[3]) print("*****************") place1 = '' place3 = '' if p[1] is not None and p[1].value == '': place1 = self.latest_bool self.latest_bool = None if p[1] is None: place1 = self.find_place() if p[3] is None: place3 = self.find_place() if p[1] is None and p[3] is None: self.codeGenerator.boolean_expression(p, self.new_bool_temp(), place1=place3, place3=place1) else: self.codeGenerator.boolean_expression(p, self.new_bool_temp(), place1=place1, place3=place3) if p[3] is None: self.latest_bool = place3 else: self.latest_bool = p[3].value def p_exp_lt_exp(self, p): """exp : exp LT exp""" print("exp : exp LT exp") print("*****************") print(p[1]) print(p[2]) print(p[3]) print("*****************") def p_exp_ne_exp(self, p): """exp : exp NE exp""" print("exp : exp NE exp") def p_exp_eq_exp(self, p): """exp : exp EQ exp""" print("exp : exp EQ exp") def p_exp_ge_exp(self, p): """exp : exp GE exp""" print("exp : exp GE exp") def p_exp_le_exp(self, p): """exp : exp LE exp""" print("exp : exp LE exp") def p_exp_int(self, p): """exp : INTEGERNUMBER""" print("exp : INTEGERNUMBER") self.array_length = p[1] p[0] = NonTerminal() p[0].value = str(p[1]) def p_exp_float(self, p): """exp : FLOATNUMBER""" print("exp : FLOATNUMBER") p[0] = NonTerminal() p[0].value = str(int(p[1])) def p_exp_true(self, p): """exp : TRUE""" print("exp : TRUE") p[0] = NonTerminal() p[0].value = '1' def p_exp_false(self, p): """exp : FALSE""" print("exp : FALSE") p[0] = NonTerminal() p[0].value = '0' def p_explist_exp(self, p): """explist : exp""" print("explist : exp") def p_explist_explist(self, p): """explist : explist COMMA exp""" print("explist : explist COMMA exp") precedence = (('right', 'ASSIGN'), ('left', 'OR'), ('left', 'AND'), ('left', 'LT', 'GT', 'NE', 'EQ', 'LE', 'GE'), ('left', 'SUM', 'SUB'), ('left', 'MUL', 'DIV', 'MOD'), ('left', 'NOT'), ('left', 'IF'), ('left', 'ELSEIF', 'ELSE')) def new_temp(self): temp = "T" + str(self.tempCount) self.tempCount += 1 return temp def new_bool_temp(self): temp = "B" + str(self.tempCountBool) self.tempCountBool += 1 return temp def find_place(self, name=''): tmp = name if name == '': tmp = self.var_stack.pop() return self.symbolTable.find_place(tmp) def p_error(self, p): # print(p.value) print(p) raise Exception('ParsingError: invalid grammar at ', p) def build(self, **kwargs): """build the parser""" self.parser = yacc.yacc(module=self, **kwargs) return self.parser
#!/usr/bin/python from scaner import Scaner from parser import Parser from codeGenerator import CodeGenerator import sys for line in sys.stdin: expression = str(line) break print("Expression: " + expression) scaner = Scaner() parser = Parser() codeGen = CodeGenerator() tokens = scaner.scan(expression) tree = parser.constructTree(tokens) commands = codeGen.createCommands(tree) cl = "" for item in commands: print(item) cl = cl + item + ";" sys.stdout.write(cl)