public void put(string key, Tipo tipo)
{
if (!tablaSimbolos.ContainsKey(key))
tablaSimbolos.Add(key, tipo);
else
throw new Exception("La variable \"" + key + "\" ya fue declarada. EnvT.");
}
public override bool esEquivalente(Tipo t)
{
return t is Cadena;
}
public abstract bool esEquivalente(Tipo t);
public EnumerationVariableDeclaration(string enumName, string enumVarName, Tipo tipoenum, Valor valEnum)
{
enumerationName = enumName;
enumerationVarName = enumVarName;
tipo = tipoenum;
valorEnum = valEnum;
entornoValoresActual = Parser.entornoValores;
}
Sentence function_declaration(Tipo retorno, string id)
{
EnvTypes savedEnvTypes = entornoTipos;
entornoTipos = new EnvTypes(entornoTipos);
//EnvValues savedEnvValues = entornoValores;
//entornoValores = new EnvValues(entornoValores);
EnvValues savedEnvValues = Parser.pilaValores.Peek();
Parser.pilaValores.Push(new EnvValues(Parser.pilaValores.Peek()));
match("(");
Dictionary<string,Tipo> paramsTypeList = parameter_type_list();
match(")");
FunctionDefinition funcDefinition = new FunctionDefinition();
funcionActual = funcDefinition;
Sentence compoundStmnt = function_definition();
funcDefinition.init(id, retorno, compoundStmnt);
entornoTipos = savedEnvTypes;
entornoValores = savedEnvValues;
Parser.pilaValores.Pop();
Funcion funcion = new Funcion(retorno, paramsTypeList);
entornoTipos.put(id, funcion);
ValorFuncion funcionVal = new ValorFuncion(funcDefinition);
//entornoValores.put(id, funcionVal);
Parser.pilaValores.Peek().put(id, funcionVal);
funcionActual = null;
if (id == "main")
{
main = funcDefinition;
}
return funcDefinition;
}
VariableDeclarations variable_declarator(VariableDeclarator primerVariable, Tipo tipoVariables)
{
primerVariable.initialization = variable_initializer();//primer variable viene sin inicializador
entornoTipos.put(primerVariable.declaration.id, primerVariable.declaration.tipo);//tablasimbolos
VariableDeclaration listaDeclaracionVariables = variable_declarators(primerVariable, tipoVariables);
return new VariableDeclarations(listaDeclaracionVariables);
}
public override bool esEquivalente(Tipo t)
{
return t is Entero;
}
public override bool esEquivalente(Tipo t)
{
return t is Void;
}
public Tipo validarSemanticohelper(Tipo t)
{
if (t is Arreglo)
return validarSemanticohelper(((Arreglo)t).tipoArreglo);
else
return t;
}
public void init(string nombreFuncion, Tipo ret, Sentence cpStmnt)
{
idFuncion = nombreFuncion;
Tiporetorno = ret;
compoundStatement = cpStmnt;
entornoTiposLocal = Parser.entornoTipos;
}
public FunctionDefinition(string nombreFuncion, Tipo ret, Sentence cpStmnt)
{
idFuncion = nombreFuncion;
Tiporetorno = ret;
compoundStatement = cpStmnt;
entornoTiposLocal = Parser.entornoTipos;
entornoValoresLocal = Parser.entornoValores;
ValorRetorno = null;
returned = false;
}
public override bool esEquivalente(Tipo t)
{
if (t is Funcion)
{
Funcion func = (Funcion)t;
if (!tipoRetorno.esEquivalente(func.tipoRetorno))
return false;
//for (int x = 0; x < )
return true;
//return Parametros.esEquivalente(func.Parametros);
}
else
return false;
}
public Funcion(Tipo retorno, Dictionary<string, Tipo> parametros)
{
tipoRetorno = retorno;
Parametros = parametros;
}
public override bool esEquivalente(Tipo t)
{
return t is Flotante;
}
public static Valor getDefaultValue(Tipo tipo)
{
if (tipo is Arreglo)
{
return getValorArreglo((Arreglo)tipo);
}
else
return new ValorDefault();
}
public VariableSubDeclarator(Tipo typevar, string idvar)
{
tipo = typevar;
id = idvar;
}
public Arreglo(Tipo tipo, int tam)
{
tipoArreglo = tipo;
size = tam;
}
public override bool esEquivalente(Tipo t)
{
return t is Caracter;
}
public override bool esEquivalente(Tipo t)
{
if (t is Arreglo)
{
Arreglo array = (Arreglo)t;
if (!tipoArreglo.esEquivalente(array.tipoArreglo))
return false;
return size == array.size;
}
else
return false;
}
Tipo variable_array(Tipo tipoArreglo)
{
if (peek("["))
{
match("[");
//Expr sizeExpr = expr();
int ind;
bool parseo = Int32.TryParse(currentToken.Lexema,out ind);
if (parseo == false)
throw new Exception("Error al parsear la cadena a entero currentToken:\"" + currentToken.Lexema + "\".");
int sizeExpr = ind;
match(TokenType.INTEGER_LITERAL);
match("]");
Tipo tipoArreglo2 = variable_array(tipoArreglo);
Arreglo array_t = new Arreglo(tipoArreglo2, sizeExpr);
//array_t.isReference = true;
return array_t;
} else
return tipoArreglo;//null
}
public override bool esEquivalente(Tipo t)
{
return t is Booleano;
}
VariableDeclaration variable_declarators(VariableDeclaration beforeDeclaration, Tipo tipoVariables)
{
if (peek(","))
{
match(",");
string idVariable = direct_variable_declarator();
Tipo tipoVariable = variable_array(tipoVariables);
Initializers init = variable_initializer();
entornoTipos.put(idVariable, tipoVariable);//tablasimbolos
VariableSubDeclarator variableActual = new VariableSubDeclarator(tipoVariable, idVariable);
VariableDeclarator actualDeclaration = new VariableDeclarator(variableActual, init);
VariableDeclarators variableDeclarators = new VariableDeclarators(beforeDeclaration, actualDeclaration);
return variable_declarators(variableDeclarators, tipoVariables);
}
else
return beforeDeclaration;//null
}
public override bool esEquivalente(Tipo t)
{
if (t is Registro)
{
Registro r = (Registro)t;
if (entornoTiposStruct.tablaSimbolos.Count == r.entornoTiposStruct.tablaSimbolos.Count)
{
for (int i = 0; i < entornoTiposStruct.tablaSimbolos.Count; i++)
{
Tipo miCampo = entornoTiposStruct.tablaSimbolos.ElementAt(i).Value;
Tipo otroCampo = r.entornoTiposStruct.tablaSimbolos.ElementAt(i).Value;
if (!(miCampo.esEquivalente(otroCampo)))
return false;
}
return true;
}
else
return false;
}
else
return false;
}
public StructVariableDeclaration(string strid,string strvarname, Tipo tipostr, Valor valRegistro)
{
strId = strid;
strVarId = strvarname;
tipo = tipostr;
valorRegistro = valRegistro;
}
public override bool esEquivalente(Tipo t)
{
return t is Enumeracion;
}