def factor(self): self.dbg_msg( "factor" ) tok=self.peek() if tok.kind == EzhilToken.LPAREN: lparen_tok = self.dequeue() val=self.expr() if self.dequeue().kind!= EzhilToken.RPAREN: raise SyntaxError("Missing Parens "+str(self.last_token())) elif tok.kind == EzhilToken.NUMBER: tok_num = self.dequeue() [l, c] = tok_num.get_line_col() val = Number( tok.val , l, c, self.debug ) elif tok.kind == EzhilToken.LOGICAL_NOT: tok_not = self.dequeue() [l, c] = tok_not.get_line_col() val = UnaryExpr( self.expr(), tok_not , l, c, self.debug ) self.dbg_msg("completed parsing unary expression"+str(val)) elif tok.kind == EzhilToken.ID: tok_id = self.dequeue() [l, c] = tok_id.get_line_col() val = Identifier( tok.val , l, c, self.debug ) ptok = self.peek() self.dbg_msg("factor: "+str(ptok) + " / "+str(tok) ) if ( ptok.kind == EzhilToken.LPAREN ): ## function call [l, c] = ptok.get_line_col() vallist = self.valuelist() val=ExprCall( val, vallist, l, c, self.debug ) elif ( ptok.kind == EzhilToken.LSQRBRACE ): ## indexing a array type variable or ID val=None raise ParseException("arrays not implemented"+str(ptok)); elif tok.kind == EzhilToken.STRING : str_tok = self.dequeue() [l,c] = str_tok.get_line_col() val = String( tok.val , l, c, self.debug ) elif tok.kind in EzhilToken.ADDSUB: unop = self.dequeue(); [l, c] = unop.get_line_col() val=Expr(Number(0),unop,self.term(),l,c,self.debug); elif tok.kind == EzhilToken.LSQRBRACE: # creating a list/array expression list_start = self.dequeue(); val = Array() while( True ): exprval = self.expr() val.append( exprval ) if self.debug : print(self.peek().__class__,self.peek()) if ( self.peek().kind == EzhilToken.RSQRBRACE ): break else: assert( self.peek().kind == EzhilToken.COMMA) self.dequeue() assert( self.peek().kind == EzhilToken.RSQRBRACE ) list_end = self.dequeue() else: raise ParseException("Expected Number, found something "+str(tok)) self.dbg_msg( "factor-returning: "+str(val) ) return val
def num(p): value = 0 if (p[0].gettokentype() == 'SPECIAL'): value = p[1].value / 10000 else: value = p[0].value + p[2] / 10000 return Number(self.builder, self.module, value)
def printitem(p): ''' p[0] = numero ou variavel ''' if (p[0].gettokentype() == 'num'): return Number(self.builder, self.module, int(p[0].value)) else: return PrintItem(self.builder, self.module, p[0])
def parseSwitchStmt(self, exp): ## @ <ID/EXPR> SWITCH @( expr ) CASE {stmtlist} @( expr ) CASE {stmtlist} OTHERWISE {stmtlist} END ## implement as an if-elseif-else statement self.dbg_msg("parsing SWITCH statement") sw_tok = self.dequeue() [l, c] = sw_tok.get_line_col() self.inside_if = True lhs = exp[0] # enter this if-statement always ifstmt = IfStmt(Number(1), None, None, l, c, self.debug) self.if_stack.append(ifstmt) self.dbg_msg("parsing SWITCH-body") #self.dbg_msg ptok = self.peek() equality_token = EzhilLexeme("=", EzhilToken.EQUALITY) while (ptok.kind == EzhilToken.ATRATEOF or ptok.kind == EzhilToken.OTHERWISE): self.inside_if = True [l, c] = ptok.get_line_col() if (ptok.kind == EzhilToken.ATRATEOF): # parse elseif branch self.dbg_msg("parsing CASE") self.match(EzhilToken.ATRATEOF) exp = self.valuelist() self.dbg_msg("parsing CASE EXPR") self.match(EzhilToken.CASE) next_stmt = self.stmtlist() expr = Expr(lhs, equality_token, exp[0], l, c, self.debug) self.dbg_msg("building an Expr " + str(expr)) if not ifstmt.body: ifstmt.expr = expr ifstmt.body = next_stmt else: case_stmt = IfStmt(expr, next_stmt, None, l, c, self.debug) ifstmt.append_stmt(case_stmt) elif (ptok.kind == EzhilToken.OTHERWISE): #parse else branch self.dbg_msg("parsing OTHERWISE: ") self.match(EzhilToken.OTHERWISE) self.dbg_msg("parsing OTHERWISE-Body") self.inside_if = False body = self.stmtlist() else_stmt = ElseStmt(body, l, c, self.debug) if not ifstmt.body: ifstmt.body = else_stmt else: ifstmt.append_stmt(else_stmt) break else: self.inside_if = False raise ParseError( "SWITCH-CASE-OTHERWISE statement syntax is messed up") ptok = self.peek() self.dbg_msg("parsing SWITCH-CASE next bits " + str(ptok)) self.match(EzhilToken.END) self.inside_if = False self.dbg_msg("parsing -SWITCH-CASE- complete") return ifstmt
def factor(self): if self.current_token.type == NUM: factor = Number(self.current_token.value) self.consume(NUM) elif self.current_token.type == LPAREN: self.consume(LPAREN) factor = self.expr() self.consume(RPAREN) else: self.error() return factor
def parseExpression(parser): expression = None if parser.matchTokensort(STRING): #data string expression = Text(parser.currentToken[1], lineo=parser.currentToken[2]) parser.next() elif parser.matchTokensort(NUMBER): #number stuff expression = Number(parser.currentToken[1], lineo=parser.currentToken[2]) parser.next() elif parser.matchLexeme("["): expression = parseList(parser) elif parser.matchLexeme("{"): expression = parseRecord(parser) elif parser.matchTokensort(NAME): #Variable expression = Name(parser.currentToken[1]) #Check for Variable DOT Field expression fields = [] while parser.peek(lexeme=".") and parser.peek(x=2, tokensort=NAME): parser.next(lexeme=".") #skip. parser.next(expected="NAME", tokensort=NAME) fields.append(parser.currentToken[1]) if fields: expression = Field(expression, fields, lineo=parser.currentToken[2]) parser.next() #Check for expression PLUS expression if parser.matchLexeme("+") and expression: left = expression parser.next() # skip + right = parseExpression(parser) expression = Cat(left, right, lineo=parser.currentToken[2]) #indentedLog(expression) if not expression: raise SyntaxError( parser.currentToken, expected= "Expression: symbol, string, number, list, record, name.field") return expression
def factor(self): self.dbg_msg("factor") tok = self.peek() if tok.kind == Token.LPAREN: lparen_tok = self.dequeue() val = self.expr() if self.dequeue().kind != Token.RPAREN: raise SyntaxError("Missing Parens") elif tok.kind == Token.NUMBER: tok_num = self.dequeue() [l, c] = tok_num.get_line_col() val = Number(tok.val, l, c, self.debug) elif tok.kind == Token.ID: tok_id = self.dequeue() [l, c] = tok_id.get_line_col() val = Identifier(tok.val, l, c, self.debug) ptok = self.peek() self.dbg_msg("factor: " + str(ptok) + " / " + str(tok)) if (ptok.kind == Token.LPAREN): ## function call [l, c] = ptok.get_line_col() vallist = self.valuelist() val = ExprCall(val, vallist, l, c, self.debug) elif (ptok.kind == Token.LSQRBRACE): ## array type val = None raise ParseException("arrays not implemented" + str(ptok)) elif tok.kind == Token.STRING: str_tok = self.dequeue() [l, c] = str_tok.get_line_col() val = String(tok.val, l, c, self.debug) else: raise ParseException("Expected Number, found something " + str(tok)) self.dbg_msg("factor-returning: " + str(val)) return val
def PRINTF(*args): str_op = Interpreter.SPRINTF_worker(*args) print(str_op) return Number(len(str_op))
def INPUT(args): op = (raw_input(args)) if (isinstance(op, int) or isinstance(op, float)): return Number(0.0 + op) return String(op)
def factor(self): self.dbg_msg( "factor" ) tok=self.peek() if tok.kind == EzhilToken.LPAREN: lparen_tok = self.dequeue() val=self.expr() if self.dequeue().kind!= EzhilToken.RPAREN: raise SyntaxError("Missing Parens "+unicode(self.last_token())) elif tok.kind == EzhilToken.NUMBER: tok_num = self.dequeue() [l, c] = tok_num.get_line_col() val = Number( tok.val , l, c, self.debug ) elif tok.kind == EzhilToken.LOGICAL_NOT: tok_not = self.dequeue() [l, c] = tok_not.get_line_col() val = UnaryExpr( self.expr(), tok_not , l, c, self.debug ) self.dbg_msg("completed parsing unary expression"+unicode(val)) elif tok.kind == EzhilToken.ID: tok_id = self.dequeue() [l, c] = tok_id.get_line_col() val = Identifier( tok.val , l, c, self.debug ) ptok = self.peek() self.dbg_msg(u"factor: "+unicode(ptok) + u" / "+ unicode(tok) ) if ( ptok.kind == EzhilToken.LPAREN ): ## function call [l, c] = ptok.get_line_col() vallist = self.valuelist() val=ExprCall( val, vallist, l, c, self.debug ) elif ( ptok.kind == EzhilToken.LSQRBRACE ): ## indexing a array type variable or ID [l,c] = ptok.get_line_col() ## replace with a call to __getitem__ exp = self.factor(); if ( hasattr(exp,'__getitem__') ): VL2 = ValueList([val,exp[0]],l,c,self.debug) else: # when exp is a expression VL2 = ValueList([val,exp],l,c,self.debug) val = ExprCall( Identifier("__getitem__",l,c), VL2,l,c,self.debug) for itr in range(1,len(exp)): VL2 = ValueList([val,exp[itr]],l,c,self.debug) val = ExprCall( Identifier("__getitem__",l,c), VL2,l,c,self.debug) #raise ParseException("array indexing implemented"+unicode(ptok)); elif ( ptok.kind == EzhilToken.LCURLBRACE ): val=None raise ParseException("dictionary indexing implemented"+unicode(ptok)); elif tok.kind == EzhilToken.STRING : str_tok = self.dequeue() [l,c] = str_tok.get_line_col() val = String( tok.val , l, c, self.debug ) elif tok.kind in EzhilToken.ADDSUB: unop = self.dequeue(); [l, c] = unop.get_line_col() val=Expr(Number(0),unop,self.term(),l,c,self.debug); elif tok.kind == EzhilToken.LCURLBRACE: # creating a list/dictionary expression dict_start = self.dequeue(); val = Dict() while( True ): if ( self.peek().kind == EzhilToken.RCURLBRACE ): break; exprkey = self.expr() tok_colon = self.match(EzhilToken.COLON) exprval = self.expr() val.update( {exprkey : exprval} ) if self.debug : print(self.peek().__class__,self.peek()) if ( self.peek().kind == EzhilToken.RCURLBRACE ): break else: assert( self.peek().kind == EzhilToken.COMMA) self.dequeue() assert( self.peek().kind == EzhilToken.RCURLBRACE ) list_end = self.dequeue() elif tok.kind == EzhilToken.LSQRBRACE: # creating a list/array expression list_start = self.dequeue(); val = Array() while( True ): if ( self.peek().kind == EzhilToken.RSQRBRACE ): break; exprval = self.expr() val.append( exprval ) if self.debug : print(self.peek().__class__,self.peek()) if ( self.peek().kind == EzhilToken.RSQRBRACE ): break else: assert( self.peek().kind == EzhilToken.COMMA) self.dequeue() assert( self.peek().kind == EzhilToken.RSQRBRACE ) list_end = self.dequeue() else: raise ParseException("Expected Number, found something "+unicode(tok)) self.dbg_msg( u"factor-returning: "+unicode(val) ) return val
def factor(self): self.dbg_msg("factor") tok = self.peek() if tok.kind == EzhilToken.LPAREN: lparen_tok = self.dequeue() val = self.expr() if self.dequeue().kind != EzhilToken.RPAREN: raise SyntaxError("Missing Parens " + str(self.last_token())) elif tok.kind == EzhilToken.NUMBER: tok_num = self.dequeue() [l, c] = tok_num.get_line_col() val = Number(tok.val, l, c, self.debug) elif tok.kind == EzhilToken.LOGICAL_NOT: tok_not = self.dequeue() [l, c] = tok_not.get_line_col() val = UnaryExpr(self.expr(), tok_not, l, c, self.debug) self.dbg_msg("completed parsing unary expression" + str(val)) elif tok.kind == EzhilToken.ID: tok_id = self.dequeue() [l, c] = tok_id.get_line_col() val = Identifier(tok.val, l, c, self.debug) ptok = self.peek() self.dbg_msg("factor: " + str(ptok) + " / " + str(tok)) if (ptok.kind == EzhilToken.LPAREN): ## function call [l, c] = ptok.get_line_col() vallist = self.valuelist() val = ExprCall(val, vallist, l, c, self.debug) elif (ptok.kind == EzhilToken.LSQRBRACE): ## indexing a array type variable or ID [l, c] = ptok.get_line_col() ## replace with a call to __getitem__ exp = self.factor() if (hasattr(exp, '__getitem__')): VL2 = ValueList([val, exp[0]], l, c, self.debug) else: # when exp is a expression VL2 = ValueList([val, exp], l, c, self.debug) val = ExprCall(Identifier("__getitem__", l, c), VL2, l, c, self.debug) for itr in range(1, len(exp)): VL2 = ValueList([val, exp[itr]], l, c, self.debug) val = ExprCall(Identifier("__getitem__", l, c), VL2, l, c, self.debug) #raise ParseException("array indexing implemented"+str(ptok)); elif (ptok.kind == EzhilToken.LCURLBRACE): val = None raise ParseException("dictionary indexing implemented" + str(ptok)) elif tok.kind == EzhilToken.STRING: str_tok = self.dequeue() [l, c] = str_tok.get_line_col() val = String(tok.val, l, c, self.debug) elif tok.kind in EzhilToken.ADDSUB: unop = self.dequeue() [l, c] = unop.get_line_col() val = Expr(Number(0), unop, self.term(), l, c, self.debug) elif tok.kind == EzhilToken.LCURLBRACE: # creating a list/dictionary expression dict_start = self.dequeue() val = Dict() while (True): if (self.peek().kind == EzhilToken.RCURLBRACE): break exprkey = self.expr() tok_colon = self.match(EzhilToken.COLON) exprval = self.expr() val.update({exprkey: exprval}) if self.debug: print(self.peek().__class__, self.peek()) if (self.peek().kind == EzhilToken.RCURLBRACE): break else: assert (self.peek().kind == EzhilToken.COMMA) self.dequeue() assert (self.peek().kind == EzhilToken.RCURLBRACE) list_end = self.dequeue() elif tok.kind == EzhilToken.LSQRBRACE: # creating a list/array expression list_start = self.dequeue() val = Array() while (True): if (self.peek().kind == EzhilToken.RSQRBRACE): break exprval = self.expr() val.append(exprval) if self.debug: print(self.peek().__class__, self.peek()) if (self.peek().kind == EzhilToken.RSQRBRACE): break else: assert (self.peek().kind == EzhilToken.COMMA) self.dequeue() assert (self.peek().kind == EzhilToken.RSQRBRACE) list_end = self.dequeue() else: raise ParseException("Expected Number, found something " + str(tok)) self.dbg_msg("factor-returning: " + str(val)) return val
def factor_number(p): return Number(self.builder, self.module, p[0].getstr())
def snum(p): value = p[1].value if (p[0].getstr() == '-'): value = value * (-1) return Number(self.builder, self.module, value)
def factor(self): self.dbg_msg("factor") tok = self.peek() if tok.kind == EzhilToken.LPAREN: lparen_tok = self.dequeue() val = self.expr() if self.dequeue().kind != EzhilToken.RPAREN: raise SyntaxError("Missing Parens " + str(self.last_token())) elif tok.kind == EzhilToken.NUMBER: tok_num = self.dequeue() [l, c] = tok_num.get_line_col() val = Number(tok.val, l, c, self.debug) elif tok.kind == EzhilToken.LOGICAL_NOT: tok_not = self.dequeue() [l, c] = tok_not.get_line_col() val = UnaryExpr(self.expr(), tok_not, l, c, self.debug) self.dbg_msg("completed parsing unary expression" + str(val)) elif tok.kind == EzhilToken.ID: tok_id = self.dequeue() [l, c] = tok_id.get_line_col() val = Identifier(tok.val, l, c, self.debug) ptok = self.peek() self.dbg_msg("factor: " + str(ptok) + " / " + str(tok)) if (ptok.kind == EzhilToken.LPAREN): ## function call [l, c] = ptok.get_line_col() vallist = self.valuelist() val = ExprCall(val, vallist, l, c, self.debug) elif (ptok.kind == EzhilToken.LSQRBRACE): ## indexing a array type variable or ID val = None raise ParseException("arrays not implemented" + str(ptok)) elif tok.kind == EzhilToken.STRING: str_tok = self.dequeue() [l, c] = str_tok.get_line_col() val = String(tok.val, l, c, self.debug) elif tok.kind in EzhilToken.ADDSUB: unop = self.dequeue() [l, c] = unop.get_line_col() val = Expr(Number(0), unop, self.term(), l, c, self.debug) elif tok.kind == EzhilToken.LSQRBRACE: # creating a list/array expression list_start = self.dequeue() val = Array() while (True): exprval = self.expr() val.append(exprval) if self.debug: print(self.peek().__class__, self.peek()) if (self.peek().kind == EzhilToken.RSQRBRACE): break else: assert (self.peek().kind == EzhilToken.COMMA) self.dequeue() assert (self.peek().kind == EzhilToken.RSQRBRACE) list_end = self.dequeue() else: raise ParseException("Expected Number, found something " + str(tok)) self.dbg_msg("factor-returning: " + str(val)) return val
def stmt(self, pass_in_ATexpr=None): """ try an assign, print, return, if or eval statement """ self.dbg_msg(" STMT ") ptok = self.peek() self.dbg_msg("stmt: peeking at " + str(ptok)) if (ptok.kind == EzhilToken.RETURN): ## return <expression> self.dbg_msg('enter->return: <expression>') ret_tok = self.dequeue() [l, c] = ret_tok.get_line_col() rstmt = ReturnStmt(self.expr(), l, c, self.debug) self.dbg_msg("return statement parsed") return rstmt elif (ptok.kind == EzhilToken.PRINT): self.currently_parsing.append(ptok) ## print <expression> print_tok = self.dequeue() [l, c] = print_tok.get_line_col() exprlist_val = self.exprlist() self.currently_parsing.pop() return PrintStmt(exprlist_val, l, c, self.debug) elif (ptok.kind == EzhilToken.ATRATEOF or pass_in_ATexpr): ## @ <expression> {if | while | elseif} if not pass_in_ATexpr: at_tok = self.match(EzhilToken.ATRATEOF) self.currently_parsing.append(at_tok) exp = self.valuelist() self.currently_parsing.pop() else: exp = pass_in_ATexpr if (self.debug): print("return from valuelist ", str(exp)) ptok = self.peek() if (ptok.kind == EzhilToken.IF): return self.parseIfStmt(exp) elif (ptok.kind == EzhilToken.WHILE): ## @ ( expr ) while { body } end self.loop_stack.append(True) self.dbg_msg("while-statement") while_tok = self.dequeue() self.currently_parsing.append(while_tok) [l, c] = while_tok.get_line_col() wexpr = exp[0] body = self.stmtlist() self.match(EzhilToken.END) whilestmt = WhileStmt(wexpr, body, l, c, self.debug) self.loop_stack.pop() self.currently_parsing.pop() return whilestmt elif (ptok.kind == EzhilToken.SWITCH): return self.parseSwitchStmt(exp) elif (ptok.kind == EzhilToken.FOREACH): foreach_tok = self.dequeue() self.currently_parsing.append(foreach_tok) [l, c] = foreach_tok.get_line_col() if (self.debug): print("parsing FOREACH stmt") self.loop_stack.append(True) self.dbg_msg("foreach-statement") # convert to a for statement - building Ezhil AST - transformations if not isinstance(exp[1], Identifier): raise ParseError(" FOR-EACH statement " + str(foreach_tok)) foreach_iter = exp[1] iter = Identifier("__" + foreach_iter.id, l=0, c=-1) eq_token = EzhilLexeme("=", EzhilToken.EQUALS) plus_token = EzhilLexeme("+", EzhilToken.PLUS) lt_token = EzhilLexeme("<", EzhilToken.LT) if (self.debug): print("build init assign stmt") init = AssignStmt(iter, eq_token, Number(0), l, c, self.debug) if (self.debug): print("build cond expr") VL1 = ValueList([exp[0]], l, c, self.debug) cond = Expr( iter, lt_token, ExprCall(Identifier("len", l, c), VL1, l, c, self.debug), l, c, self.debug) if (self.debug): print("build plus1 stmt") plus1_iter = Expr(iter, plus_token, Number(1), l, c, self.debug) if (self.debug): print("build equals stmt") update = AssignStmt(iter, eq_token, plus1_iter, l, c, self.debug) body = self.stmtlist() #parse body # and insert artifical update variable in body VL2 = ValueList([exp[0], iter], l, c, self.debug) extract_foreach_iter_from_list = ExprCall( Identifier("__getitem__", l, c), VL2, l, c, self.debug) foreach_iter_Assign = AssignStmt( foreach_iter, eq_token, extract_foreach_iter_from_list, l, c, self.debug) body.List.insert(0, foreach_iter_Assign) # complete FOREACH stmt self.match(EzhilToken.END) self.currently_parsing.pop() foreach_stmt = ForStmt(init, cond, update, body, l, c, self.debug) self.loop_stack.pop() if (self.debug): print("completed parsing FOR-EACH loop", str(foreach_stmt)) return foreach_stmt elif (ptok.kind == EzhilToken.FOR): ## Fixme : empty for loops not allowed. """ For ( exp1 , exp2 , exp3 ) stmtlist end""" if (self.debug): print("parsing FOR stmt") self.loop_stack.append(True) self.dbg_msg("for-statement") for_tok = self.peek() self.currently_parsing.append(for_tok) if (self.debug): print("matching for STMT", str(self.peek())) self.match(EzhilToken.FOR) if (self.debug): print("matched for STMT", str(self.peek())) [l, c] = for_tok.get_line_col() init, cond, update = exp[0], exp[1], exp[2] if (self.debug): print("extract 3 parts", str(init), str(cond), str(update)) body = self.stmtlist() self.match(EzhilToken.END) self.currently_parsing.pop() if (self.debug): print("body of loop", str(body)) forstmt = ForStmt(init, cond, update, body, l, c, self.debug) self.loop_stack.pop() if (self.debug): print("completed parsing FOR loop", str(forstmt)) return forstmt elif (ptok.kind == EzhilToken.DO): if (self.debug): print("parsing DO-WHILE statement") self.loop_stack.append(True) do_tok = self.dequeue() self.currently_parsing.append(do_tok) [l, c] = do_tok.get_line_col() body = self.stmtlist() if (self.debug): print("parsed body") self.match(EzhilToken.DOWHILE) self.match(EzhilToken.ATRATEOF) exp = self.valuelist() if (self.debug): print("parsed EXP", exp[0]) doWhileStmt = DoWhileStmt(exp[0], body, l, c, self.debug) self.loop_stack.pop() self.currently_parsing.pop() return doWhileStmt elif (ptok.kind == EzhilToken.BREAK): ## break, must be in loop-environment self.dbg_msg("break-statement") break_tok = self.dequeue() [l, c] = break_tok.get_line_col() self.check_loop_stack() ##raises a parse error brkstmt = BreakStmt(l, c, self.debug) return brkstmt elif (ptok.kind == EzhilToken.CONTINUE): ## continue, must be in loop-environment self.dbg_msg("continue-statement") cont_tok = self.dequeue() [l, c] = cont_tok.get_line_col() self.check_loop_stack() ##raises a parse error cntstmt = ContinueStmt(l, c, self.debug) return cntstmt else: ## lval := rval ptok = self.peek() self.currently_parsing.append(ptok) [l, c] = ptok.get_line_col() lhs = self.expr() self.dbg_msg("parsing expr: " + str(lhs)) ptok = self.peek() if (ptok.kind in EzhilToken.ASSIGNOP): assign_tok = self.dequeue() rhs = self.expr() [l, c] = assign_tok.get_line_col() self.currently_parsing.pop() return AssignStmt(lhs, assign_tok, rhs, l, c, self.debug) self.currently_parsing.pop() return EvalStmt(lhs, l, c, self.debug) raise ParseException("parsing Statement, unkown operators" + str(ptok))
def number(p): return Number(self.builder, self.module, p[0].value)
def ezhil_tamil_length(arg): return Number(len(tamil.utf8.get_letters(arg)))
def expression_number(p): # p is a list of the pieces matched by the right hand side of the # rule return Number(int(p[0].getstr()))
def p_atom(tokens): token = tokens[0] if (token.gettokentype() == 'NUMBER'): return Number(int(token.getstr())) elif (token.gettokentype() == 'NAME'): return Ident(token.getstr())
def handleNumber(p): return Number(p[0].value)
def number(p): return Number(p[0].value)
def int_function(p): result = 0 for i in range(len(p)): result = result * 10 + p[i] return Number(self.builder, self.module, result)