public void estado1(ID_token token, Stack <String> pila)
{
escribirTransicion(token, pila);
if (token.ID.Equals("Id_TOKEN"))
{
asignacionRaiz(pila);
pila.Push("estado2");
arbolSintactico.agregarNodo(pila.Peek());
asignacionRaiz(pila);
}
else if (token.ID.Equals("VariableType_TOKEN"))
{
asignacionRaiz(pila);
pila.Push("estado3");
arbolSintactico.agregarNodo(pila.Peek());
asignacionRaiz(pila);
}
else if (token.ID.Equals("ReservatedWord_TOKEN"))
{
asignacionRaiz(pila);
pila.Push("estado4");
arbolSintactico.agregarNodo(pila.Peek());
asignacionRaiz(pila);
}
else if (token.lexema.Equals("COMENTARIO"))
{
///la produccion genera el estado terminal de tipo COMENTARIO
pila.Push("COMENTARIO");
}
else
{
pila.Pop();
}
escribirTransicion(token, pila);
}
public Boolean verificacionTerminal(ID_token token, Stack <String> pila)
{
if (pila.Count == 0)
{
return(false);
}
if (token.lexema.Equals(pila.Peek()))
{
Console.WriteLine("Se encontro igual: T = " + token.lexema + " P = " + pila.Peek());
pila.Pop();
return(false);
}
else
{
if (isTerminal(pila.Peek()))
{
errores.Add("Error en la linea " + token.lineaUbicacion + " se esperaba " + " \"" + pila.Peek() + " \" ");
pila.Pop();
//pila.Push(token.lexema);
escribirTransicion(token, pila);
return(true);
}
else
{
Boolean temp = shift(token, pila);
return(temp);
}
}
}
public void LOGICA2(ID_token token, Stack <String> pila)
{
if (token.lexema.Equals("&&"))
{
asignacionRaiz(pila);
pila.Pop();
pila.Push("LOGICA");
pila.Push("&&");
arbolSintactico.agregarNodo("&&");
arbolSintactico.agregarNodo("LOGICA");
}
else if (token.lexema.Equals("||"))
{
asignacionRaiz(pila);
pila.Pop();
pila.Push("LOGICA");
pila.Push("||");
arbolSintactico.agregarNodo("||");
arbolSintactico.agregarNodo("LOGICA");
}
else
{
pila.Pop();
}
escribirTransicion(token, pila);
}
private void ASIG_P(ID_token token, Stack <String> pila)
{
asignacionRaiz(pila);
if (token.lexema.Equals("ID_ENTERO"))
{
pila.Pop();
pila.Push("ID_ENTERO");
arbolSintactico.agregarNodo(token.lexema);
}
else if (token.lexema.Equals("NUMERO_E"))
{
pila.Pop();
pila.Push("NUMERO_E");
arbolSintactico.agregarNodo(token.lexema);
}
else
{
erroresSintaxis.Add("Error en la linea " + token.lineaUbicacion + " se esperaba una asignacion de tipo entera");
pila.Pop();
pila.Push(token.lexema);
}
escribirTransicion(token, pila);
}
public void ejecutar(List <ID_token> tokes)
{
if (tokes.Count > 0)
{
ID_token fin = new ID_token("FINAL_TOKEN", "$", 0, 0, Color.Orange);
fin.lexema = "$";
tokes.Add(fin);
Stack <String> pila = new Stack <String>();
pila.Push("$");
pila.Push("estado0");
//Agregacion de la raiz del arbol sintactico
arbolSintactico.inicio();
asignacionVariables = new AsignacionVar(this.retornarArbol);
expLogicas = new ExprecionesLogicas(this.retornarArbol);
ID_token token;
Boolean res = false;
for (int j = 0; j < tokes.Count; j++)
{
token = tokes.ElementAt(j);
do
{
res = verificacionTerminal(token, pila);
} while (res);
}
foreach (String var in pila)
{
Console.WriteLine(var);
}
}
}
public void ASIG_CP(ID_token token, Stack <String> pila, List <String> errores)
{
asignacionRaiz(pila);
if (token.lexema.Equals("LETRA"))
{
pila.Pop();
pila.Push("LETRA");
arbolSintactico.agregarNodo(token.lexema);
}
else if (token.lexema.Equals("ID_CARACTER"))
{
pila.Pop();
pila.Push("ID_CARACTER");
arbolSintactico.agregarNodo(token.lexema);
}
else
{
pila.Pop();
if (token.ID.Equals("Id_TOKEN"))
{
if (token.lexema.Equals("ID_"))
{
errores.Add("Error en la linea " + token.lineaUbicacion + " la variable \" " + token.contenido + " \" no esta declarada");
}
else
{
errores.Add("Error en la linea " + token.lineaUbicacion + " la variable \" " + token.contenido + " \" ya esta declarada");
}
}
errores.Add("Error en la linea " + token.lineaUbicacion + " se esperaba una asignacion de tipo caracter");
pila.Push(token.lexema);
}
escribirTransicion(token, pila);
}
public void ESTADO_LOGICO(ID_token token, Stack <String> pila, List <String> errores)
{
asignacionRaiz(pila);
if (token.lexema.Equals("VERDADERO"))
{
pila.Pop();
pila.Push("VERDADERO");
arbolSintactico.agregarNodo(token.lexema);
}
else if (token.lexema.Equals("FALSO"))
{
pila.Pop();
pila.Push("FALSO");
arbolSintactico.agregarNodo(token.lexema);
}
else if (token.lexema.Equals("ID_BOOLEANO"))
{
pila.Pop();
pila.Push("ID_BOOLEANO");
arbolSintactico.agregarNodo(token.lexema);
}
else
{
errores.Add("Error en la linea " + token.lineaUbicacion + " se esperaba una sentencia booleana");
pila.Pop();
pila.Push(token.lexema);
}
escribirTransicion(token, pila);
}
private void escribirTransicion(ID_token token, Stack <String> pila)
{
if (pila.Count > 0)
{
Console.WriteLine("Estado: " + pila.Peek() + " Lexema: " + token.lexema);
}
}
public void estado0(ID_token token, Stack <String> pila)
{
if (token.lexema.Equals("PRINCIPAL"))
{
pila.Pop();
pila.Push("}");
pila.Push("estado1");
pila.Push("{");
pila.Push(")");
pila.Push("(");
pila.Push("PRINCIPAL");
arbolSintactico.agregarNodo("PRINCIPAL");
arbolSintactico.agregarNodo("(");
arbolSintactico.agregarNodo(")");
arbolSintactico.agregarNodo("{");
arbolSintactico.agregarNodo("estado1");
arbolSintactico.agregarNodo("}");
}
else
{
errores.Add("Error en linea " + token.lineaUbicacion + " se esperaba el inicio de clase \"principal\"");
pila.Pop();
pila.Push(token.lexema);
}
escribirTransicion(token, pila);
}
public void LOGICA(ID_token token, Stack <String> pila, List <String> errores)
{
asignacionRaiz(pila);
if (token.ID.Equals("BooleanState_TOKEN") || token.lexema.Equals("ID_BOOLEANO"))
{
pila.Pop();
pila.Push("LOGICA2");
pila.Push("ESTADO_LOGICO");
arbolSintactico.agregarNodo("ESTADO_LOGICO");
arbolSintactico.agregarNodo("LOGICA2");
}
else if (token.lexema.Equals("NUMERO_E") || token.lexema.Equals("NUMERO_D") || token.lexema.Equals("ID_ENTERO") || token.lexema.Equals("ID_DECIMAL") || token.lexema.Equals("-"))
{
pila.Pop();
pila.Push("LOGICA2");
pila.Push("NUM3");
pila.Push("OP_RELACIONAL");
pila.Push("NUM2");
arbolSintactico.agregarNodo("NUM2");
arbolSintactico.agregarNodo("OP_RELACIONAL");
arbolSintactico.agregarNodo("NUM3");
arbolSintactico.agregarNodo("LOGICA2");
}
else if (token.contenido.Equals("!"))
{
pila.Pop();
pila.Push("LOGICA2");
pila.Push("LOGICA");
pila.Push("!");
arbolSintactico.agregarNodo("!");
arbolSintactico.agregarNodo("LOGICA");
arbolSintactico.agregarNodo("LOGICA2");
}
else if (token.lexema.Equals("("))
{
pila.Pop();
pila.Push("LOGICA2");
pila.Push(")");
pila.Push("LOGICA");
pila.Push("(");
arbolSintactico.agregarNodo("(");
arbolSintactico.agregarNodo("LOGICA");
arbolSintactico.agregarNodo(")");
arbolSintactico.agregarNodo("LOGICA2");
}
else
{
errores.Add("Error en la linea " + token.lineaUbicacion + " se esperaba una sentencia booleana");
pila.Pop();
pila.Push(token.lexema);
}
escribirTransicion(token, pila);
}
public void ASIG_C2(ID_token token, Stack <String> pila, List <String> errores)
{
asignacionRaiz(pila);
if (token.lexema.Equals("="))
{
pila.Pop();
pila.Push(";");
pila.Push("ASIG_CP");
pila.Push("=");
arbolSintactico.agregarNodo("=");
arbolSintactico.agregarNodo("ASIG_CP");
arbolSintactico.agregarNodo(";");
}
else if (token.lexema.Equals(","))
{
pila.Pop();
pila.Push("ASIG_C2");
pila.Push("ID_CARACTER");
pila.Push(",");
arbolSintactico.agregarNodo(",");
arbolSintactico.agregarNodo("ID_CARACTER");
arbolSintactico.agregarNodo("ASIG_C2");
}
else if (token.lexema.Equals("ID_CARACTER"))
{
pila.Pop();
pila.Push("ASIG_C2");
pila.Push("ID_CARACTER");
arbolSintactico.agregarNodo("ID_CARACTER");
arbolSintactico.agregarNodo("ASIG_C2");
}
else if (token.lexema.Equals(";"))
{
pila.Pop();
pila.Push(";");
arbolSintactico.agregarNodo(";");
}
else
{
pila.Pop();
if (token.ID.Equals("Id_TOKEN"))
{
errores.Add("Error en la linea " + token.lineaUbicacion + " la variable \" " + token.contenido + " \" ya ah sido declarada con anteoridad");
}
else
{
errores.Add("Error en la linea " + token.lineaUbicacion + " se esperaba una asignacion o fin de declaracion");
}
pila.Push(token.lexema);
}
escribirTransicion(token, pila);
}
public void estado2(ID_token token, Stack <String> pila)
{
asignacionRaiz(pila);
if (token.lexema.Equals("ID_ENTERO"))
{
pila.Pop();
pila.Push("ASIG_E");
pila.Push("ID_ENTERO");
arbolSintactico.agregarNodo("ID_ENTERO");
arbolSintactico.agregarNodo("ASIG_E");
}
else if (token.lexema.Equals("ID_DECIMAL"))
{
pila.Pop();
pila.Push("ASIG_D");
pila.Push("ID_DECIMAL");
arbolSintactico.agregarNodo("ID_DECIMAL");
arbolSintactico.agregarNodo("ASIG_D");
}
else if (token.lexema.Equals("ID_CADENA"))
{
pila.Pop();
pila.Push("ASIG_S");
pila.Push("ID_CADENA");
arbolSintactico.agregarNodo("ID_CADENA");
arbolSintactico.agregarNodo("ASIG_S");
}
else if (token.lexema.Equals("ID_BOOLEANO"))
{
pila.Pop();
pila.Push("ASIG_B");
pila.Push("ID_BOOLEANO");
arbolSintactico.agregarNodo("ID_BOOLEANO");
arbolSintactico.agregarNodo("ASIG_B");
}
else if (token.lexema.Equals("ID_CARACTER"))
{
pila.Pop();
pila.Push("ASIG_C");
pila.Push("ID_CARACTER");
arbolSintactico.agregarNodo("ID_CARACTER");
arbolSintactico.agregarNodo("ASIG_C");
}
else
{
pila.Pop();
erroresSintaxis.Add("Error en la linea " + token.lineaUbicacion + " \" " + token.contenido + " \" la variable no esta declarada");
pila.Push(token.lexema);
}
escribirTransicion(token, pila);
}
public void estado3(ID_token token, Stack <String> pila)
{
asignacionRaiz(pila);
if (token.lexema.Equals("ENTERO"))
{
pila.Pop();
pila.Push("ASIG_E2");
pila.Push("ENTERO");
arbolSintactico.agregarNodo("ENTERO");
arbolSintactico.agregarNodo("ASIG_E2");
}
else if (token.lexema.Equals("DECIMAL"))
{
pila.Pop();
pila.Push("ASIG_D2");
pila.Push("DECIMAL");
arbolSintactico.agregarNodo("DECIMAL");
arbolSintactico.agregarNodo("ASIG_D2");
}
else if (token.lexema.Equals("CADENA"))
{
pila.Pop();
pila.Push("ASIG_S2");
pila.Push("CADENA");
arbolSintactico.agregarNodo("CADENA");
arbolSintactico.agregarNodo("ASIG_S2");
}
else if (token.lexema.Equals("BOOLEANO"))
{
pila.Pop();
pila.Push("ASIG_B2");
pila.Push("BOOLEANO");
arbolSintactico.agregarNodo("BOOLEANO");
arbolSintactico.agregarNodo("ASIG_B2");
}
else if (token.lexema.Equals("CARACTER"))
{
pila.Pop();
pila.Push("ASIG_C2");
pila.Push("CARACTER");
arbolSintactico.agregarNodo("CARACTER");
arbolSintactico.agregarNodo("ASIG_C2");
}
else
{
pila.Pop();
erroresSintaxis.Add("Error en la linea " + token.lineaUbicacion + " se esperaba declaracion u otro metodo");
pila.Push(token.lexema);
}
escribirTransicion(token, pila);
}
public void NUM3(ID_token token, Stack <String> pila)
{
asignacionRaiz(pila);
if (token.lexema.Equals("NUMERO_E") || token.lexema.Equals("NUMERO_D") || token.lexema.Equals("ID_ENTERO") || token.lexema.Equals("ID_DECIMAL") || token.lexema.Equals("-"))
{
pila.Pop();
pila.Push("NUM2");
arbolSintactico.agregarNodo("NUM2");
}
}
private void EXP_P(ID_token token, Stack <String> pila)
{
asignacionRaiz(pila);
if (token.lexema.Equals("+"))
{
pila.Pop();
pila.Push("EXP");
pila.Push("+");
arbolSintactico.agregarNodo("+");
arbolSintactico.agregarNodo("EXP");
}
else
{
pila.Pop();
}
}
private void ES_SI_2(ID_token token, Stack <String> pila)
{
if (token.lexema.Equals("SINO"))
{
asignacionRaiz(pila);
pila.Pop();
pila.Push("}");
pila.Push("estado1");
pila.Push("{");
pila.Push("SINO");
arbolSintactico.agregarNodo("SINO");
arbolSintactico.agregarNodo("{");
arbolSintactico.agregarNodo("estado1");
arbolSintactico.agregarNodo("}");
}
else if (token.lexema.Equals("SINO_SI"))
{
asignacionRaiz(pila);
pila.Pop();
pila.Push("ES_SI_2");
pila.Push("}");
pila.Push("estado1");
pila.Push("{");
pila.Push(")");
pila.Push("LOGICA");
pila.Push("(");
pila.Push("SINO_SI");
arbolSintactico.agregarNodo("SINO_SI");
arbolSintactico.agregarNodo("(");
arbolSintactico.agregarNodo("LOGICA");
arbolSintactico.agregarNodo(")");
arbolSintactico.agregarNodo("{");
arbolSintactico.agregarNodo("estado1");
arbolSintactico.agregarNodo("}");
arbolSintactico.agregarNodo("ES_SI_2");
}
else
{
pila.Pop();
}
escribirTransicion(token, pila);
}
public void NUM2(ID_token token, Stack <String> pila)
{
asignacionRaiz(pila);
if (token.lexema.Equals("-"))
{
pila.Pop();
pila.Push("NUM");
pila.Push("-");
arbolSintactico.agregarNodo("-");
arbolSintactico.agregarNodo("NUM");
}
else
{
pila.Pop();
pila.Push("NUM");
arbolSintactico.agregarNodo("NUM");
}
}
public void ASIG_E(ID_token token, Stack <String> pila, List <String> errores)
{
asignacionRaiz(pila);
if (token.lexema.Equals("="))
{
pila.Pop();
pila.Push(";");
pila.Push("ASIG_EP2");
pila.Push("=");
arbolSintactico.agregarNodo("=");
arbolSintactico.agregarNodo("ASIG_EP2");
arbolSintactico.agregarNodo(";");
}
else if (token.lexema.Equals("++"))
{
pila.Pop();
pila.Push(";");
pila.Push("++");
arbolSintactico.agregarNodo("++");
arbolSintactico.agregarNodo(";");
}
else if (token.lexema.Equals("--"))
{
pila.Pop();
pila.Push(";");
pila.Push("--");
arbolSintactico.agregarNodo("--");
arbolSintactico.agregarNodo(";");
}
else
{
pila.Pop();
errores.Add("Error en la linea " + token.lineaUbicacion + " se esperaba una asignacion de tipo entero");
pila.Push(token.lexema);
}
escribirTransicion(token, pila);
}
private void EXP(ID_token token, Stack <String> pila)
{
asignacionRaiz(pila);
String lexTemp = token.lexema;
if (lexTemp.Equals("CAD_TEXTO") || lexTemp.Equals("ID_CADENA") || lexTemp.Equals("NUMERO_E") || lexTemp.Equals("ID_ENTERO") || lexTemp.Equals("NUMERO_D") || lexTemp.Equals("ID_DECIMAL"))
{
pila.Pop();
pila.Push("EXP_P");
pila.Push(token.lexema);
arbolSintactico.agregarNodo(token.lexema);
arbolSintactico.agregarNodo("EXP_P");
}
else
{
erroresSintaxis.Add("Error en la linea " + token.lineaUbicacion + " se espera una variable contenedora o una cantidad numerica");
pila.Pop();
pila.Push(token.lexema);
}
}
public void NUM(ID_token token, Stack <String> pila, List <String> errores)
{
asignacionRaiz(pila);
if (token.lexema.Equals("NUMERO_E"))
{
pila.Pop();
pila.Push("NUMERO_E");
arbolSintactico.agregarNodo(token.lexema);
}
else if (token.lexema.Equals("NUMERO_D"))
{
pila.Pop();
pila.Push("NUMERO_D");
arbolSintactico.agregarNodo(token.lexema);
}
else if (token.lexema.Equals("ID_ENTERO"))
{
pila.Pop();
pila.Push("ID_ENTERO");
arbolSintactico.agregarNodo(token.lexema);
}
else if (token.lexema.Equals("ID_DECIMAL"))
{
pila.Pop();
pila.Push("ID_DECIMAL");
arbolSintactico.agregarNodo(token.lexema);
}
else
{
errores.Add("Error en la linea " + token.lineaUbicacion + ", " + " \"" + token.contenido + "\" " + " se esperaba una variable o valor de tipo numerico");
pila.Pop();
pila.Push(token.lexema);
}
escribirTransicion(token, pila);
}
public Boolean shift(ID_token token, Stack <String> pila)
{
Boolean respuesta = false;
switch (pila.Peek())
{
case "estado0":
estado0(token, pila);
respuesta = true;
break;
case "estado1":
estado1(token, pila);
respuesta = true;
break;
case "estado2":
estado2(token, pila);
respuesta = true;
break;
case "estado3":
estado3(token, pila);
respuesta = true;
break;
case "estado4":
estado4(token, pila);
respuesta = true;
break;
case "ASIG_E2":
this.asignacionVariables.ASIG_E2(token, pila, errores);
respuesta = true;
break;
case "ASIG_E":
this.asignacionVariables.ASIG_E(token, pila, errores);
respuesta = true;
break;
case "ASIG_EP":
this.asignacionVariables.ASIG_EP(token, pila, errores);
respuesta = true;
break;
case "ASIG_D2":
this.asignacionVariables.ASIG_D2(token, pila, errores);
respuesta = true;
break;
case "ASIG_D":
this.asignacionVariables.ASIG_D(token, pila, errores);
respuesta = true;
break;
case "ASIG_DP":
this.asignacionVariables.ASIG_DP(token, pila, errores);
respuesta = true;
break;
case "ASIG_S":
this.asignacionVariables.ASIG_S(token, pila, errores);
respuesta = true;
break;
case "ASIG_SP":
this.asignacionVariables.ASIG_SP(token, pila, errores);
respuesta = true;
break;
case "ASIG_S2":
this.asignacionVariables.ASIG_S2(token, pila, errores);
respuesta = true;
break;
case "ASIG_B":
this.asignacionVariables.ASIG_B(token, pila, errores);
respuesta = true;
break;
case "ASIG_BP":
this.asignacionVariables.ASIG_BP(token, pila, errores);
respuesta = true;
break;
case "ASIG_B2":
this.asignacionVariables.ASIG_B2(token, pila, errores);
respuesta = true;
break;
case "ASIG_C":
this.asignacionVariables.ASIG_C(token, pila, errores);
respuesta = true;
break;
case "ASIG_CP":
this.asignacionVariables.ASIG_CP(token, pila, errores);
respuesta = true;
break;
case "ASIG_C2":
this.asignacionVariables.ASIG_C2(token, pila, errores);
respuesta = true;
break;
case "LOGICA":
this.expLogicas.LOGICA(token, pila, errores);
respuesta = true;
break;
case "LOGICA2":
this.expLogicas.LOGICA2(token, pila);
respuesta = true;
break;
case "ESTADO_LOGICO":
this.expLogicas.ESTADO_LOGICO(token, pila, errores);
respuesta = true;
break;
case "NUM":
this.expLogicas.NUM(token, pila, errores);
respuesta = true;
break;
case "NUM2":
this.expLogicas.NUM2(token, pila);
respuesta = true;
break;
case "NUM3":
this.expLogicas.NUM3(token, pila);
respuesta = true;
break;
case "ASIG":
ASIG(token, pila);
respuesta = true;
break;
case "ASIG_P":
ASIG_P(token, pila);
respuesta = true;
break;
case "ES_SI_2":
ES_SI_2(token, pila);
respuesta = true;
break;
case "EXP":
EXP(token, pila);
respuesta = true;
break;
case "EXP_P":
EXP_P(token, pila);
respuesta = true;
break;
case "ASIG_EP2":
this.asignacionVariables.ASIG_EP2(token, pila);
respuesta = true;
break;
case "ASIG_DP2":
this.asignacionVariables.ASIG_DP2(token, pila);
respuesta = true;
break;
default:
errores.Add("Error en linea " + token.lineaUbicacion + " no se esperaba otro token");
respuesta = false;
break;
}
return(respuesta);
}
public void estado4(ID_token token, Stack <String> pila)
{
asignacionRaiz(pila);
if (token.lexema.Equals("MIENTRAS"))
{
pila.Pop();
pila.Push("}");
pila.Push("estado1");
pila.Push("{");
pila.Push(")");
pila.Push("LOGICA");
pila.Push("(");
pila.Push("MIENTRAS");
arbolSintactico.agregarNodo("MIENTRAS");
arbolSintactico.agregarNodo("(");
arbolSintactico.agregarNodo("LOGICA");
arbolSintactico.agregarNodo(")");
arbolSintactico.agregarNodo("{");
arbolSintactico.agregarNodo("estado1");
arbolSintactico.agregarNodo("}");
}
else if (token.lexema.Equals("SI"))
{
pila.Pop();
pila.Push("ES_SI_2");
pila.Push("}");
pila.Push("estado1");
pila.Push("{");
pila.Push(")");
pila.Push("LOGICA");
pila.Push("(");
pila.Push("SI");
arbolSintactico.agregarNodo("SI");
arbolSintactico.agregarNodo("(");
arbolSintactico.agregarNodo("LOGICA");
arbolSintactico.agregarNodo(")");
arbolSintactico.agregarNodo("{");
arbolSintactico.agregarNodo("estado1");
arbolSintactico.agregarNodo("}");
arbolSintactico.agregarNodo("ES_SI_2");
}
else if (token.lexema.Equals("HACER"))
{
pila.Pop();
pila.Push(")");
pila.Push("LOGICA");
pila.Push("(");
pila.Push("MIENTRAS");
pila.Push("}");
pila.Push("estado1");
pila.Push("{");
pila.Push("HACER");
arbolSintactico.agregarNodo("HACER");
arbolSintactico.agregarNodo("{");
arbolSintactico.agregarNodo("estado1");
arbolSintactico.agregarNodo("}");
arbolSintactico.agregarNodo("MIENTRAS");
arbolSintactico.agregarNodo("(");
arbolSintactico.agregarNodo("LOGICA");
arbolSintactico.agregarNodo(")");
}
else if (token.lexema.Equals("DESDE"))
{
pila.Pop();
pila.Push("}");
pila.Push("estado1");
pila.Push("{");
pila.Push("ASIG_EP2");
pila.Push("INCREMENTO");
pila.Push("LOGICA");
pila.Push("HASTA");
pila.Push("ASIG");
pila.Push("DESDE");
arbolSintactico.agregarNodo("DESDE");
arbolSintactico.agregarNodo("ASIG");
arbolSintactico.agregarNodo("HASTA");
arbolSintactico.agregarNodo("LOGICA");
arbolSintactico.agregarNodo("INCREMENTO");
arbolSintactico.agregarNodo("ASIG_EP2");
arbolSintactico.agregarNodo("{");
arbolSintactico.agregarNodo("estado1");
arbolSintactico.agregarNodo("}");
}
else if (token.lexema.Equals("IMPRIMIR"))
{
pila.Pop();
pila.Push(";");
pila.Push(")");
pila.Push("EXP");
pila.Push("(");
pila.Push("IMPRIMIR");
arbolSintactico.agregarNodo("IMPRIMIR");
arbolSintactico.agregarNodo("(");
arbolSintactico.agregarNodo("EXP");
arbolSintactico.agregarNodo(")");
arbolSintactico.agregarNodo(";");
}
else if (token.lexema.Equals("LEER"))
{
pila.Pop();
pila.Push(";");
pila.Push(")");
pila.Push("ID_CADENA");
pila.Push("(");
pila.Push("LEER");
arbolSintactico.agregarNodo("LEER");
arbolSintactico.agregarNodo("(");
arbolSintactico.agregarNodo("ID_CADENA");
arbolSintactico.agregarNodo(")");
arbolSintactico.agregarNodo(";");
}
else
{
erroresSintaxis.Add("Error en la linea " + token.lineaUbicacion + " no se esperaba \" " + token.contenido + " \" ");
pila.Pop();
pila.Push(token.lexema);
}
escribirTransicion(token, pila);
}
