Reporte de La Práctica 4

Página|1
Tecnológico Nacional de México
Trabajo: Reporte de práctica 4
Analizador semántico
Carrera: Ingeniería en Sistemas Computacionales
Horario: 8:00 a.m. – 9:00 a.m.
Integrantes de equipo:
Aviles Zapata Gloria Dayan 19320889
Bautista Celestino Alejandra 19320893
Cipriano Garcia Daniel 19321372
Lugar y fecha de entrega: Acapulco de Juárez, Gro A 03 de Junio del 2022
Clave de asignatura: SCD – 1015
Semestre: Sexto
Página|2
INDICE
Índice de figuras………………………….…………………………………..………... 3
Introducción…………………………...………………………………………………...4
Analizador léxico……………………………………………………………..………... 5
Función del analizador léxico………………………………………………………….. 5
Funciones ……………………………………………………………..………………..6
Análisis sintácticos……………………………………………………………..……... 7
Funcionamiento……………………………………………………………..………… 7
Tipos de analizadores……………………………………………………………..……8
Aplicaciones……………………………………………………………..……………. 9
¿Qué es el análisis léxico? ………………………………………………………...…. 10
Funcionamiento del análisis léxico…………………………………………………… 11
Componentes léxicos, patrones y lexemas…………………………………………… 11
¿Qué es una constante? ……………………………………………………………… 11
¿Qué es una variable? ……………………………………………………………….. 12
¿Qué es un operando? ……………………………………………………………….. 13
¿Qué es un operador? ………………………………………………………………... 13
Requisitos de software……………………………………………………………...… 14
Requisitos de hardware…………………………………………………………….… 15
Descripción de los pasos o etapas para el desarrollo………………………………… 15
Código fuente……………………………………………………………..…….……. 16
Ejemplos de ejecución de la práctica…………………………………………….…... 60
Conclusión……………………………………………………………..…………..…. 63
Bibliografías…………………………………………………………..…………..… 64
Página|3
INDICE DE FIGURA
Figura 1.- Interacción entre el analizador léxico y el analizador sintáctico.....................5
Figura 2.- Árbol de análisis sintáctico..............................................................................7
Figura 3.- Fases de compilador….....................................................................................9
Figura 4.- Tipos de datos............................................................................................... 13
Figura 5.- Analizador Semántico................................................................................... 14
Figura 6.- Ejemplo 1. .....................................................................................................59
Figura 7.- Ejemplo 2. .....................................................................................................59
Figura 8.- Ejemplo 3.......................................................................................................60
Figura 9.- Ejemplo 4…...................................................................................................60
Figura 10.- Ejemplo 5……….........................................................................................61

Página|4
Reporte de la práctica 4.- Analizador semántico
Desarrollo de la práctica
INTRODUCCIÓN
En esta investigación entenderemos que el análisis semántico no es más que la salida de un
resultado, estos debes ser correcto ya que este análisis detecta los errores que pueda contener
el programa. El análisis semántico se trata de determinar el tipo de los resultados
intermedios, comprobar que los argumentos que tiene un operador pertenecen al conjunto de
los operadores posibles, y si son compatibles ente si, comprobará que el significado do lo
que se va leyendo es válido. Podremos apreciar en cada fase del proceso de compilación se
pueden encontrar errores pero el análisis semántico detecta el error, la fase puede tratar el
error, de manera que el compilador pueda continuar, permitiendo así que se puedan detectar
errores posteriores. Un compilador que se detenga cuando encuentre el primer error no es
muy eficaz.
En el análisis semántico se detectan errores relacionados con la validez del programa. Se
puede decir que estos errores son de tipo sintáctico-semántico, pero no pueden ser
detectados por el analizador sintáctico, ya que se relacionan con interdependencias entre las
diferentes partes de un programa que no son reflejadas en un análisis gramatical. El
analizador semántico recibe la información resultado del análisis sintáctico que puede ser un
árbol jerárquico con la información relativa a la organización de los tokens en la instrucción
que se está analizando.

Página|5
ANALIZADOR LÉXICO
Un analizador léxico es un módulo destinado a leer caracteres del archivo de entrada, donde
se encuentra la cadena a analizar, reconocer subcadenas que correspondan a símbolos del
lenguaje y retornar los tokens correspondientes y sus atributos.
Las técnicas utilizadas para construir analizadores léxicos también se pueden aplicar a otras
áreas, como, por ejemplo, a lenguajes de consulta y sistemas de recuperación de
información. En cada aplicación, el problema de fondo es la especificación y diseño de
programas que ejecuten las acciones activadas por patrones dentro de las cadenas.
FUNCIÓN DEL ANALIZADOR LÉXICO
El analizador léxico forma parte de la primera fase de un compilador. Un compilador es un
programa que lee un programa escrito en un lenguaje, el lenguaje fuente, y lo traduce a un
programa equivalente en otro lenguaje, el lenguaje objeto. El proceso para construir un
compilador se encuentra dividido en cuatro etapas:
 El análisis léxico: transforma el código fuente en tokens.
 El análisis sintáctico: construye un árbol sintáctico
 El análisis semántico: realiza el chequeo de tipos
 La generación de código: genera código de maquina

Página|6
La función principal de los analizadores léxicos consiste en leer la secuencia de caracteres
de entrada y dar como resultado una secuencia de componentes léxicos que utiliza el
analizador sintáctico para hacer el análisis.
Figura 1 Interacción entre el analizador léxico y el analizador sintáctico
FUNCIONES
 Eliminar los comentarios del programa.
 Eliminar espacios en blanco, tabuladores, retorno de carro, etc, y en general, todo
aquello que carezca de significado según la sintaxis del lenguaje.
 Reconocer los identificadores de usuario, números, palabras reservadas del lenguaje
y tratarlos correctamente con respecto a la tabla de símbolos (solo en los casos que
debe de tratar con la tabla de símbolos).
 Llevar la cuenta del número de línea por la que va leyendo, por si se produce algún
error, dar información sobre donde se ha producido.
 Avisar de errores léxicos. Por ejemplo, si @ no pertenece al lenguaje, avisar de un
error.
 Puede hacer funciones de preprocesador.

Página|7
El analizador léxico puede realizar tareas secundarias en la interfaz del usuario, como
eliminar espacios en blanco, tabulaciones y caracteres de fin de línea.
En algunas ocasiones, los analizadores léxicos se dividen en una cascada de dos fases: la
primera llamada “examen” y la segunda “análisis léxico”. El examinador se encarga de
realizar tareas sencillas, mientras que el analizador léxico es el que realiza las operaciones
más complejas.
ANÁLISIS SINTÁCTICO
Un analizador sintáctico es un programa que normalmente es parte de un compilador. El
compilador se asegura de que el código se traduce correctamente a un lenguaje ejecutable.
La tarea del analizador es, en este caso, la descomposición y transformación de las entradas
en un formato utilizable para su posterior procesamiento. Se analiza una cadena de
instrucciones en un lenguaje de programación y luego se descompone en sus componentes
individuales.
FUNCIONAMIENTO
Para analizar un texto, los analizadores suelen utilizar un analizador léxico separado
(llamado lexer), que descompone los datos de entrada en fichas (símbolos de entrada como
palabras). Los Lexers son por lo general máquinas de finitas, que siguen la gramática
regular y por lo tanto aseguran un desglose adecuado. Los tokens obtenidos de esta manera
sirven como caracteres de entrada para el analizador sintáctico.
El analizador actual maneja la gramática de los datos de entrada, realiza un análisis
sintáctico de éstos y como regla general crea un árbol de sintaxis (árbol de análisis). Esto se
Página|8
puede utilizar para el procesamiento posterior de los datos, por ejemplo, la generación de
código por un compilador o ejecutado por un intérprete (traductor). Por lo tanto, el
analizador es el software que comprueba, procesa y reenvía las instrucciones del código
fuente.
Figura 2 Árbol de análisis sintáctico
TIPOS DE ANALIZADORES
Hay básicamente dos métodos de análisis diferentes, análisis de arriba hacia abajo (top-
down) y análisis de abajo hacia arriba (bottom-up). Éstos difieren generalmente en el orden
en el que se crean los elementos del árbol sintáctico.
De arriba a abajo:
En el método top-down, el analizador trabaja en un método orientado a objetivos, lo que
significa que busca a partir del símbolo de inicio de la sintaxis y busca una derivación
sintáctica adecuada. Por lo tanto, el árbol de análisis se desarrolla de arriba hacia abajo en
la dirección de un desglose cada vez más detallado.

Página|9
De abajo hacia arriba:
El analizador ascendente comienza con el símbolo de la cadena de entrada e intenta
establecer relaciones sintácticas cada vez mayores. Esto se hace hasta que el símbolo de
inicio de la gramática se ha alcanzado.
APLICACIONES
Un analizador sintáctico se utiliza a menudo para convertir texto en una nueva estructura,
por ejemplo, un árbol sintáctico, que expresa la disposición jerárquica de los elementos. En
las siguientes aplicaciones el uso de un analizador es usualmente esencial:
 La lectura de un lenguaje de programación es realizada por un analizador.
Proporciona una estructura de datos al compilador, con la que se puede generar el
código máquina o bytecode.
 El código HTML es al principio sólo una cadena de caracteres para un ordenador
que debe ser analizada por el analizador contenido en el navegador web.
Proporciona una descripción de la página web como una estructura de datos que
puede ser proyectada por un motor de diseño en la pantalla.
 Los analizadores especiales de XML son responsables del análisis de los
documentos XML y preparan la información contenida en ellos para su uso
posterior.
P á g i n a | 10
Figura 3 Fases de compilador
¿QUÉ ES EL ANÁLISIS LÉXICO?
El análisis léxico según el diccionario de la real academia española se define como lo
siguiente:
 Análisis: Distinción y separación de las partes de un todo hasta llegar a conocer sus
principios o elementos. En el caso del análisis gramática, examen de los componentes del
discurso y de sus respectivas propiedades y funciones.
 Léxico: Vocabulario, conjunto de las palabras de un idioma, o de las que pertenecen al uso
de una región, a una actividad determinada, a un campo semántico, etc.

P á g i n a | 11
FUNCIONAMIENTO DEL ANÁLISIS LÉXICO
Entonces a partir de estas definiciones se puede afirmar que el análisis léxico es el proceso de
examinar cada elemento de una frase para determinar si pertenece a un lenguaje o no a un
lenguaje. Por su parte el analizador léxico es un instrumento (programa) que nos ayuda a examinar
cada elemento de una cadena de entrada, para agruparlo en conjuntos homogéneos y asignarle una
clave que define la categoría correspondiente (TOKEN).
El analizador léxico es un programa que toma como entrada el contenido de un archivo escrito en
el lenguaje de programación a compilar (programa fuente), lo evalúa y posteriormente genera un
archivo de salida escrito en TOKENS, listo para la siguiente fase del compilador.
COMPONENTES LÉXICOS, PATRONES Y LEXEMAS
• Patrón: Es la regla que establece el lenguaje de programación para cada uno de los
componentes.
• Componente léxico: Cada uno de los caracteres que componen los patrones.
• Lexema: Es la cadena de entrada que se debe evaluar para establecer si pertenece o no al
lenguaje de programación diseñado.
¿QUÉ ES UNA CONSTANTE?
Una constante es un elemento de datos con nombre con un valor predefinido, mientras que
una variable es un elemento de datos con nombre cuyo valor puede cambiar durante el
curso de la ejecución de un programa.

P á g i n a | 12
Por ejemplo:
Null: Una referencia vacía. Parecido a un puntero vacío.
True: Equivalente al número 1.
False: Equivalente al número 0.
CONCEPTOS DE ELEMENTOS A UTILIZAR:
¿QUÉ ES UNA VARIABLE?
El concepto de variable en informática hace referencia a un nombre que representa un valor
y se utiliza de forma habitual en programación para guardar distintos tipos de datos para
poder operar con ellos posteriormente
Las variables pueden utilizarse en programación para guardar datos temporales que son
necesarios para realizar determinadas operaciones. A este tipo de variables se las
denomina variables auxiliares. También es común utilizar variables acumulativas que se
encargan de almacenar valores que pueden irse incrementando a lo largo del tiempo.
Por ejemplo:
Variables sin valor definido:
int actual, cont; char n, rango; double raiz, valor;

Variables con valor definido:
int actual=0, cont=24;
char p = 57, n = 'a', rango = '\x18'; double raiz = 2.21, valor = 217.56;
P á g i n a | 13
¿QUÉ ES UN OPERANDO?
Los operadores son:
• +, que representa la unión. L (E + F) = L (E) 𝖴 L (F).
• Yuxtaposición (i.e., símbolo de no operador, como en xy que significa x × y)
para representar la concatenación. L (EF) = L (E) L (F), donde la concatenación
de los lenguajes L y M es {xy|x ∈ L y, y ∈ M}, la concatenación también se
representa por un punto “·” ´o como “dot”.
• ∗ para representar la cerradura. L(E∗ ) = (L(E))∗ , donde L ∗ = {ϵ} 𝖴 L 𝖴 LL 𝖴
LLL ...
• Si E es una expresión regular, entonces (E), E entre paréntesis, también es una
expresión regular que denota el mismo lenguaje que E. Formalmente: L((E)) =
L(E).ç
¿QUÉ ES UN OPERADOR?
Operando se define como: Si E es una expresión recular, entonces L (E) denota el lenguaje
que define E. Las expresiones se construyen de la manera siguiente:
Un operando puede ser:
• Una variable, que pertenece o se representa por medio de un lenguaje.
• Un símbolo, que se representa a sí mismo como un conjunto de cadenas, i, e, a
representa el lenguaje {a}.
• ℰ, representado por {ℰ} (un lenguaje).
• θ, representando a θ (el lenguaje vacío).

P á g i n a | 14
Tipos de datos
Requisitos del software y hardware:
Requisitos de Software:
 Windows 10 (8u51 y superiores).
 Windows 8.x (escritorio).
 Windows 7 SP1.
 Windows Vista SP2.
 Windows Server 2008 R2 SP1 (64 bits).
 Windows Server 2012 y 2012 R2 (64 bits).
 Exploradores: Internet Explorer 9 y superior, Firefox.

P á g i n a | 15
Requisitos de Hardware:
 RAM: 128 MB.
 Espacio en disco: 124 MB para JRE; 2 MB para Java Update. • Procesador: Mínimo
Pentium 2 a 266 MHz.
Formulario Principal
Figura 5.- Analizador Semántico

P á g i n a | 16
o Código fuente
package analizadorsintactico;
import java.awt.Color;
import javax.swing.JOptionPane;
public class InterfazCodigo extends javax.swing.JFrame {
LogicaAnalizadorSemantico Operaciones = new LogicaAnalizadorSemantico();
public InterfazCodigo() {
getContentPane().setBackground(Color.orange);
initComponents();
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
jScrollPane1 = new javax.swing.JScrollPane();
Lugar_Codigo = new javax.swing.JTextArea();
EjecutarAD = new javax.swing.JButton();
jScrollPane2 = new javax.swing.JScrollPane();
Mostar_Operaciones = new javax.swing.JTextArea();
EjecutarOperaciones = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();

P á g i n a | 17
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setBackground(new java.awt.Color(255, 153, 51));
Lugar_Codigo.setColumns(20);
Lugar_Codigo.setFont(new java.awt.Font("Consolas", 0, 14)); // NOI18N
Lugar_Codigo.setForeground(new java.awt.Color(0, 51, 102));
Lugar_Codigo.setRows(5);
jScrollPane1.setViewportView(Lugar_Codigo);
EjecutarAD.setBackground(new java.awt.Color(255, 255, 255));
EjecutarAD.setFont(new java.awt.Font("Consolas", 1, 14)); // NOI18N
EjecutarAD.setText("Analizar");
EjecutarAD.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
EjecutarADActionPerformed(evt);
});
Mostar_Operaciones.setColumns(20);
Mostar_Operaciones.setFont(new java.awt.Font("Consolas", 0, 14)); // NOI18N
Mostar_Operaciones.setRows(5);
Mostar_Operaciones.setEnabled(false);
jScrollPane2.setViewportView(Mostar_Operaciones);
EjecutarOperaciones.setBackground(new java.awt.Color(255, 255, 255));
EjecutarOperaciones.setFont(new java.awt.Font("Consolas", 1, 14)); // NOI18N
EjecutarOperaciones.setText("Ejecutar");
P á g i n a | 18
EjecutarOperaciones.setEnabled(false);
EjecutarOperaciones.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
EjecutarOperacionesActionPerformed(evt);
});
jLabel1.setFont(new java.awt.Font("Consolas", 1, 36)); // NOI18N
jLabel1.setForeground(new java.awt.Color(0, 0, 153));
jLabel1.setText("Analizador Semántico");
jLabel2.setText("Declaración de variables");
jLabel4.setText("Ingresar expresión");
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 409,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(116, 116, 116))

P á g i n a | 19
.addGroup(layout.createSequentialGroup()
.addGap(21, 21, 21)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(55, 55, 55)
.addComponent(EjecutarAD, javax.swing.GroupLayout.PREFERRED_SIZE, 167,
.addGap(148, 148, 148)
.addComponent(EjecutarOperaciones,
javax.swing.GroupLayout.PREFERRED_SIZE, 161,
.addGap(68, 68, 68))
.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 290,
.addGap(18, 18, 18)
javax.swing.GroupLayout.PREFERRED_SIZE)))
.addContainerGap(25, Short.MAX_VALUE))
.addGap(76, 76, 76)
.addComponent(jLabel2)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
P á g i n a | 20
.addGap(303, 303, 303))
.addGap(96, 96, 96))))
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addContainerGap()
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 78,
.addGap(2, 2, 2)
.addComponent(jLabel3))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jLabel4))))
P á g i n a | 21
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING,
false)
.addComponent(jScrollPane2)
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELIN
E)
.addComponent(EjecutarAD)
.addComponent(EjecutarOperaciones))
.addContainerGap(36, Short.MAX_VALUE))
);
pack();
}// </editor-fold>
private void EjecutarADActionPerformed(java.awt.event.ActionEvent evt) {
if (Operaciones.separarCodigo(Lugar_Codigo.getText()) == "") {
Mostar_Operaciones.setEnabled(true);
EjecutarOperaciones.setEnabled(true);
Lugar_Codigo.setEnabled(false);
EjecutarAD.setEnabled(false);
} else {
JOptionPane.showMessageDialog(null,
Operaciones.separarCodigo(Lugar_Codigo.getText()));
}
P á g i n a | 22
}
private void EjecutarOperacionesActionPerformed(java.awt.event.ActionEvent evt) {
Operaciones.separarOperaciones(Mostar_Operaciones.getText());
Mostar_Operaciones.setEnabled(false);
EjecutarOperaciones.setEnabled(false);
Lugar_Codigo.setEnabled(true);
EjecutarAD.setEnabled(true);
public static void main(String args[]) {
/* Set the Nimbus look and feel */
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
/* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
* For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
} }
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(InterfazCodigo.class.getName()).log(java.util.logging.Level.S
EVERE, null, ex);
} catch (InstantiationException ex) {

P á g i n a | 23
EVERE, null, ex);
} catch (IllegalAccessException ex) {
EVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
EVERE, null, ex);
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new InterfazCodigo().setVisible(true);
});
private javax.swing.JButton EjecutarAD;
private javax.swing.JButton EjecutarOperaciones;
private javax.swing.JTextArea Lugar_Codigo;
private javax.swing.JTextArea Mostar_Operaciones;
private javax.swing.JLabel jLabel1;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JScrollPane jScrollPane2;

P á g i n a | 24
}
o Formulario de las operaciones.
package analizadorsintactico;
import java.util.ArrayList;
import javax.swing.JOptionPane;
public class LogicaAnalizadorSemantico {
private ArrayList<String> codigoParte = new ArrayList();
private ArrayList<String> operacionesCodigo = new ArrayList();
private ArrayList<String> errores = new ArrayList();
private ArrayList<String> varsInt = new ArrayList();
private ArrayList<String> varsString = new ArrayList();
private ArrayList<String> varsChar = new ArrayList();
private ArrayList<String> varsDouble = new ArrayList();
private ArrayList<String> varsFloat = new ArrayList();
private ArrayList<String> varsBoolean = new ArrayList();
private ArrayList<String> stringTipo = new ArrayList();
private ArrayList<Integer> intTipo = new ArrayList();
private ArrayList<char[]> charTipo = new ArrayList();
private ArrayList<Double> doubleTipo = new ArrayList();
private ArrayList<Float> floatTipo = new ArrayList();
private ArrayList<Boolean> booleanTipo = new ArrayList();

P á g i n a | 25
int caracter = 0;
public void Reset() {
codigoParte.clear();
errores.clear();
operacionesCodigo.clear();
varsInt.clear();
varsString.clear();
varsChar.clear();
varsDouble.clear();
varsFloat.clear();
varsBoolean.clear();
stringTipo.clear();
intTipo.clear();
charTipo.clear();
doubleTipo.clear();
floatTipo.clear();
booleanTipo.clear();
public String separarCodigo(String Texto) {
Reset();
boolean bandera = false;
String Codigo = "";
String LineasCodigo[] = Texto.split("[ \n]");
for (int i = 0; i < LineasCodigo.length; i++) {

P á g i n a | 26
switch (LineasCodigo[i]) {
case "int":
Codigo += LineasCodigo[i] + " ";
break;
case "string":
break;
case "char":
break;
case "boolean":
break;
case "float":
break;
case "double":
break;
default:
for (int j = 0; j < LineasCodigo[i].length(); j++) {
caracter = LineasCodigo[i].substring(j, j + 1).charAt(0);
if (caracter == 59) {
bandera = true;
}}
P á g i n a | 27
if (bandera) {
Codigo += LineasCodigo[i];
codigoParte.add(Codigo);
Codigo = "";
bandera = false;
} else {
}break;
}}
for (int i = 0; i < codigoParte.size(); i++) {
validarLinea(codigoParte.get(i)); }
if (varsInt.size() > 0) {
for (int j = 0; j < varsInt.size(); j++) {
if (varsString.contains(varsInt.get(j))) {
errores.add("Variable " + varsInt.get(j) + " ya sido declara en una variable string\n");
if (varsBoolean.contains(varsInt.get(j))) {
errores.add("Variable " + varsInt.get(j) + " ya sido declara en una variable boolean\
n");
if (varsChar.contains(varsInt.get(j))) {
errores.add("Variable " + varsInt.get(j) + " ya sido declara en una variable char\n");
if (varsFloat.contains(varsInt.get(j))) {
errores.add("Variable " + varsInt.get(j) + " ya sido declara en una variable float\n");

P á g i n a | 28
}
if (varsDouble.contains(varsInt.get(j))) {
errores.add("Variable " + varsInt.get(j) + " ya sido declara en una variable double\n");
} }}
String auxiliar = "";
for (int j = 0; j < errores.size(); j++) {
auxiliar += errores.get(j);
return auxiliar;
public boolean validarLinea(String Codigo) {
boolean Bandera = true;
String LineaCodigo[] = Codigo.split(" ");
for (int i = 0; i < LineaCodigo.length; i++) {
if (LineaCodigo[i].equals("int") && i == 0) {
for (int j = 1; j < LineaCodigo.length; j++) {
if (LineaCodigo[j].equals("string")) {
errores.add("Error, dos tipo de datos juntos: " + LineaCodigo[i] + " y " +
LineaCodigo[j] + "\n");
Bandera = false;
} else if (LineaCodigo[j].equals("char")) {
P á g i n a | 29
Bandera = false;
} else if (LineaCodigo[j].equals("boolena")) {
Bandera = false;
} else if (LineaCodigo[j].equals("float")) {
Bandera = false;
} else if (LineaCodigo[j].equals("double")) {
Bandera = false;
} else {
String Variable = "";
for (int k = 0; k < LineaCodigo[j].length(); k++) {
caracter = LineaCodigo[j].substring(k, k + 1).charAt(0);
if (caracter != 44 && caracter != 59) {
Variable += LineaCodigo[j].substring(k, k + 1);
} }
if (Variable == "") {
errores.add("Te falta declarar alguna variable\n");
Bandera = false;
} else {
varsInt.add(Variable);
P á g i n a | 30
intTipo.add(0);
} }}
} else if (LineaCodigo[i].equals("string") && i == 0) {
if (LineaCodigo[j].equals("int")) {
Bandera = false;
Bandera = false;
Bandera = false;
Bandera = false;
Bandera = false;
P á g i n a | 31
} else {
} }
Bandera = false;
} else {
varsString.add(Variable);
stringTipo.add("");
}} }
} else if (LineaCodigo[i].equals("char") && i == 0) {
Bandera = false;
} else if (LineaCodigo[j].equals("string")) {
Bandera = false;
P á g i n a | 32
Bandera = false;
Bandera = false;
Bandera = false;
} else {
} }
Bandera = false;
} else {
varsChar.add(Variable);
P á g i n a | 33
//TipoChar.add('s','2');
} } }
} else if (LineaCodigo[i].equals("boolean") && i == 0) {
Bandera = false;
Bandera = false;
Bandera = false;
Bandera = false;
Bandera = false;
P á g i n a | 34
} else {
} }
Bandera = false;
} else {
varsBoolean.add(Variable);
booleanTipo.add(true);
} } }
} else if (LineaCodigo[i].equals("float") && i == 0) {
Bandera = false;
Bandera = false;
P á g i n a | 35
Bandera = false;
Bandera = false;
errores.add("Error, dos tipo de datos juntos: " + LineaCodigo[i] + " y " + LineaCodigo[j] +
"\n");
Bandera = false;
} else {
} }
Bandera = false;
} else {
varsFloat.add(Variable);
floatTipo.add(0.0f);
P á g i n a | 36
}} }
} else if (LineaCodigo[i].equals("double") && i == 0) {
Bandera = false;
Bandera = false;
Bandera = false;
Bandera = false;
Bandera = false;
P á g i n a | 37
} else {
} }
Bandera = false;
} else {
varsDouble.add(Variable);
doubleTipo.add(0.0d);
}}}
} else if (i == 0) {
if (LineaCodigo[1].equals("=") && !LineaCodigo[2].equals(";")) {
if (varsInt.contains(LineaCodigo[0])) {
int indice = 0;
String valor = "";
for (int j = 0; j < varsInt.size(); j++) {
if (varsInt.get(j).equals(LineaCodigo[0])) {
indice = j;
}}
for (int k = 0; k < LineaCodigo[2].length(); k++) {

P á g i n a | 38
caracter = LineaCodigo[2].substring(k, k + 1).charAt(0);
if (caracter != 59) {
valor += LineaCodigo[2].substring(k, k + 1);
try {
intTipo.set(indice, Integer.parseInt(valor));
} catch (Exception ex) {
errores.add("Error: la variable " + LineaCodigo[0] + " no se le puede asignar el
valor " + valor + "\n");
Bandera = false;
} else if (varsString.contains(LineaCodigo[0])) {
int indice = 0;
String valor = "";
for (int j = 0; j < varsString.size(); j++) {
if (varsString.get(j).equals(LineaCodigo[0])) {
indice = j;

P á g i n a | 39
}}
try {
stringTipo.set(indice, valor);
Bandera = false;
} else if (varsChar.contains(LineaCodigo[0])) {
int indice = 0;
String valor = "";
for (int j = 0; j < varsChar.size(); j++) {
if (varsChar.get(j).equals(LineaCodigo[0])) {
indice = j;
try {

P á g i n a | 40
Bandera = false;
} else if (varsBoolean.contains(LineaCodigo[0])) {
int indice = 0;
String valor = "";
for (int j = 0; j < varsBoolean.size(); j++) {
if (varsBoolean.get(j).equals(LineaCodigo[0])) {
indice = j;
try {
booleanTipo.set(indice, Boolean.valueOf(valor));
Bandera = false;
}
P á g i n a | 41
} else if (varsDouble.contains(LineaCodigo[0])) {
int indice = 0;
String valor = "";
for (int j = 0; j < varsDouble.size(); j++) {
if (varsDouble.get(j).equals(LineaCodigo[0])) {
indice = j;
try {
doubleTipo.set(indice, Double.parseDouble(valor));
Bandera = false;
} else if (varsFloat.contains(LineaCodigo[0])) {
int indice = 0;
String valor = "";

P á g i n a | 42
for (int j = 0; j < varsFloat.size(); j++) {
if (varsFloat.get(j).equals(LineaCodigo[0])) {
indice = j;
try {
floatTipo.set(indice, Float.parseFloat(valor));
Bandera = false;
} else {
errores.add("La variable " + LineaCodigo[0] + " no ha sido declarada\n");
Bandera = false;
} else if (LineaCodigo[2].equals(";")) {
errores.add("Error en la variable: " + LineaCodigo[0] + " no hay ningun valor valor\
n");
P á g i n a | 43
Bandera = false;
} else {
errores.add("Error al asignar un valor a la variable " + LineaCodigo[0] + "\n");
Bandera = false;
}}} return Bandera;
public void separarOperaciones(String Texto) {
String LineasCodigo[] = Texto.split("[ \n]");
String Codigo = "";
boolean Auxiliar = false;
for (int i = 0; i < LineasCodigo.length; i++) {
for (int j = 0; j < LineasCodigo[i].length(); j++) {
caracter = LineasCodigo[i].substring(j, j + 1).charAt(0);
operacionesCodigo.add(Codigo);
Codigo = "";
} else {
Codigo += LineasCodigo[i].substring(j, j + 1);
if (Auxiliar) {
Auxiliar = false;
} else {
Codigo += " ";

P á g i n a | 44
}
if (i + 1 < LineasCodigo.length) {
for (int j = 0; j < LineasCodigo[i + 1].length(); j++) {
caracter = LineasCodigo[i + 1].substring(j, j + 1).charAt(0);
Auxiliar = true; }
} } }
for (int i = 0; i < operacionesCodigo.size(); i++) {
validarVariable(operacionesCodigo.get(i));
if (errores.isEmpty()) {
Operar(operacionesCodigo.get(i));
if (errores.isEmpty()) {
mostrarOperaciones(operacionesCodigo.get(i));
} else {
JOptionPane.showMessageDialog(null, auxiliar);
}
P á g i n a | 45
} else {
JOptionPane.showMessageDialog(null, auxiliar);
public void validarVariable(String codigo) {
String LineaCodigo[] = codigo.split(" ");
if (!LineaCodigo[i].equals("print") && !LineaCodigo[i].equals("=") && !
LineaCodigo[i].equals("+") && !LineaCodigo[i].equals("-") && !LineaCodigo[i].equals("/")
&& !LineaCodigo[i].equals("*") && !LineaCodigo[i].equals("^")) {
if (varsInt.contains(LineaCodigo[i])) {
} else if (varsString.contains(LineaCodigo[i])) {
} else if (varsChar.contains(LineaCodigo[i])) {
} else if (varsBoolean.contains(LineaCodigo[i])) {
} else if (varsDouble.contains(LineaCodigo[i])) {
} else if (varsFloat.contains(LineaCodigo[i])) {
} else {
P á g i n a | 46
errores.add("Error no ha sido declarada la siguiente variable: " + LineaCodigo[i] + "\n");
public void mostrarOperaciones(String codigo) {
if (LineaCodigo[0].equals("print")) {
JOptionPane.showMessageDialog(null, intTipo.get(varsInt.indexOf(LineaCodigo[1])));
stringTipo.get(varsString.indexOf(LineaCodigo[1])));
charTipo.get(varsChar.indexOf(LineaCodigo[1])));
booleanTipo.get(varsBoolean.indexOf(LineaCodigo[1])));
doubleTipo.get(varsDouble.indexOf(LineaCodigo[1])));
} else if (varsFloat.contains(LineaCodigo[1])) {
P á g i n a | 47
JOptionPane.showMessageDialog(null, floatTipo.get(varsFloat.indexOf(LineaCodigo[1])));
public void Operar(String codigo) {
if (!LineaCodigo[0].equals("print")) {
if (LineaCodigo[3].equals("+")) {
try {
int Total = 0;
if (i % 2 == 0) {
Total += intTipo.get(varsInt.indexOf(LineaCodigo[i]));
System.out.println("*");
intTipo.set(varsInt.indexOf(LineaCodigo[0]), Total);
errores.add("Error, variables no tienen el mismo tipo de dato\n");
} else if (LineaCodigo[3].equals("-")) {
P á g i n a | 48
try {
int Total = 0;
if (i % 2 == 0) {
if (i == 2) {
Total = intTipo.get(varsInt.indexOf(LineaCodigo[i]));
} else {
Total -= intTipo.get(varsInt.indexOf(LineaCodigo[i]));
} else if (LineaCodigo[3].equals("*")) {
try {
int Total = 0;
if (i % 2 == 0) {
if (i == 2) {
} else {
Total *= intTipo.get(varsInt.indexOf(LineaCodigo[i]));
}
P á g i n a | 49
}
} else if (LineaCodigo[3].equals("/")) {
try {
int Total = 0;
if (i % 2 == 0) {
if (i == 2) {
} else {
Total /= intTipo.get(varsInt.indexOf(LineaCodigo[i]));
} else if (LineaCodigo[3].equals("^")) {
try {
int Total = 0;
P á g i n a | 50
if (i % 2 == 0) {
if (i == 2) {
} else {
Total = (int) Math.pow(Total,
intTipo.get(varsInt.indexOf(LineaCodigo[i])));
try {
String Total = "";
if (i % 2 == 0) {
Total += stringTipo.get(varsString.indexOf(LineaCodigo[i])) + " ";
stringTipo.set(varsString.indexOf(LineaCodigo[0]), Total);
P á g i n a | 51
System.out.println("l");
System.out.println("s");
try {
double Total = 0;
if (i % 2 == 0) {
Total += doubleTipo.get(varsDouble.indexOf(LineaCodigo[i]));
doubleTipo.set(varsDouble.indexOf(LineaCodigo[0]), Total);
errores.add("Error las variables no tienen el mismo tipo de dato\n");
try {
double Total = 0;

P á g i n a | 52
if (i % 2 == 0) {
if (i == 2) {
Total = doubleTipo.get(varsDouble.indexOf(LineaCodigo[i]));
} else {
Total -= doubleTipo.get(varsDouble.indexOf(LineaCodigo[i]));
try {
double Total = 0;
if (i % 2 == 0) {
if (i == 2) {
} else {
Total *= doubleTipo.get(varsDouble.indexOf(LineaCodigo[i]));
P á g i n a | 53
try {
double Total = 0;
if (i % 2 == 0) {
if (i == 2) {
} else {
Total /= doubleTipo.get(varsDouble.indexOf(LineaCodigo[i]));
try {
double Total = 0;
if (i % 2 == 0) {
P á g i n a | 54
if (i == 2) {
} else {
Total = Math.pow(Total,
doubleTipo.get(varsDouble.indexOf(LineaCodigo[i])));
} else if (varsFloat.contains(LineaCodigo[0])) {//float
try {
float Total = 0;
if (i % 2 == 0) {
Total += floatTipo.get(varsFloat.indexOf(LineaCodigo[i]));
floatTipo.set(varsFloat.indexOf(LineaCodigo[0]), Total);

P á g i n a | 55
try {
float Total = 0;
if (i % 2 == 0) {
if (i == 2) {
Total = floatTipo.get(varsFloat.indexOf(LineaCodigo[i]));
} else {
Total -= floatTipo.get(varsFloat.indexOf(LineaCodigo[i]));
try {
float Total = 0;
if (i % 2 == 0) {
if (i == 2) {
P á g i n a | 56
} else {
Total *= floatTipo.get(varsFloat.indexOf(LineaCodigo[i]));
try {
float Total = 0;
if (i % 2 == 0) {
if (i == 2) {
} else {
Total /= floatTipo.get(varsFloat.indexOf(LineaCodigo[i]));
}
P á g i n a | 57
try {
float Total = 0;
if (i % 2 == 0) {
if (i == 2) {
} else {
Total = (float) Math.pow(Total,
floatTipo.get(varsFloat.indexOf(LineaCodigo[i])));
}
P á g i n a | 58
EJEMPLO DE EJECUCION DE LA PRÁCTICA
EJEMPLO 1
EJEMPLO 2
P á g i n a | 59
EJEMPLO 3
EJEMPLO 4
P á g i n a | 60
EJEMPLO 5
P á g i n a | 61
CONCLUSIÓN
El Analizador Semántico, como se ha podido notar durante el desarrollo de esta práctica e
investigativo, tiene una gran importancia dentro del proceso de la compilación de códigos en
cualquier lenguaje, ya que dé él depende la revisión del código en busca de errores
semánticos en dicho código y de esta manera se asegura una coherencia y un sentido valido
en el código según el lenguaje que esté escrito.
Además de esto, forma parte de un conjunto complejo de piezas que conforman el sistema de
un intérprete de códigos o compilador, donde las tareas de cada pieza son de suma
importancia, como también lo es la gramática correcta del lenguaje utilizado a interpretar, es
por esto que un análisis semántico debe ser acertado.
Como bien pudimos ver que el analizador semántico se compone de un conjunto de rutinas
independientes, llamadas por los analizadores morfológicos y sintácticos. El análisis
semántico utiliza como entrada el árbol sintáctico detectado por el análisis sintáctico para
comprobar restricciones de tipo y otras limitaciones semánticas y preparar la generación de
código. En compiladores de un solo paso, las llamadas a las rutinas semánticas se realizan
directamente desde el analizador sintáctico y son dichas rutinas las que llaman al generador
de código. El instrumento más utilizado para conseguirlo es la gramática de atributos. En ella
se utiliza la estructura jerárquica determinada por la fase de análisis sintáctico para identificar
los operadores y operadores de expresiones y proposiciones.

P á g i n a | 62
BIBLIOGRAFIAS
 John E. Hopcroft, Rajeev Motwani and Jeffrey D. Ullman (2001). Automata Theory,
Language and Computation. Addison-Wesley Publishing.
 Operadores y expresiones. (s. f.). Recuperado 23 de septiembre de 2021, de
https://www.ibm.com/docs/es/tivoli-monitoring/6.3.0?topic=languageoperators-
expressions
 BELLO, Andrés (1847): Gramática de la lengua castellana (destinada al uso de los
americanos). Con las notas de Rufino José Cuervo. Estudio y edición de R. Trujillo (2
vols.), Arco/Libros, Madrid, 1988.
 wikipedia . (0). analisis sintactico . 23 nov 2021 , de wikipedia Sitio web:
https://es.wikipedia.org/wiki/An%C3%A1lisis_sint%C3%A1ctico_(ling%C3%BC%
C3%ADstica)
 John E. Hopcroft, Rajeev Motwani and Jeffrey D. Ullman (2001). Automata Theory,
Language and Computation. Addison-Wesley Publishing.
 Operadores y expresiones. (s. f.). Recuperado 23 de septiembre de 2021, de
https://www.ibm.com/docs/es/tivoli-monitoring/6.3.0?topic=languageoperators-
expressions

Reporte de La Práctica 4

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Reporte de La Práctica 4

Cargado por

Copyright:

Formatos disponibles

Página|1

Tecnológico Nacional de México

Trabajo: Reporte de práctica 4

Carrera: Ingeniería en Sistemas Computacionales

Horario: 8:00 a.m. – 9:00 a.m.

Aviles Zapata Gloria Dayan 19320889

Bautista Celestino Alejandra 19320893

Cipriano Garcia Daniel 19321372

Lugar y fecha de entrega: Acapulco de Juárez, Gro A 03 de Junio del 2022

Clave de asignatura: SCD – 1015

Función del analizador léxico………………………………………………………….. 5

¿Qué es el análisis léxico? ………………………………………………………...…. 10

Funcionamiento del análisis léxico…………………………………………………… 11

Componentes léxicos, patrones y lexemas…………………………………………… 11

¿Qué es una constante? ……………………………………………………………… 11

¿Qué es una variable? ……………………………………………………………….. 12

¿Qué es un operando? ……………………………………………………………….. 13

¿Qué es un operador? ………………………………………………………………... 13

Descripción de los pasos o etapas para el desarrollo………………………………… 15

Ejemplos de ejecución de la práctica…………………………………………….…... 60

Figura 1.- Interacción entre el analizador léxico y el analizador sintáctico.....................5

Figura 2.- Árbol de análisis sintáctico..............................................................................7

Figura 3.- Fases de compilador….....................................................................................9

Figura 4.- Tipos de datos............................................................................................... 13

Figura 5.- Analizador Semántico................................................................................... 14

Figura 6.- Ejemplo 1. .....................................................................................................59

Figura 7.- Ejemplo 2. .....................................................................................................59

Figura 8.- Ejemplo 3.......................................................................................................60

Figura 9.- Ejemplo 4…...................................................................................................60

Figura 10.- Ejemplo 5……….........................................................................................61

Reporte de la práctica 4.- Analizador semántico

En esta investigación entenderemos que el análisis semántico no es más que la salida de un

el programa. El análisis semántico se trata de determinar el tipo de los resultados

errores posteriores. Un compilador que se detenga cuando encuentre el primer error no es

En el análisis semántico se detectan errores relacionados con la validez del programa. Se

diferentes partes de un programa que no son reflejadas en un análisis gramatical. El

árbol jerárquico con la información relativa a la organización de los tokens en la instrucción

que se está analizando.

se encuentra la cadena a analizar, reconocer subcadenas que correspondan a símbolos del

lenguaje y retornar los tokens correspondientes y sus atributos.

áreas, como, por ejemplo, a lenguajes de consulta y sistemas de recuperación de

información. En cada aplicación, el problema de fondo es la especificación y diseño de

FUNCIÓN DEL ANALIZADOR LÉXICO

El analizador léxico forma parte de la primera fase de un compilador. Un compilador es un

programa que lee un programa escrito en un lenguaje, el lenguaje fuente, y lo traduce a un

programa equivalente en otro lenguaje, el lenguaje objeto. El proceso para construir un

compilador se encuentra dividido en cuatro etapas:

 El análisis léxico: transforma el código fuente en tokens.

 El análisis sintáctico: construye un árbol sintáctico

 El análisis semántico: realiza el chequeo de tipos

 La generación de código: genera código de maquina

La función principal de los analizadores léxicos consiste en leer la secuencia de caracteres

analizador sintáctico para hacer el análisis.

Figura 1 Interacción entre el analizador léxico y el analizador sintáctico

 Eliminar los comentarios del programa.

 Eliminar espacios en blanco, tabuladores, retorno de carro, etc, y en general, todo

aquello que carezca de significado según la sintaxis del lenguaje.

 Reconocer los identificadores de usuario, números, palabras reservadas del lenguaje

debe de tratar con la tabla de símbolos).

error, dar información sobre donde se ha producido.

 Avisar de errores léxicos. Por ejemplo, si @ no pertenece al lenguaje, avisar de un

 Puede hacer funciones de preprocesador.

eliminar espacios en blanco, tabulaciones y caracteres de fin de línea.