ESCUELA POLITECNICA NACIONAL

Facultad de Ingeniería en Sistemas

Materia: Compiladores y Lenguajes

Código: SIC424

Grupo: GR2

Tema: Detector de Paridad

Grupo de Trabajo 1

Integrantes:

Alvear Fabricio
Iñiguez Rodman
Ontaneda Nicole
Reinoso Paul
Silva Andrea

Fecha de entrega: 20 de noviembre de 2018

Período Académico: octubre/18 – febrero/19
Objetivo:
 Conocer el funcionamiento básico de un ensamblador
 Observar las diferentes etapas que conforman un ensamblador
 Implementar en C++ un cross ensamblador

Marco Teórico:
Ensambladores son los encargados de transformar o traducir los programas escritos en
ensamblador a su equivalente en código maquina o binario para que pueda ser ejecutado
por la CPU. Este fue el primer lenguaje de programación que tradujo el lenguaje maquina
a un lenguaje más natural para el ser humano. Con todo esto podemos decir que el
lenguaje ensamblador es un lenguaje de programación de bajo nivel que se utiliza para
escribir programas para computadoras, es la representación más directa del código
máquina comprensible por los programadores.
El lenguaje ensamblador se usó para la creación de programas en el pasado, actualmente
se usa muy poco. Únicamente cuando se requiere un control directo del hardware o se
quiere conseguir rendimientos poco comunes de los equipos. Un programa escrito con el
lenguaje ensamblador seguirá los siguientes pasos: este programa tiene una serie de
instrucciones que contienen las órdenes a seguir para llevar a cabo una acción. Todas
estas órdenes son cargadas en la memoria de la computadora.

¿Qué Ofrecen Los Ensambladores Avanzados?

 Control avanzado de estructuras.
 Procedimiento de alto nivel, declaración de funciones.
 Tipos de datos que incluyen: estructuras, registros, uniones, clases y conjuntos.
 Sofisticado procesamiento de macros.

Tipos De Ensambladores:
Aunque todos los ensambladores realizan básicamente las mismas tareas, podemos
clasificarlos de acuerdo con características, así podemos clasificarlas en:
 Ensambladores Cruzados (Cross-Assembler).
 Ensambladores Residentes.
 Macroensambladores.
 Microensambladores.
 Ensambladores De Una Fase.
 Ensambladores De Dos Fases.

Ensambladores Cruzados
Es aquel que se ejecuta sobre un computador con un procesador diferente de aquel para
el que se ensambla el código. Los ensambladores cruzados permiten a un programador
desarrollar programas para diferentes sistemas sobre un computador.
Sin embargo, excepto en el caso de minicomputadores y grandes computadores que
pueden ofrecer un simulador de microprocesador destinatario real, no se puede
normalmente probar y depurar el código creado por un ensamblador cruzado sin
ejecutarse sobre una maquina real que utilice este procesador. En cualquier caso, siempre
se debe utilizar la sintaxis correcta, esto es, códigos OP, operandos, y así sucesivamente,
para el microprocesador para el que el ensamblador cruzado está diseñado. Ej. asMSX es
un ensamblador cruzado para MSX (cross-assembler), es decir, un programa que genera
archivos binarios para MSX, y para cualquier otra máquina que utilice el microprocesador
Z80, desde cualquier plataforma IBM/PC con el sistema operativo Windows (cualquier
versión).

Desarrollo:
Ejercicio: implementar en C++ un ensamblador que recibe como entrada un archivo
que lee las instrucciones que será el programa objeto y retornara el programa fuente
CODIGO
#include <iostream>
#include <sstream>
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <iostream>
#include <cassert>
#include <cstring>
#include <cstdlib>

using namespace std;

int main(int argc, char *argv[])
{
//DEFINICION DE VARIABLES
int i=0,j=0, intContador=0;
int intPosiComandos[20];
string token, memoria, strControl;
string tokens;
char linea2[100];
string strPosiComandos [20];
//CONSTRUCCION DEL SET DE INSTRUCCIONES
fflush(stdin);
printf("inicio token %d",token);
printf("inicio tokens %d",tokens);
string setInstrucion[5][4] = {{"3F","LDAA","$00"," Cargar variable A "},
{"5E","LDAB","$00"," Cargar variable B "},
{"4A","STAA","$00"," Almacenar variable A "},
{"38","ABA"," ","Sumar A con B y almacenar en A "},
{"9C","SWI"," ","STOP"}};
//LEER TEXTO PLANO
//fstream archivo("intruc_ensablador.txt");
ifstream archivo("intruc_ensablador.txt");

//fstream archivo;

string linea;

//if(!archivo.is_open()){
// archivo.open("intruc_ensablador.txt", ios::in);
// printf("abrio el archivo");
//}
while(getline(archivo,linea,'*'))

//cout<< linea << "\n";

// cout << linea << endl;

archivo >> linea ;

std::cout <<" imrpiendo linea: " << linea << std::endl;

while(strControl==""){ //PARA NO TERMINAR AL DAR ENTER

tokens=linea;
istringstream iss(tokens);

//istringstream stream(linea);

//SALTO DE LINEA, COMENTARIO Y MEMORIA

do
{
// printf("imprimeindo iss:%c",iss.getline());
iss >> token; //GUARDA LAS PALABRAS QUE SE PRODUCEN POR
EL TOKEN

for (i = 0; i < 4; i++) {

if (token == "SWI" || token == "swi"){

strControl="SWI"; //AL ESCRIBIR "END TERMINA EL

PROGRAMA"
}

std::cout <<" imrpiendo token: " << token << " instruccion: " <<
setInstrucion[i][1] << std::endl;

if (token == setInstrucion[i][1] )
{
printf("entrando...\n");
 intPosiComandos[intContador]=i;
iss >> memoria;
//cout<<"memoria.substr(1,2):
"<<memoria.substr(1,2)<<" iss: "<<iss;

strPosiComandos[intContador]=memoria.substr(1,2);
cout << "strposicomandos:" <<
strPosiComandos[intContador] << endl;

//PARA GUARDAR LA POSICION DE

MEMORIA E IR A BUSCAR EN EL ARREGLO MEMORIA

//setInstrucion[i][2]="$"+memoria.substr(1,2);
//cout << "setinstrucion:" <<
setInstrucion[i][2] << endl;

intContador++;
printf("inticontador. %i\n",intContador);
}

}
} while (iss); }
//IMPRIMIR LAS SENTENCIAS QUE RECONOCE EL TRADUCTOR
cout<<"\nInstrucciones permitidas"<<endl;
for (i = 0; i <= 7; i++) {
cout<< setInstrucion[i][1]<<endl;
}
cout<<"\nPARA TERMINAR ESCRIBA SWI"<<endl;
cout<<"\nPROGRAMA OBJETO:"<<endl;
//DIVIDIR EN PALABRAS LAS FRASES QUE SE INGRESAN

//IMPRESION DEL PROGRMA OBJETO Y LA TABLA CON LOS

RESPECTIVOS COMENTARIOS
cout<<"\n \n \tPROGRAMA FUENTE:"<<endl;

for(i=0;i<intContador;i++){
// printf("imprimiendo comando%c",strPosiComandos[i]);
// cout<<"\t"<<setInstrucion[intPosiComandos[i]][0]<<"
"<<strPosiComandos[i]<<endl;
cout<<"Imprimiendo comando:\t"<<
setInstrucion[intPosiComandos[i]][0]<<" "<<strPosiComandos[i]<<endl;

}
cout<<"Imprimiendo comando:\t"<< setInstrucion[4][0]<<" "<<endl;

archivo.close();
system ("pause");
return 0;
}
RESULTADO:
Conclusiones:
 Se concluyo que el ensamblador cruzado permite al programador desarrollar
programas para diferentes sistemas sobre un computador.
 Se determino no se puede normalmente probar y depurar el código creado por un
ensamblador cruzado sin ejecutarse sobre una maquina real que utilice este
procesador.

Recomendaciones:
 Debemos estar familiarizados con la sintaxis del lenguaje de programación.
 Es importante investigar sobre el tema más a fondo para este tipo de
implementaciones.

Bibliografía:
 D.A. PATTERSON, J.L HENNESSY. Estructura y diseño de computadores
Reverté, 2000.
 A. CLEMENTS. Microprocessor Systems Design. 3ra edición, ITP – PWS
Publishing Company, 1997.