//Función que se ejecuta al final de mandar llamar la función
public bool solveFunction()
{
//Se elimina la función de la pila de funciones
Function funcion = popFunctionStack();
//Si no existe ningúna función, no se hace nada
if (funcion == null)
{
return(false);
}
//Si la cantidad de parámetros que se escribieron es diferente a la cantidad de parámetros de la función
if (funcion.getSize() != funcArgCount - 1)
{
return(false);
}
//Se genera el cuádruplo goSub
GoSub goSub = new GoSub(funcion);
//Se obtiene la variable donde se guarda el retorno
Variable returnFunctVariable = funcion.getReturnVariable();
//pushSymbolStack(funcion.getReturnVariable());
//Se escribe el cuadruplo del goSub
writeIntermediateCode(goSub);
//Se parsea la variable de retorno
parseVariable(returnFunctVariable);
//Si el tipo de retorno de la función está definido
if (returnFunctVariable != null && returnFunctVariable.getType() != OperationTypes.TYPE_UNDEFINED)
{
//Se genera una variable temporal para que guarde el valor del retorno
Variable returnTempVariable = getTempVar(returnFunctVariable.getType(), returnFunctVariable.isParsed());
//Se crea la asignación para guardar el resultado de la ejecución de la pila
createIntermediateCodeNoTemp(OperationTypes.EQUAL, funcion.getReturnVariable(), returnTempVariable);
//Se hace push a la pila porque se está mandando llamar
pushSymbolStack(returnTempVariable);
}
//Como ya se mandó llamar, se resetea el contador de los argumentos
funcArgCount = 1;
return(true);
}
//Función que se encarga de resolver las multiplicaciónes y divisiónes
public bool solveMultAndDiv()
{
//Si lo que está hasta arriba de la pila de operadores es una multiplicación o división
if (getTopOperatorStack() == OperationTypes.MULTIPLICATION || getTopOperatorStack() == OperationTypes.DIVISION)
{
Variable right_operand = popSymnbolStack(); //Se obtiene el operado derecho
Variable left_operand = popSymnbolStack(); //Se obtiene el operando izquierdo
int operatorValue = popOperatorStack(); //Se obtiene el operador
//Se obtiene el tipo de dato que resulta de aplicar la operación
int resultType = cuboSemantico.getOperationResult(left_operand.getType(), right_operand.getType(), operatorValue);
//Si la operación es válida (que el tipo de dato no sea UNDEFINED)
if (resultType != OperationTypes.TYPE_UNDEFINED)
{
//Se crea su cuádruplo
createIntermediateCode(operatorValue, left_operand, right_operand);
//Se regresa true en señal de éxito
return(true);
}
}
//Si hubo algún error en alguna parte, se regresa false
return(false);
}
//Función que prepara un cuádruplo con solo dos variables, sin crear una variable temporal
public bool createIntermediateCodeNoTemp(int op, Variable var1, Variable var2)
{
if (var1 == null || var2 == null)
{
return(false);
}
//Variable que guarda el resultado de hacer una operación entre dos tipos de dato
parseVariable(var1);
parseVariable(var2);
int resultType = cuboSemantico.semanticCube[var1.getType(), var2.getType(), op];
//Si el resultado es UNDEFINED
if (resultType == OperationTypes.TYPE_UNDEFINED)
{
//Se regresa false en señal de error
return(false);
}
//Objeto de cuádruplo de operación que genera el cuádruplo a escrubur en el archivo de cuádruplos
OperationQuadruple quadruple = new OperationQuadruple();
quadruple.setLineNumber(lineCont); //Se le asigna el número de línea que le pertenece
quadruple.setOperator(op); //Se le asigna el operador que va a utilizar
quadruple.setVariables(var1, var2); //Se le asigna las variables que se utilizan en la operación
//Se manda a escribir en el archivo de cuádruplos
writeIntermediateCode(quadruple);
//Se regresa true como operación exitosa
return(true);
}
//Función que genera el cuádruplo con 3 variables (incluye la variable temporal)
public void createIntermediateCode(int op, Variable var1, Variable var2)
{
if (var1 == null || var2 == null)
{
return;
}
parseVariable(var1);
parseVariable(var2);
//Se obtiene el tipo que guarda la variable temporal. Al ser la variable que va a almacenar el resultado de una
//operación, su tipo de dato es el que resulte de hacer esa operación
int resultType = cuboSemantico.semanticCube[var1.getType(), var2.getType(), op];
Variable tempVar = getTempVar(resultType, true);
//Se le hace push a la pila de símbolos
pushSymbolStack(tempVar);
//Se crea un cádruplo de operación para esta operación
OperationQuadruple quadruple = new OperationQuadruple();
quadruple.setOperator(op); //Se le guarda la operación que va a realizar
quadruple.setVariables(var1, var2, tempVar); //Se guardan las variables involucradas
quadruple.setLineNumber(lineCont); //Se le guarda el número de línea que le corresponde
//Se manda a escribir el cuádruplo al archivo de cuádruplos
writeIntermediateCode(quadruple);
}
//Función que maneja la resolución de operadores relacionales
public bool solveRelOp()
{
//Si lo que está hasta arriba de la pila no es un operador relacional
if (!isRelOp(getTopOperatorStack()))
{
//Se regresa falso en señal de error
return(false);
}
Variable right_operand = popSymnbolStack(); //Se obtiene el operando de la derecha de la pila
Variable left_operand = popSymnbolStack(); //Se obtiene el operadon de la izquierda de la pila
//Se obtiene el operador de la pila
int operatorValue = popOperatorStack();
//Se obtiene el tipo de dato del resultado de hacer la operación
int resultType = cuboSemantico.getOperationResult(left_operand.getType(), right_operand.getType(), operatorValue);
//Si el resultado está definido
if (resultType != OperationTypes.TYPE_UNDEFINED)
{
//Se crea el cuádruplo de esta operación
createIntermediateCode(operatorValue, left_operand, right_operand);
}
else
{
//Si no estaba definida la operación entre los dos tipos de datos, se regresa falso en señal de error
return(false);
}
//Se regresa true en señal de éxito
return(true);
}
//Función que resuelve las sumas y restas
public bool solveSumAndMinus()
{
//Si lo que está hasta arriba de la pila de operadores es una suma o una resta
if (getTopOperatorStack() == OperationTypes.PLUS || getTopOperatorStack() == OperationTypes.MINUS)
{
Variable right_operand = popSymnbolStack(); //Se obtiene el operando derecho
Variable left_operand = popSymnbolStack(); //Se obtiene el operando izquierdo
if (right_operand == null || left_operand == null)
{
return(false);
}
int operatorValue = popOperatorStack(); //Se obtiene el operador
//Se obtierne el tipo de dato de hacer la operación
int resultType = cuboSemantico.getOperationResult(left_operand.getType(), right_operand.getType(), operatorValue);
//Si la operaci{on entre los tipos de datos es válida (que no sea UNDEFINED)
if (resultType != OperationTypes.TYPE_UNDEFINED)
{
//Se crea el cuádruplo de la operación
createIntermediateCode(operatorValue, left_operand, right_operand);
//Se regresa verdadero en señal de éxito
return(true);
}
}
//Si en algún momento falló algo, se regresa falseo en señal de falla
return(false);
}
public void parseVariable(Variable variable)
{
if (variable == null || variable.isParsed())
{
return;
}
//Se obtiene la posición del tipo de dato equivalente del cubo semántico que le dió a la variable el Parser
int posSemCube = cuboSemantico.getCubePosition(variable.getType());
variable.setType(posSemCube); //Se guarda el nuevo valor de su tipo de dato
variable.setParsed(); //Se indica que ya fue parseada esta variable
}
//Función para crear el cuádruplo de RETURN
public bool createReturn(int token)
{
//No puede regresar un valor en una función de tipo de retorno void
if (getTopFunctionStack() != null && getTopFunctionStack().getReturnVariable() == null && token != Parser._Return)
{
return(false);
}
//Se va a regresar lo último que está en el stack de símbolos
Variable returnValue = popSymnbolStack();
Return returnObj;
//Si se está en un return solo (sin regresar variable)
if (token == Parser._Return)
{
//Se crea un Return con nulo
returnObj = new Return(null);
}
//Si no, quiere decir que si se va a regresar el resultado de una EXPR pero no se está en una función
else if (getTopFunctionStack() == null)
{
returnObj = new Return(returnValue);
}
//Si no, quiere decir que si se va a regresar el resultado de una EXPR
else
{
Function funcion = getTopFunctionStack();
Variable returnVariable = funcion.getReturnVariable();
parseVariable(returnVariable);
parseVariable(returnValue);
//Si el tipo de dato que regresa la función es distinto al tipo de datod de lo que se va a sacar
if (returnVariable.getType() != returnValue.getType())
{
return(false);
}
returnObj = new Return(funcion, returnValue);
}
//Se escribe el cuádruplo
writeIntermediateCode(returnObj);
return(true);
}
//Función que agrega un parámetro a la función de la que se está trabajando
public bool setFunctParam()
{
//Se obtiene lo que resulte de resolver del parámetro
Variable parametro = popSymnbolStack();
//Se obtiene la funciónen la que se está trabajando
Function funcion = getTopFunctionStack();
if (funcion == null || parametro == null)
{
return(false);
}
//Se obtiene la variable de parámetro de acuerdo con el parámetro que se esté trabajando
Variable funcParameter = funcion.getParam(funcArgCount);
//Si regresa nulo es que hay un error, ya que no existe tal argumento
if (funcParameter == null)
{
return(false);
}
//para asegurarnos, se parsean las variables para asegurar que se está hablando en los mismos códigos
parseVariable(parametro);
parseVariable(funcParameter);
//Si los tipos de dato de las variables son diferentes igual hay un error
if (parametro.getType() != funcParameter.getType())
{
return(false);
}
//Se gemera el cuádruplo param
Param param = new Param(funcParameter, parametro);
//Se manda a escribir el cuádruplo
writeIntermediateCode(param);
//Se aumenta el contador de argumentos de función
funcArgCount++;
return(true);
}
bool assignGlobalAddress(Variable var)
{
int tempAddress = 0;
if (var.isConstant())
{
switch (var.getType())
{
case Parser._CTE_F:
tempAddress = addressManager.getConstFloatAddress();
break;
case Parser._CTE_I:
tempAddress = addressManager.getConstIntAddress();
break;
case Parser._CTE_S:
tempAddress = addressManager.getConstStringAddress();
break;
default:
var.setAddress(OperationTypes.TYPE_UNDEFINED);
return(false);
}
}
else
{
switch (var.getType())
{
case Parser._CTE_I:
tempAddress = addressManager.getGlobalIntVarAddress();
break;
case Parser._CTE_F:
tempAddress = addressManager.getGlobalFloatVarAddress();
break;
case Parser._CTE_S:
tempAddress = addressManager.getGlobalStringVarAddress();
break;
case Parser._Int:
tempAddress = addressManager.getGlobalIntVarAddress();
break;
case Parser._Float:
tempAddress = addressManager.getGlobalFloatVarAddress();
break;
case Parser._Bool:
tempAddress = addressManager.getGlobalBoolVarAddress();
break;
case Parser._String:
tempAddress = addressManager.getGlobalStringVarAddress();
break;
default:
return(false);
}
}
var.setAddress(tempAddress);
return(true);
}
public bool assignlocalAddress(Variable var)
{
int tempAddress = 0;
if (var.isParsed())
{
switch (var.getType())
{
case OperationTypes.TYPE_BOOL:
tempAddress = addressManager.getBoolAddress();
break;
case OperationTypes.TYPE_FLOAT:
tempAddress = addressManager.getFloatAddress();
break;
case OperationTypes.TYPE_INT:
tempAddress = addressManager.getIntAddress();
break;
case OperationTypes.TYPE_STRING:
tempAddress = addressManager.getStringAddress();
break;
default:
var.setAddress(OperationTypes.TYPE_UNDEFINED);
return(false);
}
}
else
{
switch (var.getType())
{
case Parser._CTE_I:
tempAddress = addressManager.getConstIntAddress();
break;
case Parser._CTE_F:
tempAddress = addressManager.getConstFloatAddress();
break;
case Parser._CTE_S:
tempAddress = addressManager.getConstStringAddress();
break;
case Parser._Int:
tempAddress = addressManager.getIntAddress();
break;
case Parser._Float:
tempAddress = addressManager.getFloatAddress();
break;
case Parser._Bool:
tempAddress = addressManager.getBoolAddress();
break;
case Parser._String:
tempAddress = addressManager.getStringAddress();
break;
default:
var.setAddress(OperationTypes.TYPE_UNDEFINED);
return(false);
}
}
var.setAddress(tempAddress);
return(true);
}
//Función que genera los cuádruplos de la condición del Loop
public bool createLoopCondition(Variable variable)
{
if (variable == null)
{
return(false);
}
Variable varReff;
//Si lo que se recibió es una constante entera
if (variable.getType() == Parser._CTE_I)
{
//Agrega la constante a la tabla de constantes
varReff = varTable.addConstant(variable);
}
else
{
//Si no es constante, es una variable
varReff = varTable.findVariable(variable.getName());
}
//La variable debe de existir
if (varReff == null)
{
return(false);
}
//Variable que guarda la variable que vamos a comparar con cero
Variable varToCompare;
if (varReff.isConstant())
{
//Si se entregó una constante, se genera una variable auxiliar que es la que va a ir decrementándoce hasta llegar a cero
Variable tempVarConstant = new Variable("1LOOP_AUX_VARIABLE", Parser._Int);
//Se agrega esta variable a la tabla de variables
varTable.addVariable(tempVarConstant);
//Se parsea la variable
parseVariable(tempVarConstant);
//Se crea un cuádruplo donde se le asigna el valor de la constante a la variable auxiliar
createIntermediateCodeNoTemp(OperationTypes.EQUAL, varReff, tempVarConstant);
//Ahora sabemos que la variable a comparar es la que tiene el valor asignado de la constante
varToCompare = tempVarConstant;
}
else
{
//Si fue una variable, se obtiene su referencia para que sea comparada en el ciclo
varToCompare = varReff;
}
//Se obtiene la constante 0 para hacer la condición del Loop
Variable constantCero = varTable.addConstant(new Variable("0", Parser._CTE_I, "0"));
//Se hace push al stack de saltos indicando dónde está la comparación
pushJumpStack(lineCont);
//Se crea el cuádruplo <>. Variable, 0, tempX
createIntermediateCode(OperationTypes.DIFFERENT_THAN, varToCompare, constantCero);
//Se hace push al stack de saltos con un goToF por la condición
pushGoToF(popSymnbolStack());
return(true);
}