Este documento describe un proyecto para crear un analizador gramatical del idioma español. El analizador consta de tres partes: un analizador léxico, un analizador sintáctico y una gramática. El analizador léxico identifica tokens en una cadena de entrada, y el analizador sintáctico construye un árbol de derivación basado en las reglas gramaticales. El documento explica cada parte del analizador y proporciona ejemplos de oraciones aceptadas y rechazadas.

1. ANALIZADOR GRAMATICAL
CURSO: Semántica Formal de Lenguajes de
Programación
TEMA: Creación de un Analizador Gramatical
PROFESOR: Johnny Fernández Chero
INTEGRANTES:
 Hinostroza Guanilo, Mc Pool.
-2015-
Guadalupe, Perú
INGENIERÍA INFORMÁTICA
UNIVERSIDAD NACIONAL DE
TRUJILLO
SEDE VALLE JEQUETEPEQUE

2. PROBLEMA:
Nuestro programa consiste en un Analizador gramatical para el idioma español capaz de
reconocer oraciones y analizarlas si están correctamente estructuradas, así mismo debe
reconocer solo las palabras del diccionario como correctamente escritas.
Para esto tenemos que crear un analizador léxico y un analizador sintáctico que resulte en un
árbol de derivación con las reglas de inferencia sintácticas.
DELIMITACIÓN DEL PROBLEMA:
Por motivos de la complejidad gramatical y la amplitud del bagaje lingüístico del idioma
nuestro programa solo abarcara una parte de este tomando como estructura base el sujeto y
el predicado con sus respectivas partes y algunos accidentes gramaticales, pero no por esto en
un futuro se quite la posibilidad de ampliar sus funciones.
ESTRUCTURA:
El programa consta de 3 partes:
I. El Controlador
a. Analizador Léxico
b. Analizador Sintáctico
II. Gramática
a. Analizador Gramatical
III. Modelo
a. Adverbio
b. Diccionario
c. Palabra
d. Predicado
e. Pronombre
f. Sustantivo
g. Verbo
ETIMOLOGÍA
 Analizar: Examinar detalladamente una cosa, separando o considerando por separado
sus partes, para conocer sus características o cualidades, o su estado, y extraer
conclusiones.
 Gramática: Parte de la lingüística que estudia la estructura de las palabras y sus
accidentes, así como la manera en que se combinan para formar oraciones; incluye la
morfología y la sintaxis, y ciertas escuelas incluyen también la fonología es decir es el
conjunto de normar y reglas para hablar y escribir correctamente una lengua.
ANALIZADOR LÉXICO

3.  Esta etapa está basada usualmente en una máquina de estados finitos. Esta máquina
contiene la información de las posibles secuencias de caracteres que puede conformar
cualquier token que sea parte del lenguaje (las instancias individuales de estas
secuencias de caracteres son denominados lexemas). Por ejemplo, un token de
naturaleza entero puede contener cualquier secuencia de caracteres numéricos.
 Es la primera fase de este analizador gramatical consistente en un programa que recibe
como entrada el código fuente de otro programa (secuencia de caracteres) y produce
una salida compuesta de tokens (componentes léxicos) o símbolos. Estos tokens sirven
para una posterior etapa del proceso de traducción, siendo la entrada para el analizador
sintáctico.
DICCIONARIO (TOKENS)
 Son la palabras que va a reconocer y admitir si son correctas como aceptadas.
 Son de varios tipos según el lenguaje español para este programa use: Pronombres,
Adverbios, Sustantivos, Verbos y Predicados.
 Ejm. De Pronombres: El, Los, La.
 Ejm. De Sustantivos: Gato, Perro, Jinete, Casa.
ANALIZADOR SINTÁCTICO
 Un analizador sintáctico (o parser) es una de las partes de un compilador que
transforma su entrada en un árbol de derivación.
 El análisis sintáctico convierte el texto de entrada en otras estructuras (comúnmente
árboles), que son más útiles para el posterior análisis y capturan la jerarquía implícita de
la entrada. Un analizador léxico crea tokens de una secuencia de caracteres de entrada
y son estos tokens los que son procesados por el analizador sintáctico para construir la
estructura de datos, por ejemplo un árbol de análisis o árboles de sintaxis abstracta.
REGLAS DEL ÁRBOL DE DERIVACIÓN
Las reglas que establecen como deben estar formadas las oraciones que van a ser reconocidas
como aceptadas:
 Pronombre Sustantivo Adverbio Verbo Predicado
 Pronombre Verbo Adverbio Predicado
 Pronombre Verbo Adverbio Pronombre Predicado
 Pronombre Sustantivo Verbo Adverbio Pronombre Predicado
 Pronombre Sustantivo Verbo Predicado
 Pronombre Sustantivo Adverbio Adverbio Adverbio
PRUEBAS
 “Ellos corren por la mañana“
 REGLA FINAL: Pronombre Verbo Adverbio Pronombre Predicado

4.  Ellos corren por la mañana : aceptada
 “Sale gente la por la noche ”
 REGLA FINAL: Verbo Sustantivo Pronombre Adverbio Pronombre Predicado
 Sale gente la por la noche : rechazada
 “Los jinetes son muy inteligentes.”
 REGLA FINAL: Pronombre Sustantivo Adverbio Adverbio Adverbio
 Los jinetes son muy inteligentes : aceptada
 “Inteligentes muy son los Jinetes.”
 REGLA FINAL: Adverbio Adverbio Adverbio Pronombre Sustantivo
 Inteligentes muy son los Jinetes : rechazada
 “El Perro regala juguetes.”
 REGLA FINAL: Pronombre Sustantivo Verbo Predicado
 El Perro regala juguetes : aceptada
 “El regala juguetes Perro.”
 REGLA FINAL: Pronombre Verbo Predicado Sustantivo
 El regala juguetes Perro : rechazada
 “Ellos corren por la mañana.”
 REGLA FINAL: Pronombre Verbo Adverbio Pronombre Predicado
 Ellos corren por la mañana : aceptada
 “Corren ellos por la mañana.”
 REGLA FINAL: Verbo Pronombre Pronombre Adverbio Predicado
 Corren ellos la por mañana : rechazada
 “El gato se comió el ratón.”
 ERROR DE LEXICO...
 El gato se comio al ratón : rechazada

5. Analizador Léxico
package controlador;
import java.util.List;
import modelo.Diccionario;
import modelo.Palabra;
public class AnalizadorLexico {
Diccionario alfabeto;
public AnalizadorLexico(Diccionario alfabeto) {
this.alfabeto = alfabeto;
}
public int verificarCadena(String cadena){
for(int i=0;i<alfabeto.size();++i){
if(cadena.equalsIgnoreCase(alfabeto.get(i).getPalabra()))
return i;
else if( alfabeto.get(i) instanceof modelo.Verbo )
if( ( (modelo.Verbo) alfabeto.get(i) ) . isVerbo(cadena) )
return i;
}
return -1;
}
public boolean validarCadena(String cadena){
String[] palabras = cadena.split(" ");
boolean valida = true;
for(int i=0; i<palabras.length && valida;++i){
valida &= verificarCadena(palabras[i]) != -1;
}
return valida;
}
public Diccionario getAlfabeto() {
return alfabeto;
}

6. Analizador Sintáctico
package controlador;
import java.util.ArrayList;
import java.util.List;
import modelo.Palabra;
public class AnalizadorSintactivo {
AnalizadorLexico analizadorlexico;
List<String> reglas;
public AnalizadorSintactivo(AnalizadorLexico analizadorlexico) {
this.analizadorlexico = analizadorlexico;
}
public void setReglas(List<String> reglas) {
this.reglas = reglas;
}
public boolean analizarSemantica(String cadena,boolean debug){
String reglafinal = "";
if(analizadorlexico.validarCadena(cadena)){
String[] tokens = cadena.split(" ");
List<Palabra> regla = new ArrayList();
for(int i=0;i<tokens.length;++i){
regla.add(
analizadorlexico.getAlfabeto().get(
analizadorlexico.verificarCadena(tokens[i])
)
);
}
reglafinal = regla.get(0).getClase();
for(int j=1;j<regla.size();++j){
reglafinal += " " + regla.get(j).getClase();
}
if(debug) System.out.println("REGLA FINAL: "+reglafinal);
boolean valido = false;
for(int i=0;i<this.reglas.size() && !valido;++i){
if(reglafinal.compareToIgnoreCase(this.reglas.get(i)) == 0){
return true;
}
}
}else
if(debug) System.out.println("ERROR DE LEXICO...");
return false;
}
}

7. ANALIZADOR GRAMATICAL
package gramatica;
import controlador.AnalizadorLexico;
import controlador.AnalizadorSintactivo;
import java.util.ArrayList;
import java.util.List;
import modelo.Adverbio;
import modelo.Diccionario;
import modelo.Predicado;
import modelo.Pronombre;
import modelo.Sustantivo;
import modelo.Verbo;
public class Gramatica {
public static void main(String[] args) {
Diccionario diccionario = new Diccionario();
diccionario.add(new Sustantivo("Casa"));
diccionario.add(new Sustantivo("Jinetes"));
diccionario.add(new Sustantivo("Carro"));
diccionario.add(new Sustantivo("Gente"));
diccionario.add(new Sustantivo("Perro"));
diccionario.add(new Verbo("Compra"));
diccionario.add(new Verbo("Regala"));
diccionario.add(new Verbo("Camina"));
diccionario.add(new Verbo(new String[]{"Corre","Corro","Corremos","Corren"},"Correr"));
diccionario.add(new Verbo(new String[]{"Sale","Salimos","Salen"},"Salir"));
diccionario.add(new Predicado("Mañana"));
diccionario.add(new Predicado("Noche"));
diccionario.add(new Predicado("Juguetes"));
diccionario.add(new Pronombre("El"));
diccionario.add(new Pronombre("Los"));
diccionario.add(new Pronombre("La"));
diccionario.add(new Pronombre("Yo"));
diccionario.add(new Pronombre("Ellos"));
diccionario.add(new Adverbio("Se"));
diccionario.add(new Adverbio("Son"));
diccionario.add(new Adverbio("Muy"));
diccionario.add(new Adverbio("Por"));
diccionario.add(new Adverbio("Hoy"));
diccionario.add(new Adverbio("Inteligentes"));
AnalizadorLexico analizadorlexico = new AnalizadorLexico(diccionario);
AnalizadorSintactivo analizadorsintactico = new AnalizadorSintactivo(analizadorlexico);
List<String> reglas = new ArrayList();
reglas.add("Pronombre Sustantivo Adverbio Verbo Predicado");
reglas.add("Pronombre Verbo Adverbio Predicado");
reglas.add("Pronombre Verbo Adverbio Pronombre Predicado");
reglas.add("Pronombre Sustantivo Verbo Adverbio Pronombre Predicado");
reglas.add("Pronombre Sustantivo Verbo Predicado");
reglas.add("Pronombre Sustantivo Adverbio Adverbio Adverbio");
analizadorsintactico.setReglas(reglas);
List<String> pruebas = new ArrayList();
pruebas.add("La gente sale por la noche");
pruebas.add("Sale gente la por la noche");
pruebas.add("Los jinetes son muy inteligentes");
pruebas.add("Inteligentes muy son los Jinetes");
pruebas.add("El Perro regala juguetes");
pruebas.add("El regala juguetes Perro");
pruebas.add("Ellos corren por la mañana");
pruebas.add("Corren ellos la por mañana");
pruebas.add("El gato se comio al ratón");
for(String prueba : pruebas){
if(analizadorsintactico.analizarSemantica(prueba,true))
System.out.println(prueba+ " : "+ "aceptada n");
else
System.out.println(prueba+ " : "+ "rechazadan");
} } }

8. MODELO
ADVERBIO
package modelo;
public class Adverbio extends Palabra{
public Adverbio(String palabra) {
super(palabra);
}
@Override
public String getClase() {
return "Adverbio"; //To change body of generated methods, choose Tools | Templates.
}
}
DICCIONARIO
package modelo;
import java.util.ArrayList;
public class Diccionario extends ArrayList<Palabra>{
}
PALABRA
package modelo;
public class Palabra{
protected String palabra;
public Palabra(String palabra) {this.palabra = palabra;}
public String getPalabra() {return palabra;}
public String getClase(){
return "Palabra";
}
}
PREDICADO
package modelo;
public class Predicado extends Palabra{
public Predicado(String palabra) {super(palabra);}
@Override
public String getClase() {
return "Predicado";
}
}
PRONOMBRE
package modelo;
public class Pronombre extends Palabra{
public Pronombre(String palabra) {
super(palabra);
}
@Override
public String getClase() {
return "Pronombre"; //To change body of generated methods, choose Tools | Templates.
}
}
SUSTANTIVO
package modelo;
public class Sustantivo extends Palabra {
public Sustantivo(String palabra) {super(palabra);}
@Override

9. public String getClase() {
return "Sustantivo";
}
}
VERBO
package modelo;
import java.util.ArrayList;
import java.util.List;
public class Verbo extends Palabra{
List<String> conjugadas = new ArrayList();
public Verbo(String[] conjugadas, String palabra) {
super(palabra);
for(String item : conjugadas){
this.conjugadas.add(item);
}
}
public Verbo(String palabra) {
super(palabra);
}
@Override
public String getClase() {
return "Verbo";
}
public boolean isVerbo(String cadena){
for(String item : this.conjugadas){
if(item.equalsIgnoreCase(cadena))
return true;
}
return false;
}
}
CONCLUSIONES
Después de haber concluido con el proyecto puedo decir satisfactoriamente que alcance la meta que
esperaba lograr un analizador gramatical, pero al ser este la versión 1.0, hay muchas mejoras que son
necesarias realizar para tener un producto final en óptimas condiciones para lanzar al mercado.
EJECUCIÓN:
En el código Fuente en la clase Gramática en la última parte escribir la oración para analizar entre comillas.
PROYECTO A FUTURO
Agregarle una interfaz, incrementar su diccionario para que reconozca palabras a partir de sus raíces, que
sea capaz de reconocer las reglas de tildación y acentuación, como agudas, graves, esdrújulas y
sobresdrújulas, diptongos, triptongos Hiatos, etc. Signos de interrogación y exclamación entre otras más.