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)
| | |-+  problema con cadena		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: problema con cadena  (Leído 2,213 veces)
m@o_614


Desconectado Desconectado

Mensajes: 389


Ver Perfil
problema con cadena
« en: 11 Junio 2014, 21:58 pm »
Saludos tengo el siguiente archivo:

Citar
    0001.....Pri........equ.....1
    0002.....Seg......equ.....2
    0003.....Ter......equ.....3
    0004.....Cua.....equ.....4
    00FF.....null.....ORG.....255
    00FF......Et.......Ds.b.....5
    0000......Otra...equ......0
    0104......null....Swi......null......3F
    0105......null....Ds.W....5
    0005......Qui....equ.......5
    010F......null....Swi.......null......3F
    0006.......Sex...equ.......6
    0110......Sep...Swi.......null.......3F
    0008......Oct....equ......8
    0111......null....Ldaa....3...........9603
    0113......null....Ldaa....Sep.......B60110
    0116......null....Ds.b....3
    0119......null....Ldaa....3..........9603
    0009......Nov....equ.....9
    011B.....null....Swi.....Null.......3F
    011C......null....Dc.b....2.........02
    000B......Dec....Equ.....11
    null....End.....null

Aqui 3F,9603,B60110 son códigos máquina, pero las directivas Equ,End, Org y Ds.b(directiva de reserva de memoria) no van a generar codigo. Con este archivo yo tengo que generar un archivo en el que se impriman unos registros así:

S0....
S1+04+0104+3F-> aqui se agrega la direccion (0104) y despues el codigo maquina 3F, y ahi paramos porque despues de 3F hay un Ds.W, y este nos indica que se tiene que concluir e imprimir en el archivo como está..

la segunda linea seria:

S1+0A+010F+[3F][3F][9603][B60110] y como despues esta Ds.b también ahi paramos

la ultima linea seria :

S1+07+0119+[9603][3F][02]  y como despues tenemos puros equ's que no generan codigo máquina y al ultimo el END, entonces ahi paramos

esta es la linea donde tengo problemas porque me la imprime asi:

S1+06+0119+[9603][3F] y ya!! le falta el 02 y no entiendo por que no concatena este ultimo, el codigo es el siguiente:

Código
  1. void leerTEMPORAL(COD *cabeza,TABSIM **t,char *archivo)
  2. {
  3.     int car,indice,longitud_del_codigo = 0,longitud = 3,bytesDisponibles = 16,disponibles = 16,x = 0,base = 16;
  4.     int direccionActual,bytesSumados;
  5.     FILE *tmp;
  6.     DIV division,*codMaquina;
  7.     COD *seEncontro = NULL;
  8.     char *TIPO,*VALOR,*ETIQUETA,*CODOP,*OPERANDO,*COD_MAQUINA;
  9.     char *tipo = "S1",*Longitud,*direccion,*codigo_datos,*checksum,*nuevaDireccion;
  10.     codigo_datos = (char*)calloc(33,sizeof(char));
  11.     if((tmp = fopen("TEMPORAL.txt","r")) != NULL)
  12.     {
  13.         while((car = fgetc(tmp)) != EOF)
  14.         {
  15.             TIPO = Etiqueta_Codop_Operando(tmp,TIPO_);
  16.             ignorarEspacios(tmp);
  17.             VALOR = Etiqueta_Codop_Operando(tmp,VALOR_);
  18.             ignorarEspacios(tmp);
  19.             ETIQUETA = Etiqueta_Codop_Operando(tmp,ETIQUETA_);
  20.             ignorarEspacios(tmp);
  21.             CODOP = Etiqueta_Codop_Operando(tmp,CODOP_);
  22.             ignorarEspacios(tmp);
  23.             OPERANDO = Etiqueta_Codop_Operando(tmp,OPERANDO_);
  24.             if((seEncontro = buscarCodop(cabeza,CODOP)) != NULL)
  25.             {
  26.                 if(!verificarOperando(seEncontro,OPERANDO))
  27.                 {
  28.                     indice = obtenerIndiceDireccionamiento(seEncontro,OPERANDO);
  29.                     COD_MAQUINA = calcularCodigo_Maquina(seEncontro,indice,VALOR,ETIQUETA,CODOP,OPERANDO,t);
  30.                     longitudValida(COD_MAQUINA,&longitud_del_codigo);
  31.                     if(agregarCodigo_Maquina(longitud_del_codigo))
  32.                     {
  33.                         if(disponibles == 16)
  34.                            direccion = VALOR;
  35.                         strcat(codigo_datos,COD_MAQUINA);
  36.                         disponibles = bytesDisponibles-longitud_del_codigo;
  37.                     }
  38.                     else
  39.                     {
  40.                         if(disponibles != 0)
  41.                         {
  42.                             if(disponibles == 16)
  43.                                direccion = VALOR;
  44.                             codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
  45.                             strcat(codigo_datos,codMaquina->bytesRequeridos);
  46.                             disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
  47.                             Longitud = calcularLongitudS1(longitud,codigo_datos);
  48.                             //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  49.                             crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  50.                             direccionActual = obtenerNumero(VALOR,x,base);
  51.                             bytesSumados = obtenerNumero(codMaquina->bytesPendientes,x,base);
  52.                             longitud_del_codigo = 0;
  53.                             bytesDisponibles = 16;
  54.                             longitudValida(COD_MAQUINA,&longitud_del_codigo);
  55.                             if(agregarCodigo_Maquina(longitud_del_codigo))
  56.                             {
  57.                                 strcpy(codigo_datos,codMaquina->bytesPendientes);
  58.                                 disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
  59.                             }
  60.                         }
  61.                         else
  62.                         {
  63.                             Longitud = calcularLongitudS1(longitud,codigo_datos);
  64.                             //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  65.                             crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  66.                             longitud_del_codigo = 0;
  67.                             disponibles = 16;
  68.                             direccion = VALOR;
  69.                             *codigo_datos = 0;
  70.                             longitudValida(COD_MAQUINA,&longitud_del_codigo);
  71.                             if(agregarCodigo_Maquina(longitud_del_codigo))
  72.                             {
  73.                                 strcpy(codigo_datos,COD_MAQUINA);
  74.                                 disponibles = bytesDisponibles-longitud_del_codigo;
  75.                             }
  76.                         }
  77.                     }
  78.                 }
  79.             }
  80.             else if(esDirectivaCONSTANTES_1byte(CODOP)||esDirectivaCONSTANTES_2byte(CODOP)||esDirectivaCARACTERES(CODOP))
  81.             {
  82.                 COD_MAQUINA = codigoMaquina_Directivas(VALOR,ETIQUETA,CODOP,OPERANDO);
  83.                 longitudValida(COD_MAQUINA,&longitud_del_codigo);
  84.                 if(agregarCodigo_Maquina(longitud_del_codigo))
  85.                 {
  86.                     if(disponibles == 16)
  87.                        direccion = VALOR;
  88.                     strcat(codigo_datos,COD_MAQUINA);
  89.                     disponibles = bytesDisponibles-longitud_del_codigo;
  90.                 }
  91.                 else
  92.                 {
  93.                     if(disponibles != 0)
  94.                     {
  95.                         if(disponibles == 16)
  96.                            direccion = VALOR;
  97.                         codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
  98.                         strcat(codigo_datos,codMaquina->bytesRequeridos);
  99.                         disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
  100.                         Longitud = calcularLongitudS1(longitud,codigo_datos);
  101.                         //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  102.                         crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  103.                         direccionActual = obtenerNumero(VALOR,x,base);
  104.                         bytesSumados = strlen(codMaquina->bytesRequeridos)/2;
  105.                         nuevaDireccion = calcularDireccion(direccionActual,bytesSumados);
  106.                         direccion = nuevaDireccion;
  107.                         longitud_del_codigo = 0;
  108.                         bytesDisponibles = 16;
  109.                         *codigo_datos = 0;
  110.                         longitudValida(COD_MAQUINA,&longitud_del_codigo);
  111.                         if(agregarCodigo_Maquina(longitud_del_codigo))
  112.                         {
  113.                             strcpy(codigo_datos,codMaquina->bytesPendientes);
  114.                             disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
  115.                         }
  116.                     }
  117.                     else
  118.                     {
  119.                         Longitud = calcularLongitudS1(longitud,codigo_datos);
  120.                         //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  121.                         crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  122.                         longitud_del_codigo = 0;
  123.                         direccion = VALOR;
  124.                         longitudValida(COD_MAQUINA,&longitud_del_codigo);
  125.                         if(agregarCodigo_Maquina(longitud_del_codigo))
  126.                         {
  127.                             strcpy(codigo_datos,COD_MAQUINA);
  128.                             disponibles = bytesDisponibles-longitud_del_codigo;
  129.                         }
  130.                     }
  131.                 }
  132.             }
  133.             else if(esDirectivaRESERVA_MEMORIA1byte(CODOP)||esDirectivaRESERVA_MEMORIA2byte(CODOP))
  134.             {
  135.                 printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  136.                 if(codigo_datos[CERO] != '\0')
  137.                 {
  138.                     Longitud = calcularLongitudS1(longitud,codigo_datos);
  139.                     //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  140.                     crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  141.                     longitud_del_codigo = 0;
  142.                     disponibles = 16;
  143.                     *codigo_datos = 0;
  144.                 }
  145.             }
  146.             else
  147.             {
  148.                 if((strcmp(CODOP,"ORG")) == 0)
  149.                 {
  150.                     printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  151.                     calcularS0(archivo);
  152.                 }
  153.                 else if((strcmp(CODOP,"END")) == 0)
  154.                 {
  155.                     if(codigo_datos[CERO] != '\0')
  156.                     {
  157.                         Longitud = calcularLongitudS1(longitud,codigo_datos);
  158.                         //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  159.                         crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  160.                     }
  161.                     printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  162.                     crearArchivoS9();
  163.                 }
  164.                 else if((strcmp(CODOP,"EQU")) == 0)
  165.                    printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  166.                 else
  167.                 {
  168.                     printf("%s   %s   %s   %s\t",VALOR,ETIQUETA,CODOP,OPERANDO);
  169.                     printf("NO SE ENCONTRO EL CODOP DE OPERANDO\n");
  170.                 }
  171.             }
  172.         }
  173.     }
  174.     else
  175.        printf("No se pudo abrir archivo\n");
  176. }

la longitud del campo donde se concatenan los codigos maquinas debe ser maximo 32, por eso tengo la función que me dice si el codigo se puede agregar o no, y en caso de que no se pueda hago un nuevo registro. El codigo si funciona lo probe varias veces pero en la ultima me trono y creo que puede ser por la manera en la que le estoy asignando memoria a cadena_datos(donde concateno los codigos)

gracias de antemano
« Última modificación: 11 Junio 2014, 22:01 pm por m@o_614 » En línea
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: problema con cadena
« Respuesta #1 en: 11 Junio 2014, 22:45 pm »
Ese código tienes que dividirlo para hacerlo más manejable.

176 líneas y 26 variables suponen bastante densidad para una sola función.
En línea
m@o_614


Desconectado Desconectado

Mensajes: 389


Ver Perfil
Re: problema con cadena
« Respuesta #2 en: 12 Junio 2014, 01:19 am »
muchas gracias eferion por tu respuesta, ahora ya hice 2 nuevas funciones, una que me calcule la nuevaDireccion que me va a imprimir en el archivo, las nuevas direcciones se calculan en caso de que la haya alcanzado la maxima longitud de la variable codigo_datos(que es 16 bytes, osea 32 caracteres).

No se si disminuí mucho el tamaño de la función, pero fue lo maximo que lo pude reducir.

Código
  1. void leerTEMPORAL(COD *cabeza,TABSIM **t,char *archivo)
  2. {
  3.     int car,indice,longitud_del_codigo = 0,longitud = 3,bytesDisponibles = 16,disponibles = 16;
  4.     FILE *tmp;
  5.     DIV division,*codMaquina;
  6.     COD *seEncontro = NULL;
  7.     char *TIPO,*VALOR,*ETIQUETA,*CODOP,*OPERANDO,*COD_MAQUINA;
  8.     char *tipo = "S1",*Longitud,*direccion,*codigo_datos,*checksum;
  9.     codigo_datos = (char*)calloc(33,sizeof(char));
  10.     if((tmp = fopen("TEMPORAL.txt","r")) != NULL)
  11.     {
  12.         while((car = fgetc(tmp)) != EOF)
  13.         {
  14.             TIPO = Etiqueta_Codop_Operando(tmp,TIPO_);
  15.             ignorarEspacios(tmp);
  16.             VALOR = Etiqueta_Codop_Operando(tmp,VALOR_);
  17.             ignorarEspacios(tmp);
  18.             ETIQUETA = Etiqueta_Codop_Operando(tmp,ETIQUETA_);
  19.             ignorarEspacios(tmp);
  20.             CODOP = Etiqueta_Codop_Operando(tmp,CODOP_);
  21.             ignorarEspacios(tmp);
  22.             OPERANDO = Etiqueta_Codop_Operando(tmp,OPERANDO_);
  23.             if((seEncontro = buscarCodop(cabeza,CODOP)) != NULL)
  24.             {
  25.                 if(!verificarOperando(seEncontro,OPERANDO))
  26.                 {
  27.                     indice = obtenerIndiceDireccionamiento(seEncontro,OPERANDO);
  28.                     COD_MAQUINA = calcularCodigo_Maquina(seEncontro,indice,VALOR,ETIQUETA,CODOP,OPERANDO,t);
  29.                     longitudValida(COD_MAQUINA,&longitud_del_codigo);
  30.                     if(agregarCodigo_Maquina(longitud_del_codigo))
  31.                     {
  32.                         if(disponibles == 16)
  33.                            direccion = VALOR;
  34.                         strcat(codigo_datos,COD_MAQUINA);
  35.                         disponibles = bytesDisponibles-longitud_del_codigo;
  36.                     }
  37.                     else
  38.                     {
  39.                         if(disponibles != 0)
  40.                         {
  41.                             codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
  42.                             strcat(codigo_datos,codMaquina->bytesRequeridos);
  43.                             disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
  44.                             Longitud = calcularLongitudS1(longitud,codigo_datos);
  45.                             checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  46.                             crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  47.                             direccion = nuevaDireccion(codMaquina,VALOR);
  48.                             inicializarVariables(&longitud_del_codigo,&bytesDisponibles);
  49.                             longitudValida(COD_MAQUINA,&longitud_del_codigo);
  50.                             if(agregarCodigo_Maquina(longitud_del_codigo))
  51.                             {
  52.                                 *codigo_datos = 0;
  53.                                 strcpy(codigo_datos,codMaquina->bytesPendientes);
  54.                                 disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
  55.                             }
  56.                         }
  57.                         else
  58.                         {
  59.                             Longitud = calcularLongitudS1(longitud,codigo_datos);
  60.                             checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  61.                             crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  62.                             inicializarVariables(&longitud_del_codigo,&disponibles);
  63.                             direccion = VALOR;
  64.                             *codigo_datos = 0;
  65.                             longitudValida(COD_MAQUINA,&longitud_del_codigo);
  66.                             if(agregarCodigo_Maquina(longitud_del_codigo))
  67.                             {
  68.                                 strcpy(codigo_datos,COD_MAQUINA);
  69.                                 disponibles = bytesDisponibles-longitud_del_codigo;
  70.                             }
  71.                         }
  72.                     }
  73.                 }
  74.             }
  75.             else if(esDirectivaCONSTANTES_1byte(CODOP)||esDirectivaCONSTANTES_2byte(CODOP)||esDirectivaCARACTERES(CODOP))
  76.             {
  77.                 COD_MAQUINA = codigoMaquina_Directivas(VALOR,ETIQUETA,CODOP,OPERANDO);
  78.                 longitudValida(COD_MAQUINA,&longitud_del_codigo);
  79.                 if(agregarCodigo_Maquina(longitud_del_codigo))
  80.                 {
  81.                     if(disponibles == 16)
  82.                        direccion = VALOR;
  83.                     strcat(codigo_datos,COD_MAQUINA);
  84.                     disponibles = bytesDisponibles-longitud_del_codigo;
  85.                 }
  86.                 else
  87.                 {
  88.                     if(disponibles != 0)
  89.                     {
  90.                         codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
  91.                         strcat(codigo_datos,codMaquina->bytesRequeridos);
  92.                         disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
  93.                         Longitud = calcularLongitudS1(longitud,codigo_datos);
  94.                         checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  95.                         crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  96.                         direccion = nuevaDireccion(codMaquina,VALOR);
  97.                         inicializarVariables(&longitud_del_codigo,&bytesDisponibles);
  98.                         *codigo_datos = 0;
  99.                         longitudValida(COD_MAQUINA,&longitud_del_codigo);
  100.                         if(agregarCodigo_Maquina(longitud_del_codigo))
  101.                         {
  102.                             strcpy(codigo_datos,codMaquina->bytesPendientes);
  103.                             disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
  104.                         }
  105.                     }
  106.                     else
  107.                     {
  108.                         Longitud = calcularLongitudS1(longitud,codigo_datos);
  109.                         checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  110.                         crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  111.                         inicializarVariables(&longitud_del_codigo,&bytesDisponibles);
  112.                         direccion = VALOR;
  113.                         longitudValida(COD_MAQUINA,&longitud_del_codigo);
  114.                         if(agregarCodigo_Maquina(longitud_del_codigo))
  115.                         {
  116.                             strcpy(codigo_datos,COD_MAQUINA);
  117.                             disponibles = bytesDisponibles-longitud_del_codigo;
  118.                         }
  119.                     }
  120.                 }
  121.             }
  122.             else if(esDirectivaRESERVA_MEMORIA1byte(CODOP)||esDirectivaRESERVA_MEMORIA2byte(CODOP))
  123.             {
  124.                 printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  125.                 if(codigo_datos[CERO] != '\0')
  126.                 {
  127.                     Longitud = calcularLongitudS1(longitud,codigo_datos);
  128.                     checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  129.                     crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  130.                     inicializarVariables(&longitud_del_codigo,&disponibles);
  131.                     *codigo_datos = 0;
  132.                 }
  133.             }
  134.             else
  135.             {
  136.                 if((strcmp(CODOP,"ORG")) == 0)
  137.                 {
  138.                     printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  139.                     calcularS0(archivo);
  140.                 }
  141.                 else if((strcmp(CODOP,"END")) == 0)
  142.                 {
  143.                     if(codigo_datos[CERO] != '\0')
  144.                     {
  145.                         Longitud = calcularLongitudS1(longitud,codigo_datos);
  146.                         checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  147.                         crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  148.                     }
  149.                     printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  150.                     crearArchivoS9();
  151.                 }
  152.                 else if((strcmp(CODOP,"EQU")) == 0)
  153.                    printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  154.                 else
  155.                 {
  156.                     printf("%s   %s   %s   %s\t",VALOR,ETIQUETA,CODOP,OPERANDO);
  157.                     printf("NO SE ENCONTRO EL CODOP DE OPERANDO\n");
  158.                 }
  159.             }
  160.         }
  161.     }
  162.     else
  163.        printf("No se pudo abrir archivo\n");
  164. }

y las funciones que recien hice son estas:

Código
  1. void inicializarVariables(int *longitud_del_codigo,int *bytesDisponibles)
  2. {
  3.     *longitud_del_codigo = 0;
  4.     *bytesDisponibles = 16;
  5. }
  6.  
  7. char *nuevaDireccion(DIV *codMaquina,char *VALOR)
  8. {
  9.     int suma,bytesAgregados,direccionActual,x = 0,base = 16;
  10.     char *direccion;
  11.     direccion = (char*)calloc(5,sizeof(char));
  12.     bytesAgregados = strlen(codMaquina->bytesRequeridos)/2;
  13.     direccionActual = obtenerNumero(VALOR,x,base);
  14.     suma = direccionActual+bytesAgregados;
  15.     sprintf(direccion,"%04X",suma);
  16.     return direccion;
  17. }

el codigo sigue teniendo ese pequeño error en la linea donde esta Dc.b que su codigo máquina no me lo concatena al registroS1, ahorita ya no me truena pero quiero quitarle todas las fallas posibles para asi cuando me lo revisen no tenga errores ni nada.

gracias
En línea
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: problema con cadena
« Respuesta #3 en: 12 Junio 2014, 11:07 am »
Código
  1. char* TIPO // ...
  2. char* tipo = "S1";

Realmente es necesario? También puedes aprovechar, ya puestos y hacer combinaciones con números:

Código
  1. char *TIPO, *T1po, *T1p0, *tIpO, *t1po //...

En serio, evita este tipo de prácticas. Además, si tipo (que no TIPO) es constante casi es mejor que lo declares con un define:

Código
  1. #define ETIQUETA_S1 "S1"
  2.  
  3. // ...
  4.  
  5. crearRegistroS1( ETIQUETA_S1, Longitud, direccion, codigo_datos, checksum );

También estaría bien que homogeneizases el código... parece que la función ha sido escrita por 20 personas diferentes:

* hay variables en minúsculas, en mayúsculas y mezcladas, con guión bajo y sin el, ... con las funciones pasa lo mismo
* declaras una variable para S1 pero luego en otros sitios utilizas valores puestos a pelo

Es mucho mejor que te propongas un formato para el código y que lo sigas con todas las consecuencias. Un pequeño ejemplo:

* las variables se nombran siempre en minúsculas y usando guiones bajos para separar las palabras: una_variable
* las funciones se nombran con nomenclatura lower Camel Case: funcionCalcularS1
* el tabulado del código será con espacios, no tabuladores, y cada tabulación constará de 3 espacios.
* las llaves de bucles, condicionales y funciones se ponen en una nueva línea.
* Después de una coma que separa argumentos se deja siempre un espacio.
...

Así todo el código presentará una estructura uniforme y será mucho más fácil de leer y de entender. Puedes encontrar diferentes guías ya hechas buscando en google.

También, por otro lado, deberías plantearte el agrupar las variables que están relacionadas entre ellas en estructuras. Es lo que te dije en el primer mensaje, usas 26 variables en esa función... seguro que algunas variables se pueden agrupar. Quedará claro que esas variables están relacionadas de alguna forma y eso mejorará la legibilidad... e incluso puede que consigas reducir el número de argumentos en alguna función.

No hay que tener miedo a declarar estructuras, bien usadas son muy buenos aliados.

Por otro lado, deberías plantearte la posibilidad de sacar cada posibilidad de "esDirectiva" a una función nueva. Lo suyo es intentar programar bajo la premisa: 1 función = 1 responsabilidad. En tu caso, la función leerTemporal se encarga de:

* leer un fichero
* interpretar sus funciones
* en función del tipo de instrucción realizar acciones personalizadas

eso son, al menos, 3 responsabilidades diferentes. Esto te lleva a tener un código monolítico que dificulta su mantenimiento, su expansión y su legibilidad (si, insisto mucho en la legibilidad... tengo mis motivos. Un código que no es legible es costoso de mantener y de interpretar. La legibilidad puede ser un bonus positivo o negativo en tu código y tú eres el que elige)

PD.: codigo_datos crea lagunas de memoria... no se hace el free correspondiente. Además, si siempre va a ser de 33 caracteres yo me plantearía usar memoria estática... C no está pensado para hacer reservas de memoria pequeñas... es muy ineficiente en este aspecto. Además, la memoria dinámica hay que usarla con cabeza y sólo cuando sea necesario, ya que complica la elaboración del código y facilita la aparición de lagunas de memoria.
En línea
m@o_614


Desconectado Desconectado

Mensajes: 389


Ver Perfil
Re: problema con cadena
« Respuesta #4 en: 12 Junio 2014, 22:16 pm »
gracias eferion, voy a tratar de quitarme todos esos vicios de programación que tengo. El codigo_datos no siempre va a ser de tamaño 33, sino que su máximo tamaño es 33(o 16 bytes). Y si por ejemplo declaro char cadena_datos[33], para asignarle una cadena como "2300", le pongo cadena_datos = "2300"???? y cuando tenga que inicializar el arreglo a 0(o sea que no contenga nada dentro) como le hago si quiero pasar el codigo_datos a la función inicializarVariables??

Código
  1. // codigo_datos esta declarado como char codigo_datos[33];
  2. void inicializarVariables(int *longitud_del_codigo,int *bytesDisponibles,char *codigo_datos)
  3. {
  4.     *longitud_del_codigo = 0;
  5.     *bytesDisponibles = 16;
  6.     *codigo_datos = 0; asii seria???
  7. }

y con un arreglo cadena_datos[33] también puedo usar el strcat??? para ir concatenando los códigos máquina que se me generen.
« Última modificación: 12 Junio 2014, 22:31 pm por m@o_614 » En línea
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: problema con cadena
« Respuesta #5 en: 13 Junio 2014, 08:20 am »
Cita de: m@o_614 en 12 Junio 2014, 22:16 pm
El codigo_datos no siempre va a ser de tamaño 33, sino que su máximo tamaño es 33(o 16 bytes). Y si por ejemplo declaro char cadena_datos[33], para asignarle una cadena como "2300", le pongo cadena_datos = "2300"????

Código
  1. strcpy( cadena_datos, "2300" );

Cita de: m@o_614 en 12 Junio 2014, 22:16 pm
... y cuando tenga que inicializar el arreglo a 0(o sea que no contenga nada dentro) como le hago si quiero pasar el codigo_datos a la función inicializarVariables??

El ejemplo que has puesto es perfectamente válido.

Cita de: m@o_614 en 12 Junio 2014, 22:16 pm
y con un arreglo cadena_datos[33] también puedo usar el strcat??? para ir concatenando los códigos máquina que se me generen.

No vas a notar diferencias entre crear el buffer en el stack (como te propongo) o en el heap (con malloc). En ambos casos cadena_datos va a ser un puntero. Para el uso que le vas a dar, la única diferencia palpable es que no vas a tener que usar malloc y free.
En línea
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
problema con cadena de texto
Programación Visual Basic 		pedraosone 9 3,055 Último mensaje 9 Noviembre 2007, 01:36 am
por pedraosone
Problema con comparar cadena??
Programación Visual Basic 		Hole_System 2 1,867 Último mensaje 11 Julio 2008, 09:08 am
por Hole_System
Problema senddata cadena
Programación Visual Basic 		Cromatico 0 1,332 Último mensaje 18 Enero 2012, 22:53 pm
por Cromatico
Problema con cadena
Programación C/C++ 		jaxoR 4 1,580 Último mensaje 25 Marzo 2014, 02:41 am
por rir3760
Problema al recorrer cadena
Programación C/C++ 		Joe Fraddy 8 3,084 Último mensaje 7 Octubre 2016, 21:11 pm
por Joe Fraddy
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines