problema con cadena

[m@o_614]

Saludos tengo el siguiente archivo:

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 (c) [Seleccionar] Expandir

void leerTEMPORAL(COD *cabeza,TABSIM **t,char *archivo)
{
   int car,indice,longitud_del_codigo = 0,longitud = 3,bytesDisponibles = 16,disponibles = 16,x = 0,base = 16;
   int direccionActual,bytesSumados;
   FILE *tmp;
   DIV division,*codMaquina;
   COD *seEncontro = NULL;
   char *TIPO,*VALOR,*ETIQUETA,*CODOP,*OPERANDO,*COD_MAQUINA;
   char *tipo = "S1",*Longitud,*direccion,*codigo_datos,*checksum,*nuevaDireccion;
   codigo_datos = (char*)calloc(33,sizeof(char));
   if((tmp = fopen("TEMPORAL.txt","r")) != NULL)
   {
       while((car = fgetc(tmp)) != EOF)
       {
           TIPO = Etiqueta_Codop_Operando(tmp,TIPO_);
           ignorarEspacios(tmp);
           VALOR = Etiqueta_Codop_Operando(tmp,VALOR_);
           ignorarEspacios(tmp);
           ETIQUETA = Etiqueta_Codop_Operando(tmp,ETIQUETA_);
           ignorarEspacios(tmp);
           CODOP = Etiqueta_Codop_Operando(tmp,CODOP_);
           ignorarEspacios(tmp);
           OPERANDO = Etiqueta_Codop_Operando(tmp,OPERANDO_);
           if((seEncontro = buscarCodop(cabeza,CODOP)) != NULL)
           {
               if(!verificarOperando(seEncontro,OPERANDO))
               {
                   indice = obtenerIndiceDireccionamiento(seEncontro,OPERANDO);
                   COD_MAQUINA = calcularCodigo_Maquina(seEncontro,indice,VALOR,ETIQUETA,CODOP,OPERANDO,t);
                   longitudValida(COD_MAQUINA,&longitud_del_codigo);
                   if(agregarCodigo_Maquina(longitud_del_codigo))
                   {
                       if(disponibles == 16)
                          direccion = VALOR;
                       strcat(codigo_datos,COD_MAQUINA);
                       disponibles = bytesDisponibles-longitud_del_codigo;
                   }
                   else
                   {
                       if(disponibles != 0)
                       {
                           if(disponibles == 16)
                              direccion = VALOR;
                           codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
                           strcat(codigo_datos,codMaquina->bytesRequeridos);
                           disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
                           Longitud = calcularLongitudS1(longitud,codigo_datos);
                           //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                           crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                           direccionActual = obtenerNumero(VALOR,x,base);
                           bytesSumados = obtenerNumero(codMaquina->bytesPendientes,x,base);
                           longitud_del_codigo = 0;
                           bytesDisponibles = 16;
                           longitudValida(COD_MAQUINA,&longitud_del_codigo);
                           if(agregarCodigo_Maquina(longitud_del_codigo))
                           {
                               strcpy(codigo_datos,codMaquina->bytesPendientes);
                               disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
                           }
                       }
                       else
                       {
                           Longitud = calcularLongitudS1(longitud,codigo_datos);
                           //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                           crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                           longitud_del_codigo = 0;
                           disponibles = 16;
                           direccion = VALOR;
                           *codigo_datos = 0;
                           longitudValida(COD_MAQUINA,&longitud_del_codigo);
                           if(agregarCodigo_Maquina(longitud_del_codigo))
                           {
                               strcpy(codigo_datos,COD_MAQUINA);
                               disponibles = bytesDisponibles-longitud_del_codigo;
                           }
                       }
                   }
               }
           }
           else if(esDirectivaCONSTANTES_1byte(CODOP)||esDirectivaCONSTANTES_2byte(CODOP)||esDirectivaCARACTERES(CODOP))
           {
               COD_MAQUINA = codigoMaquina_Directivas(VALOR,ETIQUETA,CODOP,OPERANDO);
               longitudValida(COD_MAQUINA,&longitud_del_codigo);
               if(agregarCodigo_Maquina(longitud_del_codigo))
               {
                   if(disponibles == 16)
                      direccion = VALOR;
                   strcat(codigo_datos,COD_MAQUINA);
                   disponibles = bytesDisponibles-longitud_del_codigo;
               }
               else
               {
                   if(disponibles != 0)
                   {
                       if(disponibles == 16)
                          direccion = VALOR;
                       codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
                       strcat(codigo_datos,codMaquina->bytesRequeridos);
                       disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
                       Longitud = calcularLongitudS1(longitud,codigo_datos);
                       //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                       crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                       direccionActual = obtenerNumero(VALOR,x,base);
                       bytesSumados = strlen(codMaquina->bytesRequeridos)/2;
                       nuevaDireccion = calcularDireccion(direccionActual,bytesSumados);
                       direccion = nuevaDireccion;
                       longitud_del_codigo = 0;
                       bytesDisponibles = 16;
                       *codigo_datos = 0;
                       longitudValida(COD_MAQUINA,&longitud_del_codigo);
                       if(agregarCodigo_Maquina(longitud_del_codigo))
                       {
                           strcpy(codigo_datos,codMaquina->bytesPendientes);
                           disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
                       }
                   }
                   else
                   {
                       Longitud = calcularLongitudS1(longitud,codigo_datos);
                       //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                       crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                       longitud_del_codigo = 0;
                       direccion = VALOR;
                       longitudValida(COD_MAQUINA,&longitud_del_codigo);
                       if(agregarCodigo_Maquina(longitud_del_codigo))
                       {
                           strcpy(codigo_datos,COD_MAQUINA);
                           disponibles = bytesDisponibles-longitud_del_codigo;
                       }
                   }
               }
           }
           else if(esDirectivaRESERVA_MEMORIA1byte(CODOP)||esDirectivaRESERVA_MEMORIA2byte(CODOP))
           {
               printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
               if(codigo_datos[CERO] != '\0')
               {
                   Longitud = calcularLongitudS1(longitud,codigo_datos);
                   //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                   crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                   longitud_del_codigo = 0;
                   disponibles = 16;
                   *codigo_datos = 0;
               }
           }
           else
           {
               if((strcmp(CODOP,"ORG")) == 0)
               {
                   printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
                   calcularS0(archivo);
               }
               else if((strcmp(CODOP,"END")) == 0)
               {
                   if(codigo_datos[CERO] != '\0')
                   {
                       Longitud = calcularLongitudS1(longitud,codigo_datos);
                       //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                       crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                   }
                   printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
                   crearArchivoS9();
               }
               else if((strcmp(CODOP,"EQU")) == 0)
                  printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
               else
               {
                   printf("%s   %s   %s   %s\t",VALOR,ETIQUETA,CODOP,OPERANDO);
                   printf("NO SE ENCONTRO EL CODOP DE OPERANDO\n");
               }
           }
       }
   }
   else
      printf("No se pudo abrir archivo\n");
}

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

[eferion]

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.

[m@o_614]

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 (c) [Seleccionar] Expandir

void leerTEMPORAL(COD *cabeza,TABSIM **t,char *archivo)
{
    int car,indice,longitud_del_codigo = 0,longitud = 3,bytesDisponibles = 16,disponibles = 16;
    FILE *tmp;
    DIV division,*codMaquina;
    COD *seEncontro = NULL;
    char *TIPO,*VALOR,*ETIQUETA,*CODOP,*OPERANDO,*COD_MAQUINA;
    char *tipo = "S1",*Longitud,*direccion,*codigo_datos,*checksum;
    codigo_datos = (char*)calloc(33,sizeof(char));
    if((tmp = fopen("TEMPORAL.txt","r")) != NULL)
    {
        while((car = fgetc(tmp)) != EOF)
        {
            TIPO = Etiqueta_Codop_Operando(tmp,TIPO_);
            ignorarEspacios(tmp);
            VALOR = Etiqueta_Codop_Operando(tmp,VALOR_);
            ignorarEspacios(tmp);
            ETIQUETA = Etiqueta_Codop_Operando(tmp,ETIQUETA_);
            ignorarEspacios(tmp);
            CODOP = Etiqueta_Codop_Operando(tmp,CODOP_);
            ignorarEspacios(tmp);
            OPERANDO = Etiqueta_Codop_Operando(tmp,OPERANDO_);
            if((seEncontro = buscarCodop(cabeza,CODOP)) != NULL)
            {
                if(!verificarOperando(seEncontro,OPERANDO))
                {
                    indice = obtenerIndiceDireccionamiento(seEncontro,OPERANDO);
                    COD_MAQUINA = calcularCodigo_Maquina(seEncontro,indice,VALOR,ETIQUETA,CODOP,OPERANDO,t);
                    longitudValida(COD_MAQUINA,&longitud_del_codigo);
                    if(agregarCodigo_Maquina(longitud_del_codigo))
                    {
                        if(disponibles == 16)
                           direccion = VALOR;
                        strcat(codigo_datos,COD_MAQUINA);
                        disponibles = bytesDisponibles-longitud_del_codigo;
                    }
                    else
                    {
                        if(disponibles != 0)
                        {
                            codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
                            strcat(codigo_datos,codMaquina->bytesRequeridos);
                            disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
                            Longitud = calcularLongitudS1(longitud,codigo_datos);
                            checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                            crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                            direccion = nuevaDireccion(codMaquina,VALOR);
                            inicializarVariables(&longitud_del_codigo,&bytesDisponibles);
                            longitudValida(COD_MAQUINA,&longitud_del_codigo);
                            if(agregarCodigo_Maquina(longitud_del_codigo))
                            {
                                *codigo_datos = 0;
                                strcpy(codigo_datos,codMaquina->bytesPendientes);
                                disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
                            }
                        }
                        else
                        {
                            Longitud = calcularLongitudS1(longitud,codigo_datos);
                            checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                            crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                            inicializarVariables(&longitud_del_codigo,&disponibles);
                            direccion = VALOR;
                            *codigo_datos = 0;
                            longitudValida(COD_MAQUINA,&longitud_del_codigo);
                            if(agregarCodigo_Maquina(longitud_del_codigo))
                            {
                                strcpy(codigo_datos,COD_MAQUINA);
                                disponibles = bytesDisponibles-longitud_del_codigo;
                            }
                        }
                    }
                }
            }
            else if(esDirectivaCONSTANTES_1byte(CODOP)||esDirectivaCONSTANTES_2byte(CODOP)||esDirectivaCARACTERES(CODOP))
            {
                COD_MAQUINA = codigoMaquina_Directivas(VALOR,ETIQUETA,CODOP,OPERANDO);
                longitudValida(COD_MAQUINA,&longitud_del_codigo);
                if(agregarCodigo_Maquina(longitud_del_codigo))
                {
                    if(disponibles == 16)
                       direccion = VALOR;
                    strcat(codigo_datos,COD_MAQUINA);
                    disponibles = bytesDisponibles-longitud_del_codigo;
                }
                else
                {
                    if(disponibles != 0)
                    {
                        codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
                        strcat(codigo_datos,codMaquina->bytesRequeridos);
                        disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
                        Longitud = calcularLongitudS1(longitud,codigo_datos);
                        checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                        crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                        direccion = nuevaDireccion(codMaquina,VALOR);
                        inicializarVariables(&longitud_del_codigo,&bytesDisponibles);
                        *codigo_datos = 0;
                        longitudValida(COD_MAQUINA,&longitud_del_codigo);
                        if(agregarCodigo_Maquina(longitud_del_codigo))
                        {
                            strcpy(codigo_datos,codMaquina->bytesPendientes);
                            disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
                        }
                    }
                    else
                    {
                        Longitud = calcularLongitudS1(longitud,codigo_datos);
                        checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                        crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                        inicializarVariables(&longitud_del_codigo,&bytesDisponibles);
                        direccion = VALOR;
                        longitudValida(COD_MAQUINA,&longitud_del_codigo);
                        if(agregarCodigo_Maquina(longitud_del_codigo))
                        {
                            strcpy(codigo_datos,COD_MAQUINA);
                            disponibles = bytesDisponibles-longitud_del_codigo;
                        }
                    }
                }
            }
            else if(esDirectivaRESERVA_MEMORIA1byte(CODOP)||esDirectivaRESERVA_MEMORIA2byte(CODOP))
            {
                printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
                if(codigo_datos[CERO] != '\0')
                {
                    Longitud = calcularLongitudS1(longitud,codigo_datos);
                    checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                    crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                    inicializarVariables(&longitud_del_codigo,&disponibles);
                    *codigo_datos = 0;
                }
            }
            else
            {
                if((strcmp(CODOP,"ORG")) == 0)
                {
                    printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
                    calcularS0(archivo);
                }
                else if((strcmp(CODOP,"END")) == 0)
                {
                    if(codigo_datos[CERO] != '\0')
                    {
                        Longitud = calcularLongitudS1(longitud,codigo_datos);
                        checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                        crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                    }
                    printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
                    crearArchivoS9();
                }
                else if((strcmp(CODOP,"EQU")) == 0)
                   printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
                else
                {
                    printf("%s   %s   %s   %s\t",VALOR,ETIQUETA,CODOP,OPERANDO);
                    printf("NO SE ENCONTRO EL CODOP DE OPERANDO\n");
                }
            }
        }
    }
    else
       printf("No se pudo abrir archivo\n");
}

y las funciones que recien hice son estas:

Código (c) [Seleccionar] Expandir

void inicializarVariables(int *longitud_del_codigo,int *bytesDisponibles)
{
    *longitud_del_codigo = 0;
    *bytesDisponibles = 16;
}

char *nuevaDireccion(DIV *codMaquina,char *VALOR)
{
    int suma,bytesAgregados,direccionActual,x = 0,base = 16;
    char *direccion;
    direccion = (char*)calloc(5,sizeof(char));
    bytesAgregados = strlen(codMaquina->bytesRequeridos)/2;
    direccionActual = obtenerNumero(VALOR,x,base);
    suma = direccionActual+bytesAgregados;
    sprintf(direccion,"%04X",suma);
    return direccion;
}

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

[eferion]

Código (c) [Seleccionar] Expandir


char* TIPO // ...
char* tipo = "S1";

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

Código (c) [Seleccionar] Expandir

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 (c) [Seleccionar] Expandir


#define ETIQUETA_S1 "S1"

// ...

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.

[m@o_614]

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 (c) [Seleccionar] Expandir


// codigo_datos esta declarado como char codigo_datos[33];
void inicializarVariables(int *longitud_del_codigo,int *bytesDisponibles,char *codigo_datos)
{
    *longitud_del_codigo = 0;
    *bytesDisponibles = 16;
    *codigo_datos = 0; asii seria???
}

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.

[eferion]

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 (c) [Seleccionar] Expandir

strcpy( 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??

El ejemplo que has puesto es perfectamente válido.

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.