Reporte de Actividades Unidad 2 Lenguajes y Automatas 2

TECNOLGICO NACIONAL DE MXICO
INSTITUTO TECNOLGICO DE ACAPULCO

Educacin Tecnolgica con Compromiso Social
Carrera:
Ingeniera en Sistemas Computacionales
Asignatura:
Lenguajes y Autmatas II
Reporte de actividades de aprendizaje y prcticas

Unidad 2. Generacin de cdigo intermedio
Competencia especfica a desarrollar
Disea las reglas para traducir el cdigo fuente a un cdigo intermedio
Profesor:
Integrantes del equipo:
Nombre
Nmero de control
ndice
Contenido
Introduccin..................................................................................................... 3
Actividad 1........................................................................................................ 4
Aplicar los tipos de notacion para la conversion de expresiones: infija, prefija y
postfija............................................................................................................. 4
Actividad 2...................................................................................................... 18
Representar expresiones mediante el codigo intermedio...................................18
Actividad 3...................................................................................................... 26
Reconocer el manejo de tipos en las expresiones y el uso de operadores..........26
Actividad 4...................................................................................................... 49
Desarrollar las acciones que representen la estrucutra de un lenguaje de
programacion de alto nivel en un codigo intermedio.........................................49
Actividad 5...................................................................................................... 71
Aplicar las acciones construidas a la gramatica del lenguaje prototipo..............71
Actividad 6. ................................................................................................. 84
Integrar equipos de trabajo para la generacion de un codigo intermedio..........84
Actividad 7. ............................................................................................... 117
Avance del proyecto final.............................................................................117
Conclusin................................................................................................... 129
Bibliografa................................................................................................. 130
Introduccin
En la construccin de un compilador varios tipos de anlisis juegan un papel
bastante importante en esta unidad y en siguientes prcticas abordaremos un
anlisis conocido como anlisis semntico es de suma importancia conocer su

funcionamiento ya que gracias a l el compilador puede realizar su trabajo
correctamente. El anlisis semntico tiene como objetivo valga la redundancia
analizar el significado de las expresiones que introducimos para saber si han
determinado momento se ha cometido un error. Tiene un trabajo relacionado con
el anlisis sintctico y lxico ya que trabajan en conjunto para poder tener un buen
desarrollo a la hora de realizar nuestros programas. Se abordarn aspectos como
la deteccin de errores y cmo manejarlos, temas de suma importancia para lo
que queremos realizar en un futuro en esta clase.
Actividad 1. Aplicar los tipos de notacin para la conversin de expresiones:

infija, fija, postfija
Consideremos la suma de A y B. Sabemos que tenemos que aplicar el operador

aritmtico + a los operandos A y B. Esta expresin aritmtica se puede escribir de
tres formas:
A+B, notacin infija. Esta es la forma ms comn para representar la

operacin, en donde el operador aritmtico est entre los operandos.
+AB, notacin prefija. El operador aritmtico precede a los operandos.
AB+, notacin posfija. El operador aritmtico sucede a los operandos.
En el caso de la notacin infija, si slo hay un operador involucrado no existe

mayor problema, pero si en la expresin aritmtica hay ms de uno, se necesita
saber cul de los operadores tiene precedencia sobre los dems. Por ejemplo, en
la expresin A+B*C, el operador * tiene precedencia sobre el operador +. Si no
se define la precedencia de los operadores, las expresiones seran ambiguas.
La ventaja de las notaciones prefija y posfija es que no dan pie a ambigedades.

Retomemos el ejemplo anterior. Si consideramos la expresin A+B*C, su notacin
prefija es +*BCA, pero si consideramos (A+B)*C, en prefijo sera *+ABC. En el
caso de la notacin posfija, las expresiones anteriores se escriben como ABC*+ y
AB+C*.
Programa 1 utilizado:
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
namespace infijaposfijanuevo
{
static class Program
{
public static void Main(string[] args)
{
//string cadena = "(1+17)*2";
Console.WriteLine("Ingresa la cadena a cambiar:");

string algo = Console.ReadLine();
Console.WriteLine(algo.PasarStringPosfijo());
Console.Read();
}
}
public static class resolver
{
public static string PasarStringPosfijo(this string stringeninfijo)
{
int tamanio = stringeninfijo.Length;
Stack<char> pila = new Stack<char>();
StringBuilder stringenposfijo = new StringBuilder();
for (int i = 0; i < tamanio; i++)
{
if ((stringeninfijo[i] >= '0') && (stringeninfijo[i] <= '9'))
{
stringenposfijo.Append(stringeninfijo[i]);
}
else if (stringeninfijo[i] == '(')
{
pila.Push(stringeninfijo[i]);
}
else if ((stringeninfijo[i] == '*') || (stringeninfijo[i] == '+') || (stringeninfijo[i] == '-') ||
(stringeninfijo[i] == '/'))
{
while ((pila.Count > 0) && (pila.Peek() != '('))
{
if (precedenciadeoperadores(pila.Peek(), stringeninfijo[i]))
{
stringenposfijo.Append(pila.Pop());
}
else
{
break;
}
}
}
else if (stringeninfijo[i] == ')')
{
5

{
}
if (pila.Count > 0)
pila.Pop(); //quita el parentesis izquierdo de la pila
}
}
while (pila.Count > 0)
{
}
return stringenposfijo.ToString();
}
public static bool precedenciadeoperadores(char top, char p_2)
{
if (top == '+' && p_2 == '*') // + tiene menor precedencia que *
return false;
if (top == '*' && p_2 == '-') // * tiene mayor precedencia que return true;
if (top == '+' && p_2 == '-') // + tiene la misma precedencia que +
return true;
return true;
}
public static int EvaluarRes(string posfija)
{
Stack<int> pilaResultado = new Stack<int>();
int tama = posfija.Length;
for (int i = 0; i < tama; i++)
{
if ((posfija[i] == '*') || (posfija[i] == '+') || (posfija[i] == '-') || (posfija[i] == ' '))
{
int resz = DimeOperador(pilaResultado.Pop(), pilaResultado.Pop(), posfija[i]);
pilaResultado.Push(resz);
}
else if ((posfija[i] >= '0') || (posfija[i] <= '9'))
{
pilaResultado.Push((int)(posfija[i] - '0'));
}
}
return pilaResultado.Pop();
6
}
public static int DimeOperador(int p, int p_2, char p_3)
{
switch (p_3)
{
case '+':
return p_2 + p;
case '-':
return p_2 - p;
case '*':
return p_2 * p;
case '/':
return p_2 / p;
default:
return -1;
}
}
}
}
Ejemplo 1:
using System;
using System.Text;
{

{
{
Console.Read();
}
}
{
{
{
{
}
{
}
else if ((stringeninfijo[i] == '*') || (stringeninfijo[i] == '+') || (stringeninfijo[i]
== '-') || (stringeninfijo[i] == '/'))
{
{
{
}
else
{
break;
}
}
}
{
{
}
if (pila.Count > 0)
9

}
}
{
}
}
{
return false;
return true;
return true;
}
{
{
10

{
int resz = DimeOperador(pilaResultado.Pop(), pilaResultado.Pop(),
posfija[i]);
}
{
}
}
}
{
switch (p_3)
{
case '+':
return p_2 + p;
case '-':
return p_2 - p;
case '*':
return p_2 * p;
case '/':
return p_2 / p;
default:
11
return -1;
}
}
}
}
Ejemplo 2:
using System;
using System.Text;
{
{
{
12

Console.Read();
}
}
{
{
{
{
}
{
}
else if ((stringeninfijo[i] == '*') || (stringeninfijo[i] == '+') || (stringeninfijo[i]
== '-') || (stringeninfijo[i] == '/'))
13
{
{
{
}
else
{
break;
}
}
}
{
{
}
if (pila.Count > 0)
}
}
14
{
}
}
{
return false;
return true;
return true;
}
{
{
{
int resz = DimeOperador(pilaResultado.Pop(), pilaResultado.Pop(),
posfija[i]);
15
}
{
}
}
}
{
switch (p_3)
{
case '+':
return p_2 + p;
case '-':
return p_2 - p;
case '*':
return p_2 * p;
case '/':
return p_2 / p;
default:
return -1;
}
}
}
16
Ejemplo 3:
Actividad 2. Representar expresiones mediante el cdigo intermedio

Despus de los anlisis sintcticos y semnticos, algunos compiladores generan
una representacin intermedia explicita del programa fuente. Se puede considerar
esta representacin intermedia como un programa para una maquina abstracta.
Esta representacin intermedia debe tener dos propiedades importantes, debe ser
fcil de producir y fcil de traducir al programa objeto.
17
a) El cdigo intermedi es particularmente utilizado cuando el objetivo de

compilador es producir cdigo muy eficiente, ya que para hacerlo as se
requiere una cantidad importante del anlisis de las propiedades del cdigo
objetivo, y esto se facilita mediante el uso del cdigo intermedio.
b) El cdigo intermedio tambin puede ser til al hacer que un compilador sea
ms fcilmente re dirigible: si el cdigo intermedio es hasta cierto punto
independiente de la maquina objetivo, entonces genera cdigo para una
maquina objetivo diferente solo requiere volver a escribir el traductor de
cdigo intermedio a cdigo objetivo, y por lo regular esto es ms fcil que
volver a escribir todo un generador de cdigo.
c) La representacin intermedia puede tener diversas formas, se trata una
forma intermedia llamada "CDIGO DE TRES DIRRECCIONES" y el
"CDIGO P"
Primer programa:
using System;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace actividad2
{
class Program
{
static void Main(string[] args)
{
char[] letra = {'a','b','c','d','e','f','g','h','i','j','k',
'l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
18
'P','Q','R','S','T','U','V','W','X','Y','Z'};
String cadena;
int tamcad, tamlet, m = 0;
char[] Tabla = new char[15];
tamlet = letra.Length;
Console.Write("\nIngresa una expresion: ");

cadena = Console.ReadLine();
tamcad = cadena.Length;//Devuelve el tamao de la cadena
char[] destino = new char[tamcad];
cadena.CopyTo(0, destino, 0, tamcad);//Copia la cadena y la almacena en
un arreglo
for (int i = 0; i < tamcad; i++)

{
for (int j = 0; j < tamlet; j++)
{
if(destino[i] == letra[j])
{
Tabla[m] = destino[i];
m = m + 1;
}
}
}
Console.WriteLine("\n Tabla de Simbolos\n");

19
Console.WriteLine(" _____________");
for(int k= 0; k < m; k++)
{
Console.WriteLine(" | <id,{0}>: {1} |", k, Tabla[k]);
}
Console.ReadLine();
}
}
}
Ejemplo 1:
Segundo Programa utilizado:

using System;
using System.Linq;
using System.Text;
20
{
class Program
{
{
char[] numero = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
String cadena;
int tamcad, tamnum, m = 0;
tamnum = numero.Length;

un arreglo

{
for (int j = 0; j < tamnum; j++)
{
if (destino[i] == numero[j])
{
21
m = m + 1;
}
}
}

for (int k = 0; k < m; k++)
{
}
Console.ReadLine();
}
}
}
Ejemplo 2:
22
Tercer Programa utilizado:

using System;
using System.Linq;
using System.Text;
{
class Program
{
{
char[] Oparit = { '+', '-', '*', '/', '=' };
String cadena;
int tamcad, tamOparit, m = 0;
tamOparit = Oparit.Length;

un arreglo
23

{
for (int j = 0; j < tamOparit; j++)
{
if (destino[i] == Oparit[j])
{
m = m + 1;
}
}
}

for (int k = 0; k < m; k++)
{
}
Console.ReadLine();
}
}
}
24
Ejemplo 3:
Actividad 3. Reconocer el manejo de tipos en las expresiones y el uso de

operadores
Una expresin es una combinacin de operadores y operandos de cuya
evaluacin se obtiene un valor. Los operandos pueden ser nombres que denoten
objetos variables o constantes, funciones, literales de cualquier tipo adecuado de
acuerdo con los operadores u otras expresiones ms simples. La evaluacin de
una expresin da lugar a un valor de algn tipo, una expresin se dice que es del
tipo de su resultado. Ejemplos de expresiones:
a + 5*b
(a >= 0) and ((b+5) > 10)
25
a
-a * 2 + b
-b + sqrt(b**2 - 4*a*c)
length(s) > 0
Las expresiones se evalan de acuerdo con la precedencia de los operadores.
Ante una secuencia de operadores de igual precedencia, la evaluacin se realiza
segn el orden de escritura, de izquierda a derecha. El orden de evaluacin puede
modificarse usando parntesis.
Operadores Principales:
Estos son los operadores de precedencia ms alta. Tenga en cuenta que puede
hacer clic en los operadores para ir a las pginas de detalles con ejemplos.
x.y: acceso a miembros.
x?.y: acceso a miembros condicional null. Devuelve null si el operando izquierdo
es null.
f(x): invocacin de funcin.
a[x]: indizacin de objeto agregado.
a?[x]: indizacin condicional null. Devuelve null si el operando izquierdo es null.
x++: incremento de postfijo. Devuelve el valor de x y, a continuacin, actualiza la
ubicacin de almacenamiento con el valor de x que es uno mayor (normalmente
agrega el entero 1).
x--: decremento de postfijo. Devuelve el valor de x; a continuacin, actualiza la
ubicacin de almacenamiento con el valor de x que es uno menos (normalmente
resta el entero 1).
New: creacin de instancias de tipo.
Typeof: devuelve el objeto System.Type que representa el operando.
Checked: habilita la comprobacin de desbordamiento para operaciones con
enteros.
Unchecked: deshabilita la comprobacin de desbordamiento para operaciones con
enteros. Este es el comportamiento predeterminado del compilador.
26
default(T): devuelve el valor inicializado predeterminado de tipo T, null para tipos

de referencia, cero para tipos numricos y cero o null en miembros para tipos de
struct.
Delegate: declara y devuelve una instancia de delegado.
Sizeof: devuelve el tamao en bytes del operando de tipo.
->: desreferenciacin del puntero combinada con acceso a miembros.
Operadores unarios
Estos operadores tienen mayor precedencia que los de la seccin siguiente y
menor que los de la anterior. Tenga en cuenta que puede hacer clic en los
operadores para ir a las pginas de detalles con ejemplos.
+x: devuelve el valor de x.
-x: negacin numrica.
!x: negacin lgica.
~x: complemento bit a bit.
++x: incremento de prefijo. Devuelve el valor de x despus de actualizar la
ubicacin de almacenamiento con el valor de x que es uno mayor (normalmente
agrega el entero 1).
--x: decremento de prefijo. Devuelve el valor de x despus de actualizar la
ubicacin de almacenamiento con el valor de x que es uno menos (normalmente
resta el entero 1).
(T)x: conversin de tipos.
Await: espera una Task.
&x: direccin de.
*x: desreferenciacin.
Operadores multiplicativos
x * y: multiplicacin.
27
x / y: divisin. Si los operandos son enteros, el resultado es un entero que se

trunca hacia cero (por ejemplo, -7 / 2 is -3).
x % y: mdulo. Si los operandos son enteros, devuelve el resto de dividir x entre
y. Si q = x / y y r = x % y, entonces x = q * y + r.
Operadores aditivos
x + y: suma.
x y: resta.
Operadores de desplazamiento
x << y: desplaza los bits a la izquierda y rellena con cero a la derecha.
x >> y: desplaza los bits a la derecha. Si el operando izquierdo es int o long, los
bits de la izquierda se rellenan con el bit de signo. Si el operando izquierdo es
uint o ulong, los bits de la izquierda se rellenan con cero.
Operadores de comprobacin de tipos y relacionales
x < y: menor que (true si x es menor que y).
x > y: mayor que (true si x es mayor que y).
x <= y: menor o igual que.
x >= y: menor o igual que.
Is: compatibilidad de tipos. Devuelve true si el operando izquierdo evaluado se
puede convertir al tipo especificado en el operando derecho (un tipo esttico).
28
As: conversin de tipos. Devuelve el operando izquierdo convertido al tipo

especificado por el operando derecho (un tipo esttico), pero as devuelve null
donde (T)x producira una excepcin.
Operadores de igualdad
x == y: igualdad. De forma predeterminada, para los tipos de referencia distintos
de string, devuelve igualdad de referencia (prueba de identidad). Sin embargo,
los tipos pueden sobrecargar ==, por lo que si su intencin es probar la identidad,
es mejor usar el mtodo ReferenceEquals en object.
x != y: distinto de. Vea el comentario de ==. Si un tipo sobrecarga ==, debe
sobrecargar !=.
Operador lgico AND
Este operador tiene mayor precedencia que el de la seccin siguiente y menor que
los de la anterior. Tenga en cuenta que puede hacer clic en el operador para ir a la
pgina de detalles con ejemplos.
x & y: AND lgico o bit a bit. El uso con tipos enteros y tipos enum suele estar
permitido.
Operador lgico XOR
el de la anterior. Tenga en cuenta que puede hacer clic en el operador para ir a la
x ^ y: XOR lgico o bit a bit. Por lo general puede usarlo con tipos enteros y tipos
enum.
Operador lgico OR
x | y: OR lgico o bit a bit. El uso con tipos enteros y tipos enum suele estar
permitido.
Operador condicional AND
29
x && y: AND lgico. Si el primer operando es false, C# no evala el segundo
operando.
Operador condicional OR
x || y: OR lgico. Si el primer operando es true, C# no evala el segundo
operando.
Operador de uso combinado de null
x ?? y: devuelve x si no es null; de lo contrario, devuelve y.
Operador condicional
t ? x : y: si la prueba t es true, evala y devuelve x; en caso contrario, evala y
devuelve y.
Operadores de asignacin y Lambda
menor que el de la anterior. Tenga en cuenta que puede hacer clic en los
x = y: asignacin.
x += y: incremento. Agregue el valor de y al valor de x, almacene el resultado en x
y devuelva el nuevo valor. Si x designa un event, y debe ser una funcin
adecuada que C# agregue como un controlador de eventos.
30
x -= y: decremento. Reste el valor de y del valor de x, almacene el resultado en x

y devuelva el nuevo valor. Si x designa un event, y debe ser una funcin
adecuada que C# quite como un controlador de eventos.
x *= y: asignacin y multiplicacin. Multiplique el valor de y por el valor de x,
almacene el resultado en x y devuelva el nuevo valor.
x /= y: asignacin y divisin. Divida el valor de x por el valor de y, almacene el
resultado en x y devuelva el nuevo valor.
x %= y: asignacin y mdulo. Divida el valor de x por el valor de y, almacene el
resto en x y devuelva el nuevo valor.
x &= y: asignacin y AND. AND el valor de y con el valor de x, almacene el
x |= y: asignacin y OR. OR el valor de y con el valor de x, almacene el resultado
en x y devuelva el nuevo valor.
x ^= y: asignacin y XOR. XOR el valor de y con el valor de x, almacene el
x <<= y: asignacin y desplazamiento a la izquierda. Desplace el valor de x a la
izquierda y lugares, almacene el resultado en x y devuelva el nuevo valor.
x >>= y: asignacin y desplazamiento a la derecha. Desplace el valor de x a la
derecha y posiciones, almacene el resultado en x y devuelva el nuevo valor.
=>: declaracin lambda
Programa 1 utilizado
using System;
using System.Linq;
using System.Text;
namespace Analizador
31
{
class Program
{
{
//a32e23
String cadena, Dato;
int tamcad, tamlet, tamnum, tamOparit, tamOpeRe, tamOpeLog, m = 1,
Opcion;
float a = 5, b = 10, c = 15;
float Resultado = 0;
'P','Q','R','S','T','U','V','W','X','Y','Z'};
char[] numero = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
char[] Oparit = { '+', '-', '*', '/', '=' };
char[] OpeRe = { '<', '>', '!' };
char[] OpeLog = { '&', '|', '~' };
//Devuelve el tamao de la cadena
tamOpeRe = OpeRe.Length;
tamOpeLog = OpeLog.Length;
Console.WriteLine("Que desea utilizar?");
Console.WriteLine("\n[1]Analizador Lexico");
Console.WriteLine("\n[2]Analizador Sintactico");
Console.Write("\nTu Opcion: ");
Dato = Console.ReadLine();
Opcion = Convert.ToInt32(Dato);
switch (Opcion)
{
case 1:
Console.WriteLine("\n\nAnalizador Lexico");
char[] destino = new char[tamcad + 5];
32
cadena.CopyTo(0, destino, 0, tamcad);//Copia la cadena y la

almacena en un arreglo
Console.WriteLine("\n
Tabla de Simbolos");
Console.WriteLine("___________________________________");
//Palabras reservadas
{
{
if (destino[i] == letra[j])
{
if (destino[i] == 'i' || destino[i] == 'f' || destino[i] == 'd' || destino[i]
== 'w' || destino[i] == 'c' || destino[i] == 'e' || destino[i] == 's')
{
if (destino[i] == 'i')
{
if (destino[i] == 'i' && destino[i + 1] == 'f')
{
Console.WriteLine("\n| {0}{1} | palabra reservada
|", destino[i], destino[i + 1]);
i = i + 1;
break;
}
else Console.WriteLine("\n| {0}
| una letra
|",
destino[i]);
}
if (destino[i] == 'f')
{
if (destino[i] == 'f' && destino[i + 1] == 'o' && destino[i + 2]
== 'r')
{
Console.WriteLine("\n| {0}{1}{2}
|", destino[i], destino[i + 1], destino[i + 2]);
i = i + 2;
break;
}
destino[i]);
}
if (destino[i] == 'd')
{
33
| palabra reservada
| una letra
|",
if (destino[i] == 'd' && destino[i + 1] == 'o')

{
i = i + 1;
break;
}
| una letra
|",
destino[i]);
}
if (destino[i] == 'w')
{
if (destino[i] == 'w' && destino[i + 1] == 'h' && destino[i +
2] == 'i' && destino[i + 3] == 'l' && destino[i + 4] == 'e')
{
Console.WriteLine("\n| {0}{1}{2}{3}{4} | palabra
reservada
|", destino[i], destino[i + 1], destino[i + 2], destino[i + 3], destino[i +
4]);
i = i + 4;
break;
}
| una letra
|",
destino[i]);
}
if (destino[i] == 'c')
{
if (destino[i] == 'c' && destino[i + 1] == 'a' && destino[i + 2]
== 's' && destino[i + 3] == 'e')
{
Console.WriteLine("\n| {0}{1}{2}{3} | palabra reservada
|", destino[i], destino[i + 1], destino[i + 2], destino[i + 3]);
i = i + 3;
break;
}
destino[i]);
}
if (destino[i] == 's')
34
| una letra
|",
{
if (destino[i] == 's' && destino[i + 1] == 'w' && destino[i +
2] == 'i' && destino[i + 3] == 't' && destino[i + 4] == 'c' && destino[i + 5] == 'h')
{
Console.WriteLine("\n| {0}{1}{2}{3}{4}{5} | palabra
reservada
|", destino[i], destino[i + 1], destino[i + 2], destino[i + 3], destino[i + 4],
destino[i + 5]);
i = i + 5;
break;
}
| una letra
|",
destino[i]);
}
if (destino[i] == 'e')
{
if (destino[i] == 'e' && destino[i + 1] == 'l' && destino[i + 2]
== 's' && destino[i + 3] == 'e')
{
i = i + 4;
break;
}
| una letra
|",
destino[i]);
}
}
| una letra
|",
destino[i]);
}
}
//Nmeros
{
{
Console.WriteLine("\n| {0}
destino[i]);
}
}
35
| un numero
|",
//Operadores aritmticos
{
{
| un operador aritmetico |",
destino[i]);
}
}
//Operadores lgicos
for (int j = 0; j < tamOpeLog; j++)
{
if (destino[i] == OpeLog[j])
{
| un operador logico |",
destino[i]);
}
}
//Operadores relacionales
for (int j = 0; j < tamOpeRe; j++)
{
if (destino[i] == OpeRe[j])
{
if (destino[i + 1] == '=' && destino[i + 2] != OpeRe[j])
{
Console.WriteLine("\n| {0}{1} | un operador relacional |",
destino[i], destino[i + 1]);
i = i + 1;
}
else
{
| un operador relacional |",
destino[i]);
}
}
}
}
break;
36
Muestra el reconocimiento de dos operadores aritmeticos

using System;
using System.Linq;
using System.Text;
{
class Program
{
{
//a32e23
Opcion;
float a = 5, b = 10, c = 15;
'P','Q','R','S','T','U','V','W','X','Y','Z'};
char[] numero = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
char[] Oparit = { '+', '-', '*', '/', '=' };
37
char[] OpeRe = { '<', '>', '!' };

char[] OpeLog = { '&', '|', '~' };
switch (Opcion)
{
case 1:
{
{
{
{
{
{
38
Console.WriteLine("\n| {0}{1}
| palabra reservada

i = i + 1;
break;
}
| una letra
|",
destino[i]);
}
{
== 'r')
{
i = i + 2;
break;
}
| palabra reservada
| una letra
|",
destino[i]);
}
{
{
i = i + 1;
break;
}
| una letra
|",
destino[i]);
}
{
{
39
reservada
4]);

i = i + 4;
break;
}
| una letra
|",
destino[i]);
}
{
== 's' && destino[i + 3] == 'e')
{
i = i + 3;
break;
}
| una letra
|",
destino[i]);
}
{
{
reservada
destino[i + 5]);
i = i + 5;
break;
}
destino[i]);
}
{
40
| una letra
|",

== 's' && destino[i + 3] == 'e')
{
i = i + 4;
break;
}
| una letra
|",
destino[i]);
}
}
| una letra
|",
destino[i]);
}
}
//Nmeros
{
{
| un numero
|",
destino[i]);
}
}
{
{
destino[i]);
}
}
//Operadores lgicos
{
{
destino[i]);
}
41
}
{
{
{
i = i + 1;
}
else
{
destino[i]);
}
}
}
}
break;
Muestra el reconocimiento de un operador relacional y un operador lgico

using System;
using System.Linq;
using System.Text;
42
{
class Program
{
{
//a32e23
Opcion;
float a = 5, b = 10, c = 15;
'P','Q','R','S','T','U','V','W','X','Y','Z'};
char[] numero = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
char[] Oparit = { '+', '-', '*', '/', '=' };
char[] OpeRe = { '<', '>', '!' };
char[] OpeLog = { '&', '|', '~' };
switch (Opcion)
{
case 1:
43
{
{
{
{
{
{
i = i + 1;
break;
}
| una letra
|",
destino[i]);
}
{
== 'r')
{
i = i + 2;
break;
}
destino[i]);
}
44
| palabra reservada
| una letra
|",
{
{
i = i + 1;
break;
}
| una letra
|",
destino[i]);
}
{
{
reservada
4]);
i = i + 4;
break;
}
| una letra
|",
destino[i]);
}
{
== 's' && destino[i + 3] == 'e')
{
i = i + 3;
break;
}
destino[i]);
45
| una letra
|",
}
{
{
reservada
destino[i + 5]);
i = i + 5;
break;
}
| una letra
|",
destino[i]);
}
{
== 's' && destino[i + 3] == 'e')
{
i = i + 4;
break;
}
| una letra
|",
destino[i]);
}
}
destino[i]);
}
}
//Nmeros
{
{
46
| una letra
|",
| un numero
|",
destino[i]);
}
}
{
{
destino[i]);
}
}
//Operadores lgicos
{
{
destino[i]);
}
}
{
{
{
i = i + 1;
}
else
{
destino[i]);
}
}
}
}
47
break;
Muestra el reconocimiento de tres operadores de diferente categoria
Actividad 4. Desarrollar las acciones que representen la estructura de un

lenguaje de programacin de alto nivel en un cdigo intermedio
Desarrollar las acciones que representen la estructura de un lenguaje de programacin de
alto nivel en un cdigo intermedio.
48
LENGUAJE INTERMEDIO
Un lenguaje intermedio se puede definir como una manera de representar procedimientos
y estructuras de datos que sirva como entrada para una MV en alguna parte de su
jerarqua, entre el lenguaje de entrada (el nivel ms alto) y el cdigo ejecutado en la
mquina (el nivel ms bajo) - tanto en el tiempo de compilacin como en el de ejecucin.
Para considerar el papel de los lenguajes intermedios y sus ventajas y desventajas,
conviene destacar la diferencia entre la traduccin de un lenguaje de alto nivel a cdigo
mquina anteriormente a su ejecucin (su compilacin) y su interpretacin, es decir, la
conversin decada instruccin del lenguaje a cdigo mquina y su ejecucin, una por una,
al ejecutar el programa. Este proceso se realiza a travs de una MV de interpretacin que
simula un ordenador cuyo cdigo mquina es el lenguaje de alto nivel que est siendo
interpretado. Y tpicamente, esta MV se construye a travs de un conjunto de programas
de cdigo mquina que representa los algoritmos y estructuras de datos necesarios para
la ejecucin de las instrucciones del lenguaje de alto nivel. Hay ventajas y desventajas en
cada manera de convertir los lenguajes de alto nivel a cdigo mquina, que se pueden
resumir as:
Compilacin
1. No hay que repetir la conversin de la misma instruccin a cdigo mquina cada vez
que aparece. Ventajas
2. Los programas corren muy rpido. Desventajas 1. Prdida de claridad e informacin
sobre el programa.
3. Dificultad en localizar la fuente exacta de error.
Ejemplos: Ada, C, C++, FORTRAN, Pascal Interpretacin
1. No hay prdida de claridad ni de informacin sobre un programa ni sobre donde estn
los errores.
2. No hay que decodificar cdigo que no se va a ejecutar.Ventajas3. El cdigo es
tpicamente ms compacto.
Desventajas
1. Los programas corren mucho ms lentamente se paga el coste de decodificar cada
instruccin. Ejemplos: HTML, Lisp, ML, Perl, Postscript, Prolog, Smalltalk
Estos dos casos representan los dos extremos porque, como ya se ha visto, existe
tambin lo que se llama la compilacin parcial, que es una mezcla de los dos enfoques,
donde se compila el lenguaje de alto nivel a un lenguaje intermedio (ms cerca de las
estructuras presentes en el cdigo mquina que las del cdigo fuente) y luego se
interpreta este lenguaje al ejecutar el programa. Como puede imaginarse, esta tcnica
49
combina las ventajas y desventajas de los dos enfoques anteriores. Un ejemplo de esta
combinacin existe en el lenguaje de programacin Java y su entorno. Entre otras cosas,
Java empez con la idea de liberar al programador de las dificultades deportar su
aplicacin a nuevas plataformas lo cual, si el programa est muy vinculado a algn
aspecto del sistema operativo donde fue escrito, podra ser muy difcil. Se compilar el
cdigo fuente de Java a un cdigo byte (bytecode) antes de ejecutarlo. Y a la hora de
correr el programa, este cdigo, como lenguaje intermedio, sera el lenguaje de entrada
para una MV, que con un conjunto de libreras (el entorno de ejecucin de Java, Java
Runtime o JRE), la interpretara para su ejecucin. Por lo tanto, este bytecode podra
correr en cualquier hardware donde haya una versin del JRE disponible. Como este
bytecode est ms cerca del nivel de mquina que de un lenguaje de alto nivel, los
programas corrern ms rpidamente
la naturaleza de C como una abstraccin del lenguaje ensamblador y su uso como
lenguaje de sistema en Unix-like y otros sistemas operativos lo han convertido en un
lenguaje intermedio popular: Eiffel, Sather, Esterel, algunos dialectos de Lisp (Lush,
Gambit, Haskell, Glasgow Haskell Compiler), Squeak, Cython, Seed7, Vala y otros usan C
como un lenguaje intermedio. Variantes de C han sido diseadas para proveer a C de
caractersticas como un lenguaje ensamblador portable, incluyendo C-- o el lenguaje
intermedio de C.
El Common Intermediate Language de Microsoft es un lenguaje intermedio diseado para

ser compartido por todos los compiladores del .NET Framework antes de ser generado el
cdigo mquina.
El GNU Compiler Collection (GCC) usa varios lenguajes intermedios internamente para
simplificar la portabilidad. Entre esos lenguajes estn:
El histrico Register transfer language (RTL)
El lenguaje de rbol GENERIC
El basado en SSA, GIMPLE
Mientras la mayora de lenguajes son diseados para soportar lenguajes escritos
estticamente, la representacin intermedia de Parrot est diseada para soportar
lenguajes escritos dinmicamente (inicialmente Perl y Python).
LENGUAJES DE ALTO NIVEL:
50
Estos lenguajes son los mas utilizado por los programadores. Estn diseados para que
las personas escriban y entiendan los programas de un modo mucho mas fcil que los
lenguajes mquina y ensamblador. Un programa escrito en lenguaje de alto nivel es
independiente de la mquina (las instrucciones no dependen del diseo del hardware o de
una computadora en particular), por lo que estos programas son portables o
transportables. Los programas escritos en lenguaje de alto nivel pueden ser ejecutados
con poca o ninguna modificacin en diferentes tipos de computadoras. Son lenguajes de
programacin en los que las instrucciones enviadas para que el ordenador ejecute ciertas
rdenes son similares al lenguaje humano. Dado que el ordenador no es capaz de
reconocer estas ordenes, es necesario el uso de un intrprete que traduzca el lenguaje de
alto nivel a un lenguaje de bajo nivel que el sistema pueda entender.
Por lo general se piensa que los ordenadores son mquinas que realizan tareas de
clculos o procesamiento de texto. La descripcin anterior es slo una forma muy
esquemtica de ver una computadora. Hay un alto nivel de abstraccin entre lo que se
pide a la computadora y lo que realmente comprende. Existe tambin una relacin
compleja entre los lenguajes de alto nivel y el cdigo mquina.
Los lenguajes de alto nivel son normalmente fciles de aprender porque estn formados
por elementos de lenguajes naturales, como el ingls. En BASIC, el lenguaje de alto nivel
ms conocido, los comandos como IF CONTADOR=10 THEN STOP pueden utilizarse
para pedir a la computadora que pare si CONTADOR es igual a diez. Por desgracia para
muchas personas esta forma de trabajar es un poco frustrante, dado que a pesar de que
las computadoras parecen comprender un lenguaje natural, lo hacen en realidad de una
forma rgida y sistemtica.
Los lenguajes de alto nivel, tambin denominados lenguajes evolucionados, surgen con
posterioridad a los anteriores (lenguaje mquina, lenguajes de bajo nivel o ensamblador)
con los siguientes objetivos, entre otros:
Lograr independencia de la maquina, pudiendo utilizar un mismo programa en diferentes
equipos con la nica condicin de disponer de un programa traductor o compilador, que
es suministrado por el fabricante, para obtener el programa ejecutable en lenguaje binario
de la maquina que se trate. Adems, no se necesita conocer el hardware especifico de
dicha maquina. Aproximarse al lenguaje natural, para que el programa se pueda escribir y
leer de una forma ms sencilla, eliminando muchas de las posibilidades de cometer
errores que se daban en el lenguaje maquina, ya que se utilizan palabras (en ingles) en
lugar de cadenas de smbolos sin ningn significado aparente.
Incluir rutinas de uso frecuente, como las de entrada / salida, funciones matemticas,
manejo de tablas, etc., que figuran en una especie de librera del lenguaje, de manera que
se puedan utilizar siempre que se quiera sin necesidad de programarlas cada vez.
Ventajas de los lenguajes de alto nivel: el tiempo de formacin de los programadores es
relativamente corto comparado con otros lenguajes. La escritura de programas se basa en
reglas sintcticas similares a los lenguajes humanos, nombres de las instrucciones tales
51
como READ, WRITE, PRINT, OPEN, etc. Las modificaciones y puestas a punto de los
programas son ms fciles. Reduccin del costo de los programas. Transportabilidad.
Permiten tener una mejor documentacin. Son ms fciles de mantener.
Por lo general se piensa que los ordenadores son mquinas que realizan tareas de
clculos o procesamiento de textos. La descripcin anterior es slo una forma muy
esquemtica de ver una computadora. Hay un alto nivel de abstraccin entre lo que se
pide a la computadora y lo que realmente comprende. Existe tambin una relacin
compleja entre los lenguajes de alto nivel y el cdigo mquina.
Los lenguajes de alto nivel son normalmente fciles de aprender porque estn formados
por elementos de lenguajes naturales, como el ingls. En BASIC, el lenguaje de alto nivel
ms conocido, los comandos como
"IF CONTADOR = 10 THEN STOP" pueden utilizarse para pedir a la computadora que
pare si CONTADOR es igual a 10. Por desgracia para muchas personas esta forma de
trabajar es un poco frustrante, dado que a pesar de que las computadoras parecen
comprender un lenguaje natural, lo hacen en realidad de una forma rgida y sistemtica.
Desventajas de los lenguajes de alto nivel: incremento del tiempo de puesta a punto al
necesitarse diferentes traducciones del programa fuente para conseguir el programa
definitivo. No se aprovechan los recursos internos de la maquina que se explotan mucho
mejor en lenguajes mquina y ensambladores. Aumento de la ocupacin de memoria. El
tiempo de ejecucin de los programas es mucho mayor.
Se puede decir que el principal problema que presentan los lenguajes de alto nivel es la
gran cantidad de ellos que existen actualmente en uso, adems de las diferentes
versiones o dialectos que se han desarrollado de algunos de ellos. Es difcil establecer
una clasificacin general de los mismos, ya que en cualquiera que se realice habr
lenguajes que pertenezcan a mas de uno de los grupos establecidos. Una clasificacin
muy extendida, atendiendo a la forma de trabajar de los programas y a la filosofa con que
fueron concebidos.
Un ejemplo de cdigo seria programacin hibrida metiendo en un lenguaje de C++ este
cdigo ejecuta este fragmento de cdigo
#include "stdafx.h"
#include <conio.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
52
char *bufer = "Escriba un numero entre 0 y 1000: ";

char *bufer1 = "Base ";
int a, c, b = 0; int d = 0;
void fac(int num)
{
int r = num;
for (int i = num - 1; i > 0; i--)
{
_asm
{
push eax
push ecx
mov ecx, i
mov eax, 0h
mov eax, r
mul ecx
mov r, eax
pop ecx
pop eax
}
}
cout << "El factorial de " << num << " es: " << r << endl;
}
int _tmain(int argc, _TCHAR* argv[])
{
int i, op;
53
do
{
cout << "MENU" << endl << endl;
cout << "1)Convertidor de bases" << endl << endl;
cout << "2)Suma" << endl << endl;
cout << "3)Resta" << endl << endl;
cout << "4)Division" << endl << endl;
cout << "5)Factorial de un numero" << endl << endl;
cout << "6)Tabla ASCII" << endl << endl;
cout << "7)Salir" << endl << endl;
cout << "Selecione una opcion: "; cin >> op;
switch (op)
{case 1:
{
system("cls");
_cputs(bufer);
a = _getche();
while (a >= '0'&&a <= '9')
{
_asm sub a, 30h;
b = b * 10 + a;
a = _getche();
}
_putch(10);
_putch(13);
for (i = 2; i < 17; i++)
{
54
_cputs(bufer1);
muestra(10, i);
_cputs(": ");
muestra(i, b);
_putch(10);
_putch(13);
}
_getch();
break;
}
case 2:
{
system("cls");
_cputs("Meta el primer valor: ");
cin >> a;
_putch(10);
_cputs("meta el seundo valor: ");
cin >> c;
_putch(10);
suma(a, c);
_putch(10);
_putch(13);
_getch();
break;
}
55
case 3:
{
system("cls");
cin >> a;
_putch(10);
cin >> c;
_putch(10);
resta(a, c);
_putch(10);
_putch(13);
_getch();
break;
}
case 4:
{
system("cls");
cin >> a;
_putch(10);
cin >> c;
_putch(10);
division(a, c);
_putch(10);
_putch(13);
56
_getch();
break;
}
case 5:
{system("cls");
cout << "Meta un numero: ";
cin >> a;
fac(a);
_getch();
break;
}
case 6:
{
system("cls");
for (i = 0; i < 256; i++)
{
cout << i << ".- ";
ascii(i);
_putch(10);
}
_getch();
break;
}
}
} while (op != 7);
57
return 0;
}
Lo que mostrar a este programa ser la opcin numero 5 a la cual llamaremos numero
factorial que quedera de esta manera.
El siguiente cdigo me mostrara el cdigo ascci utilizando lenguaje alto y medio

ejecutndolo con su cdigo de esta manera
#include "stdafx.h"
#include <conio.h>
#include<iostream>
#include<stdlib.h>

int a, c, b = 0; int d = 0;
58
void ascii(int n)
{
int r;
_asm
{
mov eax, n
mov r, eax
}
_putch(r);
}
{
int i, op;
do
{
59
switch (op)
{case 1:
{
system("cls");
_cputs(bufer);
a = _getche();
while (a >= '0'&&a <= '9')
{
_asm sub a, 30h;
b = b * 10 + a;
a = _getche();
}
_putch(10);
_putch(13);
for (i = 2; i < 17; i++)
{
_cputs(bufer1);
muestra(10, i);
_cputs(": ");
muestra(i, b);
_putch(10);
_putch(13);
}
_getch();
break;
}
60
case 2:
{
system("cls");
cin >> a;
_putch(10);
cin >> c;
_putch(10);
suma(a, c);
_putch(10);
_putch(13);
_getch();
break;
}
case 3:
{
system("cls");
cin >> a;
_putch(10);
cin >> c;
_putch(10);
resta(a, c);
_putch(10);
61
_putch(13);
_getch();
break;
}
case 4:
{
system("cls");
cin >> a;
_putch(10);
cin >> c;
_putch(10);
division(a, c);
_putch(10);
_putch(13);
_getch();
break;
}
case 5:
{system("cls");
cin >> a;
fac(a);
_getch();
break;
62
}
case 6:
{
system("cls");
for (i = 0; i < 256; i++)
{
cout << i << ".- ";
ascii(i);
_putch(10);
}
_getch();
break;
}
}
} while (op != 7);
return 0;
}
Ahora como resultado saldr esta tabla
63
El ultimo cdigo muestra como podemos sumar 2 numero con ambos lenguajes unidos el
cdigo quedara de esta forma
#include "stdafx.h"
#include <conio.h>
#include<iostream>
#include<stdlib.h>

int a, c, b = 0; int d = 0;
void suma(int num, int num2)
{
int r1;
64
_asm
{
mov eax, num
add eax, num2
mov r1, eax
}
_cputs("Suma: ");
cout << r1;
_putch(10);
}
{
int i, op;
do
{
65
switch (op)
{case 1:
{
system("cls");
_cputs(bufer);
a = _getche();
while (a >= '0'&&a <= '9')
{
_asm sub a, 30h;
b = b * 10 + a;
a = _getche();
}
_putch(10);
_putch(13);
for (i = 2; i < 17; i++)
{
_cputs(bufer1);
muestra(10, i);
_cputs(": ");
muestra(i, b);
_putch(10);
_putch(13);
}
_getch();
break;
}
66
case 2:
{
system("cls");
cin >> a;
_putch(10);
cin >> c;
_putch(10);
suma(a, c);
_putch(10);
_putch(13);
_getch();
break;
}
case 3:
{
system("cls");
cin >> a;
_putch(10);
cin >> c;
_putch(10);
resta(a, c);
_putch(10);
_putch(13);
67
_getch();
break;
}
case 4:
{
system("cls");
cin >> a;
_putch(10);
cin >> c;
_putch(10);
division(a, c);
_putch(10);
_putch(13);
_getch();
break;
}
case 5:
{system("cls");
cin >> a;
fac(a);
_getch();
break;
}
68
case 6:
{
system("cls");
for (i = 0; i < 256; i++)
{
cout << i << ".- ";
ascii(i);
_putch(10);
}
_getch();
break;
}
}
} while (op != 7);
return 0;
}
Y mostrare la operacin de esta forma
69
Esto es la manera de acciones que podemos utilizar un lenguaje de alto nivel en uno
intermedio pudiendo utilizar lenguaje ensamblador
Actividad 5. Aplicar las acciones construidas a la gramtica del lenguaje

prototipo
Las primeras versiones de los programas suelen ser incorrectas, 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.
Los errores en la programacin pueden ser de los siguientes tipos:
Lxicos, producidos al escribir mal un identificador, una palabra clave o un

operador.
Sintcticos, por una expresin aritmtica o parntesis no equilibrados.
Semnticos, como un operador aplicado a un operando incompatible.
Lgicos, puede ser una llamada infinitamente recursiva.
70
De correccin, cuando el programa no hace lo que el programador

realmente deseaba.
Muchos errores de naturaleza sintctica Recuperacin: Al producirse un error el

compilador debe ser capaz de informar del error y seguir compilando. (Ideal).
El manejo de errores de sintaxis es el ms complicado desde el punto de vista de
la creacin de compiladores. Nos interesa que cuando el compilador encuentre un
error, se recupere y siga buscando errores. Por lo tanto, el manejador de errores
de un analizador sintctico debe tener como objetivos:
Indicar los errores de forma clara y precisa. Aclarar el tipo de error y su

localizacin.
Recuperarse del error, para poder seguir examinando la entrada.
No ralentizar significativamente la compilacin.
Un buen compilador debe hacerse siempre teniendo tambin en mente los

errores que se pueden producir; con ello se consigue:
Simplificar la estructura del compilador.
Mejorar la respuesta ante los errores.
Ejemplo 1.using System;

using System.Linq;
using System.Text;
namespace diagrama
{
class Program
{
{
string cadena, sentencia = "", sentencia2 = "", sentencia3 = "";
int tamcad, tamcad2, tamcad3;
71
Console.Write("Ingresa la primera sentencia: ");

un arreglo
Console.Write("\nIngresa la segunda sentencia: ");
tamcad2 = cadena.Length;//Devuelve el tamao de la cadena
char[] destino2 = new char[tamcad2];
cadena.CopyTo(0, destino2, 0, tamcad2);//Copia la cadena y la almacena
en un arreglo
Console.Write("\nIngresa la tercera sentencia: ");
en un arreglo
if(destino[tamcad - 1] == ';')
{
if(destino[0] == 'i' || destino2[0] == 'i' || destino3[0] == 'i')
{
if(destino[0] == 'i')
{
for (int i = 4; i < tamcad - 1; i++)
{
sentencia = sentencia + destino[i];
}
Console.WriteLine("\nLa sentencia {0} es de tipo int", sentencia);
}
if (destino2[0] == 'i')
{
for (int i = 4; i < tamcad2 - 1; i++)
{
sentencia2 = sentencia2 + destino2[i];
}
Console.WriteLine("\nLa sentencia {0} es de tipo int", sentencia2);
}
{
72

{
}
}
}
if (destino[0] == 'f' || destino2[0] == 'f' || destino3[0] == 'f')
{
if (destino[0] == 'f')
{
{
}
Console.WriteLine("\nLa sentencia {0} es de tipo float", sentencia);
}
if(destino2[0] == 'f')
{
{
}
Console.WriteLine("\nLa sentencia {0} es de tipo float", sentencia2);
}
{
{
}
}
}
if (destino[0] == 'b' || destino2[0] == 'b' || destino3[0] == 'b')

{
if (destino[0] == 'b')
{
{
73
}
Console.WriteLine("\nLa sentencia {0} es de tipo booleano",
sentencia);
}
if (destino2[0] == 'b')
{
{
}
sentencia2);
}
{
{
}
sentencia3);
}
}
if (destino[0] == 'c' || destino2[0] == 'c' || destino3[0] == 'c')
{
if (destino[0] == 'c')
{
{
}
Console.WriteLine("\nLa sentencia {0} es de tipo char", sentencia);
}
if (destino2[0] == 'c')
{
{
}
Console.WriteLine("\nLa sentencia {0} es de tipo char", sentencia2);
}
74
{
{
}
}
}
}
else
{
Console.WriteLine("\nA esta sentencia le falta el ;. Intente de nuevo mas
tarde.");
}
Console.ReadLine();
}
}
}
EJEMPLO 2.using System;

using System.Linq;
using System.Text;
namespace diagrama
{
class Program
{
{
75

un arreglo
en un arreglo
en un arreglo
{
{
{
{
}
}
{
{
}
}
{
76

{
}
}
}
{
{
{
}
}
{
{
}
}
{
{
}
}
}

{
{
{
77
}
sentencia);
}
{
{
}
sentencia2);
}
{
{
}
sentencia3);
}
}
{
{
{
}
}
{
{
}
}
78
{
{
}
}
}
}
else
{
tarde.");
}
Console.ReadLine();
}
}
}
Ejemplo 3.using System;

using System.Linq;
using System.Text;
namespace diagrama
{
class Program
{
{
79

un arreglo
en un arreglo
en un arreglo
{
{
{
{
}
}
{
{
}
}
{
80

{
}
}
}
{
{
{
}
}
{
{
}
}
{
{
}
}
}

{
{
{
81
}
sentencia);
}
{
{
}
sentencia2);
}
{
{
}
sentencia3);
}
}
{
{
{
}
}
{
{
}
}
82
{
{
}
}
}
}
else
{
tarde.");
}
Console.ReadLine();
}
}
}
Actividad 6. Integrar equipos de trabajo para la generacin de un cdigo

intermedio
EL cdigo fuente puede ser traducido en su cdigo de la mquina destino,
entonces, por qu hemos de traducir el cdigo fuente en un cdigo intermedio
que luego se traduce en su cdigo de destino? Vamos a ver las razones por las
que necesitamos un cdigo intermedio.
1. Si un compilador traduce el idioma de origen a su ordenador de destino sin
tener la opcin de generar cdigo intermedio, a continuacin, en cada
nueva mquina, una nativa del compilador completo es necesario.
83
2. Cdigo Intermedio elimina la necesidad de un nuevo compilador completo

para cada mquina de la seccin de anlisis mismo de todos los
compiladores.
3. La segunda parte del compilador, sntesis, se modifica de acuerdo a la

mquina de destino.
Es ms fcil de aplicar las modificaciones del cdigo fuente para mejorar

rendimiento del cdigo mediante la aplicacin de tcnicas de optimizacin cdigo
el cdigo intermedio.
Primer programa utilizado:
using System;
using System.Linq;
using System.Text;
namespace MTOperaciones
{
class Program
{
{
String cadena;
int tamcad, tamlet, tamOparit;
int a = 5, b = 10, c = 15, m = 1;
double Resultado = 0;
84
//Console.WriteLine("Analizador Sintactico\n");
//Console.WriteLine("a = 5, b = 10, c= 15\n");

un arreglo
//Arreglos con posibles datos a introducir

char[] letra = {'a','b','c'};
char[] Oparit = { '+', '-', '*', '/'};

char[] AS = new char[2];

char[] OM = new char[1];
AS[0] = destino[0];
for (int k = 0; k < letra.Length; k++)

{
85
for (int l = 1; l < destino.Length; l++)

{
if (letra[k] == destino[l])
{
AS[m] = destino[l];
}
}
}
m = 0;
for (int n = 0; n < tamOparit; n++)
{
for (int o = 0; o < destino.Length; o++)
{
if (Oparit[n] == destino[o])
{
OM[m] = destino[o];
}
}
}
if(OM[0] == '+')
{
if (AS[0] == 'a' && AS[1] == 'b')
{
86
Resultado = a + b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a + a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a + c;
}
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b + b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c + c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
87
Resultado = b + c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b + a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c + a;
}
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c + b;
}
}
else if(OM[0] == '-')

{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a - b;
}
88
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a - a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a - c;
}
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b - b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c - c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b - c;
}
89
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b - a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c - a;
}
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c - b;
}
}
else if(OM[0] == '*')

{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a * b;
}
if (AS[0] == 'a' && AS[1] == 'a')
90
{
Resultado = a * a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a * c;
}
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b * b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c * c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b * c;
}
if (AS[0] == 'b' && AS[1] == 'a')
91
{
Resultado = b * a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c * a;
}
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c * b;
}
}
else if(OM[0] == '/')

{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a / b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a / a;
92
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a / c;
}
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b / b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c / c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b / c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b / a;
93
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c / a;
}
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c / b;
}
}
Console.WriteLine("El resultado de la operacion es: {0} = {1}", cadena,

Resultado);
Console.ReadLine();
}
}
}
Ejemplo 1:
94
Segundo programa:
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
String cadena;
int a = 5, b = 10, c = 15, m = 1;

un arreglo
95

char[] Oparit = { '+', '-', '*', '/'};


AS[0] = destino[0];

{
{
{
AS[m] = destino[l];
}
}
}
96
m = 0;
{
{
{
OM[m] = destino[o];
}
}
}
if(OM[0] == '+')
{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a + b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a + a;
}
97
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a + c;
}
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b + b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c + c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b + c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b + a;
}
98
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c + a;
}
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c + b;
}
}
else if(OM[0] == '-')

{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a - b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a - a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
99
Resultado = a - c;
}
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b - b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c - c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b - c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b - a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
100
Resultado = c - a;
}
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c - b;
}
}
else if(OM[0] == '*')

{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a * b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a * a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a * c;
}
101
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b * b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c * c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b * c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b * a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c * a;
}
102
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c * b;
}
}
else if(OM[0] == '/')

{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a / b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a / a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a / c;
}
if (AS[0] == 'b' && AS[1] == 'b')
103
{
Resultado = b / b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c / c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b / c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b / a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c / a;
}
if (AS[0] == 'c' && AS[1] == 'b')
104
{
Resultado = c / b;
}
}

Resultado);
Console.ReadLine();
}
}
}
Ejemplo 2:
Tercer programa:
using System;
105
using System.Linq;
using System.Text;
{
class Program
{
{
String cadena;
int a = 5, b = 10, c = 15, m = 1;

un arreglo

106
char[] Oparit = { '+', '-', '*', '/'};


AS[0] = destino[0];

{
{
{
AS[m] = destino[l];
}
}
}
m = 0;
107
{
{
{
OM[m] = destino[o];
}
}
}
if(OM[0] == '+')
{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a + b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a + a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a + c;
108
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b + b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c + c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b + c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b + a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c + a;
109
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c + b;
}
}
else if(OM[0] == '-')

{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a - b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a - a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a - c;
}
110
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b - b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c - c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b - c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b - a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c - a;
}
111
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c - b;
}
}
else if(OM[0] == '*')

{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a * b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a * a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a * c;
}
if (AS[0] == 'b' && AS[1] == 'b')

{
112
Resultado = b * b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c * c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b * c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b * a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c * a;
}
if (AS[0] == 'c' && AS[1] == 'b')

{
113
Resultado = c * b;
}
}
else if(OM[0] == '/')

{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a / b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a / a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a / c;
}
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b / b;
}
114
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c / c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b / c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b / a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c / a;
}
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c / b;
}
115

Resultado);
Console.ReadLine();
}
}
}
Ejemplo 3:
Actividad 7 Avance del proyecto final

Estos generadores producen analizadores sintcticos, normalmente a partir de
una entrada fundamentada en una gramtica independiente de libre contexto. En
los primeros compiladores, el anlisis sintctico consuma no slo gran parte del
tiempo de ejecucin del compilador, sino gran parte del esfuerzo intelectual de
escribirlo. Esta fase se considera ahora una de las ms fciles de aplicar. Muchos
de los generadores de analizadores sintcticos utilizan poderosos algoritmos de
anlisis sintctico, y son demasiado complejos para realizarlos manualmente.
Programa utilizado:
case 2:
Console.WriteLine("\n\nAnalizador Sintactico\n");
Console.WriteLine("a = 5, b = 10, c= 15\n");

116
char[] destino2 = new char[tamcad];
cadena.CopyTo(0, destino2, 0, tamcad);//Copia la cadena y la

AS[0] = destino2[0];

{
for (int l = 1; l < destino2.Length; l++)
{
if (letra[k] == destino2[l])
{
AS[m] = destino2[l];
}
}
}
m = 0;
{
for (int o = 0; o < destino2.Length; o++)
117
{
if (Oparit[n] == destino2[o])
{
OM[m] = destino2[o];
}
}
}
if (OM[0] == '+')
{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a + b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a + a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a + c;
}
118
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b + b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c + c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b + c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b + a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c + a;
}
119
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c + b;
}
}
else if (OM[0] == '-')

{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a - b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a - a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a - c;
}
if (AS[0] == 'b' && AS[1] == 'b')

{
120
Resultado = b - b;
}
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c - c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b - c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b - a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c - a;
}
if (AS[0] == 'c' && AS[1] == 'b')

{
121
Resultado = c - b;
}
}
else if (OM[0] == '*')

{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a * b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a * a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a * c;
}
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b * b;
}
122
if (AS[0] == 'c' && AS[1] == 'c')

{
Resultado = c * c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b * c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b * a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c * a;
}
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c * b;
}
123
else if (OM[0] == '/')

{
if (AS[0] == 'a' && AS[1] == 'b')
{
Resultado = a / b;
}
if (AS[0] == 'a' && AS[1] == 'a')

{
Resultado = a / a;
}
if (AS[0] == 'a' && AS[1] == 'c')

{
Resultado = a / c;
}
if (AS[0] == 'b' && AS[1] == 'b')

{
Resultado = b / b;
}
if (AS[0] == 'c' && AS[1] == 'c')
124
{
Resultado = c / c;
}
if (AS[0] == 'b' && AS[1] == 'c')

{
Resultado = b / c;
}
if (AS[0] == 'b' && AS[1] == 'a')

{
Resultado = b / a;
}
if (AS[0] == 'c' && AS[1] == 'a')

{
Resultado = c / a;
}
if (AS[0] == 'c' && AS[1] == 'b')

{
Resultado = c / b;
}
}
125

Resultado);
break;
}
Console.ReadLine();
}
}
}
Ejemplo 1:
Anlisis sintctico de una expresin.
126
Ejemplo 2:

Ejemplo 3:
127
Conclusin
En las actividades anteriores se ha demostrado que es posible establecer un
camino evolutivo continuo en el que se sitan los algoritmos de anlisis sintctico
que incorporan las estrategias de anlisis ms importantes, tanto para el caso de
las gramticas de adjuncin de rboles como para el caso de las gramticas
lineales de ndices. Los lenguajes evolucionan con el tiempo, adquiriendo nuevas
construcciones y realizando tareas adicionales. Estas nuevas construcciones se
pueden aadir con ms facilidad a un lenguaje cuando existe una aplicacin
basada en una descripcin gramatical del lenguaje. Finalmente hemos analizado
que dentro de los analizadores sintcticos que vimos, pudimos notar la diferencia
entre los que son descendentes y los ascendentes, y sus principales
caractersticas, viendo tambin la forma normal de Chomsky que es de gran
importancia en el anlisis sintctico. Por otro lado, llevamos los conocimientos
tericos a la prctica mediante las actividades y programas relacionados con las
mismas.
128
Bibliografa
1. Teora de Autmatas, lenguajes y computacin Tercera Edicin, Hopcroft,

Motwani, Ullman, Editorial Pearson Addison Wesley, Captulo 1, Pag. 24-27
2. Construccin de Compiladores: Principios y Prctica Primera Edicin,
Kenneth Louden, Captulo 1, Pag. 7-14
3. Viviancos Emilio (2011).. Incorporacin de acciones semnticas en Bison,
Universitat Politcnica de Valncia UPV
4. http://www.dynamics.unam.edu/users/mtrejo/cursos/compiladores/compilers
.pdf
5. http://c.conclase.net/curso/?cap=009
6. http://di002.edv.uniovi.es/~ortin/publications/semantico.pdf
7. http://c.conclase.net/curso/?cap=009
129
130

Reporte de Actividades Unidad 2 Lenguajes y Automatas 2

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Reporte de Actividades Unidad 2 Lenguajes y Automatas 2

Caricato da

Copyright:

Formati disponibili

TECNOLGICO NACIONAL DE MXICO

INSTITUTO TECNOLGICO DE ACAPULCO

Reporte de actividades de aprendizaje y prcticas

Disea las reglas para traducir el cdigo fuente a un cdigo intermedio

anlisis conocido como anlisis semntico es de suma importancia conocer su

Actividad 1. Aplicar los tipos de notacin para la conversin de expresiones:

Consideremos la suma de A y B. Sabemos que tenemos que aplicar el operador

A+B, notacin infija. Esta es la forma ms comn para representar la

+AB, notacin prefija. El operador aritmtico precede a los operandos.

AB+, notacin posfija. El operador aritmtico sucede a los operandos.

En el caso de la notacin infija, si slo hay un operador involucrado no existe

La ventaja de las notaciones prefija y posfija es que no dan pie a ambigedades.

Console.WriteLine("Ingresa la cadena a cambiar:");

while ((pila.Count > 0) && (pila.Peek() != '('))

static class Program

pila.Pop(); //quita el parentesis izquierdo de la pila

if ((posfija[i] == '*') || (posfija[i] == '+') || (posfija[i] == '-') || (posfija[i] == ' '))

//string cadena = "(1+17)*2";

Actividad 2. Representar expresiones mediante el cdigo intermedio

a) El cdigo intermedi es particularmente utilizado cuando el objetivo de

Console.Write("\nIngresa una expresion: ");

for (int i = 0; i < tamcad; i++)

Console.WriteLine("\n Tabla de Simbolos\n");

Segundo Programa utilizado:

Console.Write("\nIngresa una expresion: ");

for (int i = 0; i < tamcad; i++)

Console.WriteLine("\n Tabla de Simbolos\n");

Tercer Programa utilizado:

Console.Write("\nIngresa una expresion: ");

for (int i = 0; i < tamcad; i++)

Console.WriteLine("\n Tabla de Simbolos\n");

Actividad 3. Reconocer el manejo de tipos en las expresiones y el uso de

default(T): devuelve el valor inicializado predeterminado de tipo T, null para tipos

x / y: divisin. Si los operandos son enteros, el resultado es un entero que se

As: conversin de tipos. Devuelve el operando izquierdo convertido al tipo

x -= y: decremento. Reste el valor de y del valor de x, almacene el resultado en x

cadena.CopyTo(0, destino, 0, tamcad);//Copia la cadena y la

if (destino[i] == 'd' && destino[i + 1] == 'o')

| un operador aritmetico |",

Muestra el reconocimiento de dos operadores aritmeticos

char[] OpeRe = { '<', '>', '!' };

|", destino[i], destino[i + 1]);

Console.WriteLine("\n| {0}{1}{2}{3}{4} | palabra

if (destino[i] == 'e' && destino[i + 1] == 'l' && destino[i + 2]

| un operador aritmetico |",

Muestra el reconocimiento de un operador relacional y un operador lgico

| un operador aritmetico |",

Muestra el reconocimiento de tres operadores de diferente categoria

Actividad 4. Desarrollar las acciones que representen la estructura de un

El Common Intermediate Language de Microsoft es un lenguaje intermedio diseado para

LENGUAJES DE ALTO NIVEL:

using namespace std;

char *bufer = "Escriba un numero entre 0 y 1000: ";

El siguiente cdigo me mostrara el cdigo ascci utilizando lenguaje alto y medio

using namespace std;

char *bufer = "Escriba un numero entre 0 y 1000: ";

Ahora como resultado saldr esta tabla

using namespace std;

char *bufer = "Escriba un numero entre 0 y 1000: ";

Actividad 5. Aplicar las acciones construidas a la gramtica del lenguaje

Lxicos, producidos al escribir mal un identificador, una palabra clave o un

De correccin, cuando el programa no hace lo que el programador

Muchos errores de naturaleza sintctica Recuperacin: Al producirse un error el

Indicar los errores de forma clara y precisa. Aclarar el tipo de error y su