INDICE

UNDAD 1............................................................................................................. 5
ntroduccin a la programacin de sistemas...............................................................5
1.1 Qu es y qu estudia la programacin de sistemas?.....................................5
1.2 Herramientas desarrolladas con la teora de programacin de sistemas............6
1.3 Lenguajes................................................................................................. 8
1.3.1 Lenguajes naturales............................................................................. 8
1.3.2 Lenguajes artificiales............................................................................ 9
1.3.3 Proceso de la comunicacin..................................................................9
1.4 Traductor y su estructura.......................................................................... 11
1.4.1 Ensambladores................................................................................. 11
1.4.2 Compiladores................................................................................... 12
1.4.3 Interpretes........................................................................................ 14
1.5 Generadores de cdigo para compiladores (compilador de compilador)...........14
UNDAD 2........................................................................................................... 16
ntroduccin al diseo de los lenguajes de programacin...........................................16
2.1 Visin del problema.................................................................................. 16
2.2 Consideraciones Preliminares...................................................................18
2.3 Objetivos y filosofas del diseo de los lenguajes de programacin.................19
2.4 Diseo detallado...................................................................................... 20
2.5 Caso de estudio...................................................................................... 20
UNDAD 3........................................................................................................... 21
Anlisis Lxico..................................................................................................... 21
3.1 ntroduccin a los Autmatas finitos y expresiones regulares.........................21
3.2 Analizador de lxico................................................................................. 21
3.3 Manejo de localidades temporales de memoria (buffers)...............................22
3.4 Creacin de tablas de smbolos.................................................................23
3.5 Manejo de errores lxicos......................................................................... 24
3.6 Generadores de cdigo lxico: Lex y Flex...................................................24
UNDAD 4........................................................................................................... 25
Anlisis sintctico................................................................................................. 25
4.1 ntroduccin a las Gramticas libres de contexto y rboles de derivacin.........25
4.2 Diagramas de sintaxis.............................................................................. 26
4.3 Precedencia de operadores.......................................................................26
4.4 Analizador sintctico................................................................................ 26
4.4.1 Analiador descendente !LL"...............................................................26
4.4.2 Analiador ascendente !L#$ LAL#.......................................................26
4.5 Administracin de tablas de smbolos.........................................................26
4.6 Manejo de errores sintcticos y su recuperacin..........................................26
4.7 Generadores de cdigo para analizadores sintcticos: Yacc, Bison.................26
UNDAD 5........................................................................................................... 26
Anlisis semntico................................................................................................ 26
5.1 Analizador semntico............................................................................... 26
5.2 Verificacin de tipos en expresiones...........................................................26
5.3 Conversin de tipos................................................................................. 26
5.4 Acciones agregadas en un analizador sintctico descendente (top-down)........26
5.5 Pila semntica en un analizador sintctico ascendente (bottom-up)................26
5.6 Administracin de la tabla de smbolos.......................................................26
5.7 Manejo de errores semnticos...................................................................26
UNDAD 6........................................................................................................... 26
Generacin de cdigo intermedio........................................................................... 26
6.1 Lenguajes intermedios.............................................................................. 27
6.2 Notaciones............................................................................................. 27
%.2.1 Infija................................................................................................ 27
%.2.2 Postfija............................................................................................. 27
%.2.3 Prefija.............................................................................................. 27
6.3 Representacin de cdigo intermedio.........................................................27
%.3.1 &otacin Polaca................................................................................ 27
%.3.2 Codigo P.......................................................................................... 27
%.3.3 'riplos.............................................................................................. 27
%.3.4 Cu(druplos....................................................................................... 27
6.4 Esquemas de generacin..........................................................................27
%.4.1 E)presiones...................................................................................... 27
%.4.2 *eclaracin de +ariables$ constantes...................................................27
%.4.3 Estatuto de asignacin.......................................................................27
%.4.4 Estatuto condicional........................................................................... 27
%.4., Estatuto de ciclos.............................................................................. 27
%.4.% Arreglos........................................................................................... 27
%.4.- .unciones........................................................................................ 27
UNDAD 7........................................................................................................... 27
Optimizacin........................................................................................................ 27
7.1 Tipos de optimizacin............................................................................... 27
-.1.1 Locales............................................................................................ 27
-.1.2 /ucles............................................................................................. 27
-.1.3 0lobales.......................................................................................... 27
-.1.4 *e mirilla.......................................................................................... 27
7.2 Costos................................................................................................... 27
-.2.1 Costo de ejecucin............................................................................ 27
-.2.2 Criterios para mejorar el cdigo...........................................................27
-.2.3 1erramientas para el an(lisis del flujo de datos......................................27
UNDAD 8........................................................................................................... 28
Generacin de cdigo objeto.................................................................................. 28
8.1 Lenguaje mquina................................................................................... 28
2.1.1 Caracter3sticas.................................................................................. 28
2.1.2 *ireccionamiento............................................................................... 28
8.2 Lenguaje ensamblador............................................................................. 28
2.2.1 Caracter3sticas.................................................................................. 28
2.2.2 Almacenamiento............................................................................... 28
8.3 Registros................................................................................................ 28
2.3.1 *istribucin...................................................................................... 28
2.3.2 Asignacin........................................................................................ 28
8.4 Administracin de memoria.......................................................................28
UNIDAD 1
Introduccin a la programacin de sistemas
1.1Qu es y qu estudia la programacin de sistemas?
QU ES?
Un sistema es un conjunto de componentes que interaccionan entre si para
lograr un objetivo comn. Las personas se comunican con el lenguaje, que es un
sistema muy desarrollado formado por palabras y smbolos que tienen significado
para el que habla y para quienes lo escuchan, lo mismo es para las computadoras
las cuales tienen sistemas y se comunican por medio de computadoras.
La programacin es el proceso de convertir las especificaciones a grandes
rasgos de los sistemas en instrucciones de maquina que produzcan los resultados
deseados.
QU ESTUDA?
El trabajo de un programador de sistemas es seleccionar, modificar y mantener
el complejo software del sistema operativo. Por lo tanto, los programadores de
sistemas desempean una funcin de apoyo al mantener el ambiente del software
del sistema operativo en el que trabajan los programadores de aplicaciones y los
operadores de las computadoras. Tambin participan en las decisiones relativas a
reducciones o ampliaciones de hardware y/o software. Programacin de Sistemas
Conceptos y Aplicaciones Se entiende por programacin de sistemas el conjunto
de programas necesario para que una computadora de una imagen coherente y
monoltica ante sus usuarios. Es un rea especializada dentro de las ciencias de la
computacin. As, mediante la programacin de sistemas, no solo se manejan las
computadoras por medio del lenguaje maquina (0 y 1) sino por otros sistemas
operativos, sin lo cual sera muy difcil la interaccin con la maquina.
En esta rea se estudia la teora de mquinas y su aplicacin en el diseo de
sistemas digitales y de arquitectura de computadoras. reas especficas: Sistemas
digitales para arquitecturas paralelas y control de procesos y sistemas
reconfigurables.
nteligencia artificial aplicada a trabajo cooperativo En las aplicaciones
cooperativas realizadas en el entorno Web, es viable hacer uso de las
herramientas de inteligencia artificial. Se estn diseando y construyendo
herramientas para elaborar un sistema sin costura que opere en Web con la
finalidad de proporcionar a un grupo de coautores el soporte necesario para
producir conjunta y simultneamente un mismo documento.
1.2Herramientas desarrolladas con la teora de programacin de sistemas.
Las herramientas de programacin, son aquellas que permiten realizar
aplicativos, programas, rutinas, utilitarios y sistemas para que la parte fsica del
computador u ordenador, funcione y pueda producir resultados.
Hoy en da existen mltiples herramientas de programacin en el mercado,
tanto para analistas expertos como para analistas inexpertos.
Las herramientas de programacin ms comunes del mercado, cuentan hoy
da con programas de depuracin o debugger, que son utilitarios que nos permiten
detectar los posibles errores en tiempo de ejecucin o corrida de rutinas y
programas.
Muchas herramientas de software que manipulan programas fuente realizan
primero algn tipo de anlisis. Algunos ejemplos de tales herramientas son:
Editores de estructuras4 Un editor de estructuras toma como entrada una
secuencia de rdenes para construir un programa fuente. El editor de estructuras
no slo realiza las funciones de creacin y modificacin de textos de un editor de
textos ordinario, sino que tambin analiza el texto del programa, imponiendo al
programa fuente una estructura jerrquica apropiada. De esa manera, el editor de
estructuras puede realizar tareas adicionales tiles para la preparacin de
programas. Por ejemplo, puede comprobar si la entrada est formada
correctamente, puede proporcionar palabras clave de manera automtica (por
ejemplo, cuando el usuario escribe while, el editor proporciona el correspondiente
do y le recuerda al usuario que entre las dos palabras debe ir un condicional) y
puede saltar desde un begin o un parntesis izquierdo hasta su correspondiente
end o parntesis derecho. Adems, la salida de tal editor suele ser similar a la
salida de la fase de anlisis de un compilador.
Impresoras est5ticas4 Una impresora esttica analiza un programa y lo
imprime de forma que la estructura del programa resulte claramente visible. Por
ejemplo, los comentarios pueden aparecer con un tipo de letra especial, y las
proposiciones pueden aparecer con una indentacin proporcional a la profundidad
de su anidamiento en la organizacin jerrquica de las proposiciones.
6erificadores est(ticos: Un verificador esttico lee un programa, lo analiza e
intenta descubrir errores potenciales sin ejecutar el programa. La parte de anlisis
a menudo es similar a la que se encuentra en los compiladores de optimizacin.
As, un verificador esttico puede detectar si hay partes de un programa que
nunca se podrn ejecutar o si cierta variable se usa antes de ser definida.
Adems, puede detectar errores de lgica, como intentar utilizar una variable real
como apuntador, empleando las tcnicas de verificacin de tipos.
Int5rpretes4 En lugar de producir un programa objeto como resultado de una
traduccin, un intrprete realiza las operaciones que implica el programa fuente.
Para una proposicin de asignacin, por ejemplo, un intrprete podra construir un
rbol como el de la figura 1 y despus efectuar las operaciones de los nodos
conforme "recorre el rbol. En la raz descubrira que tiene que realizar una
asignacin, y llamara a una rutina para evaluar la expresin de la derecha y
despus almacenara el valor resultante en la localidad de memoria asociada con
el identificador posicin. En el hijo derecho de la raz, la rutina descubrira que
tiene que calcular la suma de dos expresiones. Se llamara a s misma de manera
recursiva para calcular el valor de la expresin velocidad*60. Despus sumara
ese valor de la variable inicial. Muchas veces los intrpretes se usan para ejecutar
lenguajes de rdenes, pues cada operador que se ejecuta en un lenguaje de
rdenes suele ser una invocacin de una rutina compleja, como un editor o un
compilador. Del mismo modo algunos lenguajes de "muy alto nivel, normalmente
son interpretados, porque hay muchas cosas sobre los datos, como el tamao y la
forma de las matrices, que no se pueden deducir en el momento de la
compilacin.
Compiladores4 Tradicionalmente, se concibe un compilador como un
programa que traduce un programa fuente, como FORTRAN, al lenguaje
ensamblador o de mquina de algn computador. Sin embargo, hay lugares, al
parecer, no relacionados donde la tecnologa de los compiladores se usa con
regularidad. La parte de anlisis de cada uno de los siguientes ejemplos es
parecida a la de un compilador convencional.
.ormadores de te)tos. Un formador de textos toma como entrada una
cadena de caracteres, la mayor parte de la cual es texto para componer, pero
alguna incluye rdenes para indicar prrafos, figuras o estructuras matemticas,
como subndices o superndices.
Compiladores de circuitos de silicio. Un compilador de circuitos de silicio
tiene un lenguaje fuente similar o idntico a un lenguaje de programacin
convencional. Sin embargo las variables del lenguaje no representan localidades
de memoria, sino seales lgicas (0 o 1) o grupos de seales en un circuito de
conmutacin. La salida es el diseo de un circuito en un lenguaje apropiado.
Int5rpretes de consultas. Un intrprete de consultas traduce un predicado
que contiene operadores relacionales y bolanos a rdenes para buscar en una
base de datos registros que satisfagan ese predicado.
1.3Lenguajes.
Se llama lenguaje a cualquier tipo de cdigo semitico estructurado, para el
que existe un contexto de uso y ciertos principios combinatorios formales. Existen
muchos contextos tanto naturales como artificiales donde aparecen lenguajes.
El lenguaje humano se basa en la capacidad de los seres humanos para
comunicarse mediante de signos. Principalmente lo hacemos utilizando el signo
lingstico. An as, hay diversos tipos de lenguaje. El lenguaje humano puede
estudiarse en cuanto a su desarrollo desde dos puntos de vista complementarios:
la ontogenia, que remite al proceso de adquisicin del lenguaje por el ser humano,
y la filogenia El lenguaje animal se basa en el uso de seales sonoras, visuales y
olfativas a modo de signos para referirse a un referente o un significado diferente
de dichas seales. Dentro del lenguaje animal estn los gritos de alarma, el
lenguaje de las abejas, etc. Los lenguajes formales son construcciones artificiales
humanas, que se usan en matemtica y otras disciplinas formales, incluyendo
lenguajes de programacin. Estas construcciones tienen estructuras internas que
comparten con el lenguaje humano natural, por lo que pueden ser en parte
analizados con los mismos conceptos que ste.
1.3.1 Lenguajes naturales.
Este tipo de lenguaje es el que nos permite el designar las cosas actuales y
razonar a cerca de ellas, fue desarrollado y organizado a partir de la experiencia
humana y puede ser utilizado para analizar situaciones altamente complejas y
razonar muy sutilmente. La riqueza de sus componentes semnticos da a los
lenguajes naturales su gran poder expresivo y su valor como una herramienta para
razonamiento sutil. Por otro lado la sintaxis de un LN puede ser modelada
fcilmente por un lenguaje formal, similar a los utilizados en las matemticas y la
lgica. Otra propiedad de los lenguajes naturales es la polisemntica, es decir la
posibilidad de que una palabra en una oracin tenga diversos significados.
En un primer resumen, los lenguajes naturales se caracterizan por las
siguientes propiedades:
Desarrollados por enriquecimiento progresivo antes de cualquier intento de
formacin de una teora.
La importancia de su carcter expresivo debido grandemente a la riqueza del
componente semntico (polisemntica).
Dificultad o imposibilidad de una formalizacin completa.
1.3.2 Lenguajes artificiales.
El lenguaje nos permite hacer la abstraccin y conceptualizacin de ideas y por
medio de este comunicarnos. En las distintas ramas de la ciencia nos
encontramos con lenguajes artificiales o mejor conocidos como lenguajes formales
que limitan su alcance a su materia de estudio.
Concretamente y despus de esta breve introduccin, en la actualidad nos
encontramos con distintos lenguajes para programar y tambin los campos de
aplicacin son variados y completamente distintos. De acuerdo a la complejidad
del problema a resolver ser necesario hacer una seleccin adecuada del lenguaje
de programacin (incluso se puede generar el lenguaje de programacin propio)
que permita resolver de manera eficiente el problema.
Hasta hace pocos aos, el software de desarrollo se basaba
fundamentalmente en Lenguajes Artificiales (Basic, C, Cobol, Pascal.) para
"explicar a la computadora las acciones a realizar. Por el contrario, los
"Orientados a Objetos permiten que el programador ignore el lenguaje
comprensible para la mquina poniendo a su disposicin una serie de objetos
preprogramados. De este modo la tarea se simplifica enormemente y se reduce a
disponer dentro de la ventana de programa y en la secuencia adecuada, los
programas y funciones de los que nos provee.
1.3.3 Proceso de la comunicacin.
La comunicacin es un fenmeno inherente a la relacin grupal de los seres
vivos por medio del cual stos obtienen informacin acerca de su entorno y de
otros entornos y son capaces de compartirla haciendo partcipes a otros de esa
informacin. La comunicacin es de suma importancia para la supervivencia de
especies gregarias, pues la informacin que sta extrae de su medio ambiente y
su facultad de transmitir mensajes sern claves para sacar ventaja del modo de
vida gregario.
Etimolgicamente, la palabra comunicacin deriva del latn "communicare, que
puede traducirse como "poner en comn, compartir algo. Se considera una
categora polismica en tanto su utilizacin no es exclusiva de una ciencia social
en particular, teniendo connotaciones propias de la ciencia social de que se trate.
Proceso de transmisin de informacin de un emisor (A) a un receptor (B) a
travs de un medio (c). En la transmisin y la recepcin de esa informacin se
utiliza un cdigo especfico que debe ser "codificado, por el emisor y
"decodificado por el receptor.
Elementos del Proceso de la comunicacin:
Los elementos de la comunicacin humana son: fuente, emisor o codificador,
cdigo (reglas del signo, smbolo), mensaje primario (bajo un cdigo), receptor o
decodificador, canal, ruido (barreras o interferencias) y la retroalimentacin o
realimentacin (feed-back, mensaje de retorno o mensaje secundario).
Fuente: Es el lugar de donde emana la informacin, los datos, el contenido
que se enviar, en conclusin: de donde nace el mensaje primario.
Emisor o codificador: Es el punto (persona, organizacin.) que elige y
selecciona los signos adecuados para transmitir su mensaje; es decir, los codifica
para poder llevarlo de manera entendible al receptor. En el emisor se inicia el
proceso comunicativo.
Receptor o decodificador: Es el punto (persona, organizacin.) al que se
destina el mensaje, realiza un proceso inverso al del emisor ya que en l est el
descifrar e interpretar lo que el emisor quiere dar a conocer. Existen dos tipos de
receptor, el pasivo que es el que slo recibe el mensaje, y el receptor activo o
perceptor ya que es la persona que no slo recibe el mensaje sino que lo percibe y
lo almacena. El mensaje es recibido tal como el emisor quiso decir, en este tipo de
receptor se realiza lo que comnmente denominamos el feed-back o
retroalimentacin.
Cdigo: Es el conjunto de reglas propias de cada sistema de signos y
smbolos que el emisor utilizar para trasmitir su mensaje, para combinarlos de
manera arbitraria porque tiene que estar de una manera adecuada para que el
receptor pueda captarlo. Un ejemplo claro es el cdigo que utilizan los marinos
para poder comunicarse; la gramtica de algn idioma; los algoritmos en la
informtica., todo lo que nos rodea son cdigos.
Mensaje: Es el contenido de la informacin (contenido enviado): el conjunto
de ideas, sentimientos, acontecimientos expresados por el emisor y que desea
trasmitir al receptor para que sean captados de la manera que desea el emisor. El
mensaje es la informacin.
Canal: Es el medio a travs del cual se transmite la informacin-
comunicacin, estableciendo una conexin entre el emisor y el receptor. Mejor
conocido como el soporte material o espacial por el que circula el mensaje.
Ejemplos: el aire, en el caso de la voz; el hilo telefnico, en el caso de una
conversacin telefnica.
Referente: Realidad que es percibida gracias al mensaje. Comprende todo
aquello que es descrito por el mensaje.
Situacin: Es el tiempo y el lugar en que se realiza el acto comunicativo.
nterferencia o barrera: Cualquier perturbacin que sufre la seal en el
proceso comunicativo, se puede dar en cualquiera de sus elementos. Son las
distorsiones del sonido en la conversacin, o la distorsin de la imagen de la
televisin, la alteracin de la escritura en un viaje, la afona del hablante, la
sordera del oyente, la ortografa defectuosa, la distraccin del receptor, el alumno
que no atiende aunque est en silencio.
Retroalimentacin o realimentacin (mensaje de retorno): Es la condicin
necesaria para la interactividad del proceso comunicativo, siempre y cuando se
reciba una respuesta (actitud, conducta.) sea deseada o no. Logrando la
interaccin entre el emisor y el receptor. Puede ser positiva (cuando fomenta la
comunicacin) o negativa (cuando se busca cambiar el tema o terminar la
comunicacin). Si no hay realimentacin, entonces solo hay informacin ms no
comunicacin.
1.4Traductor y su estructura.
En un sentido orientado hacia la computacin, un traductor, de manera general,
es un software que toma como entrada un programa escrito en un cdigo llamado
fuente y genera como salida otro programa en un cdigo llamado objeto.
Algunos ejemplos de traductores son los compiladores (toma como entrada
cdigo en alto nivel y genera como salida cdigo en bajo nivel), los interpretes
(toma como entrada cdigo en alto nivel y genera como salida un cdigo
intermedio), los preprocesadores (toma como entrada cdigo en alto nivel y
genera como salida cdigo en alto nivel) y el ensamblador (toma como entrada
cdigo en ensamblador y genera como salida cdigo en bajo nivel).
Su estructura podria ser expresada de la siguiente manera:
cdigo fuente ->> traductor -> cdigo objeto
1.4.1 Ensambladores.
El trmino ensamblador (del ingls assembler) se refiere a un tipo de programa
informtico que se encarga de traducir un fichero fuente escrito en un lenguaje
ensamblador, a un fichero objeto que contiene cdigo mquina, ejecutable
directamente por la mquina para la que se ha generado. El propsito para el que
se crearon este tipo de aplicaciones es la de facilitar la escritura de programas, ya
que escribir directamente en cdigo binario, que es el nico cdigo entendible por
la computadora, es en la prctica imposible. La evolucin de los lenguajes de
programacin a partir del lenguaje ensamblador origin tambin la evolucin de
este programa ensamblador hacia lo que se conoce como programa compilador.
Funcionamiento:
El programa lee el fichero escrito en lenguaje ensamblador y sustituye cada
uno de los cdigos mnemotcnicos que aparecen por su cdigo de operacin
correspondiente en sistema binario.
Tipos de ensambladores:
Podemos distinguir entre tres tipos de ensambladores:
Ensambladores bsicos. Son de muy bajo nivel, y su tarea consiste
bsicamente en ofrecer nombres simblicos a las distintas instrucciones,
parmetros y cosas tales como los modos de direccionamiento. Adems, reconoce
una serie de directivas (o meta instrucciones) que indican ciertos parmetros de
funcionamiento del ensamblador.
Ensambladores modulares, o macro ensambladores. Descendientes de los
ensambladores bsicos, fueron muy populares en las dcadas de los 50 y los 60,
antes de la generalizacin de los lenguajes de alto nivel. Hacen todo lo que puede
hacer un ensamblador, y adems proporcionan una serie de directivas para definir
e invocar macroinstrucciones (o simplemente, macros). Vase X86.
Ensambladores modulares 32-bits o de alto nivel. Son ensambladores que
aparecieron como respuesta a una nueva arquitectura de procesadores de 32 bits,
muchos de ellos teniendo compatibilidad hacia atrs pudiendo trabajar con
programas con estructuras de 16 bits. Adems de realizar la misma tarea que los
anteriores, permitiendo tambin el uso de macros, permiten utilizar estructuras de
programacin ms complejas propias de los lenguajes de alto nivel.
1.4.2 Compiladores.
Un compilador acepta programas escritos en un lenguaje de alto nivel y los
traduce a otro lenguaje, generando un programa equivalente independiente, que
puede ejecutarse tantas veces como se quiera. Este proceso de traduccin se
conoce como compilacin.
El de los programas de partida (LA)
El de los programas equivalentes traducidos (LB), normalmente el lenguaje
de mquina
El lenguaje en que est escrito el propio compilador (LC), que puede ser igual
o diferente a LA. Aumenta la portabilidad del compilador si est escrito en el
mismo lenguaje, es decir, se puede compilar a s mismo.
Los programas interpretados suelen ser ms lentos que los compilados, pero
los intrpretes son ms flexibles como entornos de programacin y depuracin.
Partes de un compilador:
Normalmente los compiladores estn divididos en dos partes:
Front End: es la parte que analiza el cdigo fuente, comprueba su validez,
genera el rbol de derivacin y rellena los valores de la tabla de smbolos. Esta
parte suele ser independiente de la plataforma o sistema para el cual se vaya a
compilar.
Back End: es la parte que genera el cdigo mquina, especfico de una
plataforma, a partir de los resultados de la fase de anlisis, realizada por el Front
End.
Tipos de compiladores:
Esta taxonoma de los tipos de compiladores no es excluyente, por lo que
puede haber compiladores que se adscriban a varias categoras:
Compiladores cruzados: generan cdigo para un sistema distinto del que
estn funcionando.
Compiladores optimizadores: realizan cambios en el cdigo para mejorar su
eficiencia, pero manteniendo la funcionalidad del programa original.
Compiladores de una sola pasada: generan el cdigo mquina a partir de una
nica lectura del cdigo fuente.
Compiladores de varias pasadas: necesitan leer el cdigo fuente varias veces
antes de poder producir el cdigo mquina.
Compiladores JT (Just n Time): forman parte de un intrprete y compilan
partes del cdigo segn se necesitan.
Pauta de creacin de un compilador: En las primeras pocas de la informtica,
el software de los compiladores era considerado como uno de los ms complejos
existentes.
Los primeros compiladores se realizaron programndolos directamente en
lenguaje mquina o en ensamblador. Una vez que se dispone de un compilador,
se pueden escribir nuevas versiones del compilador (u otros compiladores
distintos) en el lenguaje que compila ese compilador.
Actualmente existen herramientas que facilitan la tarea de escribir
compiladores intrpretes informticos. Estas herramientas permiten generar el
esqueleto del analizador sintctico a partir de una definicin formal del lenguaje de
partida, especificada normalmente mediante una gramtica formal y barata,
dejando nicamente al programador del compilador la tarea de programar las
acciones semnticas asociadas.
1.4.3 Interpretes.
Un intrprete es un traductor que toma un programa fuente, lo traduce y a
continuacin lo ejecuta. BASC es un lenguaje interpretado.
Se trata de traductores-ejecutores ya que con cada instruccin realizan un
proceso triple de lectura-traduccin-ejecucin. Son relativamente lentos, pero muy
buenos para la depuracin de programas.
Se puede tambin utilizar una alternativa diferente de los compiladores para
traducir lenguajes de alto nivel. En vez de traducir el programa fuente y grabar en
forma permanente el cdigo objeto que se produce durante la corrida de
compilacin para utilizarlo en una corrida de produccin futura, el programador
slo carga el programa fuente en la computadora junto con los datos que se van a
procesar. A continuacin, un programa intrprete, almacenado en el sistema
operativo del disco, o incluido de manera permanente dentro de la mquina,
convierte cada proposicin del programa fuente en lenguaje de mquina conforme
vaya siendo necesario durante el proceso de los datos. No se graba el cdigo
objeto para utilizarlo posteriormente.
La siguiente vez que se utilice una instruccin, se le debe interpretar otra vez y
traducir a lenguaje mquina. Por ejemplo, durante el procesamiento repetitivo de
los pasos de un ciclo, cada instruccin del ciclo tendr que volver a ser
interpretado cada vez que se ejecute el ciclo, lo cual hace que el programa sea
ms lento en tiempo de ejecucin (porque se va revisando el cdigo en tiempo de
ejecucin) pero ms rpido en tiempo de diseo (porque no se tiene que estar
compilando a cada momento el cdigo completo). El intrprete elimina la
necesidad de realizar una corrida de compilacin despus de cada modificacin
del programa cuando se quiere agregar funciones o corregir errores; pero es obvio
que un programa objeto compilado con antelacin deber ejecutarse con mucha
mayor rapidez que uno que se debe interpretar a cada paso durante una corrida
de produccin.
1.5Generadores de cdigo para compiladores (compilador de compilador).
Aqu se hablar de las herramientas generadoras automticas de cdigo para
un compilador. Estas herramientas trabajan basadas en un conjunto de reglas;
estas reglas definen la traduccin de las instrucciones del lenguaje intermedio al
lenguaje de mquina.
Para la generacin de cdigo, se busca en las reglas establecidas la
proposicin que coincida con la entrada actual; la entrada actual proviene de un
rbol. Un ejemplo de esto seria
Entonces el compilador recibe una entrada de caracteres, por lo general escrita
por el programador; el compilador realiza los anlisis: lxico, sintctico y
semntico, para generar seguidamente el cdigo intermedio, el cdigo intermedio
se genera con principios de bsqueda de patrones y aplicacin de reglas.
Despus se hace la optimizacin del cdigo intermedio; seguidamente se realiza
la generacin de cdigo objeto en lenguaje de mquina.
En sntesis para crear un generador de cdigo se deben hacer muchas de las
tareas que realizan los compiladores; algunas de estas tareas son: la bsqueda de
patrones, la escritura de cdigo, el anlisis sintctico, el anlisis lxico y la
optimizacin de cdigo. Estas tareas las realiza el desarrollador una vez para una
arquitectura especfica.
METACOMPLADOR: Es Sinnimo De compilador de compiladores y se refiere
a un programa que recibe como entrada las especificaciones del lenguaje para el
que se desea obtener un compilador y genera como salida el compilador para ese
lenguaje. El desarrollo de los metacompiladores se encuentra con la dificultad de
unir la generacin de cdigo con la parte de anlisis. Lo que s se han desarrollado
es generadores de analizadores lxicos y sintcticos.
Por ejemplo, los conocidos:
LEX: generador de analizadores lxicos
YACC: analizadores sintcticos desarrollados para generador de UNX.
Los inconvenientes que tienen son que los analizadores que generan no son
muy eficientes.
UNIDAD 2
Introduccin al diseo de los lenguajes de programacin
2.1Visin del problema.
Proporciona modelos de diseo que permitan caracterizar el desarrollo de
aplicaciones utilizando un lenguaje de programacin se necesita un lenguaje de
modelado que sea capaz de capturar la semntica del modelo al que se ajusta el
lenguaje de programacin.
El modelado de diseo proporcionado por el lenguaje de modelado debe ser
capas de capturar la semntica del programa que implementa la especificacin de
requisitos.
En los ltimos aos, una de las artes ms predominantes en el mundo de la
programacin ha sido el diseo de lenguaje de programacin. El numero de
lenguajes de programacin propuesta y diseados son extremadamente grandes.
Aun el numero de de lenguajes para el que un compilador ha aplicado es inmenso.
Sammet (1976) indica 167 en su lista 19741975. Aun que los primeros lenguajes
de programacin primitivos nacieran cerca 25 aos atrs, hasta que reciente
mente hubiesen un pequeo proceso en el diseo de nuevos lenguajes de
programacin.
Los primeros lenguajes fueron los pioneros, explorando un nuevo campo. No
es de sorprenderse que carecieran de un buen diseo. No se debera criticar a los
diseadores o FORTRAN; puesto que suficientes problemas tenan con disear y
aplicar uno de los primeros lenguajes de alto nivel Si hay cualquier crtica de ser
concedida con respecto a FORTRAN, Nadie razonablemente los podra esperar
que a la crtica sean concedidos con respecto a 25 aos ms tarde, sus objetivos
deben ser los usuarios que se han adherido tan tenazmente a ciertos diseadores
cados en desuso del lenguaje que tienen tan perpetuaron con entusiasmo los
desperfectos de FORTRAN. Se debe notar que nuestras referencias a FORTRAN
en el prrafo anterior y a travs de este captulo se refiere a FORTRAN V antes
que FORTRAN 77.
Despus que el desarrollo inicial del lenguaje de alto nivel y la implementacin
de los primeros pocos compiladores, all result un perodo bastante largo en el
que las tentativas conscientes se hicieron para disear nuevos lenguajes sin los
desperfectos de los viejos. La mayor parte de estas tentativas eran los fracasos,
no tanto de una falta de ideas en cmo disear mejores lenguajes como de un
supervit de ideas. Una buena ampliacin de este proceso es la nocin que "si
podra significar algo, debera (Radin y Rogoway, 1965), que llev a PL/YO. Ms
recientemente, la experiencia de errores pasados haba llevado al conocimiento
verdadero acerca de cmo construir mejores lenguajes de programacin.
Las ideas y los principios bsicos se establecen suficientemente bien para
indicar las pautas explcitas para el diseo del lenguaje. Esas reas que aun no
han sido comprendidas se encuentran bajo investigacin.
Esta discusin procurar por consiguiente acentuar un sistema. El enfoque
ordenado al diseo del lenguaje, se debe recordar, sin embargo, hacer la
justificacin apropiada a muchos temas que a menudo son necesarios para
discutir detalles as como generalidades. El campo del diseo del lenguaje no es
de ninguna manera completamente desarrollada, y muchas reas no han sido bien
unificadas. Tambin, muchas reas interrelacionan y son difcil de discutirlos
separadamente.
Por la necesidad, esta discusin sin embargo, restringe su alcance. Las
descripciones elaboradas de las caractersticas posibles del lenguaje se limitarn
se asume que el diseador potencial del lenguaje tiene las bases suficientes en
lenguajes de programacin para estar enterado de las ideas prinsipales. Las
caractersticas especficas se discutirn para especificar razones , pero ninguna
tentativa se har para dar un catlogo general. Hay ya varios catlogos , como:
(Elson, 1973; Pratt, 1975; Nlcholls, 1975). Una proposicin bsica de este captulo
entero es que un buen lenguaje no es apenas una coleccin casual de
caractersticas de un total unificado. Se asumir que los lenguajes, bajo la
discusin son de alto nivel los idiomas. La discusin ser restringida tambin en
gran parte a idiomas procesales para escribir software ("software se utiliza aqu
en sus la mayora de los sentidos generales para significar "los programas para
ser utilizados por otra persona). Mucho de lo que se dice ser aplicable a otras
clases de lenguajes.
El disear completamente un lenguaje. Si es que es el enfoque se toma, como
sea, se debe tomar con cuidado para no hacer una extensin tan grande y
compleja como se llega a ser, el hecho, de un nuevo lenguaje. En tales casos, la
necesidad de retener algunas interfaces con un viejo lenguaje probablemente
ceder gravemente el diseo de la extensin. Tambin, si uno extiende un
lenguaje existente, es necesario escoger cuidadosamente un lenguaje base para
que el trabajo de la extensin se aminorare y la extensin elegantemente quede
dentro del lenguaje. El objetivo debe ser el de producir un lenguaje el cual se ms
grande aun que igualmente bien construido.
Sera posible el modificar un lenguaje existente, utilizando posiblemente un
macroprocessor o algo similar? Aun que con facilidad un macro contrario de menor
parmetro (sustituyendo simplemente un texto especificado para cada ocurrencia
de una identificacin definida) podra producir modificaciones mayores en la
sintaxis de un lenguaje, si se utilizara diestramente (por ejemplo, RATFOR definido
por Kernighan y Plauger, 19746) sin embargo, el poder de este enfoque para una
tarea ms compleja, tal como la introduccin de nuevas estructuras de datos, se
limitan.
Algunas consideraciones serias deben ser dadas a estas tcnicas como
alternativas para un nuevo lenguaje, con el simple motivo de aminorar el trabajo y
el tiempo implicado. Quizs no haya ningn otro problema relacionado con la
computadora que observe tan tentadoramente fcil y sea sumamente terrible un
buen trabajo de diseo de lenguaje. Prescinda de la nocin que es posible agitar
un diseo el fin de semana y el comenzar aplicando un traductor para el lunes. Un
mes luego habr de asentarse todava los puntos secundarios del diseo del
idioma y la implementacin no habr obtenido casi en ningn lugar.
2.2Consideraciones Preliminares.
Debemos tomar en cuenta las palabras reservadas del lenguaje, los
operadores, los tipos de datos.
Debemos considerar el objetivo del lenguaje, si es un lenguaje de enseanza,
si es un lenguaje para profesionales, si el cdigo desarrollado va a ser mejor.
Los factores fundamentales en la calidad del software son:
La eficiencia: capacidad para el aprovechamiento ptimo de los recursos que
emplea.
La portabilidad: facilidad para ser ejecutados en distintos entornos lgicos o
fsicos.
La verificabilidad: capacidad para soportar procedimientos de pruebas, test o
ensayos.
La integridad: nivel de proteccin frente a procesos que traten de alterarlo.
La facilidad de uso: comodidad y claridad en la interaccin con el usuario.
La exactitud: nivel de precisin que alcanzan los resultados obtenidos.
La robustez: capacidad para funcionar correctamente en situaciones extremas.
La extensibilidad: capacidad para adaptar su funcionamiento al incremento en
sus objetivos.
La compatibilidad: facilidad de poder ser aplicados en conjuncin con otros
programas.
La reutilizacin: posibilidad de utilizarlos (total o parcialmente) en nuevos
contextos.
2.3Objetivos y filosofas del diseo de los lenguajes de programacin.
Objetivo:
El principal objetivo del lenguaje es, por supuesto, servir de apoyo didctico en
una materia de lenguajes de programacin, intrpretes y compiladores. Derivado
de la persecucin de este objetivo surgen varias metas especficas y objetivos
particulares:
La apreciacin del desarrollo e implementacin de un lenguaje de
programacin.
La comprensin del procedimiento seguido en la formacin de un conjunto de
reglas gramaticales que permiten identificar y nombrar sin ambigedad acciones y
secuencias ordenadas de acciones sobre el contexto especfico de un problema
en particular.
Proporcionar un medio de familiarizacin con la realizacin de operaciones
aritmticas usando una pila y su posterior extensin para la manipulacin de otros
datos.
La clara especificacin y adecuada documentacin del proceso de creacin o
extensin de un lenguaje y sus resultados.
Filosofa:
El lenguaje de programacin esta pensado para la programacin evolutiva.
Esta consiste en un mtodo de programacin basado en un ciclo de prueba y error
donde se refina un programa hasta conseguir que haga lo que queremos. Esta
forma de programar se aplica a problemas donde se desconoce que algoritmo nos
llevar a la solucin. Esta situacin se da en investigacin y en la creacin de
prototipos donde hay que realizar muchas pruebas hasta dar con la solucin ms
apropiada. Para estos casos, es ms apropiado el uso de un interprete que un
compilador, ya que de esta forma se reduce el tiempo invertido en cada prueba.
Para que un lenguaje sea efectivo en programacin evolutiva tiene que facilitar:
la interaccin, la modificacin del programa y aportar instrucciones de alto nivel
cercanas al problema. Estos tres puntos se consiguen cuando el lenguaje tiene las
siguientes caractersticas:
Estado de nteraccin. Entre prueba y prueba es interesante guardar el estado
de ejecucin. De esta forma se evita repetir la ejecucin de las instrucciones
necesarias para llegar al estado de ejecucin donde queremos realizar pruebas.
Los programas implementa esta caracterstica mediante un mbito global dinmico
que guarda funciones y variables mientras se utiliza el intrprete.
Sintaxis Cercana al Problema. Es ms efectivo escribir en una notacin
cercana al problema que adaptarse a la sintaxis de un lenguaje de programacin.
De esta forma se evita el paso de traduccin que tiene que realizar el programador
antes de escribir una nueva sentencia del programa.
2.4Diseo detallado.
El diseo detallado tiene que ver con la especificacin de detalles algortmicos,
representaciones concretas de datos, interconexiones entre funciones y
estructuras de datos, y empaque del producto de programacin. El diseo
detallado est fuertemente influenciado por el lenguaje de instrumentacin, pero
no es lo mismo que la instrumentacin; el diseo detallado tiene que ver ms con
aspectos semnticos y menos con detalles sintcticos que es la instrumentacin.
El punto de inicio para el diseo detallado es una estructura arquitectnica a la
que se le van a proporcionar los detalles algortmicos y las representaciones
concretas de datos. Mientras que hay una fuerte tentacin para proceder
directamente de la estructura arquitectnica a la instrumentacin, hay varias
ventajas que pueden lograrse en el nivel intermedio de detalle proporcionado por
el diseo detallado.
La instrumentacin comunica los aspectos de la sintaxis del lenguaje de
programacin, el estilo de codificacin la documentacin interna, y la insercin de
pruebas y depuraciones al cdigo. Las dificultades que se encuentran durante la
instrumentacin casi siempre se deben al hecho de que el instrumentador
simultneamente est realizando anlisis, diseo y actividades de codificacin
mientras intenta expresar el resultado final en un lenguaje de instrumentacin. El
diseo detallado permite el diseo de algoritmos y representaciones de datos en
un nivel ms alto de abstraccin y notacin que el que proporciona el lenguaje de
instrumentacin.
El diseo detallado separa la actividad de diseo a bajo nivel de la
instrumentacin, igual que las actividades de anlisis y diseo aslan las
consideraciones de lo que se desea de la estructura que lograr los resultados
deseados. Una especificacin adecuada de diseo detallado minimiza el nmero
de sorpresas durante la instrumentacin del producto.
2.5Caso de estudio.
UNIDAD 3
Anlisis L!ico
3.1ntroduccin a los Autmatas finitos y expresiones regulares.
Autmata:
Un autmata finito o mquina de estado finito es un modelo matemtico de un
sistema que recibe una cadena constituida por smbolos de un alfabeto y
determina si esa cadena pertenece al lenguaje que el autmata reconoce.
Definicin formal
Formalmente, un autmata finito (AF) puede ser descrito como una 5-tupla
(S,Z,T,s,A) donde:
* S un conjunto de estados;
* Z es un alfabeto;
* T es la funcin de transicin:
* s es el estado inicial;
* A es un conjunto de estados de aceptacin o finales.
3.2Analizador de lxico.
El analizador lxico es la primera fase de un compilador, lee caracteres de
entrada para formar componentes e identificarlos o clasificarlos y pasar la
informacin de los componentes al analizador sintctico.
Realiza adems funciones como eliminar espacios en blanco, saltos de lnea,
tabuladores, ignorar comentarios, deteccin y recuperacin de errores. Los errores
que un analizador lxico reconoce son smbolos no vlidos o no reconocidos por el
lxico del lenguaje o que no forman parte de ningn componente lxico.
Existen diversos mtodos para construir una analizador lxico, un mtodo es
usar un AFD para describir el patrn de cada componente. Para este mtodo se
parte de una tabla descriptiva de los componentes lxicos que reconocer el
analizador, en donde se clasifican los diversos tipos de componentes.
Para cada componente se construye un AFD que permita identificar el patrn
de smbolos que deber recibir y donde deber terminar ese patrn que seale
que ah se encontr un componente. Todos los AFDs se integran en un solo
diagrama. Finalmente se determina la matriz de transicin de estados, que no es
ms que transcripcin del AFD integrado, en donde las columnas son los smbolos
que acepta el analizador, incluyendo una columna para \b \t \n y otra columna para
"otro que representa a cualquier caractr o smbolo diferente de los sealados por
el analizador. Lo que resta es crear un algoritmo de reconocimiento de cadenas y
aadir mediante una seleccin de casos para tomar la accin correspondiente
segn la cadena encontrada.
3.3Manejo de localidades temporales de memoria (buffers).
La forma ms fcil de leer un programa es carcter por carcter pero es
ineficiente.
La forma ms eficiente es realizar una copia a la memoria de todo el cdigo
fuente. Pero esto en la gran mayora de las ocasiones es imprctico por las
dimensiones de los programas. Para solucionar este problema se sugiere utilizar
buffers.
Manejo de buffers:
Existen muchas formas de dividir el trabajo, pero siempre se deber llevar dos
punteros, uno al carcter actual y otro al inicial del lexema.
El manejo de buffers es esencial para realizar el anlisis de grandes programas
de mejor manera
La diferente de velocidad entre los dos tipos de memoria es muy grande, por lo
que resulta interesante definir algn tipo de estrategia que reduzca este
diferencial.
Un buffer se define como un conjunto de bytes que son ledos o escritos desde
un dispositivo de almacenamiento, en la memoria primaria. Cuando se desea leer
una informacin, se lee un bloque de informacin en el que aparece. La
modificacin de un dato se realiza sobre el buffer, que posteriormente debe ser
enviado al dispositivo de almacenamiento. La utilizacin de esta tcnica permite
reducir el nmero de accesos a memoria secundaria.
Nmero de Buffers y Velocidad de Acceso:
El manejo de buffers por parte del administrador de ficheros permite reducir el
nmero de accesos a memoria secundaria. Pero una cuestin fundamental es el
nmero de buffers a utilizar. Si slo se utiliza un buffer, un problema que realice
lecturas y escrituras de modo alterno, debera leer un bloque en cada operacin. -
Esto se resuelve mediante la utilizacin de un buffer para escritura y otro para
lectura. Pero la lectura, o escritura, alterna sobre varios ficheros puede provocar el
mismo problema. Otra alternativa es la utilizacin de ambos bloques para lecturas
y escrituras de modo alternado.
La generalizacin de esta idea es el caso real, varios buffers que se manejan
de modo indistinto para lecturas y escrituras. La gestin de estos buffers es
realizada por el administrador de ficheros, aunque el usuario puede controlar el
nmero de buffers.
Si todos los buffers estn ocupados, se debe vaciar uno de ellos para
posibilitar una lectura. Normalmente se utiliza al algoritmo LRU, es decir, se vaca
el buffer menos recientemente utilizado.
3.4Creacin de tablas de smbolos.
Tabla: conjunto de pares clave-valor, llamados elementos de la tabla.
La tabla de smbolos es una componente necesaria de un compilador. Al
declarar un identificador (normalmente una sola vez), ste es insertado en la tabla.
Cada vez que se utilice el identificador se realizar una bsqueda en la tabla para
obtener la informacin asociada (el valor).
Bsqueda: dada la clave de un elemento, encontrar su valor.
nsercin: Dado un par clave-valor, aadir un elemento nuevo a la tabla.
Cambio de valor: Buscar el elemento y cambiar su valor.
Borrado: Eliminar un elemento de la tabla.
Longitud de bsqueda (o tiempo de acceso):
De una clave: Li = nmero de comparaciones con elementos de la tabla para
encontrar esa clave. Mxima: LM = nmero mximo de comparaciones para
encontrar cualquier clave. Media (esperada): Lm = nmero medio de
comparaciones para encontrar un valor. Si la frecuencia de todas las claves es la
misma:
Lm = (S Li)/N
Si la frecuencia de todas las claves no es la misma:
Lm = S pi.Li
Grado de ocupacin:
s = n/N
donde n=nmero de elementos en la tabla y N=capacidad mxima de la tabla.
Funcin de bsqueda: B : KE asocia a cada clave k un elemento B(k).
Valor asociado a una clave k: v(B(k)). Puede ser mltiple, en cuyo caso
normalmente se convierte en un puntero. Si est en la tabla puede almacenarse
consecutivamente o en subtablas paralelas.
Tablas de smbolos (identificadores) La clave es el identificador. El valor est
formado por:
Atributos del identificador. Puntero a la posicin de memoria asignada. La clave
puede sustituirse por un puntero.
Los identificadores pueden estar empaquetados.
La longitud del identificador puede especificarse en la tabla o delante del
nombre, o ser implcita.
Tablas consecutivas: Todos los elementos ocupan posiciones de memoria
adyacentes. Tablas ligadas: cada elemento apunta al siguiente. Tablas doblemente
ligadas: cada elemento apunta al siguiente y al anterior. Tablas no ordenadas
nsercin: en el primer lugar vaco.
3.5Manejo de errores lxicos.
Recuperacin en modo pnico: este tipo de estrategia es la ms comn.
Consiste en que cuando se detecta una cadena no reconocible, se siguen leyendo
caracteres hasta que se vuelve a detectar un token vlido. Borrar un carcter
extrao. nsertar un carcter que falta (e.g. reemplazar 2C por 2*C). Reemplazar
un carcter incorrecto por otro correcto (e.g. reemplazar NTEJER por NTEGER si
el lugar en donde aparece el primer lexema no es el indicado para un identificador)
ntercambiar dos caracteres, tokens, adyacentes (e.g. NTEGER por NTEGER
).
La recuperacin de errores durante el AL puede producir otros en las siguientes
fases. var numero : integer; begin num?ero:=10; end el compilador podra producir
los siguientes mensajes de error: ERROR LXCO: carcter no reconocido (?)
ERROR SEMNTCO: identificador no declarado (num) ERROR SNTCTCO:
falta operador entre identificadores ERROR SEMNTCO: identificador no
declarado (ero)
Otras veces no: var i,j: integer; begin i:=1; ? j:=2; end
3.6Generadores de cdigo lxico: Lex y Flex.
UNIDAD "
Anlisis sintctico
4.1ntroduccin a las Gramticas libres de contexto y rboles de derivacin.
Gramticas de Contexto Libre:
La flexibilidad proporcionada por las gramticas de contexto libre es tal que es
la ms usada para definir la sintaxis de los lenguajes de programacin.
Una definicin formal de una gramtica de contexto sensitivo es la siguiente:
Es un cudruplo G= (V, S , P, S) donde V es un conjunto finito de variables, S
es un conjunto finito de smbolos terminales, P es un conjunto finito de reglas y S
es el smbolo inicial.
Cada produccin tiene la forma uVv, donde u es una variable del conjunto V, y
v es un miembro de (V S)* . Esto quiere decir En la parte izquierda dela
produccin viene siempre una variable (smbolo no terminal) y en la parte derecha
pueden venir cualquier nmero de smbolos terminales y no terminales incluyendo
la cadena nula.
Una gramtica de contexto libre produce un lenguaje tambin de contexto libre:
G L(G).
Arboles De Derivacin:
Existen bsicamente dos formas de describir cmo en una cierta gramtica una
cadena puede ser derivada desde el smbolo inicial. La forma ms simple es listar
las cadenas de smbolos consecutivas, comenzando por el smbolo inicial y
finalizando con la cadena y las reglas que han sido aplicadas. Si introducimos
estrategias como reemplazar siempre el no terminal de ms a la izquierda primero,
entonces la lista de reglas aplicadas es suficiente. A esto se le llama derivacin por
la izquierda.
La distincin entre derivacin por la izquierda y por la derecha es importante
porque en la mayora de analizadores la transformacin de la entrada es definida
dando una parte de cdigo para cada produccin que es ejecutada cuando la regla
es aplicada. De modo que es importante saber qu derivacin aplica el analizador,
por que determina el orden en el que el cdigo ser ejecutado.
Una derivacin tambin puede ser expresada mediante una estructura
jerrquica sobre la cadena que est siendo derivada.
4.2 Diagramas de sintaxis.
Un segundo mtodo alternativo para desplegar las producciones de ciertas
gramticas de tipo 2 es el diagrama de sintaxis. sta es una imagen de la
producciones que permite al usuario ver las sustituciones en forma dinmica, es
decir, verlas como un movimiento a travs del diagrama. En la figura 10.5 se
ilustrar los diagramas que resultan de la traduccin de conjuntos de producciones
tpicos, que son, por lo general, todas las producciones que aparecen en el lado
derecho de algn enunciado BNF.
a) <w> ::= <w1> <w2> <w3>
b) w> ::= <w1><w2> | w1a | bc<w2
c) <w> ::= ab<w>.
d) w> ::= ab | ab<w.
4.3 Precedencia de Operadores
Una expresin est compuesta por operadores, variables y constantes. Para
simplificar, podemos pensar que la forma en la que C evala esta expresin es
dividiendo el todo en subexpresiones. Las reglas que definen que subexpresin
evaluar primero, se denominan reglas de precedencia. Aunque siempre podemos
alterar dichas reglas mediante la utilizacin de parntesis. En la siguiente tabla
detallamos la precedencia entre los operadores de C.
Tabla 3.6: Precedencia de operadores Mayor precedencia
( ) [ ] - .
! ++ * & sizeof (operadores unarios)
* / %
+ -
== !=
&
&&
?:
= += -= *= /= %=
,
Menor precedencia
Precedencia de operadores
La interpretacin de cualquier expresin en C++ est determinada por la
precedencia y asociatividad de los operadores en dicha expresin. Cada operador
tiene una precedencia, y los operadores en una expresin se evalan en orden de
mayor a menor precedencia. La evaluacin de operadores con la misma
precedencia viene determinada por su asociatividad. Y, al igual que en
matemticas, los parntesis anulan las reglas de precedencia.
En la siguiente tabla se listan los operadores en C++, su precedencia y su
asociatividad. Los operadores se listan en orden de prioridad decreciente (los
situados ms arriba tienen mayor prioridad). Los operadores en la misma lnea
horizontal tienen la misma precedencia.
Operador Propsito Asociatividad
Scope (unario) De derecha a izquierda
Scope (binario) De izquierda a derecha
. Seleccin de miembros De izquierda a derecha
[] ndices De izquierda a derecha
() Llamada a funcin De izquierda a derecha
++ Postincremento De izquierda a derecha
Postdecremento De izquierda a derecha
sizeof Tamao de un objeto De derecha a izquierda
++ Preincremento De derecha a izquierda
Predecremento De derecha a izquierda
& + - ! ~ Operadores unarios De derecha a izquierda
new Crea un objeto De derecha a izquierda
delete Borra un objeto De derecha a izquierda
() Conversin de tipo (type cast) De derecha a izquierda
* .* Puntero a un miembro De izquierda a derecha
/ % Operadores multiplicativos De izquierda a derecha
+ - Operadores aditivos De izquierda a derecha
Operadores bitwise De izquierda a derecha
< > <= >= Operadores de relacin De izquierda a derecha
== != Operadores de igualdad De izquierda a derecha
& Y bitwise De izquierda a derecha
^ bitwise O exclusivo De izquierda a derecha
| bitwise O inclusivo De izquierda a derecha
&& Y lgico De izquierda a derecha
?: Operador condicional De derecha a izquierda
= *= /= += -= >*gt;=
&= ^= |= %= <<= Operadores de asignacin De derecha a izquierda
, Operador coma De derecha a izquierda
4.4 Analizador Sintactico
Un analizador sintctico ( Parser ) es un programa que reconoce si una o
varias cadenas de caracteres forman parte de un determinado lenguaje. Los
lenguajes habitualmente reconocidos por los analizadores sintcticos son los
lenguajes libres de contexto. Cabe notar que existe una justificacin formal que
establece que los lenguajes libres de contexto son aquellos reconocibles por un
autmata de pila, de modo que todo analizador sintctico que reconozca un
lenguaje libre de contexto es equivalente en capacidad computacional a un
autmata de pila. Los analizadores sintcticos fueron extensivamente estudiados
durante los aos 70 del siglo XX, detectndose numerosos patrones de
funcionamiento en ellos, cosa que permiti la creacin de programas generadores
de analizadores sintticos a partir de una especificacin de la sintaxis del lenguaje,
tales y como yacc, GNU bison y javacc.
4.4.1 Analizador Descendente Ll
Anlisis Sintctico Predictivo Recursivo
La siguiente fase en la construccin del analizador es la fase de anlisis sintctico.
Esta toma como entrada el flujo de terminales y construye como salida el rbol de
anlisis sintctico abstracto.
El rbol de anlisis sintctico abstracto es una representacin compactada del
rbol de anlisis sintctico concreto que contiene la misma informacin que ste.
Existen diferentes mtodos de anlisis sintctico. La mayora caen en una de dos
categoras: ascendentes y descendentes. Los ascendentes construyen el rbol
desde las hojas hacia la raz. Los descendentes lo hacen en modo inverso. El que
usaremos aqui es uno de los ms sencillos: se denomina mtodo de anlisis
predictivo descendente recursivo.
4.4.2 Analizador Ascendente Lr Lalr
Analizador Ascendente LR
ntenta construir un rbol de anlisis sintctico, empezando desde la raz y
descendiendo hacia las hojas. Lo que es lo mismo que intentar obtener una
derivacin por la izquierda para una cadena de entrada, comenzando desde la raz
y creando los nodos del rbol en orden previo.
4.5 Administracin Tabla De Smbolos
"La tabla de smbolos registra informacin acerca de cada nombre de smbolo en
un programa. Histricamente, los nombres se llamaron smbolos, ms que de una
tabla de nombres. En este captulo, la palabra smbolo significa nombre. La fase
de anlisis semntico crea la tabla de smbolos, puesto que no es sino hasta este
anlisis que se tiene la suficiente informacin sobre un nombre para describirlo. La
generacin de cdigo usa la tabla de smbolos para extraer las directivas del
ensamblador, para el tipo y para el tamao apropiados.
Una tabla de smbolos es una estructura de datos que contiene un registro por
cada identificador. El registro incluye los campos para los atributos del
identificador.
El administrador de la tabla de smbolos se encarga de manejar los accesos a la
tabla de smbolos, en cada una de las etapas de compilacin de un programa.
4.6 Manejo Errores Sintcticos y Recuperacin
Hay dos conceptos fundamentales:
Correccin de errores: exige que el programa pueda ejecutarse. Suele utilizarse
en sistemas que genern .EXE directamente, pues ahorra tiempo (permite
encontrar errores de ejecucin a la vez que los de compilacin).
Recuperacin de errores: slo trata de evitar que el nmero de mensajes de error
sea demasiado grande y que el compilador/intrprete pueda seguir ejecutndose
correctamente en instrucciones sucesivas.
Correccin ortogrfica
Errores ortogrficos tpicos:
Un carcter por otro.
Un carcter perdido.
Un carcter aadido.
Dos caracteres intercambiados.
Pueden comprobarse slo los errores anteriores, lo que acelera el proceso.
Correcciones posibles:
Anlisis sintctico
Si se espera una palabra reservada y aparece un identificador, buscar la palabra
reservada ms parecida al identificador.
Deshacer errores de concatenacin. Por ejemplo, convertir 'begina' en 'begin a'.
Anlisis semntico
Si un identificador se utiliza en un contexto incompatible con su tipo, tratar de
sustituirlo por otro de nombre parecido y tipo compatible con el contexto.
Si un identificador no ha sido referenciado o asignado, es candidato para
correccin ortogrfica. Slo en compiladores de dos pasos. En la tabla de
smbolos se puede aadir como valor un par de contadores de uso y asignacin.
Todas las correcciones efectuadas deben ser cuidadosamente documentadas,
para evitar que el programador se pierda al probar el programa. Correccin de
errores sintcticos
Si se detecta al analizar la cadena
xUy
donde x,y en A* y U en A es el prximo smbolo a analizar, podemos intentar lo
siguiente:
Borrar U e intentarlo de nuevo.
nsertar una cadena de terminales z entre x, U y empezar a analizar a partir de z.
nsertar una cadena de terminales z entre x, U y empezar a analizar a partir de U,
poniendo z en la pila (si es anlisis bottom-up).
Borrar smbolos del final de x e intentar de nuevo.
No hacer nunca los dos ltimos. Deshace la informacin semntica asociada.
Ejemplo: tenemos
if (.) { x=0; else .
El error se detecta en "else. Solucin posible: aadir "} delante de "else,
analizando
if (.) { x=0; } else .
Recuperacin de errores de compilacin
Conviene tener una sola rutina de recuperacin de errores separada del resto del
compilador.
Evitar que un solo error produzca varios mensajes.
Ejemplo: A[i1,i2,.,i3], donde A no es un "array. Al abrir el corchete nos dar un
error: "A no es un array. Al cerrar el corchete podra dar otro: "El nmero de
ndices no coincide con el rango de A. Si se ha dado el primero, el segundo es
innecesario. Una solucin: detectado el primer error, se sustituye la referencia a A
por una referencia a un identificador "fantasma. La rutina de recuperacin de
errores podra ignorar los mensajes que se refieren al identificador fantasma.
Evitar que un error idntico repetido produzca varios mensajes. Ejemplo:
{ .
{ int i;
.
/* { */ .
}
for (i=0; i<j; i++) { a=j-i+1; b=2*a+i; }
}
}
Se nos olvida poner la tercera llave. La llave siguiente cierra el segundo bloque. "i
est indefinida en el primer bloque. El bucle "for nos dara cinco veces el mensaje
"variable i indefinida.
Solucin: crear un identificador llamado "i en la tabla de smbolos con los atributos
correctos. Esto elimina los mensajes subsiguientes. Atencin: esto podra hacer
que no se detecte un error real que nos interesara atrapar. Otra alternativa sera
imprimir un solo mensaje diciendo que el identificador "i ha sido utilizado sin
declaracin previa en las lneas nmero a,b,c.
Recuperacin de errores en un intrprete
Hay que sealar el error y detener la ejecucin, permitiendo al programador
revisar las variables
revisar el cdigo
modificar el cdigo
reanudar la ejecucin
saltarse lneas
abandonar la ejecucin del ltimo programa
abandonar totalmente la ejecucin
y asegurarse de que todo sigue correctamente. En lenguaje simblico se puede
manipular la pila de ejecucin, salir automticamente de rutinas pendientes, sin
continuar la ejecucin, etc .
4.7 Generadores Codigo para Analizadores Sintacticos Yacc Bison
La entrada a programas de computacin generalmente tiene una estructura
determinada; de hecho, cada programa de computacin que recibe una entrada
puede ser visto como definidor de un "lenguaje de entrada que acepta. Un
lenguaje de entrada puede ser tan complejo como un lenguaje de programacin, o
tan simple como una secuencia de nmeros. Desafortunadamente, las facilidades
usuales para la entrada son limitadas, difciles de usar y generalmente negligentes
en cuanto al chequeo y validacin de la entrada.
YACC provee una herramienta general para describir la entrada de un programa
de computacin. El usuario de YACC especifica las estructuras de su entrada,
junto con el cdigo que ser invocado en la medida en que cada una de esas
estructuras es reconocida. YACC convierte esa especificacin en una subrutina
que maneja el proceso de entrada, frecuentemente es conveniente y apropiado
tener el mayor control en la aplicacin del usuario manejada por esta subrutina.
La subrutina de entrada producida por YACC llama a la rutina provista por el
usuario para devolver el prximo tem bsico de la entrada. As, el usuario puede
especificar su entrada en trminos de caracteres individuales de entrada, o en
trminos de constructor de mayor nivel, tales como nombres y nmeros. La rutina
provista por el usuario podra tambin manipular rasgos idiomticos tales como
comentarios y convenciones de continuacin, que comnmente desafan las
especificaciones gramaticales sencillas.
GNU Bison es un generador de parser de propsito general que convierte una
descripcin gramatical desde una gramtica libre de contexto LALR en un
programa en C para hacer el parse. Es utilizado para crear parsers para muchos
lenguajes, desde simples calculadoras hasta lenguajes complejos.
GNU Bison tiene compatibilidad con Yacc: todas las gramticas bien escritas para
Yacc, funcionan en Bison sin necesidad de ser modificadas. Cualquier persona
que est familiarizada con Yacc podra utilizar Bison sin problemas. Es necesaria
experiencia con C para utilizar Bison.
Unidad 5 Anlisis semntico
5.1 Analizador Semntico

Se compone de un conjunto de rutinas independientes, llamadas por los
analizadores morfolgico y sintctico.
El anlisis semntico utiliza como entrada el rbol sintctico detectado por el
anlisis sintctico para comprobar restricciones de tipo y otras limitaciones
semnticas y preparar la generacin de cdigo.
En compiladores de un solo paso, las llamadas a las rutinas semnticas se
realizan directamente desde el analizador sintctico y son dichas rutinas las que
llaman al generador de cdigo. El instrumento ms utilizado para conseguirlo es la
gramtica de atributos.
En compiladores de dos o ms pasos, el anlisis semntico se realiza
independientemente de la generacin de cdigo, pasndose informacin a travs
de un archivo intermedio, que normalmente contiene informacin sobre el rbol
sintctico en forma linealizada (para facilitar su manejo y hacer posible su
almacenamiento en memoria auxiliar).
En cualquier caso, las rutinas semnticas suelen hacer uso de una pila (la pila
semntica) que contiene la informacin semntica asociada a los operandos (y a
veces a los operadores) en forma de registros semnticos.
Propagacin de atributos Sea la expresin
int a,b,c;
a/(b+c^2)
El rbol sintctico es:
/
---------
| |
a +
---------
| |
b ^
---------
| |
c 2
De la instruccin declarativa, la tabla de smbolos y el analizador morfolgico
obtenemos los atributos de los operandos:
/
---------
| |
a +
int ---------
| |
b ^
int ---------
| |
c 2
int int
Propagando los atributos obtenemos:
/ int
---------
| |
a + int
int ---------
| |
b ^ int
int ---------
| |
c 2
int int
Si la expresin hubiera sido
a/(b+c^~2)
El rbol sintctico sera el mismo, sustituyendo 2 por ~2. Sin embargo, la
propagacin de atributos sera diferente:
/ real
---------
| |
a + real
int ---------
| |
b ^ real
int ---------
| |
c ~2
int int
En algn caso podra llegar a producirse error (p.e. si / representara slo la
divisin entera).
Si la expresin hubiera sido
int a,b,c,d;
a/(b+c^d)
El rbol sintctico sera el mismo, sustituyendo 2 por d. Sin embargo, la
propagacin de atributos sera incompleta:
/ {int,real}
---------
| |
a + {int,real}
int ---------
| |
b ^ {int,real}
int ---------
| |
c d
int int
El analizador semntico podra reducir los tipos inseguros al tipo mximo (real) o
utilizar un tipo interno nuevo (ej. arit={int,real}, una unin).
Lo anterior es un ejemplo de propagacin bottom-up. La propagacin top-down
tambin es posible: lo que se transmite son las restricciones y los tipos de las
hojas sirven de comprobacin. Por ejemplo, si la divisin slo puede ser entera,
transmitimos hacia abajo la restriccin de que sus operandos slo pueden ser
enteros. Al llegar a d, esa restriccin se convierte en que d debe ser positiva. Si no
lo es, error.
La implantacin de todos los casos posibles de operacin con tipos mixtos podra
ser excesivamente cara. En su lugar, se parte de operaciones relativamente
simples (ej. int+int, real+real) y no se implementan las restantes (ej. int+real,
real+int), aadiendo en su lugar operaciones mondicas de cambio de tipo (ej.
intreal).
Esta decisin puede introducir ambigedades. Por ejemplo, sea el programa
real a;
int b,c;
a:=b+c
El rbol sintctico es:
:=
---------
| |
a +
real ---------
| |
b c
int int
Existen dos conversiones posibles:
:= real := real
--------- ---------
| | | |
a + real a + int
real --------- real ---------
| | | |
b c b c
int int int int
El problema es que no tenemos garanta de que los dos procedimientos sean
equivalentes. El segundo puede dar overflow, el primero prdida de precisin. La
definicin del lenguaje debe especificar estos casos.
Las transformaciones posibles se pueden representar mediante un grafo cuyos
nodos son los tipos de datos y cada arco indica una transformacin. Dado un
operando de tipo A que se desea convertir al tipo B, se trata de encontrar una
cadena de arcos que pase de A a B en el grafo anterior. Podra haber varios
grafos, cada uno de los cuales se aplicar en diferentes condiciones, por ejemplo,
uno para las asignaciones, otro para las expresiones, etc.
5.2 Verificacion Tipos en Expresiones
5.3 Conversin de Tipos
Hay situaciones en las cuales se tiene un valor de un tipo dado y se desea
almacenar ese valor en una variable de un tipo diferente. En algunos tipos es
posible almacenar simplemente el valor sin una conversin de tipos; lo que se
denomina conversin automtica. Esto slo es posible en Java si el compilador
reconoce que la variable destino tiene la suficiente precisin para contener el valor
origen, como almacenar un valor byte en una variable int. A esto se le llama
ensanchamiento o promocin, dado que el tipo ms pequeo se ensancha o
promociona al tipo compatible ms grande. Si por el contrario, se desea asignar un
valor de variable int a una variable byte se necesita realizar una conversin de
tipos explcita. A esto se le llama estrechamiento, dado que se estrecha
explcitamente el valor para que quepa en el destino. La conversin de un tipo se
realiza poniendo delante un nombre de tipo entre parntesis, por ejemplo, (tipo)
valor. El cdigo siguiente demuestra la conversin de tipos de int a byte. Si el valor
del entero fuese mayor que el rango de un byte, se reducira al mdulo (resto de la
divisin) del rango de byte.
int a = 100;
byte b = (byte) a;
5.4 Acciones Agregadas Analizador Sintactico Descendente (top-down)
Muchas de las actividades que realiza un analizador semntico no son
estndares, dependern del objetivo del lenguaje de programacin; por ejemplo,
en algunas aplicaciones es interesante conocer que los datos estn en algn
rango vlido o que ciertos valores se utilicen para uso reservado
Acciones agregadas a un analizador semntico
En algunas ocasiones nos interesa conocer el significado de las palabras de
algn lenguaje dependiendo del contexto (gramticas de tipo 1) para diferenciar
palabras polisemnticas.
5.5 Pila Semantica En Analizador Sintactico Ascendente (bottom-up)
El diseo ascendente se refiere a la identificacin de aquellos procesos que
necesitan computarizarse con forme vayan apareciendo, su anlisis como sistema
y su codificacin, o bien, la adquisicin de paquetes de software para satisfacer el
problema inmediato.
Pila semntica
Los problemas de integracin entre los subsistemas son sumamente costosos y
muchos de ellos no se solucionan hasta que la programacin alcanza la fecha
limite para la integracin total del sistema.
Se necesita una memoria auxiliar que nos permita guardar los datos intermedios
para poder hacer la comparacin.
5.6 Administracin Tabla de Smbolos
"La tabla de smbolos registra informacin acerca de cada nombre de smbolo en
un programa. Histricamente, los nombres se llamaron smbolos, ms que de una
tabla de nombres. En este captulo, la palabra smbolo significa nombre. La fase
de anlisis semntico crea la tabla de smbolos, puesto que no es sino hasta este
anlisis que se tiene la suficiente informacin sobre un nombre para describirlo. La
generacin de cdigo usa la tabla de smbolos para extraer las directivas del
ensamblador, para el tipo y para el tamao apropiados.
Una tabla de smbolos es una estructura de datos que contiene un registro por
cada identificador. El registro incluye los campos para los atributos del
identificador.
El administrador de la tabla de smbolos se encarga de manejar los accesos a la
tabla de smbolos, en cada una de las etapas de compilacin de un programa.

5.7 Manejo Errores Semnticos
Un compilador es un sistema que en la mayora de los casos tiene que manejar
una entrada incorrecta. Sobre todo en las primeras etapas de la creacin de un
programa, es probable que el compilador se utilizar para efectuar las
caractersticas que debera proporcionar un buen sistema de edicin dirigido por la
sintaxis, es decir, para determinar si las variables han sido declaradas antes de
usarla, o si faltan corchetes o algo as. Por lo tanto, el manejo de errores es parte
importante de un compilador y el escritor del compilador siempre debe tener esto
presente durante su diseo.
Hay que sealar que los posibles errores ya deben estar considerados al disear
un lenguaje de programacin. Por ejemplo, considerar si cada proposicin del
lenguaje de programacin comienza con una palabra clave diferente (excepto la
proposicin de asignacin, por supuesto). Sin embargo, es indispensable lo
siguiente:
El compilador debe ser capaz de detectar errores en la entrada;
El compilador debe recuperarse de los errores sin perder demasiada informacin;
Y sobre todo, el compilador debe producir un mensaje de error que permita al
programador encontrar y corregir fcilmente los elementos (sintcticamente)
incorrectos de su programa.
Los mensajes de error de la forma
*** Error 111 ***
*** Ocurri un error ***
*** Falta declaracin ***
*** Falta delimitador ***
no son tiles para el programador y no deben presentarse en un ambiente de
compilacin amigable y bien diseado. Por ejemplo, el mensaje de error 'Falta
declaracin' podra reemplazarse por
*** No se ha declarado la variable Nombre ***
o en el caso del delimitador omitido se puede especificar cul es el delimitador
esperado. Adems de estos mensajes de error informativos, es deseable que el
compilador produzca una lista con el cdigo fuente e indique en ese listado dnde
han ocurrido los errores.
No obstante, antes de considerar el manejo de errores en el anlisis lxico y
sintctico, hay que caracterizar y clasificar los errores posibles (Sec. 6.1). Esta
clasificacin nos mostrar que un compilador no puede detectar todos los tipos de
errores.
Clasificacin de Errores
Durante un proceso de resolucin de problemas existen varias formas en que
pueden surgir errores, las cuales se reflejan en el cdigo fuente del programa.
Desde el punto de vista del compilador, los errores se pueden dividir en dos
categoras:
Errores visibles y Errores invisibles

Los errores invisibles en un programa son aquellos que no puede detectar el
compilador, ya que no son el resultado de un uso incorrecto del lenguaje de
programacin, sino de decisiones errneas durante el proceso de especificacin o
de la mala formulacin de algoritmos. Por ejemplo, si se escribe
a : = b + c ; en lugar de a : = b * c ;
el error no podr ser detectado por el compilador ni por el sistema de ejecucin.
Estos errores lgicos no afectan la validez del programa en cuanto a su correccin
sintctica. Son objeto de tcnicas formales de verificacin de programas que no se
consideran aqu. Para conocer ms sobre la verificacin de programas, consulte,
por ejemplo, [LOEC 87].
Los errores visibles, a diferencia de los errores lgico, pueden ser detectados por
el compilador o al menos por el sistema de ejecucin. Estos errores se pueden
caracterizar de la siguiente manera:
Errores de ortografa y
Errores que ocurren por omitir requisitos formales del lenguaje de programacin.
Estos errores se presentar porque los programadores no tienen el cuidado
suficiente al programador. Los errores del segundo tipo tambin pueden ocurrir
porque el programador no comprende a la perfeccin el lenguaje que se utiliza o
porque suele escribir sus programas en otro lenguaje y, por tanto, emplea las
construcciones de dicho lenguaje (estos problemas pueden presentarse al usar a
la vez lenguajes de programacin como PASCAL y MODULA-2, por ejemplo).
Clasificacin de Ocurrencias
Por lo regular, los errores visibles o detectables por el compilador se dividen en
tres clases, dependiendo de la fase del compilador en el cual se detectan:
Errores Lxicos;
Errores Sintcticos;
Errores Semnticos;
Por ejemplo, un error lxico puede ocasionarse por usar un carcter invlido (uno
que no pertenezca al vocabulario del lenguaje de programacin) o por tratar de
reconocer una constante que produce un desbordamiento.
Un error de sintaxis se detecta cuando el analizador sintctico espera un smbolo
que no corresponde al que se acaba de leer. Los analizadores sintcticos LL y LR
tienen la ventaja de que pueden detectar errores sintcticos lo ms pronto posible,
es decir, se genera un mensaje de error en cuanto el smbolo analizado no sigue
la secuencia de los smbolos analizados hasta ese momento.
Los errores semnticos corresponden a la semntica del lenguaje de
programacin, la cual normalmente no est descrita por la gramtica. Los errores
semnticos ms comunes son la omisin de declaraciones.
Adems de estas tres clases de errores, hay otros que sern detectados por el
sistema de ejecucin porque el compilador ha proporcionado el cdigo generado
con ciertas acciones para estos casos.
Un Error de Ejecucin
tpico ocurre cuando el ndice de una matriz no es un elemento del subintervalo
especificado o por intentar una divisin entre cero. En tales situaciones, se informa
del error y se detiene la ejecucin del programa.
Clasificacin Estadstica
Ripley y Druseikis muestran resultados interesantes sobre el anlisis estadstico
de los errores de sintaxis en [RPL 78]. Ellos investigaron los errores que cometen
los programadores de PASCAL y analizaron los resultados en relacin con las
estrategias de recuperacin. El resultado principal del estudio fue que los errores
de sintaxis suelen ser muy simples y que, por lo general, slo ocurre un error por
frase. En el resumen siguiente se describen de manera general los resultados del
estudio:
Al menos el 40% de los programas compilados eran sintctica o semnticamente
incorrectos.
Un 80% de las proposiciones incorrectas slo tenan un error.
El 13% de las proposiciones incorrectas tenan dos errores, menos del 3% tenan
tres errores y el resto tenan cuatro o ms errores por proposicin.
En aproximadamente la mitad de los errores de componentes lxicos olvidados, el
elemento que faltaba era ":", mientras que omitir el "END" final ocupaba el
segundo lugar, con un 10.5%.
En un 13% de los errores de componentes lxico incorrecto se escribi "," en lugar
de ";" y en ms del 9% de los casos se escribi ":=" en lugar de "=".
Los errores que ocurren pueden clasificarse en cuatro categoras:
Errores de puntuacin,
Errores de operadores y operandos,
Errores de palabras clave y
Otros tipos de errores.
La distribucin estadstica de estas cuatro categoras aparece en la figura 6.1.
Efectos de los Errores
La deteccin de un error en el cdigo fuente ocasiona ciertas reacciones del
compilador. El comportamiento de un compilador en el caso de que el cdigo
fuente contenga un error puede tener varias facetas:
El proceso de compilacin de detiene al ocurrir el error y el compilador debe
informar del error.
El proceso de compilacin contina cuando ocurre el error y se informa de ste en
un archivo de listado.
El compilador no reconoce el error y por tanto no advierte al programador.
La ltima situacin nunca debe presentarse en un buen sistema de compilacin;
es decir, el compilador debe ser capaz de detectar todos los errores visibles.
La detencin del proceso de compilacin al detectar el primer error es la forma
ms simple de satisfacer el requisito de que una compilacin siempre debe
terminar, sin importar cul sea la entrada [BRN 85]. Sin embargo, este
comportamiento tambin es el peor en un ambiente amigable para el usuario, ya
que una compilacin puede tardar varios minutos. Por lo tanto, el programador
espera que el sistema de compilacin detecte todos los errores posibles en el
mismo proceso de compilacin.
Entonces, en general, el compilador debe recuperarse de un error para poder
revisar el cdigo fuente en busca de otros errores. No obstante, hay que observar
que cualquier "reparacin" efectuada por el compilador tiene el propsito nico de
continuar la bsqueda de otros errores, no de corregir el cdigo fuente. No hay
reglas generales bien definidas acerca de cmo recuperarse de un error, por lo
cual el proceso de recuperacin debe hacerse en hiptesis acerca de los errores.
La carencia de tales reglas se debe al hecho de que el proceso de recuperacin
siempre depende del lenguaje.
Manejo de Errores en el Anlisis Lxico
Los errores lxicos se detectan cuando el analizador lxico intenta reconocer
componentes lxicos en el cdigo fuente. Los errores lxicos tpicos son:
Nombres ilegales de identificadores: un nombre contiene caracteres invlidos;
Nmeros invlidos: un nmero contiene caracteres invlidos (por ejemplo; 2,13 en
lugar de 2.13), no est formando correctamente (por ejemplo, 0.1.33), o es
demasiado grande y por tanto produce un desbordamiento;
Cadenas incorrectas de caracteres: una cadena de caracteres es demasiado larga
(probablemente por la omisin de comillas que cierran);
Errores de ortografa en palabras reservadas: caracteres omitidos, adicionales,
incorrectos o mezclados;
Etiquetas ilegales: una etiqueta es demasiado larga o contiene caracteres
invlidos;
Fin de archivo: se detecta un fin de archivo a la mitad de un componente lxico.
La mayora de los errores lxicos se deben a descuidos del programador. En
general, la recuperacin de los errores lxicos es relativamente sencilla.
Si un nombre, un nmero o una etiqueta contiene un carcter invlido, se elimina
el carcter y contina el anlisis en el siguiente carcter; en otras palabras, el
analizador lxico comienza a reconocer el siguiente componente lxico. El efecto
es la generacin de un error de sintaxis que ser detectado por el analizador
sintctico. Este mtodo tambin puede aplicarse a nmeros mal formados.
Las secuencias de caracteres como 12AB pueden ocurrir si falta un operador (el
caso menos probable) o cuando se han tecleado mal ciertos caracteres. Es
imposible que el analizador lxico pueda decidir si esta secuencia es un
identificador ilegal o u nmero ilegal. En tales casos, el analizador lxico puede
saltarse la cadena completa o intentar dividir las secuencias ilegales en
secuencias legales ms cortas. ndependientemente de cul sea la decisin , la
consecuencia ser un error de sintaxis.
La deteccin de cadenas demasiado margas no es muy complicada, incluso si
faltan las comillas que cierran, porque por lo general no est permitido que las
cadenas pasen de una lnea a la siguiente. Si faltan las comillas que cierran,
puede usarse el carcter de fin de lnea como el fin de cadena y reanudar el
anlisis lxico en la lnea siguiente. Esta reparacin quizs produzca errores
adicionales. En cualquier caso, el programador debe ser informado por medio de
un mensaje de error.
Un caso similar a la falta de comillas que cierran en una cadena, es la falta de un
smbolo de terminacin de comentario. Como por lo regular est permitido que los
comentario abarquen varias lneas, no podr detectarse la falta del smbolo que
cierra el comentario hasta que el analizador lxico llegue al final del archivo o al
smbolo de fin de otro comentario (si no se permiten comentarios anidados).
Si se sabe que el siguiente componente lxico debe ser una palabra reservada, es
posible corregir una palabra reservada mal escrita. Esto se hace mediante
funciones de correccin de errores, bien conocidas en los sistemas de lenguajes
naturales, o simplemente aplicando una funcin de distancia mtrica entre la
secuencia de entrada y el conjunto de palabras reservadas.
Por ltimo, el proceso de compilacin puede terminar si se detecta un fin de
archivo dentro de un componente lxico.
Manejo de Errores en el Anlisis Sintctico
El analizador sintctico detecta un error de sintaxis cuando el analizador lxico
proporciona el siguiente smbolo y ste es incompatible con el estado actual del
analizador sintctico. Los errores sintcticos tpicos son:
Parntesis o corchetes omitidos, por ejemplo, x : = y * (1 + z;
Operadores u operando omitidos, por ejemplo, x : = y (1 + z );
Delimitadores omitidos, por ejemplo, x : = y + 1 F a THEN y : = z.
No hay estrategias de recuperacin de errores cuya validez sea general, y la
mayora de las estrategias conocidas son heursticas, ya que se basan en
suposiciones acerca de cmo pueden ocurrir los errores y lo que probablemente
quiso decir el programador con una determinada construccin. Sin embargo, hay
algunas estrategias que gozan de amplia aceptacin:
Recuperacin de emergencia (o en modo pnico): Al detectar un error, el
analizador sintctico salta todos los smbolos de entrada hasta encontrar un
smbolo que pertenezca a un conjunto previamente definido de smbolos de
sincronizacin. Estos smbolos de sincronizacin son el punto y como, el smbolo
end o cualquier palabra clave que pueda ser el inicio de una proposicin nueva,
por ejemplo. Es fcil implantar la recuperacin de emergencia, pero slo reconoce
un error por proporcin. Esto no necesariamente es una desventaja, ya que no es
muy probable que ocurran varios errores en la misma proposicin (vase [PL 78],
por ejemplo). Esta suposicin es un ejemplo tpico del carcter heurstico de esta
estrategia.
Recuperacin por insercin, borrado y reemplazo: ste tambin es un mtodo fcil
de implantar y funciona bien en ciertos casos de error. Usemos como ejemplo una
declaracin de variable en PASCAL . cuando una coma va seguida por dos
puntos, en lugar de un nombre de variable, es posible eliminar esta coma. En
forma similar, se puede insertar un punto y coma omitido o reemplazar un punto y
coma por una coma en una lista de parmetros.
Recuperacin por expansin de gramtica: De acuerdo con [RPL 78], el 60% de
los errores en los programas fuente son errores de puntuacin, por ejemplo, la
escritura de un punto y coma en lugar de una coma, o viceversa. Una forma de
recuperarse de estos errores es legalizarlos en ciertos casos, introduciendo lo que
llamaremos producciones de error en la gramtica del lenguaje de programacin.
La expansin de la gramtica con estas producciones no quiere decir que ciertos
errores no sern detectados, ya que pueden incluirse acciones para informar de su
deteccin.
La recuperacin de emergencia es la estrategia que se encontrar en la mayora
de los compiladores, pero la legalizacin de ciertos errores mediante la definicin
de una gramtica aumentada es una tcnica que se emplea con frecuencia. No
obstante, hay que expandir la gramtica con mucho cuidado para asegurarse de
que no cambien el tipo y las caractersticas de la gramtica.
Los errores de sintaxis se detectan cuando el analizador sintctico espera un
smbolo que no concuerda con el smbolo que est analizando, a . En los
analizadores sintcticos LL, los errores de sintaxis se detectan cuando a y el no
terminal que estn en la cima de la pila nos llevan a un ndice de una posicin
vaca de la tabla de anlisis sintctico. En los analizadores sintcticos LR, los
errores de sintaxis se detectan cuando hay un ndice a una posicin vaca de la
tabla, o sea, cuando no se especifica ninguna transicin al analizar en el estado
actual (vase Cap. 4). Sin embargo, si se emplea una gramtica aumentada con
producciones de error adicionales, no slo se detectarn errores por medio de los
ndices a posiciones vacas de la tabla de anlisis sintctico.
Errores Semnticos
Los errores que puede detectar el analizador sintctico son aquellos que violan las
reglas de una gramtica independiente del contexto. Ya hemos mencionado que
algunas de las caractersticas de un lenguaje de programacin no pueden
enunciarse con reglas independientes del contexto, ya que dependen de l; por
ejemplo, la restriccin de que los identificadores deben declararse previamente.
Por lo tanto, los principales errores semnticos son:
dentificadores no definidos;
Operadores y operandos incompatibles.
Es mucho ms difcil introducir mtodos formales para la recuperacin de errores
semnticos que para la recuperacin de errores sintcticos, ya que a menudo la
recuperacin de errores semnticos es ad hoc. No obstante, puede requerirse
que, por lo menos, el error semntico sea informado al programador, que se le
ignore y que, por tanto, se suprimir la generacin de cdigo.
Sin embargo, la mayora de los errores semnticos pueden ser detectados
mediante la revisin de la tabla de smbolos, suponiendo un tipo que se base en el
contexto donde ocurra o un tipo universal que permita al identificador ser un
operando de cualquier operador del lenguaje. Al hacerlo, evitamos la produccin
de un mensaje de error cada vez que se use la variable no definida. Si el tipo de
un operando no concuerda con los requisitos de tipo del operador, tambin es
conveniente reemplazar el operando con una variable ficticia de tipo universal.
Recuperacin de Errores PL/0
A continuacin ejemplificaremos algunos de los mtodos antes mencionados para
la recuperacin de errores sintcticos. Para ellos expandiremos fragmentos del
programa del analizador sintctico descendente recursivo de PL/0 que vimos en el
captulo 4.
Recuperacin de Emergencia
La idea del anlisis sintctico descendente recursivo es que un problema de
anlisis sintctico se divida en subproblemas que se resuelven en forma recursiva.
Ahora bien, la ocurrencia de un error en un subproblema significa que no slo hay
que informar del error al procedimiento que llama. Mas bien, hay que garantizar
que el procedimiento del subproblema se recupere del error de modo que el
procedimiento invocador pueda continuar con el proceso de anlisis sintctico, es
decir, que termine de forma normal.
Por ello, adems de generar un mensaje de error, hay que ir saltndose la entrada
hasta llegar a un smbolo de sincronizacin. Esto implica que cada procedimiento
de un analizador sintctico descendente recursivo debe conocer cules son los
smbolos
PROCEDURE Prueba(Siguiente, detencin: conjsm; n:
NTEGER);
(*siguiente, detencin: smbolos de sincronizacin*)
(*n: nmero de error *)
VAR smsinc : conjsm;
BEJN
F NOT (smbolo N siguiente) THEN
Error (n);
Smsinc := siguiente + detencin;
WHLE NOT (smbolo N smsinc) DO Leer_Smbolo END
END
END Prueba;
Figura 6.2 Procedimiento para revisar y saltar smbolos

PROCEDURE Expresin (siguiente: conjsm);
VAR ADDoSUB: smbolos;
PROCEDURE Trmino (siguiente: conjsm);
VAR MULoDV:smbolos;
PROCEDURE Factor (siguiente: conjsm);
VAR i: NTEGER;
BEGN (*Factor*)
Prueba (iniciofact, siguiente, ...);
WHLE smbolo N iniciofact DO
...
Prueba (siguiente, [pareni], ...)
END
END Factor;
BEGN (*Trmino*)
Factor (siguiente + [por, diagonal]);
WHLE smbolo N [por, diagonal]) DO
MULoDV := smbolo; Leer_Smbolo;
Factor (siguiente + [por, diagonal]);
...
END
END Trmino;
BEGN (*Expresin*)
...
END Expresin;
Figura 6.3 Uso del procedimiento de prueba
vlidos que le pueden seguir. Para evitar el salto descontrolado de smbolos, se
aumentan los conjuntos de smbolos de detencin adicionales que indiquen las
construcciones que no deben saltarse. Los smbolos siguientes y los smbolos de
detencin forman, en conjunto, los smbolos de sincronizacin.
En la caso de la implantacin, esto quiere decir que cada procedimiento de
anlisis sintctico consta de un parmetro que especifica el conjunto de los
smbolos vlidos que siguen. La prueba para los smbolos de sincronizacin puede
efectuarse fcilmente con el procedimiento presentado en la figura 6.2. este
procedimiento prueba si un smbolo siguiente es legal. En caos de un smbolo
ilegal, se genera un mensaje de error y se saltan los smbolos de entrada hasta
detectar un smbolo de sincronizacin. Este procedimiento de prueba ser
invocado al final de cada procedimiento para verificar que le smbolo siguiente sea
vlido, pero tambin puede emplearse al iniciar un procedimiento de anlisis
sintctico para verificar si el smbolo de entrada actual es un smbolo inicial
permitido. El uso del procedimiento de prueba se ilustra en la figura 6.3 para el
anlisis sintctico de expresiones aritmticas (donde 'iniciofact' indica los smbolos
iniciales permitidos para 'Factor').
Expansin de Gramtica
Como ya mencionamos, es un hecho bien conocido que los errores de puntuacin
son muy comunes. Por ejemplo, consideremos las constantes PL/0 que se
separan por comas; un error frecuente en el cual podramos pensar sera el uso de
un punto y coma en lugar de la coma. Sabiendo esto, la estructura sintctica de
las declaraciones de constantes puede modificarse de manera que se permita
usar coma y punto y coma, como se muestra en la figura 6.4.
La declaracin modificada de constantes de la figura 6.4 legaliza el error que
acabamos de describir. El diagrama sintctico de la figura 6.4 puede entonces
traducirse al fragmento de programa de la figura 6.5, mediante las tcnicas
presentadas en el captulo 4.

F smbolo = smconst THEN
Leer_Smbolo;
REPEAT
Declaracin_const;
WHLE smbolo = coma DO
Leer_Smbolo; Declaracin_const
END;
F smbolo = puntocoma THEN Leer_Smbolo
ELSE Error(...) END;
UNTL (smbolo <> ident);
END;
Figura 6.5 Cdigo modificado para el anlisis des de constantes

El fragmento del programa de la figura 6.5 permite la separacin de constantes
con comas o puntos y coma sin producir mensajes de error. Adems de esta
legalizacin, se aceptar la omisin de la coma y el punto y coma; sin embargo, en
este caso s se produce un mensaje de error. Es obvio que de esta misma forma
podemos expandir la sintaxis de las declaraciones de variables para permitir la
separacin con puntos y coma o incluso con espacios (vase Fig. 6.6).

F smbolo = smvar THEN
Ler_Smbolo;
REPEAT
Declaracin_var;
WHLE smbolo = coma DO
Leer_Smbolo; Declaracin_var
END;
F smbolo = puntocoma THEN Leer_Smbolo
ELSE Error (...) END;
UNTL (smbolo <> ident);
END;

En forma anloga, puede permitirse la omisin del punto y coma entre dos
proposiciones. Esto muestra en el fragmento de programa de la figura 6.7, donde
'sminicioprop' es el conjunto de smbolos iniciales de la proposiciones.

F smbolo = smbegin THEN
Leer_Smbolo;
REPEAT
Proposicin (siguiente + [puntocoma, smend]);
WHLE smbolo = puntocoma DO
Leer_Smbolo;
Proposicin (siguiente + [puntocoma, smed]);
END
UNTL NOT (smbolo N sminicioprop);
F smbolo = smed THEN
Leer_smbollo
ELSE Error(...) END;
END;
Unidad 6 Generacin de cdigo
6.1 Lenguajes ntermedios
Lenguaje ntermedio. Tipo (1)
Es una representacin ms abstracta y uniforme que un lenguaje mquina
concreto. Su misin es descomponer las expresiones complejas en binarias y las
sentencias complejas en sentencias simples. Ventajas: Permite una fase de
anlisis (anlisis semntico) independiente de la mquina. Se pueden realizar
optimizaciones sobre el cdigo intermedio (Las complejas rutinas de optimizacin
son independientes de la mquina). Desventajas: Prdida de eficiencia (no
permite una compilacin de una sola pasada). ntroduce en el compilador una
nueva fase de traduccin.
Lenguaje ntermedio. Tipo (2)
Tipos de lenguajes intermedios: rbol sintctico. rbol sintctico abstracto.
Todos los nodos del rbol representan smbolos terminales. Los nodos hijos son
operandos y los nodos internos son operadores. Grafo dirigido acclico (GDA).
Notacin posfija. Definicin de una mquina abstracta. N-tupla: Cada
sentencia del lenguaje intermedio consta de N elementos: (Operador, Operando1,
Operando2, . , Operando N ?~1) Los ms usuales son los tercetos (tripletas) y
los cuartetos (cudruplas), llamados tambin cdigo de tres direcciones.
Lenguaje ntermedio. Tipo (3)
Tripletas: Ejemplo: d = a + b * c [1] (*, b, c) [2] (+, a, [1]) [3] (=, d, [2]) <operador>,
<operando_1>, <operando_2> Cuartetos: Ejemplo: d = a + b * c (*, b, c, temp1) (+,
a, temp1, temp2) (=, temp2, , d)
6.2 Notaciones Lenguajes ntermedios
6.2.1 nfija Lenguajes ntermedios
6.2.2 Postfija Lenguajes ntermedios
6.2.3 Prefija Lenguajes ntermedios
6.3 Representacin Cdigo ntermedio
6.3.1 Notacin Polaca
La notacin polaca es la originada por un Autmata con pila, en la que los
operadores siempre preceden a los operandos sobre los que actan, y que tiene la
ventaja de no necesitar parntesis:
Estandar
Ejemplo 1: 2 * ( 3 + 5 )
Ejemplo 2: 2 * 3 + 5
Polaca
Ejemplo 1: * 2 + 3 5
Ejemplo 2: + * 2 3 5
6.3.2 Cdigo P
Cdigo P o Prolog
Prolog, proveniente del francs Programation et Logique, es un lenguaje de
programacin lgico e interpretado, bastante popular en el medio de investigacin
en nteligencia Artificial.
Se trata de un lenguaje de programacin ideado a principios de los aos 70 en la
universidad de Aix-Marseille por los profesores Alain Colmerauer y Phillipe
Roussel. nicialmente se trataba de un lenguaje totalmente interpretado hasta que,
a mediados de los 70, David H.D. Warren desarroll un compilador capaz de
traducir Prolog en un conjunto de instrucciones de una mquina abstracta
denominada Warren Abstract Machine, o abreviadamente, WAM. Desde entonces
Prolog es un lenguaje semi-interpretado.
Prolog se enmarca en el paradigma de los lenguajes lgicos, lo que lo diferencia
enormemente de otros lenguajes ms populares tales como Fortran, Pascal, C,
etc.
En todos los mencionados, las instrucciones se ejecutan normalmente en orden
secuencial, es decir, una a continuacin de otra, en el mismo orden en que estn
escritas, que slo vara cuando se alcanza una instruccin de control (un bucle,
una instruccin condicional o una transferencia).
Los programas en Prolog se componen de clusulas de Horn que constituyen
reglas del tipo "modus ponendo ponens, es decir, "Si es verdad el antecendente,
entonces es verdad el consecuente. No obstante, la forma de escribir las
clusulas de Horn es al contrario de lo habitual. Primero se escribe el consecuente
y luego el antecedente. El antecedente puede ser una conjuncin de condiciones
que se denomina secuencia de objetivos. Cada objetivo se separa con una coma y
puede considerarse similar a una instruccin o llamada a procedimiento de los
lenguajes imperativos. En Prolog no existen instrucciones de control. Su ejecucin
se basa en dos conceptos: la unificacin y el backtracking. Gracias a la
unificacin, cada objetivo determina un subconjunto de clusulas susceptibles de
ser ejecutadas. Cada una de ellas se denomina punto de eleccin. Prolog
selecciona el primer punto de eleccin y sigue ejecutando el programa hasta
determinar si el objetivo es verdadero o falso. En caso de ser falso entra en juego
el 'backtracking', que consiste en deshacer todo lo ejecutado situando el programa
en el mismo estado en el que estaba justo antes de llegar al punto de eleccin.
Entonces se toma el siguiente punto de eleccin que estaba pendiente y se repite
de nuevo el proceso. Todos los objetivos terminan su ejecucin bien en
"verdadero, bien en "falso.
Las listas son colecciones de elementos en Prolog. Una lista se divide en dos
partes: Cabeza. Es el primer elemento de la lista. Cola. Es una lista con el resto de
los elementos de la lista. La cabeza y la cola de una lista se separan con el
smbolo "|.
Ejemplo de Cdigo Prolog
declaraciones
padrede('juan', 'maria'). % juan es padre de maria
padrede('pablo', 'juan'). % pablo es padre de juan
padrede('pablo', 'marcela').
padrede('carlos', 'debora').
% A es hijo de B si B es padre de A
hijode(A,B) :- padrede(B,A).
% A es abuelo de B si A es padre de C y C es padre B
abuelode(A,B) :-
padrede(A,C),
padrede(C,B).
% A y B son hermanos si el padre de A es tambin el padre de B y si A y B no son
lo mismo
hermanode(A,B) :-
padrede(C,A) ,
padrede(C,B),
A \== B.
% A y B son familiares si A es padre de B o A es hijo de B o A es hermano de B
familiarde(A,B) :-
padrede(A,B).
familiarde(A,B) :-
hijode(A,B).
familiarde(A,B) :-
hermanode(A,B).
consultas
% juan es hermano de marcela?
?- hermanode('juan', 'marcela').
yes
% carlos es hermano de juan?
?- hermanode('carlos', 'juan').
no
% pablo es abuelo de maria?
?- abuelode('pablo', 'maria').
yes
% maria es abuelo de pablo?
?- abuelode('maria', 'pablo').
no
Ejemplo sobre Listas Prolog
% Si queremos hallar la longitud de una lista.
% La longitud de una lista vacia es 0.
% La longitud de cualquier lista es la longitud de la cola + 1.
longitud([],0).
longitud([H|T],N):-longitud(T,N0), N is N0 + 1.
?- longitud([a,b,c],L).
3
?- longitud([a,b,c],4).
No
% Si queremos determinar si un elemento es pertenece a una lista.
% El elemento pertenece a la lista si coincide con la cabeza de la lista.
% El elemento pertenece a la lista si es se encuentra en la cola de la lista.
pertenece(X,[X|_]).
pertenece(X,[_|R]):- pertenece(X,R).
?- pertenece(b,[a,b,c]).
Yes
?- pertenece(b,[a,[b,c]]).
No
?- pertenece([b,c],[a,[b,c]]).
Yes
% Si queremos eliminar un elemento de la lista.
% Si X es la cabeza de la lista, la cola T es la lista sin X
% Si X no es la cabeza de la lista, conservamos la cabeza de la lista
% como parte de la respuesta y continuamos eliminando X de la cola T.
elimina (X,[X|T],T).
elimina (X,[H|T],[H|T1]):- elimina (X,T,T1).
?- elimina(1,[1,2,3,4],R).
R = [2,3,4]
?- elimina(1,R,[2,3]).
R = [1, 2, 3]
R = [2, 1, 3]
R = [2, 3, 1]
% Si queremos calcular la inversa de una lista.
% La inversa de una lista vacia es una lista vacia.
% La inversa de H|T es la inversa de T concatenada con H.
inversa([],[]).
inversa([H|T],L):- inversa(T,R), concatenar(R,[H],L).
?- inversa([a,b,c,d],[d,c,b,a]).
6.3.3 Triplos Lenguajes ntermedios
6.3.4 Cudruplos Lenguajes ntermedios
6.4 Esquemas de Generacin Lenguajes ntermedios
Cuando una empresa desarrolla un compilador para un lenguaje fuente y un
lenguaje objeto determinados, normalmente no es el nico compilador que la
empresa piensa desarrollar; es ms muchos fabricantes de microprocesadores
tienen una divisin de dedicada a desarrollar compiladores para los nuevos chips
que construya.
Cuando el nmero de lenguaje fuente crece hasta un nmero grande M, y/o
cuando el nmero de lenguajes objeto tambin crece hasta un nmero grande N,
es necesario encontrar una tcnica para evitar tener que disear M x N
compiladores. La solucin consiste en utilizar un lenguaje intermedio o una
representacin intermedia; de esta forma slo hay que construir M programas que
traduzcan de cada lenguaje fuente al lenguaje intermedio (los front ende), y N
programas que traduzcan del lenguaje intermedio a cada lenguaje objeto (los back
end).
La matemtica (del lat. mathematca, y este del gr. d d0qd, derivado de
0qd, conocimiento) es una ciencia formal que estudia las propiedades y las
relaciones que se pueden establecer entre los entes abstractos, como los
smbolos, los nmeros y las figuras geomtricas.[1]
Aunque la matemtica sea la supuesta "Reina de las Ciencias, algunos
matemticos no la consideran una ciencia natural. Principalmente, los
matemticos definen e investigan estructuras y conceptos abstractos por razones
puramente internas a la matemtica, debido a que tales estructuras pueden
proveer, por ejemplo, una generalizacin elegante, o una herramienta til para
clculos frecuentes. Adems, muchos matemticos consideran la matemtica
como una forma de arte en vez de una ciencia prctica o aplicada. Sin embargo,
las estructuras que los matemticos investigan frecuentemente s tienen su origen
en las ciencias naturales, y muchas veces encuentran sus aplicaciones en ellas,
particularmente en la fsica.
No existe un nico lenguaje intermedio en todos los compiladores, sino que cada
empresa que disea compiladores suele tener su propio lenguaje intermedio. La
utilizacin de un lenguaje intermedio permite construir en, mucho menos tiempo un
compilador para otra mquina y tambin permite construir compiladores para otros
lenguajes fuente generando cdigos para la misma mquina. La matemtica es un
arte, pero tambin una ciencia de estudio. nformalmente, se puede decir que es el
estudio de los "nmeros y smbolos. Es decir, es la investigacin de estructuras
abstractas definidas a partir de axiomas, utilizando la lgica y la notacin
matemtica. Es tambin la ciencia de las relaciones espaciales y cuantitativas. Se
trata de relaciones exactas que existen entre cantidades y magnitudes, y de los
mtodos por los cuales, de acuerdo con estas relaciones, las cantidades buscadas
son deducibles a partir de otras cantidades conocidas o presupuestas.
Vase tambin: Filosofa de la matemtica No es infrecuente encontrar a quien
describe la matemtica como una simple extensin de los lenguajes naturales
humanos, que utiliza una gramtica y un vocabulario definidos con extrema
precisin, cuyo propsito es la descripcin y exploracin de relaciones
conceptuales y fsicas. Recientemente, sin embargo, los avances en el estudio del
lenguaje humano apuntan en una direccin diferente: los lenguajes naturales
(como el espaol y el francs) y los lenguajes formales (como la matemtica y los
lenguajes de programacin) son estructuras de naturaleza bsicamente diferente.
Por ejemplo, el compilador de C de GNU que se distribuye con Linux es una
versin de una familia de compiladores de C para diferentes mquinas o sistemas
operativos: Alpha, AX, Sun, HP, MS-DOS, etc.. Adems, GNU ha desarrollado un
compilador de FORTRAN y otro de Pascal que, al utilizar el mismo lenguaje
intermedio, pueden ser portados a todos los sistemas y mquinas en las que y a
existe un compilador de C de GNU con relativamente poco esfuerzo.
La generacin de cdigo intermedio transforma un rbol de anlisis sintctico
(semntico) en una representacin en un lenguaje intermedio, que suele ser
cdigo suficientemente sencillo para poder luego generar cdigo mquina.
Una forma de hacer esto es mediante el llamado cdigo de tres direcciones. Una
sentencia en cdigo de tres direcciones es: A := B op C, donde A, B y C son
operandos y op es un operador binario. Tambin permite condiciones simples y
saltos. Por ejemplo, para la siguiente sentencia:
WHLE (A > B) AND (A < = 2 * B 5) DO A : = A + B
el cdigo intermedio generado ( cdigo en tres direcciones) ser:
L1 : F A > B GOTO L2
GOTO L3
L2 : T1 : = 2 * B (*nivel ms alto que ensamblador*)
T2 : = T1 5 (*pero ms sencillo que Pascal*)
F A < T2 GOTO L4
GOTO L3
L4 : A : = A + B
GOTO L1
L3 : . . . . . . .
APLCACONES
La importancia practica de lenguaje en la informtica se manifiesta principalmente
en el uso cotidiano que hace el profesional informtico de compiladores e
interpretes, consustancial al la gestin y programacin de los sistemas
informticos. As pues, un conocimiento acerca del funcionamiento interno de
estas herramientas bsicas resulta fundamental. Pero los conocimientos
adquiridos en su estudio encuentren aplicacin fuera del campo de la compilacin.
Es probable que ocas personas realice o mantenga un compilador para un
lenguaje de programacin, pero mucha gente puede obtener provecho del uso de
un gran nmero de sus tcnicas para el diseo de software en general.
En efecto, entre los campos de la informtica en los que encuentra aplicacin las
tcnicas aprendidas en COMPLADORES e NTRPRETES se puede citar lo
siguiente:
Tratamiento de ficheros de texto con informacin estructurada. Lenguaje como
Perl y TEL, o comandos como el sed o egrep de UNX, incorpora tratamiento de
expresiones regulares para la deteccin y/o modificacin de patrones sin texto.
Procesadores de texto. Procesadores como vi o Emacs incorporan tambin la
posibilidad de efectuar bsquedas y sustituciones mediante expresiones regulares.
Existen tambin procesadores (entre ellos los Emacs) capaces de analizar y tratar
ficheros de texto de organizacin compleja.
Diseo e interpretacin de lenguaje para formateo y texto y descripcin de
grficos. Sistema de formateo de texto (como el HTML o el TEX) o para la
especificacin de tablas (tbl), ecuaciones (eqn), grficos (postscript), etc. requieren
sofisticados microprocesadores.
Gestin de base de datos. Las tcnicas que estamos considerando pueden
explotarse tanto en la exploracin y proceso de ficheros de informacin como en la
realizacin de la interfase de usuario.
Traduccin de formato de fichero.
Calculo simblico.
Reconocimiento de formas. Las tcnicas de anlisis sintctico son ampliamente
utilizadas en la deteccin de patrones en texto, el reconocimiento automtico del
habla o la visin por computador.
6.4.1 Expresiones Lenguajes ntermedios
6.4.2 Declaracin Variables Constantes Lenguajes ntermedios
6.4.3 Estatuto Asignacin Lenguajes ntermedios
6.4.4 Estatuto Condicional Lenguajes ntermedios
6.4.5 Estatuto Ciclos Lenguajes ntermedios
6.4.6 Arreglos Lenguajes ntermedios
(ntermediate language). En computacin, un lenguaje intermedio es el lenguaje
de una mquina abstracta diseada para ayudar en el anlisis de los programas
de computadora. El trmino viene de su uso en los compiladores, donde un
compilador primero traduce el cdigo fuente de un programa, en una forma ms
apropiada para las transformaciones de mejora del cdigo (forma usualmente
llamada bytecode), como un paso intermedio antes de generar el archivo objeto o
el cdigo mquina para una mquina especfica.
Una variante del significado de "lenguaje intermedio se da en esos lenguajes de
alto nivel que no soportan o no generan un archivo objeto o cdigo mquina, pero
s generan un lenguaje intermedio. Luego ese lenguaje intermedio se transfiere a
un compilador que termina de realizar el archivo objeto o el cdigo mquina. Esto
se emplea generalmente por cuestiones de optimizacin y portabilidad.
6.4.7 Funciones Lenguajes ntermedios
Funcin del Lenguaje, entendemos que es el uso de la lengua que hace un
hablante. En simples palabras, las funciones del lenguaje son los diferentes
objetivos, propsitos y servicio que se le da al lenguaje al comunicarse, dndose
una funcin del lenguaje por cada factor que tiene ste, en donde la funcin que
prevalece es el factor en donde ms se pone nfasis al comunicarse. Diversos
lingistas (Karl Bhler, Roman Jakobson, Michael Halliday.) han propuesto
distintas clasificaciones de las funciones del lenguaje: Bhler propuso que existan
nicamente tres funciones: La Representativa (por la cual se trasmiten
informaciones objetivamente) La Expresiva o emotiva (que expresa sentimientos
del emisor) La Conativa, mediante la que se influye en el receptor del mensaje a
travs de rdenes, mandatos o sugerencias. Este modelo pareca muy
incompleto a Jakobson, quien caracteriz mejor las funciones de Bhler y aadi
otras tres sobre los ejes de los factores de la comunicacin :
Funcin Apelativa o Conativa Se centra en el receptor. Es la funcin de mandato y
pregunta. Sus recursos lingsticos son los vocativos, oraciones interrogativas,
utilizacin deliberada de elementos afectivos, adjetivos valorativos, trminos
connotativos y toda la serie de recursos retricos. Se da en lenguaje coloquial, es
dominante en la publicidad y propaganda poltica e ideolgica en general.
Mediante el uso de esta funcin se pretende causar una reaccin en el receptor.
Es decir con esta funcin se pretende que haga algo o que deje de hacer. Por
ejemplo cuando decimos "cllate o "abre la puerta por favor, etc. El mensaje
solicita la atencin del destinatario, es decir apela a l, implicita o explicitamente.
Tambin se le conoce como funcin apelativa. Funcion Referencial Es la funcin
del lenguaje en donde se pone nfasis al factor de contexto. Al ser el contexto todo
lo extra comunicativo, la funcin referencial trata solamente sucesos reales y
comprobables, ya que no son opiniones ni cosas subjetivas, lo que son es una
serie de elementos verificables entre otros Est presente en todos los actos
comunicativos. Se da cuando el mensaje que se transmite puede ser verificable,
porque reconocemos la relacin que se establece entre el mensaje y el objeto
(referente) Es aquella que utiliza el lenguaje denotativo (el significado primario de
las palabras). Prevalecen los sustantivos y verbos; los textos informativos,
cientficos y periodsticos. Hay 7 funciones: Expresiva o emotiva, apelativa o
conativa, referencial o representativa, situacional, Esta funcin se centra en el
contexto e identifica la relacion entre el mensaje y el objeto del que se habla; es
decir, se centra en la tercera persona, la lengua se usa para hablar de algo o
alguien, que no somos ni t ni yo. As, la funcin referencial se hace presente en
casi todos los mensajes y sirve para evaluar si stos son objetivos o no.
Unidad # $ptimi%acin
7.1 Tipos Optimizacin
La optimizacin va a depender del lenguaje de programacin y es directamente
proporcional al tiempo de compilacin; es decir, entre ms optimizacin mayor
tiempo de compilacin.
Las optimizaciones pueden realizarse de diferentes formas. Las optimizaciones
se realizan en base al alcance ofrecido por el compilador de programacin y es
directamente proporcional al tiempo de compilacin; es decir, entre ms
optimizacin mayor tiempo de compilacin.
Como el tiempo de optimizacin es gran consumidor de tiempo (dado que tiene
que recorrer todo el rbol de posibles soluciones para el proceso de optimizacin)
la optimizacin se deja hasta la fase de prueba final.
Algunos editores ofrecen una versin de depuracin y otra de entrega o final.
La optimizacin es un proceso que tiene a minimizar o maximizar alguna variable
de rendimiento, generalmente tiempo, espacio, procesador, etc.
Desafortunamente no existen optimizador que hagan un programa ms rpido y
que ocupe menor espacio.
La optimizacin se realiza reestructurando el cdigo de tal forma que el nuevo
cdigo generado tenga mayores beneficios. La mayora de los compiladores
tienen una optimizacin baja, se necesita de compiladores especiales para
realmente optimizar el cdigo.
7.1.1 Locales Optimizacin

La optimizacin local se realiza sobre mdulos del programa. En la mayora de las
ocasiones a travs de funciones, mtodos, procedimientos, clases, etc.
La caracterstica de las optimizaciones locales es que slo se ven reflejados en
dichas secciones.
Optimizacin Local
La optimizacin local sirve cuando un bloque de programa o seccin es crtico por
ejemplo: la E/S, la concurrencia, la rapidez y confiabilidad de un conjunto de
instrucciones.
Como el espacio de soluciones es ms pequeo la optimizacin local es ms
rpida.
Locales Optimizacin
La optimizacin local se realiza sobre mdulos del programa. En la mayora de las
ocasiones a travs de funciones, mtodos, procedimientos, clases, etc.
La caracterstica de las optimizaciones locales es que slo se ven reflejados en
dichas secciones.
Optimizacin Local
La optimizacin local sirve cuando un bloque de programa o seccin es crtico por
ejemplo: la E/S, la concurrencia, la rapidez y confiabilidad de un conjunto de
instrucciones.
Como el espacio de soluciones es ms pequeo la optimizacin local es ms
rpida.

7.1.2 Bucles Optimizacin
Los ciclos son una de las partes ms esenciales en el rendimiento de un
programa dado que realizan acciones repetitivas, y si dichas acciones estn mal
realizadas, el problema se hace N veces ms grandes.
La mayora de las optimizaciones sobre ciclos tratan de encontrar elementos que
no deben repetirse en un ciclo.
Ciclos
while(a == b)
{ int c = a; c = 5; .; }
En este caso es mejor pasar el int c =a; fuera del ciclo de ser posible.
Ciclos
El problema de la optimizacin en ciclos y en generalradica es que muy difcil
saber el uso exacto de algunas instrucciones. Asque no todo cdigo de proceso
puede ser optimizado. Otros uso de la optimizacin pueden ser el mejoramiento
de consultas en SQL o en aplicaciones remotas (sockets, E/S, etc.)
7.1.3 Globales Optimizacin
variables y eliminarlas toma su tiempo) pero consume ms memoria.
Algunas optimizaciones incluyen utilizar como variables registros del CPU, utilizar
instrucciones en ensamblador.
7.1.4 De Mirilla Optimizacin
El pensamiento crtico es un elemento importante para el xito en la vida (Huitt,
1993; Thomas y Smoot, 1994). Una Definicion Propuesta: El pensamiento critico
debe ser contrastado con el pensamiento no-critico. pensamiento habitual o
rutinario.
la lluvia de ideas
pensamiento creativo
pensamiento prejuicioso el pensamiento emocional el pensamiento intuitivo
La definicion de Huitt:
El pensamiento crtico es la actividad mental disciplinada de evaluar los
argumentos o proposiciones haciendo juicios que puedan guiar el desarrollo de las
creencias y la toma de accin to:
7.1.4 Optimizacin de Mirilla
La optimizacin de mirilla trata deestructurar de manera eficiente el flujo del
programa, sobre todo en instrucciones de bifurcacin como son las decisiones,
ciclos y saltos de rutinas.
La idea es tener los saltos lo ms cerca de las llamadas, siendo el salto lo ms
pequeo posible.
7.2 Costos Optimizacin
Los costos son el factor ms importante a tomar en cuentaa la hora de optimizar
ya que en ocasiones la mejora obtenida puede verse no reflejada en el programa
finalpero si ser perjudicial para el equipo de desarrollo.
La optimizacin de una pequea mejora tal vez tenga una pequea ganancia en
tiempo o en espacio pero sale muy costosa en tiempo en generarla.
Pero en cambio si esa optimizacin se hace por ejemplo en un ciclo, la mejora
obtenida puede ser N veces mayor por lo cual el costo se minimiza y es benfico
la mejora.
Por ejemplo: for(int i=0; i< 10000; i++); si la ganancia es de 30 ms 300s.
7.2.1 Costo de Ejecucin Optimizacin
Los costos de ejecucin son aquellos que vienen implcitos al ejecutar el
programa.
En algunos programas se tiene un mnimo para ejecutar el programa, por lo que
el espacio y la velocidad del microprocesadores son elementos que se deben
optimizar para tener un mercado potencial ms amplio.
Las aplicaciones multimedios como los videojuegos tienen un costo de ejecucin
alto por lo cual la optimizacin de su desempeo es crtico, la gran mayora de las
veces requieren de procesadores rpidos (e.g. tarjetas de video) o de mucha
memoria.
Otro tipo de aplicaciones que deben optimizarse son las aplicaciones para
dispositivos mviles.
Los dispositivos mviles tiene recursos ms limitados que un dispositivo de
cmputo convencional razn por la cual, el mejor uso de memoriay otros recursos
de hardware tiene mayor rendimiento.
En algunos casos es preferible tener la lgica del negocio ms fuerte enotros
dispositivos y hacer uso de arquitecturas descentralizadas como cliente/servidor o
P2P.
7.2.2 Criterios para Mejorar Cdigo
La mejor manera de optimizar el cdigo es hacer ver a los programadores que
optimicen su cdigo desde el inicio, el problema radica en que el costo podra ser
muy grande ya que tendra que codificar ms y/o hacer su cdigo mas legible.
Los criterios de optimizacin siempre estn definidos por el compilador.
Muchos de estos criterios pueden modificarse con directivas del compilador
desde el cdigo o de manera externa.
Este proceso lo realizan algunas herramientas del sistema como los ofuscadores
para cdigomvil y cdigo para dispositivos mviles.
7.2.3 Herramientas para Anlisis del Flujo de Datos
Existen algunas herramientas que permiten el anlisis de los flujos de datos, entre
ellas tenemos los depuradores y desambladores.
La optimizacin al igual que la programacin es un arte y no se ha podido
sistematizar del todo.
Unidad & 'eneracin de cdigo o(jeto
8.1 Lenguaje Maquina Caractersticas

Un lenguaje de programacin de bajo nivel es el que proporciona poca o ninguna
abstraccin del microprocesador de un ordenador. Consecuentemente es
fcilmente trasladado a lenguaje de mquina.
La palabra "bajo no implica que el lenguaje sea inferior a un lenguaje de alto nivel;
se refiere a la reducida abstraccin entre el lenguaje y el hardware.
Uso: ventajas e inconvenientes. En general se utiliza este tipo de lenguaje para
programar controladores (drivers).
La programacin en un lenguaje de bajo nivel como el lenguaje de la mquina o el
lenguaje simblico tiene ciertas ventajas:
Mayor adaptacin al equipo.
Posibilidad de obtener la mxima velocidad con mnimo uso de memoria.
Pero tambin tiene importantes inconvenientes:
mposibilidad de escribir cdigo independiente de la mquina.
Mayor dificultad en la programacin y en la comprensin de los programas.
El programador debe conocer ms de un centenar de intrucciones.
Es necesario conocer en detalle la arquitectura de la mquina.
Caractersticas
Se trabaja a nivel de instrucciones, es decir, su programacin es al ms fino
detalle. Est orientado a la mquina.
Primera generacin
El lenguaje de programacin de primera generacin (por sus siglas en ingls,
1GL), es el lenguaje de cdigo mquina. Es el nico lenguaje que un
microprocesador entiende de forma nativa. El lenguaje mquina no puede ser
escrito o ledo usando un editor de texto, y por lo tanto es raro que una persona lo
use directamente.
Segunda generacin
El lenguaje de programacin de segunda generacin (por sus siglas en ingls,
2GL), es el lenguaje ensamblador. Se considera de segunda generacin porque,
aunque no es lenguaje nativo del microprocesador, un programador de lenguaje
ensamblador debe conocer la arquitectura del microprocesador (como por ejemplo
las particularidades de sus registros o su conjunto de instrucciones).
8.1.2 Direccionamiento Lenguaje Maquina
Es la forma en como se accede a la memoria. Recordar que un programa no
puede ejecutarse sino se encuentra en memoria principal. La forma de acceder a
la memoria depende del microprocesador, pero en general existen dos tipos de
direccionamiento: directo e indirecto.
El direccionamiento directo tambin recibe el nombre de direccionamiento
absoluto y el acceso a las direcciones se hace de manera directa. El
direccionamiento indirecto tambin recibe el nombre de direccionamiento relativo y
se basa a partir de una direccin genrica, generalmente el inicio del programa.
Para acceder a una direccin relativa se suma a la direccin base el nmero de
espacios de memorias necesarias. El direccionamiento relativo hace a los
programas relocalizables e independientes. Si la direccin base es el inicio de la
memoria fija el direccionamiento pasa a ser un variante de direccionamiento
absoluto.
8.2 Lenguaje Ensamblador Caracteristicas
El lenguaje Assembly es un tipo de lenguaje de bajo nivel utilizado para escribir
programas informticos, y constituye la representacin ms directa del cdigo
mquina especfico para cada arquitectura de computadoras legible por un
programador.
Fue usado ampliamente en el pasado para el desarrollo de software, pero
actualmente slo se utiliza en contadas ocasiones, especialmente cuando se
requiere la manipulacin directa del hardware o se pretenden rendimientos
inusuales de los equipos.
Ensambladores [editar]Un ensamblador crea cdigo objeto traduciendo
instrucciones mnemnicas a cdigos operativos, e interpretando los nombres
simblicos para direcciones de memoria y otras entidades. El uso de referencias
simblicas es una caracterstica bsica de los ensambladores, evitando tediosos
clculos y direccionamiento manual despus de cada modificacin del programa.
La mayora de los ensambladores tambin incluyen facilidades para crear macros ,
a fin de generar series de instrucciones cortas que se ejecutan en tiempo real, en
lugar de utilizar subrutinas[1] .
Los ensambladores son por lo general ms fciles de programar que los
compiladores de lenguajes de alto nivel, y han estado disponibles desde la dcada
de 1950. Los ensambladores modernos, especialmente para arquitecturas
basadas en RSC, como por ejemplo MPS, SPARC y PA-RSC optimizan las
instrucciones para explotar al mximo la eficiencia de segmentacin del CPU.
Los ensambladores de alto nivel ofrecen posibilidades de abstraccin que
incluyen:
Control avanzado de estructuras. Procedimientos de alto nivel, declaracin de
funciones. Tipos de datos que incluyen estructuras, registros, uniones, clases y
conjuntos. Sofisticado procesamiento de macros.
Lenguaje [editar]Un programa escrito en lenguaje Assembly consiste en una serie
de instrucciones que corresponden al flujo de rdenes ejecutables que pueden ser
cargadas en la memoria de una computadora. Por ejemplo, un procesador x86
puede ejecutar la siguiente instruccin binaria como se expresa en cdigo
maquina:
Binario: 10110000 01100001 (Hexadecimal: 0xb061) La representacin
equivalente en Assembly es ms fcil de recordar:
mov al, 061h Esta instruccin significa:
Mueva el valor hexadecimal 61 (97 decimal) al registro "al. El mnemnico "mov
es un cdigo de operacin u "opcode , elegido por los diseadores de la coleccin
de instrucciones para abreviar "move (mover).- El opcode es seguido por una lista
de argumentos o parmetros, completando una instruccin de ensamblador tpica.
La transformacin del lenguaje Assembly en cdigo mquina la realiza un
programa ensamblador, y la traduccin inversa la puede efectuar un
desensamblador. A diferencia de los lenguajes de alto nivel, aqu hay usualmente
una correspondencia 1 a 1 entre las instrucciones simples del ensamblador y el
lenguaje mquina. Sin embargo, en algunos casos, un ensamblador puede
proveer "pseudo instrucciones que se expanden en un cdigo de mquina ms
extenso a fin de proveer la funcionalidad necesaria. Por ejemplo, para un cdigo
mquina condicional como "si X mayor o igual que , un ensamblador puede
utilizar una pseudoinstruccin al grupo "haga si menor que , y "si = 0 sobre el
resultado de la condicin anterior. Los ensambladores ms completos tambin
proveen un rico lenguaje de macros que se utiliza para generar cdigo ms
complejo y secuencias de datos.
Cada arquitectura de computadoras tiene su propio lenguaje de mquina, y en
consecuencia su propio lenguaje Assembly. Los ordenadores difieren en el tipo y
nmero de operaciones que soportan; tambin pueden tener diferente cantidad de
registros, y distinta representacin de los tipos de datos en memoria. Aunque la
mayora de las computadoras son capaces de cumplir esencialmente las mismas
funciones, la forma en que lo hacen difiere, y los respectivos lenguajes Assembly
reflejan tal diferencia.
Pueden existir mltiples conjuntos de mnemnicos o sintxis de Assembly para un
mismo conjunto de instrucciones, instanciados tpicamente en diferentes
programas ensamblador. En estos casos, la alternativa ms popular es la provista
por los fabricantes, y usada en los manuales del programa.
Cdigo mquina (o lenguaje de mquina) [editar]El lenguaje de mquina est
formado por instrucciones sencillas, que -dependiendo de la estructura del
procesador- pueden especificar:
Registros especficos para operaciones aritmticas, direccionamiento o control de
funciones. Posiciones de memoria especficas (offset). Modos de direccionamiento
usados para interpretar operandos. Las operaciones ms complejas se realizan
combinando estas instrucciones sencillas, que pueden ser ejecutadas
secuencialmente o mediante instrucciones de control de flujo.
Las operaciones disponibles en la mayora de los conjuntos de instrucciones
incluye:
mover llenar un registro con un valor constante mover datos de una posicin de
memoria a un registro o viceversa escribir y leer datos de dispositivos computar
sumar, restar, multiplicar o dividir los valores de dos registros, colocando el
resultado en uno de ellos o en otro registro realizar operaciones binarias,
incluyendo operaciones lgicas (AND/OR/XOR/NOT) comparar valores entre
registros (mayor, menor, igual) afectar el flujo del programa saltar a otra posicin
en el programa y ejecutar instrucciones all saltar si se cumplen ciertas
condiciones (F) saltar a otra posicin, pero guardar el punto de salida para
retornar (CALL, llamada a subrutinas) Algunas computadoras incluyen
instrucciones complejas dentro de sus capacidades. Una sola instruccin compleja
hace lo mismo que en otras computadoras puede requerir una larga serie de
instrucciones, por ejemplo:
salvar varios registros en la pila de una sola vez mover grandes bloques de
memoria operaciones aritmticas complejas o de punto flotante (seno, coseno,
raz cuadrada ) El nivel de lenguaje Assembly tiene aspectos importantes de los
niveles de microarquitectura, en los cuales se encuentra (SA y sistema operativo)
estos dos se utilizan para la traduccin en lugar de la interpretacin. Algunas
caractersticas del lenguaje se describen a continuacin Los programas que sirven
para traducir algn programa para el usuario se llama traductores, el lenguaje en
que esta escrito el programa original se llama lenguaje fuente, el lenguaje original
que sea modificado se llama lenguaje objeto.
Se usa la traduccin cuando se cuenta con un procesador (ya sea hardware o un
interprete) para el lenguaje objeto pero no para el lenguaje fuente, Si la traduccin
se realiza correctamente, la ejecucin del programa traducido dar exactamente
los mismos resultados que habra dado la ejecucin del programa fuente. Hay dos
diferencias entre traduccin e interpretacin, en la traduccin no se ejecuta
directamente el programa original, en el lenguaje fuente se convierte en un
programa equivalente llamado programa objeto o programa binario ejecutable y
este funciona solo cuando se ha acabado la traduccin.
El cdigo mquina, un simple patrn de bits, es hecho legible reemplazando
valores crudos por smbolos denominados mnemnicos. Se invent para facilitar la
tarea de los primeros programadores que hasta ese momento tenan que escribir
directamente en cdigo binario. antes an era peor, ya que el cdigo de ceros y
unos (el programa) deba introducirse en una tarjeta perforada. La posicin
ocupada por cada punto equivala a un "1 o a un "0 segn hubiera un hueco o
no. Lo cual supona una forma casi idntica en la que hoy se escriben los datos
binaros en soportes tales como los CDs y DVDs.
Mientras que una computadora reconoce la instruccin de mquina A-32
10110000 01100001
para los programadores de microprocesadores x86 es mucho ms fcil reconocer
dicha instruccin empleando lenguaje Assembly:
movb 061,%al
(que significa mover el valor hexadecimal 61 (97 decimal) al registro 'al'.)
Cada instruccin de la mquina se transforma en una nica instruccin en cdigo
simblico.
Pero adems, para mejorar la legibilidad del programa, el cdigo simblico
introduce instrucciones adicionales, que no corresponden a ninguna instruccin de
la mquina y que proporcionan informacin. Se llaman "pseudoinstrucciones.
El cdigo simblico puede parecer de difcil acceso, pero es ms fcil de recordar
e interpretar que el binario o el hexadecimal.
Los lenguajes simblicos no resuelven definitivamente el problema de cmo
programar un ordenador de la manera ms sencilla posible. Para utilizarlos, hay
que conocer a fondo el microprocesador, los registros de trabajo de que dispone,
la estructura de la memoria, y muchas cosas ms.
Adems, el lenguaje Assembly est demasiado ligado al microprocesador para
que sea posible escribir programas independientes de la mquina en que van a
ejecutarse.
Este cdigo simblico no puede ser ejecutado directamente por un ordenador, por
lo que es preciso traducirlo previamente. Pero la traduccin es un proceso
mecnico y repetitivo, que se presta a su realizacin por un programa de
ordenador.
Los programas que traducen cdigo simblico al lenguaje de mquina se llaman
ensambladores ("assembler, en ingls), porque son capaces de ensamblar el
programa traducido a partir de varias piezas, procedimientos o subrutinas a cdigo
binario ("1 y "0) que entiende el procesador.
Ejemplos de lenguaje Assembly [editar]
Ejemplo 1 [editar]El siguiente es un ejemplo del programa clsico Hola mundo
escrito para la arquitectura de procesador x86 (bajo el sistema operativo DOS ).
.model small .stack .data Cadena1 DB 'Hola Mundo.' .code
programa:
mov ax, data
mov ds, ax
mov dx, offset Cadena1
mov ah, 9
int 21h
end programa
8.2.2 Almacenamiento Lenguaje Ensamblador
Una de las principales ventajas del uso del ensamblador, es que se encarga de
administrar de manera transparente para el usuario la creacin de memoria, las
bifurcaciones y el paso de parmetros.
Adems nos permite acceder directamente a los recursos de la mquina para un
mejor desempeo.
8.3 Registros Lenguaje Ensamblador
Los registros del procesador se emplean para controlar instrucciones en ejecucin,
manejar direccionamiento de memoria y proporcionar capacidad aritmtica. Los
registros son espacios fsicos dentro del microprocesador con capacidad de 4 bits
hasta 64 bits dependiendo del microprocesador que se emplee. Los registros son
direccionables por medio de una vieta, que es una direccin de memoria. Los
bits, por conveniencia, se numeran de derecha a izquierda (15, 14, 13.. 3, 2, 1,
0), los registros estn divididos en seis grupos los cuales tienen un fin especfico.
Los registros se dividen en:
Registros de segmento
Registros de apuntadores de instrucciones
Registros apuntadores
Registros de propsitos generales
Registro ndice
Registro de bandera.
Registros de uso general
AX = Registro acumulador, dividido en AH y AL (8 bits cada uno).- nterviene en las
operaciones aritmticas y lgicas, despus de la operacin arroja un resultado.
BX = Registro base, dividido en BH y BL.- Se utiliza en transferencias de datos
entre la memoria y el procesador.
CX = Registro contador, dividido en CH y CL.- Se utiliza como contador en
bucles(LOOP), en operaciones con cadenas(REP), y en desplazamientos(CL).
DX = Registro de datos, dividido en DH y DL.- Se utiliza en operaciones de
multiplicacin y divisin junto con Ax y en operaciones de entrada y salida de
puertos, su mitad inferior DL contiene el nmero de puertos.
Registros de segmento.
Un registro de segmento se utiliza para alinear en un limite de prrafo o dicho de
otra forma codifica la direccin de inicio de cada segmento y su direccin en un
registro de segmento supone cuatro bits 0 a su derecha.
Un registro de segmento tiene 16 bits de longitud y facilita un rea de memoria
para direccionamientos conocidos como el segmento actual. Los registros de
segmento son: CS (cdigo), DS (datos), SS (pila), ES , FS y GS.
Registro Apuntador de instrucciones.(P)
El registro apuntador de instrucciones (P) de 16 bits contiene el desplazamiento
de direccin de la siguiente instruccin que se ejecuta.
Registro ndice.
Los registros S y D estn disponibles para direccionamientos indexados y para
sumas y restas. Que son las operaciones de punta.
Registro de bandera.
Los registros de banderas sirven parar indicar el estado actual de la maquina y el
resultado del procesamiento, Cuando algunas instrucciones piden comparaciones
o clculos aritmticos cambian el estado de las banderas.
8.3.1 Distribucin Lenguaje Ensamblador
La distribucin es el proceso en el que el programa generado puede ejecutarse en
otras mquinas. Con respecto al ensamblador, la mayora del direccionamiento se
hace relativo para que el programa sea relocalizable por un programa llamado
cargador. En el caso de programas compiladores se necesitan de las libreras, si
son estticos se incluyen en el ejecutable por lo que el programa se hace grfico,
si son dinmicas no pero el programa es ms pequeo. Debido a la complejidad
del software actual se necesitan de asistentes para poder instalar y ejecutar un
programa.
8.3.2 Asignacin Lenguaje Ensamblador
8.4 Administracin Memoria Lenguaje Ensamblador
La administracin de la memoria es un proceso hoy en da muy importante, de tal
modo que su mal o buen uso tiene una accin directa sobre el desempeo de
memoria.
En general un ensamblador tiene un administrador de memoria ms limitado que
un compilador.
En la mayora de los lenguajes de programacin el uso de punteros no estaba
vigilado por lo que se tienen muchos problemas con el uso de memoria.
Los lenguajes ms recientes controlan el uso de punteros y tienen un programa
denominado recolector de basura que se encarga de limpiar la memoria no
utilizada mejorando el desempeo.