aboutsummaryrefslogtreecommitdiff
path: root/compilador/parse/expr.py
diff options
context:
space:
mode:
Diffstat (limited to 'compilador/parse/expr.py')
-rw-r--r--compilador/parse/expr.py255
1 files changed, 250 insertions, 5 deletions
diff --git a/compilador/parse/expr.py b/compilador/parse/expr.py
index 23b1a61..492b4e6 100644
--- a/compilador/parse/expr.py
+++ b/compilador/parse/expr.py
@@ -1,12 +1,257 @@
+from typing import NoReturn, Optional, cast
+
+from tabla import Token, LexToken
from parse.base import BaseParser
+from parse.ident import ParseIdent
from errors import Error
-from astree.expr import Expr
+from astree.expr import Expr, BinarithmOp, ConstantExpr, NumberConstant, CallExpr, PrintExpr, BinarithmExpr, CompoundExpr, ReadExpr, AccessExpr, AssignExpr
class ParseExpr:
def __init__(self, parser: BaseParser):
self.parser = parser
- def expr(self) -> Expr | Error:
- self.parser.iterador.next()
- return
-
+ def expr(self) -> (Expr | Error):
+ obj = self.binarithm(None, 0)
+
+ # =
+ tok = self.parser._try(Token.EQUAL)
+ if not tok:
+ return obj
+
+ error = self.parser.synassert(
+ isinstance(obj, AccessExpr),
+ "Se esperaba un objeto como destino de la asignación.")
+ if type(error) is Error:
+ return error
+
+ # Expresión
+ expr = self.expr()
+ if type(expr) is Error:
+ return expr
+
+ return AssignExpr(_object = obj,
+ value = expr)
+
+ # WIP
+ def binarithm(self, lvalue: Expr, i: int) -> (Expr | Error):
+ print(f'binarithm({lvalue}, {i})')
+ _lvalue = lvalue
+ if not lvalue:
+ _lvalue = self.cast(lvalue)
+ if type(_lvalue) is Error:
+ return _lvalue
+ print(f'lvalue = {_lvalue}')
+
+ tok = self.parser.lex()
+ print(f'tok = {tok}')
+ j: int = self.precedence(tok.tipo)
+ while j >= i:
+ op = self.binop_for_tok(tok.tipo)
+
+ rvalue = self.cast(_lvalue)
+ if type(rvalue) is Error:
+ return rvalue
+
+ tok = self.parser.lex()
+ k: int = self.precedence(tok.tipo)
+ while k > j:
+ self.parser.unlex()
+ rvalue = self.binarithm(rvalue, k)
+ if type(rvalue) is Error:
+ return rvalue
+ tok = self.parser.lex()
+
+ k = self.precedence(tok.tipo)
+
+ _lvalue = BinarithmExpr(op = op,
+ lvalue = _lvalue,
+ rvalue = rvalue)
+
+ j = self.precedence(tok.tipo)
+
+ self.parser.unlex()
+ return _lvalue
+
+ def call(self, lvalue: Expr) -> (Expr | Error):
+ args: List[Expr] = []
+
+ while not self.parser._try(Token.R_PAREN):
+ # Expresión
+ expr = self.expr()
+ if type(expr) is Error:
+ return epr
+
+ args.append(expr)
+
+ # ,
+ if self.parser._try(Token.COMMA):
+ continue
+
+ # )
+ if self.parser._try(Token.R_PAREN):
+ break
+
+ return CallExpr(lvalue = lvalue,
+ args = args)
+
+ def compound_expr(self) -> (Expr | Error):
+ items: List[Expr] = []
+
+ # {
+ lbracket = self.parser.want(Token.L_BRACKET)
+ if type(lbracket) is Error:
+ return lbracket
+
+ while True:
+ # }
+ item = self.parser.peek(Token.R_BRACKET)
+ if item: break
+
+ item = self.expr()
+ if type(item) is Error:
+ return item
+
+ items.append(item)
+
+ # ;
+ semicolon = self.parser.want(Token.SEMICOLON)
+ if type(semicolon) is Error:
+ return semicolon
+
+ # }
+ rbracket = self.parser.want(Token.R_BRACKET)
+ if type(rbracket) is Error:
+ return rbracket
+
+ return CompoundExpr(exprs = items)
+
+ def builtin(self) -> (Expr | Error):
+ tok: LexToken = self.parser.peek(Token.PRINT, Token.READ)
+ if not tok:
+ return self.postfix(None)
+
+ if tok.tipo == Token.PRINT:
+ return self.print_expr()
+ elif tok.tipo == Token.READ:
+ return self.read_expr()
+
+
+ def postfix(self, lvalue: Optional[Expr]) -> (Expr | Error):
+ _lvalue: Optional[Expr] = lvalue
+ if not lvalue:
+ _lvalue = self.plain_expression()
+ if type(_lvalue) == Error:
+ return _lvalue
+
+ tok: LexToken = self.parser._try(Token.L_PAREN)
+ if not tok:
+ return _lvalue
+
+ _next: Optional[LexToken] = None
+ if tok == Token.L_PAREN:
+ return self.call(_lvalue)
+
+ return self.postfix(_next)
+
+ def print_expr(self) -> (Expr | Error):
+ _print = self.parser.want(Token.PRINT)
+ if type(_print) is Error:
+ return _print
+
+ lparen = self.parser.want(Token.L_PAREN)
+ if type(lparen) is Error:
+ return lparen
+
+ expr = self.expr()
+ if type(expr) is Error:
+ return expr
+
+ rparen = self.parser.want(Token.R_PAREN)
+ if type(rparen) is Error:
+ return rparen
+
+ return PrintExpr(expr = expr)
+
+ def read_expr(self) -> (Expr | Error):
+ _read = self.parser.want(Token.READ)
+ if type(_read) is Error:
+ return _read
+
+ ident = ParseIdent(self.parser).ident()
+ if type(ident) is Error:
+ return ident
+
+ return ReadExpr(expr = ident)
+
+ # WIP
+ def cast(self, lvalue: Optional[Expr]) -> (Expr | Error):
+ return self.unarithm()
+
+ # WIP
+ def constant(self) -> (Expr | Error):
+ tok: LexToken = self.parser.lex()
+ expr: Optional[ConstantExpr] = None
+ if tok.tipo == Token.STRING_LIT:
+ expr: str = tok.valor
+ elif tok.tipo == Token.INT_LIT:
+ expr = NumberConstant(value = tok.valor)
+ elif tok.tipo == Token.BOOLEAN_LIT:
+ expr: bool = tok.valor
+ else:
+ return Error(msg = "Se esperaba una constante.", numlinea = tok.numlinea)
+ return expr
+
+ # WIP
+ def plain_expression(self) -> (Expr | Error):
+ tok: LexToken = self.parser.peek()
+ if tok.tipo in [Token.BOOLEAN_LIT, Token.CHAR_LIT, Token.INT_LIT, Token.STRING_LIT]:
+ return self.constant()
+ elif tok.tipo == Token.L_PAREN:
+ lparen = self.parser.want(Token.L_PAREN)
+ if type(lparen) is Error:
+ return lparen
+ expr = self.expr()
+ if type(expr) is Error:
+ return expr
+ rparen = self.parser.want(Token.R_PAREN)
+ if type(rparen) is Error:
+ return rparen
+ elif tok.tipo == Token.IDENT:
+ ident = ParseIdent(self.parser).ident()
+ if type(ident) is Error:
+ return ident
+ return ident
+
+ def unarithm(self) -> (Expr | Error):
+ return self.builtin()
+
+ def binop_for_tok(self, tok: Token) -> (BinarithmOp | NoReturn):
+ if tok is Token.SLASH:
+ return BinarithmOp.DIV
+ elif tok is Token.GT:
+ return BinarithmOp.GT
+ elif tok is Token.GEQ:
+ return BinarithmOp.GTEQ
+ elif tok is Token.EQEQ:
+ return BinarithmOp.LEQUAL
+ elif tok is Token.LT:
+ return BinarithmOp.LESS
+ elif tok is Token.LEQ:
+ return BinarithmOp.LESSEQ
+ elif tok is Token.MINUS:
+ return BinarithmOp.MINUS
+ elif tok is Token.NOTEQ:
+ return BinarithmOp.NEQUAL
+ elif tok is Token.PLUS:
+ return BinarithmOp.PLUS
+ elif tok is Token.TIMES:
+ return BinarithmOp.TIMES
+
+ def precedence(self, tok: Token) -> int:
+ if tok in [Token.EQEQ, Token.NOTEQ]:
+ return 0
+ elif tok in [Token.PLUS, Token.MINUS]:
+ return 1
+ elif tok in [Token.TIMES, Token.SLASH]:
+ return 2
+ return -1