public Variable addParamToFunction(Variable param)
{
//Variable auxiliar para saber si se encuentra o no en la tabla de variables local
Variable auxParam = findVariableInLastScope(param.getName());
//Se tuvo que regresar un null si es que esa variable no existe
if (auxParam != null)
{
parser.ErrorHandler.SemErr("ERROR: Several declarations of " + param.getName());
//Se regresa nulo en señal de error.
return(null);
}
//Se agrega a la tabla de variables
addVariable(param);
codeGenerator.parseVariable(param);
//assignlocalAddress(param);
//Se agrega a la lista de parámetros de la función
actualFunction.addParam(param);
//Se regresa la variable
return(param);
}
public void addGlobalVariable(Variable variable)
{
//Si la pila de variables está vacía
if (variableStack.Count == 0)
{
//Se crea una nueva capa a la tabla de variables
addVariableLayer(variable);
assignGlobalAddress(variable);
//Se termina la ejecución
return;
}
Dictionary <string, Variable> lastVariable = getTopVariableStack();;
foreach (Dictionary <string, Variable> i in variableStack)
{
lastVariable = i;
}
//Se intenta agregar la variable en el diccionario
try {
lastVariable.Add(variable.getName(), variable);
assignGlobalAddress(variable);
}
catch (ArgumentException) {
//En caso de que no se pueda, quiere decir que esa variable ya está declarada, por lo que se manda el error.
parser.ErrorHandler.SemErr("Several declarations of " + variable.getName());
}
}
//Función que agrega constantes a la tabla de constantes
public Variable addConstant(Variable constante)
{
try {
//Se agrega la constante al diccionario de constantes
constantsDiccionary.Add(constante.getName(), constante);
//Se asigna al objeto que es una constante
constante.setConstant();
//Se le asigna una dirección constante
assignGlobalAddress(constante);
//Se le asigna el valor de la constante
constante.setValue(constante.getName());
//Genera un cu{adruplo de asignación para que guarde el valor de la constante en memoria
codeGenerator.createConstant(constante);
}
catch (ArgumentException) {
//Si hubo un error (la constante ya estaba ahí) se regresa el objeto de constante
return(constantsDiccionary[constante.getName()]);
}
//Se regresa la constante ya con sus campos llenos
return(constante);
}
//Función paa agregar variables a la tabla de variables
public void addVariable(Variable variable)
{
//Si la pila de variables está vacía
if (variableStack.Count == 0)
{
//Se crea una nueva capa a la tabla de variables
addVariableLayer(variable);
assignGlobalAddress(variable);
//Se termina la ejecución
return;
}
//Si se encontró una variable con el mismo nombre
if (findVariableInLastScope(variable.getName()) != null)
{
//Error, no se pueden tener variables con el mismo nombre en el mismo scope
parser.ErrorHandler.SemErr("Sevaral declarations of " + variable.getName());
return;
}
//Se obtiene la referencia a la primera variable del scope
Dictionary <string, Variable> lastVariable = getTopVariableStack();
//Si el top de la pila no es nulo, se agrega la variable al diccionario
if (lastVariable != null)
{
try {
lastVariable.Add(variable.getName(), variable);
}
catch (ArgumentException) {
//Si no se puede agregar es que ya existe una variable con ese nombre
parser.ErrorHandler.SemErr("Sevaral declarations of " + variable.getName());
return;
}
}
else
{
//Se quita el nulo de la capa
removeVariableLayer();
//Se le guarda la variable
addVariableLayer(variable);
}
//Si la pila es de tamaño 1, solo hay variables globales
if (variableStack.Count > 1)
{
assignlocalAddress(variable);
}
else
{
assignGlobalAddress(variable);
}
}
public string getQuadruple()
{
if (returnVariable == null && returnValue != null)
{
return("RETURN, " + returnValue.getName() + ", _, " + " UNDEF");
}
else if (returnValue != null)
{
return("RETURN, " + returnValue.getName() + ", _, " + returnVariable.getName());
}
return("RETURN, " + "UNDEF" + ", _, " + "UNDEF");
}
//Función que agrega una nueva capa a la tabla de variables
public void addVariableLayer(Variable variable)
{
Dictionary <string, Variable> aux = new Dictionary <string, Variable>();
aux.Add(variable.getName(), variable);
//Se le hace push al stack
variableStack.Push(aux);
}
public string getQuadruple()
{
if (constant == null)
{
return("ASSIGN_CONSTANT, _ _,_");
}
return("ASSIGN_CONSTANT, " + constant.getName() + ", _,_");
}
//Función que agrega un nuevo parámetro a la función actual
public void addFunctParam(Variable variableParam)
{
//Si ya existe una variable que se llama igual, no puede ser
if (findVariable(variableParam.getName()) != null)
{
parser.ErrorHandler.SemErr("Several declarations of " + variableParam.getName());
//return;
}
//Si no hay parámetros, se agrega la variable a la tabla de variables la variable local
//agregando una nueva capa a la pila
if (actualFunction.getParam(1) == null)
{
addVariableLayer(variableParam);
}
else
{
//Si ya tiene parámetros, solo se agrega en su capa de la tabla de variables
addVariable(variableParam);
}
//Se agrega el parámetro a la función
actualFunction.addParam(variableParam);
}
//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);
}
public string getQuadruple()
{
return("PRINT, _, _, " + variable.getName());
}
public string getQuadruple()
{
return("PARAM, " + numberParam.getName() + ", _, " + paramVariable.getName());
}
public string getQuadruple()
{
return(lineNumber + " GoToFalse, " + variable.getName() + ", _, " + jumpTo);
}