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