CLASE 1

Compiladores e
Intrpretes
La ctedra de Compiladores e Intrpretes presenta una introduccin al software
cuya funcin nica es compilar programas fuentes en un determinado lenguaje.
Existen dos tipos principales de traductores de los lenguajes de programacin de
alto nivel: COMPILADORES
INTERPRETES
Compilador
Proceso de traduccin que convierte un programa fuente escrito en un lenguaje de
alto nivel a un programa objeto en cdigo mquina y listo por tanto para
ejecutarse en el ordenador, con poca o ninguna preparacin adicional

Interpretes
Analiza el programa fuente y lo ejecuta directamente, Ejemplo del traductor
humano

CLASE 2
INTRODUCCION AL PROCESO DE COMPILACION
Traductor
Un traductor es programa que toma como entrada un texto escrito en un lenguaje
y da como salida otro texto en otro lenguaje diferente

Compilador
Es un traductor que convierte un texto escrito en un lenguaje de alto nivel
Ensamblador
Es un lenguaje de bajo nivel, donde cada sentencia del lenguaje fuente se traduce
a una instruccin del lenguaje maquina
Interprete
No genera cdigo objeto, analiza y ejecuta directamente cada proposicin del
cdigo fuente
Preprocesador
Procesa un texto fuente modificndolo en cierta forma previamente a la
complicacin

Clase 3
INTRODUCION, CONCEPTOS, CARACTERISTICAS Y COMPONENTES DE LOS
COMPILADORES
CLASIFICACION DE LOS LENGUAJES DE PROGRAMACION
La programacin de computadoras se realiza en los llamados lenguajes de
programacin, stos posibilitan la comunicacin entre el programador y la
computadora, a travs de un conjunto de instrucciones u rdenes especificadas
por el lenguaje.
Diferentes puntos de vista para clasificar los lenguajes de programacin:
1. Su grado de independencia con la mquina.
2. La forma de sus instrucciones y la forma de procesar el cdigo fuente.

3. Por generaciones.
Los lenguajes de programacin segn su grado de independencia de la mquina:
a) Lenguaje mquina (representacin binaria o hexadecimal.).
b) Lenguaje ensamblador o de bajo nivel (versin simblica de un lenguaje
mquina).
c) Lenguaje de medio nivel (lenguaje C).
d) Lenguaje de alto nivel (FORTRAN, COBOL, Pascal).
Lenguaje de mquina
El lenguaje de mquina de una computadora consta de cadenas de nmeros
binarios (ceros y unos) y es el nico que "entienden" directamente los
procesadores
Lenguaje ensamblador
La comunicacin en lenguaje de mquina es particular de cada procesador que se
usa, y programar en este lenguaje es muy difcil y tedioso, por lo que se empez a
buscar mejores medios de comunicacin con sta
Lenguajes de alto nivel
Los primeros programas ensambladores producan slo una instruccin en lenguaje
de mquina por cada instruccin del programa fuente
Los lenguajes de programacin segn su forma de procesar el cdigo fuente
Traductores (translators).
Compiladores (compilers).
Ensambladores (assemblers).
Interpretes (interpreters).
Editores (editors).

CLASE 4
TABLA DE SMBOLOS
TABLA DE SMBOLOS

Almacena todos los nombres declarados en el programa y sus atributos (tipo, valor,
direccin, parmetros, etc.).
Estructura de datos.
Almacena informacin sobre:
Los identificadores.
Las palabras reservadas.

Las constantes.
Contiene una entrada para cada uno de los smbolos definidos en el programa
fuente.
Sobre los identificadores, y opcionalmente sobre las palabras reservadas y las
constantes.
Analizador Lxico: Pasa en el token y la entrada de la TS creada.
Analizador Sintctico y Semntico: Busca el token y si no lo encuentra crea una
nueva entrada.

Esquema general

TABLA DE SMBOLOS

CLASE 5
LABORATORIO 1

CLASE 6
CONCEPTOS GENERALES SOBRE ANALISIS LEXICO
QU ENTENDEMOS POR LEXICO?

El lxico de un lenguaje natural est constituido por todas las palabras y smbolos que
lo componen. Para un lenguaje de programacin la definicin tambin es vlida
QU ENTENDEMOS POR SINTAXIS?
En lingstica, sintaxis es el estudio de la funcin que desempea cada palabra en el
entorno de una frase. Mientras que semntica es el estudio del significado de una
palabra tanto a nivel individual como en el contexto de una frase.
QU ENTENDEMOS POR SEMANTICA?
Semntica en los lenguajes de programacin es el conjunto de reglas que especifican
el significado de cualquier sentencia, sintcticamente correcta y escrita en un
determinado lenguaje. Por ejemplo en el lenguaje Pascal la sentencia: suma:= 27/lado
Es sintcticamente correcta, ya que a la izquierda del smbolo de asignacin hay un
identificador, y a la derecha una expresin.
CONCEPTOS ANALIZADOR LEXICO
Token Es el nombre que se le da a cada patrn definido, ste nombre debe usarse en
todos los procesos del anlisis en todos los lexemas encontrados.
Patrn Es una representacin lgica de una serie de agrupaciones de caracteres con
caractersticas comunes.
Lexema Es cada una de las combinaciones de caracteres que encajan en la definicin
de un patrn o token. Ej. Variable1, x, a, edad, y2, etc.
Atributo Caractersticas propias de cada token, por tanto se les denomina atributos del
token.
Gramtica Se define como un ente formal para especificar de una manera finita el
conjunto de cadenas de smbolos que constituyen un lenguaje.
Alfabeto Conjunto finito de smbolos no vaco que conforman una gramtica, se
representan por (sigma).
Clase # 6 Conceptos del Anlisis Lxico
Por: Ing. Marvin Parada, Compiladores Ciclo I-2016 Pgina 4
Smbolo Entidad abstracta que no se va a definir pues se deja como axioma.
Normalmente son letras de alfabetos, nmeros o caracteres especiales como +, -, *, /,
etc. No necesariamente sern uno solo, ya que un smbolo puede ser una combinacin
como palabras reservadas de un lenguaje de programacin then, end, beging, else,
while, etc.
Expresin Regular Representan patrones de cadenas de caracteres. Se conocen ms
como metalenguajes que sirven para describir los lenguajes regulares.
Diagrama de Transicin Es el conjunto de secuencias de entrada que representan
grficamente los smbolos validos por la gramtica, es una representacin de los
universales autmatas que aparecen en la matemtica y otras ciencias.
Tabla de Transiciones Es la manera ms cercana de representar los autmatas, consta
de filas que representan los estados y las columnas que representan los smbolos de
entrada. Adicionalmente se agregan dos columnas para representar los tokens y para
indicar retrocesos.

Cadena Se define como una secuencia de smbolos de un lenguaje determinado. Por

ejemplo 0001, abcd, a+4*b, 11000, etc. Una cadena siempre tiene una longitud que
esta denotada por la cantidad de smbolos independientes que la conforman. |abcde|
5 |000111| 6 Cuando la cadena es vaca se representa como ||0.
Lenguaje Un lenguaje es un conjunto de palabras que se puede representar con un
determinado alfabeto.
Autmata Es una construccin lgica que recibe como entrada una cadena de smbolos
y produce una salida indicando si la salida es una cadena que pertenece a un
determinado lenguaje.
CLASE 7
ANALIZADOR SINTACTICO: INTRODUCCION, CONCEPTOS, CARACTERISTICAS
QU ES EL ANALIZADOR SINTCTICO?
Es la fase del analizador que se encarga de chequear el texto de entrada en base a una
gramtica dada. Y en caso de que el programa de entrada sea vlido, suministra el rbol
sintctico que lo reconoce.
El anlisis sintctico es un anlisis a nivel de sentencias, y es mucho ms complejo que
el anlisis lxico. Su funcin es tomar el programa fuente en forma de tokens, que recibe
del analizador lxico, y determinar la estructura de las sentencias del programa. Este
proceso es similar a determinar la estructura de una frase en castellano, determinando
quien es el sujeto, predicado, el verbo y los complementos. El anlisis sintctico agrupa a
los tokens en clases sintcticas (denominadas no terminales en la definicin de la
gramtica), tales como expresiones, procedimientos, etc.
Ejemplo el anlisis sintctico de la siguiente expresin:
(A+B)*(C+D)
Con las reglas de la gramtica que se presenta a continuacin dar lugar al rbol
sintctico EJEMPLO
<expresin> ::= <trmino> <ms trminos>
<ms trminos>::= +<trmino> <ms trminos>| - <trmino> <ms trminos> |
<vaco>
<trmino> ::= <factor> <ms factores>
<ms factores>::= * <factor> <ms factores>|/ <factor> <ms factores> | <vaco>
<factor> ::= ( <expresin> ) | <variable> | <constante>
La estructura de la gramtica anterior refleja la prioridad de los operadores, as los
operadores + y - tienen la prioridad ms baja, mientras que * y / tienen una
prioridad superior. Se evaluaran en primer lugar las constantes, variables y expresiones
entre parntesis.
Los rboles sintcticos se construyen con un conjunto de reglas conocidas como
gramtica, y que definen con total precisin el lenguaje fuente.
Al proceso de reconocer la estructura del lenguaje fuente se conoce con el nombre de
anlisis sintctico (parsing).
La principal tarea del analizador sintctico no es comprobar que la sintaxis del programa
fuente sea correcta, sino construir una representacin interna de ese programa y en el
caso en que sea un programa incorrecto, dar un mensaje de error.
EL ANALIZADOR SINTCTICO (ASN) comprueba que el orden en que el analizador
lxico le va entregando los tokens es vlido. Si esto es as significar que la sucesin de

smbolos que representan dichos tokens puede ser generada por la gramtica
correspondiente al lenguaje del cdigo fuente.
La forma ms habitual de representar la sintaxis de un programa es el rbol de
anlisis sintctico, y lo que hacen los analizadores sintcticos es construir una
derivacin por la izquierda o por la derecha del programa fuente, que en realidad son
dos recorridos determinados del rbol de anlisis sintctico. A partir de ese recorrido el
analizador sintctico debe construir una representacin intermedia de ese programa
fuente: un rbol sintctico abstracto o bien un programa en un lenguaje intermedio; por
este motivo, es muy importante que la gramtica est bien diseada, e incluso es
frecuente redisear la gramtica original para facilitar la tarea de obtener la
representacin intermedia mediante un analizador sintctico concreto.
LAS PRINCIPALES FUNCIONES SON:
Identificar cada tipo de instruccin y sus componentes.
Completar la Tabla de Smbolo s.
Realizar comprobaciones estticas:
Se realizan durante la compilacin del programa.
Ejemplos: comp. de tipos, unicidad de etiquetas e identificadores, etc.
Realizar comprobaciones dinmicas:
Aquellas que el compilador incorpora al programa traducido.
Hacen referencia a aspectos que slo pueden ser conocidos en tiempo de
ejecucin
Dependientes del estado de la mquina en la ejecucin o del propio programa.
Validar las declaraciones de identificadores: en muchos lenguajes no se puede usar
una variable si no ha sido declarada con anterioridad.
Hay distintas clases de analizadores o reconocedores sintcticos, pero en general se
clasifican en 2 grandes grupos: A.S.
Ascendentes y A.S. Descendentes.
TIPOS DE ANLISIS SINTCTICOS
Desde el punto de vista de la teora de Anlisis Sintctico, hay dos estrategias para
construir el rbol sintctico:
Anlisis descendente: partimos de la raz del rbol (donde estar situado el axioma o
smbolo inicial de la gramtica) y se van aplicando reglas por la izquierda de forma que se
obtiene una derivacin por la izquierda de la cadena de entrada. Para decidir qu regla
aplicar, se lee un token de la entrada. Recorriendo el rbol de anlisis sintctico
resultante, en profundidad de izquierda a derecha, encontraremos en las hojas del rbol
los tokens que nos devuelve el Analizador Lxico (A.L.) en ese mismo orden.
Anlisis ascendente: partiendo de la cadena de entrada, se construye el rbol de
anlisis sintctico empezando por las hojas (donde estn los tokens) y se van creando
nodos intermedios hasta llegar a la raz (hasta el smbolo inicial), construyendo as el
rbol de abajo a arriba. El recorrido del rbol se har desde las hojas hasta la raz. El
orden en el que se van encontrando las producciones corresponde a la inversa de una
derivacin por la derecha.
Las dos estrategias recorren la cadena de entrada de izquierda a derecha una sola vez, y
necesitan (para que el anlisis sea eficiente) que la gramtica no sea ambigua.
Para ello, el analizador sintctico (A.S.) comprueba que el orden en que el analizador
lxico le va entregando los tokens es vlido. Si esto es as significar que la sucesin
de smbolos que representan dichos tokens puede ser generada por la gramtica
correspondiente al lenguaje del cdigo fuente.

MANEJO DE ERRORES SINTCTICOS

Si un compilador tuviera que procesar slo programas correctos, su diseo e
implantacin se simplificaran mucho. Pero los programadores a menudo escriben
programas incorrectos, y un buen compilador debera ayudar al programador a
identificar y localizar errores. Es ms, considerar desde el principio el manejo de
errores puede simplificar la estructura de un compilador y mejorar su respuesta a los
errores.

CLASE 8
EJEMPLO DE ANALIZADOR LEXICO-SINTACTICO MINI-DEV
PROTOTIPO DE UN ANALIZADOR LEXICO
Archivos de Cdigo Fuente

Ejemplo1(prueba_lexico.txt
):
M
{
R a;
R b;
C = a+ b;
W c;
}
Analizador Lxico (Lexico.h)
#ifndef Lexico_H
#define Lexico_H
#include<iostream>
#include<stdio.h>
#include<ctype.h>
#include<stdlib.h>
#include<string>
#define TAM_BUFFER 100
using namespace std;
class Lexico
{
char *nombreFichero;
FILE* entrada;
int n1;
int traza;
char buffer[TAM_BUFFER];
int pBuffer;
public:

Ejemplo2
(prueba_sintactico.txt):

M
{
R a;
R b;
c = a + b * 2;
W c;
}

Lexico(char *unNombreFichero, int una_traza=0);

~Lexico(void);
char siguienteToken(void);
void devuelveToken(char toke);
int lineaActual(void){return n1; };
int existeTraza(void){if(traza)return 1; else return 0;}
};
Lexico::Lexico(char *unNombreFichero, int una_traza)
{
entrada=fopen(unNombreFichero, "rt");
if((entrada==NULL))
{
cout<<"No se puede abrir el archivo"<<endl;
system("pause");
exit(-2);
}
if(una_traza) traza=1;
else traza = 0;
n1=1;
pBuffer=0;
}
Lexico::~Lexico()
{
fclose(entrada);
}
char Lexico::siguienteToken(void)
{
char car;
while((car=((pBuffer>0) ? buffer[--pBuffer]:getc(entrada)))!=EOF)
{
if(car==' ') continue;
if(car=='\n'){++n1; continue;}
break;
}
if(traza) cout<<"ANALIZADOR LEXICO: Lee el token"<<car<<endl;
switch(car)
{
case'M':
case'R':
case'W':
case'=':
case'(':
case')':
case';':
case'}':
case'{':
case'.':
case'+':
case'*':
case'-':
case'/':
case'%':
return(car);
}
if(islower(car))return(car);
else if(isdigit(car)) return(car);
else

{
cout<<"Error Lexico: Token Desconocido"<<endl;
system("pause");
exit(-4);
}
return(car);
}
void Lexico::devuelveToken(char token)
{
if(pBuffer>TAM_BUFFER)
{
cout<<"ERROR: Desbordamiento de buffer del analizador lxico"<<endl;
system("pause");
exit(-5);
}
else
{
buffer[pBuffer++]=token;
if(existeTraza())
cout<<"ANALIZADOR LEXICO: Recibe en buffer el token"<<token<<endl;
system("pause");
}
}
#endif

Analizador Sintctico (Sintactico.h)

#ifndef Sintactico_H
#define Sintactico_H
#include "lexico.h"
#include <stdlib.h>
using namespace std;
class Sintactico{
void programa (void);
void bloque (void);
void sentencia (void);
void otra_sentencia (void);
void asignacion(void);
void lectura (void);
void escritura(void);
void variable(void);
void expresion(void);
void termino(void);
void mas_terminos(void);
void factor(void);
void mas_factores(void);
void constante(void);
void errores (int codigo);
Lexico lexico; //objeto lxico miembro de la clase
public:
Sintactico(char *fuente, int traza);
~Sintactico(void);
};
Sintactico::Sintactico(char *fuente, int traza):lexico(fuente, traza)
//se inicializa el constructor de la clase lxico
{

if (lexico.existeTraza())
cout<<"INICIO DE ANALISIS SINTACTICO"<<endl;
programa();
}
/********************************************************************/
Sintactico::~Sintactico(void)
{
if (lexico.existeTraza())
{
cout<<"FIN DE ANALISIS SINTACTICO"<<endl;
cout<<"FIN DE COMPILACION"<<endl;
}
}
/********************************************************************/
void Sintactico::programa(void)
{
char token;
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <PROGRAMA>"<<endl;
token=lexico.siguienteToken();
if (token=='M') cout <<"M";
else errores(8);
token=lexico.siguienteToken();
if (token!='{') errores(9);
bloque();
token=lexico.siguienteToken();
if (token=='}')
{
cout<<"}";
}
else errores(2);
}
/************************************************************************/
void Sintactico::bloque(void)
{
char token=' ';
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <BLOQUE>"<<endl;
sentencia();
otra_sentencia();
}
/**********************************************************************/
void Sintactico::otra_sentencia(void)
{
char token;
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <OTRA_SENTENCIA>"<<endl;
token=lexico.siguienteToken();
if (token==';')
{
sentencia();
otra_sentencia();
}
else lexico.devuelveToken(token); //vacio
}
/*********************************************************************/
void Sintactico::sentencia(void)
{
char token;
if (lexico.existeTraza())

cout<<"ANALISIS SINTACTICO: <SENTENCIA>"<<endl;

token=lexico.siguienteToken();
if ((token>='a') && (token<='z'))
{
lexico.devuelveToken(token);
asignacion();
}
else if (token=='R') lectura();
else if (token=='W') escritura();
else errores(6);
}
/**********************************************************************/
void Sintactico::asignacion()
{
char token;
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <ASIGNACION>"<<endl;
variable();
token=lexico.siguienteToken();
if (token!='=') errores(3);
expresion();
}
/*********************************************************************/
void Sintactico::variable(void)
{
char token;
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <VARIABLE>"<<endl;
token=lexico.siguienteToken();
if ((token>='a') && (token<='z')) cout<<token;
else errores(5);
}
/********************************************************************/
void Sintactico::expresion(void)
{
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <EXPRESION>"<<endl;
termino();
mas_terminos();
}
/*********************************************************************/
void Sintactico::termino(void)
{
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <TERMINO>"<<endl;
factor();
mas_factores();
}
/*********************************************************************/
void Sintactico::mas_terminos(void)
{
char token;
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <MAS_TERMINOS>"<<endl;
token=lexico.siguienteToken();
if (token=='+')
{
termino();
mas_terminos();
}

else if (token =='-')

{
termino();
mas_terminos();
}
else lexico.devuelveToken(token); // <vacio>
}
/*********************************************************************/
void Sintactico::factor(void)
{
char token;
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <FACTOR>"<<endl;
token=lexico.siguienteToken();
if ((token>='0') && (token<='9'))
{
lexico.devuelveToken(token);
constante();
}
else if (token=='(')
{
expresion();
token=lexico.siguienteToken();
if (token!=')') errores(4);
}
else
{
lexico.devuelveToken(token);
variable();
}
}
/*********************************************************************/
void Sintactico::mas_factores(void)
{
char token;
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <MAS_FACTORES>"<<endl;
token=lexico.siguienteToken();
switch (token)
{
case '*':factor();
mas_factores();
break;
case '/':factor();
mas_factores();
break;
case '%':factor();
mas_factores();
break;
default: //<vacio>
lexico.devuelveToken(token);
}
}
/*********************************************************************/
void Sintactico::lectura(void)
{
char token;
token=lexico.siguienteToken();
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <LECTURA> "<<token<<endl;

if((token<'a')||(token>'z')) errores(5);
}
/**********************************************************************/
void Sintactico::escritura(void)
{
char token;
token=lexico.siguienteToken();
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <ESCRITURA> "<<token<<endl;
if ((token<'a') || (token>'z')) errores(5);
}
/************************************************/
void Sintactico::constante(void)
{
char token;
if (lexico.existeTraza())
cout<<"ANALISIS SINTACTICO: <CONSTANTE>"<<endl;
token=lexico.siguienteToken();
if ((token>='0') && (token<='9')) cout<<token;
else errores(7);
}
/*******************************************************************/
void Sintactico::errores(int codigo)
{
int x;
cout<<"LINEA "<<lexico.lineaActual();
cout<<" ERROR SINTACTICO "<<codigo;
switch (codigo)
{
case 1 :cout<<" :ESPERABA UN ;"<<endl;break;
case 2 :cout<<" :ESPERABA UNA }"<<endl;break;
case 3 :cout<<" :ESPERABA UN ="<<endl;break;
case 4 :cout<<" :ESPERABA UN )"<<endl;break;
case 5 :cout<<" :ESPERABA UN IDENTIFICADOR"<<endl;break;
case 6 :cout<<" :INSTRUCCION DESCONOCIDA"<<endl;break;
case 7 :cout<<" :ESPERABA UNA CONSTANTE"<<endl;break;
case 8 :cout<<" :ESPERABA UNA M DE MAIN"<<endl;break;
case 9 :cout<<" :ESPERABA UNA {"<<endl;break;
default:
cout<<" :NO DOCUMENTADO"<<endl;
}
cin>>x;
exit(-(codigo+100));
}
#endif

Programa Principal (Lexico.cpp)

#include<iostream>
#include "Lexico.h"
using namespace std;
int main()
{
Lexico lexico("prueba_lexico.txt",1);
return 0;

}
Programa Principal (Sintactico.cpp)
#include<iostream>
#include "Sintactico.h"
using namespace std;
int main()
{
Sintactico sintactico("prueba_sintactico.txt",1);
return 0;
}

CLASE 9
ANLISIS SEMNTICO
Semntica de un lenguaje de programacin es el conjunto de reglas que
especifican el significado de cualquier sentencia sintcticamente vlida
Es la etapa que procesa la informacin adicional necesaria para el
procesamiento de un lenguaje, una vez que la estructura sintctica de
un programa haya sido obtenida
Un analizador semntico comprueba que un
Analizador sintctico es semnticamente vlido.
Adems genera un rbol semntico o etiquetado

CLASE 10
LENGUAJE ENSAMBLADOR

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
HISTORIA

El primer compilador fue escrito por Grace Hopper, en 1952 para el lenguaje de
programacin A-0.
En 1950 John Backus dirigi una investigacin en IBM sobre un lenguaje algebraico.
En 1954 se empez a desarrollar un lenguaje que permita escribir frmulas
matemticas de manera traducible por un ordenador; le llamaron FORTRAN
(FORmulae TRANslator).
Fue el primer lenguaje de alto nivel y se introdujo en 1957 para el uso de la
computadora IBM modelo 704
Los elementos bsicos del lenguaje ensamblador son:
Etiquetas
Instrucciones
Operando
Directivas
Comentarios
Etiquetas
Una etiqueta es una palabra utilizada para designar alguna lnea o seccin del
programa, se pueden utilizar para saltar de una parte hacia esa
Etiqueta
MicrocontroladorPIC
Los PIC son una familia de microcontroladores tipo RISC fabricados por Microchip
Technology Inc. y derivados del PIC1650, originalmente desarrollado por la divisin
de microelectrnica de General Instrument
Operando
Son los elementos que emplea la instruccin que se est ejecutando. Usualmente
los operando son los registros, las variables o las constantes
Directivas
Las directivas son similares a las instrucciones, pero a diferencia de estas las
directivas son propias del lenguaje ensamblador e independientes del
microcontrolador que se utilice