Chirango » programar http://www.chirango.com Cultura TV Tecnologí­a Software Mexico Wed, 11 May 2011 00:54:58 +0000 http://wordpress.org/?v=2.9.2 en hourly 1 Simulador URM http://www.chirango.com/simulador-urm/ http://www.chirango.com/simulador-urm/#comments Fri, 17 Oct 2008 03:26:18 +0000 escusado http://www.chirango.com/?p=598
Hace una semana me dejaron de tarea en la escuela, programar un ehm.. “simulador” de una maquina URM (Unlimited Register Machine) un modelo de computadora muy primitivo y básico, aunque es de los primeros modelos desarrollados, ha sido probado que puede resolver algoritmos de alta complejidad.

Esto les podrá servir un poco si necesitan hacer algo parecido, ya que en la internet, hay pocos ejemplos de este modelo, sumo uno mas con este.

El programa está escrito en C puro básicamente:

El programa lee instrucciones desde un txt en este formato:

Z(3)
Z(4)
Z(5)
S(4)
S(5)
J(1,5,8)
J(1,1,4)
Z(5)
S(3)
J(2,3,12)
J(1,1,4)

(Que en este caso es una multiplicación).
carga las instrucciones a un arreglo
y finalmente un switch lee y ejecuta las instrucciones.

Muy sencillo, se puede mejorar muchísimo con objetos, funciones, etc.

acá el code ->

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5.  
  6. /*www.chirango.com
  7. Programado por Toily el 16 de Octubre 2008 para la Fundación Arturo Rosenblueth
  8. rosenblueth.mx
  9. Objetivo didáctico*/
  10.  
  11. int main() {
  12.         int tamano = 0; //inicializacoón de la variable que determina el tamaño del arreglo
  13.         int lin,col; //navega arreglo para imprimirlo
  14.         int i =0; //navega arreglo para llenarlo
  15.         int j =0; //navega arreglo para llenarlo
  16.         char c;     //char para capturar caracter del archivo
  17.         char valor[1024]; //auxiliar para baajar los valores que se leen en formato char a int en el arreglo de instrucciones
  18.         valor[0] = ‘\0′; //inicializar valor como cadena vacia
  19.  
  20.        
  21.         //Necesario para abrir el archivo
  22.         FILE *file;
  23.         file = fopen("suma.txt", "r");  //nombre de archivo
  24.        
  25.         /* abrir archivo */
  26.         if(file==NULL) {
  27.                 printf("No existe el archivo.\n");
  28.                 return 1;
  29.         }
  30.         else {
  31.                 printf("Leyendo archivo y cargando programa…\n");
  32.                 //Archivo abierto
  33.                 //Leer archivo
  34.                 /*calcular el tamaño del programa basado en el numero de) encontrados*/
  35.                 while(1) {
  36.                         c = fgetc(file);
  37.                         if(c!=EOF) {
  38.                                 if(c==’)'){ //calcular el tamaño del programa para crear el arreglo…
  39.                                         tamano++;
  40.                                 }
  41.                         }
  42.                         else {
  43.                                 printf("El programa tiene %i lineas\nCargando programa al arreglo de instrucciones…\n",tamano);
  44.                 fclose(file);
  45.                                 break; //fin del archivo
  46.                         }
  47.                 }
  48.                 file = fopen("suma.txt", "r");
  49.                 int instrucciones [tamano][4]; //crear arreglo basado en el tamaño del programa o el numero de ) que haya encontrado
  50.  
  51.                 lin=0;
  52.                 col=0;
  53.                 while(1) {
  54.                         c = fgetc(file);
  55.                         if(c!=EOF) {
  56.                                
  57.                         if(c==’\n’) c=’\0′; //hack para corregir el salto de linea en la cadena y que no pase al arreglo de instrucciones
  58.                                
  59.                                 /*Cargado de programa al arreglo
  60.                                  instrucciones [lin] [col]
  61.                                  por ser un arreglo de enteros, las instrucciones corresponden así:
  62.                                  Z = 0
  63.                                  S = 1
  64.                                  J = 2
  65.                                  C = 3
  66.                                  */     
  67.                         switch (c) {
  68.                                 case ‘Z’:
  69.                                         c=’0′;
  70.                                         break;
  71.                                 case ‘S’:
  72.                                         c=’1′;
  73.                                         break;
  74.                                 case ‘J’:
  75.                                         c=’2′;
  76.                                         break;
  77.                                 case ‘C’:
  78.                                         c=’3′;
  79.                                         break;
  80.                                 default:
  81.                                         break;
  82.                         }       
  83.                                
  84.                                 if( c==’(‘ || c==’,’ || c==’)’ ) {
  85.                                 //      Navegacion dentro del arreglo para acomodar los numeros en sus lugares y,0 para instrucciones);
  86.                                         if(c==’(‘ || c==’,'){
  87.                                                 col++;
  88.                                         }
  89.  
  90.                                         if(c==’)'){
  91.                                                 lin++;
  92.                                                 col=0;
  93.                                         }       
  94.                                        
  95.                                         memset(valor, 0, 1024); //resetea la variable valor para poder ser usada de nuevo
  96.                                 }else{ 
  97.                                         valor[strlen(valor)] = c;
  98.                                         valor[strlen(valor)] = ‘\0′;
  99.                                 }
  100.                                 instrucciones[lin][col] = atoi(valor); //atoi convierte de cadena a entero para bajarlo al arreglo int
  101.                         }
  102.                         else {
  103.                                 printf("———–\nPrograma cargado con éxito:\n\n");
  104.                                 break; //fin del archivo
  105.                         }
  106.                 }
  107.                 for (i = 0; i < lin; i++){//muestra el contenido del programa
  108.                         for (j = 0; j < 4; j++){
  109.                                 printf(" %i ",instrucciones[i] [j]);
  110.                         }
  111.                         printf("\n");
  112.                 }
  113.                 printf("\nCerrando archivo…\n");
  114.                 fclose(file);
  115. /*****************************************  TERMINA LECTURA DE ARCHIVO y no mames falta lo demás xD  ************************/        
  116.                  int registros[256]; //tira de registros manipulables;
  117.                 //int registros[6] = { 2, 2, 3, 0, 5, 6 };
  118.  
  119.                
  120.                 int cabezal=0; //variable para recorrer el arreglo de instrucciones
  121.                 //int largo=0;//conocer el tamaño de la tira de registros
  122.                 int k=0;//auxiliar para contar
  123.                
  124.                
  125.                 printf("\nIndique los valores de los registros (-1 para terminar)\n");
  126.                 while(1){//llenado de la tira de registros
  127.                         printf("\n%i: ",k+1);
  128.                         scanf( "%d", &registros[k]);
  129.                         //if(k>0 && registros[k]>registros[k-1]) largo = registros[k] //conocer el valor mas alto para crear la tabla de registros
  130.                         if(registros[k]<0)break;
  131.                         k++;
  132.                 }
  133.                
  134.                  
  135.                 /*
  136.                 Z = 0
  137.                 S = 1
  138.                 J = 2
  139.                 C = 3
  140.                 */
  141.  
  142.                 while(1){
  143.                         switch (instrucciones[cabezal][0]) {
  144.                                 case 0: //Z crea un 0 en el registro X
  145.                                         registros[ (instrucciones[cabezal][1])-1 ]=0; //-1 para la correccion del espacio ya que el array empiezxa en 0
  146.                                         cabezal++;
  147.                                         break;
  148.                                 case 1:
  149.                                         registros[ (instrucciones[cabezal][1])-1 ]++;
  150.                                         cabezal++;
  151.                                         break;
  152.                                 case 2:
  153.                                         if( registros[ (instrucciones[cabezal][1])-1 ] == registros[ (instrucciones[cabezal][2])-1 ]){
  154.                                                 cabezal= instrucciones[cabezal][3]-1;
  155.                                         }else{
  156.                                                 cabezal++;
  157.                                         }
  158.                                         break;
  159.                                 case 3:
  160.                                         registros[ (instrucciones[cabezal][2])-1 ]=registros[ (instrucciones[cabezal][1])-1 ];
  161.                                         cabezal++;
  162.                                         break;
  163.                                 default:
  164.                                         break;
  165.                         }
  166.                        
  167.                         if(cabezal==lin) break;
  168.                 }
  169.                
  170.                 for (j = 0; j < 10; j++){
  171.                         printf("%i: %i \n",j+1,registros[j]);
  172.                 }
  173.                
  174.                 return 0;
  175.         }
  176. }
  177.  
  178.  

Lamentablemente ( y lo acepto xD jaja) estoy OXIDADISMO en C así que el programa esta bastante sucio, estructuradisimo, y mal muy mal hecho, PERO lo interesante es que explica el algoritmo de manera MUY simple.
Saludos banda geeky

]]> http://www.chirango.com/simulador-urm/feed/ 1