def p_is_array_term(p): '''is_array_term : is_array_term '[' expression ']' | is_array_term '.' ID | ID ''' if len(p) > 4: if type(p[1]) == leaf: new_branch = branch() new_branch.setType("ACCESS") new_branch.add(p[1]) new_branch.add(p[3]) p[0] = new_branch else: new_branch = p[1] new_branch.add(p[3]) p[0] = new_branch elif len(p) > 2: if type(p[1]) == leaf: new_branch = branch() new_branch.setType("ACCESS") new_branch.add(p[1]) new_branch.add(leaf(p[3], "STRING")) p[0] = new_branch else: new_branch = p[1] new_branch.add(leaf(p[3], "STRING")) p[0] = new_branch else: p[0] = leaf(p[1], "ID")
def p_statement_group(p): '''statement : IF '(' expression ')' GOTO LABEL | UNSET '(' term ')' | GOTO LABEL | EXIT ''' global sym_table new_branch = branch() if len(p) > 5: new_branch.add(p[3]) r_leaf = leaf(p[6], "LABEL") new_branch.add(r_leaf) new_branch.setType("IF") sym_table.appendGrammar( 7, 'statement -> IF ( expression ) GOTO LABEL ') elif len(p) > 3: new_branch.add(p[3]) new_branch.setType("UNSET") sym_table.appendGrammar(8, 'statement -> UNSET ( term ) ') elif len(p) > 2: r_leaf = leaf(p[2], "LABEL") new_branch.add(r_leaf) new_branch.setType("GOTO") sym_table.appendGrammar(9, 'statement -> GOTO LABEL ') else: new_branch.setType("EXIT") sym_table.appendGrammar(10, 'statement -> EXIT ') p[0] = new_branch
def p_sub_decl(p): '''sub_decl : ID "=" expression | ID "=" READ "(" ")" | decl_array "=" "{" expression_list "}" | decl_index "=" "{" expression_list "}" | decl_index "=" expression | decl_index "=" READ "(" ")" | decl_index | decl_array | ID ''' global sym_table new_branch = branch() if len(p) == 4: if type(p[1]) == branch: #TODO assign to index of array pass else: l_leaf = leaf(p[1], "ID") r_leaf = p[3] new_branch.add(l_leaf) new_branch.add(r_leaf) new_branch.setType("ASSIGN") sym_table.appendGrammar( 5, 'statement -> is_array_term = expression') elif len(p) > 3: if p[4] == '(': l_leaf = leaf(p[1], "ID") r_leaf = leaf("read()", "READ") new_branch.add(l_leaf) new_branch.add(r_leaf) new_branch.setType("ASSIGN") else: l_leaf = p[1] r_leaf = p[4] r_leaf.setType("VARRAY") new_branch.add(l_leaf) new_branch.add(r_leaf) new_branch.setType("ASSIGN") else: if type(p[1]) == branch: #TODO assign to index of array pass else: new_branch = leaf(p[1], "ID") p[0] = new_branch
def p_arg(p): ''' arg : type ID | type "&" ID ''' new_branch = branch() new_branch.add(leaf(p[1], p[1])) if len(p) == 3: new_branch.add(leaf(p[2], "ID")) else: new_branch.add(leaf(p[3], "ID")) new_branch.add(leaf("&", "POINT")) new_branch.setType("DECLARE") p[0] = new_branch
def p_decl_index(p): '''decl_index : decl_index "[" term "]" | ID "[" term "]" ''' if type(p[1]) == leaf: p[0] = leaf(p[1], "ID") else: p[0] = p[1]
def READ(node, sym_table): # lookup the last line index = sym_table.terminal.search(r'\n', "insert", backwards=True, regexp=True) txt = sym_table.terminal.get(str(index),'end-1c') if txt == "": index ="1.0" index = sym_table.terminal.index("%s+1c" % index) # print before start waiting sym_table.terminal.insert(str(float(index)+1), sym_table.getLog()) sym_table.cleanLog() sym_table.terminal.focus_set() # wait input from terminal x = Label() global read_input x.wait_variable(sym_table.read_input) value = sym_table.read_input.get() typ = '' try: try: value = int(value) typ = 'NUM' except: value = float(value) typ = 'FLOAT' except: typ = 'STRING' return leaf(value, typ)
def p_unary_exp(p): '''unary_expr : "+" "+" is_array_term %prec PRE | "-" "-" is_array_term %prec PRE | is_array_term "+" "+" %prec POST | is_array_term "-" "-" %prec POST ''' r_leaf = leaf("1", "INT") global sym_table new_branch = branch() if p[1] == '+': l_leaf = p[3] new_branch.setType("ADD") sym_table.appendGrammar(12, 'unary_expr -> ++ is_array_term') elif p[1] == '-': l_leaf = p[3] new_branch.setType("SUB") sym_table.appendGrammar(12, 'unary_expr -> -- is_array_term') # TODO create an special node type that indicates ADD and SUB will occur in the next block elif p[2] == '+': l_leaf = p[1] new_branch.setType("ADD") sym_table.appendGrammar(12, 'unary_expr -> is_array_term ++') elif p[2] == '-': l_leaf = p[1] new_branch.setType("SUB") sym_table.appendGrammar(12, 'unary_expr -> is_array_term --') new_branch.add(l_leaf) new_branch.add(r_leaf) new_branch2 = branch() new_branch2.add(l_leaf) new_branch2.add(new_branch) new_branch2.setType("ASSIGN") p[0] = new_branch2
def p_function(p): '''function : type ID "(" argument_list "{" compound_statement | VOID ID "(" argument_list "{" compound_statement''' new_branch = branch() new_branch.setType("FUNCTION") # add type new_branch.add(leaf(p[1], p[1].upper())) # add ID new_branch.add(leaf(p[2], "ID")) # add new scope new_branch.add(p[6]) # if has add arguments if p[4] != None: new_branch.add(p[4]) p[0] = new_branch
def p_decl_array(p): '''decl_array : decl_array "[" "]" | ID "[" "]" ''' if type(p[1]) == leaf: p[0] = leaf(p[1], "ID") else: p[0] = p[1]
def p_expression_string(p): 'factor : STRING' string = p[1].replace("'", "") string = string.replace("\"", "") l_leaf = leaf(string, "STRING") p[0] = l_leaf global sym_table sym_table.appendGrammar(44, 'factor -> STRING')
def p_struct(p): 'struct : STRUCT ID "{" assigment_list "}" ";" ' new_branch = branch() new_branch.setType("STRUCT") new_branch.add(leaf(p[2], "ID")) new_branch.add(p[4]) p[0] = new_branch
def p_term_group(p): '''expression : '(' INT ')' factor | '(' FLOAT ')' factor | '(' CHAR ')' factor | '(' factor ')' | '~' factor | '!' factor | '&' VAR | ABS '(' factor ')' | ARRAY '(' ')' | READ '(' ')' ''' global sym_table new_branch = branch() if p[1] == '(': l_leaf = p[4] new_branch.add(l_leaf) if p[2] == 'int': new_branch.setType("TOINT") sym_table.appendGrammar(32, 'expression -> ( INT ) factor') elif p[2] == 'float': new_branch.setType("TOFLOAT") sym_table.appendGrammar(33, 'expression -> ( FLOAT ) factor') elif p[2] == 'char': new_branch.setType("TOCHAR") sym_table.appendGrammar(34, 'expression -> ( CHAR ) factor') else: new_branch = p[2] sym_table.appendGrammar(35, 'expression -> ( factor )') elif p[1] == '~': l_leaf = p[2] new_branch.add(l_leaf) new_branch.setType("BNOT") sym_table.appendGrammar(36, 'expression -> ~ factor') elif p[1] == '!': l_leaf = p[2] new_branch.add(l_leaf) new_branch.setType("NOT") sym_table.appendGrammar(37, 'expression -> ! factor') elif p[1] == '&': l_leaf = leaf(p[2], "ID") new_branch.add(l_leaf) new_branch.setType("POINT") sym_table.appendGrammar(38, 'expression -> & factor') elif p[1] == 'abs': l_leaf = p[3] new_branch.add(l_leaf) new_branch.setType("ABS") sym_table.appendGrammar(39, 'expression -> ABS ( factor )') elif p[1] == 'array': new_branch.setType("ARRAY") sym_table.appendGrammar(40, 'expression -> ARRAY ( )') elif p[1] == 'read': new_branch.setType("READ") sym_table.appendGrammar(41, 'expression -> READ ( )') p[0] = new_branch
def p_function_call(p): 'function_call : ID "(" parentheses_expression' new_branch = branch() new_branch.setType("CALL") new_branch.add(leaf(p[1], "ID")) if p[3] != None: new_branch.add(p[3]) p[0] = new_branch
def p_term_group(p): '''expression : '(' INT ')' expression %prec CAST | '(' FLOAT ')' expression %prec CAST | '(' CHAR ')' expression %prec CAST | '(' ID ')' expression %prec CAST | '(' expression ')' | '~' expression | '!' expression %prec NOT_PRE | '&' ID %prec POINT | expression '?' expression ':' expression | function_call ''' global sym_table new_branch = branch() if p[1] == '(': if len(p) > 4: l_leaf = p[4] new_branch.add(l_leaf) if p[2] == 'int': new_branch.setType("TOINT") sym_table.appendGrammar( 32, 'expression -> ( INT ) expression') elif p[2] == 'float': new_branch.setType("TOFLOAT") sym_table.appendGrammar( 33, 'expression -> ( FLOAT ) expression') elif p[2] == 'char': new_branch.setType("TOCHAR") sym_table.appendGrammar( 34, 'expression -> ( CHAR ) expression') else: new_branch.setType("TOID") sym_table.appendGrammar(34, 'expression -> ( ID ) expression') else: new_branch = p[2] sym_table.appendGrammar(35, 'expression -> ( expression )') elif p[1] == '~': l_leaf = p[2] new_branch.add(l_leaf) new_branch.setType("BNOT") sym_table.appendGrammar(36, 'expression -> ~ expression') elif p[1] == '!': l_leaf = p[2] new_branch.add(l_leaf) new_branch.setType("NOT") sym_table.appendGrammar(37, 'expression -> ! expression') elif p[1] == '&': l_leaf = leaf(p[2], "ID") new_branch.add(l_leaf) new_branch.setType("POINT") sym_table.appendGrammar(38, 'expression -> & ID') else: new_branch = p[1] sym_table.appendGrammar(38.1, 'expression -> function_call') p[0] = new_branch
def p_term_decimal(p): 'term : NUMBER "." NUMBER ' powder = p[3] for i in range(len(str(p[3]))): powder = powder / 10 double = float(p[1]) + powder l_leaf = leaf(double, "FLOAT") p[0] = l_leaf global sym_table sym_table.appendGrammar(43, 'term -> NUMBER "." NUMBER')
def p_expression_decimal(p): 'factor : NUMBER "." NUMBER' powder = p[3] for i in range(len(str(p[3]))): powder = powder / 10 double = float(p[1]) + powder l_leaf = leaf(double, "FLOAT") p[0] = l_leaf global sym_table sym_table.appendGrammar(43, 'factor -> DECIMAL')
def p_term_uminus(p): "term : '-' factor %prec UMINUS" l_leaf = p[2] r_leaf = leaf(-1, "NUM") global sym_table new_branch = branch() new_branch.add(l_leaf) new_branch.add(r_leaf) new_branch.setType("MUL") sym_table.appendGrammar(31, 'term -> - factor') p[0] = new_branch
def p_expression_uminus(p): "expression : '-' expression %prec UMINUS" l_leaf = p[2] r_leaf = leaf(-1, "INT") global sym_table new_branch = branch() new_branch.add(l_leaf) new_branch.add(r_leaf) new_branch.setType("MUL") sym_table.appendGrammar(31, 'term -> - expression') p[0] = new_branch
def p_declare_struct(p): '''declare_struct : declare_struct "," decl_index | declare_struct "," ID | STRUCT ID decl_index | STRUCT ID ID ''' new_branch = branch() new_branch.setType("ARRAY") if p[1] == 'struct': new_branch.add(leaf(p[2], "ID")) if type(p[3]) == str: new_branch.add(leaf(p[3], "ID")) else: new_branch.add(p[3]) else: new_branch = p[1] if type(p[3]) == str: new_branch.add(leaf(p[3], "ID")) else: new_branch.add(p[3]) p[0] = new_branch
def p_declaration_statement(p): '''declaration : declaration "," sub_decl | type sub_decl ''' if len(p) == 3: new_branch = branch() new_branch.add(leaf(p[1], p[1])) new_branch.add(p[2]) new_branch.setType("DECLARE") p[0] = new_branch else: new_branch = p[1] new_branch.add(p[3]) p[0] = new_branch
def p_native_statement(p): '''native_statement : PRINT "(" STRING "," expression_list ")" ";" | PRINT "(" STRING ")" ";" | GOTO ID ";" | ID ":" ''' new_branch = branch() if len(p) > 6: new_branch.setType("PRINT") new_branch.add(leaf(p[3], "STRING")) p[5].setType("SCOPE") p[5].setValue("EXPS") new_branch.add(p[5]) elif len(p) > 4: new_branch.setType("PRINT") new_branch.add(leaf(p[3], "STRING")) elif len(p) > 3: new_branch.setType("GOTO") new_branch.add(leaf(p[2], "ID")) else: new_branch.setType("LABEL") new_branch.add(leaf(p[1], "ID")) p[0] = new_branch
def TOVALUE(value, sym_table): try: if value.getType() == leaf.TYPE["ID"]: return value.execute(sym_table) elif value.getType() == leaf.TYPE["ACCESS"]: result = value.execute(sym_table) index = result.getRef() array = result.getValue() value = array[index] return leaf(array[index], TYPEOF(value)) elif type(value) == sym: if value.getType() == leaf.TYPE["STRUCT"]: index = value.getRef() array = value.getValue() return array[index] return value.getValue() elif value.getType() > 5: value = value.execute(sym_table) value = leaf(value, TYPEOF(value)) return value except: # its the value itself return value
def p_term_array(p): '''is_array_term : is_array_term '[' factor ']' | VAR ''' global sym_table if len(p) > 2: new_branch = branch() new_branch.add(p[1]) new_branch.add(p[3]) new_branch.setType("ACCESS") p[0] = new_branch sym_table.appendGrammar( 45, 'is_array_term -> is_array_term [ factor ]') else: l_leaf = leaf(p[1], "ID") p[0] = l_leaf sym_table.appendGrammar(46, 'is_array_term -> VAR')
def p_expression_decimal(p): 'factor : DECIMAL' l_leaf = leaf(p[1], "FLOAT") p[0] = l_leaf global sym_table sym_table.appendGrammar(43, 'factor -> DECIMAL')
def TOCHAR(node, sym_table): return leaf(CONVERT('char', node, sym_table), "STRING")
def TOFLOAT(node, sym_table): return leaf(CONVERT('float', node, sym_table), "FLOAT")
def TOINT(node, sym_table): return leaf(CONVERT('int', node, sym_table), "NUM")
def p_term_string(p): 'term : STRING' l_leaf = leaf(p[1], "STRING") p[0] = l_leaf global sym_table sym_table.appendGrammar(44, 'factor -> STRING')
def p_term_number(p): 'term : NUMBER' l_leaf = leaf(p[1], "INT") p[0] = l_leaf global sym_table sym_table.appendGrammar(42, 'term -> NUMBER')
def p_expression_number(p): 'factor : NUMBER' l_leaf = leaf(p[1], "NUM") p[0] = l_leaf global sym_table sym_table.appendGrammar(42, 'factor -> NUMBER')