def p_expression_math_operations(self, parse):
"""
expression : expression PLUS expression
| expression MINUS expression
| expression MULTIPLY expression
| expression DIVIDE expression
"""
if parse[2] == '+':
parse[0] = AST.Sum(summand1=parse[1],
summand2=parse[3],
line=parse.lineno(2),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(2)))
elif parse[2] == '-':
parse[0] = AST.Sub(minuend=parse[1],
subtrahend=parse[3],
line=parse.lineno(2),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(2)))
elif parse[2] == '*':
parse[0] = AST.Mult(factor1=parse[1],
factor2=parse[3],
line=parse.lineno(2),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(2)))
elif parse[2] == '/':
parse[0] = AST.Div(dividend=parse[1],
divisor=parse[3],
line=parse.lineno(2),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(2)))
def p_expression_math_comparisons(self, parse):
"""
expression : expression LT expression
| expression LTEQ expression
| expression EQ expression
"""
if parse[2] == '<':
parse[0] = AST.LessThan(left=parse[1],
right=parse[3],
line=parse.lineno(2),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(2)))
elif parse[2] == '<=':
parse[0] = AST.LessOrEqualThan(left=parse[1],
right=parse[3],
line=parse.lineno(2),
column=lexer.find_column(
parse.lexer.lexdata,
parse.lexpos(2)))
elif parse[2] == '=':
parse[0] = AST.Equals(left=parse[1],
right=parse[3],
line=parse.lineno(2),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(2)))
def p_expression_self_dispatch(self, parse):
"""
expression : ID LPAREN arguments_list_opt RPAREN
"""
parse[0] = AST.DynamicCall(instance=AST.Identifier(
'self',
line=parse.lineno(1),
column=lexer.find_column(parse.lexer.lexdata, parse.lexpos(1))),
method=parse[1],
args=parse[3],
line=parse.lineno(1),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(1)))
def p_Operacion_binaria(p):
''' Operacion_binaria : Operacion_binaria PLUS Operacion_binaria
| Operacion_binaria MINUS Operacion_binaria
| Operacion_binaria TIMES Operacion_binaria
| Operacion_binaria DIVIDE Operacion_binaria
| Operacion_binaria MOD Operacion_binaria
| Operacion_binaria AND Operacion_binaria
| Operacion_binaria OR Operacion_binaria
| Operacion_binaria EQEQ Operacion_binaria
| Operacion_binaria NEQEQ Operacion_binaria
| Operacion_binaria GREAT Operacion_binaria
| Operacion_binaria GREATEQ Operacion_binaria
| Operacion_binaria LESS Operacion_binaria
| Operacion_binaria LESSEQ Operacion_binaria
| Operacion_binaria IN Operacion_binaria
| Operacion_binaria RANGE Operacion_binaria
| Operacion_binaria INTERSECTION Operacion_binaria
| NOT Operacion_binaria
| NUMBER
| VAR_IDENTIFIER
| LPAREN Operacion_binaria RPAREN
| RTOI LPAREN Operacion_binaria RPAREN
| LENGTH LPAREN Operacion_binaria RPAREN
| TOP LPAREN Operacion_binaria RPAREN
| BOTTOM LPAREN Operacion_binaria RPAREN
| MINUS Operacion_binaria %prec UMINUS
| TRUE
| FALSE
'''
global error
if len(p)>=5:
p[0] = Operacion(InstFuncion(p[1],p[3]))
elif len(p)>=4:
if p[1]=='(':
p[0]=p[2]
else:
p[0] = Operacion(p[1],p[2],p[3])
elif len(p)>=3:
p[0] = Operacion(p[2],p[1])
else:
p[0] = Operacion(p[1])
col = find_column(p.slice[1].lexer.lexdata,p.slice[1])+1
#print 'machete ' + str(p.slice[1])
p[0].setPosition(p.lineno(1),col)
# Verificacion de si la variable fue declarada o no
if p[1] != 'true' and p[1] != 'false' and type(p[1]) != int:
retorno = fueDeclarada(p[1])
if retorno is None:
col = find_column(p.slice[1].lexer.lexdata,p.slice[1])
print 'Error: Linea '+str(p.lineno(1))+', columna '+str(col)+': Variable "'+str(p[1])+'" no declarada'
error = 1
def p_error(p):
print "Error de sintaxis en la linea",
print p.lineno -1 ,
print ", columna: " + str(find_column(p.lexer.lexdata,p)),
print ": token inesperado:",
print p.value
yacc.restart()
def p_Inst_Lectura(p):
'''Inst_Lectura : INST_READ VAR_IDENTIFIER '''
p[0] = Lectura(p[2])
global listaTablas
global error
check = 0
retorno = fueDeclarada(p[2])
if retorno is None:
col = find_column(p.slice[2].lexer.lexdata,p.slice[2])
print 'Error: Linea '+str(p.lineno(2))+', columna '+ str(col)+': Variable "'+p[2]+'" no declarada'
error = 1
elif retorno.blocked:
col = find_column(p.slice[1].lexer.lexdata,p.slice[1])
print 'Error: Linea '+str(p.lineno(2))+', columna '+ str(col)+': Variable "'+p[2]+'"',
print 'es el indice de un bloque FOR, y no puede modificarse'
error = 1
def p_expression_integer_constant(self, parse):
"""
expression : INTEGER
"""
parse[0] = AST.INTEGER(value=parse[1],
line=parse.lineno(1),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(1)))
def p_expression_object_identifier(self, parse):
"""
expression : ID
"""
parse[0] = AST.Identifier(name=parse[1],
line=parse.lineno(1),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(1)))
def p_expression_boolean_complement(self, parse):
"""
expression : NOT expression
"""
parse[0] = AST.Not(parse[2],
line=parse.lineno(1),
column=lexer.find_column(parse.lexer.lexdata,
parse.lexpos(1)))
def p_expression_string_constant(self, parse):
"""
expression : STRING
"""
parse[0] = AST.STRING(value=parse[1],
line=parse.lineno(1),
column=lexer.find_column(parse.lexer.lexdata,
parse.lexpos(1)))
def p_expression_block(self, parse):
"""
expression : LBRACE block_list RBRACE
"""
parse[0] = AST.Block(exprs=parse[2],
line=parse.lineno(1),
column=lexer.find_column(parse.lexer.lexdata,
parse.lexpos(1)))
def p_expression_new(self, parse):
"""
expression : NEW TYPE
"""
parse[0] = AST.NewType(parse[2],
line=parse.lineno(2),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(2)))
def p_expression_isvoid(self, parse):
"""
expression : ISVOID expression
"""
parse[0] = AST.IsVoid(parse[2],
line=parse.lineno(2),
column=lexer.find_column(parse.lexer.lexdata,
parse.lexpos(2)))
def p_expression_integer_complement(self, parse):
"""
expression : INT_COMP expression
"""
parse[0] = AST.LogicalNot(parse[2],
line=parse.lineno(1),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(1)))
def p_expression_while_loop(self, parse):
"""
expression : WHILE expression LOOP expression POOL
"""
parse[0] = AST.While(predicate=parse[2],
body=parse[4],
line=parse.lineno(1),
column=lexer.find_column(parse.lexer.lexdata,
parse.lexpos(1)))
def p_feature_attr(self, parse):
"""
attribute_def : ID COLON TYPE
"""
parse[0] = AST.AttributeDef(name=parse[1],
Type=parse[3],
line=parse.lineno(1),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(1)))
def p_expression_boolean_constant(self, parse):
"""
expression : TRUE
| FALSE
"""
parse[0] = AST.Boolean(value=parse[1],
line=parse.lineno(1),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(1)))
def p_expression_let_simple(self, parse):
"""
let_expression : LET nested_vars IN expression
"""
parse[0] = AST.Let(var_list=parse[2],
body=parse[4],
line=parse.lineno(2),
column=lexer.find_column(parse.lexer.lexdata,
parse.lexpos(2)))
def p_expression_assignment(self, parse):
"""
expression : ID ASSIGN expression
"""
parse[0] = AST.AssignExpr(instance=parse[1],
expr=parse[3],
line=parse.lineno(1),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(1)))
def p_expression_case(self, parse):
"""
expression : CASE expression OF actions_list ESAC
"""
parse[0] = AST.Case(expr=parse[2],
actions=parse[4],
line=parse.lineno(1),
column=lexer.find_column(parse.lexer.lexdata,
parse.lexpos(1)))
def p_let_var_def(self, parse):
"""
let_var_def : ID COLON TYPE
"""
parse[0] = AST.LetVarDef(name=parse[1],
Type=parse[3],
line=parse.lineno(1),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(1)))
def p_error(symbol):
if symbol:
text = symbol.lexer.lexdata
message = "ERROR: Syntax error at line %d, column %d: "
message += "Unexpected token '%s'"
data = (symbol.lineno, find_column(text, symbol), symbol.value)
parser_error.append(message % data)
else:
parser_error.append("ERROR: Syntax error at EOF")
def p_error(symbol):
if symbol:
text = symbol.lexer.lexdata
message = "ERROR: Syntax error at line %d, column %d: "
message += "Unexpected token '%s'"
data = (symbol.lineno, find_column(text, symbol), symbol.value)
parser_error.append(message % data)
else:
parser_error.append("ERROR: Syntax error at EOF")
def p_error(symbol):
if symbol:
code = symbol.lexer.lexdata
errorString = 'Error: se encontro un caracter inesperado {0}' .format(symbol.value)
errorString += '(Línea {0}, Columna {1})'.format(symbol.lineno, find_column(code,symbol))
parser_errorList.append(errorString)
else:
parser_errorList.append('Error: error de sintaxis al final del archivo.')
def p_expression_if_conditional(self, parse):
"""
expression : IF expression THEN expression ELSE expression FI
"""
parse[0] = AST.If(predicate=parse[2],
then_body=parse[4],
else_body=parse[6],
line=parse.lineno(1),
column=lexer.find_column(parse.lexer.lexdata,
parse.lexpos(1)))
def p_class_inherits(self, parse):
"""
class : CLASS TYPE INHERITS TYPE LBRACE features_list_opt RBRACE
"""
parse[0] = AST.Class(name=parse[2],
parent=parse[4],
features=parse[6],
line=parse.lineno(2),
column=lexer.find_column(parse.lexer.lexdata,
parse.lexpos(4)))
def p_formal_param(self, parse):
"""
formal_param : ID COLON TYPE
"""
parse[0] = AST.FormalParameter(name=parse[1],
param_type=parse[3],
line=parse.lineno(1),
column=lexer.find_column(
parse.lexer.lexdata,
parse.lexpos(1)))
def p_expression_dispatch(self, parse):
"""
expression : expression DOT ID LPAREN arguments_list_opt RPAREN
"""
parse[0] = AST.DynamicCall(instance=parse[1],
method=parse[3],
args=parse[5],
line=parse.lineno(3),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(3)))
def p_class(self, parse):
"""
class : CLASS TYPE LBRACE features_list_opt RBRACE
"""
parse[0] = AST.Class(name=parse[2],
parent="Object",
features=parse[4],
line=parse.lineno(2),
column=lexer.find_column(parse.lexer.lexdata,
parse.lexpos(2)))
def p_action_expr(self, parse):
"""
action : ID COLON TYPE ARROW expression SEMICOLON
"""
parse[0] = AST.Action(name=parse[1],
action_type=parse[3],
body=parse[5],
line=parse.lineno(1),
column=lexer.find_column(parse.lexer.lexdata,
parse.lexpos(1)))
def p_feature_method(self, parse):
"""
feature : ID LPAREN formal_params_list RPAREN COLON TYPE LBRACE expression RBRACE
"""
parse[0] = AST.ClassMethod(name=parse[1],
params=parse[3],
return_type=parse[6],
expr=parse[8],
line=parse.lineno(1),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(1)))
def p_Lista_Variables(p):
'''Lista_Variables : VAR_IDENTIFIER
| VAR_IDENTIFIER COMMA Lista_Variables '''
insercion = SymTable.variable(p[1],'')
insercion.setLine(p.lineno(1))
insercion.setColumn(find_column(p.slice[1].lexer.lexdata,p.slice[1]))
if(len(p)>=3):
p[3].lista.insert(0,insercion)
p[0] = listaVariables( p[3].lista)
else:
p[0] = listaVariables([insercion])
def p_feature_method_no_formals(self, parse):
"""
feature : ID LPAREN RPAREN COLON TYPE LBRACE expression RBRACE
"""
parse[0] = AST.ClassMethod(name=parse[1],
params=tuple(),
return_type=parse[5],
expr=parse[7],
line=parse.lineno(1),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(1)))
def p_expression_static_dispatch(self, parse):
"""
expression : expression AT TYPE DOT ID LPAREN arguments_list_opt RPAREN
"""
parse[0] = AST.StaticCall(instance=parse[1],
static_type=parse[3],
method=parse[5],
args=parse[7],
line=parse.lineno(5),
column=lexer.find_column(
parse.lexer.lexdata, parse.lexpos(5)))
def p_error(symbol):
if symbol:
code = symbol.lexer.lexdata
errorString = 'Error: se encontro un caracter inesperado {0}'.format(
symbol.value)
errorString += '(Línea {0}, Columna {1})'.format(
symbol.lineno, find_column(code, symbol))
parser_errorList.append(errorString)
else:
parser_errorList.append(
'Error: error de sintaxis al final del archivo.')
def p_error(self, parse):
"""
Error rule for Syntax Errors handling and reporting.
"""
if not parse:
error = ErrorParser('"EOF"', 0, 0)
self.errors.append(error)
return
message = f'"{parse.value}"'
error = ErrorParser(
message, parse.lineno,
lexer.find_column(parse.lexer.lexdata, parse.lexpos))
self.errors.append(error)
self.parser.errok()
def p_Inst_Asignacion(p):
'''Inst_Asignacion : VAR_IDENTIFIER EQUAL Expresion'''
p[0] = Asignacion(p[1],p[3])
global error
# Verifico que la variable a asignar haya sido declarada,
# y si su tipo coincide con el tipo de la expresion
existente = fueDeclarada(p[1])
col = find_column(p.slice[1].lexer.lexdata,p.slice[1])
if existente is None:
print '''Error: Linea %d, columna %d: Variable "%s" no declarada''' % (p.lineno(1),col,p[1])
error = 1
else:
if existente.blocked == 1:
print '''Error: Linea %d, columna %d: Variable "%s" es el indice de un bloque FOR, y no puede modificarse'''% (p.lineno(1),col,p[1])
error = 1
elif existente.type != p[3].tipo and p[3].tipo != 'None':
error = 1
print 'Error: Linea '+str(p.lineno(1))+', columna ' + str(col) + ':',
print 'A la variable "'+p[1]+'"',
print 'de tipo "' + existente.type + '" no se le puede asignar',
print 'una expresion de tipo "' + p[3].tipo + '"'
elif p[3].tipo == 'None':
error = 1
