Analizador Sintáctico
Enviado por • 27 de Noviembre de 2013 • 9.282 Palabras (38 Páginas) • 581 Visitas
Programación de Sistemas
Grupo: 5551
“Analizador Sintáctico”
Integrante:
Islas López Sandy Paulina
Profesora Xóchitl Raquel Wong Cohen
Periodo 2013-2
Introducción al trabajo
En este documento se conocerán las características y principales funciones de un analizador sintáctico.
Analizaremos e interpretaremos como un compilador realiza el análisis sintáctico de un programa.
Índice
Introducción al trabajo 2
Introducción al tema 3
Análisis sintáctico 3
Desarrollo 5
Código 5
Captura de pantallas 12
Conclusiones Individuales 13
Arteaga Islas Esmeralda 13
Bravo Aguilar Josué Benjamín 13
García Contreras Eunice Sinaí 13
Islas López Sandy Paulina 13
Martínez Diosdado Carlos Adolfo 13
Conclusiones General 14
Referencias. 14
Introducción al tema
Todo lenguaje de programación tiene reglas que describen la estructura sintáctica de programas bien formados. En Pascal, por ejemplo, un programa se compone de bloques, un bloque de proposiciones, una proposición de expresiones, una expresión de componentes léxicos, y así sucesivamente. Se puede describir la sintaxis de las construcciones de los lenguajes de programación por medio de gramáticas de contexto libre o notación BNF ( Backus-Naur Form).
Las gramáticas ofrecen ventajas significativas a los diseñadores de lenguajes y a los desarrolladores de compiladores.
Las gramáticas son especificaciones sintácticas y precisas de lenguajes de programación.
A partir de una gramática se puede generar automáticamente un analizador sintáctico.
El proceso de construcción puede llevar a descubrir ambigüedades.
Una gramática proporciona una estructura a un lenguaje de programación, siendo más fácil generar código y detectar errores.
Es más fácil ampliar/modificar el lenguaje si está descrito con una gramática.
La mayor parte de este tema está dedicada a los métodos de análisis sintáctico de uso típico en compiladores. Primero se introducen los conceptos básicos, después las técnicas adecuadas para la aplicación manual. Además como los programas pueden contener errores sintácticos, los métodos de análisis sintáctico se pueden ampliar para que se recuperen de los errores sintácticos más frecuentes.
Análisis sintáctico
El análisis sintáctico es un análisis a nivel de sentencias, y es mucho más complejo que el análisis léxico. Su función es tomar el programa fuente en forma de tokens, que recibe del analizador léxico, y determinar la estructura de las sentencias del programa. Este proceso es similar a determinar la estructura de una frase en Castellano, determinando quien es el sujeto, predicado, el verbo y los complementos.
El análisis sintáctico agrupa a los tokens en clases sintácticas (denominadas no terminales en la definición de la gramática), tales como expresiones, procedimientos, etc.
El analizador sintáctico o parser obtiene un árbol sintáctico (u otra estructura equivalente) en la cual las hojas son los tokens, y cualquier nodo que no sea una hoja, representa un tipo de clase sintáctica (operaciones). Por ejemplo el análisis sintáctico de la siguiente expresión:
(A+B)*(C+D)
Con las reglas de la gramática que se presenta a continuación dará lugar al árbol sintáctico de la figura 3:
o <expresión> ::= <término> <más términos>
o <más términos>::= +<término> <más términos>| - <término> <más términos> | <vacío>
o <término> ::= <factor> <más factores>
o <más factores>::= * <factor> <más factores>|/ <factor> <más factores> | <vacío>
o <factor> ::= ( <expresión> ) | <variable> | <constante>
La estructura de la gramática anterior refleja la prioridad de los operadores, así los operadores “+” y “-” tienen la prioridad más baja, mientras que “*” y “/” tienen una prioridad superior. Se evaluaran en primer lugar las constantes, variables y expresiones entre paréntesis.
Los árboles sintácticos se construyen con un conjunto de reglas conocidas como gramática, y que definen con total precisión el lenguaje fuente.
Al proceso de reconocer la estructura del lenguaje fuente se conoce con el nombre de análisis sintáctico (parsing). Hay distintas clases de analizadores o reconocedores sintácticos, pero en general se clasifican en 2 grandes grupos: A.S.
Ascendentes y A.S. Descendentes.
La principal tarea del analizador sintáctico no es comprobar que la sintaxis del programa fuente sea correcta, sino construir una representación interna de ese programa y en el caso en que sea un programa incorrecto, dar un mensaje de error.
Para ello, el analizador sintáctico (A.S.) comprueba que el orden en que el analizador léxico le va entregando los tokens es válido. Si esto es así significará que la sucesión de símbolos que representan dichos tokens puede ser generada por la gramática correspondiente al lenguaje del código fuente.
Desarrollo
Código
package cadenas;
import javax.swing.JOptionPane;
public class Main {
public static void main(String[] args) {
}
}
-----------------------------------------------------------------------------------------------------------------------------------
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.MalformedURLException;
import javax.swing.*;
import javax.swing.JOptionPane;
import javax.swing.JFileChooser;
import javax.swing.filechooser.FileNameExtensionFilter;
public class Cadenas extends javax.swing.JFrame {
String cadena=""; /*Declaracion de cadenas*/
String cadenas="";/*Declaracion de cadenas*/
public Cadenas() {/*declaracion de la clase*/
initComponents();
pontab();
}
Object[] rows = new Object[2];/* creacion de objeto rows*/
javax.swing.table.DefaultTableModel tablass
= new javax.swing.table.DefaultTableModel();//creacion de tablas
private void pontab() { // creacion de clase pontab
tablass.addColumn(null);// agrega columnas
tablass.addColumn(null);
}
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
jPanel2 = new javax.swing.JPanel();
jLabel2 = new javax.swing.JLabel();
jScrollPane1 = new javax.swing.JScrollPane();
jTextArea1 = new javax.swing.JTextArea();
jButton2 = new javax.swing.JButton();
jButton3 = new javax.swing.JButton();
jLabel3 = new javax.swing.JLabel();
jScrollPane3 = new javax.swing.JScrollPane();
tabla = new javax.swing.JTable();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
jPanel2.setBorder(javax.swing.BorderFactory.createTitledBorder("Txt"));
jLabel2.setText("Original");
jTextArea1.setColumns(20);
jTextArea1.setRows(5);
jScrollPane1.setViewportView(jTextArea1);
jButton2.setText("...");
jButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton2ActionPerformed(evt);
}
});
jButton3.setText("Evaluar");
jButton3.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton3ActionPerformed(evt);
}
});
jLabel3.setText("Separada");
tabla.setModel(new javax.swing.table.DefaultTableModel(
new Object [][] {
},
new String [] {
"1", "2"
}
));
jScrollPane3.setViewportView(tabla);
javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2);
jPanel2.setLayout(jPanel2Layout);
jPanel2Layout.setHorizontalGroup(
jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel2Layout.createSequentialGroup()
.addContainerGap()
.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jLabel2)
.addGroup(jPanel2Layout.createSequentialGroup()
.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
.addComponent(jButton3, javax.swing.GroupLayout.DEFAULT_SIZE, 82, Short.MAX_VALUE)
.addComponent(jButton2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
.addGap(18, 18, 18)
.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel2Layout.createSequentialGroup()
.addComponent(jLabel3)
.addGap(0, 0, Short.MAX_VALUE))
.addComponent(jScrollPane3, javax.swing.GroupLayout.DEFAULT_SIZE, 674, Short.MAX_VALUE))))
.addContainerGap())
);
jPanel2Layout.setVerticalGroup(
jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel2Layout.createSequentialGroup()
.addContainerGap()
.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jLabel2)
.addComponent(jLabel3))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel2Layout.createSequentialGroup()
.addGap(71, 71, 71)
.addComponent(jButton2)
.addGap(29, 29, 29)
.addComponent(jButton3))
.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 250, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jScrollPane3, javax.swing.GroupLayout.PREFERRED_SIZE, 252, javax.swing.GroupLayout.PREFERRED_SIZE))
.addContainerGap(24, Short.MAX_VALUE))
);
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(jPanel2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addContainerGap())
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(jPanel2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addContainerGap())
);
pack();
}// </editor-fold>
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
JFileChooser fileChooser = new JFileChooser();
int variable = fileChooser.showOpenDialog(null);
try {
FileReader captura = new FileReader(fileChooser.getSelectedFile());
BufferedReader contenido = new BufferedReader(captura);
while ((cadenas = contenido.readLine()) != null) {
cadena += cadenas + "\n";
}
jTextArea1.setText(cadena);
} catch (Exception ghu) {
}
}
private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {
try {
File archi = new File(".txt");//seleccion de archivos
PrintWriter archivonuevo
= new PrintWriter(new FileWriter(archi));
char caa;
String junta = "";
String numjunta = "";
String [] relacional = {"<",">","==","=!"}; //arreglo para operadores relacionales
char [] numeros = {'0','1','2','3','4','5','6','7','8','9'};//arreglo para numeros
char [] arit = {'+','-','*','/'};//operadores aritmeticos
String letras = "abcdefghijklmnñopqrstuvwxyzABCDEFGHIJKLMNÑOPQRSTUVWXYZ";
String [] reservadas = {"if", "String","for","catch","else","do","while","switch",
"private","void","array","char","System","length","public","try",
"out","print","new","true","false","isLetter","isDigit","println","toCharArray"};
char [] especial = {'(',')','[',']','{','}',':',';','%','#','?','"',',','.','~','^','\\','¬','°','$'};//caracteres especiales
char [] log = {'&','|'};//operadores logicos
char [] asignacion = {'='};
for ( int ii = 0; ii < cadena.length(); ii++ ) { //ciclo que recorre las cadenas
caa = cadena.charAt(ii);
if (caa != ' ') { //condicion que separa los espacios
int v1 = 0;//declaracion de variables de tipo entero
int v2 = 0;
int v3 = 0;
while(v1 < especial.length){//ciclo que recorre los arreglos empezando por especial
if(caa==especial[v1]){ //condicion
if(v3==0){ // condicion anidada
if("".equals(junta)){
rows[0] = caa; // acomoda en las columnas
rows[1] = "Caracter Especial";
tablass.addRow(rows); // lo imprime en las columnas
tabla.setModel(tablass);
archivonuevo.println(caa+" Caracter Especial");
archivonuevo.flush();// no se para que es el flush :s
} else {
for(int v4 = 0; v4 < reservadas.length; v4++){ // este ciclo recorre el arreglo de las palabras reservadas
if(reservadas[v4].equals(junta)){//condicion de reservadas
rows[0] = junta;
rows[1] = "Palabra Reservada";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(junta+" Palabra Reservada");
archivonuevo.flush();
junta = "";
rows[0] = caa;
rows[1] = "Caracter Especial";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(caa+" Caracter Especial");
archivonuevo.flush();
v2++;
}
}
if(v2==0){ // condicion de variables
rows[0] = junta;
rows[1] = "Nombre de variable";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(junta+" Nombre de variable");
archivonuevo.flush();
junta = "";
rows[0] = caa;
rows[1] = "Caracter Especial";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(caa+" Caracter Especial");
archivonuevo.flush();
}
}
}
}
v1++;
}
int v5 = 0;
int v7 = 0;
while(v5 < arit.length){ // ciclo que recorre el arreglo de operadores aritmeticos
if(caa==arit[v5]){ // condicion de compara
if("".equals(junta)){
rows[0] = caa;
rows[1] = "Operador Aritmetico";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(caa+" Operador Aritmetico");
archivonuevo.flush();
} else {
for(int v6 = 0; v6 < reservadas.length; v6++){ //ciclo que recorre el arreglo de palabras reservadas
if(reservadas[v6].equals(junta)){ // condicion de el arreglo
rows[0] = junta; // aqui se manda a las columnas de la tabla
rows[1] = "Palabra Reservada";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(junta+" Palabra Reservada");// con su respectivo mensaje
archivonuevo.flush();
junta = "";
rows[0] = caa;
rows[1] = " Operador aritmetico";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(caa+" Operador Aritmetico");
archivonuevo.flush();
v7++;
}
}
if(v7==0){// aqui no hay ciclo por que lo que queda es las variables
rows[0] = junta;// manda a imprimir a las columnas
rows[1] = " Nombre de variable";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(junta+" Nombre de variable");
archivonuevo.flush();
junta = "";
rows[0] = caa;
rows[1] = " Operador Aritmetico";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(caa+" Operador Aritmetico");
archivonuevo.flush();
}
}
}
v5++;
}
int v8 = 0;
int v9 = 0;
while(v8 < log.length){
if(caa==log[v8]){
if("".equals(junta)){
rows[0] = caa;
rows[1] = " Operador Logico";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(caa+" Operador Logico");
archivonuevo.flush();
} else {
for(int s = 0; s < reservadas.length; s++){
if(reservadas[s].equals(junta)){
rows[0] = junta;
rows[1] = "Palabra Reservada";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(junta+" Palabra Reservada");
archivonuevo.flush();
junta = "";
rows[0] = caa;
rows[1] = "Operador Logico";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(caa+" Operador logico");
archivonuevo.flush();
v9++;
}
}
if(v9==0){
rows[0] = junta;
rows[1] = " Nombre de variable";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(junta+" Nombre de variabe");
archivonuevo.flush();
junta = "";
rows[0] = caa;
rows[1] = " Operador Logico";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(caa+" Operador logico");
archivonuevo.flush();
}
}
}
v8++;
}
int v11 = 0;
int v12 = 0;
while(v11 < asignacion.length){
if(caa==asignacion[v11]){
if("".equals(junta)){
rows[0] = caa;
rows[1] = " Operador de Asignacion";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(caa+" Operador de Asignacion");
archivonuevo.flush();
} else {
for(int v13 = 0; v13 < reservadas.length; v13++){
if(reservadas[v13].equals(junta)){
rows[0] = junta;
rows[1] = " Palabra Reservada";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(junta+" Palabra Reservada");
archivonuevo.flush();
junta = "";
rows[0] = caa;
rows[1] = "Operador de Asignacion";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(caa+" Operador de Asignacion");
archivonuevo.flush();
v12++;
}
}
if(v12==0){
rows[0] = junta;
rows[1] = "Nombre de variabe";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(junta+" Nombre de variabe");
archivonuevo.flush();
junta = "";
rows[0] = caa;
rows[1] = "Operador de Asignacion";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(caa+" Operador de Asignacion");
archivonuevo.flush();
}
}
}
v11++;
}
int v15 = 0;
while(v15 < letras.length()){
if(caa==letras.charAt(v15)){
junta = junta+caa;
}
v15++;
}
int v17 = 0;
int u1 = 0;
while(v17 < numeros.length){
if(caa==numeros[v17]){
if("".equals(junta)){
} else {
junta = junta+caa;
u1++;
}
if(u1==0){
numjunta = numjunta+caa;
}
}
v17++;
}
} else {
if("".equals(junta)){
} else {
int v18 = 0;
for(int v19 = 0; v19 < reservadas.length; v19++){
if(reservadas[v19].equals(junta)){
rows[0] = junta;
rows[1] = "Palabra Reservada";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(junta+" Palabra Reservada");
archivonuevo.flush();
junta = "";
v18++;
}
}
if(v18==0){
rows[0] = junta;
rows[1] = "Nombre de variable";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(junta+" Nombre de variabe");
archivonuevo.flush();
junta = "";
}
}
if(numjunta==""){
}else{
rows[0] = numjunta;
rows[1] = "Digito";
tablass.addRow(rows);
tabla.setModel(tablass);
archivonuevo.println(junta+" Digito");
archivonuevo.flush();
numjunta = "";
}
}
}
archivonuevo.close();
} catch (IOException ex) {
}
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Cadenas().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JPanel jPanel2;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JScrollPane jScrollPane3;
private javax.swing.JTextArea jTextArea1;
private javax.swing.JTable tabla;
// End of variables declaration
}
Captura de pantallas
Conclusiones Individuales
Arteaga Islas Esmeralda
Los analizadores sintácticos son útiles en la programación de sistemas ya que dan un amplio conocimiento de lo que genera un código, así mismo como responderá este pequeño programa, aprendí que este es una base de entrada que recibe datos los revisa y puede hacer que sean acomodados, así mismo es capaz de reconocer en donde va un símbolo o letra.
Bravo Aguilar Josué Benjamín
Se supone que la salida del analizador sintáctico es alguna representación del árbol sintáctico que reconoce la secuencia de tokens suministrada por el analizador léxico. Al concluir esta práctica tuve un amplio conocimiento del analizador pues este reconoce letras, números y caracteres especiales que va acomodando en tablas.
García Contreras Eunice Sinaí
En este tema aprendimos los recursos que utiliza un analizador sintáctico, aprendí que es la fase de entra que revisa los datos de entrada en una base gramatical. Así mismo vi que este puede tener diferentes entradas, puede entrar a errores, tablas entre otras cosas.
Islas López Sandy Paulina
Gracias a este trabajo aprendí sobre algunas de las reglas que nos describe la estructura de los programas, también me di cuenta de que el análisis sintáctico es mucho más complejo que el análisis léxico. Este determina la estructura de las sentencias del programa.
Martínez Diosdado Carlos Adolfo
Con este trabajo me quedo de una forma más clara que los lenguajes de programación tienen un conjunto de reglas que describen la estructura sintáctica de los programas correctos. La sintaxis de las construcciones de los lenguajes de programación puede describirse mediante gramáticas y ofrecen significativas ventajas tanto para los diseñadores del lenguaje como para los escritores de compiladores.
Conclusiones General
Atreves del presente trabajo pudimos aprender un poco más sobre el análisis sintáctico para una cadena de componentes léxicos, que tenga el axioma de la gramática, mediante la aplicación de sus reglas así como los tipos de análisis y la aplicación en un código de Programación.
Referencias.
Aho, A.V., Sethi, R., Ullman, J.D. (1990), Compiladores: principios, técnicas y herramientas, Tema 4, pag.: 163-186.
Louden, K.C. (1997), Compiler Construction: Principles and Practice, Tema 3, páginas: 93-140.
http://www.lcc.uma.es/~galvez/ftp/tci/tictema3.pdf extraído el 1 de Octubre del 2013
http://www.udb.edu.sv/udb/archivo/guia/informatica-ingenieria/compiladores/2013/ii/guia-3.pdf extraído el 1 de Octubre del 2013
...