def p_ver_quadruples(p):
'ver_quadruples : epsilon'
arrIndex = stackOP.pop() # el indice del arreglo
arrIndexType = stackType.pop() # el tipo del indice del arreglo
if arrIndexType != 'int':
print("ERROR: Array index must be an Integer at line:" +
str(p.lexer.lineno))
quit()
arrIndexBase = stackOP.pop() # la base que se sumara
arrType = stackType.pop() # el tipo del arreglo
arrId = VCsemantics.getArrName(arrIndexBase)
arrK, lim_inf, lim_sup = VCsemantics.validateArrIdScope(
arrId, str(p.lexer.lineno))
tempo = VCmemory.getTempIndex(
arrType) # ayuda a conseguir el index de la temporal
quadruples.append(['ver', arrIndex, lim_inf, lim_sup])
quadruples.append(['+-k', arrIndex, arrK, tempo])
newTempo = VCmemory.getTempIndex(
arrType) # al sumarle la base se guarda en nueva temporal
quadruples.append(['+base', tempo, arrIndexBase, newTempo])
stackOP.append('(' + str(newTempo) + ')')
stackType.append(arrType)
def p_check_symbol_term(p):
'check_symbol_term : epsilon'
if stackSymbol: # Si el stack no esta vacio
if stackSymbol[-1] == '*' or stackSymbol[-1] == '/':
right_op = stackOP.pop()
right_type = stackType.pop()
left_op = stackOP.pop()
left_type = stackType.pop()
operator = stackSymbol.pop()
typeResult = VCsemantics.validateSemanticCube(
operator, left_type, right_type
) # si al sumar dos enteros se regresa un entero typeresult es = 'int'
tempo = VCmemory.getTempIndex(typeResult)
if typeResult != 'error': # si sumas un entero con un string typeresult seria = a 'error'
quadruples.append([operator, left_op, right_op, tempo])
stackOP.append(tempo)
stackType.append(typeResult)
else:
print("Type mismatch error at line " + str(p.lexer.lineno))
quit()
def p_create_gosub(p):
'create_gosub : epsilon'
global param_counter, functionIndex_onCall
functionName = VCsemantics.getFunctionName(functionIndex_onCall)
functionQuadrupleStart = VCsemantics.getFunctionQuadrupleStart(
functionIndex_onCall)
functionParamas = VCsemantics.returnFunctionParamNumbers(
functionIndex_onCall)
functionType = VCsemantics.getFunctionType(functionIndex_onCall)
if param_counter != functionParamas:
print('TypeError: validateFunctionParams() at line ',
str(p.lexer.lineno))
quit()
else:
quadruples.append(['gosub', functionName, '', functionQuadrupleStart])
if functionType != 'void':
tempo = VCmemory.getTempIndex(functionType)
quadruples.append(['=r', functionName, '', tempo])
stackOP.append(tempo)
stackType.append(functionType)
#resetear las variables globales
param_counter = 0
functionIndex_onCall = 0
def p_incrementByOne(p):
'incrementByOne : epsilon'
left_op = stackOP.pop()
left_type = stackType.pop()
typeResult = VCsemantics.validateSemanticCube(
p[-1], left_type, 'int') # asumimos que 1 = 'int'
if typeResult != 'error':
cteValue, cteType, cteIndexMem = VCsemantics.push_cte_toTable(
1, str(p.lexer.lineno)) # get index of cte 1
tempo = VCmemory.getTempIndex(
typeResult
) # nos ayuda a conseguir el index de los temporales dependiendo del tipo
quadruples.append([p[-1], left_op, cteIndexMem, tempo])
quadruples.append(['=', tempo, '', left_op])
else:
print("Type mismatch error at line " + str(p.lexer.lineno))
quit()
def p_increment_equals(p):
'increment_equals : epsilon'
right_op = stackOP.pop()
right_type = stackType.pop()
left_op = stackOP.pop()
left_type = stackType.pop()
operator = stackSymbol.pop()
if operator == '+=':
operator = '+'
else:
operator = '-'
typeResult = VCsemantics.validateSemanticCube(operator, left_type,
right_type)
if typeResult != 'error':
tempo = VCmemory.getTempIndex(typeResult)
quadruples.append([operator, left_op, right_op, tempo])
quadruples.append(['=', tempo, ' ', left_op])
def p_push_end_quadruple(p):
'push_end_quadruple : epsilon'
VCmemory.getContextTypeQty() # agrega el contedo de variables del main
VCmemory.getTempsTypeQty() # agrega el conteo de temps del main
quadruples.append(['END', '', '',
'']) # cuadruplo que dice cuando acaba el programa