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