elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Los 10 CVE más críticos (peligrosos) de 2020


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  modos de direccionamiento indexado de 5/9/16 bits		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: modos de direccionamiento indexado de 5/9/16 bits  (Leído 2,687 veces)
m@o_614


Desconectado Desconectado

Mensajes: 389


Ver Perfil
modos de direccionamiento indexado de 5/9/16 bits
« en: 5 Marzo 2014, 21:32 pm »
Saludos

tengo el siguiente código en el que tengo una cadena de nombre operando como la siguiente:

2983,X

y tengo que averiguar que modo de direccionamiento indexado es, las reglas son:

Modo indizado de 5 bits. en el operando se representan números decimales con un rango de -16 a 15, despues del valor debe de haber siempre una coma, y después el nombre de registro que puede ser X,Y,SP o PC

Modo indizado de 9 bits. Es lo mismo que en el de arriba solo que los numeros decimales de  rango desde -256 a -17 y de 16 a 255.

Modo indizado de 16 bits. Es lo mismo solo que tiene rango de 256 a 65535.

para estos tres modos de direccionamiento ya tengo el código que funciona bien, pero tengo que agregarle otro modo de direccionamiento un poco diferente y no se bien cómo hacerlo:

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <math.h>
  5. #define CERO 0
  6. #define MAX_DIRECTO 255
  7. #define MAX_IDX_INDIRECTO 65535
  8. #define MIN_IDX_9BITS 16
  9. #define MAX_IDX_9BITS 255
  10. #define MIN_EXT_IDX16BITS 256
  11. #define MAX_EXT_IDX16BITS 65535
  12. #define MIN_IDX_5BITS -16
  13. #define MAX_IDX_5BITS 15
  14. #define MIN_9BITS_NEG -256
  15. #define MAX_9BITS_NEG -17
  16. #define INMEDIATO '#'
  17. #define HEXADECIMAL '$'
  18. #define OCTAL '@'
  19. #define BINARIO '%'
  20. #define INDEXADO_INDIRECTO '['
  21.  
  22. int verificarRegistro(char *cadena);
  23. void verificarRangoIndexado_5_9_16bits(int num);
  24. void modoDireccionamiento(char *operando);
  25. void indexado_5bits_9bits_16bits(char *operando,int x);
  26. int convertir_a_numero(char *cadena);
  27.  
  28. int main()
  29. {
  30.     char *operando = "5,X";
  31.     modoDireccionamiento(operando);
  32.     return 0;
  33. }
  34.  
  35. void modoDireccionamiento(char *operando)
  36. {
  37.     int car;
  38.     car = operando[0];
  39.     switch(car)
  40.     {
  41.         case '-':
  42.            x = 1;
  43.            indexado_5bits_9bits_16bits(operando,x);
  44.            break;
  45.         case '0':
  46.         case '1':
  47.         case '2':
  48.         case '3':
  49.         case '4':
  50.         case '5':
  51.         case '6':
  52.         case '7':
  53.         case '8':
  54.         case '9':
  55.            x = 0;
  56.            indexado_5bits_9bits_16bits(operando,x);
  57.            break;
  58.         default:
  59.            printf("Error");
  60.     }
  61. }
  62.  
  63. void indexado_5bits_9bits_16bits(char *operando,int x)
  64. {
  65.     int i,j,num;
  66.     char *cadena = NULL,c[2],*cadena2 = NULL;
  67.     cadena = calloc(6,sizeof(char));
  68.     cadena2 = calloc(2,sizeof(char));
  69.     for(i = x;operando[i] != ',';i++)
  70.     {
  71.         sprintf(c,"%c",operando[i]);
  72.         strcat(cadena,c);
  73.     }
  74.     for(j = i+1;operando[j] != '\0';j++)
  75.     {
  76.         sprintf(c,"%c",operando[j]);
  77.         strcat(cadena2,c);
  78.     }
  79.     num = convertir_a_numero(cadena);
  80.     if(x == 1)
  81.        num = num*(-1);
  82.     if(verificarRegistro(cadena2))
  83.        verificarRangoIndexado_5_9_16bits(num);
  84.     else
  85.        printf("\nRegistro invalido para modo de direccionamiento indexado Indirecto\n");
  86. }
  87.  
  88. int convertir_a_numero(char *cadena)
  89. {
  90.     int i,j,entero,numero = 0,lon;
  91.     int potencias[] = {1,10,100,1000,10000};
  92.     lon = strlen(cadena);
  93.     for(i = 0,j = lon-1;cadena[i] != '\0';i++,j--)
  94.     {
  95.         entero = cadena[i]-48;
  96.         numero += entero*potencias[j];
  97.     }
  98.     return numero;
  99. }
  100.  
  101. void verificarRangoIndexado_5_9_16bits(int num)
  102. {
  103.     if(num >= MIN_IDX_5BITS && num <= MAX_IDX_5BITS)
  104.        printf("Indexado de 5 bits, (IDX)\n");
  105.     else if((num >= MIN_9BITS_NEG && num <= MAX_9BITS_NEG)||(num >= MIN_IDX_9BITS && num <= MAX_IDX_9BITS))
  106.        printf("Indexado de 9 bits, (IDX)\n");
  107.     else if(num >= MIN_EXT_IDX16BITS && num <= MAX_EXT_IDX16BITS)
  108.        printf("Indexado de 16 bits, (IDX)\n");
  109.     else
  110.     {
  111.         printf("Error: El rango valido de un direccionamiento indexado de 5 bits es de -16 a 15\n");
  112.         printf("el de un direccionamiento indexado de 9 bits es de -256 a -17 y de 16 a 255\n");
  113.         printf("y el de un direccionamiento indexado de 16 bits es de 256 a 65535\n");
  114.     }
  115. }
  116.  
  117. int verificarRegistro(char *cadena)
  118. {
  119.     int i;
  120.     char *registro[] = {"X","Y","SP","PC"};
  121.     for(i = 0;i < 4;i++)
  122.     {
  123.         if((strcmp(cadena,registro[i])) == 0)
  124.            return 1;
  125.     }
  126.     return 0;
  127. }
  128.  

y el direccionamiento que le tengo que agregar dice:

Modo indexado de Pre/Post Incremento Decremento: sus valores númericos tienen rango de 1 a 8, después del valor debe de haber siempre una coma y después de la coma hay un signo positivo o negativo y despues el nombre de registro X,Y o SP, algo como: +X,-SP..O tambien puede tener primero el nombre del registro y despues el signo como: X+,SP-

Pero no tengo una idea clara de como hacer las modificaciones al codigo que ya tengo para agregarle esto,el problema es que los registros despues de la coma son diferentes a los de los otros 3 direccionamientos, alguna idea??

gracias de antemano
« Última modificación: 5 Marzo 2014, 21:33 pm por m@o_614 » En línea
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: modos de direccionamiento indexado de 5/9/16 bits
« Respuesta #1 en: 6 Marzo 2014, 12:14 pm »
El código que usas para convertir a números es un poco raro... sobretodo porque arrastras el bit de negativo para hacer la conversión final en otro sitio diferente.

Además, el offset en los 16 bits es siempre positivo... al menos según el enunciado que has copiado.

He desacoplado los diferentes tipos de indexados para dotarlo de más flexibilidad y capacidad de crecimiento.

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. #define _4BITS  0x0F
  6. #define MIN_IDX_5BITS -16
  7. #define MAX_IDX_5BITS 15
  8. #define MIN_IDX_9BITS -256
  9. #define MAX_IDX_9BITS 255
  10. #define MIN_IDX_16BITS 256
  11. #define MAX_IDX_16BITS 65535
  12.  
  13. int verificarRegistro(char *cadena);
  14. void verificarRangoIndexado_5_9_16bits(int num);
  15. void modoDireccionamiento(char *operando);
  16. void indexado_5bits_9bits_16bits(char *operando,int x);
  17. int indexado_5bits( int offset, char* registro );
  18. int indexado_9bits( int offset, char* registro );
  19. int indexado_16bits( int offset, char* registro );
  20. int indexado_indirecto( int offset, char* registro, int min, int max );
  21. int indexado_preincremento( int offset, char* registro );
  22. int indexado_postincremento( int offset, char* registro );
  23.  
  24. int convertir_a_numero(char *cadena);
  25.  
  26. int main()
  27. {
  28.   printf( "5 bits ----------\n");
  29.   char *operando = "15,X";
  30.   modoDireccionamiento(operando);
  31.   operando = "-16,Y";
  32.   modoDireccionamiento(operando);
  33.  
  34.   printf( "9 bits ----------\n");
  35.   operando = "16,SP";
  36.   modoDireccionamiento(operando);
  37.   operando = "-17,PC";
  38.   modoDireccionamiento(operando);
  39.   operando = "255,X";
  40.   modoDireccionamiento(operando);
  41.   operando = "-256,Y";
  42.   modoDireccionamiento(operando);
  43.  
  44.   printf( "16 bits ---------\n");
  45.   operando = "256,SP";
  46.   modoDireccionamiento(operando);
  47.   operando = "65535,PC";
  48.   modoDireccionamiento(operando);
  49.  
  50.   printf( "preincremento ---\n");
  51.   operando = "8,+PC";
  52.   modoDireccionamiento(operando);
  53.   operando = "4,-PC";
  54.   modoDireccionamiento(operando);
  55.  
  56.   printf( "postincremento --\n");
  57.   operando = "1,PC+";
  58.   modoDireccionamiento(operando);
  59.   operando = "7,PC-";
  60.   modoDireccionamiento(operando);
  61.  
  62.   printf( "No validos -----\n" );
  63.   operando = "-6000,PC";
  64.   modoDireccionamiento(operando);
  65.   operando = "200,A";
  66.   modoDireccionamiento(operando);
  67.   operando = "24,+PC";
  68.   modoDireccionamiento(operando);
  69.   return 0;
  70. }
  71.  
  72. void modoDireccionamiento(char *operando)
  73. {
  74.   char buffer[255];
  75.   strcpy( buffer, operando );
  76.  
  77.   int length = strlen( operando );
  78.   char* op1 = strtok( buffer, "," );
  79.   char* op2 = strtok( NULL, "," );
  80.  
  81.   int continuar = 1;
  82.   if ( strlen( op1 ) != length && strlen( op2 ) != 0 )
  83.   {
  84.     int offset = convertir_a_numero( op1 );
  85.  
  86.     continuar = !indexado_5bits( offset, op2 );
  87.  
  88.     if ( continuar )
  89.       continuar = !indexado_9bits( offset, op2 );
  90.  
  91.     if ( continuar )
  92.       continuar = !indexado_16bits( offset, op2 );
  93.  
  94.     if ( continuar )
  95.       continuar = !indexado_postincremento( offset, op2 );
  96.  
  97.     if ( continuar )
  98.       continuar = !indexado_preincremento( offset, op2 );
  99.   }
  100.  
  101.   if ( continuar )
  102.     printf( "Indexado no reconocido.\n" );
  103. }
  104.  
  105. int indexado_5bits( int offset, char* registro )
  106. {
  107.   int ok = indexado_indirecto( offset, registro, MIN_IDX_5BITS, MAX_IDX_5BITS );
  108.  
  109.   if ( ok )
  110.     printf("Indexado de 5 bits, (IDX)\n");
  111.  
  112.   return ok;
  113. }
  114.  
  115. int indexado_9bits( int offset, char* registro )
  116. {
  117.   int ok = indexado_indirecto( offset, registro, MIN_IDX_9BITS, MAX_IDX_9BITS );
  118.  
  119.   if ( ok )
  120.     printf("Indexado de 9 bits, (IDX)\n");
  121.  
  122.   return ok;
  123. }
  124.  
  125. int indexado_16bits( int offset, char* registro )
  126. {
  127.   int ok = indexado_indirecto( offset, registro, MIN_IDX_16BITS, MAX_IDX_16BITS );
  128.  
  129.   if ( ok )
  130.     printf("Indexado de 16 bits, (IDX)\n");
  131.  
  132.   return ok;
  133. }
  134.  
  135. int indexado_indirecto( int offset, char* registro, int min, int max )
  136. {
  137.   int ok = ( offset >= min && offset <= max );
  138.  
  139.   if ( ok )
  140.     ok = verificarRegistro( registro );
  141.  
  142.   return ok;
  143. }
  144.  
  145. int indexado_preincremento( int offset, char* registro )
  146. {
  147.   int ok = ( ( offset & _4BITS ) == offset );
  148.  
  149.   if ( ok )
  150.     ok = (registro[0] == '-') || (registro[0] == '+');
  151.  
  152.   if ( ok )
  153.     ok = verificarRegistro( registro + 1 );
  154.  
  155.   if ( ok )
  156.     printf( "Indexado con preincremento, (IDX)\n" );
  157.  
  158.   return ok;
  159. }
  160.  
  161. int indexado_postincremento( int offset, char* registro )
  162. {
  163.   char buffer[10];
  164.   strcpy(buffer, registro);
  165.  
  166.   int ok = ( ( offset & _4BITS ) == offset );
  167.  
  168.   if ( ok )
  169.   {
  170.     int pos_inc = strlen( buffer ) - 1;
  171.     ok = (buffer[pos_inc] == '-') || (buffer[pos_inc]=='+');
  172.     buffer[pos_inc] = 0;
  173.   }
  174.  
  175.   if ( ok )
  176.     ok = verificarRegistro( buffer );
  177.  
  178.   if ( ok )
  179.     printf( "Indexado con postincremento, (IDX)\n" );
  180.  
  181.   return ok;
  182. }
  183.  
  184. int convertir_a_numero(char *cadena)
  185. {
  186.   int numero = 0;
  187.   int index = 0;
  188.   int neg = 0;
  189.   if ( cadena[0] == '-' )
  190.   {
  191.     neg = 1;
  192.     index = 1;
  193.   }
  194.  
  195.   for ( ; index < strlen(cadena); index++ )
  196.   {
  197.     numero *= 10;
  198.     numero += cadena[index] - '0';
  199.   }
  200.  
  201.   if ( neg )
  202.     numero *= -1;
  203.  
  204.   return numero;
  205. }
  206.  
  207. int verificarRegistro(char *cadena)
  208. {
  209.   int i;
  210.   char *registro[] = {"X","Y","SP","PC"};
  211.   for(i = 0;i < 4;i++)
  212.   {
  213.     if((strcmp(cadena,registro[i])) == 0)
  214.       return 1;
  215.   }
  216.   return 0;
  217. }

Salida:

Código:
5 bits ----------
Indexado de 5 bits, (IDX)
Indexado de 5 bits, (IDX)
9 bits ----------
Indexado de 9 bits, (IDX)
Indexado de 9 bits, (IDX)
Indexado de 9 bits, (IDX)
Indexado de 9 bits, (IDX)
16 bits ---------
Indexado de 16 bits, (IDX)
Indexado de 16 bits, (IDX)
preincremento ---
Indexado con preincremento, (IDX)
Indexado con preincremento, (IDX)
postincremento --
Indexado con postincremento, (IDX)
Indexado con postincremento, (IDX)
No validos -----
Indexado no reconocido.
Indexado no reconocido.
Indexado no reconocido.

Dado que todas las funciones de comprobación de índices tienen la misma firma, se podría crear un puntero con todas las comprobaciones y ejecutarlas de forma iterativa en un bucle for... pero eso ya lo dejo de tu mano.

Un saludo.
En línea
m@o_614


Desconectado Desconectado

Mensajes: 389


Ver Perfil
Re: modos de direccionamiento indexado de 5/9/16 bits
« Respuesta #2 en: 8 Marzo 2014, 02:56 am »
gracias eferion por tu respuesta, lo que yo estaba intentando hacer es como tengo una cadena por ejemplo "-64,SP" pues priimero el numero -64 lo tengo que convertir a int porque es una cadena, entonces agarro lo que se encuentra antes de la coma primero convierto el numero a entero y despues si veo que tiene el signo de menos lo multiplico por menos 1. como tengo diferentes rangos para los direccionamientos pero el registro( lo que va despues de la coma) es el mismo hago lo siguiente

primero verifico que el registro sea X,Y,SP o PC y despues veo en que rango se encuentra el numero para imprimir es de 5 bits, o es de 9 bits....

pero ahora tengo que hacer otro direccionamiento:

3,+SP-> imprime es de PreIncremento
3,SP+-> imprime es de PostIncremento
3,-SP-> imprime es de PreDecremento
3,SP-  -> imprime es de PostDecremento

pero no se bien como hacerle, primero veo que tenga un signo al principio, y despues como le hago para que verifique los que tienen el signo al final?? alguna idea??
En línea
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: modos de direccionamiento indexado de 5/9/16 bits
« Respuesta #3 en: 8 Marzo 2014, 09:50 am »
Cita de: m@o_614 en  8 Marzo 2014, 02:56 am
pero ahora tengo que hacer otro direccionamiento:

3,+SP-> imprime es de PreIncremento
3,SP+-> imprime es de PostIncremento
3,-SP-> imprime es de PreDecremento
3,SP-  -> imprime es de PostDecremento

pero no se bien como hacerle, primero veo que tenga un signo al principio, y despues como le hago para que verifique los que tienen el signo al final?? alguna idea??

Si miras el código que te puesto verás que ya hace eso. Lo único que no discrimina entre incremento y decremento... pero es un cambio que lleva 2 minutos contados :)
En línea
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Direccionamiento indexado ASM
ASM 		farresito 5 6,769 Último mensaje 20 Agosto 2010, 08:43 am
por Eternal Idol
Tablas indexado de 8 bits.
Electrónica 		Meta 4 4,191 Último mensaje 29 Agosto 2010, 18:09 pm
por Tokes
robots.txt o indexado
Desarrollo Web 		Mr.Blue 7 3,822 Último mensaje 8 Noviembre 2010, 07:04 am
por WebMonster
modos de direccionamiento
Programación C/C++ 		m@o_614 7 3,860 Último mensaje 24 Febrero 2014, 02:50 am
por m@o_614
Problema en archivo indexado
Programación C/C++ 		n-utz 0 1,651 Último mensaje 22 Octubre 2016, 19:15 pm
por n-utz
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines