FACULTAD DE INGENIERÍA

CARRERA DE INGENIERÍA DE SISTEMAS COMPUTACIONALES

TITULO :
GRAMÁ TICA DE LIBRE CONTEXTO Y COMPROBADOR DE
TIPOS
ALUMNOS :
N00134338@upn.pe - RODAS VEREAU, PIEER ALEXANDER
N00137131@upn.pe - ROJAS PLASENCIA, HAROLD HUGO
N00080537@upn.pe - FERNANDEZ GUEVARA, CESAR
ALEXANDER
N00164263@upn.pe - ZAVALETA SALDAÑ A, YASSET ZAIR
DOCENTE : Ing. Carlos Enrique Castillo Diestra

FECHA : 13 / Julio

TRUJILLO – PERÚ

2021

INDICE
Contenido
INDICE.............................................................................................................................................................1
INTRODUCCIÓN..............................................................................................................................................3
I. CONTENIDO.............................................................................................................................................4
A. Componentes léxicos (tokens) del lenguaje de programación..........................................................4
B. Descripción del lenguaje.....................................................................................................................6
C. Gramática de libre contexto del lenguaje..........................................................................................9
D. Comprobador de tipos......................................................................................................................13
II. CONCLUSIONES.....................................................................................................................................20
III. REFERENCIAS BIBLIOGRÁFICAS.........................................................................................................20
 INTRODUCCIÓN

El análisis sintáctico toma los tokens que le envía el analizador léxico y comprueba si con ellos se
puede formar alguna sentencia válida del lenguaje. Recuérdese que se entiende por sintaxis
como el conjunto de reglas formales que especifican como se construyen las sentencias de un
determinado lenguaje. La sintaxis de los lenguajes de programación habitualmente se describe
mediante gramáticas libres de contexto (o gramáticas tipo 2) utilizando algún tipo de notación. Por
ejemplo, las notaciones BNF y EBNF. Esta especificación ofrece numerosas ventajas a los
diseñadores de lenguajes y a los escritores de compiladores:

• Una gramática da una especificación sintáctica precisa, y fácil de comprender, de un lenguaje

de programación.

• Una gramática bien diseñada da una estructura al lenguaje de programación que se utiliza en la
traducción del programa fuente en código objeto correcto y para la detección de errores. Existen
herramientas que a partir de la descripción de la gramática se puede generar el código del
analizador sintáctico.

• Los lenguajes de programación después de un periodo de tiempo, adquieren nuevas

construcciones y llevan a cabo tareas adicionales. Estas nuevas construcciones se pueden añadir
más fácilmente al lenguaje cuando hay una implementación basada en una descripción
gramatical del lenguaje.

Habitualmente la estructura sintáctica de los lenguajes de programación se especifica

sintácticamente mediante gramáticas libres de contexto o de tipo 2.
I. CONTENIDO

A. Componentes léxicos (tokens) del lenguaje de programación

B. Descripción del lenguaje
Una gramática libre de contexto es una gramática que satisface ciertas propiedades. En
informática, las gramáticas describen idiomas; específicamente, describen lenguajes
formales.

Un lenguaje formal es simplemente un conjunto (término matemático para una colección

de objetos) de cadenas (secuencias de símbolos ... muy similar al uso de programación de
la palabra "cadena"). Un ejemplo simple de un lenguaje formal es el conjunto de todas las
cadenas binarias de longitud tres, {000, 001, 010, 011, 100, 101, 110, 111}.

Las gramáticas funcionan definiendo las transformaciones que puede realizar para
construir una cadena en el lenguaje descrito por una gramática. Las gramáticas dirán
cómo transformar un símbolo de inicio (generalmente S) en una cadena de símbolos. Una
gramática para el idioma dada anteriormente es:

S -> BBB

B -> 0

B -> 1

La forma de interpretar esto es decir que Spuede ser reemplazado por BBB, y Bpuede ser
reemplazado por 0, y Bpuede ser reemplazado por 1. Entonces, para construir la cadena
010 podemos hacerlo S -> BBB -> 0BB -> 01B -> 010.

Una gramática libre de contexto es simplemente una gramática donde lo que está
reemplazando (a la izquierda de la flecha) es un solo símbolo "no terminal". Un símbolo no
terminal es cualquier símbolo que usa en la gramática que no puede aparecer en sus
cadenas finales. En la gramática anterior, "S" y "B" son símbolos no terminales, y "0" y "1"
son símbolos "terminales". Gramáticas como

S -> AB

AB -> 1

A -> AA

B -> 0

No son regulares ya que contienen reglas como "AB -> 1".

EJEMPLO 1:

IOSTREAM

using namespace std void main(void)

char a;
boolean estado = false; int intentos = 0;
do
{
cout<<"Ingrese letra: "; cin<<a;
intentos++;
} while(a != h)
cout<<"¡Felicidades! te tomo<< intentos<<"!";
}

EJEMPLO 2:

IOSTREAN

using namespace std void main(void){

int a = 0; int b=4;

string nombre; cout<<"Ingresa tu nombre: "; cin>>nombre;

cout<<"La suma es "<<a+b<< "Gracias por participar"<< nombre;

EJEMPLO 3:

IOSTREAM

using namespace std void main(void)

int contador = 1; float total = 0.0; float nota, promedio;

while (contador <= 5)

cout<<" Dame la nota: "; cin >> nota;

total = total + nota; contador ++;

}

promedio = total / 5.0;

cout<<"El promedio es: "<< promedio;

EJEMPLO 4:

IOSTREAM

usig namespace std void main(void)

cout << "Ingrese la Opción a ejecutar: "; int opcion = 0;

cin >> opcion;

switch(opcion)

case 1: cout << "Usted ha seleccionado la opción 1"; break;

case 2: cout << "Usted ha seleccionado la opción 2"; break;

case 3: cout << "Usted ha seleccionado la opción 3"; break;

EJEMPLO 5:

IOSTREAM

using namespace std void main(void)

{ int a=0; int b=1:

int c=1;

while(c<100)

cout<<c; c=a+b; a=b; b=c;

}
C. Gramática de libre contexto del lenguaje
MiniCPP : Libreria EspacioDeNombre VOID MAIN'('VOID')''{'Cuerpo'}'
;

Libreria : IOSTREAM Libreria

| FSTREAM Libreria
| CMATH Libreria
| CSTRING Libreria
| /*vacio*/
;

EspacioDeNombre : USING NAMESPACE STD

;

Cuerpo : Variables Cuerpo

| Sentencias Cuerpo
| Sentencias
;

Variables : TipoVariable IDENT MasIdent';'

| VarConAsig';'
;

MasIdent : ','IDENT MasIdent

| /*vacio*/
;

VarConAsig : TipoVariable Asignacion MasAsig

;

MasAsig : ','Asignacion MasAsig

| /*vacio*/
;

TipoVariable : INT
| FLOAT
| CHAR
| STRING
;

Sentencias : Asignacion
| Leer
| Escribir
| Hacer
| Mientras
| Para
| Condicional
| Seleccion
;

Asignacion : IDENT '=' Expresion';'

| IDENT '=' CADENA';'
| IDENT '=' BOOLEAN';'
;

Leer : CIN'>''>'IDENT';'
;

Escribir : COUT '<''<'Contenido';'

;

Contenido : Expresion MasContenido

| CADENA MasContenido
;

MasContenido : '<''<'Contenido
| /*vacio*/
;
Hacer : DO'{'Sentencias'}'WHILE'('Condicion')'';'
;

Mientras : WHILE'('Condicion')''{'Sentencias'}'
;

Para : FOR'('IDENT'='INT';' Condicion';' Incrementos')''{'Sentencias'}'

;

Condicional : IF'('Condicion')''{'Sentencias'}'MasCondicional
;

MasCondicional : ELSE Condicional

| ELSE '{'Sentencias'}'
| /*vacio*/
;

Seleccion : SWITCH'('IDENT')''{'CASE Opcion':'Sentencias

BREAK';'MasSeleccion'}'
;

MasSeleccion : CASE Opcion':'Sentencias BREAK';'MasSeleccion

| /*vacio*/
;

Opcion : INT
| CHAR
| CADENA
;

Incrementos : INCREMENTO
| DECREMENTO
;

Condicion : Expresion OpRelacional Expresion

;

OpRelacional : '>'
| '<'
| MAYORIGUAL
| MENORIGUAL
| IGUALA
| NOIGUALA
;

Expresion : Expresion '+' Termino

| Expresion '-' Termino
| Termino
;

Termino : Termino '*' Factor

| Termino '/' Factor
| Termino '%' Factor
| Factor
;

Factor : INT
| FLOAT
| IDENT
| '('Expresion')'
;
%%
 D. Comprobador de tipos

Asignacion : IDENT '=' Expresion';' {IF($1.TIPO == $3.TIPO)

| IDENT '=' CADENA';' $$.TIPO = TVACIO
| IDENT '=' BOOLEAN';'; ELSE
$$.tipo = TERROR; }
Hacer : DO'{'Sentencias'}'WHILE'('Condicion')'';' {IF($7.TIPO == CTEBOOLEAN)
$$ $1 $2 $3 $4 $5 $6 $7 $8 $9 $$.TIPO = $3.TIPO
; ELSE
$$.tipo = TERROR; }

Mientras: WHILE'('Condicion')''{'Sentencias'}' {IF($3.TIPO == CTEBOOLEAN)

$$ $1 $2 $3 $4 $5 $6 $7 $$.TIPO = $3.TIPO
; ELSE
$$.TIPO == TERROR;

Para : FOR'('IDENT'='INT';' Condicion';' Incrementos')''{'Sentencias'}'

$$ $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13
;

{IF($7.tipo == CTEBOOLEAN && $9.TIPO = CTEINT)

$$.tipo = $12.tipo
ELSE
$$.tipo = TERROR; }

Condicional : IF'('Condicion')''{'Sentencias'}'MasCondicional
$$ $1 $2 $3 $4 $5 $6 $7 $8
| /*vacio*/
;

{IF($3.tipo == CTEBOOLEAN)
$$.tipo = $6.tipo
ELSE
$$.tipo = TERROR; }

Seleccion: SWITCH'('IDENT')''{'CASE Opcion':'Sentencias BREAK';'MasSeleccion'}'

$$ $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13
| /*vacio*/
;
{IF ($3.TIPO == VARINT || $3.TIPO == VARCHAR || $3.TIPO = VARSTRING &&
$7.TIPO == $3.TIPO)
$$.TIPO == $9.TIPO
ELSE
$$.TIPO == TERROR; }
Condicion : Expresion ESIGUALA Expresion
$$ $1 $2 $3

{IF($1.TIPO == CTEBOOLEAN || $1.TIPO == VARBOOLEAN &&

$3.TIPO == CTEBOOLEAN || $3.TIPO == VARBOOLEAN)
$$.TIPO == CTEBOOLEAN;
ELSE IF($1.TIPO == CTECHAR || $1.TIPO == VARCHAR &&
$3.TIPO == CTECHAR || $3.TIPO == VARCHAR)
$$.TIPO == CTEBOOLEAN;
ELSE IF($1.TIPO == CTEINT || $1.TIPO == VARINT ||
$1.TIPO == CTEFLOAT || $1.TIPO == VARFLOAT &&
$3.TIPO == CTEINT || $3.TIPO == VARINT ||
$3.TIPO == CTEFLOAT || $3.TIPO == VARFLOAT)
$$.TIPO == CTEBOOLEAN;
IF($$.TIPO == CTEBOOLEAN)
{$$.addr = $1.addr
code[ip]= OP_IGUAL
ip++;}
ELSE
{$$.TIPO = TERROR;
error("Tipos Incompatibles");}

| Expresion NOESIGUALA Expresion

$$ $1 $2 $3

{IF($1.TIPO == CTEBOOLEAN || $1.TIPO == VARBOOLEAN &&

$3.TIPO == CTEBOOLEAN || $3.TIPO == VARBOOLEAN)
$$.TIPO == CTEBOOLEAN;
ELSE IF($1.TIPO == CTECHAR || $1.TIPO == VARCHAR &&
$3.TIPO == CTECHAR || $3.TIPO == VARCHAR)
$$.TIPO == CTEBOOLEAN;
ELSE IF($1.TIPO == CTEINT || $1.TIPO == VARINT ||
$1.TIPO == CTEFLOAT || $1.TIPO == VARFLOAT &&
$3.TIPO == CTEINT || $3.TIPO == VARINT ||
$3.TIPO == CTEFLOAT || $3.TIPO == VARFLOAT)
$$.TIPO == CTEBOOLEAN;
IF($$.TIPO == CTEBOOLEAN)
{$$.addr = $1.addr
code[ip]= OP_NOESIGUAL
ip++;}
 ELSE
{$$.TIPO = TERROR;
error("Tipos Incompatibles");}

| Expresion MAYORIGUAL Expresion

$$ $1 $2 $3

IF($1.TIPO == CTEINT || $1.TIPO == VARINT ||

$1.TIPO == CTEFLOAT || $1.TIPO == VARFLOAT &&
$3.TIPO == CTEINT || $3.TIPO == VARINT ||
$3.TIPO == CTEFLOAT || $3.TIPO == VARFLOAT)
$$.TIPO == CTEBOOLEAN;
IF($$.TIPO == CTEBOOLEAN)
{$$.addr = $1.addr
code[ip]= OP_MAYORIGUAL
ip++;}
ELSE
{$$.TIPO = TERROR;
error("Tipos Incompatibles");}

| Expresion MENORIGUAL Expresion

$$ $1 $2 $3

IF($1.TIPO == CTEINT || $1.TIPO == VARINT || $1.TIPO == CTEFLOAT

|| $1.TIPO == VARFLOAT && $3.TIPO == CTEINT || $3.TIPO ==
VARINT || $3.TIPO == CTEFLOAT || $3.TIPO == VARFLOAT)
$$.TIPO == CTEBOOLEAN;
IF($$.TIPO == CTEBOOLEAN)
{$$.addr = $1.addr
code[ip]= OP_MENORIGUAL
ip++;}
ELSE
{$$.TIPO = TERROR;
error("Tipos Incompatibles");}

| Expresion '<' Expresion

$$ $1 $2 $3

IF($1.TIPO == CTEINT || $1.TIPO == VARINT || $1.TIPO == CTEFLOAT

|| $1.TIPO == VARFLOAT && $3.TIPO == CTEINT || $3.TIPO == VARINT
|| $3.TIPO == CTEFLOAT || $3.TIPO == VARFLOAT)
$$.TIPO == CTEBOOLEAN;
IF($$.TIPO == CTEBOOLEAN)
{$$.addr = $1.addr
 code[ip]= OP_MENOR
ip++;}
ELSE
{$$.TIPO = TERROR;
error("Tipos Incompatibles");}

| Expresion '>' Espresion

$$ $1 $2 $3

IF($1.TIPO == CTEINT || $1.TIPO == VARINT || $1.TIPO == CTEFLOAT

|| $1.TIPO == VARFLOAT && $3.TIPO == CTEINT || $3.TIPO == VARINT
|| $3.TIPO == CTEFLOAT || $3.TIPO == VARFLOAT)
$$.TIPO == CTEBOOLEAN;
IF($$.TIPO == CTEBOOLEAN)
{$$.addr = $1.addr
code[ip]= OP_MAYOR
ip++;}
ELSE
{$$.TIPO = TERROR;
error("Tipos Incompatibles");}

Expresion : Expresion '+' Termino

$$ $1 $2 $3

{IF($1.TIPO == CTEINT || $1.TIPO == VARINT && $3.TIPO == CTEINT

|| $3.TIPO == VARINT)
$$.TIPO == CTEINT;
ELSE($1.TIPO == CTEFLOAT || $1.TIPO == VARFLOAT &&
$3.TIPO == CTEFLOAT || $3.TIPO == VARFLOAT)
$$.TIPO == CTEFLOAT;
IF ($$.TIPO == CTEINT || $$.TIPO == CTEFLOAT)
{$$.addr = $1.addr
code[ip]= OP_SUMA
ip++;}
ELSE
{$$.TIPO = TERROR;
error("Tipos Incompatibles");}

| Expresion '-' Termino

$1 $2 $3
 {IF($1.TIPO == CTEINT || $1.TIPO == VARINT && $3.TIPO == CTEINT
|| $3.TIPO == VARINT)
$$.TIPO == CTEINT;
ELSE($1.TIPO == CTEFLOAT || $1.TIPO == VARFLOAT && $3.TIPO == CTEFLOAT ||
$3.TIPO == VARFLOAT)
$$.TIPO == CTEFLOAT;
IF ($$.TIPO == CTEINT || $$.TIPO == CTEFLOAT)
{$$.addr = $1.addr
code[ip]= OP_RESTA
ip++;}
ELSE
{$$.TIPO = TERROR;
error("Tipos Incompatibles");}

| Termino
;

Termino : Termino '*' Factor

$$ $1 $2 $3

{IF($1.TIPO == CTEINT || $1.TIPO == VARINT && $3.TIPO == CTEINT

|| $3.TIPO == VARINT)
$$.TIPO == CTEINT;
ELSE($1.TIPO == CTEFLOAT || $1.TIPO == VARFLOAT && $3.TIPO == CTEFLOAT ||
$3.TIPO == VARFLOAT)
$$.TIPO == CTEFLOAT; IF($$.TIPO ==
CTEINT || $$.TIPO == CTEFLOAT)
{$$.addr = $1.addr
code[ip]= OP_MULTIPLICAR
ip++;}
ELSE
{$$.TIPO = TERROR;
error("Tipos Incompatibles");}

| Termino '/' Factor

$$ $1 $2 $3

{IF($1.TIPO == CTEINT || $1.TIPO == VARINT && $3.TIPO == CTEINT

|| $3.TIPO == VARINT)
$$.TIPO == CTEINT;
ELSE($1.TIPO == CTEFLOAT || $1.TIPO == VARFLOAT && $3.TIPO == CTEFLOAT ||
$3.TIPO == VARFLOAT)
 $$.TIPO == CTEFLOAT; IF($$.TIPO ==
CTEINT || $$.TIPO == CTEFLOAT)
{$$.addr = $1.addr
code[ip]= OP_DIVIDIR
ip++;
ELSE
{$$.TIPO = TERROR;
error("Tipos Incompatibles");}

| Termino '%' Factor

$$ $1 $2 $3

{IF($1.TIPO == CTEINT || $1.TIPO == VARINT && $3.TIPO == CTEINT

|| $3.TIPO == VARINT)
$$.TIPO == CTEINT; IF
($$.TIPO == CTEINT)
{$$.addr = $1.addr
code[ip]= OP_MODULO
ip++;}
ELSE
{$$.TIPO = TERROR;
error("Tipos Incompatibles");}

| Factor
;

OP_ESIGUAL:
stack[SP-1] = stack[SP-1] = stack[SP]
SP = SP - 1
IP = IP + 1
OP_NOESIGUAL:
stack[SP-1] = stack[SP-1] != stack[SP]
SP = SP - 1
IP = IP + 1
OP_MAYORIGUAL:
stack[SP-1] = stack[SP-1] >= stack[SP]
SP = SP - 1
IP = IP + 1
OP_MENORIGUAL:
stack[SP-1] = stack[SP-1] <= stack[SP]
SP = SP - 1
IP = IP + 1
OP_MAYOR:
stack[SP-1] = stack[SP-1] > stack[SP]
SP = SP - 1
 IP = IP + 1
OP_MENOR:
stack[SP-1] = stack[SP-1] < stack[SP]
SP = SP - 1
IP = IP + 1
OP_SUMA:
stack[SP-1] = stack[SP-1] + stack[SP]
SP = SP - 1
IP = IP + 1
OP_RESTA:
stack[SP-1] = stack[SP-1] - stack[SP]
SP = SP - 1
IP = IP + 1
OP_MULTIPLICAR:
stack[SP-1] = stack[SP-1] * stack[SP]
SP = SP - 1
IP = IP + 1
OP_DIVIDIR:
stack[SP-1] = stack[SP-1] / stack[SP]
SP = SP - 1
IP = IP + 1
OP_MODULO:
stack[SP-1] = stack[SP-1] % stack[SP]
SP = SP - 1
IP = IP + 1
 II. CONCLUSIONES

 La gramática de libre contexto tuvo una influencia positiva por parte léxica y
sintáctica.
 Se demostró por parte de la categoría “Calidad de la gramática” todas las
reglas que se han diseñado de manera correcta.
 Se demostró por parte de la categoría “Amplitud de la gramática” todas las
características del lenguaje solicitado.
 Se demostró por parte de la categoría “Calidad del comprobador de tipos”
todas las comprobaciones correctamente construidas.
 Se demostró por parte de la categoría “Amplitud del comprobador de tipos”
todas las comprobaciones necesarias.

III. REFERENCIAS BIBLIOGRÁFICAS

Lenguajes Libres de Contexto—Más allá de los Autómatas Finitos. (s. f.). 21.

CÓRDOBA, U. D. (2010). Gramáticas de Contexto Libre. Retrieved from

http://www.uco.es/users/ma1fegan/2010-2011/talf/temas/tema-8/Tema-8-gramaticas-contexto-libre.pdf

Sells, Peters (1985) LECTURES ON CONTEMPORARY SYNTACTIC THEORIES. Center for the Study of Language
and Information, Universidad de Stantord.