Вы находитесь на странице: 1из 13

Universidad Adventista de Centro Amrica

II Cuatrimestre
2014


Compiladores e Intrpretes
Licenciatura Cdigo: IS581


Profesor: Dodanim Castillo Aruz
Ttulo: Proyecto Final - Analizador


Alumnos:
Ana Baiza
Misael Vallejos Zumbado


Agosto 2014
2

Tabla de contenido
1. Introduccin .................................................................................................................................... 3
1.1. Qu es ANALIZADOR? ............................................................................................................. 3
1.2. Idea bsica ................................................................................................................................ 3
2. Anlisis lxico .................................................................................................................................. 3
2.1 Tokens ....................................................................................................................................... 3
2.2. Palabras reservadas.................................................................................................................. 3
2.3. Operadores ............................................................................................................................... 4
2.4. Identificadores ......................................................................................................................... 4
2.4.1. Significado de Identificadores ........................................................................................... 4
3. Anlisis sintctico ........................................................................................................................... 5
3.1 Definiciones ............................................................................................................................... 5
3.2. Reglas ....................................................................................................................................... 6
4. CDIGO ........................................................................................................................................... 9
4.1 Analizador Lxico ....................................................................................................................... 9
4.2 Analizador Semntico .............................................................................................................. 10
4.3 Analizador................................................................................................................................ 13


3

1. Introduccin

1.1. Qu es ANALIZADOR?
ANALIZADOR como su nombre lo indica se encarga de analizar o leer un cdigo escrito en leguaje
C y describir sus diferentes disposiciones.

1.2. Idea bsica
La idea bsica del compilador propuesto es detectar dentro de un archivo de cdigo de lenguaje C,
una serie de smbolos los cuales se categorizaron en cuatro grupos:
Estructura repetitiva: est compuesto por los ciclos de repeticin o bucles (for, while, etc.).
Estructura selectiva: est compuesto por rdenes de control (if, case, etc.).
Funciones: est compuesto por todas aquellas funciones que se encuentren declaradas en
el archivo que se examine (main, nulo, etc.).
Structs: est compuesto por todas aquellas otras estructuras que se defina dentro de la
instruccin struct que declaramos en el analizador lxico.
Los conceptos en torno a cmo debe estructurarse el lenguaje, lo que su sintaxis debe ser y qu
caractersticas debe proporcionar, se describe ms adelante.

2. Anlisis lxico

2.1 Tokens
Hay varios tipos de tokens. Los tokens estn separados por espacios en blanco (espacios,
tabuladores, nuevas lneas).

2.2. Palabras reservadas
Los siguientes son algunos ejemplos de los identificadores que estn utilizados como palabras
reservadas, y no pueden ser utilizados de otra manera:
4

else
switch
case
for
while
do
if
return
break
struct
void
int

2.3. Operadores
Los operadores soportados son operadores aditivos, operadores de incremento y decremento,
operadores relacionales, operadores de igualdad y operador de asignacin.
OPRELACION "<"|">"|">="|"<="|"!="|"=="
OPINCREMENTO "+"|"-"|"*"|"/"
OPINCREMENTO2 "++"|"--"
OPINCREMENTO3 "-="|"+="|"*="|"/="
OPLOG "&&"|"||"

2.4. Identificadores
Un identificador es una secuencia de letras y dgitos que comienzan con una letra.
letra [a-zA-Z_]
DIGITO [0-9]
ID ([a-zA-Z]|"_")([a-zA-Z0-9]|"_")*

2.4.1. Significado de Identificadores
Los identificadores pueden referirse a muchas cosas diferentes etiquetas de tipos, funciones y
objetos o variables de tipos.
Los tipos fundamentales soportados son:
char: tipo de carcter (normalmente 1 byte).
int: tipo de dato entero con signo (normalmente 2 o 4 bytes).
long: tipo de dato entero largo con signo (normalmente 2 bytes).
short: tipo de dato entero corto con signo (normalmente 2 bytes).
float: tipo de dato flotante (real) (normalmente 4 bytes).
double: tipo de dato flotante (real) (normalmente 8 bytes).
void: tipo de dato que puede representar: Nada (para funciones) o cualquier tipo de dato.
TIPOSDATO "char"|"int"|"long"|"short"|"float"|"double"|"void"
5

3. Anlisis sintctico

3.1 Definiciones
Al igual que en lex, incluimos las libreras que usaremos en el programa, definiciones de los tokens,
tipos de datos y precedencia de la gramtica.
%union
{
char *valor;
}

Esta definicin, se traduce a una unin de C que a su vez dar el tipo de dato a una variable global
que ser de donde yacc tomara los datos a procesar, en la unin se definen miembros cuyos
correspondientes tipos de datos sern usados para dar el tipo de dato a los tokens.
Esta estructura puede llegar a ser muy compleja, y para saber de que tipo es cada token devuelto
por yylex(), se usan las definiciones %token y %type.

%token <valor> T_ID T_INT T_FLOAT T_IF T_ELSE T_SWITCH T_CASE T_FOR T_WHILE T_DO
T_TDATO T_OPAARIT T_INCR2 T_COMA T_PTCOM T_OPRELACION
T_OPASIG T_PA T_PC T_CA T_CC T_INCR T_ANDOR T_CHAR T_RETURN
T_STRUCT T_DOSPTO T_BREAK T_CAR
%type <valor> argumentos
%type <valor> declaracion
%type <valor> id
%type <valor> conte
%type <valor> return
%type <valor> asignaciones
%type <valor> operArit
%type <valor> valores
%type <valor> cases
%type <valor> case
%type <valor> constantes
%start funciones

%token: sirve para definir los tokens que hay, y si es necesario, el tipo de dato que usan,
todos los tokens son tomados como smbolos terminales, estos tambin tienen el objetivo
de servir como etiquetas que yylex() regresa a yacc para identificar el token que se ha ledo
recientemente.
6

%type: es anlogo a %token, solo que este define el tipo de dato para smbolos no
terminales de nuestra gramtica, la nica diferencia es que el tipo de dato a usar es
obligatorio.
<valor>: Indica el miembro al que sern mapeados los tokens en la unin yylval dentro de
lex.

3.2. Reglas
En esta parte finalmente llegamos a la definicin de la gramtica, ac podemos observar que cada
smbolo se define con su nombre, seguido de dos puntos ":" seguidos de varios smbolos que
conformaran su composicin gramatical que en caso de tener varias opciones, son separados por
"|" (or) indicando que se tienen varias opciones para reducir ese smbolo y para terminar cada regla,
un ";".
funciones : funciones funcion|
funcion;

funcion : T_TDATO T_ID T_PA argumentos T_PC T_CA conte T_CC{
if(!strcmp($1,"void")){
if(strcmp($7,""))
yyerror("Documento no valido");
}
else if(!strcmp($7,""))
yyerror("Documento no valido");
fprintf(fsalidaFun,"Funcion:\t%s\nRetorno:\t%s\nArgumentos:\t%s\
n========\n", $2, $7, $4);};

argumentos: T_TDATO T_ID {strcat($1," ");strcat($1,$2);$$=$1;}|
T_TDATO T_ID T_COMA argumentos {strcat($1," ");strcat($1,$2);
strcat($1,", ");strcat($1,$4);$$=$1;}
|{$$="";};

conte: elementos conte {$$=$2;}|
return {$$=$1;}|{$$="";};

elementos: declaracion|operaciones|estructuras;

declaracion: T_TDATO id T_PTCOM {strcat($1," ");strcat($1,$2);$$=$1;}|
T_TDATO id T_PTCOM declaracion {strcat($1," ");strcat($1,$2);
strcat($1,", ");strcat($1,$4);$$=$1;};

id: T_ID{$$=$1;}|
T_ID T_COMA id {strcat($1,",");strcat($1,$3);$$=$1;};

7

operaciones: asignaciones T_PTCOM {}|
T_ID T_OPASIG T_CHAR{}|
operArit T_PTCOM {}|
operaciones asignaciones T_PTCOM {}|
operaciones operArit T_PTCOM {};

asignaciones: T_ID T_OPASIG T_ID {strcat($1,$2);strcat($1,$3);$$=$1;}|
T_ID T_OPASIG T_INT {strcat($1,$2);strcat($1,$3);$$=$1;}|
T_ID T_OPASIG T_FLOAT {strcat($1,$2);strcat($1,$3);$$=$1;};

operArit: T_ID T_OPAARIT valores {strcat($1,$2);strcat($1,$3);$$=$1;}|
T_ID T_OPASIG valores T_INCR valores {strcat($1,$2);strcat($1,$3);
strcat($1,$4);strcat($1,$5);$$=$1;}|
T_ID T_INCR2 {strcat($1,$2);$$=$1;};

valores: T_INT {$$=$1;}|
T_FLOAT {$$=$1;}|
T_ID {$$=$1;};

return: T_RETURN T_PA T_ID T_PC T_PTCOM {$$=$3;}|
T_RETURN T_PA T_INT T_PC T_PTCOM {$$=$3;}|
T_RETURN T_PA T_FLOAT T_PC T_PTCOM {$$=$3;};

estructuras: estructuras estructurasCuerpo {}|
estructurasCuerpo {};

estructurasCuerpo: estructuraAlgoritmo|struct;

estructuraAlgoritmo: for|while|dowhile|if|IfElse|switch;

for: T_FOR T_PA asignaciones T_PTCOM valores T_OPRELACION valores T_PTCOM
operArit T_PC T_CA contsEstructura T_CC{
strcat($5,$6);strcat($5,$7);
fprintf(fsalidaRep,"Estructura repetitiva:\t%s\nAsignaciones:\t%s\
nCondicion de Paro:\t%s\nIncremento:\t%s\n========\n",$1,$3,$5,$9);
};

while: T_WHILE T_PA valores T_OPRELACION valores T_PC T_CA contsEstructura
T_CC{
strcat($3,$4);strcat($3,$5);
fprintf(fsalidaRep,"Estructura repetitiva:\t%s\nCondicion de
paro:\t%s\n========\n",$1,$3);
};

dowhile: T_DO T_CA contsEstructura T_CC T_WHILE T_PA valores T_OPRELACION
valores T_PC T_PTCOM {
strcat($7,$8);strcat($7,$9);
8

fprintf(fsalidaRep,"Estructura repetitiva:\tDo-while\nCondicion de
paro:\t%s\n========\n",$7);
};

if: T_IF T_PA valores T_OPRELACION valores T_PC T_CA contsEstructura T_CC
{
strcat($3,$4);strcat($3,$5);
fprintf(fsalidaSel,"Condicional:\nif\nCondicion a evaluar:\t%s\n========\
n",$3);}|
T_IF T_PA valores T_OPRELACION valores T_PC contEstructura {
strcat($3,$4);strcat($3,$5);
fprintf(fsalidaSel,"Condicional:\tif\nCondicion a evaluar:\t%s\n========\
n",$3);
};

IfElse: T_IF T_PA valores T_OPRELACION valores T_PC T_CA contsEstructura T_CC
T_ELSE T_CA contsEstructura T_CC {
strcat($3,$4);strcat($3,$5);
fprintf(fsalidaSel,"Condicional:\tif-else\nCondicion a
evaluar:\t%s\n========\n",$3);
};

switch: T_SWITCH T_PA valores T_PC T_CA cases T_CC {
fprintf(fsalidaSel,"Condicional:\tswitch-case\nCondicion a
Evaluar:\t%s\nCases: case %s\n========\n",$3,$6);
};

cases: cases case {strcat($1,", case ");strcat($1,$2);$$=$1;}|
case {$$=$1;};

case: T_CASE constantes T_DOSPTO operaciones T_BREAK T_PTCOM {$$=$2;}
| T_CASE T_CAR T_DOSPTO operaciones T_BREAK T_PTCOM {$$=$2;};

constantes: T_INT {$$=$1;}|
T_FLOAT {$$=$1;}|
T_CHAR {$$=$1;};

contsEstructura: contsEstructura contEstructura|contEstructura| ;

contEstructura: operaciones|estructuraAlgoritmo;

struct: T_STRUCT T_ID T_CA declaracion T_CC T_PTCOM {
fprintf(fsalidaStru,"Struct:\t%s\nMiembros:\t%s\n========\n",$2,$4);
};

9

4. CDIGO

4.1 Analizador Lxico
letra [a-zA-Z_]
DIGITO [0-9]
ID ([a-zA-Z]|"_")([a-zA-Z0-9]|"_")*
TIPOSDATO "char"|"int"|"long"|"short"|"float"|"double"|"void"
OPRELACION "<"|">"|">="|"<="|"!="|"=="
OPINCREMENTO "+"|"-"|"*"|"/"
OPINCREMENTO2 "++"|"--"
OPINCREMENTO3 "-="|"+="|"*="|"/="
OPLOG "&&"|"||"
%%

"else" {yylval.valor = strdup(yytext); return(T_ELSE);}
"switch" {yylval.valor = strdup(yytext); return(T_SWITCH);}
"case" {yylval.valor = strdup(yytext); return(T_CASE);}
"for" {yylval.valor = strdup(yytext); return(T_FOR);}
"while" {yylval.valor = strdup(yytext); return(T_WHILE);}
"do" {yylval.valor = strdup(yytext); return(T_DO);}
"if" {yylval.valor = strdup(yytext); return(T_IF);}
"return" {yylval.valor = strdup(yytext); return(T_RETURN);}
"break" {yylval.valor = strdup(yytext); return(T_BREAK);}
"struct" {yylval.valor = strdup(yytext); return(T_STRUCT);}
{DIGITO}+ {yylval.valor = strdup(yytext); return(T_INT);}
{DIGITO}+"."{DIGITO}+ {yylval.valor = strdup(yytext); return(T_FLOAT);}
"'"{letra}"'" {yylval.valor = strdup(yytext); return(T_CAR);}
"\""{letra}"\"" {yylval.valor = strdup(yytext); return(T_CHAR);}
{TIPOSDATO} {yylval.valor = strdup(yytext); return(T_TDATO);}
{ID} {yylval.valor = strdup(yytext); return(T_ID);}
{OPINCREMENTO} {yylval.valor = strdup(yytext); return(T_INCR);}
{OPINCREMENTO3} {yylval.valor = strdup(yytext); return(T_OPAARIT);}
{OPINCREMENTO2} {yylval.valor = strdup(yytext); return(T_INCR2);}
{OPRELACION} {yylval.valor = strdup(yytext); return(T_OPRELACION);}
{OPLOG} {yylval.valor = strdup(yytext); return(T_ANDOR);}
";" {yylval.valor = strdup(yytext); return(T_PTCOM);}
"," {yylval.valor = strdup(yytext); return(T_COMA);}
":" {yylval.valor = strdup(yytext); return(T_DOSPTO);}
"=" {yylval.valor = strdup(yytext); return(T_OPASIG);}
"(" {yylval.valor = strdup(yytext); return(T_PA);}
")" {yylval.valor = strdup(yytext); return(T_PC);}
"{" {yylval.valor = strdup(yytext); return(T_CA);}
"}" {yylval.valor = strdup(yytext); return(T_CC);}
\n ++lineas;
. {}

10

4.2 Analizador Semntico
%union
{
char *valor;
}

%token <valor> T_ID T_INT T_FLOAT T_IF T_ELSE T_SWITCH T_CASE T_FOR T_WHILE T_DO
T_TDATO T_OPAARIT T_INCR2 T_COMA T_PTCOM T_OPRELACION T_OPASIG T_PA T_PC
T_CA T_CC T_INCR T_ANDOR T_CHAR T_RETURN T_STRUCT T_DOSPTO T_BREAK T_CAR
%type <valor> argumentos
%type <valor> declaracion
%type <valor> id
%type <valor> conte
%type <valor> return
%type <valor> asignaciones
%type <valor> operArit
%type <valor> valores
%type <valor> cases
%type <valor> case
%type <valor> constantes
%start funciones
%%

/*Definciones principales*/

funciones : funciones funcion|
funcion;

funcion : T_TDATO T_ID T_PA argumentos T_PC T_CA conte T_CC{
if(!strcmp($1,"void")){
if(strcmp($7,""))
yyerror("Documento no valido");
}
else if(!strcmp($7,""))
yyerror("Documento no valido");
fprintf(fsalidaFun,"Funcion:\t%s\nRetorno:\t%s\nArgumentos:\t%s\
n========\n", $2, $7, $4);};

argumentos: T_TDATO T_ID {strcat($1," ");strcat($1,$2);$$=$1;}|
T_TDATO T_ID T_COMA argumentos {strcat($1," ");strcat($1,$2);
strcat($1,", ");strcat($1,$4);$$=$1;}
|{$$="";};

conte: elementos conte {$$=$2;}|
return {$$=$1;}|{$$="";};

elementos: declaracion|operaciones|estructuras;

11

declaracion: T_TDATO id T_PTCOM {strcat($1," ");strcat($1,$2);$$=$1;}|
T_TDATO id T_PTCOM declaracion {strcat($1," ");strcat($1,$2);
strcat($1,", ");strcat($1,$4);$$=$1;};

id: T_ID{$$=$1;}|
T_ID T_COMA id {strcat($1,",");strcat($1,$3);$$=$1;};

operaciones: asignaciones T_PTCOM {}|
T_ID T_OPASIG T_CHAR{}|
operArit T_PTCOM {}|
operaciones asignaciones T_PTCOM {}|
operaciones operArit T_PTCOM {};

asignaciones: T_ID T_OPASIG T_ID {strcat($1,$2);strcat($1,$3);$$=$1;}|
T_ID T_OPASIG T_INT {strcat($1,$2);strcat($1,$3);$$=$1;}|
T_ID T_OPASIG T_FLOAT {strcat($1,$2);strcat($1,$3);$$=$1;};

operArit: T_ID T_OPAARIT valores {strcat($1,$2);strcat($1,$3);$$=$1;}|
T_ID T_OPASIG valores T_INCR valores {strcat($1,$2);strcat($1,$3);
strcat($1,$4);strcat($1,$5);$$=$1;}|
T_ID T_INCR2 {strcat($1,$2);$$=$1;};

valores: T_INT {$$=$1;}|
T_FLOAT {$$=$1;}|
T_ID {$$=$1;};

return: T_RETURN T_PA T_ID T_PC T_PTCOM {$$=$3;}|
T_RETURN T_PA T_INT T_PC T_PTCOM {$$=$3;}|
T_RETURN T_PA T_FLOAT T_PC T_PTCOM {$$=$3;};

estructuras: estructuras estructurasCuerpo {}|
estructurasCuerpo {};

estructurasCuerpo: estructuraAlgoritmo|struct;

estructuraAlgoritmo: for|while|dowhile|if|IfElse|switch;

for: T_FOR T_PA asignaciones T_PTCOM valores T_OPRELACION valores T_PTCOM
operArit T_PC T_CA contsEstructura T_CC{
strcat($5,$6);strcat($5,$7);
fprintf(fsalidaRep,"Estructura repetitiva:\t%s\nAsignaciones:\t%s\
nCondicion de Paro:\t%s\nIncremento:\t%s\n========\n",$1,$3,$5,$9);
};

while: T_WHILE T_PA valores T_OPRELACION valores T_PC T_CA contsEstructura
T_CC{
strcat($3,$4);strcat($3,$5);
12

fprintf(fsalidaRep,"Estructura repetitiva:\t%s\nCondicion de
paro:\t%s\n========\n",$1,$3);
};

dowhile: T_DO T_CA contsEstructura T_CC T_WHILE T_PA valores T_OPRELACION
valores T_PC T_PTCOM {
strcat($7,$8);strcat($7,$9);
fprintf(fsalidaRep,"Estructura repetitiva:\tDo-while\nCondicion de
paro:\t%s\n========\n",$7);
};

if: T_IF T_PA valores T_OPRELACION valores T_PC T_CA contsEstructura T_CC
{
strcat($3,$4);strcat($3,$5);
fprintf(fsalidaSel,"Condicional:\nif\nCondicion a evaluar:\t%s\n========\
n",$3);}|
T_IF T_PA valores T_OPRELACION valores T_PC contEstructura {
strcat($3,$4);strcat($3,$5);
fprintf(fsalidaSel,"Condicional:\tif\nCondicion a evaluar:\t%s\n========\
n",$3);
};

IfElse: T_IF T_PA valores T_OPRELACION valores T_PC T_CA contsEstructura T_CC
T_ELSE T_CA contsEstructura T_CC {
strcat($3,$4);strcat($3,$5);
fprintf(fsalidaSel,"Condicional:\tif-else\nCondicion a
evaluar:\t%s\n========\n",$3);
};

switch: T_SWITCH T_PA valores T_PC T_CA cases T_CC {
fprintf(fsalidaSel,"Condicional:\tswitch-case\nCondicion a
Evaluar:\t%s\nCases: case %s\n========\n",$3,$6);
};

cases: cases case {strcat($1,", case ");strcat($1,$2);$$=$1;}|
case {$$=$1;};

case: T_CASE constantes T_DOSPTO operaciones T_BREAK T_PTCOM {$$=$2;}
| T_CASE T_CAR T_DOSPTO operaciones T_BREAK T_PTCOM {$$=$2;};

constantes: T_INT {$$=$1;}|
T_FLOAT {$$=$1;}|
T_CHAR {$$=$1;};

contsEstructura: contsEstructura contEstructura|contEstructura| ;

contEstructura: operaciones|estructuraAlgoritmo;

13

struct: T_STRUCT T_ID T_CA declaracion T_CC T_PTCOM {
fprintf(fsalidaStru,"Struct:\t%s\nMiembros:\t%s\n========\n",$2,$4);
};

4.3 Analizador
void yyerror(char *s)
{
printf("\nProblema al Analizar Documento : %s\n\n",s);
exit(0);
}

int main( int argc, char **argv )
{
if (argc>1){
yyin = fopen(argv[1], "r");
fsalidaRep = fopen("Estructura Repetitiva.txt","w");
fsalidaSel = fopen("Estructura Selectiva.txt","w");
fsalidaFun = fopen("Funciones.txt","w");
fsalidaStru = fopen("Structs.txt","w");
}else
{
printf("Forma de uso: ./analizador archivo_entrada\n");
return 0;
}
yyparse();

return 0;
}