private static string OperarLogico(string valor1, string valor2, ParseTreeNode node)
{
if (valor1.Equals("") || valor2.Equals(""))
{
return("");
}
int a = EnumTipoDato(valor1);
int b = EnumTipoDato(valor2);
if (a != EnumTipoDato("boolean") && b != EnumTipoDato("boolean"))
{
SingletonListas s = SingletonListas.GetInstance();
Error e = new Error()
{
Tipo = "Semántico",
Columna = node.Token.Location.Column,
Fila = node.Token.Location.Line,
Fuente = node.Token.ValueString,
Comentario = $"El operador {node.Token.ValueString} solo admite bool"
};
s.Errores.Add(e);
return("");
}
return("boolean");
}
private static void LlamadaMetodo(ParseTreeNode root)
{
if (root.Term.Name.Equals("LLAMADAMETODO"))
{
//LLAMADAMETODO.Rule = id + PARAMETROSLLAMADOS
// | id;
string id = root.ChildNodes[0].Token.ValueString;
SingletonListas s = SingletonListas.GetInstance();
Ambito a = s.GetAmbito(id);
if (a == null)
{
s.NuevoError("Semántico", id, root.ChildNodes[0].Token.Location.Line, root.ChildNodes[0].Token.Location.Column, $"No existe el procedimiento {id}");
return;
}
if (root.ChildNodes.Count == 2)
{
}
else
{
}
}
else if (root.Term.Name.Equals("PARAMETROSLLAMADOS"))
{
//PARAMETROSLLAMADOS.Rule = PARAMETROSLLAMADOS + C
// | C;
if (root.ChildNodes.Count == 2)
{
}
else
{
List <Variable> pars = new List <Variable>();
}
}
}
public static SingletonListas GetInstance()
{
if (instancia == null)
{
instancia = new SingletonListas();
}
return(instancia);
}
private static void SentenciaIf(ParseTreeNode root, string tipoDato, string H_AMBITO, bool controlFlujo = false)
{
if (root.Term.Name.Equals("SENTENCIAIF"))
{
//SENTENCIAIF.Rule = rif + SENTENCIAIFAUX;
SentenciaIf(root.ChildNodes[1], tipoDato, H_AMBITO, controlFlujo);
}
else if (root.Term.Name.Equals("SENTENCIAIFAUX"))
{
//SENTENCIAIFAUX.Rule = C + SENTENCIAS + SENTENCIAELSEIF;
SingletonListas s = SingletonListas.GetInstance();
string comparacion = ObtenerC(root.ChildNodes[0], H_AMBITO);
if (!comparacion.Equals("boolean"))
{
Error e = new Error()
{
Tipo = "Semántico",
Fila = 0,
Columna = 0,
Fuente = "If",
Comentario = "Se esperaba boolean"
};
s.NuevoError(e);
}
Sentencia(root.ChildNodes[1], tipoDato, H_AMBITO, controlFlujo);
SentenciaIf(root.ChildNodes[2], tipoDato, H_AMBITO, controlFlujo);
}
else if (root.Term.Name.Equals("SENTENCIAELSEIF"))
{
//SENTENCIAELSEIF.Rule = relse + SENTPRIMA
// |;
if (root.ChildNodes.Count == 2)
{
SentenciaIf(root.ChildNodes[1], tipoDato, H_AMBITO, controlFlujo);
}
return;
}
else if (root.Term.Name.Equals("SENTPRIMA"))
{
//SENTPRIMA.Rule = rif + SENTENCIAIFAUX
// | SENTENCIAS;
if (root.ChildNodes.Count == 2)
{
SentenciaIf(root.ChildNodes[1], tipoDato, H_AMBITO, controlFlujo);
}
else
{
Sentencia(root.ChildNodes[0], tipoDato, H_AMBITO, controlFlujo);
}
}
}
private static List <Variable> ObtenerListaId(ParseTreeNode root, string H_AMBITO)
{
//LISTA_IDS.Rule = LISTA_IDS + id
// | id;
SingletonListas s = SingletonListas.GetInstance();
if (root.ChildNodes.Count == 2)
{
List <Variable> vars = ObtenerListaId(root.ChildNodes[0], H_AMBITO);
Variable v = new Variable()
{
Indice = 0,
Ambito = H_AMBITO,
Columna = root.ChildNodes[1].Token.Location.Column,
Fila = root.ChildNodes[1].Token.Location.Line,
Id = root.ChildNodes[1].Token.ValueString
};
if (s.VerificarId(v, H_AMBITO))
{
vars.Add(v);
}
else
{
s.NuevoError(v.Ambito, v.Id, v.Fila, v.Columna, $"Ya se encuentra declarada la variable {v.Id}");
}
return(vars);
}
else
{
List <Variable> vars = new List <Variable>();
Variable v = new Variable()
{
Indice = 0,
Ambito = H_AMBITO,
Columna = root.ChildNodes[0].Token.Location.Column,
Fila = root.ChildNodes[0].Token.Location.Line,
Id = root.ChildNodes[0].Token.ValueString
};
if (s.VerificarId(v, H_AMBITO))
{
vars.Add(v);
}
else
{
s.NuevoError(v.Ambito, v.Id, v.Fila, v.Columna, $"Ya se encuentra declarada la variable {v.Id}");
}
return(vars);
}
}
private static string OperarRelacional(string valor1, string valor2, ParseTreeNode node, string H_AMBITO)
{
if (valor1.Equals("") || valor2.Equals(""))
{
return("");
}
if (valor1.Equals(valor2))
{
return("boolean");
}
else
{
SingletonListas s = SingletonListas.GetInstance();
s.NuevoError(H_AMBITO, node.Token.ValueString, node.Token.Location.Line, node.Token.Location.Column, $"El operador {node.Token.ValueString} no admite comparación {valor1} y {valor2}");
return("");
}
}
private static string NegarE(ParseTreeNode root, string valor, string H_AMBITO)
{
// -E
if (valor.Equals(""))
{
return("");
}
int tipo = EnumTipoDato(valor);
if (tipo == EnumTipoDato("int") || tipo == EnumTipoDato("double") || tipo == EnumTipoDato("boolean"))
{
return(valor);
}
SingletonListas s = SingletonListas.GetInstance();
s.NuevoError(H_AMBITO, root.Token.ValueString, root.Token.Location.Line, root.Token.Location.Column, $"No se puede negar {valor}");
return("");
}
private static void SentenciaWhile(ParseTreeNode root, string tipoDato, string H_AMBITO, bool controlFlujo = false)
{
//SENTENCIAWHILE.Rule = rwhile + C + SENTENCIAS;
SingletonListas s = SingletonListas.GetInstance();
string comparacion = ObtenerC(root.ChildNodes[1], H_AMBITO);
if (!comparacion.Equals("boolean"))
{
Error e = new Error()
{
Tipo = "Semántico",
Fila = root.ChildNodes[0].Token.Location.Line,
Columna = root.ChildNodes[0].Token.Location.Column,
Fuente = "while",
Comentario = $"Se esperaba tipo de dato boolean"
};
s.NuevoError(e);
}
Sentencia(root.ChildNodes[2], tipoDato, H_AMBITO, true);
}
public override void ReportParseError(ParsingContext context)
{
SingletonListas s = SingletonListas.GetInstance();
base.ReportParseError(context);
string error = context.CurrentToken.ValueString;
string tipo;
int fila;
int columna;
string descripcion = "";
if (error.Contains("Invalid character"))
{
tipo = "Léxico";
fila = context.Source.Location.Line;
columna = context.Source.Location.Column;
string delimStr = ":";
char[] delim = delimStr.ToCharArray();
string[] division = error.Split(delim, 2);
descripcion = "Caracter Invalido " + division[0];
}
else
{
tipo = "Sintáctico";
fila = context.Source.Location.Line;
columna = context.Source.Location.Column;
descripcion = "Se esperaba: " + context.GetExpectedTermSet().ToString();
}
Error e = new Error()
{
Tipo = tipo,
Fila = fila,
Columna = columna,
Comentario = descripcion,
Fuente = error
};
s.NuevoError(e);
}
private static void PalabraReturn(ParseTreeNode root, string tipoDato, string H_AMBITO)
{
//SENTENCIARETURN.Rule = C
// |;
SingletonListas s = SingletonListas.GetInstance();
if (root.ChildNodes.Count == 1)
{
string tipoDatoValor = ObtenerC(root.ChildNodes[0], H_AMBITO);
if (!tipoDatoValor.Equals(tipoDato))
{
Error e = new Error()
{
Tipo = "Semántico",
Fila = 0,
Columna = 0,
Fuente = "return",
Comentario = $"{H_AMBITO} retorna {tipoDato} no {tipoDatoValor}"
};
s.NuevoError(e);
}
}
else
{
if (!tipoDato.Equals("void"))
{
Error e = new Error()
{
Tipo = "Semántico",
Fila = 0,
Columna = 0,
Fuente = "return",
Comentario = $"{H_AMBITO} esperaba retornar {tipoDato}"
};
s.NuevoError(e);
}
}
}
private static void AnalizarMetodos(ParseTreeNode root)
{
//METODO.Rule = id + TIPODATO + LISTAPARAMETROS + SENTENCIAS
// | rmain + TIPODATO + LISTAPARAMETROS + SENTENCIAS;
string nombre = root.ChildNodes[0].Token.ValueString;
string tipo = ObtenerTipoDato(root.ChildNodes[1]);
SingletonListas s = SingletonListas.GetInstance();
Ambito a = new Ambito()
{
Id = nombre,
Nombre = nombre,
Tipo = tipo
};
s.Ambitos.Add(a);
List <Variable> pars = DeclaracionParametros(root.ChildNodes[2], nombre);
s.AlmacenarParametros(pars, nombre);
s.AlmacenarVariable(pars, nombre);
AnalizarSentencias(root.ChildNodes[3], tipo, nombre);
}
private static string ObtenerE(ParseTreeNode root, string H_AMBITO)
{
if (root.ChildNodes.Count == 3)
{
//E.Rule = E + mas + E
// | E + menos + E
// | E + por + E
// | E + dividir + E
// | E + modulo + E
// | E + potencia + E
string valor1 = ObtenerE(root.ChildNodes[0], H_AMBITO);
string valor2 = ObtenerE(root.ChildNodes[2], H_AMBITO);
if (valor1.Equals("") || valor2.Equals(""))
{
return("");
}
int a = EnumTipoDato(valor1);
int b = EnumTipoDato(valor2);
int columna = root.ChildNodes[1].Token.Location.Column;
int fila = root.ChildNodes[1].Token.Location.Line;
if (root.ChildNodes[1].Token.ValueString.Equals("+"))
{
return(SUMA[a, b]);
}
if (root.ChildNodes[1].Token.ValueString.Equals("-"))
{
return(RESTA[a, b]);
}
if (root.ChildNodes[1].Token.ValueString.Equals("*"))
{
return(MULTIPLICACION[a, b]);
}
if (root.ChildNodes[1].Token.ValueString.Equals("/"))
{
return(DIVISION[a, b]);
}
if (root.ChildNodes[1].Token.ValueString.Equals("%"))
{
return(MODULO[a, b]);
}
if (root.ChildNodes[1].Token.ValueString.Equals("^"))
{
return(POTENCIA[a, b]);
}
}
else
{
//E
if (root.ChildNodes[0].Token == null)
{
return(ObtenerE(root.ChildNodes[0], H_AMBITO));
}
//rtrue
if (root.ChildNodes[0].Token.ValueString.ToLower().Equals("true"))
{
return("boolean");
}
//rfalse
if (root.ChildNodes[0].Token.ValueString.ToLower().Equals("false"))
{
return("boolean");
}
if (root.ChildNodes[0].Term.Name.Equals("id"))
{
//id
SingletonListas s = SingletonListas.GetInstance();
Variable v = s.GetVariable(root.ChildNodes[0].Token.ValueString, H_AMBITO);
if (v != null)
{
return(v.Tipo);
}
else
{
s.NuevoError("Semántico", root.ChildNodes[0].Token.ValueString, root.ChildNodes[0].Token.Location.Line, root.ChildNodes[0].Token.Location.Column, $"La variable {root.ChildNodes[0].Token.ValueString} no se encuentra declarada");
}
}
//numentero
//numdecimal
//cadena
//caracter
return(root.ChildNodes[0].Term.Name.ToLower());
}
return("");
}
private static void DeclaracionVariable(ParseTreeNode root, string H_AMBITO)
{
//DECLARA.Rule = id + TIPODATO + VALOR
// | LISTA_IDS + TIPODATO + VALOR
// | id + TIPODATO + E + VALOR;
SingletonListas s = SingletonListas.GetInstance();
if (root.ChildNodes.Count == 3)
{
List <Variable> vars;
string tipoDato = ObtenerTipoDato(root.ChildNodes[1]);
string tipoDatoValor = tipoDato;
object valor = ValorDefecto(tipoDato);
if (root.ChildNodes[2].ChildNodes.Count > 0)
{
tipoDatoValor = ObtenerTipoDatoValor(root.ChildNodes[2], H_AMBITO);
}
if (tipoDatoValor.Equals(""))
{
return;
}
if (root.ChildNodes[0].Token == null)
{
vars = ObtenerListaId(root.ChildNodes[0], H_AMBITO);
foreach (Variable v in vars)
{
v.Tipo = tipoDato;
v.Valor = valor;
}
}
else
{
vars = new List <Variable>();
Variable v = new Variable()
{
Id = root.ChildNodes[0].Token.ValueString,
Tipo = tipoDato,
Fila = root.ChildNodes[0].Token.Location.Line,
Columna = root.ChildNodes[0].Token.Location.Column,
Valor = valor,
Indice = 0,
Ambito = H_AMBITO
};
if (!s.VerificarId(v, H_AMBITO))
{
s.NuevoError(H_AMBITO, v.Id, v.Fila, v.Columna, $"Ya se encuentra declarada la variable {v.Id}");
}
else
{
vars.Add(v);
}
}
if (vars.Count != 0)
{
int fila = vars[vars.Count - 1].Fila;
int columna = vars[vars.Count - 1].Columna;
string id = vars[vars.Count - 1].Id;
if (tipoDato.Equals(tipoDatoValor))
{
s.AlmacenarVariable(vars, H_AMBITO);
}
else
{
s.NuevoError(H_AMBITO, id, fila, columna, "Tipo de datos no coinciden");
}
}
}
else
{
}
}
