def visit_term15(self, node, ch): l = ch.pop(0) while len(ch): op, r = ch.pop(0), ch.pop(0) if op == '<<': l = expr.Binary(l, op, r, lambda x, y: x << y) elif op == '>>': l = expr.Binary(l, op, r, lambda x, y: x >> y) return l
def visit_term16(self, node, ch): l = ch.pop(0) while len(ch): op, r = ch.pop(0), ch.pop(0) if op == '+': l = expr.Binary(l, op, r, lambda x, y: x + y) elif op == '-': l = expr.Binary(l, op, r, lambda x, y: x - y) return l
def visit_term17(self, node, ch): l = ch.pop(0) while len(ch): op, r = ch.pop(0), ch.pop(0) if op == '*': l = expr.Binary(l, op, r, lambda x, y: x * y) elif op == '/': l = expr.Binary(l, op, r, lambda x, y: x / y) elif op == '%': l = expr.Binary(l, op, r, lambda x, y: x % y) return l
def visit_term12(self, node, ch): l = ch.pop(0) while len(ch): op, r = ch.pop(0), ch.pop(0) if op == '==': l = expr.Binary(l, op, r, lambda x, y: gdb.Value(x == y)) elif op == '!=': l = expr.Binary(l, op, r, lambda x, y: gdb.Value(x != y)) elif op == '==?': l = expr.Filter(l, op, r, lambda x, y: gdb.Value(x == y)) elif op == '!=?': l = expr.Filter(l, op, r, lambda x, y: gdb.Value(x != y)) return l
def _equality(self) -> ex.Expr: expr = self._comparison() while self._match(TokenType.BANG_EQUAL, TokenType.EQUAL_EQUAL): op = self._previous right = self._comparison() expr = ex.Binary(expr, op, right) return expr
def _sequence(self) -> ex.Expr: expr = self._assignment() while self._match(TokenType.COMMA): op = self._previous right = self._assignment() expr = ex.Binary(expr, op, right) return expr
def _term(self) -> ex.Expr: expr = self._factor() while self._match(TokenType.MINUS, TokenType.PLUS): op = self._previous right = self._factor() expr = ex.Binary(expr, op, right) return expr
def _factor(self) -> ex.Expr: expr = self._unary() while self._match(TokenType.SLASH, TokenType.STAR): op = self._previous right = self._unary() expr = ex.Binary(expr, op, right) return expr
def multiplication(self): expr = self.unary() while self.match(TokenType.STAR, TokenType.SLASH, TokenType.PERCENT): op = self.peek(-1) right = self.unary() expr = Expr.Binary(expr, op, right) return expr
def equality(self): expr = self.comparison() while self.match(TokenType.BANG_EQUAL, TokenType.EQUAL_EQUAL): op = self.peek(-1) right = self.comparison() expr = Expr.Binary(expr, op, right) return expr
def visit_term7(self, node, ch): l = ch.pop(0) while len(ch): op, r = ch.pop(0), ch.pop(0) if op == '||': l = expr.Binary(l, op, r, lambda x, y: 1 if x or y else 0) return l
def addition(self): expr = self.multiplication() while self.match(TokenType.PLUS, TokenType.MINUS): op = self.peek(-1) right = self.multiplication() expr = Expr.Binary(expr, op, right) return expr
def comparison(self): expr = self.addition() while self.match(TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL): op = self.peek(-1) right = self.addition() expr = Expr.Binary(expr, op, right) return expr
def addition(self): expr = self.multiplication() while self.match(TokenType.MINUS, TokenType.PLUS): operator = self.previous() right = self.multiplication() expr = Expr.Binary(expr, operator, right) return expr
def _comparison(self) -> ex.Expr: expr = self._term() while self._match(TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL): op = self._previous right = self._term() expr = ex.Binary(expr, op, right) return expr
def multiplication(self): expr = self.unary() while self.match(TokenType.SLASH, TokenType.STAR): operator = self.previous() right = self.unary() expr = Expr.Binary(expr, operator, right) return expr
def equality(self): expr = self.comparison() while self.match(TokenType.BANG_EQUAL, TokenType.EQUAL_EQUAL): operator = self.previous() right = self.comparison() expr = Expr.Binary(expr, operator, right) return expr
def factor(self) -> e.Expr: # anything of higher precedence is returned without executing loop expr: e.Expr = self.unary() while self.match(TokenType.STAR, TokenType.SLASH): operator: Token = self.previous() right: e.Expr = self.unary() expr = e.Binary(expr, operator, right) return expr
def equality(self) -> e.Expr: # anything of higher precedence is returned without executing loop expr: e.Expr = self.comparison() while self.match(TokenType.BANG_EQUAL, TokenType.EQUAL_EQUAL): operator: Token = self.previous() right: e.Expr = self.comparison() expr = e.Binary(expr, operator, right) return expr
def term(self) -> e.Expr: # anything of higher precedence is returned without executing loop expr: e.Expr = self.factor() while self.match(TokenType.MINUS, TokenType.PLUS): operator: Token = self.previous() right: e.Expr = self.factor() expr = e.Binary(expr, operator, right) return expr
def comparison(self): expr = self.addition() while self.match(TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL): operator = self.previous() right = self.addition() expr = Expr.Binary(expr, operator, right) return expr
def visit_term13(self, node, ch): l = ch.pop(0) while len(ch): op, r = ch.pop(0), ch.pop(0) if op == '<': l = expr.Binary(l, op, r, lambda x, y: gdb.Value(x < y)) elif op == '>': l = expr.Binary(l, op, r, lambda x, y: gdb.Value(x > y)) elif op == '<=': l = expr.Binary(l, op, r, lambda x, y: gdb.Value(x <= y)) elif op == '>=': l = expr.Binary(l, op, r, lambda x, y: gdb.Value(x >= y)) elif op == '<?': l = expr.Filter(l, op, r, lambda x, y: gdb.Value(x < y)) elif op == '>?': l = expr.Filter(l, op, r, lambda x, y: gdb.Value(x > y)) elif op == '<=?': l = expr.Filter(l, op, r, lambda x, y: gdb.Value(x <= y)) elif op == '>=?': l = expr.Filter(l, op, r, lambda x, y: gdb.Value(x >= y)) return l
def crement(self): isAdding = False if self.peek(-1).type == TokenType.PLUS_PLUS: isAdding = True identifier = self.peek(-2) if isAdding: tok = TokenType.PLUS else: tok = TokenType.MINUS val = 1 return Expr.Assignment( Expr.Variable(identifier).name, Expr.Binary(Expr.Variable(identifier), Token(tok, None, None, None), Expr.Literal(val)))
def comparison(self) -> e.Expr: # TODO: you could create a helper method for parsing a left-associative # series of binary operators given a list of token types and an operand # method handle to simplify this redundant code. expr: e.Expr = self.term() while self.match( TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL, ): operator: Token = self.previous() right: e.Expr = self.term() expr = e.Binary(expr, operator, right) return expr
def visit_term19(self, node, ch): l = ch.pop(0) while len(ch): op, r = ch.pop(0), ch.pop(0) if op == '[': l, _ = expr.Binary(l, '{}[{}]', r, lambda x, y: x[int(y)]), ch.pop(0) elif op == '.': l = expr.Struct(l, '{}.{}', r) elif op == '->': l = expr.Struct(l, '{}->{}', r) elif op == '-->': l = expr.StructWalk(l, r) elif op == '[[': l, _ = expr.TakeNth(l, r), ch.pop(0) elif op == '@': l = expr.Until(l, r) return l
def assignment(self): left = self.ternary() if self.match(TokenType.EQUAL): equals = self.peek(-1) value = self.assignment() if isinstance(left, Expr.Variable): return Expr.Assignment(left.name, value) self.error(equals, "Invalid assignment target.") elif self.match(TokenType.PLUS_EQUAL, TokenType.MINUS_EQUAL): tok = TokenType.MINUS if self.peek(-1).type == TokenType.PLUS_EQUAL: tok = TokenType.PLUS identifier = self.peek(-2) val = self.expression() return Expr.Assignment( Expr.Variable(identifier).name, Expr.Binary(Expr.Variable(identifier), Token(tok, None, None, None), val)) return left
def visit_term9(self, node, ch): l = ch.pop(0) while len(ch): op, r = ch.pop(0), ch.pop(0) if op == '|': l = expr.Binary(l, op, r, lambda x, y: x | y) return l