Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Manual Completo de Programacion de Sistemas I
Manual Completo de Programacion de Sistemas I
SISTEMAS I
Programacin de Sistemas 1
Semestre: Sexto
Nm. Horas/semana: 4
Crditos: 8
Objetivos generales:
El alumno estar capacitado para disear, construir e
implementar de la manera ms eficiente los analizadores lxicos y
sintcticos de un compilador las caractersticas y funcionamiento
de cargadores, emsambladores y macroprocesadores.
Bibliografa Bsica:
COMPILADORES
Principios, tcnicas y herramientas
Aho, Sethi & Ullman
Ed. Addison-Wesley iberoamericana
MODERN COMPILER IMPLEMENTATION IN C
Basic techniques
Appel, Andrew W.
Ed. Cambridge
FUNDAMENTOS DE COMPILADORES
Cmo traducir al lenguaje de computadora
Lemone, Karen A.
Ed. CECSA
COMPILADORES
Conceptos fundamentales
Teufel, Schmidt & Teufel
Ed. Addison-Wesley iberoamericana
PLAN
DE
TRABAJO
MANUAL DE PROGRAMACIN DE
SISTEMAS I
1.
Datos Generales.
Materia:
2.
3.
Terica/Prctica
Horas de Clase por semana:
4 Hrs.
Horas de clase por semestre:
60 Hrs.
Carrera en que se imparte:
Ing. en Sist. Comp.
Semestre:
Sexto
Ubicacin de la materia.
A.
Ubicacin terica.
Se imparte en sexto semestre; sus antecedente son
las materias de Lenguajes y Autmatas y Admn.
De Archivos.
Materias paralelas: ninguna
Materias subsecuentes:
Programacin
de
Sistemas II
B.
Ubicacin practica.
Tipo de Alumnos:
diversos; algunos trabajan. Son
de clase baja-media-alta, ambos sexos.
Grupo: 20 alumnos por grupo promedio.
Horario: matutino
Recursos: saln austero en todo o con clima, Sala
Audiovisual, TV, Video, PC, Proy. De acetatos.
MANUAL DE PROGRAMACIN DE
SISTEMAS I
4.
Intelectual.
Que el alumno aprenda a
preparar exposiciones profesionales y exponer sus
ideas de manera clara y por escrito.
Intelectual.
Que el alumno aprenda a
pensar, razonar, analizar, sintetizar, resumir y
esquematizar.
Intelectual.
Que
el
alumno
realice
investigacin y a discutir lo investigado con otros.
Humano.
Que el alumno tenga un deseo
de superacin continua, espritu de profesionalismo,
calidad y excelencia.
Social.
Que el alumno aprenda a
convivir con diferentes grupos, con un espritu de
colaboracin y participacin.
Profesional.
Que el alumno identifique la
diferencia en el perfil de un Ingeniero en Sistemas
Computacionales en relacin con el resto de los
usuarios de computadoras.
Profesional.
Que
el
alumno
disee
herramientas (software de base) para la generacin
de nuevo conocimiento.
Metodologa de trabajo.
MANUAL DE PROGRAMACIN DE
SISTEMAS I
UNIDAD I
INTRODUCCIN
CONCEPTOS
PROGRAMACIN DE SISTEMAS: Conjunto de reglas para crear
soluciones a problemas computables. Conjunto de herramientas
que nos permiten crear software de base que son de utilidad para
interactuar con la mquina.
SOFTWARE DE
Cargador.
BASE:
Compilador,
Querys,
Sistema
Operativo,
LENGUAJES DE PROGRAMACIN
LENGUAJE DE PROGRAMACIN: Es la notacin formal para la
descripcin de algoritmos, basada en un conjunto de instrucciones en
alto nivel, que finalmente pasarn a bajo nivel para interactuar con el
hardware y generar herramientas de trabajo.
Los lenguajes son sistemas de comunicacin. Un lenguaje de
programacin consiste en todos los smbolos, caracteres y reglas de uso
que permiten a las personas "comunicarse" con las computadoras.
Existen por lo menos varios cientos de lenguajes y dialectos de
programacin diferentes. Algunos se crean para una aplicacin especial,
mientras que otros son herramientas de uso general ms flexibles que
son apropiadas para muchos tipos de aplicaciones. En todo caso los
lenguajes de programacin deben tener instrucciones que pertenecen a
las categoras ya familiares de entrada/salida, clculo/manipulacin de
textos, lgica/comparacin y almacenamiento/recuperacin.
MANUAL DE PROGRAMACIN DE
SISTEMAS I
ARITMETICOS
LENGUAJ E
LOGICOS
PASCAL
AND
NOT
OR
RELACIONALES
<
>
>
<
=
=
ASIGNACION
:=
DELIMITADORES
OPERACIONALES
PALABRAS
RESERVADAS
+,-,*,/,MOD
CICLOS
DECLARACION DE VARIABLES
DECLARACION DE CONSTANTES
MANUAL DE PROGRAMACIN DE
SISTEMAS I
MANUAL DE PROGRAMACIN DE
SISTEMAS I
MANUAL DE PROGRAMACIN DE
SISTEMAS I
ADA
ENSAMBLADOR
QUICKBASIC
BASIC
EUPHORIA
FORTRAN
PASCAL
Lenguajes funcionales
Los lenguajes funcionales se basan en el concepto de funcin, por tanto,
el objeto bsico y fundamental que manejamos son las funciones,
que se pueden considerar las principales estructuras de control
en este tipo de lenguajes.
La base fundamental para comprender este tipo de lenguajes consiste
en ver los programas y aplicaciones expresados a travs de
funciones y aplicacin entre funciones.
Las caractersticas fundamentales de estos lenguajes se exponen a
continuacin:
a. Utilizacin de funciones sobre elementos de primer orden.
b. Utilizacin de funciones polimrficas, es decir, aqullas cuyo
tipo devuelto depende del tipo de los argumentos.
MANUAL DE PROGRAMACIN DE
SISTEMAS I
ML
CAML
Haskell
Sheme
LISP
Lamda Clculo
Iswim
APL
FP
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Hope
Miranda
Eden
Gofer
Erlang
SmallTalk
PROLOG
LENGUAJES ESTRUCTURADOS
Los lenguajes estructurados incorporan una serie de
instrucciones que facilitan la construccin modular de los
programas as como correccin de errores y soporte de sistemas.
Esto facilita la comprensin del cdigo por cualquier otro
programador o analista y hace ms fcil la tarea de probar y
depurar los programas.
Adems poseen una abundante variedad de instrucciones que
facilitan el flujo o secuencia de los procedimientos o pasos que
debe seguir el programa para la realizacin de su objetivo.
ALGOL
ADA
COBOL
PASCAL
10
MANUAL DE PROGRAMACIN DE
SISTEMAS I
TRADUCTORES
Los traductores son programas que permiten pasar de un programa
fuente a un programa objeto.
En los lenguajes de bajo nivel los programas que permiten pasar de un
programa fuente a un programa objeto se llaman programas
ensambladores, mientras en los lenguajes de alto nivel estos programas
se denominan compiladores e intrpretes.
INTRPRETES
Un intrprete es un traductor que toma un programa fuente, lo traduce a
un programa objeto instruccin por instruccin, al mismo tiempo que
ejecuta el programa.
COMPILADORES
Los Compiladores son programas que traducen los programas fuentes a
programas objetos.
El compilador traduce sentencia a sentencia cada una de las
instrucciones del programa fuente a cdigo mquina y posteriormente
ejecuta el programa.
ESTRUCTURA DE UN COMPILADOR
11
MANUAL DE PROGRAMACIN DE
SISTEMAS I
12
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Fase de Anlisis:
En el llamado anlisis lexicogrfico o lxico, el compilador
revisa y controla que las "palabras" estn bien escritas y pertenezcan a
algn tipo de token (cadena) definido dentro del lenguaje, como por
ejemplo que sea algn tipo de palabra reservada, o si es el nombre de
una variable que este escrita de acuerdo a las pautas de definicin del
lenguaje. En esta etapa se crea la tabla de smbolos, la cual contiene las
variables y el tipo de dato al que pertenece, las constantes literales, el
nombre de funciones y los argumentos que reciben etc.
En el anlisis sintctico como su nombre lo indica se encarga de
revisar que los tokens estn ubicados y agrupados de acuerdo a la
definicin del lenguaje. Dicho de otra manera, que los tokens
pertenezcan a frases gramaticales validas, que el compilador utiliza para
sintetizar la salida. Por lo general las frases gramaticales son
representadas por estructuras jerrquicas, por medio de rboles de
anlisis sintctico. En esta etapa se completa la tabla de smbolos con la
dimensin de los identificadores y los atributos necesarios etc.
13
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Fase de Sntesis:
Etapa de generacin de cdigo intermedio, aunque algunos
compiladores no la tienen, es bueno saber de su existencia, en esta
etapa se lleva el cdigo del programa fuente a un cdigo interno para
poder trabajar mas fcilmente sobre l. Esta representacin interna
debe tener dos propiedades, primero debe ser fcil de representar y
segundo debe ser fcil de traducir al cdigo objeto.
En la etapa de optimizacin de cdigo, se busca obtener el
cdigo mas corto y rpido posible, utilizando distintos algoritmos de
optimizacin.
Etapa de generacin de cdigo, se lleva el cdigo intermedio
final a cdigo maquina o cdigo objeto, que por lo general consiste en
un cdigo maquina relocalizable o cdigo ensamblador. Se selecciona las
posiciones de memoria para los datos (variables) y se traduce cada una
de las instrucciones intermedias a una secuencia de instrucciones de
maquina puro.
La tabla de smbolos no es una etapa del proceso de
compilacin, sino que una tarea, una funcin que debe realizar el
proceso de compilacin. En ella se almacenan los identificadores que
aparecen en el cdigo fuente puro, como as tambin los atributos de los
mismos, su tipo, su mbito y en el caso de los procedimientos el nmero
de argumentos el tipo de los mismos etc. En otras palabras una tabla de
smbolos es una estructura de datos, que contiene un registro por cada
identificador, y sus atributos. La tabla de smbolo es accedida tanto para
escritura como parar lectura por todas las etapas. Detector de errores o
manejador de errores, al igual que la tabla de smbolos no es una etapa
del proceso de compilacin, si no que es una funcin, muy importante,
pues al ocurrir un error esta funcin debe tratar de alguna forma el error
para as seguir con el proceso de compilacin (la mayora de errores son
14
MANUAL DE PROGRAMACIN DE
SISTEMAS I
15
MANUAL DE PROGRAMACIN DE
SISTEMAS I
=
/ \
id1 +
/ \
id2 +
/ \
id3 tipo_ent
|
10
temp1= tipo_ent(10)
temp2= id3 * temp1
temp3= id2 + tem2
id1= temp3
Optimizacin de cdigo
El cdigo intermedio obtenido es
representado de una forma mas optima
y eficiente.
temp1= id3 * 10.0
id1= id2 + temp1
Generador de cdigo
Finalmente lleva el cdigo intermedio a un
cdigo objeto que en este
caso es un cdigo relocalizable o cdigo
ensamblador (tambin llamado cdigo no enlazado).
MOVF id3, R2
MULT #10.0, R2
MOVF id2, R1
ADDF R2, R1
MOVF R1, id1
Este el cdigo objeto obtenido que es enviado al modulo de ensamblado.
Para entender todo esto veamos un ejemplo utilizando como lenguaje en
este caso al popular lenguaje de programacin C creado por Kernighan
16
MANUAL DE PROGRAMACIN DE
SISTEMAS I
17
MANUAL DE PROGRAMACIN DE
SISTEMAS I
LC1:
Este cdigo ser analizado por l modulo de ensamblado, que lo llevara
a cdigo binario no enlazado, y lo enviara al modulo de enlazado. El
cdigo de salida enviado al modulo de enlazado es el
siguiente.
L�(7�.text�
@���� �
.............
.data�@�@�@�
.bss�@�@�€
Hola Mundo...!!!�%s�v�
UE�EPh�
v�.file��
ghmundo.c����.
UNIDAD II
ELEMENTOS DE LA PROGRAMACIN DE SISTEMAS
CARGADORES
La programacin de sistemas se refiere a la creacin de programas
cuya finalidad es servir a otros programas.
Entre los programas que se manejan en la programacin de
sistemas se encuentran: los sistemas operativos, los compiladores, los
manejadores de base de datos.
Un cargador es un programa que coloca en la memoria para su
ejecucin,
el programa
guardado
en
algn
dispositivo
de
almacenamiento secundario.
Dependiendo de la manera en que se manejan los procesos de
ligas y carga, podemos clasificar a los cargadores en: cargadores
iniciales, absolutos, con reubicacin y ligadores.
Cargadores Iniciales: son aquellos que indican ala PC la forma de
poner en memoria principal, unos datos almacenados en un
perifrico de memoria externa (cintas, discos, etc.) sirven para
cargar con la memoria pequeos programas que inician el
funcionamiento de la computadora.
18
MANUAL DE PROGRAMACIN DE
SISTEMAS I
19
MANUAL DE PROGRAMACIN DE
SISTEMAS I
ENSAMBLADORES
Que es ensamblador y para que sirve?
Cuando se empezaron a utilizar smbolos nemotcnicos, se
escribieron programas para traducir automticamente los programas
escritos en lenguaje ensamblador a lenguaje mquina. A estos
programas traductores se les llamo ensambladores.
La entrada para un ensamblador es un programa fuente escrito en
lenguaje ensamblador. La salida es un programa objeto, escrito en
lenguaje de mquina. El programa objeto incluye tambin la informacin
20
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Rapidez
Mayor control de la computadora
Independencia del lenguaje
La mayora de las computadoras pueden ensamblarlo
Dependencia de hardware
Mayor tiempo de codificacin
Comprensin mas profunda de la computadora
Errores mas frecuentes en el programa
Tipos de Ensambladores.
Aunque todos los ensambladores realizan bsicamente las mismas
tareas, podemos clasificarlos de acuerdo a caractersticas.
As podemos clasificarlos en:
Ensambladores Residentes.
21
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Macroensambladores.
Microensambladores.
22
MANUAL DE PROGRAMACIN DE
SISTEMAS I
23
MANUAL DE PROGRAMACIN DE
SISTEMAS I
24
MANUAL DE PROGRAMACIN DE
SISTEMAS I
MACROPROCESADORES
USOS DE UN MACROPROCESADOR
Con el fin de evitar al programador la tediosa repeticin de partes
idnticas de un programa, los ensambladores y compiladores cuentan
con macroprocesadores que permiten definir una abreviatura para
representar una parte de un programa y utilizar esa abreviatura cuantas
veces sea necesario.
Para utilizar una macro, primero hay que declararla. En la
declaracin se establece el nombre que se le dar a la macro y el
conjunto de instrucciones que representar.
El programador escribir el nombre de la macro en cada uno de los
lugares donde se requiera la aplicacin de las instrucciones por ella
representadas.
La declaracin se realiza una sola vez, pero la utilizacin o
invocacin a la macro (macrollamada) puede hacerse cuantas veces sea
necesario.
La utilizacin de macros posibilita la reduccin del tamao del
cdigo fuente, aunque el cdigo objeto tiende a ser mayor que cuando
se utilizan funciones.
Es tan comn el empleo de macroinstrucciones se les considera
como una extensin de los lenguajes. De manera similar se considera al
procesador de macroinstrucciones o macroprocesador como una
extensin del ensamblador o compilador utilizado.
El macroprocesador se encarga, en una primera pasada, de
registrar todas las declaraciones de macros y de rastrear el programa
fuente para detectar todas las macrollamadas. En cada lugar donde
encuentre una macrollamada, el macroprocesador har la sustitucin
por las instrucciones correspondientes. A este proceso de sustitucin se
le denomina expansin de la macro.
25
MANUAL DE PROGRAMACIN DE
SISTEMAS I
SISTEMAS OPERATIVOS
Es un programa que acta como intermedio entre el usuario y el
hardware de una PC y su propsito es proporcionar un entorno en el cual
el usuario pueda ejecutar sus programas.
El objetivo principal de un sistema operativo es, entonces, lograr
que el sistema de computacin se use de manera cmoda, y el objetivo
secundario es que el hardware del computador se emplee de manera
eficiente.
Un sistema Operativo es parte importante de casi cualquier
sistema de cmputo, el cual cuenta con y componentes bsicos:
hardware, Sistemas Operativos, programas de aplicacin y los usuarios.
El principal objetivo de un sistema operativo es proporcionar una
interfaz entre el equipo y los programas, para esto debe administrar los
recursos del sistema, de tal manera que su uso sea lo mas sencillo y
eficiente.
26
MANUAL DE PROGRAMACIN DE
SISTEMAS I
27
MANUAL DE PROGRAMACIN DE
SISTEMAS I
28
MANUAL DE PROGRAMACIN DE
SISTEMAS I
COMPILADORES
La necesidad de establecer comunicacin con dispositivos de
cmputo para un creciente nmero de usuarios ha obligado a construir
herramientas que permitan que esta comunicacin se realice de manera
ms efectiva y con menor consumo de tiempo.
Esto lo podemos apreciar desde finales de la dcada de los 50's,
cuando con el advenimiento de computadoras comerciales surge
tambin la necesidad de programarlas.
Se disearon lenguajes como FORTRAN y COBOL que permiten
realizar esta tarea de comunicacin al establecer una relacin entre los
problemas de los usuarios y lo que las mquinas eran capaces de
realizar.
Estos primeros lenguajes tambin vinieron acompaados de un
nuevo trmino: Compilador.
Se le atribuye a Grace Murray Hopper la acuacin de este trmino
y se refera al trabajo que estaba detrs de la programacin en aquellos
tiempos: exista una biblioteca de programas constituida de un conjunto
de rutinas, cada una de ellas probada individualmente; cuando se
necesitaba un programa, se elegan las rutinas necesarias de esa
biblioteca y se integraban para conformar el proceso que ejecutara la
computadora. Quin realizaba este trabajo de acopio de rutinas y de
integracin se le denominaba compilador, de ah que los nuevos
lenguajes tuviesen sus propios "compiladores" para la integracin del
proceso que programar representaba.
En nuestros das, el trmino an se conserva aunque con un
sentido ligeramente diferente al planteado por Hopper. Hoy en da, un
compilador es un traductor que facilita la comunicacin entre el
programador y la mquina, por medio de un proceso de transformacin.
Un compilador es un programa que lee las lneas escritas en un
lenguaje de programacin (como Pascal) y las traduce a otro que pueda
ejecutar la computadora. Los programas compilados se ejecutan ms
rpido que los interpretados, debido a que han sido completamente
traducidos a lenguaje de mquina y no necesitan compartir memoria
con el intrprete.
29
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Clasificacin de Compiladores
El programa compilador traduce las instrucciones en un lenguaje de
alto nivel a instrucciones que la computadora puede interpretar y
ejecutar. Para cada lenguaje de programacin se requiere un compilador
separado.
El compilador traduce todo el programa antes de ejecutarlo. Los
compiladores son, pues, programas de traduccin insertados en la
memoria por el sistema operativo para convertir programas de cmputo
en pulsaciones electrnicas ejecutables (lenguaje de mquina). Los
compiladores pueden ser de:
30
MANUAL DE PROGRAMACIN DE
SISTEMAS I
31
MANUAL DE PROGRAMACIN DE
SISTEMAS I
UNIDAD III
ANLISIS LXICO
EL ANALIZADOR LXICO
El analizador lxico lee los caracteres del programa fuente, y
verifica que correspondan a una secuencia lgica (identificador, palabra
reservada etc.). Esta secuencia de caracteres recibe el nombre
componente lxico o lexema.
FUNCIN DEL ANALIZADOR LXICO
32
MANUAL DE PROGRAMACIN DE
SISTEMAS I
33
MANUAL DE PROGRAMACIN DE
SISTEMAS I
34
MANUAL DE PROGRAMACIN DE
SISTEMAS I
a>b
Entonces
a=c+d:
FinEntonces:
pasara a ser Si a>b Entonces a=c+d: FinEntonces: en nuestra lista de
entrada.
Una vez que tenemos la lista de entrada limpia se procede a la
creacin de los tokens; para ello, se ha definido otro tipo de lista llamado
Tokens que contendr el nombre del token (cadena leda por la pantalla)
junto con el tipo al que pertenece.
La implementacin del analizador lxico responde al mtodo
general de programacin visto en teora, por lo tanto se manejan dos
punteros, uno al ltimo carcter ledo y otro al ltimo carcter aceptado
con lo cual podemos movernos por la lista de entrada en bsqueda del
siguiente token sin perder la posicin desde donde comenzamos la
presente bsqueda. Los tokens, o smbolos terminales de la gramtica,
han sido representados mediante dos tablas, una para los que van
acompaados de un parntesis y otra para los que no.
El motivo de esta separacin ha sido el trato distinto que se les ha
dado a ambos para no tener que distinguir, dentro de las rdenes que
lleva un parmetro, si entre el final de la orden y el parntesis que rodea
al parmetro hay o no espacios. As las ordenes Mira (id) y Mira(id) son
tratadas como el mismo token y toman el ``('' como parte de l.
Los smbolos separadores (espacios, ``:'', etc.) han sido recogidos
del mismo modo en otra tabla dado el trato distinto de los anteriores
que recibirn.
Con esta forma de recoger los tokens que reconoce este analizador
hemos conseguido no tener que realizar grandes modificaciones sobre
35
MANUAL DE PROGRAMACIN DE
SISTEMAS I
36
MANUAL DE PROGRAMACIN DE
SISTEMAS I
37
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Lexemas
ejemplo
pc-then
then
(t/T)(h/H)(e/E)(n/N)
pc-while
while
while
pc-write
write
write
pc-incdec
to
to
downto
downto
<
<
>
>
par-ab
par-cer
ident
Hola, A77aH,
pepe
lit-ent
34, 23442, 1
lit-real
34.0, 23.4e-5
lit-string
op-rel
38
MANUAL DE PROGRAMACIN DE
SISTEMAS I
39
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Son los posibles smbolos que puede aceptar un lenguaje los cuales
se pueden representar con un autmata. Conjunto de smbolos para
aceptar una palabra reservada.
Una expresin regular es una frmula para denotar "ciertos"
lenguajes. Advirtase que decimos lenguaje, no cadena de
caracteres. Una expresin regular nica denota un conjunto de
cadenas, es decir un lenguaje, no una simple cadena. Las expresiones
regulares se pueden usar para especificar unidades lxicas presentes
40
MANUAL DE PROGRAMACIN DE
SISTEMAS I
es
es
es
es
una
una
una
una
expresin
expresin
expresin
expresin
regular
regular
regular
regular
que
que
que
que
denota
denota
denota
denota
a los conjuntos R S.
al conjunto R.
a los conjuntos RS.
al conjunto R*, equivale
a)
TABLAS DE SMBOLOS
Es una estructura de datos que contiene un registro por cada
token o identificador que define los atributos de ellos mismos. La
estructura de datos permite encontrar rpidamente el registro para ser
almacenado o consultado por otras fases.
Cuando el anlisis lxico detecta un token en el programa fuente,
este se introduce e la tabla de smbolos, sin embargo, sus atributos no
pueden determinarse durante el anlisis lxico.
Por ejemplo, dada la siguiente instruccin:
41
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Var
inicial, velocidad: integer ;
Posicin
en
memoria
Token
Valor
;
integer
:
velocidad
,
inicial
Var
Delimitador
P. R. Int
S. Punt.
Id
Separador
Id
P. R. Var
Utilizado
por
42
MANUAL DE PROGRAMACIN DE
SISTEMAS I
UNIDAD IV
ANLISIS SINTCTICO
El objetivo fundamental del anlisis sintctico es "construir un
rbol sintctico" con la cadena de entrada (el "programa"), en la forma
de unidades lxicas que determina el analizador lxico, como se
muestra en la siguiente figura:
43
MANUAL DE PROGRAMACIN DE
SISTEMAS I
44
MANUAL DE PROGRAMACIN DE
SISTEMAS I
45
MANUAL DE PROGRAMACIN DE
SISTEMAS I
46
MANUAL DE PROGRAMACIN DE
SISTEMAS I
47
MANUAL DE PROGRAMACIN DE
SISTEMAS I
48
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Gramtica
Autmata
Detector
Gramtica Regular deterministico no
deterministico finito
Ejemplo
a*
+ Gramtica-lineal
Derecha
+
Gramtica-lineal
49
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Izquierda
Lenguaje libre
de contexto
+ Gramtica libre
de contexto
Autmata pushdown
no
deterministico
ab
Lenguaje sensible
al contexto
+Gramtica
Sensible al
contexto
Autmata LinealVinculada
abc
Lenguajes
Recursivos
Enumerables
+ Gramtica norestringida
Maquina de Turng
Cualquier
Funcin
Computable
Jerarqua de Chomsky.
En 1959, Noam Chomsky clasific las gramticas en cuatro tipos
de lenguajes y esta clasificacin es conocida como la jerarqua de
Chomsky, tal como se muestra en al Tabla 3.1, en la cual cada lenguaje
es descrito por el tipo de gramtica generado. Estos lenguajes sirven
como base para la clasificacin de lenguajes de programacin.
Los cuatro tipos son: lenguajes recursivamente enumerables,
lenguajes sensibles al contexto, lenguajes libres de contexto y lenguajes
regulares. Dichos lenguajes tambin se identifican como lenguajes de
tipo 0,1,2 y 3.
Las gramticas sensibles al contexto reciben el nombre de
gramticas de tipo 1, porque del lado izquierdo puede haber ms de un
elemento, lo que implica que un smbolo puede reemplazarse en el
contexto de otros.
Una gramtica es de tipo 1 si se exige que la longitud del miembro
derecho de toda regla de produccin sea mayor o igual que la longitud
del izquierdo. Con esto se impide que las cadenas que se obtengan en el
transcurso de la aplicacin de las reglas sean de longitud decreciente, y
se impide as mismo el caso extremo de que mediante una gramtica de
tipo1 puedan desaparecer cadenas de smbolo.
Gramtica y lenguaje
Reconocedor
Que genera
Autmatas lineal
TIPO 1
(Sensible al contexto)
50
MANUAL DE PROGRAMACIN DE
SISTEMAS I
de
Recursivamente Mquina
Enumerables
Turing
de
Sensibles
contexto
al Autmata
Lineal Acotado
Libres
contexto
de Autmatas de
Pila
Tipo Lenguajes
Autmatas
Finitos
y
3
Expresiones
Regulares
Los cuatro tipos de gramticas.
Lenguajes
Regulares
51
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Gramticas Ambiguas
Si una oracin en espaol tiene mas de un significado, se dice que es
ambigua. Con frecuencia tales oraciones pueden analizarse
sintcticamente en mas de una forma.
La oracin:
El tiempo vuela como una flecha.
Puede interpretarse tiempo como sustantivo, vuela como verbo y
una flecha, como una frase adverbial. Esta interpretacin es un
comentario acerca del rpido paso del tiempo. Sin embargo, si "tiempo"
se interpreta como adjetivo, "vuela" como sustantivo, "como" como un
verbo y flecha como un sujeto directo, la oracin se convertira en un
comentario acerca de la vida amorosa de alguna especie.
En forma similar, se asigna significado a las construcciones en los
lenguaje de programacin con base en sus sintaxis. Por consiguiente,
52
MANUAL DE PROGRAMACIN DE
SISTEMAS I
53
MANUAL DE PROGRAMACIN DE
SISTEMAS I
54
MANUAL DE PROGRAMACIN DE
SISTEMAS I
55
MANUAL DE PROGRAMACIN DE
SISTEMAS I
56
MANUAL DE PROGRAMACIN DE
SISTEMAS I
57
MANUAL DE PROGRAMACIN DE
SISTEMAS I
modo
de
ejemplo
considrese
la
siguiente
gramtica:
<lect> ::=READ(<lista_id)>
<lista_id> ::=id | <lista_id>,id
que definen la sintaxis de la proposicin READ del lenguaje PASCAL.
El procedimiento para <lect> es un analizador sintctico de
descenso recursivo examina primero los 2 siguientes componentes
lxicos de entrada buscando READ y (. Si se encuentran, entonces el
procedimiento para <lect> llama el procedimiento para <lista_id>. Si
ese procedimiento tiene xito, el procedimiento <lect>, examina el
siguiente componente lxico buscando un ). Si todas estas pruebas
tienen xito el procedimiento <lect> devuelve una indicacin de xito a
quien lo llama y avanza al prximo componente lxico que sigue a ). En
otro caso el procedimiento devuelve una indicacin de fallo.
El procedimiento es ligeramente ms complicado cuando hay varias
opciones definidas por la gramtica para un no terminal. En este caso el
procedimiento debe decidir que opcin intentar. Para la tcnica de
descenso recursivo, se debe poder decidir qu opcin utilizar
examinando el siguiente componente lxico de entrada. Hay otros
mtodos descendentes que eliminan este requisito, aunque no son tan
58
MANUAL DE PROGRAMACIN DE
SISTEMAS I
eficientes
como
el
descendente
recursivo.
59
MANUAL DE PROGRAMACIN DE
SISTEMAS I
60
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Sentencias
Sentencia Sentencias'
Sentencias |
Asignacin ;
Id := Expresin
Termino Expresin'
+ Termino Expresin' |
Factor Termino'
* Factor Termino' |
( Expresin )
|
|
Id
Literal
61
MANUAL DE PROGRAMACIN DE
SISTEMAS I
62
MANUAL DE PROGRAMACIN DE
SISTEMAS I
63
MANUAL DE PROGRAMACIN DE
SISTEMAS I
E TE
E TE
E E
T FT
T FT
T
T
F
E +TE
E
T
T *FT
F id
F(E)
Anlisis
Se analizar la cadena siguiente:
id + id * id $
Paso 1
Inicialmente la pila contiene el smbolo de inicio de la gramtica
precedido por el delimitador "$", as que tenemos en la pila a "$E". Y en
la entrada tenemos a la cadena completa.
Paso Pila
Entrada
Salida
1
$E
id + id * id
$
Paso 2
En la cima de la pila tenemos a "E" verificamos en la gramtica y
tenemos que es un no terminal, ocupamos la regla 3 del algoritmo, y
reemplazamos X = E por su produccin la cual es TE'. Introduciremos la
produccin en el orden inverso, y tendremos en la pila "$ E' T", y la
salida ser la produccin del no terminal "E".
Paso 3
En la cima de la pila tenemos a "T" verificamos en la gramtica y
tenemos que es un no terminal, ocupamos la regla 3 del algoritmo, y
reemplazamos X = T por su produccin la cual es FT'. Introduciremos la
64
MANUAL DE PROGRAMACIN DE
SISTEMAS I
65
MANUAL DE PROGRAMACIN DE
SISTEMAS I
66
MANUAL DE PROGRAMACIN DE
SISTEMAS I
produccin en el orden inverso, y tendremos en la pila "$ E'" "$ E' " y
la salida ser la produccin del no terminal " T' ".
Paso
Pila
Entrada
Salida
$E
id + id * id $
$ E' T
id + id * id $
E TE
$ E' T' F
id + id * id $
T FT
$ E' T' Id
id + id * id $
F id
$ E' T'
+ id * id $
$ E'
+ id * id $
$ E' T +
+ id * id $
E +TE
$ E' T
id * id $
$ E' T' F
id * id $
T FT
10
$ E' T' Id
id * id $
F id
11
$ E' T'
* id $
12
$ E' T' F *
* id $
13
$ E' T' F
id $
14
$ E' T' Id
id $
15
$ E' T'
16
$ E'
17
T *FT
F id
67
MANUAL DE PROGRAMACIN DE
SISTEMAS I
68
MANUAL DE PROGRAMACIN DE
SISTEMAS I
69
MANUAL DE PROGRAMACIN DE
SISTEMAS I
P[i,j] = 0
P[i,j] = 1
P[i,j] = 2
P[i,j] = 3
70
MANUAL DE PROGRAMACIN DE
SISTEMAS I
71
MANUAL DE PROGRAMACIN DE
SISTEMAS I
+ *
> =
>
> >
>
id
= <
<
<
<
<
= < <
<
<
> >
>
id
> >
>
Anlisis
Se analizar la cadena siguiente:
(x+y)
72
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Paso Pila
Relaci
R Token
n
<
( x+y)$
$(
<
x +y)$
$(x
>
y)$
$(E
y)$
$(E+
<
)$
$
(E+y
>
$
(E+T
>
$(E
$(E)
>
$
$
Anlisis Sintctico LR.
73
MANUAL DE PROGRAMACIN DE
SISTEMAS I
74
MANUAL DE PROGRAMACIN DE
SISTEMAS I
ET
TT*F
TF
F(E)
F id
Algoritmo
inicializar la pila al estado cero
agregar $ al final de la entrada
apuntar al primer smbolo de la entrada
repetir begin
sea s el estado de la cima de la pila y
a el smbolo de entrada actual
if accin [s,a] = desplazar # then
begin
meter a y despus # (el nuevo estado) en la pila
avanzar al siguiente smbolo de entrada
end
else if accin [s,a] = reducir A then
begin
sacar 2*| | smbolos de la pila
sea S el estado que ahora esta en la cima de la pila
meter a y despus ir_a[s,a] en la pila.
end
else if accin[s,a] = aceptar then
Return
else error()
end.
Matriz de precedencia resultante
75
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Anlisis
Inicializa la pila al estado cero, agregar el smbolo $ al final de la
cadena de entrada, paso 1:
id*(id+id)
Pila
Entrada
(1) 0
id*(id+id)
$
Acci
S a
n
0 id
id
d5
Accin
(
)
d4
d6
r2 d7
r4 r4
d5
r2
r4
Aceptar
r2
r4
r6
r6
d4
r6
8 2 3
r6
d5
d4
d5
d4
ir_a
E T F
1 2 3
9 3
1
0
8
d6
9
r1 d7
10
r3 r3
11
r5 r5
siguiente smbolo, paso 2:
d11
r1
r3
r5
r1
r3
r5
76
MANUAL DE PROGRAMACIN DE
SISTEMAS I
77
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Entrada
Accin
(1) 0
id*(id+id)$
S5
id
(2) 0 id 5
*(id+id)$
R6
(3) 0 F 3
*(id+id)$
R4
(4) 0 T 2
*(id+id)$
S7
(5) 0 T 2 * 7
(id+id)$
S4
78
MANUAL DE PROGRAMACIN DE
SISTEMAS I
(6) 0 T 2 * 7 ( 4
id+id)$
S5
id
(7) 0 T 2 * 7 ( 4 id 5
+id)$
R6
(8) 0 T 2 * 7 ( 4 F 3
+id)$
R4
(9) 0 T 2 * 7 ( 4 T 2
+id)$
R2
(10) 0 T 2 * 7 ( 4 E 8
+id)$
S6
(11) 0 T 2 * 7 ( 4 E 8 + 6
)$
S5
id
(12) 0 T 2 * 7 ( 4 E 8 + 6 id
)$
5
R6
(13) 0 T 2 * 7 ( 4 E 8 + 6 F
)$
3
R4
(14) 0 T 2 * 7 ( 4 E 8 + 6 T
)$
9
R1
(15) 0 T 2 * 7 ( 4 E 8
)$
S11
(16) 0 T 2 * 7 ( 4 E 8 ) 11
R5
11
(17) 0 T 2 * 7 F 10
R3
10
(18) 0 T 2
R2
(19) 0 E 1
::= <estado>
::= IF <expr> THEN <estado>
::= <var> := <expr>
79
MANUAL DE PROGRAMACIN DE
SISTEMAS I
<expr>
<var>
IF
THEN
: + id
=
1
$
1
IF
IF <expr>
THEN
<var> :=
<expr> +
id
Tabla parcialmente llena para la gramatica dada.
El analizador sintctico utiliza la tpica pila S y la variable para el
smbolo entrante R. Aunque la estructura de la pila tiene una pequea
diferencia; en lugar de slo smbolos, se permitir que cadenas de
smbolos aparezcan en la pila. Las cadenas que aparezcan aqu sern
cabezas (las cuales terminan en un smbolo terminal) de las partes
derechas de las reglas. Por ejemplo, si la pila convencional en algn
momento contiene:
$ IF <expr> THEN IF <expr> THEN <var>:=
La pila podra verse como:
<var>:=
IF <expr> THEN
IF <expr> THEN
$
Note que todo lo que se hace es mantener juntos todos esos
smbolos; los cuales sabemos, debern ser reducidos al mismo tiempo.
Tambin se utilizar una variable U, sta estar vaca o contendr el
smbolo el cual la ltima frase ha sido reducida. As, si la cadena parcial
analizada hasta el momento es:
$ IF <expr> THEN IF <expr> THEN <var>:= <expr>
Entonces la pila se vera como arriba y <expr> estara en U.
80
MANUAL DE PROGRAMACIN DE
SISTEMAS I
81
MANUAL DE PROGRAMACIN DE
SISTEMAS I
$
$
$
IF
IF <expr>
THEN
<var> :=
<expr> +
id
IF
THEN
: + id
=
1
U=
R=
82
MANUAL DE PROGRAMACIN DE
SISTEMAS I
IF
THEN
1
1
: + id
=
1
1
1
1
1
IF
THEN
1
1
83
: + id
=
1
1
1
1
1
2 2 2
MANUAL DE PROGRAMACIN DE
SISTEMAS I
IF
$
84
MANUAL DE PROGRAMACIN DE
SISTEMAS I
+<var>
IF
THEN
$
1
IF
IF <expr>
1
THEN
<var> :=
<expr> +
4
4
id
2
2
Subrutina 4: IF U <> "<var>" then ERROR;
i := i - 1 ;
U = '<expr>'
: + id
=
1
3 1
1
3 1
4 1
2 2 2
IF
85
THEN
: + id
MANUAL DE PROGRAMACIN DE
SISTEMAS I
$
IF
IF <expr>
THEN
<var> :=
<expr> +
id
5
0
7
1
0
1
0
9
0
=
6 0 1
0 3 1
6 0 1
8
4
2
0
0
0
0
4
2
0 3 1
0 4 1
2 2 0
6:
7:
8:
9:
0:
86
MANUAL DE PROGRAMACIN DE
SISTEMAS I
87
MANUAL DE PROGRAMACIN DE
SISTEMAS I
}
public void archtoken_crear(String nombre_arch)
{
try {
Token1 = new FileOutputStream(nombre_arch);
Token2 = new DataOutputStream(Token1);
}
catch (IOException Ex)
{
System.err.println("No se creo el archivo correctamente");
}
}
public void archtoken_cerrar()
{
try {
Token1.close();
}
catch (IOException Ex)
{
System.err.println("No se cerro corectamente");
}
}
public void archtoken_escribe(String Mensaje)
{
try {
Token2.writeBytes(Mensaje+"\r");
Token1.write('\n');
}
catch(IOException Ex)
{
System.err.println("No se escribio correctamente");
}
}
public static void main(String args[]) throws ParseException
{
dtone3 analiza;
if(args.length == 0)
{
System.err.println("Uso del programa: \"java dtone3 archivo.ejm\"");
}
else
{
if(args.length == 1)
{
try
{
analiza = new dtone3 (new java.io.FileInputStream(args[0]));
analiza.archSint_crear("Sint.txt");
analiza.dtone();
analiza.archSint_cerrar();
}
catch (java.io.FileNotFoundException e)
88
MANUAL DE PROGRAMACIN DE
SISTEMAS I
{
System.out.println("No se pudo leer el archivo : " + args[0] + " ");
}
try
{
analiza = new dtone3 (new java.io.FileInputStream(args[0]));
analiza.archtoken_crear("Lex.txt");
analiza.input(analiza);
}
catch (java.io.FileNotFoundException e)
{
System.out.println("No se pudo leer el archivo : " + args[0] + " ");
}
}
else
{
System.out.println("Formato: java dtone3 nombrearchivo.ejm");
}
}
}
void EscribeSintactico(String mensaje)
{
archSint_escribe(mensaje);
}
}
PARSER_END(dtone3)
SKIP :
{
""
| "\t"
| "\n"
| "\r"
| "\f"
}
TOKEN : {
<paccess: ("a")("c")("c")("e")("s")("s")>
|
<pbool: ("b")("o")("o")("l")>
|
<pbreak: ("b")("r")("e")("a")("k")>
|
<pbyte: ("b")("y")("t")("e")>
|
<pcase: ("c")("a")("s")("e")>
|
<pclass: ("c")("l")("a")("s")("s")>
|
<pcontinue: ("c")("o")("n")("t")("i")("n")("u")("e")>
|
<pdefault: ("d")("e")("f")("a")("u")("l")("t")>
|
<pdelete: ("d")("e")("l")("e")("t")("e")>
|
<pdo: ("d")("o")>
|
<pelse: ("e")("l")("s")("e")>
|
<pexport: ("e")("x")("p")("o")("r")("t")>
|
<pfalse: ("f")("a")("l")("s")("e")>
|
<pfor: ("f")("o")("r")>
|
<pif: ("i")("f")>
|
<pint8: ("i")("n")("t")("8")>
89
MANUAL DE PROGRAMACIN DE
SISTEMAS I
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<pint16: ("i")("n")("t")("1")("6")>
<pint32: ("i")("n")("t")("3")("2")>
<pmodule: ("m")("o")("d")("u")("l")("e")>
<pnew: ("n")("e")("w")>
<pprivate: ("p")("r")("i")("v")("a")("t")("e")>
<preturn: ("r")("e")("t")("u")("r")("n")>
<pswitch: ("s")("w")("i")("t")("c")("h")>
<ptoken: ("t")("o")("k")("e")("n")>
<ptrue: ("t")("r")("u")("e")>
<puint8: ("u")("i")("n")("t")("8")>
<puint16: ("u")("i")("n")("t")("1")("6")>
<puint32: ("u")("i")("n")("t")("3")("2")>
<puses: ("u")("s")("e")("s")>
<pwhile: ("w")("h")("i")("l")("e")>
}
TOKEN :
{
<parenizq: "(">
| <parender: ")">
| <llaveizq: "{">
| <llaveder: "}">
| <corizq: "[">
| <corder: "]">
| <puncoma: ";">
| <dospuntos: ":">
| <coma: ",">
| <punto: ".">
| <comillas: "\"">
}
TOKEN :
{
<asigna: "=">
| <mayor: ">">
| <menor: "<">
| <menigual: "<=">
| <mayigual: ">=">
| <suma: "+">
| <resta: "-">
| <div: "/">
| <cambioizq: "<<">
| <cambioder: ">>">
| <producto: "*">
| <residuo: "%">
| <inc: "++">
| <dec: "--">
| <nobin: "~">
| <nolog: "!">
| <igual: "==">
| <dif: "!=">
| <ybin: "&">
| <obin: "|">
| <xor: "~|">
| <ylog: "&&">
90
MANUAL DE PROGRAMACIN DE
SISTEMAS I
| <olog: "||">
| <sumasigna: "+=">
| <restasigna: "-=">
| <prodasigna: "*=">
| <divasigna: "/=">
| <resasigna: "%=">
| <yasigna: "&=">
| <oasigna: "|=">
| <xorasigna: "~|=">
| <camizqasig: "<<=">
| <camderasig: ">>=">
}
TOKEN :
{
<dig: ["0"-"9"] >
| <letra: ["a" - "z","A" - "Z"] >
| <entero: (<dig>)+ >
| <real: ("-")? <entero> (".") <entero> >
| <ident: <letra> (<letra> | <dig> | "_")* >
| <cadena: <comillas> (~[ "'" ])* <comillas> >
| <c_noval: ("" |"^" | "" | "" | "" | "@" | "$") >
| <cad_noval:(<letra> | <dig> | "_")* (<c_noval>)+ (<letra> | <dig> | "_" | <c_noval>)* >
}
void input(dtone3 analiza) :
{
String mensaje;
}
{
(
)+
mensaje=Checa()
{
System.out.println(mensaje);
analiza.archtoken_escribe(mensaje);
}
<EOF>
}
String Checa() :
{ Token t; }
{
t=<paccess>
{ return ( t.image +"\t\t Palabra reservada access"); }
| t=<pbool>
{ return ( t.image +"\t\t Palabra reservada bool");}
| t=<pbreak>
{ return ( t.image +"\t\t Palabra reservada break");}
| t=<pbyte>
91
MANUAL DE PROGRAMACIN DE
SISTEMAS I
92
MANUAL DE PROGRAMACIN DE
SISTEMAS I
| t=<pswitch>
{ return ( t.image +"\t\t Palabra reservada switch");}
| t=<ptoken>
{ return ( t.image +"\t\t Palabra reservada token");}
| t=<ptrue>
{ return ( t.image +"\t\t Palabra reservada true");}
| t=<puint8>
{ return ( t.image +"\t\t Palabra reservada uint8");}
| t=<puint16>
{ return ( t.image +"\t\t Palabra reservada uint16");}
| t=<puint32>
{ return ( t.image +"\t\t Palabra reservada uint32");}
| t=<puses>
{ return ( t.image +"\t\t Palabra reservada uses");}
| t=<pwhile>
{ return ( t.image +"\t\t Palabra reservada while");}
| t=<puncoma>
{ return ( t.image +"\t\t Simbolo ;");}
| t=<dospuntos>
{ return ( t.image +"\t\t Simbolo :");}
| t=<coma>
{ return ( t.image +"\t\t Simbolo ,");}
| t=<punto>
{ return ( t.image +"\t\t Simbolo .");}
| t=<parenizq>
{ return ( t.image +"\t\t Operador (");}
| t=<parender>
{ return ( t.image +"\t\t Operador )");}
| t=<corizq>
{ return ( t.image +"\t\t Operador [");}
| t=<corder>
{ return ( t.image +"\t\t Operador ]");}
| t=<llaveizq>
{ return ( t.image +"\t\t Operador {");}
| t=<llaveder>
{ return ( t.image +"\t\t Operador }");}
| t=<asigna>
{ return ( t.image +"\t\t Operador = ");}
93
MANUAL DE PROGRAMACIN DE
SISTEMAS I
| t=<mayor>
{ return ( t.image +"\t\t Operador > ");}
| t=<menor>
{ return ( t.image +"\t\t Operador < ");}
| t=<menigual>
{ return ( t.image +"\t\t Operador <= ");}
| t=<mayigual>
{ return ( t.image +"\t\t Operador >= ");}
| t=<suma>
{ return ( t.image +"\t\t Operador + ");}
| t=<resta>
{ return ( t.image +"\t\t Operador - ");}
| t=<div>
{ return ( t.image +"\t\t Operador / ");}
| t=<producto>
{ return ( t.image +"\t\t Operador * ");}
| t=<residuo>
{ return ( t.image +"\t\t Operador % ");}
| t=<cambioizq>
{ return ( t.image +"\t\t Operador << ");}
| t=<cambioder>
{ return ( t.image +"\t\t Operador >> ");}
| t=<inc>
{ return ( t.image +"\t\t Operador ++ ");}
| t=<dec>
{ return ( t.image +"\t\t Operador -- ");}
| t=<nobin>
{ return ( t.image +"\t\t Operador ~ ");}
| t=<nolog>
{ return ( t.image +"\t\t Operador ! ");}
| t=<igual>
{ return ( t.image +"\t\t Operador == ");}
| t=<dif>
{ return ( t.image +"\t\t Operador != ");}
| t=<ybin>
{ return ( t.image +"\t\t Operador binario & ");}
| t=<obin>
94
MANUAL DE PROGRAMACIN DE
SISTEMAS I
95
MANUAL DE PROGRAMACIN DE
SISTEMAS I
| t=<c_noval>
{ return ( t.image +"\t\t Caracter no valido ");}
| t=<cad_noval>
{ return ( t.image +"\t\t Cadena no valida ");}
}
EJEMPLO DE ANALISIS SINTCTICO DEL LENGUAJE DTONE
Este es el cdigo en Java del Analizador Sintctico. Se describen las gramticas y se da
una breve descripcin de cada una de ellas.
Esta gramtica corresponde a la estructura general de todo el programa.
void dtone() : {}
{
try{
CABECERA() CUERPO()
}
catch(ParseException e)
{System.out.println("Error en el programa");
}
}
Esta es la gramtica que corresponde a la cabecera del programa. ste tiene que ser el primer comando
en todos los archivos. Identifica el archivo como cdigo del dtone.
void CABECERA() : {}
{try
{VERSION() LIBRERIAS()
}
catch(ParseException e) {
System.out.println("Error en la cabecera");
}
}
Esta es la gramtica que corresponde a la versin que va en la cabecera. La versin es muy til para
identificar la versin del compilador que este cdigo necesita.
void VERSION() : {}
{try
{<pdtone> <dig> <punto> <dig> <punto> <dig>
}
catch(ParseException e) {
System.out.println("Error en la version");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
96
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Esta es la gramtica que corresponde a las libreras, lo que se hace es que se listan las libreras que van a
ser llamadas para la ejecucin del programa.
void LIBRERIAS() : {}
{try
{(<puses> <comillas> <ident>("/" <ident>)* "/*" <comillas> <puncoma>)+
}
catch(ParseException e) {
System.out.println("Error en las librerias");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta es la gramtica en la cual se define el cuerpo del programa, en el se van a listar las instrucciones para
del programa.
void CUERPO() : {}
{try
{<pmodule> <ident> <llaveizq> DECLARA() (INSTRUC())+ <llaveder>
}
catch(ParseException e) {
System.out.println("Error en el cuerpo");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta es la gramtica para las declaraciones de variables que se van a utilizar en el programa.
void DECLARA() : {}
{try
{(D_VAR() | D_ARR() | D_CONST() | D_FUNCION() )*
}
catch(ParseException e) {
System.out.println("Error en las declaraciones");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta es la gramtica de la declaracin de variables.
void D_VAR() : {}
{try
{(DEC_VAR() | DECINI_VAR()) <puncoma>
}
catch(ParseException e) {
97
MANUAL DE PROGRAMACIN DE
SISTEMAS I
98
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta gramtica corresponde a la declaracin de una constante.
void D_CONST() : {}
{try
{<pdefine> <ident> <igual> (<entero>|<real>|<cadena>) <puncoma>
}
catch(ParseException e) {
System.out.println("Error en las declaracion de constante");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta gramtica corresponde a la declaracin de una funcin.
void D_FUNCION() : {}
{try
{TIPO() <ident> <parenizq> PARAM() <parender> <llaveizq> DECLARA() (INSTRUC())+ < llaveder >
}
catch(ParseException e) {
System.out.println("Error en la declaracion de la funcion");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta gramtica corresponde a la declaracin de parmetros del programa.
void PARAM() : {}
{try
{(DEC_VAR() | D_ARR()) (<coma> (DEC_VAR() | D_ARR() ) )*
}
catch(ParseException e) {
System.out.println("Error en los parametros");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
99
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Esta gramtica define las instrucciones que sern dadas para que el programa finalmente cumpla con las
ordenes que se le estn dando a travs de dichas instrucciones.
void INSTRUC() : {}
{try
{(ASIGNACION() | CICLO() | LLAM_FUNCION())
}
catch(ParseException e) {
System.out.println("Error en la instruccion");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta es la gramtica que define las asignaciones que podemos hacer en el lenguaje de programacin Dtone.
void ASIGNACION() : {}
{try
{IZQ() <asigna> DER() <puncoma>
}
catch(ParseException e) {
System.out.println("Error en la asignacion");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta es la gramtica que define la parte izquierda de las asignaciones que podemos hacer en el lenguaje de
programacin Dtone.
void IZQ() : {}
{try
{(<ident> | ARREGLO())
}
catch(ParseException e) {
System.out.println("Error en la parte izquierda de la asginacion");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta gramtica define al arreglo que puede ir en la parte izquierda de la asignacin, es decir al arreglo se le
va a asignar un valor.
void ARREGLO() : {}
{try
{<ident> <corizq> (<ident>|<entero>) (<coma> (<ident>|<entero>))* <corder>
100
MANUAL DE PROGRAMACIN DE
SISTEMAS I
}
catch(ParseException e) {
System.out.println("Error en el arreglo");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta es la gramtica que define la parte derecha de las asignaciones que podemos hacer en el lenguaje de
programacin Dtone.
void DER() : {}
{try
{(IZQ() | <cadena> | OPER_ARIT() | <entero> | <real>)
}
catch(ParseException e) {
System.out.println("Error en la parte derecha de la asignacion");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta gramtica corresponde a los operadores aritmticos que pueden ir en la parte derecha de una
asignacin.
void OPER_ARIT() : {}
{try
{(<ident> | <entero> | <real> | ARREGLO()) ARITOP() (<ident> | <entero> | <real> | ARREGLO())
}
catch(ParseException e) {
System.out.println("Error en la operacion");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta gramtica define el simbolo del operador aritmtico.
void ARITOP() : {}
{
(<suma> | <resta> | <div> | <producto> | <residuo>)
}
Esta gramtica define los ciclos que puede contener el cuerpo del programa en el lenguaje Dtone.
void CICLO() : {}
101
MANUAL DE PROGRAMACIN DE
SISTEMAS I
{
(GIF() | GWHILE() | GDO() | GFOR() | GCASE())
}
Esta es la gramtica del IF. Se evala la condicin, si produce una verdad, la verdadera trayectoria se
ejecuta, si no la falsa trayectoria (opcional) se ejecuta.
void GIF() : {}
{try
{<pif> <parenizq> OPER_REL() <parender> (INSTRUC())+
}
catch(ParseException e) {
System.out.println("Error en el IF");
}
}
Esta es la gramtica de los operadores relacionales que pueden ir dentro de alguna instruccin de control de
flujo.
void OPER_REL() : {}
{try
{(<ident> | <entero> | <real> | ARREGLO()) RELOP() (<ident> | <entero> | <real> | ARREGLO())
}
catch(ParseException e) {
System.out.println("Error en la operacion");
}
}
Esta es la gramtica de los smbolos de los operadores relacionales que pueden ir dentro de alguna
instruccin de control de flujo.
void RELOP() : {}
{
(<mayor> | <menor> | <menigual> | <mayigual> | <igual>)
}
Esta es la gramtica del ciclo WHILE. En este ciclo se ejecuta el cuerpo si la condicin es verdadera, en caso
contrario no.
void GWHILE() : {}
{try
{<pwhile> <parenizq> OPER_REL() <parender> <llaveizq> (INSTRUC())+ <llaveder>
}
catch(ParseException e) {
System.out.println("Error en el WHILE");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
102
MANUAL DE PROGRAMACIN DE
SISTEMAS I
Esta es la gramtica del ciclo DO. En este ciclo, el cuerpo es ejecutado mientras que la condicin sea cierta.
El cuerpo del ciclo se ejecuta por lo menos una vez.
void GDO() : {}
{try
{<pdo> <llaveizq> (INSTRUC())+ <llaveder> <pwhile> <parenizq> OPER_REL() <parender> <puncoma>
}
catch(ParseException e) {
System.out.println("Error en el DO");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta es la gramtica del ciclo FOR. El cual tiene una estructura muy parecida a la de C.
void GFOR() : {}
{try
{<pfor> <parenizq> (DECINI_VAR() | ASIGNACION()) <puncoma> OPER_REL() <puncoma>
ASIGNACION() <parender> <llaveizq> (INSTRUC())+ <llaveder>
}
catch(ParseException e) {
System.out.println("Error en el FOR");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
Esta gramtica corresponde al case. Esta estructura no requiere declaraciones de ruptura.
void GCASE() : {}
{try
{<pswitch> <parenizq> (INSTRUC())+ <parender> <llaveizq> (<pcase> <entero> <dospuntos> (INSTRUC())
+)+ (<pdefault> <dospuntos> (INSTRUC())+)? <llaveder>
}
catch(ParseException e) {
System.out.println("Error en el CASE");
Token t;
do{
t = getNextToken();}
while(t.kind != puncoma & t.kind != EOF);
}
}
La siguiente gramtica describe la llamada a una funcin en Dtone.
void LLAM_FUNCION() : {}
{try
103
MANUAL DE PROGRAMACIN DE
SISTEMAS I
104