public override void ValidSemantic()
{
var arreglo = new ArrayTipo();
arreglo.tipo = obtenerTipo(identificador.tipo);
if (unidimesionarioArray != null)
{
arreglo.unidimensional = true;
unidimesionarioArray.ValidSemantic();
}
if (BidimesionarioArray != null)
{
arreglo.bidimensional = true;
BidimesionarioArray.ValidSemantic();
}
if (inicializacion != null)
{
foreach (var expresion in inicializacion)
{
var tipo = expresion.ValidateSemantic();
var tipoExpresion = obtenerTipo(identificador.tipo);
if (tipo.GetType() != tipoExpresion.GetType())
{
throw new SintanticoException("no se puede asignar" + tipo + " con " + tipoExpresion);
}
}
}
if (ContenidoStack.InstanceStack.Stack == null)
{
ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(identificador.identificador, arreglo);
}
else
{
bool existe = false;
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist(identificador.identificador))
{
existe = true;
}
}
;
if (existe == true)
{
throw new SintanticoException("variable " + identificador + " ya existe");
}
if (existe == false)
{
ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(identificador.identificador, arreglo);
}
}
}
public override void ValidSemantic()
{
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist(identificador.identificador))
{
throw new SintanticoException("variable " + identificador.identificador + " existe fila " + identificador._TOKEN.Fila + " colunma" + identificador._TOKEN.Columna);
}
}
List <TiposBases> listaParametros = new List <TiposBases>();
if (paramentros != null)
{
foreach (var lista in paramentros)
{
if (lista is YporBitStamentNode)
{
Type fieldsType = typeof(YporBitStamentNode);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var identificadorNode = fields[1].GetValue(lista);
var identificadorOperando = identificadorNode.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
var tipo = identificadorOperando[3].GetValue(identificadorNode);
var referencia = new YreferenciaTipo();
referencia.tipoReferencia = obtenerTipo((string)tipo);
listaParametros.Add(referencia);
}
if (lista is Identificador.IdentificadorStamNode)
{
Type fieldsType = typeof(Identificador.IdentificadorStamNode);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var tipo = fields[3].GetValue(lista);
var referenciaApuntador = fields[1].GetValue(lista);
if (referenciaApuntador != null)
{
var apuntador = new MulpilicadorOperdadorReferenciaTipo();
apuntador.tipoReferencia = obtenerTipo((string)tipo);
listaParametros.Add(apuntador);
}
else
{
listaParametros.Add(obtenerTipo((string)tipo));
}
}
if (lista is Identificador.IdentificadorArrayNode)
{
Type fieldsType = typeof(Identificador.IdentificadorArrayNode);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var declaracion = fields[0].GetValue(lista);
var tipo = declaracion.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
var puntero = tipo[1].GetValue(declaracion);
var unidimesional = fields[1].GetValue(lista);
var bidimesional = fields[2].GetValue(lista);
var array = new ArrayTipo();
array.tipo = obtenerTipo((string)tipo[0].GetValue(declaracion));
array.unidimensional = (unidimesional != null)?true:false;
array.bidimensional = (bidimesional != null) ? true : false;
if (puntero != null)
{
var apuntador = new MulpilicadorOperdadorReferenciaTipo();
apuntador.tipoReferencia = array;
listaParametros.Add(apuntador);
}
else
{
listaParametros.Add(array);
}
}
}
}
if (identificador.tipo == "void")
{
var funcion = new VoidTipo();
if (paramentros != null)
{
funcion.listaParametros = listaParametros;
}
ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(identificador.identificador, funcion);
}
else
{
var funcion = new FuncionTipo();
if (paramentros != null)
{
funcion.listaParametros = listaParametros;
}
funcion.retorno = obtenerTipo(identificador.tipo);
ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(identificador.identificador, funcion);
}
ContenidoStack.InstanceStack.Stack.Push(new TablaSimbolos());
if (paramentros != null)
{
foreach (var lista in paramentros)
{
lista.ValidSemantic();
}
}
if (declaracionDeFuncion.Count != 0)
{
foreach (var lista in declaracionDeFuncion)
{
if (identificador.tipo == "void")
{
if (lista is ReturnNode)
{
throw new SemanticoException("la funcion " + identificador.identificador + " es una funcion void y no es de retorno");
}
}
lista.ValidSemantic();
}
if (!(declaracionDeFuncion.Last() is ReturnNode))
{
throw new SemanticoException("la funcion " + identificador.identificador + " debe tener una funcion de retorno ");
}
}
ContenidoStack.InstanceStack.Stack.Pop();
}
public override void ValidSemantic()
{
var existeIdentificador = false;
Dictionary <string, TiposBases> elementosHeredados = new Dictionary <string, TiposBases>();
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist(variableNombre))
{
throw new SintanticoException("variable " + variableNombre + " existe " + _TOKEN.Fila + " columnas " + _TOKEN.Columna);
}
}
;
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
foreach (var tipo in stack._variables.ToList())
{
if (tipo.Value is StructTipo)
{
Type fieldsType = typeof(StructTipo);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var identificadorNode = fields[0].GetValue(tipo.Value);
if ((string)identificadorNode == identificador)
{
if (bloqueStruct != null)
{
throw new SintanticoException("variable " + identificador + " existe no se puede definir el struct " + _TOKEN.Fila + " columnas " + _TOKEN.Columna);
}
elementosHeredados = (Dictionary <string, TiposBases>)fields[1].GetValue(tipo.Value);
existeIdentificador = true;
}
}
}
}
;
if (bloqueStruct == null)
{
if (ContenidoStack.InstanceStack.Stack.ToList()[0]._variables.Count != 0)
{
if (existeIdentificador == false)
{
throw new SintanticoException("variable " + this.identificador + " no existe el struct " + _TOKEN.Fila + " columnas " + _TOKEN.Columna);
}
}
}
Dictionary <string, TiposBases> elementos = new Dictionary <string, TiposBases>();
if (bloqueStruct != null)
{
foreach (var lista in bloqueStruct)
{
if (lista is IdentificadorArrayNode)
{
Type fieldsType = typeof(IdentificadorArrayNode);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var identificadorNode = fields[0].GetValue(lista);
var unidimesional = fields[1].GetValue(lista);
var bidimesional = fields[2].GetValue(lista);
var tipo = identificadorNode.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance)[0].GetValue(identificadorNode);
var identificador = identificadorNode.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance)[2].GetValue(identificadorNode);
var uniarray = (unidimesional != null)?true:false;
var biarray = (bidimesional != null) ? true : false;
var array = new ArrayTipo();
array.tipo = obtenerTipo((string)tipo);
array.unidimensional = uniarray;
array.bidimensional = biarray;
elementos.Add((string)identificador, array);
}
if (lista is GeneralDeclarationNode)
{
Type fieldsType = typeof(GeneralDeclarationNode);
FieldInfo[] fields = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var Tipo = fields[0].GetValue(lista);
var identificador = fields[2].GetValue(lista);
elementos.Add((string)identificador, obtenerTipo((string)Tipo));
}
}
}
var structTipo = new StructTipo();
if (elementosHeredados.Count == 0)
{
structTipo.elementos = elementos;
}
else
{
structTipo.elementos = elementosHeredados;
}
structTipo.identificadorStruct = this.identificador;
ContenidoStack.InstanceStack.Stack.Peek()._variables.Add(variableNombre, structTipo);
}
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 void ValidSemantic()
{
foreach (var stack in ContenidoStack.InstanceStack.Stack)
{
if (stack.VariableExist(identificador.identificador))
{
throw new SintanticoException("variable " + identificador.identificador + " existe fila " + identificador._TOKEN.Fila + " colunma" + identificador._TOKEN.Columna);
}
}
Dictionary <string, TiposBases> listaParametros = new Dictionary <string, TiposBases>();
if (paramentros != null)
{
foreach (var lista in paramentros)
{
if (lista is YporBitStamentNode)
{
var identificadorNode = (lista as YporBitStamentNode).OperandoStament;
var tipo = (identificadorNode as IdentificadorStamNode).tipo;
var referencia = new YreferenciaTipo();
referencia.tipoReferencia = obtenerTipo(tipo);
listaParametros.Add((identificadorNode as IdentificadorStamNode).value, referencia);
}
if (lista is IdentificadorStamNode)
{
var tipo = (lista as IdentificadorStamNode).tipo;
var referenciaApuntador = (lista as IdentificadorStamNode).pointer;
if (referenciaApuntador != null)
{
var apuntador = new MulpilicadorOperdadorReferenciaTipo();
apuntador.tipoReferencia = obtenerTipo((string)tipo);
listaParametros.Add((lista as IdentificadorStamNode).value, apuntador);
}
else
{
listaParametros.Add((lista as IdentificadorStamNode).value, obtenerTipo(tipo));
}
}
if (lista is IdentificadorArrayNode)
{
var declaracion = (lista as IdentificadorArrayNode).identificador;
var tipo = (declaracion as GeneralDeclarationNode).tipo;
var puntero = (declaracion as GeneralDeclarationNode).pointer;
var unidimesional = (lista as IdentificadorArrayNode).unidimesionarioArray;
var bidimesional = (lista as IdentificadorArrayNode).BidimesionarioArray;
var array = new ArrayTipo();
array.tipo = obtenerTipo(tipo);
array.unidimensional = (unidimesional != null)?true:false;
array.bidimensional = (bidimesional != null) ? true : false;
if (puntero != null)
{
var apuntador = new MulpilicadorOperdadorReferenciaTipo();
apuntador.tipoReferencia = array;
listaParametros.Add((declaracion as GeneralDeclarationNode).identificador, apuntador);
}
else
{
listaParametros.Add((declaracion as GeneralDeclarationNode).identificador, array);
}
}
}
}
if (identificador.tipo == "void")
{
var funcion = new VoidTipo();
if (paramentros != null)
{
funcion.listaParametros = listaParametros;
}
if (declaracionDeFuncion != null)
{
funcion.sentencias = declaracionDeFuncion;
}
ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(identificador.identificador, funcion);
}
else
{
var funcion = new FuncionTipo();
if (paramentros != null)
{
funcion.listaParametros = listaParametros;
}
funcion.retorno = obtenerTipo(identificador.tipo);
funcion.sentencias = declaracionDeFuncion;
ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(identificador.identificador, funcion);
}
ContenidoStack.InstanceStack.Stack.Push(new TablaSimbolos());
if (paramentros != null)
{
foreach (var lista in paramentros)
{
lista.ValidSemantic();
}
}
if (declaracionDeFuncion.Count != 0)
{
foreach (var lista in declaracionDeFuncion)
{
if (identificador.tipo == "void")
{
if (lista is ReturnNode)
{
throw new SemanticoException("la funcion " + identificador.identificador + " es una funcion void y no es de retorno");
}
}
lista.ValidSemantic();
}
if (identificador.tipo != "void")
{
if (!(declaracionDeFuncion[declaracionDeFuncion.Count - 1] is ReturnNode))
{
throw new SemanticoException("la funcion " + identificador.identificador + " debe tener una funcion de retorno ");
}
}
}
ContenidoStack.InstanceStack.Stack.Pop();
}
