UNIVERSIDAD NACIONAL DE JUJUY

Facultad de Ingeniera

2012
ANALIZADOR RSC
PARA LENGUAJE C
Trabajo Prctico Final
COMPILADORES

Integrantes:
CRUZ, Silvia Eugenia Licenciatura en Sistemas 1005
RIOS, Flavio Oscar Licenciatura en Sistemas 713
SAGRERO, Marcelo Javier Licenciatura en Sistemas 1078

10/07/12
Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

INTRODUCCION

El siguiente trabajo consiste en la construccin de un analizador para un programa escrito en

lenguaje de programacin C. Este analizador permite reconocer: nmeros enteros, nmeros
flotantes, identificadores del lenguaje, palabras reservadas, smbolos y operadores e ignorar
comentarios y espacios en blanco.

Para su desarrollo se utilizaron las siguientes herramientas:

Microsoft Visual Studio, que es un entorno de desarrollo integrado para sistemas

operativos Windows. Este soporta varios lenguajes de programacin como ser Visual C++
que es el lenguaje utilizado para la realizacin de este trabajo final.

Flex, que permite generar analizadores lxicos, a partir de un conjunto de expresiones

regulares que busca concordancia en un fichero de entrada y ejecuta acciones asociadas a
estas gramticas.

Bison, que es un generador de analizadores sintcticos de propsito general que convierte

una descripcin para una gramtica independiente del contexto en un programa en C que
analiza esa gramtica. Usndolo junto a Flex esta herramienta nos permite construir
compiladores de lenguaje.

RIOS, SAGRERO, CRUZ Pgina 2 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

DESARROLLO
El Analizador RSC que aqu presentamos analiza sintcticamente cdigo en lenguaje C. As
de acuerdo a una entrada con una porcin del cdigo debe poder identificar las estructuras
principales, declaraciones de constantes, declaraciones de variables, estructuras de control (IF-
ELSE, SWITCH) y estructuras repetitivas (FOR, WHILE, DO WHILE).

Se debe tener en cuenta que el mismo reconoce las estructuras anidadas en ms de un nivel
de profundidad y que las acciones deben estar despus de dichas estructuras encerradas entre
llaves ({}).

De esta manera es capaz de realizar el anlisis completo del cdigo ingresado mostrando al
usuario un detalle de los elementos que componen dicho cdigo. En el caso de que la entrada sea
incorrecta, el anlisis se detendr en la palabra que produjo el error y solo mostrara los elementos
hasta all encontrados.

El analizador RSC tambin reconoce operaciones de multiplicacin, divisin, resta y suma.

Reconoce variables de tipo entero (int), carcter (char), cadena (string) y operadores como menor
igual (<=), mayor igual (>=), igual (==), menor (<) y mayor (>).

Cuando se ingresa un smbolo no reconocido se muestra por pantalla un mensaje de error e

indica el nmero de lnea en la cual se encuentra el smbolo no reconocido.

Estructura de un programa:

/*Zona de libreras:*/ /*los comentarios son opcionales*/

#include<librera.extensin > /*las libreras no son obligatorias*/

/*Zona de declaracin de variables*/

int variable1,variable2; /*la declaracin de variables nos son obligatorias*/

/*Zona de inicializacin de variables*/

Variable1=100; /*las inicializacin de variables no es obligatoria*/

/*Zona de funciones*/

void main() /*la funcin main es obligatoria */

Sentencias /*las sentencias estn compuestas por : declaracin de*/

/* variables, asignacin de valores a las variables, */

/* operaciones, estructuras (IF-ELSE, SWITCH, FOR,*/

/* DO-WHILE, WHILE, llamadas a otras funciones.

RIOS, SAGRERO, CRUZ Pgina 3 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

A continuacin en la tabla se muestra un pequeo resumen que tuvimos en cuenta respecto al

lenguaje analizado.

ESTRUCTURAS RECONOCIDAS SINTAXIS Y EJEMPLOS

comentarios /* esto es un comentario*/

Los comentarios tienen que estar encerrados entre los

smbolos /* y */ y pueden estar a continuacin de
una expresin que termine en punto coma (;), antes y
entre las libreras, antes de las funciones pero no al
final del programa fuente. Los comentarios no pueden
contener palabras reservadas, nmeros ni smbolos o
signos. O sea solo debe ser texto. Ejemplo:

#include<librera.h> /* comentario valido*/

void main() /*comentario 1nvalid0*/

printf(escribir); /*comentario valido*/

Libreras #include<librera.extension>

Este formato es obligatorio, ya que no se pueden

obviar ni el punto (.) ni la extensin.

Declaracin de variables TipoDato ElDato;

Los tipos de datos reconocidos son: int, flota, char y

string; es obligatorio que la declaracin termine con
punto coma (;).

Tambin se pueden declarar varias variables de un

tipo de dato. Ejemplos:

string frase1,frase2;

string frase1;

string frase2;

Inicializacin o asignacin de variables Variable=valor;

Donde el valor a asignar puede ser del tipo int, float,

char, string e incluso otra variable. El punto coma (;)
es obligatorio. Ejemplos:

Variable= valor1;

RIOS, SAGRERO, CRUZ Pgina 4 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

pi=3.14;

Operaciones Variable=operando operador operando;

Donde operando puede ser una expresin o un

nmero (entero o flotante) y operador puede ser:
suma (+), resta (-), producto (*) o divisin (/). El
punto coma (;) es obligatorio Ejemplos:

Total= 5 + operando;

Total= 5 + 5;

Total=operando + 5;

Total= operando + operando;

Funciones TipoDeFuncion NombreDeFuncion (TipoDeDato

argumento1, TipoDeDato argumento2)

Declaracin de variables;

Inicializacin de variables;

sentencias

Donde la declaracin de variables deben estar al

comienzo de la funcin seguida por Inicializacin de
variables o asignaciones.

Donde TipoDeFuncion puede ser del tipo void, int,

float, char, string. Los argumentos son opcionales y
TipoDeDato puede ser int, float, char, o string. La
funcin main es obligatoria y tiene que ser la primera
funcin. Ejemplos:

void main()

sentencias

int calculo(int argumento1, string argumento2)

RIOS, SAGRERO, CRUZ Pgina 5 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

sentencias

Llamada a funciones FuncionLamada(datoenviado1,datoenviado2,)

Donde FuncionLlamada es una expresin, y

DatoEnviado son opcionales pudiendo ser una
expresin o numeros (enteros o flotantes), en caso de
enviar muchos argumentos deben estar separados por
una coma (,). Ejemplos:

calculo(pi , 3.14);

printf(esto,es,un,ejemplo);

Sentencias Las sentencias pueden ser: estructuras de control (if-

else, swith, for, do-while, while), asignaciones,
llamadas a funciones u operaciones.

Sentencia if-else if ( expresion1 OperadorRelacional expresion2)

{sentencias}

else

{sentencias}

Donde OperadorRelacional puede ser: < , <= , > ,

>= , ==.

Y expresin puede ser una variable o numeros

(entero o flotante). Despus de la condicin siempre
debe haber una llave abierta ( { )y una llave cerrada (
}). En esta expresin las sentencias y else son
opcionales. Ejemplos:

if (MAX <= 100)

printf(error);

else

printf(todo,bien);

RIOS, SAGRERO, CRUZ Pgina 6 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

Sentencia switch switch(expresion)

case valor1: sentencias break;

case valorN: sentencias break;

default: sentencias

Donde expresin puede ser una variable o nmeros

(enteros o flotantes) y todo lo relacionados al switch
tiene que estar entre llaves ( { } ) y debe haber por lo
menos un case. La sentencias y break son
opcionales. Ejemplo:

switch(opcion)

{ case 1:

if(80==10)

{ printf(ejemplo);

break;

case 2: printf(sigo);

default: function(valores,100);

Sentencia for for(variable=valor;condicion;paso)

Sentencias

Donde variable=valor es la inicializacin de la

variable que controla el ciclo, condicin tiene la
forma expresin Smbolo expresin. En la cual
expresin puede ser una variable o un numero (entero
o flotante) y Smbolo puede ser: < , <= , > , >= o == .
Paso puede ser variable++ , ++variable, --variable,
variable. Ejemplo:

for(i=0 ; i < 10; i++)

RIOS, SAGRERO, CRUZ Pgina 7 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

printf( i );

Sentencia DO-WHILE do

Sentencias

}while(condicin);

Donde condicin es similar a la condicin del while.

Ejemplo:

do

printf( i )

i=i +1;

}while(i < = 10) ;

Sentencia WHILE while(condicion)

sentencias

Donde las sentencias debe estar encerradas entre

llaves ( { } ) y condicin tiene la siguiente estructura:
expresin OpRelacional expresin; en la cual
expresin puede ser una variable o un numero (entero
o flotante) y el OpRelacional puede ser: < , <= , > ,
>= o ==. Ejemplo:

while(i < = 10)

printf( i );

i=i +1;

RIOS, SAGRERO, CRUZ Pgina 8 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

Definicin de Lexemas, Patrones y Tokens de la Gramtica

LEXEMA PATRON TOKEN
Include include INCLUDE
Main main MAIN
Void void VOID
Int int INT
Float float FLOAT
Char char CHAR
String string STRING
If if IF
Else else ELSE
For for FOR
Do do DO
While while WHILE
Case case CASE
Switch switch SWITCH
Break break BREAK
Default default DEFAULT
COMILLAS
, , COMA
( ( PAR_A
) ) PAR_C
{ { LLAVE_A
} } LLAVE_C
+ + S_MAS
- - S_MENOS
* * S_POR
/ / S_DIV
# # S_NUM
< < S_MEN
> > S_MAY
s_meni <= S_MENI

RIOS, SAGRERO, CRUZ Pgina 9 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

s_mayi >= S_MAYI

coment_a /* COMENT_A
coment_c */ COMENT_C
s_digual == S_DIGUAL
s_dmas ++ S_DMAS
s_dmen -- S_DMEN
= = S_IGUAL
. . PTO
: : DOS_PTO
; ; PTO_COMA
Numero [0-9]+ NUMERO
Real {numero}\.{numero}+ REAL
Ident [a-zA-Z]([a-zA-Z]|[0-9])* IIDENT

Definiciones de la Gramtica del Lenguaje

<entrada> := <comentarios> <librerias> <comentrios> <inicial> <funciones>

<librerias>:= <libreria>
|<librerias> <comentrios> <libreria>
|

<libreria>:= <s_num> <include> <s_menor> <ident> <pto> <ident> <s_mayor>

<inicial>:= <declaraciones> <comentarios> <asignaciones> <comentarios>

|

<s_num>:= <S_NUM>

<include>:= <INCLUDE>

<s_menor>:= <S_MEN>

<s_mayor>:= <S_MAY>

<pto>:= <PTO>
<declaraciones>:= <declaracion>
|<declaraciones> <comentarios> <declaracion>
|

<declaracion>:= <tipod> <ident> <dec_recu> <pto_coma>

<dec_recu>:= | <coma> <ident> <dec_recu>

| <ident>

RIOS, SAGRERO, CRUZ Pgina 10 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

<asignaciones> := <asignacin>
|<asignaciones> <comentarios> <asignacin>
|

<asignacion> := <ident> <s_igual> <expr> <pto_coma>

<ident> := <IDENT>

<s_igual> := <S_IGUAL>

<expr> := <IDENT>
|<NUMERO>
|<REAL>

<pto_coma>:= < PTO_COMA>

/************************ FUNCIONES ************************************/

<funciones>:= <tipof main> <par_a> <argumentos> <par_c> <llave_a> <cuerpo> <llave_c>

<comentarios> <fun_rec>

<fun_rec>:= <funcion>
|<fun_rec> <comentarios> <funcion>
|

<funcion>:= <tipof> <ident> <par_a> <argumentos> <par_c> <llave_a> <cuerpo> <llave_c>

<call_func>:= <ident> <par_a> <arg> <par_c> <pto_coma>

<arg>:= <exp>
|<arg> <coma> <expr>
|

<main>:= <MAIN>

<argumentos>:= <argumento>
|<argumentos> <coma> <argumento>
|

<argumento>:= <tipof> <ident>

|

/******************************* CUERPO ***********************************/

<cuerpo>:= |<comentarios> <declaraciones> <comentarios> <asignaciones> <sentencias>

|<sentencias>
|

/***************************** SENTENCIAS ***********************************/

<sentencias>:= <comentarios> <sentencia>

|<sentencias> <comentarios> <sentencia>
|

<sentencia>:= <sent_if>
|<asignacion>

RIOS, SAGRERO, CRUZ Pgina 11 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

|<sent_while>
|<sent_for>
|<sent_do>
|<sent_case>
|<call_func>
|<operaciones>

/****************************** IF ******************************************/
<sent_if>:= <pr_if> <condiciones> <llave_a> <sentencias> <llave_c>
<comentarios> <else>

<else>:= |<pr_else> <llave_a> <sentencias> <llave_c>

|

<pr_if>:= <IF>

<pr_else>:= <ELSE>

/***************************** CONDICIONES *********************************/

<condiciones>:= <par_a> <expr> <op_log> <expr> <par_c>

<op_log>:= <S_MAYI>
|<s_menor>
|<s_mayor>
|<S_DIGUAL>
|<S_MENI>

/********************************** WHILE ***********************************/

<sent_while>:= <while> <condiciones> <llave_a> <sentencias> <llave_c>

<while>:= <WHILE>

/****************************** SENTENCIA FOR *****************************/

<sent_for>:= <for> <par_a> <asignacin> <cond_for> <pto_coma> <paso> <par_c>

<llave_a> <sentencias> <llave_c>

<for>:= <FOR>

<cond_for>:= <expr> <op_log> <expr>

<paso>:= <ident> <s_dmas>

|<ident> <s_dmen>
|<s_dmas> <ident>
|<s_dmen> <ident>

/************************ SENTENCIA DO WHILE *****************************/

<sent_do>:=<do> <llave_a> <comentarios> <sentencias> <llave_c> <while> <condiciones>

<pto_coma>

<do>:= <DO>

/****************************** EL CASE **********************************/

RIOS, SAGRERO, CRUZ Pgina 12 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

<sent_case>:= <switch> <par_a> <ident> <par_c> <llave_a> <cases> <llave_c>

<cases>:= <case>
|<cases> <case>

<case>:= <pr_case> <expr> <dos_ptos> <sentencias>

|<break> <pto_coma>
|<default> <dos_ptos> <sentencias>

<break>:= <BREAK>

<default>:= <DEFAULT>

<pr_case>:= <CASE>

<switch>:= <SWITCH>

/****************************** tipos *******************************************/

<tipof>:= <void>
|<int>
|<float>
|<char>
|<string>

<tipod>:= |<int>
|<float>
|<char>
|<string>

<void>:= <VOID>

<int>:= <INT>

<float>:= <FLOAT>

<char>:= <CHAR>

<string>:= <STRING>

/*************************** COMENTARIOS ****************************/

<comentrios>:= |<coment_a> <expr_rec> <coment_c>

|

<expr_rec>:= |<expr_com>
|<expr_rec> <expr_com>

<expr_com>:= <IDENT>
|<NUMERO>

<coment_a>:= <COMENT_A>

<coment_c>:= <COMENT_C>

/************************ SIMBOLOS ***********************************/

RIOS, SAGRERO, CRUZ Pgina 13 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

<par_a>:= <PAR_A>

<par_c>:= <PAR_C>

<coma>:= <COMA>

<llave_a>:= <LLAVE_A>

<llave_c>:= <LLAVE_C>

<dos_ptos>:= <DOS_PTOS>

/**************************** OPERACIONES *******************************/

<operaciones>:= <ident> <s_igual> <expr> <operador> <expr> <pto_coma>

|<comentrios>

<operador>:= <s_mas>
|<s_menos>
|<s_por>
|<s_div>

<s_por>:= <S_POR>

<s_div>:= <S_DIV>

<s_mas>:= <S_MAS>

<s_menos>:= <S_MENOS>

<s_dmas>:= <S_DMAS>

<s_dmen>:= <S_DMEN>

<asigna>:= <asignacion2>
|<asigna> <asignacion2>

<asignacion2>:= <ident> <s_igual> <expr> <pto_coma>

/******************************************************************************/

Especificacin para los metacompiladores

/* Fichero : analex.l" */

%header{

#include "yystype.h"

%}

%{

RIOS, SAGRERO, CRUZ Pgina 14 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

#include "anasint.h"

int linea=1;

%}

blanco " "|\t

nuevalinea \n

ident [a-zA-Z]([a-zA-Z]|[0-9])*

numero [0-9]+

real {numero}\.{numero}+

s_meni "<="

s_mayi ">="

s_digual "=="

s_dmas "++"

s_dmen "--"

coment_a "/*"

coment_c "*/"

%define LEX_PARAM YY_parse_STYPE *yylval

%%

{blanco} {;}

{nuevalinea} {linea++;}

"include" {yylval->texto = yytext; return(INCLUDE);}

"main" {yylval->texto = yytext; return(MAIN);}

"void" {yylval->texto = yytext; return(VOID);}

"int" {yylval->texto = yytext; return(INT);}

"float" {yylval->texto = yytext; return(FLOAT);}

"char" {yylval->texto = yytext; return(CHAR);}

"string" {yylval->texto = yytext; return(STRING);}

"if" {yylval->texto = yytext; return(IF);}

"else" {yylval->texto = yytext; return(ELSE);}

"for" {yylval->texto = yytext; return(FOR);}

"do" {yylval->texto = yytext; return(DO);}

"while" {yylval->texto = yytext; return(WHILE);}

RIOS, SAGRERO, CRUZ Pgina 15 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

"case" {yylval->texto = yytext; return(CASE);}

"switch" {yylval->texto = yytext; return(SWITCH);}

"break" {yylval->texto = yytext; return(BREAK);}

"default" {yylval->texto = yytext; return(DEFAULT);}

"'" {yylval->texto = yytext; return(COMILLAS);}

"," {yylval->texto = yytext; return(COMA);}

"(" {yylval->texto = yytext; return(PAR_A);}

")" {yylval->texto = yytext; return(PAR_C);}

"{" {yylval->texto = yytext; return(LLAVE_A);}

"}" {yylval->texto = yytext; return(LLAVE_C);}

"+" {yylval->texto = yytext; return(S_MAS);}

"-" {yylval->texto = yytext; return(S_MENOS);}

"*" {yylval->texto = yytext; return(S_POR);}

"/" {yylval->texto = yytext; return(S_DIV);}

"#" {yylval->texto = yytext; return(S_NUM);}

"<" {yylval->texto = yytext; return(S_MEN);}

{s_meni} {yylval->texto = yytext; return(S_MENI);}

">" {yylval->texto = yytext; return(S_MAY);}

{s_mayi} {yylval->texto = yytext; return(S_MAYI);}

{coment_a} {yylval->texto = yytext; return(COMENT_A);}

{coment_c} {yylval->texto = yytext; return(COMENT_C);}

{s_digual} {yylval->texto = yytext; return(S_DIGUAL);}

{s_dmas} {yylval->texto = yytext; return(S_DMAS);}

{s_dmen} {yylval->texto = yytext; return(S_DMEN);}

"=" {yylval->texto = yytext; return(S_IGUAL);}

"." {yylval->texto = yytext; return(PTO);}

":" {yylval->texto = yytext; return(DOS_PTOS);}

";" {yylval->texto = yytext; return(PTO_COMA);}

{numero} {yylval->texto = yytext; return(NUMERO);}

RIOS, SAGRERO, CRUZ Pgina 16 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

{real} {yylval->texto = yytext; return(REAL);}

{ident} {yylval->texto = yytext; return(IDENT);}

. {printf("\nCaracter desconocido en linea %d\n",linea); return(ERROR);}

%%

/* Fichero: anasint.y */

%header{

#include "yystype.h"

%}

%{

#include <stdio.h>

#include <string.h>

#include "analex.h"

void yyerror(const char *);

char pr[1000];

char ident[1000];

char simb[100];

char num[1000];

char opr[100];

int band_opr=0;

int band_i = 0;

int band_s = 0;

int band_n = 0;

int band_pr = 0;

void mostrar()

printf("******************************");

printf("\nALUMNOS:\n FLAVIO RIOS \n MARCELO SAGRERO\n SILVIA CRUZ\n");

printf("******************************************************************************");

printf("\n \nIdentificadores: %s\n", ident);

printf("\nSimbolos: %s\n", simb);

RIOS, SAGRERO, CRUZ Pgina 17 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

printf("\nOperadores: %s\n", opr);

printf("\nNumeros: %s\n", num);

printf("\nPalabras Reservadas: %s\n", pr);

printf("\n****************************************************************************");

printf("\n");

%}

%token

%token <texto> NUMERO IDENT INCLUDE REAL

%token <texto> IF ELSE FOR DO WHILE CASE SWITCH BREAK DEFAULT

%token <texto> S_MENI S_DIGUAL COMA PAR_C PAR_A LLAVE_A LLAVE_C S_IGUAL

%token <texto> S_DMAS S_DMEN S_MAS S_MENOS S_POR S_DIV

%token <texto> COMENT_A COMENT_C

%token <texto> PTO PTO_COMA S_NUM S_MEN S_MAY S_MAYI COMILLAS DOS_PTOS

%token <texto> MAIN VOID INT FLOAT CHAR STRING ERROR

%type <texto> asignaciones asignacion ident expr s_igual pto_coma

%define PURE

%define STYPE YY_parse_STYPE

%%

entrada : comentarios librerias comentarios inicial funciones {mostrar(); printf("\nENTRADA

CORRECTA \n\n"); }

librerias: libreria

|librerias comentarios libreria

|;

libreria: s_num include s_menor ident pto ident s_mayor {printf("\n"); };

inicial: declaraciones comentarios asignaciones comentarios

|;

s_num: S_NUM {if (band_s == 0) {strcpy(simb,$1); strcat(simb," "); band_s = 1;} else
{if(strstr(simb,$1) == NULL) {strcat(simb,$1); strcat(simb," ");}}; };

include: INCLUDE {if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1)
== NULL) {strcat(pr,$1); strcat(pr," ");}}; };

s_menor: S_MEN {if (band_opr == 0) {strcpy(opr,$1); strcat(opr," "); band_opr = 1;} else

RIOS, SAGRERO, CRUZ Pgina 18 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

{if(strstr(opr,$1) == NULL) {strcat(opr,$1); strcat(opr," ");}}; };

s_mayor: S_MAY {if (band_opr == 0) {strcpy(opr,$1); strcat(opr," "); band_opr = 1;} else
{if(strstr(opr,$1) == NULL) {strcat(opr,$1); strcat(opr," ");}}; };

pto: PTO {if (band_s == 0) {strcpy(simb,$1); strcat(simb," "); band_s = 1;} else {if(strstr(simb,$1) ==
NULL) {strcat(simb,$1); strcat(simb," ");}}; };

declaraciones: declaracion

|declaraciones comentarios declaracion

|;

declaracion: tipod ident dec_recu pto_coma

dec_recu: |coma ident dec_recu

|ident

|;

asignaciones : asignacion

|asignaciones comentarios asignacion

|;

asignacion : ident s_igual expr pto_coma

ident : IDENT {if (band_i == 0) {strcpy(ident,$1); strcat(ident," "); band_i = 1;} else {if(strstr(ident,$1)
== NULL) {strcat(ident,$1); strcat(ident," ");}};}

s_igual : S_IGUAL {if (band_opr == 0) {strcpy(opr,$1); strcat(opr," "); band_opr = 1;} else
{if(strstr(opr,$1) == NULL) {strcat(opr,$1); strcat(opr," ");}}; };

expr : IDENT {if (band_i == 0) {strcpy(ident,$1); strcat(ident," "); band_i = 1;} else
{if(strstr(ident,$1) == NULL) {strcat(ident,$1); strcat(ident," ");}};}

|NUMERO {if (band_n == 0) {strcpy(num,$1); strcat(num," "); band_n = 1;}

else {if(strstr(num,$1) == NULL) {strcat(num,$1); strcat(num," ");}};}

|REAL {if (band_n == 0) {strcpy(num,$1); strcat(num," "); band_n = 1;} else

{if(strstr(num,$1) == NULL) {strcat(num,$1); strcat(num," ");}};}

pto_coma: PTO_COMA{if (band_s == 0) {strcpy(simb,$1); strcat(simb," "); band_s = 1;} else

{if(strstr(simb,$1) == NULL) {strcat(simb,$1); strcat(simb," ");}}; }

/************************ FUNCIONES ****************************************/

RIOS, SAGRERO, CRUZ Pgina 19 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

funciones: tipof main par_a argumentos par_c llave_a cuerpo llave_c

comentarios fun_rec

fun_rec: funcion

|fun_rec comentarios funcion

|;

funcion: tipof ident par_a argumentos par_c llave_a cuerpo llave_c

call_func: ident par_a arg par_c pto_coma

arg: expr

|arg coma expr

|;

main: MAIN {if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) ==
NULL) {strcat(pr,$1); strcat(pr," ");}}; }

argumentos: argumento

|argumentos coma argumento

|;

argumento: tipof ident

|;

/************************************************************************/

/********************** CUERPO *****************************************/

cuerpo: |comentarios declaraciones comentarios asignaciones sentencias

|sentencias

|;

/*********************** SENTENCIAS ***********************************/

sentencias: comentarios sentencia

|sentencias comentarios sentencia

|;

RIOS, SAGRERO, CRUZ Pgina 20 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

sentencia: sent_if

|asignacion

|sent_while

|sent_for

|sent_do

|sent_case

|call_func

|operaciones

/************************ IF ********************************************/

sent_if: pr_if condiciones llave_a sentencias llave_c

comentarios else

else: |pr_else llave_a sentencias llave_c

|;

pr_if: IF {if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) == NULL)
{strcat(pr,$1); strcat(pr," ");}}; };

pr_else: ELSE{if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) ==
NULL) {strcat(pr,$1); strcat(pr," ");}}; };

/*********************** CONDICIONES **********************************/

condiciones: par_a expr op_log expr par_c

op_log: S_MAYI {if (band_opr == 0) {strcpy(opr,$1); strcat(opr," "); band_opr = 1;} else
{if(strstr(opr,$1) == NULL) {strcat(opr,$1); strcat(opr," ");}}; };

|s_menor

|s_mayor

|S_DIGUAL{if (band_opr == 0) {strcpy(opr,$1); strcat(opr," "); band_opr = 1;} else

{if(strstr(opr,$1) == NULL) {strcat(opr,$1); strcat(opr," ");}}; };

|S_MENI {if (band_opr == 0) {strcpy(opr,$1); strcat(opr," "); band_opr = 1;} else

{if(strstr(opr,$1) == NULL) {strcat(opr,$1); strcat(opr," ");}}; };

RIOS, SAGRERO, CRUZ Pgina 21 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

/************************WHILE ***************************************/

sent_while: while condiciones llave_a sentencias llave_c

while: WHILE {if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) ==
NULL) {strcat(pr,$1); strcat(pr," ");}}; };

/*****************************SENTENCIA FOR*****************************/

sent_for: for par_a asignacion cond_for pto_coma paso par_c

llave_a sentencias llave_c

for: FOR{if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) ==
NULL) {strcat(pr,$1); strcat(pr," ");}}; }

cond_for: expr op_log expr

paso: ident s_dmas

|ident s_dmen

|s_dmas ident

|s_dmen ident

/**************************** SENTENCIA DO WHILE ***********************/

sent_do: do llave_a comentarios sentencias llave_c while condiciones pto_coma

do: DO {if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) ==
NULL) {strcat(pr,$1); strcat(pr," ");}}; };

/**************************** EL CASE ************************************/

sent_case: switch par_a ident par_c llave_a cases llave_c

cases: case

RIOS, SAGRERO, CRUZ Pgina 22 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

|cases case

case: pr_case expr dos_ptos sentencias

|break pto_coma

|default dos_ptos sentencias

break: BREAK{if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) ==
NULL) {strcat(pr,$1); strcat(pr," ");}}; };

default: DEFAULT{if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1)
== NULL) {strcat(pr,$1); strcat(pr," ");}}; };

pr_case: CASE{if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) ==
NULL) {strcat(pr,$1); strcat(pr," ");}}; };

switch: SWITCH{if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1)
== NULL) {strcat(pr,$1); strcat(pr," ");}}; };

/***************************** tipos ***********************************/

tipof: void

|int

|float

|char

|string

tipod: |int

|float

|char

|string

void: VOID {if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) ==
NULL) {strcat(pr,$1); strcat(pr," ");}}; }

int: INT {if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) ==
NULL) {strcat(pr,$1); strcat(pr," ");}}; }

RIOS, SAGRERO, CRUZ Pgina 23 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

float: FLOAT{if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) ==
NULL) {strcat(pr,$1); strcat(pr," ");}}; }

char: CHAR{if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) ==
NULL) {strcat(pr,$1); strcat(pr," ");}}; }

string: STRING{if (band_pr == 0) {strcpy(pr,$1); strcat(pr," "); band_pr = 1;} else {if(strstr(pr,$1) ==
NULL) {strcat(pr,$1); strcat(pr," ");}}; }

/************************ COMENTARIOS *******************************/

comentarios: |coment_a expr_rec coment_c

|;

expr_rec: |expr_com

|expr_rec expr_com

expr_com: IDENT ;

|NUMERO ;

coment_a: COMENT_A

coment_c: COMENT_C

/************************* SIMBOLOS ****************************************/

par_a: PAR_A{if (band_s == 0) {strcpy(simb,$1); strcat(simb," "); band_s = 1;} else {if(strstr(simb,$1)
== NULL) {strcat(simb,$1); strcat(simb," ");}};}

par_c: PAR_C{if (band_s == 0) {strcpy(simb,$1); strcat(simb," "); band_s = 1;} else {if(strstr(simb,$1)
== NULL) {strcat(simb,$1); strcat(simb," ");}}; }

coma: COMA {if (band_s == 0) {strcpy(simb,$1); strcat(simb," "); band_s = 1;} else
{if(strstr(simb,$1) == NULL) {strcat(simb,$1); strcat(simb," ");}};}

llave_a: LLAVE_A {if (band_s == 0) {strcpy(simb,$1); strcat(simb," "); band_s = 1;} else
{if(strstr(simb,$1) == NULL) {strcat(simb,$1); strcat(simb," ");}}; }

llave_c: LLAVE_C {if (band_s == 0) {strcpy(simb,$1); strcat(simb," "); band_s = 1;} else

RIOS, SAGRERO, CRUZ Pgina 24 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

{if(strstr(simb,$1) == NULL) {strcat(simb,$1); strcat(simb," ");}}; }

dos_ptos: DOS_PTOS{if (band_s == 0) {strcpy(simb,$1); strcat(simb," "); band_s = 1;} else

{if(strstr(simb,$1) == NULL) {strcat(simb,$1); strcat(simb," ");}}; }

/********************* operaciones OPERACIONES *****************************/

operaciones: ident s_igual expr operador expr pto_coma

|comentarios

operador: s_mas

|s_menos

|s_por

|s_div

s_por: S_POR{if (band_opr == 0) {strcpy(opr,$1); strcat(opr," "); band_opr = 1;} else {if(strstr(opr,$1)
== NULL) {strcat(opr,$1); strcat(opr," ");}}; };

s_div: S_DIV{if (band_opr == 0) {strcpy(opr,$1); strcat(opr," "); band_opr = 1;} else {if(strstr(opr,$1)
== NULL) {strcat(opr,$1); strcat(opr," ");}}; };

s_mas: S_MAS{if (band_opr == 0) {strcpy(opr,$1); strcat(opr," "); band_opr = 1;} else

{if(strstr(opr,$1) == NULL) {strcat(opr,$1); strcat(opr," ");}}; };

s_menos: S_MENOS{if (band_opr == 0) {strcpy(opr,$1); strcat(opr," "); band_opr = 1;} else

{if(strstr(opr,$1) == NULL) {strcat(opr,$1); strcat(opr," ");}}; };

s_dmas: S_DMAS{if (band_opr == 0) {strcpy(opr,$1); strcat(opr," "); band_opr = 1;} else

{if(strstr(opr,$1) == NULL) {strcat(opr,$1); strcat(opr," ");}}; };

s_dmen: S_DMEN{if (band_opr == 0) {strcpy(opr,$1); strcat(opr," "); band_opr = 1;} else

{if(strstr(opr,$1) == NULL) {strcat(opr,$1); strcat(opr," ");}}; };

asigna : asignacion2

|asigna asignacion2

asignacion2 : ident s_igual expr pto_coma

/**********************************************************************/

%%

void yyerror(const char *s)

RIOS, SAGRERO, CRUZ Pgina 25 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

mostrar();

printf("\n \n ERROR: (%s)\n\n",yytext);

printf("\n \n EL CODIGO INGRESADO POSEE ERRORES DE SINTAXIS\n\n");

Ejemplos de instrucciones escritas por el usuario y sus salidas

Entradas y Salidas sin Errores

RIOS, SAGRERO, CRUZ Pgina 26 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

RIOS, SAGRERO, CRUZ Pgina 27 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

RIOS, SAGRERO, CRUZ Pgina 28 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

RIOS, SAGRERO, CRUZ Pgina 29 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

Entradas y Salidas con Errores

RIOS, SAGRERO, CRUZ Pgina 30 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

RIOS, SAGRERO, CRUZ Pgina 31 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

CONCLUSION

El presente informe fue realizado partiendo de un ejemplo prctico proporcionado por la ctedra,
este material junto con la bibliografa pertinente nos permiti tener una idea bsica de cmo
iniciar el proyecto.

Debido a que el trabajo realizado solo utiliza un conjunto reducido de expresiones regulares y
tokens, este analizador no permite el uso de la totalidad de la sintaxis del lenguaje de
programacin C. Sin embargo reconoce una gran cantidad de elementos y analiza si la porcin de
cdigo ingresada posee o no errores de sintaxis.

Lo ms difcil para nosotros fue tener en cuenta la recursividad ya que no siempre resulta como
uno espera y la correccin de errores es muy complicada porque las etiquetas estn muy
relacionadas unas con otras, es por eso que se intento hacerlo de la manera mas simple posible
para sea fcil de modificar o para encontrar y corregir errores mas rpidamente.

El alcance del analizador RSC podra ser ampliado si se realiza la definicin de nuevos lexemas
que permitan reconocer otros tokens y crear as expresiones regulares para reconocer las
estructuras faltantes como ser arreglos, registros, punteros, etc.

Finalmente es intencin de este grupo que el presente material sirva como referencia para futuros
alumnos de la ctedra de compiladores. Esperamos que el analizador aqu presentado pueda
continuar siendo desarrollado y profundizado, logrando as una herramienta mucho ms compleja
y eficiente.

RIOS, SAGRERO, CRUZ Pgina 32 de 33

Analizador RSC - Lenguaje C Trabajo Prctico Final - 2012

BIBLIOGRAFIA

[1] Apuntes de la Ctedra de Compiladores.

[2] Apuntes de la Ctedra de Lenguajes Formales.

[3] Kenneth C. Louden, Construccin de Compiladores, Thomsom, 2004.-

[4] Aho, Sethi, Ullman, Compiladores. Principios, tcnicas y herramientas, Addison-Wesley,

1990.-

[5] Curso bsico de programacin en C. Servicios Informaticos U.C.M.

RIOS, SAGRERO, CRUZ Pgina 33 de 33