private TiposBases validarAutoOperacionDivision(TiposBases expresion1, TiposBases expresion2)
{
if (!(OperadorIzquierdo is IdentificadorNode))
{
throw new SemanticoException("no se puede asignar literales fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (expresion1 is IntTipo && expresion2 is FloatTipo)
{
return(new FloatTipo());
}
if (expresion1 is FloatTipo && expresion2 is IntTipo)
{
return(new FloatTipo());
}
if (expresion1 is FloatTipo && expresion2 is FloatTipo)
{
return(new FloatTipo());
}
if (expresion1 is IntTipo && expresion2 is IntTipo)
{
return(new IntTipo());
}
throw new SemanticoException("no se puede dividir" + expresion1 + " con " + expresion2 + " fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
private TiposBases validarAutoOperacionSuma(TiposBases expresion1, TiposBases expresion2)
{
if (!(OperadorIzquierdo is IdentificadorNode))
{
throw new SemanticoException("no se puede asignar literales fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (expresion1 is StructTipo || expresion2 is StructTipo || expresion1 is VoidTipo || expresion2 is VoidTipo ||
expresion1 is EnumTipo || expresion2 is EnumTipo || expresion1 is DateTipo || expresion2 is DateTipo)
{
throw new SemanticoException("no se puede sumar" + expresion1 + " con " + expresion2 + "fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (expresion1 is StringTipo || expresion2 is StringTipo)
{
return(new StringTipo());
}
if (expresion1 == expresion2)
{
return(expresion1);
}
if ((expresion1 is IntTipo && expresion2 is FloatTipo) || (expresion2 is IntTipo && expresion1 is FloatTipo))
{
return(new FloatTipo());
}
if ((expresion1 is CharTipo && expresion2 is IntTipo) || (expresion2 is CharTipo && expresion1 is IntTipo))
{
return(new IntTipo());
}
throw new SemanticoException("no se puede auto sumar " + expresion1 + " con " + expresion2 + " fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
public static bool ConvertirABool(TiposBases.EstadoRegistro valor)
{
if (valor == TiposBases.EstadoRegistro.ACT)
{
return true;
}
return valor == TiposBases.EstadoRegistro.DES && false;
}
private TiposBases validarAutoOperacionSuma(TiposBases expresion1, TiposBases expresion2)
{
if (expresion1 is StructTipo || expresion2 is StructTipo || expresion1 is VoidTipo || expresion2 is VoidTipo)
{
throw new SemanticoException("no se puede sumar" + expresion1 + " con " + expresion2 + " fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (expresion1 is StringTipo || expresion2 is StringTipo)
{
if (!(expresion2 is EnumTipo) && !(expresion1 is EnumTipo))
{
if (!(expresion2 is DateTipo) && !(expresion1 is DateTipo))
{
return(new StringTipo());
}
}
}
if (expresion1 is CharTipo && expresion2 is CharTipo)
{
return(new StringTipo());
}
if (expresion1.GetType() == expresion2.GetType())
{
return(expresion1);
}
if ((expresion1 is IntTipo && expresion2 is FloatTipo) || (expresion2 is IntTipo && expresion1 is FloatTipo))
{
return(new FloatTipo());
}
if (expresion1 is IntTipo && expresion2 is DateTipo)
{
return(new IntTipo());
}
if (expresion2 is IntTipo && expresion1 is DateTipo)
{
return(new DateTipo());
}
if ((expresion1 is CharTipo && expresion2 is IntTipo) || (expresion2 is CharTipo && expresion1 is IntTipo))
{
return(new IntTipo());
}
if ((expresion1 is BooleanTipo && expresion2 is IntTipo) || (expresion2 is BooleanTipo && expresion1 is IntTipo))
{
return(new IntTipo());
}
throw new SemanticoException("no se puede auto sumar " + expresion1 + " con " + expresion2 + " fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
public override Implementacion.Value Interpret()
{
TiposBases tipo = null;
Value valorRetorno = null;
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist(identificador))
{
tipo = stack.GetVariable(identificador);
}
}
var TipoFuncion = (tipo as FuncionTipo);
var paramentros = TipoFuncion.listaParametros;
var sentencias = TipoFuncion.sentencias;
foreach (var parametro in paramentros)
{
ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(parametro.Key, parametro.Value);
}
var i = 0;
foreach (var parametrosInicial in ListaDeParametros)
{
dynamic parametro = parametrosInicial;
var parametroFuncion = paramentros.ToList()[i];
ContenidoStack.InstanceStack.Stack.Peek().SetVariableValue(paramentros.ToList()[i].Key, parametro.Interpret());
i++;
}
ContenidoStack.InstanceStack.Stack.Push(new TablaSimbolos());
foreach (var sentencia in sentencias)
{
if (sentencia is ReturnNode)
{
valorRetorno = (sentencia as ReturnNode).InterpetReturm();
}
else
{
sentencia.ValidSemantic();
sentencia.Interpret();
}
}
ContenidoStack.InstanceStack.Stack.Pop();
return(valorRetorno);
}
private TiposBases validarAutoOperacionMultiplicacion(TiposBases expresion1, TiposBases expresion2)
{
if ((expresion1 is IntTipo || expresion1 is FloatTipo) && (expresion2 is FloatTipo || expresion2 is IntTipo))
{
if (expresion1.GetType() == expresion2.GetType())
{
return(expresion1);
}
}
if (expresion1 is FloatTipo || expresion2 is FloatTipo)
{
return(new IntTipo());
}
if (expresion1 is IntTipo && expresion1 is IntTipo)
{
return(new IntTipo());
}
throw new SemanticoException("no se puede multiplicar" + expresion1 + " con " + expresion2 + " fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
private TiposBases validarOperacionDivisionResiduoNode(TiposBases expresion1, TiposBases expresion2)
{
if ((expresion1 is IntTipo || expresion1 is FloatTipo) && (expresion2 is FloatTipo || expresion2 is IntTipo))
{
if (expresion1.GetType() == expresion2.GetType())
{
return(expresion1);
}
}
if (expresion1 is FloatTipo || expresion2 is FloatTipo)
{
return(new IntTipo());
}
if (expresion1 is IntTipo && expresion1 is IntTipo)
{
return(new IntTipo());
}
throw new SemanticoException("no se puede obtener residuo de esta division " + expresion1 + " con " + expresion2 + " fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
public override void Interpret()
{
TiposBases tipo = null;
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist(identificador))
{
tipo = stack.GetVariable(identificador);
}
}
Dictionary <string, TiposBases> paramentros = (tipo is VoidTipo) ? (tipo as VoidTipo).listaParametros : (tipo as FuncionTipo).listaParametros;
List <StatementNode> sentencias = (tipo is VoidTipo) ? (tipo as VoidTipo).sentencias : (tipo as FuncionTipo).sentencias;
foreach (var parametro in paramentros)
{
ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(parametro.Key, parametro.Value);
}
var i = 0;
foreach (var parametrosInicial in ListaDeParametros)
{
var parametro = parametrosInicial;
var parametroFuncion = paramentros.ToList()[i];
if (parametro is IdentificadorNode)
{
ContenidoStack.InstanceStack.Stack.Peek().SetVariableValue(paramentros.ToList()[i].Key, (parametro as IdentificadorNode).Interpret());
}
i++;
}
foreach (var sentencia in sentencias)
{
sentencia.Interpret();
}
}
private TiposBases validarAutoOperacionResta(TiposBases expresion1, TiposBases expresion2)
{
if (!(OperadorIzquierdo is IdentificadorNode))
{
throw new SemanticoException("no se puede asignar literales fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if ((expresion1 is IntTipo || expresion1 is FloatTipo) && (expresion2 is FloatTipo || expresion2 is IntTipo))
{
if (expresion1.GetType() == expresion2.GetType())
{
return(expresion1);
}
}
if (expresion1 is FloatTipo || expresion2 is FloatTipo)
{
return(new FloatTipo());
}
if (expresion1 is IntTipo && expresion1 is IntTipo)
{
return(new IntTipo());
}
throw new SemanticoException("no se puede restar" + expresion1 + " con " + expresion2 + " fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
public void DeclareVariable(string name, TiposBases type)
{
_variables.Add(name, type);
_values.Add(name, type.GetDefaultValue());
}
public override void ValidSemantic()
{
if (tipo != null)
{
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist(value))
{
throw new SintanticoException("variable " + value + " existe+ fila:" + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
}
;
ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(value, obtenerTipo(tipo));
}
else
{
if (ContenidoStack.InstanceStack.Stack.Peek()._variables.Count == 0)
{
throw new SintanticoException("variable " + value + " no existe" + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
bool existe = false;
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist(value))
{
existe = true;
tipo = stack.GetVariable(value).ToString();
}
}
;
if (existe == false)
{
throw new SintanticoException("variable " + value + " no existe" + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
}
TiposBases tipoAasignar = obtenerTipo(tipo);
if (obtenerTipo(tipo) is ConstTipo)
{
throw new SintanticoException("variable " + value + " es constante no se puede asignar" + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (obtenerTipo(tipo) is ArrayTipo)
{
Type fieldsType = typeof(ArrayTipo);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var unidimensional = (bool)fields[1].GetValue(tipo);
var bidimensional = (bool)fields[2].GetValue(tipo);
var tipodeArray = (TiposBases)fields[0].GetValue(tipo);
foreach (var accesores in Asesores)
{
if (accesores is LogicaStructNode)
{
throw new SintanticoException(value + "es un arreglo no una structura");
}
if (accesores is PuntoNode)
{
throw new SintanticoException(value + "es un arreglo no una enum");
}
accesores.ValidSemantic();
}
if (bidimensional == true && Asesores.Count == 2)
{
tipoAasignar = tipodeArray;
}
if (bidimensional == true && Asesores.Count == 1)
{
tipoAasignar = new ArrayTipo();
}
if (bidimensional == false && Asesores.Count > 1)
{
throw new SintanticoException("el elemento " + value + " no es un arreglo de mas de una dimension fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (bidimensional == false && Asesores.Count == 1 && unidimensional == true)
{
tipoAasignar = tipodeArray;
}
if (bidimensional == false && Asesores.Count == 0 && unidimensional == true)
{
tipoAasignar = new ArrayTipo();
}
if (bidimensional == false && Asesores.Count == 0 && unidimensional == false)
{
throw new SintanticoException("el elemento " + value + " no es un arreglo");
}
if (bidimensional == true && Asesores.Count == 0)
{
tipoAasignar = new ArrayTipo();
}
}
if (obtenerTipo(tipo) is StructTipo)
{
var structAhora = obtenerTipo(tipo);
Type fieldsType = typeof(StructTipo);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var enumeracion = (Dictionary <string, TiposBases>)fields[0].GetValue(structAhora);
if (Asesores == null)
{
tipoAasignar = new StructTipo();
}
foreach (var accesores in Asesores)
{
if (accesores is ArrayAsesorNode)
{
throw new SintanticoException(value + "es un struct no una arreglo");
}
}
if (Asesores.Count > 1)
{
throw new SintanticoException(value + " solo se puede acceder a un elemento de el struct");
}
Type fieldsTypeAcessor = typeof(LogicaStructNode);
FieldInfo[] fieldsAcessor = fieldsTypeAcessor.GetFields(BindingFlags.Public | BindingFlags.Instance);
var elementoDestruct = fieldsAcessor[0].GetValue(Asesores[0]);
var elementoId = elementoDestruct.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
var id = (string)elementoId[0].GetValue(elementoDestruct);
var acesores = (List <AccesoresNode>)elementoId[2].GetValue(elementoDestruct);
if (enumeracion.ContainsKey(id))
{
var tipoDeElemento = enumeracion[id];
if (tipoDeElemento is ArrayTipo)
{
Type fieldsType1 = typeof(ArrayTipo);
FieldInfo[] fields1 = fieldsType1.GetFields(BindingFlags.Public | BindingFlags.Instance);
var unidimensional = (bool)fields1[1].GetValue(tipoDeElemento);
var bidimensional = (bool)fields1[2].GetValue(tipoDeElemento);
var tipodeArray = (TiposBases)fields1[0].GetValue(tipoDeElemento);
if (bidimensional == true && acesores.Count == 2)
{
tipoAasignar = tipodeArray;
}
if (bidimensional == true && acesores.Count == 1)
{
tipoAasignar = new ArrayTipo();
}
if (bidimensional == false && acesores.Count > 1)
{
throw new SintanticoException("el elemento no es un arreglo de mas de una dimension");
}
if (bidimensional == false && acesores.Count == 1 && unidimensional == true)
{
tipoAasignar = tipodeArray;
}
if (bidimensional == false && acesores.Count == 0 && unidimensional == true)
{
tipoAasignar = new ArrayTipo();
}
if (bidimensional == false && acesores.Count == 0 && unidimensional == false)
{
throw new SintanticoException("no es un arreglo ");
}
if (bidimensional == true && acesores.Count == 0)
{
tipoAasignar = new ArrayTipo();
}
}
else
{
tipoAasignar = tipoDeElemento;
}
}
}
if (inicializacion != null)
{
var inicial = inicializacion.ValidateSemantic();
if (tipoAasignar.GetType() != inicial.GetType())
{
throw new SintanticoException(" no se puede asignar " + tipo + " con " + inicial);
}
}
}
public override TiposBases ValidateSemantic()
{
TiposBases tipo = null;
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist(identificador))
{
tipo = stack.GetVariable(identificador);
}
}
;
if (tipo == null)
{
throw new SemanticoException("la funcion " + identificador + " no existe fila " + _TOKEN.Fila + "columna " + _TOKEN.Columna);
}
if (tipo is VoidTipo)
{
throw new SemanticoException("la funcion " + identificador + " debe se de retorno no void fila " + _TOKEN.Fila + "columna " + _TOKEN.Columna);
}
Type fieldsType = typeof(FuncionTipo);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var Lista = fields[0].GetValue(tipo);
var tipoRetorno = fields[1].GetValue(tipo);
var ListaFinal = (List <TiposBases>)Lista;
if (ListaDeParametros.Count != ListaFinal.Count)
{
throw new SemanticoException("la cantidad de parametros no es la misma fila " + ListaDeParametros[0]._TOKEN.Fila + "columna " + ListaDeParametros[0]._TOKEN.Columna);
}
for (int index = 0; index < ListaDeParametros.Count; index++)
{
if (ListaDeParametros[index] is YporBitNode)
{
if (!(ListaFinal[index] is MulpilicadorOperdadorReferenciaTipo))
{
throw new SemanticoException(" los paramentos son por refencia no por valor " + ListaDeParametros[0]._TOKEN.Fila + "columna " + ListaDeParametros[0]._TOKEN.Columna);
}
Type fieldsTypeReferencia = typeof(YporBitNode);
FieldInfo[] fieldsReferencia = fieldsTypeReferencia.GetFields(BindingFlags.Public | BindingFlags.Instance);
var operadorReferencia = fieldsReferencia[1].GetValue(ListaDeParametros[index]);
var tipofinarRefencia = operadorReferencia.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance)[0].GetValue(operadorReferencia);
TiposBases tipoLLamarFuncion = null;
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist((string)tipofinarRefencia))
{
tipoLLamarFuncion = stack.GetVariable((string)tipofinarRefencia);
}
}
Type fieldsTypeReferencia2 = typeof(MulpilicadorOperdadorReferenciaTipo);
FieldInfo[] fieldsReferencia2 = fieldsTypeReferencia2.GetFields(BindingFlags.Public | BindingFlags.Instance);
var operadorReferencia2 = fieldsReferencia2[0].GetValue(ListaFinal[index]);
if (tipoLLamarFuncion.GetType() != operadorReferencia2.GetType())
{
throw new SemanticoException(" el tipo de los parametros no es correcto" + ListaDeParametros[0]._TOKEN.Fila + "columna " + ListaDeParametros[0]._TOKEN.Columna);
}
if (tipoLLamarFuncion is ArrayTipo)
{
var tipodeArreglo2 = operadorReferencia2.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance)[0].GetValue(operadorReferencia2);
Type fieldsTypeArreglo1 = typeof(ArrayTipo);
FieldInfo[] fieldsArreglos = fieldsTypeArreglo1.GetFields(BindingFlags.Public | BindingFlags.Instance);
var arreglo1 = fieldsArreglos[0].GetValue(tipoLLamarFuncion);
if (arreglo1.GetType() != tipodeArreglo2.GetType())
{
throw new SemanticoException(" el tipo de los los arreglo de parametros no es correcto" + ListaDeParametros[0]._TOKEN.Fila + "columna " + ListaDeParametros[0]._TOKEN.Columna);
}
}
}
else if (ListaDeParametros[index] is OperdadorMultiplicacionUnaryNode)
{
if (!(ListaFinal[index] is YreferenciaTipo))
{
throw new SemanticoException(" los paramentos son por refencia no por valor " + ListaDeParametros[0]._TOKEN.Fila + "columna " + ListaDeParametros[0]._TOKEN.Columna);
}
Type fieldsTypeReferencia = typeof(OperdadorMultiplicacionUnaryNode);
FieldInfo[] fieldsReferencia = fieldsTypeReferencia.GetFields(BindingFlags.Public | BindingFlags.Instance);
var operadorReferencia = fieldsReferencia[1].GetValue(ListaDeParametros[index]);
var tipofinarRefencia = operadorReferencia.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance)[0].GetValue(operadorReferencia);
TiposBases tipoLLamarFuncion = null;
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist((string)tipofinarRefencia))
{
tipoLLamarFuncion = stack.GetVariable((string)tipofinarRefencia);
}
}
Type fieldsTypeReferencia2 = typeof(YreferenciaTipo);
FieldInfo[] fieldsReferencia2 = fieldsTypeReferencia2.GetFields(BindingFlags.Public | BindingFlags.Instance);
var operadorReferencia2 = fieldsReferencia2[0].GetValue(ListaFinal[index]);
if (tipoLLamarFuncion.GetType() != operadorReferencia2.GetType())
{
throw new SemanticoException(" el tipo de los parametros no es correcto" + ListaDeParametros[0]._TOKEN.Fila + "columna " + ListaDeParametros[0]._TOKEN.Columna);
}
if (tipoLLamarFuncion is ArrayTipo)
{
var tipodeArreglo2 = operadorReferencia2.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance)[0].GetValue(operadorReferencia2);
Type fieldsTypeArreglo1 = typeof(ArrayTipo);
FieldInfo[] fieldsArreglos = fieldsTypeArreglo1.GetFields(BindingFlags.Public | BindingFlags.Instance);
var arreglo1 = fieldsArreglos[0].GetValue(tipoLLamarFuncion);
if (arreglo1.GetType() != tipodeArreglo2.GetType())
{
throw new SemanticoException(" el tipo de los los arreglo de parametros no es correcto" + ListaDeParametros[0]._TOKEN.Fila + "columna " + ListaDeParametros[0]._TOKEN.Columna);
}
}
}
else if (ListaFinal[index].GetType() != ListaDeParametros[index].ValidateSemantic().GetType())
{
throw new SemanticoException(identificador + "el orden de la declaracion es incorrenta debe ser o el tipo " + ListaDeParametros + " fila " + ListaDeParametros[0]._TOKEN.Fila + "columna " + ListaDeParametros[0]._TOKEN.Columna);
}
}
return((TiposBases)tipoRetorno);
}
public void DeclareVariable(string name, TiposBases type)
{
_variables.Add(name, type);
}
public override TiposBases ValidateSemantic()
{
bool existe = false;
TiposBases tipo = null;
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist(value))
{
tipo = stack.GetVariable(value);
existe = true;
}
}
;
if (existe == false)
{
throw new SemanticoException("la variable " + value + " no existe fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (tipo is ConstTipo)
{
Type fieldsType = typeof(ConstTipo);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var tiporetorn = fields[0].GetValue(tipo);
return((TiposBases)tiporetorn);
}
if (tipo is ArrayTipo)
{
Type fieldsType = typeof(ArrayTipo);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var unidimensional = (bool)fields[1].GetValue(tipo);
var bidimensional = (bool)fields[2].GetValue(tipo);
var tipodeArray = (TiposBases)fields[0].GetValue(tipo);
if (Asesores == null)
{
return(tipo);
}
foreach (var accesores in Asesores)
{
if (accesores is LogicaStructNode)
{
throw new SintanticoException(value + "es un arreglo no una structura fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (accesores is PuntoNode)
{
throw new SintanticoException(value + "es un arreglo no una enum fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
accesores.ValidSemantic();
}
if (bidimensional == true && Asesores.Count == 2)
{
return(tipodeArray);
}
if (bidimensional == true && Asesores.Count == 1)
{
return(new ArrayTipo());
}
if (bidimensional == false && Asesores.Count > 1)
{
throw new SintanticoException("el elemento " + value + " no es un arreglo de mas de una dimension fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (bidimensional == false && Asesores.Count == 1 && unidimensional == true)
{
return(tipodeArray);
}
if (bidimensional == false && Asesores.Count == 0 && unidimensional == true)
{
return(new ArrayTipo());
}
if (bidimensional == false && Asesores.Count == 0 && unidimensional == false)
{
throw new SintanticoException("el elemento " + value + " no es un arreglo");
}
if (bidimensional == true && Asesores.Count == 0)
{
return(new ArrayTipo());
}
}
if (tipo is EnumTipo)
{
Type fieldsType = typeof(EnumTipo);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var enumeracion = (Dictionary <string, int>)fields[0].GetValue(tipo);
if (Asesores == null)
{
return(new EnumTipo());
}
foreach (var accesores in Asesores)
{
if (accesores is LogicaStructNode)
{
throw new SintanticoException(value + "es un enum no una structura fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (accesores is ArrayAsesorNode)
{
throw new SintanticoException(value + "es un enum no una arreglo fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
}
if (Asesores.Count > 1)
{
throw new SintanticoException(value + " solo se puede acceder a un elemento de el enum fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
Type fieldsTypeAcessor = typeof(PuntoNode);
FieldInfo[] fieldsAcessor = fieldsTypeAcessor.GetFields(BindingFlags.Public | BindingFlags.Instance);
var elementoDeEnum = fieldsAcessor[0].GetValue(Asesores[0]);
var elementoNombre = elementoDeEnum.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
var elemento = (string)elementoNombre[0].GetValue(elementoDeEnum);
if (elemento == null)
{
return(new EnumTipo());
}
var listadeAcesores = (List <AccesoresNode>)elementoNombre[2].GetValue(elementoDeEnum);
if (!enumeracion.ContainsKey(elemento))
{
throw new SintanticoException(elemento + " no es un elemento del enum");
}
if (listadeAcesores != null)
{
throw new SintanticoException(value + " los elementos de enum no son arreglos");
}
return(new StringTipo());
}
if (tipo is StructTipo)
{
Type fieldsType = typeof(StructTipo);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
Dictionary <string, TiposBases> enumeracion = (Dictionary <string, TiposBases>)fields[1].GetValue(tipo);
if (Asesores == null)
{
return(new StructTipo());
}
foreach (var accesores in Asesores)
{
if (accesores is ArrayAsesorNode)
{
throw new SintanticoException(value + "es un struct no una arreglo fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
}
if (Asesores.Count > 1)
{
throw new SintanticoException(value + " solo se puede acceder a un elemento de el struct fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
Type fieldsTypeAcessor = (Asesores[0] is LogicaStructNode) ? typeof(LogicaStructNode) : typeof(PuntoNode);
FieldInfo[] fieldsAcessor = fieldsTypeAcessor.GetFields(BindingFlags.Public | BindingFlags.Instance);
var elementoDestruct = fieldsAcessor[0].GetValue(Asesores[0]);
var elementoId = elementoDestruct.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
var id = (string)elementoId[0].GetValue(elementoDestruct);
var acesores = (List <AccesoresNode>)elementoId[2].GetValue(elementoDestruct);
if (enumeracion.ContainsKey(id))
{
var tipoDeElemento = enumeracion[id];
if (tipoDeElemento is ArrayTipo)
{
Type fieldsType1 = typeof(ArrayTipo);
FieldInfo[] fields1 = fieldsType1.GetFields(BindingFlags.Public | BindingFlags.Instance);
var unidimensional = (bool)fields1[1].GetValue(tipoDeElemento);
var bidimensional = (bool)fields1[2].GetValue(tipoDeElemento);
var tipodeArray = (TiposBases)fields1[0].GetValue(tipoDeElemento);
if (bidimensional == true && acesores.Count == 2)
{
return(tipodeArray);
}
if (bidimensional == true && acesores.Count == 1)
{
return(new ArrayTipo());
}
if (bidimensional == false && acesores.Count > 1)
{
throw new SintanticoException("el elemento " + id + "no es un arreglo de mas de una dimension fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (bidimensional == false && acesores.Count == 1 && unidimensional == true)
{
return(tipodeArray);
}
if (bidimensional == false && acesores.Count == 0 && unidimensional == true)
{
return(new ArrayTipo());
}
if (bidimensional == false && acesores.Count == 0 && unidimensional == false)
{
throw new SintanticoException("no es un arreglo ");
}
if (bidimensional == true && acesores.Count == 0)
{
return(new ArrayTipo());
}
}
else
{
return(tipoDeElemento);
}
}
throw new SintanticoException(value + " no es un elemento de el struct fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (tipo is MulpilicadorOperdadorReferenciaTipo)
{
if (pointer == null)
{
throw new SintanticoException(value + " es un apuntador usar * previamente fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
return(tipo);
}
else
{
if (Asesores == null || Asesores.Count == 0)
{
return(tipo);
}
else
{
throw new SintanticoException(value + " no es un elemento de el struct o un arreglo fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
}
}
private bool ConvertirEstadosRegistros(TiposBases.EstadoRegistro valor)
{
if (valor == TiposBases.EstadoRegistro.ACT)
{
return true;
}
else if (valor == TiposBases.EstadoRegistro.DES)
{
return false;
}
else
{
return false;
}
}
public override void ValidSemantic()
{
TiposBases tipo = null;
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist(identificador))
{
tipo = stack.GetVariable(identificador);
}
}
;
if (tipo == null)
{
throw new SemanticoException("la funcion " + identificador + " no existe fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
}
if (tipo is FuncionTipo)
{
Type fieldsType = typeof(FuncionTipo);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var Lista = fields[0].GetValue(tipo);
var ListaFinal = (List <TiposBases>)Lista;
if (ListaDeParametros.Count != ListaFinal.Count)
{
throw new SemanticoException("la cantidad de parametros no es la misma fila" + ListaDeParametros[0]._TOKEN.Fila + "columna " + ListaDeParametros[0]._TOKEN.Columna);
}
for (int index = 0; index < ListaDeParametros.Count; index++)
{
if (ListaDeParametros[index] is YporBitNode)
{
if (!(ListaFinal[index].GetType() is OperdadorMultiplicacionUnaryNode))
{
throw new SemanticoException(" los paramentos son por refencia no por valor " + ListaDeParametros[0]._TOKEN.Fila + "columna " + ListaDeParametros[0]._TOKEN.Columna);
}
}
else if (ListaFinal[index].GetType() != ListaDeParametros[index].ValidateSemantic().GetType())
{
throw new SemanticoException(identificador + "el orden de la declaracion es incorrenta debe ser " + ListaDeParametros);
}
}
}
else if (tipo is VoidTipo)
{
Type fieldsType = typeof(VoidTipo);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var Lista = fields[0].GetValue(tipo);
var ListaFinal = (List <TiposBases>)Lista;
if (ListaDeParametros.Count != ListaFinal.Count)
{
throw new SemanticoException("la cantidad de parametros no es la misma funcion" + identificador);
}
for (int index = 0; index < ListaDeParametros.Count; index++)
{
if (ListaFinal[index].GetType() != ListaDeParametros[index].ValidateSemantic().GetType())
{
throw new SemanticoException(identificador + " el orden de la declaracion es incorrenta debe ser " + ListaFinal);
}
}
}
}
