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(); }