2-12-2014

The Lex & Yacc

INVESTIGACIN

Integrantes del Equipo

Edgar Uriel Linares Delgado
-Daniel Alejandro Cataln Duran
-Higinio Alexander Solano Olivares

Qu es Lex and Yacc?

Lex es un programa para generar analizadores lxicos (en ingls scanners o lexers). Lex
se utiliza comnmente con el programa yacc que se utiliza para generar anlisis
sintctico. Lex, escrito originalmente por Eric Schmidt y Mike Lesk, es el analizador lxico
estndar en los sistemas Unix, y se incluye en el estndar de POSIX. Lex toma como
entrada una especificacin de analizador lxico y devuelve como salida el cdigo fuente
implementando el analizador lxico en C. Aunque tradicionalmente se trata de software
propietario, existen versiones libres de lex basadas en el cdigo original de AT&T en
sistemas como OpenSolaris y Plan 9 de los laboratorios Bell. Otra versin popular de
software libre de lex es Flex.
Lex - Un Analizador Lxico Generador ayuda a programas de escritura cuyo flujo de
control est dirigido por casos de expresiones regulares en el flujo de entrada. Es muy
adecuado para las transformaciones de tipo editor de script y para la segmentacin de
entrada en preparacin para una rutina de anlisis.Lex fuente es una tabla de expresiones
regulares y fragmentos de programas correspondientes. La tabla se traduce a un
programa que lee un flujo de entrada, copiarla en un flujo de salida y la particin de la
entrada en cadenas que concuerden con las expresiones dadas. Como se reconoce cada
una de esas cuerdas se ejecuta el fragmento de programa correspondiente. El
reconocimiento de las expresiones se lleva a cabo por un autmata finito determinista
generado por Lex. Los fragmentos de programas escritos por el usuario se ejecutan en el
orden en el que las expresiones regulares correspondientes se producen en el flujo de
entrada. Los programas de anlisis lxicos escritos con Lex aceptan especificaciones
ambiguas y elegir el partido ms largo posible en cada punto de entrada. Si es necesario,
preanlisis sustancial se realiza en la entrada, pero el flujo de entrada ser apoyado hasta
el final de la particin actual, por lo que el usuario tiene libertad general para manipularlo
Lex puede generar analizadores en C o Ratfor, un lenguaje que puede ser traducida
automticamente a Fortran porttil. Est disponible en el PDP-11 UNIX, Honeywell
SMOC, y los sistemas de IBM OS. Este manual, sin embargo, slo se discutir la
generacin de analizadores en C en el sistema UNIX, que es la nica forma admitida de
Lex por UNIX versin 7. Lex est diseado para simplificar la interfaz con Yacc, para los
que tienen acceso a este sistema compilador de compilador.

Yacc -Sin embargo, otro compilador compilador proporciona una herramienta general
para describir la entrada a un programa de ordenador. El usuario Yacc especifica las
estructuras de su entrada, junto con el cdigo que puede invocarse como se reconoce
cada dicha estructura. Yacc convierte tal especificacin en una subrutina que Han- agu- el
proceso de entrada; con frecuencia, es conveniente y apropiado que la mayor parte del
flujo de control en la aplicacin del usuario controlarlo mediante el subprograma.

Cmo funcionan?
El usuario proporciona el cdigo adicional ms all de la expresin que emparejan
necesita para completar sus tareas, posiblemente incluyendo cdigo escrito por
otros generadores. El programa que reconoce las expresiones se genera en el
lenguaje de programacin de propsito general empleado para fragmentos de
programas del usuario. De este modo, se proporciona un lenguaje de expresin de
alto nivel para escribir las expresiones de cadena que se ajustar mientras que la
libertad del usuario para escribir acciones es irreprochable. Esto evita obligando al
usuario que desee utilizar un lenguaje de manipulacin de cadenas para el anlisis
de entrada para escribir el procesamiento de programas para la misma y, a
menudo inapropiado lenguaje manejo de cadenas.
Lex no es un lenguaje completo, sino ms bien un generador que representa una
nueva caracterstica del lenguaje que se puede aadir a los diferentes lenguajes
de programacin, llamado `` lenguajes principales. '' As como lenguajes de
propsito general pueden producir cdigo a ejecutar en diferentes equipos
informticos, Lex puede escribir cdigo en diferentes lenguajes principales. El
lenguaje anfitrin se utiliza para el cdigo de salida generada por Lex y tambin
para los fragmentos de programas aadidos por el usuario. Lex convierte
expresiones y acciones (llamado origen en esta nota) en el host lenguaje de
propsito general del usuario; el programa generado se llama yylex. El programa
yylex reconocer expresiones en una corriente (llamada entrada en esta nota) y
llevar a cabo las acciones especificadas para cada expresin como se
detecte. Vase la Figura 1.
+ ------- +
Fuente -> | Lex | -> yylex
+ ------- +
+ ------- +
Entrada -> | yylex | -> Salida
+ ------- +
Una visin general de Lex
Figura 1

Para un ejemplo trivial, considere un programa para eliminar de la

entrada de todos los espacios en blanco o tabuladores en los extremos
de las lneas.
%%
[\ T] + $;

es todo lo que se requiere. El programa contiene un delimitador %% para marcar

el inicio de las reglas, y una regla. Esta norma contiene una expresin regular que
coincide con una o ms instancias de la caracteres en blanco o pestaa (escrito \ t
para la visibilidad, de acuerdo con la convencin de lenguaje C) justo antes de la
final de una lnea. Los parntesis indican la clase de caracteres hecha de blanco y
ficha; el + indica `` uno o ms ... ''; y los $ indica el final de la lnea `` '', como en
QED. No se especifica ninguna accin, por lo que el programa generado por Lex

(yylex) ignorar estos personajes. Todo lo dems se copiar. Para cambiar

cualquier cadena restante de espacios en blanco o tabuladores a un solo espacio
en blanco, aadir otra regla:
%%
[\ T] + $;
[\ T] + printf ("");

El autmata finito generado para esta fuente buscar ambas reglas a la vez,
observando a la terminacin de la serie de espacios en blanco o tabuladores si
hay o no un carcter de nueva lnea, y la ejecucin de la accin de la regla
deseada. La primera regla coincide con todas las cadenas de espacios en blanco
o tabuladores al final de las lneas, y la segunda regla todos los restantes cadenas
de espacios en blanco o tabuladores.
Lex puede ser utilizado solo para las transformaciones sencillas, o para el anlisis
y recopilacin de estadsticas en un nivel lxico. Lex tambin se puede utilizar con
un generador de analizador para llevar a cabo la fase de anlisis lxico; es
particularmente fcil para interactuar Lex y Yacc [3]. Programas Lex reconocen
expresiones slo regulares; Yacc escribe analizadores que aceptan una gran clase
de gramticas de contexto libre, pero requieren un analizador de nivel inferior para
reconocer tokens de entrada. Por lo tanto, una combinacin de Lex y Yacc es a
menudo apropiado. Cuando se utiliza como un preprocesador para un generador
de analizadores sintcticos ms tarde, Lex se utiliza para dividir el flujo de entrada,
y el generador de analizador asigna estructura a las piezas resultantes. El flujo de
control en este caso (que podra ser el primer medio de un compilador, por
ejemplo) se muestra en la Figura 2. Los programas adicionales, escrito por otros
generadores o con la mano, se puede aadir fcilmente a los programas escritos
por Lex.
gramtica lxica
reglas reglas
||
vv
+ + + --------- --------- +
| Lex | | Yacc |
+ + + --------- --------- +
||
vv
+ + + --------- --------- +
Entrada -> | yylex | -> | yyparse | -> entrada analizada
+ + + --------- --------- +

Lex con Yacc

Figura 2

Yacc usuarios se darn cuenta de que el nombre yylex es lo Yacc espera que su
analizador lxico para ser nombrado, por lo que el uso de este nombre por Lex
simplifica la interfaz.
Lex genera un autmata finito determinista de las expresiones regulares en la
fuente [4]. El autmata se interpreta, en lugar de compilado, con el fin de ahorrar

espacio. El resultado es todava un analizador rpido. En particular, el tiempo

empleado por un programa de Lex para reconocer y dividir un flujo de entrada es
proporcional a la longitud de la entrada. El nmero de Lex gobierna o la
complejidad de las normas no es importante en la determinacin de la velocidad, a
menos que las reglas que incluyen adelante contexto requieren una cantidad
significativa de volver a escanear. Lo que aumentar con el nmero y la
complejidad de las normas es el tamao de la autmata finito, y por lo tanto el
tamao del programa generado por Lex.
En el programa escrito por Lex, fragmentos del usuario (en representacin de las
acciones a realizar como se encuentre cada expresin regular) se recogen como
casos de un interruptor. El intrprete autmata dirige el flujo de control. Se
proporciona oportunidad para que el usuario inserte o bien declaraciones o
manifestaciones adicionales en la rutina que contiene las acciones, o para aadir
subrutinas, fuera de esta rutina de accin.
Lex no se limita a la fuente que puede ser interpretado sobre la base de una
bsqueda hacia delante carcter. Por ejemplo, si hay dos reglas, una que buscan
ab y otro para abcdefg, y la corriente de entrada es abcdefh, Lex reconocer ab y
dejar el puntero de entrada justo antes de cd. . . Dicha copia de seguridad es ms
costoso que el tratamiento de los idiomas ms simples.
Uso de Lex con Yacc
Lex y Yacc (un generador de analizadores sintcticos) suelen ser utilizados juntos.
Yacc utiliza una gramtica formal para analizar un flujo de entradas, algo que Lex
no puede hacer con expresiones regulares simples (Lex se limita a los autmatas
de estados finitos simples). Sin embargo, Yacc no puede leer en un flujo de
entradas simple - requiere una serie de smbolos. Lex se utiliza a menudo para
proporcionar a Yacc estos smbolos.

JLex: Un generador de analizador lxico para Java

Lex es un generador de analizador lxico para el sistema operativo UNIX, dirigida al
lenguaje de programacin C. Lex toma un archivo de especificacin de formato especial
que contiene los detalles de un analizador lxico. Esta herramienta crea un archivo fuente
C para el lexer tabla impulsada asociado.La utilidad JLex se basa en el modelo de
generador de analizador lxico Lex. JLex toma un archivo de especificacin similar al
aceptado por Lex, a continuacin, crea un archivo de cdigo fuente de Java para el
analizador lxico correspondiente.

JLex Especificaciones
Un archivo de entrada JLex est organizado en tres secciones, separadas por
directivas de dos por ciento (`` %% ''). Una especificacin adecuada JLex tiene el

siguiente formato.
cdigo de usuario
%%
Directivas JLex
%%
reglas de expresiones regulares
Las directivas `` %% '' distinguen secciones del archivo de entrada y se deben
colocar al principio de su lnea. El resto de la lnea que contiene el `%%` ''
directivas pueden ser descartados y no deben utilizarse para alojar declaraciones
o cdigo adicionales.
La seccin de cdigo de usuario - la primera seccin del archivo de especificacin
- se copia directamente en el archivo de salida resultante. Esta zona de la
especificacin proporciona espacio para la realizacin de clases de utilidad o tipos
de retorno.
La seccin de directivas JLex es la segunda parte del archivo de entrada. Aqu, las
definiciones de macros se dan y los nombres de estado se declaran.
La tercera seccin contiene las reglas de anlisis lxico, cada uno de los cuales
consta de tres partes: una lista opcional estado, una expresin regular, y una
accin.

El cdigo de usuario precede a la primera directiva de doble ciento (`` %% '). Este
cdigo se copia literalmente en el archivo de origen analizador lxico que JLex
salidas, en la parte superior del archivo. Por lo tanto, si el archivo de origen lexer
necesita comenzar con una declaracin del paquete o con la importacin de una
clase externa, la seccin de cdigo de usuario debe comenzar con la declaracin
correspondiente. Esta declaracin se copiar en la parte superior del archivo
fuente generada.

Reglamento Interno de Analizador Lxico Clase

El% {...}% directiva permite al usuario escribir cdigo Java para copiar en la clase
de anlisis lxico. Esta directiva se utiliza como sigue.
%{
<Code>
%}
Para ser reconocido correctamente, el% {y%} deben Estar situados en el principio
de una lnea. El cdigo Java especificado en <code> se copia entonces en la clase
de anlisis lxico creado por JLex.
clase yylex {
... <Code> ...
}
Esto permite que la declaracin de variables y funciones internas de la clase
analizador lxico generado. Los nombres de variables que comienzan
con yy deben ser evitados, ya que estos estn reservados para el uso de la clase
analizador lxico generado.
Los analizadores lxicos Generados
JLex tomar una especificacin adecuadamente formado y transformarlo en un
archivo de cdigo fuente de Java para el analizador lxico correspondiente.
El analayzer lxico generado reside en la clase yylex. Hay dos constructores a
esta clase, tanto requiere un solo argumento: la corriente de entrada a ser de
testigos. El flujo de entrada puede ser de tipo java.io.InputStream o java.io.Reader
(como StringReader ). Tenga en cuenta que la java.io.Reader constructor debe
utilizarse si est generando un lexer aceptar caracteres Unicode, como el JDK 1.0
java.io.InputStream clase no siempre leer Unicode correctamente.
La funcin de acceso al lxico es Yylex.yylex (), que devuelve el siguiente token
de la corriente de entrada. El tipo de retorno es Yytoken y la funcin se declara de
la siguiente manera.
clase yylex {...
pblica Yytoken yylex () {
...}
El usuario debe declarar el tipo de Yytoken y puede lograr esto convenientemente
en la primera seccin de la especificacin JLex, la seccin de cdigo de usuario.
Por ejemplo, para hacer Yylex.yylex () devuelve una envoltura alrededor de los
nmeros enteros, el usuario introduzca el siguiente cdigo en algn lugar anterior
al primer `` %% ''.
clase Yytoken {int campo; Yytoken (int f) = f {campo; }}
Luego, en las acciones lxicas, envueltos enteros seran devueltos, en algo as
como as.
{...

volver nueva Yytoken (0);

...}
Asimismo, en la seccin de cdigo de usuario, una clase podra definirse declarar
constantes que se corresponden a cada uno de los tipos de tokens.
cdigos de token de clase {...
CADENA public static final = 0;
INTEGER public static final = 1;
...}
Luego, en las acciones lxicas, estos cdigos simblicos podran ser devueltos.
{...
volver nueva Yytoken (CADENA);
...}
Estos son ejemplos simplificados; En uso real, uno probablemente definir una
clase de testigo que contiene ms informacin que un cdigo de nmero entero.
Estos ejemplos comienzan a ilustrar las tcnicas orientadas a objetos un usuario
puede emplear para definir un tipo de token arbitrariamente complejas para ser
devueltos por Yylex.yylex (). En particular, la herencia permite al usuario devolver
ms de un tipo de token. Si se necesitaba un tipo de token distinto para las
cadenas y enteros, el usuario podra hacer las siguientes declaraciones.
clase Yytoken {...}
clase IntegerToken extiende Yytoken {...}
clase StringToken extiende Yytoken {...}
A continuacin, el usuario puede volver tanto IntegerToken y StringToken tipos de
las acciones lxicas.
Los nombres de la clase de anlisis lxico, la funcin tokening, y el tipo que
devuelve cada uno pueden alterarse usando las directivas JLex.

PLY (Python Lex-Yacc)

Qu es un ply?
Es nada ms que una aplicacin lex / yacc sencillo
Qu es ply.lex?
Esto se refiere a la parte de anlisis lxico, encargado del anlisis de las
estructuras.
Qu es ply.yacc?
Es un mdulo el cual se encarga la creacin de un programa de anlisis.

PLY caractersticas esenciales.

-Se implementa completamente en Python.
-Se utiliza el anlisis sintctico LR que es razonablemente eficiente y muy
adecuado para gramticas ms grandes.
-PLY proporciona la mayor parte de las caractersticas estndar de lex / yacc
incluido el apoyo a las producciones vacas, las reglas de prioridad la recuperacin
de errores y soporte para gramticas ambiguas.
-PLY es sencillo de usar y proporciona muy extensa comprobacin de errores.
-PLY no trata de hacer nada ms ni menos que proporcionar la funcionalidad
bsica lex / yacc. En otras palabras, no es un marco de anlisis sintctico grande
o un componente de algn sistema ms grande.
-La versin original de la capa fue desarrollado en 2001 para su uso en un curso
de Introduccin a los compiladores, donde los estudiantes lo utilizaron para
construir un compilador para un lenguaje Pascal simple. Debido a su uso en un
entorno de enseanza, se realiz un gran trabajo para proporcionar una amplia
comprobacin de errores. Adems, se utiliz esta experiencia para resolver los
problemas comunes de usabilidad. Desde entonces una variedad de mejoras
incrementales se han hecho para el sistema.
PLY consta de dos mdulos separados; lex.py y yacc.py , ambos de los cuales se
encuentran en un paquete de Python llamada capa. El mdulo lex.py se utiliza
para romper texto de entrada en una coleccin de fichas especificadas por una
coleccin de reglas de expresiones regulares yacc.py se utiliza para reconocer la
sintaxis del lenguaje que se ha especificado en el formulario de una gramtica
libre de contexto. yacc.py utiliza anlisis sintctico LR y genera sus tablas de
anlisis sintctico utilizando el LALR ( 1 ) ( por defecto) o algoritmos de generacin
de tabla SLR .
Las dos herramientas tienen el propsito de trabajar juntos. Especficamente

lex.py ofrece una interfaz externa en forma de una funcin de seal () que
devuelve el siguiente token vlido en el flujo de entrada. yacc.py llama a esto
varias veces para recuperar tokens e invocar las reglas gramaticales. La salida de
yacc.py es a menudo un rbol de sintaxis abstracta (AST). Sin embargo, esto es
totalmente en manos del usuario. Si se desea yacc.py tambin se puede utilizar
para implementar simples compiladores de una pasada.
Al igual que su contraparte Unix, yacc.py proporciona la mayor parte de las
caractersticas que usted espera incluyendo una extensa revisin de errores,
validacin de la gramtica, el apoyo a las producciones vacas, fichas de error y
resolucin de ambigedad a travs de reglas de precedencia. De hecho, todo lo
que es posible en yacc tradicional debe ser apoyado en capas.
La principal diferencia entre yacc.py y yacc Unix es que yacc.py no implica un
proceso de generacin de cdigo independiente. En su lugar, PLY se basa en la
reflexin (introspeccin) para construir sus lexers y analizadores. A diferencia de
tradicional lex / yacc que requieren un archivo de entrada especial que se
convierte en un archivo fuente separado las especificaciones que figuran a PLY
son programas Python vlidos. Esto significa que no hay archivos de origen
adicionales ni hay un paso especial construccin del compilador (por ejemplo,
correr yacc para generar cdigo Python para el compilador). Desde la generacin
de las tablas de anlisis sintctico es relativamente caro, PLY almacena en cach
los resultados y las guarda en un archivo. Si no se detectan cambios en la fuente
de entrada, las tablas se leen de la memoria cach. De lo contrario, se regeneran.
Uso
PLY consta de dos archivos: lex.py y yacc.py. Estos estn contenidos
dentro del directorio ply que tambin puede ser utilizado como un paquete de
python.

Para utilizar capas, simplemente copia el directorio ply de su proyecto y de

importacin
lex y yacc del paquete de ply asociado. Por ejemplo:
importar ply.lex como lex
ply.yacc importacin como yacc
Como alternativa, puede copiar slo la lex.py archivos y yacc.py
individualmente y los utilizan como mdulos. Por ejemplo:
lex importacin
yacc importacin
El setup.py archivo se puede utilizar para instalar capas usando distutils.
El archivo doc / ply.html contiene documentacin completa sobre cmo usar
el sistema.

Como implementarlo.
Python Lex-Yacc
El extremo delantero del intrprete se implementa utilizando capas. No es de
extraar, PLY es una reescritura en Python de la Lex familiar y Yacc. Lex es un
analizador lxico responsable de tomar una secuencia de caracteres y dar salida a
una corriente de smbolos tales como enteros, cadenas, palabras clave y
smbolos. Por otro lado, Yacc es un analizador responsable de tomar una corriente
de tokens y reconociendo conjuntos de fichas como construcciones del lenguaje,
tales como declaraciones de variables, definicin de funciones, y si las
declaraciones.

CAPA fue desarrollado originalmente por David Beazley para una clase
introductoria sobre los compiladores de la Universidad de Chicago. Beazley

requiere sus estudiantes usan CAPA desarrollar un lenguaje Pascal-como simple

que incluy el anlisis lxico, el anlisis, la comprobacin de tipos, la inferencia de
tipos, de alcance anidada, y la generacin de cdigo en ensamblador para el
procesador SPARC. Esto llev CAPA a ser un proyecto maduro. Adems, PLY
cuenta con amplias instalaciones de prueba de errores para detectar errores
comunes. A diferencia de Yacc en C, que utiliza LALR-anlisis, PLY utiliza LRanlisis, que es razonablemente eficiente y muy adecuado para gramticas ms
grandes, pero restringe ligeramente los tipos de gramticas que puede ser
analizado correctamente. Adems, a diferencia de Lex y Yacc en C, PLY basa en
Python reflexin, por lo que no existen por separado Lex y Yacc archivos-todo est
en Python.

Python Lex
El primer paso para la implementacin de un intrprete es escribir la tokenizer
utilizando Python Lex; ver Listado Uno. Fichas se reconocen usando expresiones
regulares. Los pasos son sencillos:
1. Los nombres de todos los tipos de tokens vlidos se declaran como una lista de
cadenas con nombre fichas.
2. Las fichas que no requieren un procesamiento especial se declaran utilizando
variables de nivel de mdulo denominado t_TOKEN_TYPE donde TOKEN_TYPE
coincide con alguna cadena en la lista de "tokens". Cada una de estas variables
contiene una cadena de expresin regular que coincide con el smbolo
correspondiente (Python cuerdas primas se utilizan por lo general, ya que son la
forma ms conveniente de escribir cadenas de expresiones regulares).

3. Las fichas que requieren un procesamiento especial se declaran utilizando

funciones de nivel de mdulo que siguen la misma convencin de nombres. Cada
una de estas funciones tiene una cadena de documentacin que es una expresin
regular que coincide con el smbolo correspondiente. El orden de estas funciones
es importante ya que cada expresin regular se trat en orden. Por lo tanto, las
funciones con las expresiones regulares ms complejas (flotadores, por ejemplo)
deben venir antes de las funciones con las expresiones regulares complejas
menos (intercepciones, por ejemplo). Cada funcin recibe un valor de tipo
LexToken, lo modifica, y por lo general lo devuelve. A diferencia de Lex en C, que
utiliza los sindicatos, el valor devuelto tiene un atributo llamado "valor" que se
puede ajustar a un valor de cualquier tipo (incluso una instancia). Esta flexibilidad
es conveniente. Si ninguno se devuelve o si se encuentra sin retorno, el analizador
lxico ignora el token actual y pasa a la siguiente token. Esto puede ser usado
para implementar el control de espacios en blanco, pero un t_ignore variable de

nivel de mdulo llamado es ms eficiente para esta tarea. Una vez definidas las
reglas Tokenizer, lex.lex () se utiliza para construir el tokenizer. Un principal (por
ejemplo, si __name__ == '__main__' :) se incluye que pone a prueba la
funcionalidad del tokenizer mediante pruebas de regresin. Esta es una buena
prctica de programacin en Python, pero es casi imprescindible cuando se
escribe un idioma. (El cdigo fuente completo de principal est disponible
electrnicamente, vase "Centro de Recursos").

Python Yacc
El siguiente paso para la implementacin de un intrprete es escribir el analizador
utilizando Python Yacc; ver Listado Dos. Despus de importar la lista de fichas del
mdulo tokenizer escrito anteriormente, se definen una serie de funciones.
Ejemplo 1 muestra una tal funcin que reconoce una expresin en parntesis y
establece que el valor de toda la expresin es igual al valor de la expresin en el
parntesis. Cada funcin tiene una cadena de documentacin que contiene la
especificacin gramtica independiente del contexto apropiado (esta idea fue
tomada de SPARK kit de herramientas de John Aycock. Cada funcin tiene un
argumento nico, t, que es una secuencia de valores (empezando en el ndice 1)
que coinciden con los respectivos smbolos en la cadena de documentacin. Estos
valores son los mismos valores que se almacenaron en atributos t.value en el
tokenizer. El cuerpo de la funcin hace lo que el procesamiento es apropiado y
coloca el resultado en t [0].

Ejemplo:
# calclex.py
# tokenizer for a simple expression evaluator for
# numbers and +,-,*,/
import ply.lex as lex
# List of token names. This is always required
tokens = ( 'NUMBER', 'PLUS', 'MINUS', 'TIMES', 'DIVIDE', 'LPAREN', 'RPAREN',)
# Regular expression rules for simple tokens
t_PLUS = r'\+'
t_MINUS = r'-'
t_TIMES = r'\*'
t_DIVIDE = r'/'
t_LPAREN = r'\('
t_RPAREN = r'\)'

# A regular expression rule with some action code

def t_NUMBER(t):
r'\d+'
t.value = int(t.value)
return t
# Define a rule so we can track line numbers
def t_newline(t):
r'\n+'
t.lexer.lineno += len(t.value)
# A string containing ignored characters (spaces and tabs)
t_ignore = ' \t'
# Error handling rule
def t_error(t):
print "Illegal character '%s'" % t.value[0]
t.lexer.skip(1)
# Build the lexer
lexer = lex.lex()

Webgrafia

http://www.dabeaz.com/ply/ply.html
https://ng.techweb.com/authds/gateway?gateway=true&return=http%3A%2F%2Fw
ww.drdobbs.com%2Fweb-development%2Fprototyping-interpreters-using-pythonle%2F184405580
https://escompiladores.wordpress.com/2014/03/11/ply-una-implementacion-de-lexy-yacc-en-python/
http://www.gacetadelinux.com/es/lg/issue79/divakaran.html
https://code.google.com/p/ply/

http://www.drdobbs.com/web-development/prototyping-interpreters-using-pythonle/184405580
http://es.wikipedia.org/wiki/Lex_(inform%C3%A1tica)
http://translate.google.com.mx/translate?hl=es419&sl=en&tl=es&u=http%3A%2F%2Fdinosaur.compilertools.net%2F&sandbox=1
http://translate.google.com.mx/translate?hl=es419&sl=en&u=http://www.cs.princeton.edu/~appel/modern/java/JLex/current/manu
al.html&prev=search
http://www.cc.uah.es/ie/docencia/ProcesadoresDeLenguaje/2.3.JLex.pdf