TECNOLÓGICO NACIONAL DE MÉXICO

INSTITUTO TECNOLÓGICO DE TIJUANA

SUBDIRECCIÓN ACADÉMICA
DEPARTAMENTO DE SISTEMAS Y COMPUTACIÓN
PERIODO: Enero –junio 2018

Ing. Sistemas Computacionales

Lenguajes y Autómatas I

Serie:
5SC6B

Grupo:
B

Temas:
Autómatas Finitos, Expresiones Regulares y Analizador Léxico

Unidades:
II, III y IV

Alumno:
Meza Pineda José María
14212042

Maestro:

Estrada Erasmo

Fecha de entrega:

Tijuana, Baja California a 25 de Abril de 2018

Contenido
Introducción ............................................................................. 3
Autómatas Finitos ................................................................... 4
Autómatas finitos no determinísticos ...................................... 4
Autómatas finitos determinísticos ........................................... 5
Autómatas de las expresiones regulares ................................ 6
Expresiones Regulares ......................................................... 17
Tabla de expresiones regulares ............................................ 18
Analizador Léxico .................................................................. 22
Código ................................................................................... 23
Archivo de Texto ................................................................... 28
Corrida................................................................................... 29
Introducción

El analizador léxico es la primera fase de un compilador, lee caracteres de entrada

para formar componentes e identificarlos o clasificarlos y pasar la información de
los componentes al analizador sintáctico.

Un compilador es un programa informático que traduce un programa escrito en

un lenguaje de programación a otro lenguaje de programación, generando un
programa equivalente que la máquina será capaz de interpretar. Este proceso de
traducción se conoce como compilación.

El analizador léxico que incorporan la mayoría de los compiladores de los lenguajes

de programación realiza además funciones como eliminar espacios en blanco,
saltos de línea, tabuladores, ignorar comentarios, detección y recuperación de
errores. Los errores que un analizador léxico reconoce son símbolos no válidos o
no reconocidos por el léxico del lenguaje o que no forman parte de ningún
componente léxico.
Autómatas Finitos
Autómata finito (máquina de estado finito). Es un modelo computacional que realiza
cómputos en forma automática sobre una entrada para producir una salida.
Este modelo está conformado por un alfabeto, un conjunto de estados y un conjunto
de transiciones entre dichos estados. Su funcionamiento se basa en una función de
transición, que recibe a partir de un estado inicial una cadena de caracteres
pertenecientes al alfabeto (la entrada), y que va leyendo dicha cadena a medida
que el autómata se desplaza de un estado a otro, para finalmente detenerse en un
estado final o de aceptación, que representa la salida.

Autómatas finitos no determinísticos

Son autómatas de estados finitos que tienen la capacidad de estar en más de un
estado simultáneamente. No hay que considerar todos los casos en cada estado,
ya que permiten cero, una o más transiciones de salida de un estado para el mismo
símbolo del alfabeto de entrada.

Por ejemplo:

0,1

0 1
q0 q2 q3
Inicio
Autómatas finitos determinísticos
Un autómata finito determinista (AFD) es un autómata finito que además es un
sistema determinista, es decir, para cada estado en que se encuentre el autómata,
y en cualquier símbolo del alfabeto leído, existe siempre a lo más una transición
posible desde ese estado y con ese símbolo.

Un AFD costa de:

1. Un conjunto finito de estados, a menudo designado como Q.

2. Un conjunto finito de símbolos de entrada, a menudo designado como ∑
(sigma).
3. Una función de transición que toma como argumentos un estado y un símbolo
de entrada y devuelve un estado. La función de transición se designa
habitualmente como ᵟ o Δ (delta).
4. Un estado inicial, uno de los estados de Q.
5. Un conjunto de estados finales o de aceptación F. El conjunto F es un
subconjunto de Q
Autómatas de las expresiones regulares
Expresiones Regulares
Las expresiones regulares son una serie de caracteres que forman un patrón,
normalmente representativo de otro grupo de caracteres mayor, de tal forma que
podemos comparar el patrón con otro conjunto de caracteres para ver las
coincidencias.

Es un equivalente algebraico para un autómata.

Utilizado en muchos lugares como un lenguaje para describir patrones en texto que
son sencillos pero muy útiles.

Pueden definir exactamente los mismos lenguajes que los autómatas pueden
describir: Lenguajes regulares.
Tabla de expresiones regulares
Token E.R
Tipo_Dato jmtabla | jmraiz | jmrenglon Jmtabla, jmraiz,
| jmcolumna | jmborra |
jmbusca | jmnulo |
jmseleccion | jmcorto |
jmrepite | jmlong |
jmconstante | jmtecto |
jmmultiple | jmatributo |
jmenumerar | jmdiatiempo
| jmletra | jmcadena |
jmrandom | jmbyte |
jmbinario | jmentero |
jmbooleano | jmflotador |
jmdoble | jmimagen |
jmfoto | jmbol | jmcaracter
Bucles jmdo | jmforeach | jmpara |
jmencaso
Modif_acceso jmprivado | jmpublico |
jmprotegido | jmglobal
Espec_metodos jmvoid | jmoverride |
jmvirtual | jmabstracto |
jmnativo | jmestatico |
jmetiquet
Sal_bucle jmdetener | jmpara |
jmaltos | jmstop
Est_booleano jmfalso | jmverdadero |
jmreal | noreal
Cont_bloque jmcontinuar | jmavanzar |
jmseguir | jmadelantede
Lexema
jmrenglon, jmcolumna,
jmborra, jmbusca,
jmnulo, jmseleccion,
jmcorto, jmrepite, jmlong,
jmconstante, jmtecto,
jmmultiple, jmatributo,
jmenumerar,
jmdiatiempo, jmletra,
jmcadena, jmrandom,
jmbyte, jmbinario,
jmentero, jmbooleano,
jmflotador, jmdoble,
jmimagen, jmfoto jmbol |
jmcaracter
Jmdo, jmforeach,
jmpara,jmencaso
Jmprivado, jmpublico,
jmprotegido, jmglobal
jmvoid, jmoverride,
jmvirtual, jmabstracto,
jmnativo, jmestatico,
jmetiquet
Jmdetener, jmpara,
jmaltos, jmstop
Jmfalso, jmverdadero,
jmreal, noreal
Jmcontinuar, jmavanzar,
jmseguir, jmadelantede
Op_bool jmno | jmy | jmo Jmno,jmy, jmo
condicional Jmsi | jmnoo Jmsi, jmnoo
Alter_cond jmsino jmsino
Crea_obj Jmnuevo | jmnew Jmnuevo, jmnew
excepciones Jmfinalmente | jmthrow | Jmfinalmente, jmthrow,
jmexcepcion | jmintenta | jmexcepcion, jmintenta,
jmcatch | jmcopiar | jmcatch, jmcopiar,
jmdiccionario | jmdiccionario,
jmexponene jmexponene
sentencia jmswitch jmswitch
Bloque_sentencia jmcaso jmcaso
clase jmclase jmclase
referencia jmesto jmesto
Devuelve_valor jmregresar jmregresar
Asignar_prop Jmtenero | jmbteber Jmtenero, jmbteber
comentario jm// jm//
delimitador jm, | jmdelimitador | jmdel jm, jmdelimitador, jmdel
Fin_inst jm; jm;
Decla_interface jminter | jminterfaz Jminter, jminterfaz
Bloque_codigo jmporpordefecto jmporpordefecto
importar Jmimportar | jmimpo Jmimportar, jmimpo
mensaje Jmmensaje | jmmen Jmmensaje, jmmen
Propiedad_obj Jmpropiedad | jmprop Jmpropiedad, jmprop
Prop_mens Jmnom | jmnombre | Jmnom, jmnombre
jmvisible | jmcolor | jmfont | jmvisible, jmcolor, jmfont,
jmfuente | jmvianey jmfuente, jmvianey
evento Jmevento | jmevent Jmevento, jmevent
Tipo_evento Jmmouseclick | Jmmouseclick,
jmmouseenter | jmmouseenter,
jmmosepressed,
jmmosepressed |
jmmousereleased,
 jmmousereleased | jmtick |
jmbuttonclick |
jmkeypressed |
jmkeytyped |
jmkeyreleased
Function_matematica Jmatan | jmexp | jmlog |
jmlog10 | jmpow | jmsqrt |
jmavg | jmabs | jmsin |
jmcos | jmasin | jmacos
Estruc_datos Jmarreglo | jmmatriz |
jmstruct | jmlista | jmcola |
jmpila
hilos Jmresumen | jmscheduled
| jmjoin | jmhilo | jmdormir |
jmstarthilo | jmnotificacion | jmhilo, jmdormir,
jmslee
Manipulacion_datos Jmagrega | jmempujar |
jmlimpiar | jmpeek | jmpop
variable Jmtemporizador | Jmdelay
| jmciclo | jmsetup |
jmdigitalesc | jmdigitalleer | jmsetup, jmdigitalesc,
jmanalogesc |
jmanalogread |
jmdelaymicroseconds |
jmprin | jmlnhig | jmlow |
jmentrada | jmsalida |
jmpinmode | jmseria l |
jmdisplay
jmtick, jmbuttonclick,
jmkeypressed,
jmkeytyped,
jmkeyreleased
Jmatan, jmexp, jmlog,
jmlog10, jmpow, jmsqrt,
jmavg, jmabs, jmsin,
jmcos, jmasin, jmacos
Jmarreglo, jmmatriz,
jmstruct, jmlista, jmcola,
jmpila
Jmresumen,
jmscheduled, jmjoin,
jmstarthilo,
jmnotificacion, jmslee
jmagregar, jmempujar,
jmlimpiar, jmpeek, jmpop
Jmtemporizador,
Jmdelay, jmciclo,
jmdigitalleer,
jmanalogesc,
jmanalogread,
jmdelaymicroseconds,
jmprin, jmlnhig, jmlow,
jmentrada, jmsalida,
jmpinmode, jmserial,
jmdisplay
imprimir Jmimprimircad | jmlimpiar | Jmimprimircad,
jmleer | jmleercad | jmlimpiar, jmleer,
jmimprimir jmleercad, jmimprimir
Clase_prin Jmmain | jmenelmain Jmmain, jmenelmain
graficos Jmfill | jmgraphics | Jmfill,jmgraphics,jmunion
jmunion
funcion Jmfunction | jmfunciones Jmfunction,jmfunciones
metodo cdestructor | jmdes Cdestructor, jmdes
constante jmpi jmpi
Crea_alias jmalias jmalias
modificador jmvolatil jmvolatil
Operador_aritmetico +|-| /| *|^|% +, -, /, *, ^, %
Abre_parentesis ( (
Cierra_parentesis ) )
Abre_corchete [ [
Cierra_corchete ] ]
Abre_llave { {
Cierra_llave } }
Op_relacional < | > | == |=< | >= | dif <, >, ==, =<, >=, dif
asigacion -= -=
Analizador Léxico
La fase de rastreo (scanner), tiene las funciones de leer el programa fuente como
un archivo de caracteres y dividirlo en tokens. Los tokens son las palabras
reservadas de un lenguaje, secuencia de caracteres que representa una unidad de
información en el programa fuente. En cada caso un token representa un cierto
patrón de caracteres que el analizador léxico reconoce, o ajusta desde el inicio de
los caracteres de entrada. De tal manera es necesario generar un mecanismo
computacional que nos permita identificar el patrón de transición entre los
caracteres de entrada, generando tokens, que posteriormente serán clasificados.
Este mecanismo es posible crearlo a partir de un tipo específico de máquina de
estados llamado autómata finito.

Es la primera fase de un compilador. Su principal función consiste en leer la

secuencia de caracteres del programa fuente, carácter a carácter, y elaborar como
salida la secuencia de componentes léxicos que utiliza el analizador sintáctico.
Código
PARSER_BEGIN(AnalizadorLexicoMeza)

class AnalizadorLexicoMeza

public static void main(String[] args) throws ParseException

try

AnalizadorLexicoMeza analizador = new AnalizadorLexicoMeza(System.in);

analizador.Programa();

catch(ParseException e)

System.out.println(e.getMessage());

System.out.println("Error en analisis");

PARSER_END(AnalizadorLexicoMeza)

TOKEN:

<MAIN: "public static void main() ">{System.out.println("MAIN = "+image);}

<PROGRAMA: "Programa">{System.out.println("PROGRAMA = "+image);}

<IF: "i en">{System.out.println("IF = "+image);}

TOKEN:
{

<LPAREN: "(" >{System.out.println("Parentesis Derecho "+image);}

| <RPAREN: ")" >{System.out.println("Parentesis Izquierdo "+image);}

| <LBRACE: "{" >{System.out.println("Llave Derecha"+image);}

| <RBRACE: "}" >{System.out.println("Llave Izquierda"+image);}

| <LBRACKET: "[" >{System.out.println("Corchete Derecho"+image);}

| <RBRACKET: "]" >{System.out.println("Corchete Izquierdo"+image);}

| <SEMICOLON: ";" >{System.out.println("Punto y Coma"+image);}

| <COMMA: "," >{System.out.println("Coma"+image);}

| <DOT: "." >{System.out.println("Punto"+image);}

TOKEN:

<EQ: "==" >{System.out.println("Igual"+image);}

| <LE: "<=" >{System.out.println("Menor o Igual"+image);}

| <GE: ">=" >{System.out.println("Mayor o Igual"+image);}

| <NE: "!=" >{System.out.println("Diferente"+image);}

| <OR: "||" >{System.out.println("OR"+image);}

| <AND: "&&">{System.out.println("AND"+image);}

TOKEN:

<INT:"inum"|"idec"|"istr"|"ichr">{System.out.println("Entero "+image);}

| <NUMBER : (["0"-"9"])+ > {System.out.print("Numero"+image+"\r\n");}

| <IDENTIFIER : ["a"-"z","A"-"Z"](["a"-"z","A"-"Z","0"-"9","_"])*>
{System.out.print("Identificador "+image+"\r\n");}

| <CADENA : ["a"-"z","A"-"Z","0"-"9"](["a"-"z","A"-"Z","0"-
"9"])*>{System.out.print("Cadena"+image+"\r\n");}
}

TOKEN:

<TIPO_DATO:"jmtabla" | "jmraiz" | "jmrenglon" | "jmcolumna" | "jmborra" | "jmbusca" |

"jmnulo" | "jmseleccion" | "jmcorto" | "jmrepite" | "jmlong" | "jmconstante" | "jmtecto" |
"jmmultiple" | "jmatributo" | "jmenumerar" | "jmdiatiempo" | "jmletra" | "jmcadena" | "jmrandom" |
"jmbyte" | "jmbinario" | "jmentero" | "jmbooleano" | "jmflotador" | "jmdoble" | "jmimagen" |
"jmfoto" | "jmbol" | "jmcaracter">{System.out.println("Tipo de Dato "+image);}

| <BUCLES:"jmdo" | "jmforeach" | "jmpara" |

"jmencaso">{System.out.println("Bucle"+image);}

| <MODI_ACCESO:"jmprivado" | "jmpublico" | "jmprotegido" | "jmglobal">

{System.out.print("Modificador de Acceso"+image);}

| <ESPEC_METODOS:"jmvoid" | "jmoverride" | "jmvirtual" | "jmabstracto" | "jmnativo" |

"jmestatico" | "jmetiquet"> {System.out.print("Especificador de Modulos"+image);}

| <SAL_BUCLE:"jmdetener" | "jmpara" | "jmaltos" | "jmstop">{System.out.println("Salida de

Bucle"+image);}

| <EST_BOOL:"jmfalso" | "jmverdadero" | "jmreal" | "noreal">{System.out.println("Estado de

Booleano"+image);}

| <CONT_BLOQUE:"jmcontinuar" | "jmavanzar" | "jmseguir" |

"jmadelantede">{System.out.println("Contenido de Bloque"+image);}

| <OP_BOOL:"jmno" | "jmy" | "jmo">{System.out.println("Operacion Booleano"+image);}

| <CONDICIONAL:"Jmsi" | "jmnoo">{System.out.println("Condicional"+image);}

| <ALT_CONDI:"jmsino">{System.out.println("Alterno Condicional"+image);}

| <CREA_OBJ:"Jmnuevo" | "jmnew">{System.out.println("Creacion de Objeto"+image);}

| <EXEPCIONES:"Jmfinalmente" | "jmthrow" | "jmexcepcion" | "jmintenta" | "jmcatch" |

"jmcopiar" | "jmdiccionario" | "jmexponene">{System.out.println("Condicional"+image);}

| <SENTENCIA:"jmswitch">{System.out.println("Sentencia"+image);}

| <BLOQUE_SENT:"jmcaso">{System.out.println("Bloque de Sentencia"+image);}

| <CLASE:"jmclase">{System.out.println("Clase"+image);}

| <REFERENCIA:"jmesto">{System.out.println("Referencia"+image);}

| <DEVUELVE_VALOR:"jmregresar">{System.out.println("Devuelve Valor"+image);}
 | <ASIGNAR_PROP:"Jmtenero" | "jmbteber">{System.out.println("Asignar
Proporcion"+image);}

| <COMENTARIO:"jm//">{System.out.println("Comentario"+image);}

| <DELIMITADOR:"jm" | "jmdelimitador" | "jmdel">{System.out.println("Delimitador"+image);}

| <FIN_INSTANCIA:"jm;">{System.out.println("Fin de la Instacia"+image);}

| <DECLA_INTERFACE:"jminter" | "jminterfaz">{System.out.println("Declaracion de
Interface"+image);}

| <BLOQUE_CODIGO:"jmporpordefecto">{System.out.println("Bloque de Codigo por

Defecto"+image);}

| <IMPORTAR:"Jmimportar" | "jmimpo">{System.out.println("Importar"+image);}

| <MENSAJE:"Jmmensaje" | "jmmen">{System.out.println("Mensaje"+image);}

| <PROPI_OBJETO:"Jmpropiedad | jmprop">{System.out.println("Propiedades del

Objeto"+image);}

| <PROPI_MENS:"Jmnom" | "jmnombre" | "jmvisible" | "jmcolor" | "jmfont" | "jmfuente" |

"jmJOSE">{System.out.println("Propiedades del Mensaje"+image);}

| <EVENTO:"Jmevento | jmevent">{System.out.println("Evento"+image);}

| <TIPO_EVENTO:"Jmmouseclick" | "jmmouseenter" | "jmmosepressed" | "jmmousereleased"

| "jmtick" | "jmbuttonclick" | "jmkeypressed" | "jmkeytyped" |
"jmkeyreleased">{System.out.println("Tipo de Evento"+image);}

| <FUNCION_MATEMATICA:"Jmatan" | "jmexp" | "jmlog" | "jmlog10" | "jmpow" | "jmsqrt" |

"jmavg" | "jmabs" | "jmsin" | "jmcos" | "jmasin" | "jmacos">{System.out.println("Funcion
Matematica"+image);}

| <ESTRUC_DATOS:"Jmarreglo" | "jmmatriz" | "jmstruct" | "jmlista" | "jmcola" |

"jmpila">{System.out.println("Estructura de Datos"+image);}

| <HILOS:"Jmresumen" | "jmscheduled" | "jmjoin" | "jmhilo" | "jmdormir" | "jmstarthilo" |

"jmnotificacion" | "jmslee">{System.out.println("Hilos"+image);}

| <MAN_DATOS:"Jmagrega" | "jmempujar" | "jmlimpiar" | "jmpeek" |

"jmpop">{System.out.println("Manipulacion de Datos"+image);}

| <VARIABLE:"Jmtemporizador" | "Jmdelay" | "jmciclo" | "jmsetup" | "jmdigitalesc" |

"jmdigitalleer" | "jmanalogesc" | "jmanalogread" | "jmdelaymicroseconds" | "jmprin" | "jmlnhig" |
"jmlow" | "jmentrada" | "jmsalida" | "jmpinmode" | "jmserial" |
"jmdisplay">{System.out.println("Variable"+image);}

| <IMPRIMIR:"Jmimprimircad" | "jmlimpiar" | "jmleer" | "jmleercad" |

"jmimprimir">{System.out.println("Imprimir"+image);}

| <CLASE_PRIN:"Jmmain" | "jmenelmain">{System.out.println("Clase Principal"+image);}

| <GRAFICOS:"Jmfill" | "jmgraphics" | "jmunion">{System.out.println("Graficos"+image);}

| <FUNCION:"Jmfunction" | "jmfunciones">{System.out.println("Funcion"+image);}

| <METODO:"cdestructor" | "jmdes">{System.out.println("Metodo"+image);}

}
Archivo de Texto

jmtabla jmraiz jmrenglon jmcolumna jmborra jmbusca jmnulo jmseleccion jmcorto jmrepite jmlong
jmconstante jmtecto

jmmultiple jmatributo jmenumerar jmdiatiempo jmletra jmcadena

jmrandom jmbyte jmbinario jmentero jmbooleano jmflotador jmdoble jmimagen jmfoto jmbol
jmcaracter

jmdo jmforeach jmpara jmencaso

jmprivado jmpublico jmprotegido jmglobal

jmvoid jmoverride jmvirtual jmabstracto jmnativo jmestatico

jmexp jmlog jmlog10 jmpow jmsqrt jmavg jmabs jmsin jmcos jmasin jmacos

jmlimpiar jmleer jmleercad jmimprimir

Jmfill jmgraphics jmunion

Jmfinalmente jmthrow jmexcepcion jmintenta jmcatch jmcopiar jmdiccionario jmexponene

Jmmouseclick jmmouseenter jmmosepressed jmmousereleased jmtick jmbuttonclick jmkeypressed

jmkeytyped jmkeyreleased

Jmsi jmnoo

Jmatan jmexp jmlog jmlog10 jmpow jmsqrt jmavg jmabs jmsin jmcos jmasin jmacos
Corrida