def exponent(self): """ Exponent ⇒ {Factor **} Factor """ # Check for a factor expression and capture it to create an exponent expression. There must be at least one factor. aFactor = self.factor() # Initialize a variable to be used while creating an exponent expression with more than one factor expression # and '**' operator. aBinaryExpr = '' # Check for '**' operators. if self.currToken[0] == lexer.Lexer.POWER: # Capture the operator to create a BinaryExpr object. operator = self.currToken[0] # Move to the next token. self.currToken = next(self.tokens) # Create a BinaryExpr object. aBinaryExpr = ast.BinaryExpr(operator, aFactor, self.exponent()) # Check whether right was given an expression. if aBinaryExpr == '': # Return the expression. return aFactor else: # Return the BinaryExpr object. return aBinaryExpr
def expression(self): left_tree = self.conjunction() while self.currtok[0] == 'OR': self.currtok = next(self.tokens) right_tree = self.conjunction() left_tree = ast.BinaryExpr(left_tree, right_tree, '||') return left_tree
def equality(self): left_tree = self.relation() if self.currtok[2] == '==' or self.currtok[2] == '!=': tmpID = self.currtok[2] self.currtok = next(self.tokens) right_tree = self.relation() left_tree = ast.BinaryExpr(left_tree, right_tree, tmpID) return left_tree
def addition(self): left_tree = self.term() while self.currtok[0] == 'PLUS' or self.currtok[0] == "MINUS": tmpID = self.currtok[2] self.currtok = next(self.tokens) right_tree = self.term() left_tree = ast.BinaryExpr(left_tree, right_tree, tmpID) return left_tree
def relation(self): left_tree = self.addition() if self.currtok[2] == '<' or self.currtok[2] == '<=' or \ self.currtok[2] == '>' or self.currtok[2] == '>=': tmpID = self.currtok[2] self.currtok = next(self.tokens) right_tree = self.addition() left_tree = ast.BinaryExpr(left_tree, right_tree, tmpID) return left_tree
def conjunction(self): left_tree = self.equality() while self.currtok[0] == 'AND': self.currtok = next(self.tokens) right_tree = self.equality() left_tree = ast.BinaryExpr(left_tree, right_tree, '&&') return left_tree
def expon(self): left_tree = self.factor() while self.currtok[0] == 'EXPONENTIATION': tmpID = self.currtok[2] self.currtok = next(self.tokens) right_tree = self.factor() left_tree = ast.BinaryExpr(left_tree, right_tree, tmpID) return left_tree
def term(self): left_tree = self.expon() while self.currtok[0] == 'MULTIPLY' or self.currtok[ 0] == "DIVIDE" or self.currtok[0] == "MOD": tmpID = self.currtok[2] self.currtok = next(self.tokens) right_tree = self.expon() left_tree = ast.BinaryExpr(left_tree, right_tree, tmpID) return left_tree
def p_expr_binop(p): '''expr : expr PLUS expr | expr MINUS expr | expr MULTIPLY expr | expr DIVIDE expr | expr EQ expr | expr NEQ expr | expr LT expr | expr LEQ expr | expr GT expr | expr GEQ expr | expr AND expr | expr OR expr ''' p[0] = ast.BinaryExpr(binops[p[2]], p[1], p[3], p.lineno(2))
def expression(self): """ Expression ⇒ Conjunction { || Conjunction } :return: """ left_tree = self.conjuction() # Run this while the current token is # equal to "||" aka Or while self.currtok[0] == lexer.Lexer.OR: tempor = self.currtok[1] self.currtok = next(self.tokens) right_tree = self.conjuction() left_tree = ast.BinaryExpr(left_tree, right_tree, tempor) return left_tree
def conjuction(self): """ Conjunction ⇒ Equality { && Equality } :return: """ left_tree = self.equality() # Run this while the current token is equal # To "&&" aka and while self.currtok[0] == lexer.Lexer.AND: tempand = self.currtok[1] self.currtok = next(self.tokens) right_tree = self.equality() left_tree = ast.BinaryExpr(left_tree, right_tree, tempand) return left_tree
def equality(self): """ Equality ⇒ Relation [ EquOp Relation ] :return: """ left_tree = self.relation() # Check if the current token is either # "==" or "!=" if self.currtok[0] in [lexer.Lexer.EQEQ, lexer.Lexer.NOTEQ]: tmpexpr = self.currtok[1] self.currtok = next(self.tokens) right_tree = self.relation() left_tree = ast.BinaryExpr(left_tree, right_tree, tmpexpr) return left_tree
def term(self): """ Term → Factor {MulOp Factor} :return: """ left_tree = self.factor() # Run this while the current token is a # times, division, mod, or exponential while self.currtok[0] in [lexer.Lexer.TIMES, lexer.Lexer.DIV, lexer.Lexer.MOD, lexer.Lexer.EXPONENTIAL]: tmp = self.currtok[1] self.currtok = next(self.tokens) right_tree = self.factor() left_tree = ast.BinaryExpr(left_tree, right_tree, tmp) return left_tree
def get_random_binary_expr(expr_type, lhs, rhs): # FIXME lhs/rhs could be a constant, (expr) etc. Ideally we need an assert # here that makes sure that lhs and rhs type conform with the expr_type. We # might need a get_type() for all asts that can have type (including expr) if expr_type == ast.ExprType.Arith: op_type = get_random_arith_op() return ast.BinaryExpr(lhs, op_type, rhs) if expr_type == ast.ExprType.Logical: op_type = get_random_logical_op() return ast.LogicalExpr(lhs, op_type, rhs) if expr_type == ast.ExprType.Relational: op_type = get_random_relational_op() return ast.RelationalExpr(lhs, op_type, rhs) assert False, "unknown expr type"
def relation(self): """ Relation ⇒ Addition [ RelOp Addition ] :return: """ left_tree = self.addition() # Check if the current token is either a # less than, less than or equal to, greater than, or # greater than or equal to if self.currtok[0] in [lexer.Lexer.LESS, lexer.Lexer.LESSEQ, lexer.Lexer.GREAT, lexer.Lexer.GREATEQ]: tmp = self.currtok[1] self.currtok = next(self.tokens) right_tree = self.addition() left_tree = ast.BinaryExpr(left_tree, right_tree, tmp) return left_tree
def addition(self): """ Addition → Term {AddOp Term} :return: BinaryPlusExpr """ left_tree = self.term() # Run this while the current token is either # a plus or a minus while self.currtok[0] in [lexer.Lexer.PLUS, lexer.Lexer.MINUS]: tmp = self.currtok[1] self.currtok = next(self.tokens) right_tree = self.term() left_tree = ast.BinaryExpr(left_tree, right_tree, tmp) return left_tree
def expression(self): """ Expression ⇒ Conjunction { || Conjunction } """ # Check for a conjunction expression and capture it to create a BinaryExpr object. left = self.conjunction() # Check for '||' until there are no more. while self.currToken[0] == lexer.Lexer.BOOLOR: # Capture the operator to create a BinaryExpr object. operator = self.currToken[0] # Move to the next token. self.currToken = next(self.tokens) # Check for another conjunction expression and capture it to create a BinaryExpr object. right = self.conjunction() # Create a BinaryExpr object. left = ast.BinaryExpr(operator, left, right) # Return the BinaryExpr object. return left
def conjunction(self): """ Conjunction ⇒ Equality { && Equality } """ # Check for an equality expression and capture it to create a BinaryExpr object. left = self.equality() # Check for '&&' until there are no more. while self.currToken[0] == lexer.Lexer.BOOLAND: # Capture the operator to create a BinaryExpr object. operator = self.currToken[0] # Move to the next token. self.currToken = next(self.tokens) # Check for another equality expression and capture it to create a BinaryExpr object. right = self.equality() # Create a BinaryExpr object. left = ast.BinaryExpr(operator, left, right) # Return the BinaryExpr object. return left
def equality(self): """ Equality ⇒ Relation [ EquOp Relation ] """ # Check for a relation expression and capture it to create a BinaryExpr object. left = self.relation() # Check for optional EqOp operators. if self.currToken[0] in (lexer.Lexer.EQ, lexer.Lexer.NOTEQ): # Capture the operator to create a BinaryExpr object. operator = self.currToken[0] # Move to the next token. self.currToken = next(self.tokens) # Check for another relation expression and capture it to create a BinaryExpr object. right = self.relation() # Create a BinaryExpr object. left = ast.BinaryExpr(operator, left, right) # Return the BinaryExpr object. return left
def addition(self): """ Addition ⇒ Term { AddOp Term } """ # Check for a term expression and capture it to create a BinaryExpr object. left = self.term() # Check for addOps operators. while self.currToken[0] in (lexer.Lexer.ADD, lexer.Lexer.SUBTRACT): # Capture the operator to create a BinaryExpr object. operator = self.currToken[0] # Move to the next token. self.currToken = next(self.tokens) # Check for another term expression and capture it to create a BinaryExpr object. right = self.term() # Create a BinaryExpr object. left = ast.BinaryExpr(operator, left, right) # Return the BinaryExpr object. return left
def relation(self): """ Relation ⇒ Addition [ RelOp Addition ] """ # Check for an addition expression and capture it to create a BinaryExpr object. left = self.addition() # Check for optional RelOp operators. if self.currToken[0] in (lexer.Lexer.LESS, lexer.Lexer.LESSEQ, lexer.Lexer.GREAT, lexer.Lexer.GREATEQ): # Capture the operator to create a BinaryExpr object. operator = self.currToken[0] # Move to the next token. self.currToken = next(self.tokens) # Check for another addition expression and capture it to create a BinaryExpr object. right = self.addition() # Create a BinaryExpr object. left = ast.BinaryExpr(operator, left, right) # Return the BinaryExpr object. return left
def term(self): """ Term ⇒ Exponent { MulOp Exponent } """ # Check for an exponent expression and capture it to create a BinaryExpr object. left = self.exponent() # Check for mulOps operators. while self.currToken[0] in (lexer.Lexer.MULTIPLY, lexer.Lexer.DIVIDE, lexer.Lexer.REMAINDER): # Capture the operator to create a BinaryExpr object. operator = self.currToken[0] # Move to the next token. self.currToken = next(self.tokens) # Check for another exponent expression and capture it to create a BinaryExpr object. right = self.exponent() # Create a BinaryExpr object. left = ast.BinaryExpr(operator, left, right) # Return the BinaryExpr object. return left