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
