public void Parea(Token.Tipo tipo)
{
if (ErrorSintactico)
{
if (indice < ListaToken.Count() - 1)
{
indice++;
TokenActual = ListaToken.ElementAt(indice);
if (TokenActual.ObtenerTipoToken() == Token.Tipo.PUNTO_Y_COMA)
{
ErrorSintactico = false;
}
}
else
{
Console.WriteLine(":/");
}
}
else
{
if (TokenActual.ObtenerTipoToken() == tipo)
{
if (indice < ListaToken.Count() - 1)
{
indice++;
TokenActual = ListaToken.ElementAt(indice);
}
else
{
//Console.WriteLine("Error sintatico en [" + TokenActual.ObtenerTipoToken() + " " + TokenActual.ObtenerValor()+"]");
ErrorSintactico = true;
}
}
}
}
public void agregarToken(Token.Tipo tipo)
{
lTokens.AddLast(new Token(tipo, token, fila, columna));
token = "";
estado = 0;
}
public Token(Token.Tipo tipoToken, String lexema, int fila, int columna)
{
this.tipoToken = tipoToken;
this.lexema = lexema;
this.fila = fila;
this.columna = columna;
}
//Este metodo solo nos devuelve el texto correspondiente al token esperado,
//en caso de encontrar errores.
public String getTipoParaError(Token.Tipo tip)
{
switch (tip)
{
case Token.Tipo.NUMERO_ENTERO:
return("NUMERO");
case Token.Tipo.SIGNO_MAS:
return("MAS");
case Token.Tipo.SIGNO_MEN:
return("MENOS");
case Token.Tipo.SIGNO_POR:
return("por");
case Token.Tipo.SIGNO_DIV:
return("DIV");
case Token.Tipo.PARENTESIS_IZQ:
return("PAR_ABRE");
case Token.Tipo.PARENTESIS_DER:
return("PAR_CIERRA");
case Token.Tipo.ULTIMO:
return("ultimo");
default:
return("Desconocido");
}
}
public void agregarToken(Token.Tipo Tipo)
{
Console.WriteLine(auxiliarLexema);
listaTokens.AddLast(new Token(Tipo, auxiliarLexema, idToken, fila, columna));
auxiliarLexema = "";
estado = 0;
}
/*
* Metodo para añadir token a la lista de tokens
*/
public void addToken(Token.Tipo token, String lexema, int linea, int columna)
{
Token nuevoToken = new Token(token, lexema, linea, columna);
Lista_de_Tokens.Add(nuevoToken);
Console.WriteLine(nuevoToken.GetTipo);
}
public void agregarToken(Token.Tipo tipo)
{
idToken++;
ListToken.Add(new Token(idToken, fila, tipo, auxiliarLexema));
auxiliarLexema = "";
estado = 0;
}
//Metodo que agrega los tokens, va resivir un tipo de token
public void agregarTk(Token.Tipo tp)
{
ListTk.AddLast(new Token(tp, aux, contadorTK, fila, columnaiT)); //Añade a la lista de token y al mismo tiempo crea un nuevo token
contadorTK++; //Va sumnar al contador de tokens
aux = ""; //Reinicia la variable aux que contiene el valor del lexema
comp = true; //Para que vuelva a guardar nuevamente la culmna inicial del token
estado = 0;
}
public Nodo(string valor, Token.Tipo tipo, int index, Token.Tipo anterior)
{
this.izquierda = null;
this.derecha = null;
this.valor = valor;
this.index = index;
this.tipo = tipo;
this.anterior = anterior;
}
public void addToken(Token.Tipo tipo)
{
Token t = new Token(tipo, lex);
t.setFila(fila);
t.setCol(columna);
output.AddLast(t);
lex = "";
pointer = 0;
}
public void addError(Token.Tipo tipo)
{
Token t = new Token(tipo, lex);
t.setFila(fila);
t.setCol(columna);
errores.AddLast(t);
lex = "";
pointer = 0;
}
public void agregarToken(Token.Tipo tipo)
{
if (expr == 2)
{
expresion += auxlex;
}
Salida.AddLast(new Token(tipo, auxlex, fila, columnaToken));
auxlex = "";
estado = 0;
}
public void verificarAceptacion(string estado)
{
if (estado.Equals("S1"))
{
tipo = Token.Tipo.VALOR_ENTERO;
aceptacion = true;
}
else if (estado.Equals("S3"))
{
tipo = Token.Tipo.VALOR_DECIMAL;
aceptacion = true;
}
else if (estado.Equals("S6"))
{
tipo = Token.Tipo.VALOR_CADENA;
aceptacion = true;
}
else if (estado.Equals("S7"))
{
tipo = Token.Tipo.VALOR_CHART;
aceptacion = true;
}
else if (estado.Equals("S8"))
{
tipo = Token.Tipo.IDENTIFICADOR;
aceptacion = true;
}
else if (estado.Equals("S12"))
{
tipo = Token.Tipo.OPERADOR_LOGICO;
aceptacion = true;
}
else if (estado.Equals("S10") || estado.Equals("S11") ||
estado.Equals("S14"))
{
tipo = Token.Tipo.OPERADOR_RELACIONAL;
aceptacion = true;
}
else if (estado.Equals("S13"))
{
tipo = Token.Tipo.ASIGNACION;
aceptacion = true;
}
else if (estado.Equals("S15") || estado.Equals("S16") || estado.Equals("S17"))
{
tipo = Token.Tipo.OPERADOR_LOGICO;
aceptacion = true;
}
else
{
tipo = Token.Tipo.ERROR;
aceptacion = false;
}
}
private void Panic()
{
//este metodo se encarga de evitar que el analisis se detenga por un error, lo recupera
preanalisis = getNextToken();
Token.Tipo tipo = preanalisis.TipoToken;
while (!tipo.Equals(Token.Tipo.puntoycoma))
{
tipo = getNextToken().TipoToken;
}
//preanalisis = getNextToken();
}
private void emparejar(Token.Tipo tipo) //recibe el tipo para no perderme en el codigo
{
controlToken++;
if (controlToken < listaTokens.Count)
{
tokenActual = listaTokens.ElementAt(controlToken);
}
else
{
dentroExpresion = false;
}
}
private void match(Token.Tipo tipo)
{
if (actual.getTipoToken() != tipo)
{
Console.WriteLine("No se esperaba este caracter\"" + actual.getTipo() + "\", se esperaba" + tipo.ToString());
}
else if (actual.getTipoToken() != Token.Tipo.ULTIMO)
{
listaAnalizada.AddLast(actual);
controlToken++;
actual = salidaSintactico.ElementAt(controlToken);
}
}
public void emparejar(Token.Tipo tip)
{
if (tokenActual.getTipo() != tip)
{
Console.WriteLine("Error se esperaba " + getTipoParaError(tip));
lErrores.AddLast(new Error("Se esperaba " + getTipoParaError(tip), tokenActual.getFila(), tokenActual.getColumna(), "Sintactico: " + tokenActual.getValor()));
}
if (tokenActual.getTipo() != Token.Tipo.ULTIMO)
{
controlToken += 1;
tokenActual = lTokens.ElementAt(controlToken);
}
}
public void emparejar(Token.Tipo tip)
{
if (tokenActual.GetTipoE() != tip)
{
Console.WriteLine("Error se esperaba " + getTipoParaError(tip) + tokenActual.GetValor() + listaTok.ElementAt(controlToken - 1).GetValor());
String descripcionError = "Error se esperaba " + getTipoParaError(tip);
SalidaErrores.AddLast(new Error(descripcionError, tokenActual.GetFila(), tokenActual.GetColumna()));
}
if (tokenActual.GetTipoE() != Token.Tipo.ULTIMO)
{
controlToken += 1;
tokenActual = listaTok.ElementAt(controlToken);
}
}
/*
* A continuación se programa el metodo emparejar(match)
*
* Este metodo compara la entradda en la lista de tokens, es decir el tokenActual con lo que deberia
* venir, que es lo que se pasa como parametro, es decir "tip".
*
* Si "lo que viene" no es igual a "lo que deberia de venir", entonces se reporta el error,
* de lo contrario si no hemos llegado al final de la lista de tokens pasamos a analizar el
* siguiente token.
*/
public void emparejar(Token.Tipo tip)
{
if (tokenActual.getTipo() != tip)
{
//ERROR si no viene lo que deberia
Console.WriteLine("Error se esperaba " + getTipoParaError(tip));
}
//como ya se dijo si no es el ultimo token, entonces incrementamos en uno el indice de controlToken
//y damos un nuevo valor a tokenActual, que sera el suiguiente token en la lista.
if (tokenActual.getTipo() != Token.Tipo.ULTIMO)
{
controlToken += 1;
tokenActual = listaTok.ElementAt(controlToken);
}
}
public Boolean isSymbol()
{
switch (valor)
{
case '+':
this.tokenTipo = Token.Tipo.OPERADOR_ARITMETICO;
return(true);
case '-':
this.tokenTipo = Token.Tipo.OPERADOR_ARITMETICO;
return(true);
case ';':
this.tokenTipo = Token.Tipo.FIN;
return(true);
case '*':
this.tokenTipo = Token.Tipo.OPERADOR_ARITMETICO;
return(true);
case '/':
this.tokenTipo = Token.Tipo.OPERADOR_ARITMETICO;
return(true);
case '{':
this.tokenTipo = Token.Tipo.LLAVE_APERTURA;
return(true);
case '}':
this.tokenTipo = Token.Tipo.LLAVE_CIERRE;
return(true);
case '(':
this.tokenTipo = Token.Tipo.PARENTESIS_APERTURA;
return(true);
case ')':
this.tokenTipo = Token.Tipo.PARENTESIS_CIERRE;
return(true);
case ',':
this.tokenTipo = Token.Tipo.COMMAS;
return(true);
default:
return(false);
}
}
/**
* Parea:
* Compara si el token de preanalisis tiene el tipo que se indica, en caso de que no sean iguales marca error.
**/
public void Parea(Token.Tipo tipoToken)
{
//Si existe un error sintactico buscara al simbolo punto y coma para poder continuar con el analisis.
if (errorSintactico)
{
if (controlToken < listaTokens.Count - 1)
{
controlToken++;
tokenActual = listaTokens.ElementAt(controlToken);
if (tokenActual.GetTipo() == Token.Tipo.S_PUNTO_Y_COMA)
{
errorSintactico = false;
}
else
{
Console.WriteLine("Ya no se pudo recuperar :c");
}
}
}
//Si no hay error previo se procede a comparar si cumple con Parea.
else
{
//Parea se cumple bien
if (tokenActual.GetTipo() == tipoToken)
{
if (controlToken < listaTokens.Count - 1)
{
controlToken++;
tokenActual = listaTokens.ElementAt(controlToken);
while ((tokenActual.GetTipo() == Token.Tipo.COMENTARIO_INLINE || tokenActual.GetTipo() == Token.Tipo.COMENTARIO_MULTILINE) && controlToken < listaTokens.Count - 1)
{
controlToken++;
tokenActual = listaTokens.ElementAt(controlToken);
}
}
}
//Error sintactico
else
{
Console.WriteLine("Error Sintactico\nEn ID_Token: " + controlToken + "\nSe esperaba [" + tipoToken.ToString() + "] en lugar de [" + tokenActual.GetTipo() + ", " + tokenActual.GetValor() + "]");
consola += "*Error Sintactico*\nEn ID_Token: " + controlToken + "\nSe esperaba [" + tipoToken.ToString() + "] en lugar de [" + tokenActual.GetTipo() + ", " + tokenActual.GetValor() + "]\n";
errorSintactico = true;
existenciaErrorSintactico = true;
}
}
}
private Token Match(Token.Tipo tk, String descripcion)
{
Token.Tipo tipo = preanalisis.TipoToken;
if (tk.Equals(tipo))
{
Token tok = preanalisis;
preanalisis = getNextToken();
return(tok);
}
else
{
Errores(descripcion + " y se obtuvo " + preanalisis.Lexema, preanalisis.Fila, preanalisis.Columna);
Panic();
}
return(null);
}
public Token Match(Token.Tipo tk, String descripcion)
{
Token.Tipo tipo = preanalisis.TipoToken;
if (tk.Equals(tipo))
{
Token valor = preanalisis;
String val = valor.Lexema.ToLower();
valor.Lexema = val;
preanalisis = getNextToken();
return(valor);
}
else
{
Errores(descripcion + " y se obtuvo " + preanalisis.Lexema, preanalisis.Fila, preanalisis.Columna);
Panic();
}
return(null);
}
public void match(Token.Tipo tipoToken)
{
if (tokenActual.getTipo() != tipoToken)
{
Console.WriteLine("Error! se esperaba " + getTipoError(tipoToken));
Console.WriteLine(tokenActual.getValor() + " " + tokenActual.getFila());
error.AddLast(new Error(tokenActual.getValor(), "se esperaba " + getTipoError(tipoToken), tokenActual.getFila(), tokenActual.getColumna()));
while (tokenActual.getTipo() != Token.Tipo.PUNTO_COMA && tokenActual.getTipo() != Token.Tipo.ULTIMO)
{
controlToken += 1;
tokenActual = listaTokens.ElementAt(controlToken);
if (tokenActual.getTipo() != Token.Tipo.ULTIMO)
{
break;
}
}
errorEncontrado = true;
}
if (tokenActual.getTipo() != Token.Tipo.ULTIMO)
{
controlToken += 1;
tokenActual = listaTokens.ElementAt(controlToken);
}
}
private void addToken(Token.Tipo tipo)
{
salida.Add(new Token(tipo, auxLex));
auxLex = "";
}
public void agregarToken(Token.Tipo tipo)
{
Salida.AddLast(new Token(tipo, auxiliarLexico));
auxiliarLexico = "";
estado = 0;
}
Salida(Token.Tipo tipo, int parseInt)
{
this.tipoToken = tipo;
this.parseInt = parseInt;
}
/*
* Metodo para añadir error a la lista de tokens errorenos
*/
public void addTokenErroneo(Token.Tipo token, String lexema, int linea, int columna)
{
Token nuevoToken = new Token(token, lexema, linea, columna);
Lista_de_Errores.Add(nuevoToken);
}
public void setTipo(Token.Tipo tipo)
{
this.tipo = tipo;
}
public void setAnterior(Token.Tipo anterior)
{
this.anterior = anterior;
}
