Autor Tema: Seccion Especial: Construya Su Propia Pc (Leído 15219 veces)

kennethsleiker · « **en:** Miércoles 25 de Agosto de 2004, 01:55 »

Quiero proponer el siguiente problema practico para todos nosotros. Solo soy un novato porque apenas comence a estudiar C/C++ y para agudizar mi aprendizaje y talves ayudar a otros a desarrollarce igual que yo

Lo que quiero proponer consiste en desviarnos temporalmente del mundo de la programacion de lenguajes de alto nivel. "Abriremos" una computadora y veremos su estructura interna. Presentaremos la programacion en lenguaje de maquina y escribiremos varios programas en dicho lenguaje.

Para hacer que esta sea una experiencia especialmente valiosa, despues construiremos una computadora (por medio de la tecnica de simulacion basada en software) en la que podra ejecutar sus programas en lenguaje de maquina.

A) ( Programacion en lenguaje de maquina) Crearemos una computadora a la que llamaremos Simpletron. Como su nombre implica, es una maquina sencilla, pero como pronto veremos, tambien es poderosa. La Simpletron ejecuta programas escritos en el unico lenguaje que entiende directamente; es decir, el lenguaje de maquina Simpletron, o SML.

La Simpletron contiene un acumulador --es decir, un "registro especial" en el que se coloca la informacion antes de que la Simpletron la tome para efectuar calculos o examinarla de varias maneras. Toda la informacion de la Simpletron se maneja en terminos de palabras. Una palabra es un numero decimal de cuatro digitos con signo, como +3364, -1293, +0007, -0001, etc. La Simpletron viene equipada con una memoria de 100 palabras, las cuales se referencian por su numero de localidad: 00, 01, ..., 99.

Antes de ejecutar un programa SML, debemos cargar el programa en memoria. La primera instruccion de cada programa SML siempre queda en la localidad 00. El simulador comenzara la ejecucion a partir de esta localidad.

Cada instruccion en SML ocupa una palabra de la memoria de la Simpletron (por lo tanto, las instrucciones son numeros decimales de cuatro digitos con un signo). Supondremos que el signo de una instruccion SML siempre es positivo, pero el signo de una palabra de datos puede ser positivo o negativo. Cada localidad de la memoria de la Simpletron puede contener una instruccion, un valor de datos utilizado por el programa o un area no utilizada (y, por lo tanto, indefinida) de la memoria.

Los primeros dos digitos de cada instruccion SML son el codigo de operacion, que especifica la operacion que se llevara a cabo. A continuacion les muestro los codigos de operacion del SML:

Operaciones de entrada/salida:

const int READ = 10;
Lee una palabra del teclado y la pone en una localidad especifica de la memoria.
const int WRITE = 11;
Escribe en la pantalla la palabra ubicada en una localidad especifica de memoria.

Operaciones de carga/almacenamiento:
const int LOAD = 20;
Carga en el acumulador la palabra ubicada en una localidad especifica de memoria.
const int STORE = 21;
Almacena la palabra que se encuentra en el acumulador en una localidad especifica de memoria.

Operaciones aritmeticas:

const int ADD = 30;
Suma la palabra ubicada en una localidad especifica de memoria a la palabra que se encuentra en el acumulador (deja el resultado en el acumulador).
const int SUBTRACT = 31;
Resta la palabra ubicada en una localidad especifica de memoria a la palabra que se encuentra en el acumulador (deja el resultado en el acumulador).
const int DIVIDE = 32;
Divide la palabra ubicada en una localidad especifica de memoria a la palabra que se encuentra en el acumulador (deja el resultado en el acumulador).
const int MULTIPLY = 33;
Multiplica la palabra ubicada en una localidad especifica de memoria a la palabra que se encuentra en el acumulador (deja el resultado en el acumulador).
Operaciones de transferencia de control:

const int BRANCH = 40;
Bifurca a una localidad de memoria especifica
const int BRANCHNEG = 41;
Bifurca a una localidad de memoria especifica si el acumulador es negativo
const int BRANCHZERO = 42;
Bifurca a una localidad especifica de memoria si el acumulador es igual a cero.
const int HALT = 43;
Termina; el programa ha completado su trabajo.

Los ultimos dos digitos de las instrucciones SML son el operando (la direccion de la localidad especifica de memoria que contiene la palabra a la que se aplica la operacion).

Ahora consideremos varios programas SML sencillos.

Ejemplo 1
Localidad_____________Numero__________Instruccion

00___________________+1007___________Lee_A
01___________________+1008___________Lee_B
02___________________+2007___________Carga_A
03___________________+3008___________Suma_B
04___________________+2109___________Almacena_C
05___________________+1109___________Escribe_C
06___________________+4300___________Terminacion
07___________________+0000___________Variable_A
08___________________+0000___________Variable_B
09___________________+0000___________Variable_C

El primero (ejemplo 1) lee del teclado dos numeros y calcula e imprime su suma. La instruccion +1007 lee el primer numero y lo pone en la localidad 07 (la cual ha sido inicializada a cero). La instruccion +1008 lee el siguiente numero, colocandolo en la localidad 08. La instruccion load, +2007, pone (copia) en el acumulador el primer numero y la instruccion add, +3008, suma el segundo numero al que se encuentra en el acumulador. Todas las instrucciones aritmeticas de SML dejan sus resultados en el acumulador. La instruccion store, +2109, pone (copia) el resultado en la localidad de memoria 09, de donde lo toma la instruccion write, +1109, y lo imprime (como numero decimal de cuatro digitos con signo). La instruccion halt, +4300, termina la ejecucion.

El programa SML a continuacion (ejemplo 2) lee del teclado dos numeros y determina e imprime el valor mas alto. Note que la instruccion +4107 se utiliza como transferencia de control condicional, a semejanza de la instruccion if de C/C++.

Ejemplo 2
Localidad___________Numero_________Instruccion

00__________________+1009__________Lee_A
01__________________+1010__________Lee_B
02__________________+2009_________Carga_A
03__________________+3110__________Resta_B
04__________________+4107__________Bifurca_con_negativo_a_07
05__________________+1109__________Escribe_A
06__________________+4300__________Terminacion
07__________________+1110__________Escribe_B
08__________________+4300__________Terminacion
09__________________+0000__________Variable_A
10__________________+0000__________Variable_B

Seria bueno realizar algunos ejemplos sencillos de programas SML:

1- Mediante un ciclo controlado por centinela leer 10 numeros positivos y calcule e imprima su suma.

2- Mediante un ciclo controlado por contador, leer siete numeros, algunos positivos y otros negativos, y calcule e imprima su promedio.

3- Lea una serie de numeros y determine e imprima el mayor. El primer numero indicara la cantidad de numeros a procesar.

Haaa, por si no lo saben esta tarea tambien es para mi, como les habia dicho aun no se C/C++, apenas lo estoy estudiando y creo que esta es una buena forma de hacerlo, compartiendo.

Ahorita continuare con mas detalles del simulador antes de comenzar a programar.

kennethsleiker

Simulador de computadora
Al principio parecera un tanto pretencioso, pero en este problema vamos a construir nuestra propia computadora. No, nos encargaremos de soldar sus componentes. En cambio, nos valdremos de la poderosa tecnica de simulación basada en software para crear un modelo en software de la Simpletron.

No se decepcionara. Su simulador convertira en una Simpletron a la computadora en la que este trabajando y usted de hecho podra ejecutar, probar y depurar los programas SML que escribimos anteriormente.

Cuando ejecutemos el simulador Simpletron, debera comenzar por imprimir:

*** !Bienvenidos a Simpletron! ***

*** Por favor introduzca su programa una instrucción ***
*** (o dato) a la vez. Presentare ***
*** la localidad y un signo de interrogación ( ? ) . ***
*** Después usted tecleara la palabra para esa localidad. ***
*** Para detener la introducción de su programa, ***
*** teclee el centinela -9999. ***

Simularemos la memoria de la Simpletron con un arreglo llamado memory de un solo subíndice, que tiene 100 elementos. Supongamos ahora que esta ejecutandose el simulador y examinemos el dialogo a medida que ingresamos el programa del ejemplo 2:

00 ? +1010
01 ? +1009
02 ? +2009
03 ? +3110
04 ? +4107
05 ? +1109
06 ? +4300
07 ? +1110
08 ? +4300
09 ? +0000
10 ? +0000
11 ? -9999

*** Se ha completado la carga del programa ***
*** Inicia la ejecución del programa ***

El programa SML ha sido colocado (o cargado) en el arreglo memory. Ahora la Simpletron ejecuta su programa SML. La ejecución inicia con la instrucción de la localidad 00 y, como C++ , continua secuencialmente, a menos que se le dirija a otra parte del programa mediante una transferencia de control.

Mediante la variable accumulator representaremos el registro del acumulador. Emplearemos la variable counter para llevar el registro de la localidad de memoria que contiene la instrucción en ejecución. En la variable operationCode indicaremos la operación actual, es decir, los dos digitos de la izquierda de la palabra de instrucción. Mediantela variable operand indicaremos la localidad de memoria sobre la que opera la instrucción actual. Asi, operand esta formado por los dos digitos mas a la derecha de la instrucción que se esta ejecutando en el momento. No ejecutaremos las instrucciones directamente en la memoria. En cambio, transferiremos la siguiente instrucción a ejecutar de la memoria a una variable llamada instructionRegister. Luego tomaremos los dos digitos de la izquierda, poniendolos en operationCode, y tomaremos los dos de la derecha y los colocaremos en operand. Cuando comienza la operación de la Simpletron, los registros especiales se inicializan a 0.

kennethsleiker

Aquí estan los ultimos detalles sobre el simulador:

Antes de comenzar a programar quiero que hagamos un recorrido por la ejecucion de la primera instrucción SML del ejemplo anterior mostrado; la primera instrucción SML, +1009, que esta en la localidad de memoria 00. A esto se le llama ciclo de ejecucion de instrucción.

counter nos dice la localidad de la siguiente instrucción a ejecutar. Obtenemos de la memoria el contenido de dicha localidad mediante la instrucción de C++

instructionRegister = memory[ counter ];

El codigo de operación y el operando se extraen del registro de instrucciones por medio de las instruciones:

operationCode = instructionRegister / 100;
operand = instructionRegister % 100;

Ahora la Simpletron debera determinar que el codigo de operación es en realidad una read,o lectura ( en lugar de write, load, etc ). Una switch se encargara de diferenciar las doce operaciones de SML.

En la estructura switch se simula el comportamiento de varias instrucciones SML como sigue (dejaremos las demas para que cada quien las resuelva ):

read:……….. cin >> memory[ operand ]
load:……….. accumulator = memory[ operand ]
add:………... accumulator += memory[ operand ]
branch:…….. mas adelante estudiaremos las instrucciones de bifurcacion
halt:………... Esta instrucción imprime el mensaje: *** Ha terminado la ejecucion de Simpletron ***

y luego imprime el nombre y contenido de los registros, asi como el contenido completo de la memoria. Tal impresión con frecuencia es conocida como vaciado de computadora. Para ayudarle a dar una idea de el formato del vaciodo fijence en el siguiente ejemplo:

REGISTROS:
acumulador____________+0000
contador____ __________ 00
registrodeinstruccion_____+0000
codigodeoperacion_______00
operando_______________00

MEMORIA:

________0_______1______2______3_____4______5_____6______7______8______9
10 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000
20 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000
30 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000
40 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000
50 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000
60 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000
70 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000
80 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000
90 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000

Observe que el vaciado tras la ejecucion de programa Simpletron mostraria los valores reales de las instrucciones y de los datos al momento de terminar la ejecucion.

Prosigamos con la ejecucion de la primera instrucion de nuestro programa: +1009 en la localidad 00. Comohemos indicado, la instrucción switch simula esto ejecutando la instrucción C++

cin >> memory[ operand ];

Antes de la ejecucion de cin, se debera presentar un signo de interrogacion (?) en la pantalla, para pedirle al usuario una entrada. La Simpletron espera a que el usuario introduzca un valor y oprima la tecla Retorno. El valor queda en la localidad 09.

En este punto se ha completado la simulacion de la primera instrucción. Lo que queda es preparar a Simpletron para que ejecute la siguiente instrucción. Dado que la instrucción que se acaba de ejecutar no fue una transferencia de control, simplemente necesitamos incrementar el registro del contador de instrucciones como sigue:

++counter;

Con esto se completa la ejecucion simulada de la primera instrucción. El proceso completo (es decir, el ciclo de ejecucion de instrucción) inicia nuevamente con la obtencion de la siguiente instrucción a ejecutar.

Ahora consideremos la manera como se simulan las instrucciones de bifurcacion (las transferencias de control).Todo lo que necesitamos hacer es ajustar el valor del contador de instrucciones. Por lo tanto, se simula la instruccion incondicional (40) dentro de switch con:

if ( accumulator == 0 )
counter = operand;

HASTA ESTE PUNTO ESTA BIEN, YA PODEMOS COMENZAR A PROGRAMAR.

Cada quien puede embellecer el SML con caracteristicas adicionales e incluirlas en su simulador.

El simulador debera buscar varios tipos de errores. Durante la fase de carga del programa, por ejemplo, cada numero tecleado por el usuario para memory debera estar en el rango de -9999 a +9999. El simulador debera comprobar mediante un ciclo while que cada numero digitado este en este rango y, si no, solicitar al usuario que lo vuelva a teclear hasta que este correcto.

Durante la fase de ejecucion, el simulador debera buscar varios errores serios, como division entre cero, codigos de ejecucion invalidos, sobrecargas del acumulador ( es decir, operaciones aritmeticas que den valores mayores que +9999 o menores que -9999) y otros. Tales errores serios se llaman errores fatales. Al detectar un error fatal, el simulador debera imprimir un mensaje de error como:

*** Intento de dividir entre cero ***
*** Terminacion anormal de Simpletron ***

Asi como un vaciado completo con el formato que indicamos previamente. Con el se ayudara al usuario a localizar el error en el programa.

A TRABAJAR, YO COMIENZO AHORA MISMO, A MEDIDA DE CADA DESARROLLO IREMOS PUBLICANDO AQUÍ. LOS CODIGO FUENTES BUENA SUERTE.

Binary

Yo no se nada de eso...!!!
Ni idea, pero si puedo observar por arriba lo que pasa... lo que si es que soy 100% usuario a nivel de sistema operativo.

Saludos.

kennethsleiker

Cita de: "Binary"

Yo no se nada de eso...!!!
Ni idea, pero si puedo observar por arriba lo que pasa... lo que si es que soy 100% usuario a nivel de sistema operativo.

Saludos.

Gracias por tus comentario hermano. Esto simplemente trata de utilizar el lenguaje de programacion C++ para desarrollar un simulador del modelo computacional SIMPLETRON, el fin es totalmente practico.

Binary

De poder, se puede, pero no le encuentro mucho sentido...
Lo que estariamos haciendo es un tipo de lenguaje simplificado, pero su base es un lenguaje tan complejo como el C++...

Es interesante crear un lenguaje, pero no pasando por otro, sino, por lenguaje de maquina.... Sino estaria ocurriendo que nosotros procesamos cosas simples con una base muy compleja y avanzada, distrayendo todas las facultades de rapidez, que es algo absurdo....

Lo que si es que es una interesante idea, aunque poco practica... seria entretenido por lo menos hablar de eso, aunque no le saquemos el provecho, pero nada mas para detallar un poco en la logica de la programacion.

Saludos.

© Jonathan ©

Yo no le encuentro mucho sentido

... por casualidad no es una tarea de universidad???... aveces se utiliza la creacion de retos para buscar soluciones ajenas a problemas personales

... solo comentario. En fin... que gane el mejor

. Saludos

kennethsleiker

No se trata de una practica de universidad, la verdad es que he comprado un libro de C++ y lo estoy estudiando didacticamente, una de las practicas que me pide el libro es desarrollar este simulador.

El fin como habia explicado antes es para fines de aprender, esta practica me esta ayudando a comprender como trabaja la estructura interna de una PC.

Hace tres dias que comence a desarrollarlo, hasta el momento he completado la parte basica del simulador, ahora mismo estoy trabajando con la deteccion de errores en tiempo de ejecucion.

Les anexo en un archivo lo que tengo hasta el momento.

Lo he compilado en Dev-C++ (Windows) y con g++ ( GNU/Linux ) y hasta el momento esta libre de errores.

Aunque hay cosas mas avanzada a las que llegaremos en su momento, por ejemplo crear un compilador de alto nivel para nuestro simulador SML.

Solo pense que seria buena idea compartir para quienes no somos avanzado y estamos en face de aprendizaje resolber las practicas que leo en el libro dentro de este foro, ya que tambien son para mi.

PostData: Yo no asisto a la universidad y tampoco estoy estudiando en escuelas o liceos.

Noel Solw

Como se llama el libro de C++ donde esta publicado el ejercicio que quieres resolver ?

kennethsleiker

Cita de: "Noel Solw"

Como se llama el libro de C++ donde esta publicado el ejercicio que quieres resolver ?

El libro que estoy estudiando se llama C++ Como Programar, no esta publicado en la red, el ejercicio lo tengo publicado aqui mismo en este foro, lo explico en los tres primeros mensajes de este foro.

Noel Solw

Muy bien. Quien es el autor, cual es la editorial y en que fecha fue publicado.
No importa que no este en la red, para eso existen las bibliotecas publicas.
Gracias. Noel.

Blag

Aunque me parece interesante, estoy de acuerdo con Binary......Cuando se crea un lenguaje de programación o un simulador de computadora como tu dices.....Lo mejor es no depender o utilizar una base como el C++, puesto que lo único que haces es hacer que el C++ interprete los comandos que tu quieres. Y eso es muy simple....Es como decirle.....si yo ingreso 'Escribir', utiliza Cout........

Si quieren un verdadero lenguaje de programación....Aqui les dejo este....Esta hecho con Delphi (Como repositorio) y Assembler para las instrucciones....Además genera archivos .exe para dos.

Spanish Viking

Lo hizo un amigo en inglés y ho hice la traducción completa al español......como se darán cuenta, quedó en el olvido, porque yo de ASM no se casi nada de nada.....pero si alquien se anima a revisarlo puede enviarle el código fuente.

Saludos,

Blag

kennethsleiker

Respondiendo Noel Solw:
Libro: C++ Como Programar
Autor: Deitel Y Deitel
Casa Editora: Prentice Hall
Segunda Edicion
ISBN: 970-17-0254-9
1184 Paginas
Año: 1999

Y para los demas como Blag, al parecer nadie ha comprendido cual fue la idea por la cual publique esta seccion de construir un simulador Simpletron. Yo no se lenguaje C++, lo estoy aprendiendo, por tal razon no puedo tratar de construir un lenguaje mas avanzado que C++, pero con el fin de aprender puedo comenzar con una practica mas simple, es decir construir el simulador.

Blag te equivocas al pensar que el simulador solo se trata de traducir comandos como el ejemplo que diste ( Escribir sustituir por cout ), me he dado cuenta que no solo es eso, se trata de la tecnica que he podido ir desarrollando con algo que a muchos les parece simple, este tipo de practica son la base para llegar a programar bien y mejor.

Este software yo no lo voy a vender ni se utilizara en ningun lado, es para fines de desarrollar practicas y tecnicas de programacion personal. Pero por lo que veo parece que no ha sido una buena idea, por tanto voy a cerrar el foro y continuare yo solo realizando mi ejercicio.

© Jonathan ©

No lo cierres... yo me uno a el aprendizaje... ahora comprendo el fin de todo esto, me interesaria participar, de hecho necesito aprender C++ un poco mas de lo que conozco... si me permites, quiero ayudar. Saludos

kennethsleiker

Bueno, en ese sentido gracias por el apoyo Jonathan.

Continuare con la practica.

Como pueden ver por el momento estamos en una face en la que nuestro computador solo puede trabajar con numeros enteros, ya llegaremos al punto que lo modificaremos para trabajar con punto flotante y representar valores hexadecimales internamente, tambien lo llegaremos a abilitar para trabajar con cadenas de caracteres, aun no se como lo haremos pero de eso se trata esto.

Esto es lo que yo tengo por el momento.

Hasta ahora no estoy utilizando clases u objetos, estoy comenzando a crear algunas clases para el manejo de las excepciones, tambien estoy pensando modificar la parte de captura de programa por una clase, bla bla bla, no hablare mucho, primero lo primero, concentrarme en la revision de errores en tiempo de ejecucion, ya estoy trabajando en eso. Cualquier duda compartamosla entre todos!.

Hasta horita!!!

Código: Text

 
/*******************************************************&#092;
* Descripcion: Emulador de una computadora Simpletron  *
* Autor: Lic. Kenneth S. Burgos                        *
* Fecha ultima compilacion: Agosto 26, 2004            *
* Estado: incompleto                                   *
&#092;*******************************************************/
 
#include &#60;iostream&#62;
#include &#60;cstdlib&#62;
#include &#60;cstdio&#62;
#include &#60;iomanip&#62;
 
class ExcepcionDivisionEntreCero {
public:
    ExcepcionDivisionEntreCero() 
      : message( &#34;&#092;n*** Intento de dividir entre cero ***&#34; ) { }
  const char* que() const { return message; }
private:
    const char *message;
};
 
using namespace std;
 
       //Tamano de la memoria principal
#define     _SIZEMEM    100
 
       //operaciones de entrada/salida
#define     READ      10
#define     WRITE      11
 
       //operaciones de carga/almacenamiento
#define     LOAD      20
#define     STORE      21
 
           //operaciones de aritmetica
#define     ADD      30
#define     SUBTRACT    31
#define     DIVIDE      32
#define     MULTIPLY    33
 
       //operaciones de transferencia de control
#define     BRANCH      40
#define     BRANCHNEG    41
#define     BRANCHZERO    42
#define     HALT      43
 
//Variables globales
int memory[ _SIZEMEM ]    = { 0 },  //tamano de la memoria
  accumulator        = 0,    //registro del acumulador
  counter          = 0,    //Loc. Mem. contiene instruccion en ejecucion
  operationCode      = 0,    //operacion actual (primero dos digitos)
  operand          = 0,    //Loc. Mem. opera Instr. actual (2do Dig. Der).
  instructionRegister    = 0;
 
void emptyingMemory()          //vaciado de la memoria principal de la computadora
{
    cout &#60;&#60; &#34;&#092;nREGISTROS:&#092;n&#34;;
    cout &#60;&#60; &#34;acumulador               &#34; 
       &#60;&#60; setiosflags( ios::internal | ios::showpos ) 
         &#60;&#60; setw(5) &#60;&#60; setfill( '0' )
         &#60;&#60; accumulator &#60;&#60; endl;
 
    cout.unsetf( ios::showpos );
    cout.fill( ' ' );
 
  cout &#60;&#60; &#34;contador                 &#34; 
        &#60;&#60; setw(5)
          &#60;&#60; counter &#60;&#60; endl;
 
    cout &#60;&#60; &#34;registro de instruccion  &#34;
       &#60;&#60; setiosflags( ios::showpos ) 
         &#60;&#60; setw(5) &#60;&#60; setfill( '0' )
       &#60;&#60; instructionRegister &#60;&#60; endl;
 
    cout.unsetf( ios::showpos );
    cout.fill( ' ' );
 
    cout &#60;&#60; &#34;codigo de operacion      &#34;
       &#60;&#60; setw(5)
         &#60;&#60; operationCode &#60;&#60; endl;
 
    cout &#60;&#60; &#34;operando                 &#34; 
       &#60;&#60; setw(5)
       &#60;&#60; operand &#60;&#60; endl;
 
    cout &#60;&#60; &#34;&#092;n&#34;
       &#60;&#60; &#34;MEMORIA:&#092;n&#34;;
 
  cout &#60;&#60; &#34;    &#34;;
  for( int i = 0; i &#60;= 9; i++ ) cout &#60;&#60; setw(5) &#60;&#60; i &#60;&#60; ' ';
  cout &#60;&#60; endl;
 
  for( int line = 0; line &#60;= 90; line += 10 ) {
      cout &#60;&#60; setw(3) &#60;&#60; line &#60;&#60; ' ';
     for( int mem = 0; mem &#60;= 9; mem++ ) {
       cout &#60;&#60; setiosflags( ios::internal | ios::showpos )
         &#60;&#60; setw(5)
            &#60;&#60; setfill( '0' ) 
          &#60;&#60; memory[ line + mem ] &#60;&#60; ' '
          &#60;&#60; setfill( ' ' )
           &#60;&#60; resetiosflags( ios::showpos );
       if( mem == 9 ) cout &#60;&#60; endl;
    }
  }
  system( &#34;pause&#34; );
}
 
void clearAll()                      //utileria para limpiar todos los registros de procesamiento
{
  for(int loc = 0; loc &#60;= 99; loc++ )
    memory[ loc ]  = 0;
  accumulator      = 0;
  counter        = 0;
  operationCode    = 0;
  operand        = 0;
  instructionRegister  = 0;
}
 
int main()
{
  while(1) {
    system( &#34;cls&#34; );
      
    clearAll();
      cout   &#60;&#60; &#34;*** Bienvenido a Simpletron! ***&#092;n&#092;n&#34;
      &#60;&#60; &#34;*** Por favor introduzca su programa una instrucci¢n ***&#092;n&#34;
      &#60;&#60; &#34;*** (o dato) a la vez.  Presentare ***&#092;n&#34;
      &#60;&#60; &#34;*** la localidad y un signo de interrogaci¢n (?). ***&#092;n&#34;
      &#60;&#60; &#34;*** Despues usted tecleara la palabra para esa localidad. ***&#092;n&#34;
      &#60;&#60; &#34;*** Para detener la introducci¢n de su programa, ***&#092;n&#34;
      &#60;&#60; &#34;*** teclee el centinela -9999. ***&#092;n&#092;n&#34;;
 
    do {  //Capturando el programa y colocandolo en la memoria
      do {
        cout &#60;&#60; counter &#60;&#60; &#34; ? &#34;;
        cin &#62;&#62; memory[ counter ];
      } while( memory[ counter ] &#60; -9999 || memory[ counter ] &#62; 9999 );
      ++counter;
    } while( memory[ counter - 1 ] != -9999 );
    counter = 0;
 
    cout   &#60;&#60; &#34;&#092;n*** Se ha completado la carga del programa ***&#092;n&#34;
      &#60;&#60; &#34;*** Inicia la ejecuci¢n del programa       ***&#092;n&#092;n&#34;;
 
    while( operationCode != HALT ) {
        instructionRegister  = memory[ counter ];
      operationCode    = instructionRegister / _SIZEMEM;
      operand        = instructionRegister % _SIZEMEM;
 
      switch( operationCode ) {
        case READ:
          cout &#60;&#60; &#34; ? &#34;;
          cin &#62;&#62; memory[ operand ];
          ++counter;
          break;
         case WRITE:
          cout &#60;&#60; memory[ operand ] &#60;&#60; endl;
          ++counter;
          break;
        case LOAD:
          accumulator = memory[ operand ];
          ++counter;
          break;
        case STORE:
          memory[ operand ] = accumulator;
          ++counter;
          break;
        case ADD:
          accumulator += memory[ operand ];
          ++counter;
          break;
        case SUBTRACT:
          accumulator -= memory[ operand ];
          ++counter;
          break;
        case DIVIDE:
          try {
              if( memory[ operand ]== 0 )
                throw ExcepcionDivisionEntreCero();
              else
                 accumulator /= memory[ operand ];
             }
               catch( ExcepcionDivisionEntreCero ex ) {
                   cout &#60;&#60; &#34;&#092;nOcurrio una excepcion:&#34;
                      &#60;&#60; ex.que();
                 cout &#60;&#60; &#34;&#092;n*** Terminacion anormal de Simpletron ***&#34;;
               emptyingMemory();
               operationCode = 43;
             }             
                ++counter;
          break;
        case MULTIPLY:
          accumulator *= memory[ operand ];
          ++counter;
          break;
        case BRANCH:
          counter = operand;
          break;
        case BRANCHNEG:
          if( accumulator &#60; 0 ) counter = operand;
          break;
        case BRANCHZERO:
          if( accumulator == 0 ) counter = operand;
          break;
        case HALT:
          cout &#60;&#60; &#34;&#092;n*** Ha terminado la ejecuci¢n de Simpletron ***&#34;
             &#60;&#60; &#34;&#092;n&#092;n&#34;;
          emptyingMemory();
          break;
        default:
          cout &#60;&#60; &#34;&#092;n*** Instruci¢n invalida en tiempo de ejecuci¢n ***&#092;n&#34;;
          operationCode = HALT;
          emptyingMemory();
      } //switch
    } //while
  } //while
    return 0;
} //main
 
 

kennethsleiker

Muchachos me la he pasado investigando sobre el desbordamiento de datos, es lo que voy a implementarle a mi simulador en la seccion donde se eligen las operaciones a realizar.

Esta noche continuare investigando sobre el tema ademas del manejo de excepciones, para implementarlo.

El desbordamiento de datos en mi codigo fuente puede ocurrir en cualquier operacion que de como resultado valores fuera del rango -9999 hasta 9999, debemos evitar estos errores fatales, los cuales solo suceden en tiempo de ejcucion y no son detectados por el compilador.

Hasta luego.

Blag

No te lo tomes a mal kennethsleiker, no lo dije con mala intención, ni tampoco pienso que sea un mal proyecto.......

Creo que no había entendido bien tu post........disculpa

Si recién estás aprendiendo C++.....Me parece excelente que quieras hacer un proyecto como ese

Me gustaría colaborar contigo, pero la verdad es que ando muy ocupado....eso sí, estaré pendiente de tus avances y si hay algo en lo que necesites ayuda, puedes contar conmigo

Bueno pues.....Mucha suerte!!!

Saludos,

Blag

kennethsleiker

Muchas gracias Blag, que bueno que estas muy ocupado eso solo significa que vendran tiempos muy buenos para usted,

, hasta luego hermano.

JuanK

Citar

No te lo tomes a mal kennethsleiker, no lo dije con mala intención, ni tampoco pienso que sea un mal proyecto....... Creo que no había entendido bien tu post........disculpa

Si recién estás aprendiendo C++.....Me parece excelente que quieras hacer un proyecto como ese

Me gustaría colaborar contigo, pero la verdad es que ando muy ocupado....eso sí, estaré pendiente de tus avances y si hay algo en lo que necesites ayuda, puedes contar conmigo

Bueno pues.....Mucha suerte!!!

Saludos,

Blag

igual

me parece un excelente proyecto,
ojala lo puedas llevar a cabo, pues hay muchos que frecuentan el foro solo para que les hagan las cosas o las atreas y nunca salen de alli..
te felicito.

kennethsleiker

Gracias Juank

kennethsleiker

Para los de la version C ( no C++ )

Por si no lo sabian, me he dado cuenta que hay centenares de ejemplos en internet sobre SML ( simple machine languaje ), aqui les dejo el codigo de alguien que hice lo mismo que hice yo pero el lo hizo con instrucciones de C ( no C++ ).

Código: Text

 
#include &#60;stdio.h&#62;
#include &#60;math.h&#62;
#include &#60;stdlib.h&#62;
 
 
/******OPERATION CODE DEFINITIONS********/
//input/output
#define READ 10
#define WRITE 11
#define READSTR 12
#define WRITESTR 13
 
//load/store
#define LOAD 20
#define STORE 21
 
//arithmetic
#define ADD 30
#define SUBTRACT 31
#define DIVIDE 32
#define MULTIPLY 33
#define MODULUS 34
#define EXPONENT 35
 
//transfer of control
#define BRANCH 40
#define BRANCHNEG 41
#define BRANCHZERO 42
#define HALT 43
/****************************************/
#define TRUE 1
#define FALSE 0
#define MEMLOCATIONS 100
 
 
//function prototypes
void loadProg(void);
void executeProg(void);
void memoryDump(void);
 
//external variables
int memory[MEMLOCATIONS] = {0};
int accumulator = 0,
    instructionCounter = 0,
    instructionRegister = 0,
  operationCode = 0,
  operand = 0;
 
 
 
main() {
  
  loadProg();
  executeProg();
  printf(&#34;&#092;n&#34;);
  memoryDump();
  return 0;
}
 
 
void loadProg(void) {
  extern int memory[MEMLOCATIONS];
  extern int accumulator, instructionCounter, instructionRegister,
              operationCode, operand;
  int i = 0, curr_memValue = 0;
 
 
  printf(&#34;&#092;n*** Welcome to Simpletron! ***&#092;n&#34;);
  printf(&#34;&#092;n*** Please enter your program one instruction ***&#34;);
  printf(&#34;&#092;n*** (or data word) at a time. I will type the ***&#34;);
  printf(&#34;&#092;n*** location number and a question mark (?).  ***&#34;);
  printf(&#34;&#092;n*** You then type the word for that location. ***&#34;);
  printf(&#34;&#092;n*** Type the sentinel -99999 to stop entering ***&#34;);
  printf(&#34;&#092;n*** your program. ***&#092;n&#34;);
 
  while(i &#60; MEMLOCATIONS) {
    printf(&#34;%02i ? &#34;, i);
    scanf(&#34;%i&#34;, &curr_memValue);
 
    if (curr_memValue == -99999) break;
    if ((curr_memValue &#60; -9999) || (curr_memValue &#62; 9999)) {
      printf(&#34;*** Invalid instruction ***&#092;n&#34;);
    } else {
      memory[i] = curr_memValue;
      i++;
    }
  }
 
  printf(&#34;*** Program loading completed ***&#34;);
 
}
 
 
void executeProg(void) {
  extern int memory[MEMLOCATIONS];
  extern int accumulator, instructionCounter, instructionRegister,
              operationCode, operand;
  int was_control_transfer = FALSE;
  int should_halt = FALSE;
  int error_condition_halt = FALSE;
 
 
  printf(&#34;&#092;n*** Program execution begins  ***&#34;);
  
  //pass through every location in memory and perform specified operations
  instructionCounter = 0;
  while(instructionCounter &#60; MEMLOCATIONS) {
    //update flags
    was_control_transfer = FALSE;
    should_halt = FALSE;
    error_condition_halt = FALSE;
    
    //update registers
    instructionRegister = memory[instructionCounter];
    operationCode = instructionRegister/100;
    operand = instructionRegister%100;
    
    //determine type of operation
    switch(operationCode) {
    case READ:
      printf(&#34;&#092;n? &#34;);
      scanf(&#34;%d&#34;, &memory[operand]);
      break;
    case WRITE:
      printf(&#34;&#092;n%i&#34;, memory[operand]);
      break;
    case LOAD:
      accumulator = memory[operand];
      break;
    case STORE:
      memory[operand] = accumulator;
      break;
    case ADD:
      accumulator += memory[operand];
      break;
    case SUBTRACT:
      accumulator -= memory[operand];
      break;
    case DIVIDE:
      if (memory[operand] == 0) {
        error_condition_halt = TRUE;
        printf(&#34;&#092;n*** Attempt to divide by zero ***&#34;);
      } else accumulator /= memory[operand];
      break;
    case MULTIPLY:
      accumulator *= memory[operand];
      break;
    case MODULUS:
      accumulator %= memory[operand];
      break;
    case EXPONENT:
      accumulator = (int) pow(accumulator, memory[operand]);
      break;
    case BRANCH:
      instructionCounter = operand;
      was_control_transfer = TRUE;
      break;
    case BRANCHNEG:
      if(accumulator &#60; 0) {
      instructionCounter = operand;
      was_control_transfer = TRUE;
      }
      break;
    case BRANCHZERO:
      if(accumulator == 0) {
      instructionCounter = operand;
      was_control_transfer = TRUE;
      }
      break;
    case HALT:
      should_halt = TRUE;
      break;
    default :
      error_condition_halt = TRUE;
      printf(&#34;&#092;n*** Invalid operation code ***&#34;);
      break;
    }//end of switch
 
    //if it was a control transfer, instructionCounter already updated
    if(was_control_transfer == FALSE) ++instructionCounter;
    
    //check if there should be a normal halt
    if(should_halt == TRUE) {
      printf(&#34;&#092;n*** Simpletron execution terminated ***&#34;);
      break;
    }
    
    //check if there was an error condition
    if(error_condition_halt == TRUE) {
      printf(&#34;&#092;n*** Simpletron execution abnormally terminated ***&#34;);
      break;
    }
  
  }//end of while
  
  printf(&#34;&#092;n&#34;);
  system(&#34;pause&#34;);
  //memory dump for debug under error condition
  if (error_condition_halt == TRUE) memoryDump();
 
}
 
 
void memoryDump(void) {
  extern int memory[MEMLOCATIONS];
  extern int accumulator, instructionCounter, instructionRegister,
              operationCode, operand;
  int i = 0;
  
 
  printf(&#34;&#092;nREGISTERS:&#34;);
  printf(&#34;&#092;naccumulator          %+05i&#34;, accumulator);
  printf(&#34;&#092;ninstructionCounter      %02i&#34;, instructionCounter);
  printf(&#34;&#092;ninstructionRegister  %+05i&#34;, instructionRegister);
  printf(&#34;&#092;noperationCode           %02i&#34;, operationCode);
  printf(&#34;&#092;noperand                 %02i&#34;, operand);
 
  printf(&#34;&#092;nMEMORY:&#34;);
  printf(&#34;&#092;n       0     1     2     3     4     5     6     7     8     9&#34;);
  for(i = 0; i &#60;= (MEMLOCATIONS-10); i+=10) {
    printf(&#34;&#092;n%2i %+05i %+05i %+05i %+05i %+05i %+05i %+05i %+05i %+05i %+05i&#34;,
          i, memory[i], memory[i+1], memory[i+2], memory[i+3], memory[i+4], memory[i+5], memory[i+6], memory[i+7], memory[i+8], memory[i+9]);
    if (((i/10) % 10) == 9) {
      printf(&#34;&#092;n&#34;); system(&#34;pause&#34;);
    }
  }
 
  printf(&#34;&#092;n&#34;);
}
 
 

kennethsleiker

Estoy por finalizar mi emulador, mañana publicare el codigo fuente, es una version que mejorada para evitar el desbordamiento de datos en el registro del acumulador.

kennethsleiker

Bueno chicos, aqui esta lo prometido, he culminado mi emulador cumpliendo con todos los requisitos enunciado al principio de este foro. Es para mi una gran satisfaccion haber cumplido esta meta y a la vez he aprendido tecnicas nuevas con esta practica.

Es muy probable que en otro momento inicie un nuevo foro para crear un compilador de doble pasada a nuestro emulador, ya les avisare cuando llegue a ese punto ;-), por el momento voy a ver que mas puedo hacerle a mi emulador, hasta luego y buena suerte muchachos, haaa, les dejo un anexo, es un archivo comprimido con el codigo fuente.

Blag

Que bien

Felicitaciones kennethsleiker, lo pruebo en la noche y te doy mi opinión

Saludos,

Blag

kennethsleiker

Grax Blag, recuerda que no soy un Veterano como tu, he visitado tu home page y tambien revise el manual que escribiste de programacion. Tu tienes una basta experiencia en la materia, felicidades a usted tambien hermano.

Aunque he terminado lo que el ejercicio me pidio hay algunas mejoras que pienso implementarle para refinarlo antes de construirle un compilador de alto nivel, por ejemplo:

1-Aumentarle la memoria a 1000 localidades
2-Hacer que pueda efectuar calculos de modulo
3-Que realice calculos exponenciales
4-Modificarlo para que emplee valores hexadecimales, en lugar de valores enteros, para representar instrucciones en SML.
5-Que permita enviar un salto de linea a la salida.
6-Que pueda procesar valores de punto flotante, ademas de valores enteros.
7-Modificarlo a fin de que pueda manejar entrada de cadenas.
8-Modificarlo a fin de que pueda manejar salida de cadenas.

Para mi cada punto es un nuevo reto con el fin de agudizar mi aprendizaje sobre el lenguaje orientado a objeto en este caso C++ .

Cuando lo tenga resuelto lo publicare tambien con lujo de detalles :-) .

Hasta luego muchachos.