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

 

 


Tema destacado: Entrar al Canal Oficial Telegram de elhacker.net


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


Desconectado Desconectado

Mensajes: 389


Ver Perfil
validar numeros
« en: 5 Abril 2014, 02:17 am »

Saludos, tengo el siguiente segmento de codigo dentro de un CASE '[' o
CASE INDEXADO_INDIRECTO, donde tengo que validar una cadena esta cadena que inicia con [, debe de tener o bien una D despues del corchete o un numero en base DECIMAL (tiene un rango especifico de valores para que sea valido)seguido por una , despues un registro que puede ser x,y,sp,pc  y por ultimo un corchete de cierre ]

por ejemplo si tengo:

[5,Sp -> error: le falta el ultimo corchete
[,x] -> no puede haber una instruccion vacia antes de la coma
[100,] ->no puede haber una instruccion vacia despues de la coma
[ ->despues del primer [ debe haber dos registros separados por una , y despues ]
[AD,sp]-> el primer registro tiene que ser la letra D

PERO cuando le pongo algo como:

[5A9,x] -> aqui me aparece que es un numero valido, pero para este caso en especial solo puede aceptar numeros decimales, y no se como corregir esto

Código
  1. case INDEXADO_INDIRECTO:
  2.            i = 1;
  3.            tam = strlen(operando);
  4.            car = operando[i++];
  5.            if(car == '\0')
  6.               printf("Despues del primer [ debe haber dos registros separados por , y un corchete de cierre\n");
  7.            else
  8.            {
  9.                if(operando[tam-1] != ']')
  10.                   printf("Error: No se encontro corchete de cierre\n");
  11.                else
  12.                {
  13.                    switch(car)
  14.                    {
  15.                        case ']':
  16.                           printf("No pueden estar los corchetes vacios\n");
  17.                           break;
  18.                        case ',':
  19.                           printf("No puede haber una instruccion vacia antes de la coma\n");
  20.                           registro = obtenerRegistro(operando);
  21.                           if((strcmp(registro,"\0")) == 0)
  22.                              printf("No puede haber una instruccion vacia despues de la coma\n");
  23.                              break;
  24.                        case '0':
  25.                        case '1':
  26.                        case '2':
  27.                        case '3':
  28.                        case '4':
  29.                        case '5':
  30.                        case '6':
  31.                        case '7':
  32.                        case '8':
  33.                        case '9':
  34.                           if((ptr = strchr(operando,',')) == 0)
  35.                              printf("Despues del primer corchete debe haber dos registros separados por una ,\n");
  36.                           else
  37.                           {
  38.                               base = 10;
  39.                               x = 1;
  40.                               k = 0;
  41.                               esIndexadoIndirecto16bits = 1;
  42.                               instruccion = obtenerInstruccion(operando,x);
  43.                               numero = obtenerNumero(instruccion,k,base);
  44.                               registro = obtenerRegistro(operando);
  45.                               registro = convertirMayusculas(registro);
  46.                               if((strcmp(registro,"\0")) == 0)
  47.                                  printf("No puede haber una instruccion vacia despues de la coma\n");
  48.                               else
  49.                               {
  50.                                   if(!verificarRegistro(registro))
  51.                                   {
  52.                                       esIndexadoIndirecto16bits = 0;
  53.                                       printf("Los registros validos de un direccionamiento Indexado indirecto de 16 bits son X,Y,SP,PC\n");
  54.                                   }
  55.                                   if(!verificarRangoIndexadoIndirecto(numero))
  56.                                   {
  57.                                       esIndexadoIndirecto16bits = 0;
  58.                                       printf("El rango valido de un direccionamiento Indexado Indirecto de 16 bits es de 0 a 65535\n");
  59.                                   }
  60.                                   if(esIndexadoIndirecto16bits)
  61.                                   {
  62.                                       if((indice = buscarDireccionamiento(encontrado,direccionamiento[7]))!= -1)
  63.                                          printf("Indexado Indirecto de 16 bits([IDX2]), de %s bytes\n",encontrado->total_bytes[indice]);
  64.                                       else
  65.                                          printf("el codop %s no acepta el direccionamiento indexado indirecto de 16 bits\n",encontrado->instruccion);
  66.                                   }
  67.                               }
  68.                           }
  69.                          break;
  70.                       case '-':
  71.                          if((ptr = strchr(operando,',')) == 0)
  72.                             printf("Despues del primer corchete debe haber dos registros separados por una ,\n");
  73.                          else
  74.                          {
  75.                              base = 10;
  76.                              x = 0;
  77.                              k = 1;
  78.                              esIndexadoIndirecto16bits = 1;
  79.                              instruccion = obtenerInstruccion(operando,x);
  80.                              numero = obtenerNumero(instruccion,k,base);
  81.                              registro = obtenerRegistro(operando);
  82.                              registro = convertirMayusculas(registro);
  83.                              if((strcmp(registro,"\0")) == 0)
  84.                                 printf("No puede haber una instruccion vacia despues de la coma\n");
  85.                              else
  86.                              {
  87.                                  if(!verificarRegistro(registro))
  88.                                  {
  89.                                      esIndexadoIndirecto16bits = 0;
  90.                                      printf("Los registros validos de un direccionamiento Indexado indirecto de 16 bits son X,Y,SP,PC\n");
  91.                                  }
  92.                                  if(!verificarRangoIndexadoIndirecto(numero))
  93.                                  {
  94.                                      esIndexadoIndirecto16bits = 0;
  95.                                      printf("El rango valido de un direccionamiento Indexado Indirecto de 16 bits es de 0 a 65535\n");
  96.                                  }
  97.                                  if(esIndexadoIndirecto16bits)
  98.                                  {
  99.                                      if((indice = buscarDireccionamiento(encontrado,direccionamiento[7]))!= -1)
  100.                                         printf("Indexado Indirecto de 16 bits([IDX2]), de %s bytes\n",encontrado->total_bytes[indice]);
  101.                                      else
  102.                                         printf("el codop %s no acepta el direccionamiento indexado indirecto de 16 bits\n",encontrado->instruccion);
  103.                                  }
  104.                              }
  105.                          }
  106.                          break;
  107.                       default:
  108.                          x = 1;
  109.                          esIndexadoIndirecto_Acumulador = 1;
  110.                          instruccion = obtenerInstruccion(operando,x);
  111.                          registro = obtenerRegistro(operando);
  112.                          registro = convertirMayusculas(registro);
  113.                          if(!indirectoAcumulador_D(instruccion))
  114.                          {
  115.                              printf("Error: El Acumulador valido de un Indexdo Indirecto de acumulador es D\n");
  116.                              esIndexadoIndirecto_Acumulador = 0;
  117.                          }
  118.                          if(!verificarRegistro(registro))
  119.                          {
  120.                              printf("Los registros validos de un Indexado Indirecto de Acumulador son X,Y,SP,PC\n");
  121.                              esIndexadoIndirecto_Acumulador = 0;
  122.                          }
  123.                          if(esIndexadoIndirecto_Acumulador)
  124.                          {
  125.                              if((indice = buscarDireccionamiento(encontrado,direccionamiento[6]))!= -1)
  126.                                 printf("Indexado Indirecto de Acumulador D,([D,IDX]), de %s bytes\n",encontrado->total_bytes[indice]);
  127.                              else
  128.                                 printf("el codop %s no acepta el direccionamiento indexado indirecto de acumulador D\n",encontrado->instruccion);
  129.                          }
  130.                      }
  131.                }
  132.            }
  133.            break;
  134.  

y las demas funciones son estas, no puse todo el codigo porque son como 1700 lineas de codigo,se que tengo algunas malas practicas de programacion pero ahora lo importante es corregir ese bug.

Código
  1. char *obtenerRegistro(char *operando)
  2. {
  3.    int j,i = 0;
  4.    char *cadena = NULL,c[2];
  5.    cadena = calloc(2,sizeof(char));
  6.    while(operando[i] != ',')
  7.       i++;
  8.    for(j = i+1;operando[j] != ']';j++)
  9.    {
  10.        sprintf(c,"%c",operando[j]);
  11.        strcat(cadena,c);
  12.    }
  13.    return cadena;
  14. }
  15. char *obtenerInstruccion(char *operando,int x)
  16. {
  17.    int i;
  18.    char *cadena = NULL,c[2],signo[] = {'\0',','};
  19.    cadena = calloc(7,sizeof(char));
  20.    for(i = x;operando[i] != ',';i++)
  21.    {
  22.        sprintf(c,"%c",operando[i]);
  23.        strcat(cadena,c);
  24.    }
  25.    return cadena;
  26. }
  27.  
  28. int obtenerNumero(char *operando,int x,int base)
  29. {
  30.    int i,potencia,num_decimal = 0,lon,entero = 0;
  31.    lon = strlen(operando);
  32.    for(i = lon-1,potencia = 1;i >= x;i--,potencia*=base)
  33.    {
  34.        if(esLetraBase16(operando[i]))
  35.           entero = hexadecimal(operando[i]);
  36.        else
  37.           entero = operando[i]-'0';
  38.        num_decimal+= potencia*entero;
  39.    }
  40.    if(operando[CERO] == '-')
  41.       num_decimal*= -1;
  42.    return num_decimal;
  43. }
  44.  
  45. int hexadecimal(char caracter)
  46. {
  47.    int decimal;
  48.    switch(caracter)
  49.    {
  50.        case 'A':case 'a':
  51.           decimal = 10;
  52.           break;
  53.        case 'B':case 'b':
  54.           decimal = 11;
  55.           break;
  56.        case 'C':case 'c':
  57.           decimal = 12;
  58.           break;
  59.        case 'D':case 'd':
  60.           decimal = 13;
  61.           break;
  62.        case 'E':case 'e':
  63.           decimal = 14;
  64.           break;
  65.        case 'F':case 'f':
  66.           decimal = 15;
  67.           break;
  68.        default:
  69.           printf("!Error!\n");
  70.    }
  71.    return decimal;
  72. }
  73.  
  74. char *convertirMayusculas(char *cadena)
  75. {
  76.    int i;
  77.    for(i = 0;cadena[i];i++)
  78.       cadena[i] = toupper(cadena[i]);
  79.    return cadena;
  80. }
  81.  
  82. int verificarRegistro(char *cadena)
  83. {
  84.    int i;
  85.    char *registro[] = {"X","Y","SP","PC"};
  86.    for(i = 0;i < 4;i++)
  87.    {
  88.        if((strcmp(cadena,registro[i])) == 0)
  89.           return 1;
  90.    }
  91.    return 0;
  92. }
  93.  
  94. int verificarRangoIndexadoIndirecto(int numero)
  95. {
  96.    if(numero >= CERO && numero <= MAX_IDX_INDIRECTO)
  97.       return 1;
  98.    else
  99.       return 0;
  100. }
  101.  

de antemano gracias


« Última modificación: 5 Abril 2014, 02:24 am por m@o_614 » En línea

do-while


Desconectado Desconectado

Mensajes: 1.276


¿Habra que sacarla de paseo?


Ver Perfil
Re: validar numeros
« Respuesta #1 en: 5 Abril 2014, 02:54 am »

¡Buenas!

Eso de los switch me parece un poco caótico. Yo lo que haría seria una función que me valide el código que le pasas y recoja los valores en los parámetros que le pases. Después, clasifica los parámetros como te convenga. Por ejemplo:
Código
  1. #include <ctype.h>
  2. #include <string.h>
  3.  
  4. /*
  5.     Si el formato no es correcto devuelve cero, sino uno.
  6.  
  7.     si la funcion devuelve 1 hay que comprobar si valor==-1 para saber si el primer
  8.     caracter desupues de [ es una D o no
  9. */
  10.  
  11. int validar_secuencia(char *s, int *valor, char codigo[3])
  12. {
  13.    char *codigos[] = {"x]","y]","sp]","pc]"};
  14.    int i;
  15.  
  16.    *valor = 0;
  17.  
  18.    if(!(*s))
  19.        return 0;
  20.  
  21.    if(s[0] != '[')
  22.        return 0;
  23.  
  24.    if(*(++s) == 'D')
  25.    {
  26.        *valor = -1;
  27.        s++;
  28.    }
  29.    else
  30.    {
  31.        while(*(++s) && isdigit(*s))
  32.        {
  33.            (*valor) *= 10;
  34.            (*valor) += (*s) - '0';
  35.        }
  36.    }
  37.  
  38.    if(!isdigit(*s) || *(s++) != ',')
  39.        return 0;
  40.  
  41.    for(i = 0 ; i < 4 ; i++)
  42.        if(!strcmp(s,codigos[i]))
  43.            break;
  44.  
  45.    if(i == 4)
  46.        return 0;
  47.  
  48.    strcpy(codigo,codigos[i]);
  49.    codigo[strlen(codigos[i]) - 1] = '\0';
  50.  
  51.    return *(s + strlen(codigos[i])) == '\0';
  52. }
  53.  
  54. int main(int argc, char *argv[])
  55. {
  56.    char *codigos[] = {"[123,x]","[1045,sp]","hola","[1,pc","[D,y]",""},codigo[3];
  57.    int i = 0,valor;
  58.  
  59.    while(codigos[i][0])
  60.    {
  61.        if(validar_secuencia(codigos[i],&valor,codigo))
  62.            printf("%s: Codigo correcto (valor=%d, codigo=%s)\n",codigos[i],valor,codigo);
  63.  
  64.        else
  65.            printf("%s: Codigo incorrecto\n",codigos[i]);
  66.  
  67.        i++;
  68.    }
  69. }
  70.  

De todas formas, si estás obligado a utilizar los switch veremos que se puede hacer. Ya diras.

¡Saludos!


« Última modificación: 6 Abril 2014, 19:00 pm por do-while » En línea

- Doctor, confundo los números y los colores.
- Vaya marrón.
- ¿Marrón? ¡Por el culo te la hinco!
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Validar numeros (Resuelto)
Java
jesslandero2 0 3,562 Último mensaje 7 Junio 2014, 18:30 pm
por jesslandero2
[AYUDA]C++ / VALIDAR SOLO NUMEROS SEGUN MI TRABAJO « 1 2 »
Programación C/C++
hctr12 12 6,519 Último mensaje 9 Julio 2014, 15:16 pm
por leosansan
Validar solo números en un INT en C++
Programación C/C++
RGT 1 5,158 Último mensaje 5 Noviembre 2015, 12:31 pm
por class_OpenGL
Validar ingreso de cadena y de números en lenguaje C.
Programación C/C++
NOB2014 7 7,946 Último mensaje 18 Febrero 2016, 23:08 pm
por fary
SOLO VALIDAR ENTRADA DE NUMEROS
Programación C/C++
WarrirorPT3 1 1,048 Último mensaje 15 Abril 2019, 23:28 pm
por K-YreX
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines