def _unary(self) -> ex.Expr:
if self._match(TokenType.BANG, TokenType.MINUS):
op = self._previous
right = self._unary()
return ex.Unary(op, right)
if self._match(TokenType.EQUAL):
op = self._previous
self._assignment()
raise self._error(op, "Nothing to assign to.")
if self._match(TokenType.BANG_EQUAL, TokenType.EQUAL_EQUAL):
op = self._previous
self._comparison()
raise self._error(op, 'Not a unary operator.')
if self._match(TokenType.GREATER, TokenType.GREATER_EQUAL,
TokenType.LESS, TokenType.LESS_EQUAL):
op = self._previous
self._term()
raise self._error(op, 'Not a unary operator.')
if self._match(TokenType.PLUS):
op = self._previous
self._factor()
raise self._error(op, "Unary '+' expressions are not supported.")
if self._match(TokenType.SLASH, TokenType.STAR):
op = self._previous
self._unary()
raise self._error(op, 'Not a unary operator.')
return self._call()
def unary(self):
if self.match(TokenType.BANG, TokenType.MINUS):
operator = self.previous()
right = self.unary()
return Expr.Unary(operator, right)
return self.call()
def unary(self):
if self.match(TokenType.BANG, TokenType.MINUS):
op = self.peek(-1)
right = self.unary()
return Expr.Unary(op, right)
if self.match(TokenType.PLUS_PLUS, TokenType.MINUS_MINUS):
return self.crement()
return self.call()
def visit_term18(self, node, ch):
r = ch.pop()
while (len(ch)):
op = ch.pop()
if op == '#/': r = expr.Count(r)
elif op == '&&/':
r = expr.LazyGrouping(op, r, 1, lambda i, x: 1
if i and x else 0)
elif op == '||/':
r = expr.LazyGrouping(op, r, 0, lambda i, x: 1
if i or x else 0)
elif op == '-':
r = expr.Unary(op, r, lambda x: -x)
elif op == '*':
r = expr.Unary(op, r, lambda x: x.dereference())
elif op == '&':
r = expr.Unary(
op, r,
lambda x: x.address or type_error("Not addressable"))
elif op == '!':
r = expr.Unary(op, r, lambda x: gdb.Value(not x))
elif op == '~':
r = expr.Unary(op, r, lambda x: ~x)
elif op == '++':
not_implemented()
elif op == '--':
not_implemented()
else:
r = expr.Unary('(' + op + ')', r, lambda x: x.cast(types[op]))
return r
def visit_parens(self, node, ch):
op, arg = ch[0], ch[1]
if op == '(': return expr.Unary('({})', arg, lambda x: x)
if op == '{': return expr.Curlies(arg)
def unary(self) -> e.Expr:
if self.match(TokenType.BANG, TokenType.MINUS):
operator: Token = self.previous()
right: e.Expr = self.unary()
return e.Unary(operator, right)
return self.call()