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

 

 


Tema destacado: Usando Git para manipular el directorio de trabajo, el índice y commits (segunda parte)


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 [14] 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 ... 40
131  Programación / Programación C/C++ / Re: Process returned 0 en: 21 Enero 2014, 04:06 am
ohhh si ya me fije lo que le falto, se me olvido ponerle los encabezados de las funciones

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #define MAX 8
  5.  
  6. typedef enum {INS,OP,DIR,MAQ,CAL,X_CAL,TOTAL} tabla;
  7.  
  8. typedef struct nodo
  9. {
  10.     char *instruccion;
  11.     char *operando;
  12.     char *modo_direccionamiento[MAX];
  13.     char *codigo_maquina[MAX];
  14.     char *bytes_calculados[MAX];
  15.     char *bytes_x_calcular[MAX];
  16.     char *suma_bytes[MAX];
  17.     struct nodo *sig;
  18. }COD;
  19.  
  20. void quitarSaltosLinea(char *cadena);
  21. void buscarFinLinea(FILE *fd);
  22. void ignorarEspacios(FILE *fd);
  23. void imprimirLista(COD *cabeza);
  24. char *Tabla_Operandos(FILE *hc12,int tabla);
  25.  
  26. int main()
  27. {
  28.     int car,i;
  29.     FILE *hc12;
  30.     COD *cabeza = NULL,*ultimo;
  31.     char *ins,*op,*dir[MAX],*maq[MAX],*cal[MAX],*x_cal[MAX],*suma[MAX];
  32.     if((hc12 = fopen("archivo.txt","r"))!= NULL)
  33.     {
  34.         while((car = fgetc(hc12))!= EOF)
  35.         {
  36.             i = 0;
  37.             ins = Tabla_Operandos(hc12,INS);
  38.             printf("%s\t",ins);
  39.             ignorarEspacios(hc12);
  40.             op = Tabla_Operandos(hc12,OP);
  41.             printf("%s",op);
  42.             do
  43.             {
  44.                 ignorarEspacios(hc12);
  45.                 dir[i] = Tabla_Operandos(hc12,DIR);
  46.                 printf("\t%s\t",dir[i]);
  47.                 ignorarEspacios(hc12);
  48.                 maq[i] = Tabla_Operandos(hc12,MAQ);
  49.                 printf("%s\t",maq[i]);
  50.                 ignorarEspacios(hc12);
  51.                 cal[i] = Tabla_Operandos(hc12,CAL);
  52.                 printf("%s\t",cal[i]);
  53.                 ignorarEspacios(hc12);
  54.                 x_cal[i] = Tabla_Operandos(hc12,X_CAL);
  55.                 printf("%s\t",x_cal[i]);
  56.                 ignorarEspacios(hc12);
  57.                 suma[i] = Tabla_Operandos(hc12,TOTAL);
  58.                 printf("%s\n",suma[i]);
  59.                 buscarFinLinea(hc12);
  60.                 printf("*%c*",car);
  61.                 i++;
  62.             }while(car == '\t');
  63.         }
  64.     }
  65.     return 0;
  66. }
  67.  
  68. void buscarFinLinea(FILE *hc12)
  69. {
  70.     int car;
  71.     while((car = fgetc(hc12))!= '\n' && car != EOF)
  72.         ;
  73. }
  74.  
  75. void ignorarEspacios(FILE *hc12)
  76. {
  77.     int car;
  78.     do
  79.     {
  80.         car = fgetc(hc12);
  81.     }while(car == '\t' || car == ' ');
  82. }
  83.  
  84. char *Tabla_Operandos(FILE *hc12,int tabla)
  85. {
  86.  
  87.     int car,lon = 0,pos;
  88.     char *cadena;
  89.     fseek(hc12,-1,SEEK_CUR);
  90.     pos = ftell(hc12);
  91.     if((tabla==INS)||(tabla==OP)||(tabla==DIR)||(tabla==MAQ)||(tabla==CAL)||(tabla==X_CAL))
  92.     {
  93.         do
  94.         {
  95.             car = fgetc(hc12);
  96.             lon++;
  97.         }while(car != '\t' && car != EOF);
  98.     }
  99.     else
  100.     {
  101.         do
  102.         {
  103.             car = fgetc(hc12);
  104.             lon++;
  105.         }while(car != '\n' && car != EOF);
  106.         lon--;
  107.     }
  108.     fseek(hc12,pos,SEEK_SET);
  109.     cadena = (char*)calloc((lon+1),sizeof(char));
  110.     fgets(cadena,lon+1,hc12);
  111.     quitarSaltosLinea(cadena);
  112.     return cadena;
  113. }
  114.  
  115. void quitarSaltosLinea(char *cadena)
  116. {
  117.     char *ptr;
  118.     if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
  119.        *ptr = '\0';
  120. }
  121.  

y el problema esta en que no imprime el archivo como deberia
132  Programación / Programación C/C++ / Re: Process returned 0 en: 21 Enero 2014, 01:08 am
leosansan si tienes razon el primer codigo me falto poner varias cosas, pero ahora el codigo que me da problemas es el ultimo que postee, el que tiene algunas cosas modificadas
133  Programación / Programación C/C++ / Re: Process returned 0 en: 20 Enero 2014, 21:36 pm
Saludos amchacon y gracias por tu respuesta, tenias razon el problema es que tenia que agregarle la condicion de car != EOF, y ahora ya funciona, solo que ahora cambie un poco el codigo porque le agregue unas lineas al archivo, el archivo es el siguiente:

Citar
ADCA   SI   IMM      89ii      1   1   2
                   DIR      99dd      1   1   2
                   EXT      B9hhll      1   2   3
                   IDX      A9xb      1   1   2
                   IDX1      A9xbff      1   2   3
                   IDX2      A9xbeeff   1   3   4
                   [D,IDX]     A9xb      1   1   2
                   [IDX2]   A9xbeeff   1   3   4
ADCB   SI   IMM      C9ii      1   1   2
                  DIR      D9dd      1   1   2
                  EXT      F9hhll      1   2   3
                  IDX      E9xb      1   1   2
                  IDX1      E9xbff      1   2   3
                  IDX2      E9xbeeff   1   3   4
                  [D,IDX]   E9xb      1   1   2
                  [IDX2]   E9xbeeff   1   3   4
antes el archivo solo tenia la informacion del codop ADCA pero para que me leyera el de ADCB tambien, tuve que modificarlo, el codigo si me imprime ,solo que me imprime unos espacios en blanco que sobran despues de leer la ultima linea del archivo y tambien la informacion del [D,IDX] del codop ADCB no la imprime completa y tampoco la del IMM del ADCB, por que sera esto??

el codigo es:
Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #define MAX 8
  5.  
  6. typedef enum {INS,OP,DIR,MAQ,CAL,X_CAL,TOTAL} tabla;
  7.  
  8. int main()
  9. {
  10.     int car,i;
  11.     FILE *hc12;
  12.     COD *cabeza = NULL,*ultimo;
  13.     char *ins,*op,*dir[MAX],*maq[MAX],*cal[MAX],*x_cal[MAX],*suma[MAX];
  14.     if((hc12 = fopen("archivo.txt","r"))!= NULL)
  15.     {
  16.         while((car = fgetc(hc12))!= EOF)
  17.         {
  18.             i = 0;
  19.             ins = Tabla_Operandos(hc12,INS);
  20.             printf("%s\t",ins);
  21.             ignorarEspacios(hc12);
  22.             op = Tabla_Operandos(hc12,OP);
  23.             printf("%s",op);
  24.             do
  25.             {
  26.                 ignorarEspacios(hc12);
  27.                 dir[i] = Tabla_Operandos(hc12,DIR);
  28.                 printf("\t%s\t",dir[i]);
  29.                 ignorarEspacios(hc12);
  30.                 maq[i] = Tabla_Operandos(hc12,MAQ);
  31.                 printf("%s\t",maq[i]);
  32.                 ignorarEspacios(hc12);
  33.                 cal[i] = Tabla_Operandos(hc12,CAL);
  34.                 printf("%s\t",cal[i]);
  35.                 ignorarEspacios(hc12);
  36.                 x_cal[i] = Tabla_Operandos(hc12,X_CAL);
  37.                 printf("%s\t",x_cal[i]);
  38.                 ignorarEspacios(hc12);
  39.                 suma[i] = Tabla_Operandos(hc12,TOTAL);
  40.                 printf("%s\n",suma[i]);
  41.                 buscarFinLinea(hc12);
  42.                 i++;
  43.             }while(car == '\t' && car != EOF);
  44.         }
  45.     }
  46.     return 0;
  47. }
  48.  
  49. void buscarFinLinea(FILE *fd)
  50. {
  51.     int car;
  52.     while((car = fgetc(fd))!= '\n' && car != EOF)
  53.         ;
  54. }
  55.  
  56. void ignorarEspacios(FILE *fd)
  57. {
  58.     int car;
  59.     do
  60.     {
  61.         car = fgetc(fd);
  62.     }while(car == '\t' || car == ' ');
  63. }
  64.  
  65. char *Tabla_Operandos(FILE *hc12,int tabla)
  66. {
  67.  
  68.     int car,lon = 0,pos;
  69.     char *cadena;
  70.     fseek(hc12,-1,SEEK_CUR);
  71.     pos = ftell(hc12);
  72.     if((tabla==INS)||(tabla==OP)||(tabla==DIR)||(tabla==MAQ)||(tabla==CAL)||(tabla==X_CAL))
  73.     {
  74.         do
  75.         {
  76.             car = fgetc(hc12);
  77.             lon++;
  78.         }while(car != '\t' && car != EOF);
  79.     }
  80.     else
  81.     {
  82.         do
  83.         {
  84.             car = fgetc(hc12);
  85.             lon++;
  86.         }while(car != '\n' && car != EOF);
  87.         lon--;
  88.     }
  89.     fseek(hc12,pos,SEEK_SET);
  90.     cadena = (char*)calloc((lon+1),sizeof(char));
  91.     fgets(cadena,lon+1,hc12);
  92.     quitarSaltosLinea(cadena);
  93.     return cadena;
  94. }
  95.  
  96. void quitarSaltosLinea(char *cadena)
  97. {
  98.     char *ptr;
  99.     if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
  100.        *ptr = '\0';
  101. }
  102.  

gracias
134  Programación / Programación C/C++ / Process returned 0 en: 19 Enero 2014, 23:40 pm
Saludos, tengo entendido que al compilar un programa si te aparece un mensaje que diga Process returned 0 (0x0) quiere decir que compilo bien y sin errores, pero a mi en el siguiente codigo no me aparece ese mensaje, pero tampoco me aparecen mensajes de error o warnings, el programa tiene que leer un archivo y almacenar algunos datos en la variable que le corresponda, pero no se donde esta el error?? y por que el programa no termina como deberia

Código
  1. int main()
  2. {
  3.     int car,i;
  4.     FILE *hc12;
  5.     COD *cabeza = NULL,*ultimo;
  6.     char *ins,*op,*dir[MAX],*maq[MAX],*cal[MAX],*x_cal[MAX],*suma[MAX];
  7.     if((hc12 = fopen("archivo.txt","r"))!= NULL)
  8.     {
  9.         while((car = fgetc(hc12))!= EOF)
  10.         {
  11.             i = 0;
  12.             ins = Tabla_Operandos(hc12);
  13.             printf("%s\t",ins);
  14.             ignorarEspacios(hc12);
  15.             op = Tabla_Operandos(hc12);
  16.             printf("%s",op);
  17.             do
  18.             {
  19.                 ignorarEspacios(hc12);
  20.                 dir[i] = Tabla_Operandos(hc12);
  21.                 printf("\t\t%s\t",dir[i]);
  22.                 ignorarEspacios(hc12);
  23.                 maq[i] = Tabla_Operandos(hc12);
  24.                 printf("%s\t",maq[i]);
  25.                 ignorarEspacios(hc12);
  26.                 cal[i] = Tabla_Operandos(hc12);
  27.                 printf("%s\t",cal[i]);
  28.                 ignorarEspacios(hc12);
  29.                 x_cal[i] = Tabla_Operandos(hc12);
  30.                 printf("%s\t",x_cal[i]);
  31.                 ignorarEspacios(hc12);
  32.                 suma[i] = Tabla_Operandos(hc12);
  33.                 printf("%s\n",suma[i]);
  34.                 buscarFinLinea(hc12);
  35.                 i++;
  36.             }while(car == '\t');
  37.         }
  38.     }
  39.     return 0;
  40. }
  41.  
  42. void buscarFinLinea(FILE *fd)
  43. {
  44.     int car;
  45.     while((car = fgetc(fd))!= '\n')
  46.         ;
  47. }
  48.  
  49. void ignorarEspacios(FILE *fd)
  50. {
  51.     int car;
  52.     do
  53.     {
  54.         car = fgetc(fd);
  55.     }while(car == '\t' || car == ' ');
  56. }
  57.  
  58. char *Tabla_Operandos(FILE *hc12)
  59. {
  60.     int car,lon = 0,pos;
  61.     char *cadena;
  62.     fseek(hc12,-1,SEEK_CUR);
  63.     pos = ftell(hc12);
  64.     do
  65.     {
  66.         car = fgetc(hc12);
  67.         lon++;
  68.     }while(car != '\t' && car != ' ');
  69.     fseek(hc12,pos,SEEK_SET);
  70.     cadena = calloc(lon+1);
  71.     fgets(cadena,lon+1,hc12);
  72.     quitarSaltosLinea(cadena);
  73.     return cadena;
  74. }
  75.  

de antemano gracias
135  Programación / Programación C/C++ / Re: Lista con arrays en: 16 Enero 2014, 19:19 pm
gracias rir3760 tratare de pensar en alguna manera de sustituir el fseek aunque por ahora no se me ocurre nada, tambien le hice modificaciones al codigo y ya no me aparecen errores ni warnings pero el codigo me truena no entiendo por que

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. typedef struct nodo
  6. {
  7.     char *codigo;
  8.     char *Operando;
  9.     char *modo_direccionamiento[8];
  10.     char *codigo_maquina[8];
  11.     char *bytes_calculados[8];
  12.     char *bytes_x_calcular[8];
  13.     char *total_bytes[8];
  14.     struct nodo *sig;
  15. }COD;
  16.  
  17. void imprimirLista(COD *cabeza);
  18. void buscarFinLinea(FILE *hc12);
  19. void ignorarEspacios(FILE *hc12);
  20. char *Tabla_Operandos(FILE *hc12);
  21. void insertarFinal(char *ins,char *op,char **dir,char **maq,char **calculado,char **calcular,char **total,COD *ultimo,int i);
  22. COD *ultimoElemento(COD *cabeza);
  23. COD *crearNodo(char *ins,char *op,char **dir,char **maq,char **calculado,char **calcular,char **total,int i);
  24. void quitarSaltosLinea(char *cadena);
  25.  
  26. int main()
  27. {
  28.     COD *cabeza = NULL,*ultimo;
  29.     FILE *hc12;
  30.     int car,i;
  31.     char *ins,*op,*dir[8],*maq[8],*calculado[8],*calcular[8],*total[8];
  32.     if((hc12 = fopen("archivo.txt","r"))!= NULL)
  33.     {
  34.         i = 0;
  35.         while((car = fgetc(hc12))!= EOF)
  36.         {
  37.             if(car != '\t')
  38.             {
  39.                 ins = Tabla_Operandos(hc12);
  40.                 ignorarEspacios(hc12);
  41.                 op = Tabla_Operandos(hc12);
  42.                 ignorarEspacios(hc12);
  43.                 dir[i] = Tabla_Operandos(hc12);
  44.                 ignorarEspacios(hc12);
  45.                 maq[i] = Tabla_Operandos(hc12);
  46.                 ignorarEspacios(hc12);
  47.                 calculado[i] = Tabla_Operandos(hc12);
  48.                 ignorarEspacios(hc12);
  49.                 calcular[i] = Tabla_Operandos(hc12);
  50.                 ignorarEspacios(hc12);
  51.                 total[i] = Tabla_Operandos(hc12);
  52.                 buscarFinLinea(hc12);
  53.                 i++;
  54.                 if(cabeza == NULL)
  55.                    cabeza = crearNodo(ins,op,dir,maq,calculado,calcular,total,i);
  56.                 else
  57.                 {
  58.                     ultimo = ultimoElemento(cabeza);
  59.                     insertarFinal(ins,op,dir,maq,calculado,calcular,total,ultimo,i);
  60.                 }
  61.             }
  62.             else
  63.             {/*
  64.                 dir[i] = Tabla_Operandos(hc12);
  65.                 ignorarEspacios(hc12);
  66.                 maq[i] = Tabla_Operandos(hc12);
  67.                 ignorarEspacios(hc12);
  68.                 calculado[i] = Tabla_Operandos(hc12);
  69.                 ignorarEspacios(hc12);
  70.                 calcular[i] = Tabla_Operandos(hc12);
  71.                 ignorarEspacios(hc12);
  72.                 total[i] = Tabla_Operandos(hc12);
  73.                 i++;*/
  74.                 buscarFinLinea(hc12);
  75.             }
  76.         }
  77.         //imprimirLista(cabeza);
  78.     }
  79.     else
  80.        printf("No se pudo abrir archivo\n");
  81.     return 0;
  82. }
  83.  
  84. void buscarFinLinea(FILE *fd)
  85. {
  86.     int car;
  87.     while((car = fgetc(fd))!= '\n')
  88.         ;
  89. }
  90.  
  91. void ignorarEspacios(FILE *fd)
  92. {
  93.     int car;
  94.     do
  95.     {
  96.         car = fgetc(fd);
  97.     }while(car == '\t' || car == ' ');
  98. }
  99.  
  100. char *Tabla_Operandos(FILE *hc12)
  101. {
  102.     int car,lon = 0,pos;
  103.     char *cadena;
  104.     fseek(hc12,-1,SEEK_CUR);
  105.     pos = ftell(hc12);
  106.     do
  107.     {
  108.         car = fgetc(hc12);
  109.         lon++;
  110.     }while(car != '\t');
  111.     fseek(hc12,pos,SEEK_SET);
  112.     cadena = (char*)calloc((lon+1),sizeof(char));
  113.     fgets(cadena,lon+1,hc12);
  114.     quitarSaltosLinea(cadena);
  115.     return cadena;
  116. }
  117.  
  118. void quitarSaltosLinea(char *cadena)
  119. {
  120.     char *ptr;
  121.     if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
  122.        *ptr = '\0';
  123. }
  124.  
  125. void insertarFinal(char *ins,char *op,char **dir,char **maq,char **calculado,char **calcular,char **total,COD *ultimo,int i)
  126. {
  127.     ultimo->sig = crearNodo(ins,op,dir,maq,calculado,calcular,total,i);
  128.     ultimo->sig->sig = NULL;
  129.     ultimo = ultimo->sig;
  130. }
  131.  
  132. COD *ultimoElemento(COD *cabeza)
  133. {
  134.     COD *ptr;
  135.     ptr = cabeza;
  136.     while(ptr->sig != NULL)
  137.        ptr = ptr->sig;
  138.     return ptr;
  139. }
  140.  
  141. COD *crearNodo(char *ins,char *op,char **dir,char **maq,char **calculado,char **calcular,char **total,int i)
  142. {
  143.     COD *x;
  144.     int tam,tam1,tam2,tam3,tam4,tam5,tam6;
  145.     tam = strlen(ins);
  146.     tam1 = strlen(op);
  147.     tam2 = strlen(dir[i]);
  148.     tam3 = strlen(maq[i]);
  149.     tam4 = strlen(calculado[i]);
  150.     tam5 = strlen(calcular[i]);
  151.     tam6 = strlen(total[i]);
  152.     x = malloc(sizeof(COD));
  153.     x->codigo = (char*)malloc(tam+1);
  154.     x->Operando = (char*)malloc(tam1+1);
  155.     x->modo_direccionamiento[i] = (char*)malloc(tam2+1);
  156.     x->codigo_maquina[i] = (char*)malloc(tam3+1);
  157.     x->bytes_calculados[i] = (char*)malloc(tam4+1);
  158.     x->bytes_x_calcular[i] = (char*)malloc(tam5+1);
  159.     x->total_bytes[i] = (char*)malloc(tam6+1);
  160.     strcpy(x->codigo,ins);
  161.     strcpy(x->Operando,op);
  162.     strcpy(x->modo_direccionamiento[i],dir[i]);
  163.     strcpy(x->codigo_maquina[i],maq[i]);
  164.     strcpy(x->bytes_calculados[i],calculado[i]);
  165.     strcpy(x->bytes_x_calcular[i],calcular[i]);
  166.     strcpy(x->total_bytes[i],total[i]);
  167.     x->sig = NULL;
  168.     return x;
  169. }
136  Programación / Programación C/C++ / Re: Lista con arrays en: 16 Enero 2014, 01:18 am
las lineas de warning aparecen en las variables
Código
  1. calculado[i] = Tabla_Operandos(hc12);
y tambien en
Código
  1. calcular[i] = Tabla_Operandos(hc12);
y la de total.

si hago el codigo de esta manera:

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. typedef struct nodo
  6. {
  7.     char *codigo;
  8.     char *Operando;
  9.     char *modo_direccionamiento;
  10.     char *codigo_maquina;
  11.     char *bytes_calculados;
  12.     char *bytes_x_calcular;
  13.     char *total_bytes;
  14.     struct nodo *sig;
  15. }COD;
  16.  
  17. void imprimirLista(COD *cabeza);
  18. void buscarFinLinea(FILE *hc12);
  19. void ignorarEspacios(FILE *hc12);
  20. char *Tabla_Operandos(FILE *hc12);
  21. void insertarFinal(char *ins,char *op,char *dir,char *maq,char *calculado,char *calcular,char *total,COD *ultimo);
  22. COD *ultimoElemento(COD *cabeza);
  23. COD *crearNodo(char *ins,char *op,char *dir,char *maq,char *calculado,char *calcular,char *total);
  24. void quitarSaltosLinea(char *cadena);
  25.  
  26. int main()
  27. {
  28.     COD *cabeza = NULL,*ultimo;
  29.     FILE *hc12;
  30.     int car;
  31.     char *ins,*op,*dir,*maq,*calculado,*calcular,*total;
  32.     if((hc12 = fopen("archivo.txt","r"))!= NULL)
  33.     {
  34.         while((car = fgetc(hc12))!= EOF)
  35.         {
  36.             if(car != '\t')
  37.             {
  38.                 ins = Tabla_Operandos(hc12);
  39.                 ignorarEspacios(hc12);
  40.                 op = Tabla_Operandos(hc12);
  41.                 ignorarEspacios(hc12);
  42.                 dir = Tabla_Operandos(hc12);
  43.                 ignorarEspacios(hc12);
  44.                 maq = Tabla_Operandos(hc12);
  45.                 ignorarEspacios(hc12);
  46.                 calculado = Tabla_Operandos(hc12);
  47.                 ignorarEspacios(hc12);
  48.                 calcular = Tabla_Operandos(hc12);
  49.                 ignorarEspacios(hc12);
  50.                 total = Tabla_Operandos(hc12);
  51.                 buscarFinLinea(hc12);
  52.                 if(cabeza == NULL)
  53.                    cabeza = crearNodo(ins,op,dir,maq,calculado,calcular,total);
  54.                 else
  55.                 {
  56.                     ultimo = ultimoElemento(cabeza);
  57.                     insertarFinal(ins,op,dir,maq,calculado,calcular,total,ultimo);
  58.                 }
  59.             }
  60.             else
  61.                buscarFinLinea(hc12);
  62.         }
  63.         imprimirLista(cabeza);
  64.     }
  65.     else
  66.        printf("No se pudo abrir archivo\n");
  67.     return 0;
  68. }
  69.  
  70. void buscarFinLinea(FILE *fd)
  71. {
  72.     int car;
  73.     while((car = fgetc(fd))!= '\n')
  74.         ;
  75. }
  76.  
  77. void ignorarEspacios(FILE *fd)
  78. {
  79.     int car;
  80.     do
  81.     {
  82.         car = fgetc(fd);
  83.     }while(car == '\t' || car == ' ');
  84. }
  85.  
  86. char *Tabla_Operandos(FILE *hc12)
  87. {
  88.     int car,lon = 0,pos;
  89.     char *cadena;
  90.     fseek(hc12,-1,SEEK_CUR);
  91.     pos = ftell(hc12);
  92.     do
  93.     {
  94.         car = fgetc(hc12);
  95.         lon++;
  96.     }while(car != '\t');
  97.     fseek(hc12,pos,SEEK_SET);
  98.     cadena = (char*)calloc((lon+1),sizeof(char));
  99.     fgets(cadena,lon+1,hc12);
  100.     quitarSaltosLinea(cadena);
  101.     return cadena;
  102. }
  103.  
  104. void quitarSaltosLinea(char *cadena)
  105. {
  106.     char *ptr;
  107.     if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
  108.        *ptr = '\0';
  109. }
  110.  
  111. void insertarFinal(char *ins,char *op,char *dir,char *maq,char *calculado,char *calcular,char *total,COD *ultimo)
  112. {
  113.     ultimo->sig = crearNodo(ins,op,dir,maq,calculado,calcular,total);
  114.     ultimo->sig->sig = NULL;
  115.     ultimo = ultimo->sig;
  116. }
  117.  
  118. COD *ultimoElemento(COD *cabeza)
  119. {
  120.     COD *ptr;
  121.     ptr = cabeza;
  122.     while(ptr->sig != NULL)
  123.        ptr = ptr->sig;
  124.     return ptr;
  125. }
  126.  
  127. COD *crearNodo(char *ins,char *op,char *dir,char *maq,char *calculado,char *calcular,char *total)
  128. {
  129.     COD *x;
  130.     int tam,tam1,tam2,tam3,tam4,tam5,tam6;
  131.     tam = strlen(ins);
  132.     tam1 = strlen(op);
  133.     tam2 = strlen(dir);
  134.     tam3 = strlen(maq);
  135.     tam4 = strlen(calculado);
  136.     tam5 = strlen(calcular);
  137.     tam6 = strlen(total);
  138.     x = (COD*)malloc(sizeof(COD));
  139.     x->codigo = (char*)malloc((tam+1)*sizeof(char));
  140.     x->Operando = (char*)malloc((tam1+1)*sizeof(char));
  141.     x->modo_direccionamiento = (char*)malloc((tam2+1)*sizeof(char));
  142.     x->codigo_maquina = (char*)malloc((tam3+1)*sizeof(char));
  143.     x->bytes_calculados = (char*)malloc((tam4+1)*sizeof(char));
  144.     x->bytes_x_calcular = (char*)malloc((tam5+1)*sizeof(char));
  145.     x->total_bytes = (char*)malloc((tam6+1)*sizeof(char));
  146.     strcpy(x->codigo,ins);
  147.     strcpy(x->Operando,op);
  148.     strcpy(x->modo_direccionamiento,dir);
  149.     strcpy(x->codigo_maquina,maq);
  150.     strcpy(x->bytes_calculados,calculado);
  151.     strcpy(x->bytes_x_calcular,calcular);
  152.     strcpy(x->total_bytes,total);
  153.     x->sig = NULL;
  154.     return x;
  155. }
  156.  
  157. void imprimirLista(COD *cabeza)
  158. {
  159.     COD *ptr;
  160.     for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
  161.     {
  162.         printf("%s\t",ptr->codigo);
  163.         printf("%s\t",ptr->Operando);
  164.         printf("%s\t",ptr->modo_direccionamiento);
  165.         printf("%s\t\t",ptr->codigo_maquina);
  166.         printf("%s\t",ptr->bytes_calculados);
  167.         printf("%s\t",ptr->bytes_x_calcular);
  168.         printf("%s\n",ptr->total_bytes);
  169.     }
  170. }
  171.  

funciona correctamente y me imprime la primer linea del archivo:

codop    operan  direccionamiento   cod maquina   bytes     etc    etc
ADCA     SI        IMM                        89ii        1          1   2   

pero no me imprime los demas lineas, es por eso que queria que los direccionamientos, codigos maquina, etc... fueran arrays para que asi cupieran todos, pero no se como hacer para que  las variables dir, maq, calculado, calcular, total me puedan almacenar un solo elemento y despues poder modificarla para que sea un array, no se si me di a entender espero que si :(
137  Programación / Programación C/C++ / Lista con arrays en: 15 Enero 2014, 19:51 pm
Saludos tengo el siguiente archivo de texto:

ADCA****SI***IMM***89ii******1***1***2
**************DIR***99dd*****1***1***2   
**************EXT***B9hhll****1***2***3   
**************IDX***A9xb*****1***1***2   
**************IDX1**A9xbff****1***2***3   
**************IDX2**A9xbeeff**1***3***4   

los * son espacios
Y tengo que leer este archivo y que me guarde cada uno de los elementos en una variable para esto se me ocurrio que podia hacer una lista simplemente ligada que tuviera los elementos:

codop = ADCA, operando = SI y para los 5 elementos restantes pense que podria hacerlos con arreglos, que direccionamiento fuera algo como:

direc[0] = IMM
direc[1] = DIR
direc[2] = EXT
direc[3] = IDX
direc[4] = IDX1
 
y codigo maquina fuera:

maq[0] = 89ii
maq[1] = 99dd
maq[2] = B9hhl
....
....
esto seria un array de cadenas un char **direc y para los campos que tienen numeros seria un simple array, el codigo que tengo hecho es el siguiente pero me aparecen warnings que dicen assignment makes integer from pointer without a cast, y no entiendo por que,¿¿¿como corregirlo???

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. typedef struct nodo
  6. {
  7.     char *codigo;
  8.     char *Operando;
  9.     char **modo_direccionamiento;
  10.     char **codigo_maquina;
  11.     char *bytes_calculados;
  12.     char *bytes_x_calcular;
  13.     char *total_bytes;
  14.     struct nodo *sig;
  15. }COD;
  16.  
  17. void buscarFinLinea(FILE *hc12);
  18. void ignorarEspacios(FILE *hc12);
  19. char *Tabla_Operandos(FILE *hc12);
  20. void insertarFinal(char *ins,char *op,char **dir,char **maq,char *calculado,char *calcular,char *total,COD *ultimo,int i);
  21. COD *ultimoElemento(COD *cabeza);
  22. COD *crearNodo(char *ins,char *op,char **dir,char **maq,char *calculado,char *calcular,char *total,int i);
  23. void quitarSaltosLinea(char *cadena);
  24.  
  25. int main()
  26. {
  27.     COD *cabeza = NULL,*ultimo;
  28.     FILE *hc12;
  29.     int p,i,car;
  30.     char *ins,*op,**dir,**maq,*calculado,*calcular,*total;
  31.     if((hc12 = fopen("archivo.txt","r"))!= NULL)
  32.     {
  33.         i = 0;
  34.         while((car = fgetc(hc12))!= EOF)
  35.         {
  36.             if(car != '\t')
  37.             {
  38.                 ins = Tabla_Operandos(hc12);
  39.                 ignorarEspacios(hc12);
  40.                 op = Tabla_Operandos(hc12);
  41.                 ignorarEspacios(hc12);
  42.                 p = ftell(hc12);
  43.                 buscarFinLinea(hc12);
  44.                 if(car == '\t')
  45.                 {
  46.                     fseek(hc12,p,SEEK_SET);
  47.                     dir = (char**)malloc(8*sizeof(char));
  48.                     dir[i] = Tabla_Operandos(hc12);
  49.                     ignorarEspacios(hc12);
  50.                     maq = (char**)malloc(8*sizeof(char));
  51.                     maq[i] = Tabla_Operandos(hc12);
  52.                     ignorarEspacios(hc12);
  53.                     calculado = (char*)malloc(8*sizeof(char));
  54.                     calculado[i] = Tabla_Operandos(hc12);
  55.                     ignorarEspacios(hc12);
  56.                     calcular = (char*)malloc(8*sizeof(char));
  57.                     calcular[i] = Tabla_Operandos(hc12);
  58.                     ignorarEspacios(hc12);
  59.                     total = (char*)malloc(8*sizeof(char));
  60.                     total[i] = Tabla_Operandos(hc12);
  61.                     buscarFinLinea(hc12);
  62.                     if(cabeza == NULL)
  63.                        //cabeza = crearNodo(ins,op,dir,maq,calculado,calcular,total,i);
  64.                     else
  65.                     {
  66.                         //ultimo = ultimoElemento(cabeza);
  67.                         //insertarFinal(ins,op,dir,maq,calculado,calcular,total,ultimo);
  68.                     }
  69.                     i++;
  70.                 }
  71.             }
  72.         }
  73.     }
  74.     else
  75.        printf("No se pudo abrir archivo\n");
  76.     return 0;
  77. }
  78.  
  79. void buscarFinLinea(FILE *fd)
  80. {
  81.     int car;
  82.     while((car = fgetc(fd))!= '\n')
  83.         ;
  84. }
  85.  
  86. void ignorarEspacios(FILE *fd)
  87. {
  88.     int car;
  89.     do
  90.     {
  91.         car = fgetc(fd);
  92.     }while(car == '\t' || car == ' ');
  93. }
  94.  
  95. char *Tabla_Operandos(FILE *hc12)
  96. {
  97.     int car,lon = 0,pos;
  98.     char *cadena;
  99.     fseek(hc12,-1,SEEK_CUR);
  100.     pos = ftell(hc12);
  101.     do
  102.     {
  103.         car = fgetc(hc12);
  104.         lon++;
  105.     }while(car != '\t');
  106.     fseek(hc12,pos,SEEK_SET);
  107.     cadena = (char*)calloc((lon+1),sizeof(char));
  108.     fgets(cadena,lon+1,hc12);
  109.     quitarSaltosLinea(cadena);
  110.     return cadena;
  111. }
  112.  
  113. void quitarSaltosLinea(char *cadena)
  114. {
  115.     char *ptr;
  116.     if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
  117.        *ptr = '\0';
  118. }
  119.  
  120.  

de antemano gracias
138  Programación / Programación C/C++ / pasar por referencia un puntero en: 12 Enero 2014, 03:15 am
Saludos, tengo unas dudas con respecto a por que en algunas ocasiones se tienen que pasar los punteros por referencias?? como cuando estas haciendo una lista enlazada y quieres insertar por la cabeza, por que tienes que pasar el puntero por referencia, que no se supone que el puntero ya almacena una direccion de memoria y que por lo tanto no es necesario pasarlo asi funcion(&cabeza).

gracias
139  Programación / Programación C/C++ / Re: problema con lista indexada en: 8 Enero 2014, 19:11 pm
es un ensamblador, en un archivo de texto me identifica las etiquetas codigos de operacion y operandos, y despues me tiene que buscar el codop en una lista para decirme si lo encontro o no
140  Programación / Programación C/C++ / Re: problema con lista indexada en: 8 Enero 2014, 00:08 am
gracias por sus respuestas, una ultima duda, si tengo por ejemplo el archivo

*****ORG***$AB
Et1**SWI*******
*****ADCA**1,X
*****BRA***ET1

los codops son (ORG,SWI,ADCA,BRA) y cada uno de esos los tengo que buscar en una lista, en este ejemplo el unico codop que no se debe de encontrar es el ORG, pero en el codigo siempre me aparece NO SE ENCONTRO EL CODOP DE OPERACION, ya cheque que la funcion busqueda este bien implementada pero aun asi no puedo encontrar cual es el fallo

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #define LONG_ETIQUETA 8
  5. #define LONG_CODOP 5
  6. #define COMENTARIO ';'
  7. #define TABULADOR '\t'
  8. #define ESPACIOS_ ' '
  9.  
  10. typedef enum {FALSO,VERDADERO} booleano;
  11. typedef enum {ETIQUETA,CODOP,OPERANDO} linea;
  12. typedef enum {INS,OPE} tabla;
  13.  
  14. typedef struct nodo
  15. {
  16.     char *codigo;
  17.     char *Operando;
  18.     struct nodo *sig;
  19. }COD;
  20.  
  21. COD *crearNodo(char *instruccion,char *op);
  22. void insertarFinal(char *instruccion,char *op,COD *ultimo);
  23. COD *ultimoElemento(COD *cabeza);
  24. void quitarSaltosLinea(char *cadena);
  25. int verificarCombinacion(FILE *fd);
  26. booleano esComentario(FILE *fd);
  27. char *Etiqueta_Codop_Operando(FILE *fd,int linea);
  28. char *_Codop_Operando(FILE *fd,int linea);
  29. void ultimaLinea(char *codop);
  30. void erroresEtiqueta(char *etiqueta);
  31. void erroresCodop(char *codop);
  32. void buscarFinLinea(FILE *fd);
  33. void ignorarEspacios(FILE *fd);
  34. booleano esNumero(char caracter);
  35. booleano esLetra(char caracter);
  36. void listaCodops(COD *cabeza);
  37. char *Tabla_Operandos(FILE *hc12,int tabla);
  38. COD *buscarCodop(COD *cabeza,char *codop);
  39. void imprimirLista(COD *cabeza);
  40.  
  41. int main()
  42. {
  43.     FILE *fd;
  44.     int car,combinacion;
  45.     COD *cabeza = NULL,*encontrado;
  46.     char *etiqueta,*codop,*operando;
  47.     //listaCodops(cabeza);
  48.     if((fd = fopen("P2ASM.txt","r"))!= NULL)
  49.     {
  50.         while((car = fgetc(fd))!= EOF)
  51.         {
  52.             switch(car)
  53.             {
  54.                 case COMENTARIO:
  55.                    if(esComentario(fd))
  56.                       printf("COMENTARIO\n\n");
  57.                    else
  58.                       buscarFinLinea(fd);
  59.                    break;
  60.                 case ESPACIOS_:
  61.                 case TABULADOR:
  62.                    etiqueta = "null";
  63.                    printf("ETIQUETA = %s\n",etiqueta);
  64.                    ignorarEspacios(fd);
  65.                    codop = Etiqueta_Codop_Operando(fd,CODOP);
  66.                    printf("CODOP = %s\n",codop);
  67.                    erroresCodop(codop);
  68.                    if((encontrado = buscarCodop(cabeza,codop)) == NULL)
  69.                       printf("\tNO SE ENCONTRO EL CODOP DE OPERACION\n");
  70.                    combinacion = verificarCombinacion(fd);
  71.                    if(combinacion == 2)
  72.                    {
  73.                        operando = "null";
  74.                        printf("OPERANDO = %s\n\n",operando);
  75.                    }
  76.                    else
  77.                    {
  78.                        ignorarEspacios(fd);
  79.                        operando = Etiqueta_Codop_Operando(fd,OPERANDO);
  80.                        printf("OPERANDO = %s\n\n",operando);
  81.                    }
  82.                    break;
  83.                 default:
  84.                    etiqueta = Etiqueta_Codop_Operando(fd,ETIQUETA);
  85.                    printf("ETIQUETA = %s\n",etiqueta);
  86.                    erroresEtiqueta(etiqueta);
  87.                    combinacion = verificarCombinacion(fd);
  88.                    if(combinacion == 2)
  89.                    {
  90.                        codop = "null";
  91.                        printf("CODOP = %s\n",codop);
  92.                        erroresCodop(codop);
  93.                        if((encontrado = buscarCodop(cabeza,codop)) == NULL)
  94.                           printf("\tNO SE ENCONTRO EL CODOP DE OPERACION\n");
  95.                        operando = "null";
  96.                        printf("OPERANDO = %s\n\n",operando);
  97.                    }
  98.                    else
  99.                    {
  100.                        ignorarEspacios(fd);
  101.                        codop = Etiqueta_Codop_Operando(fd,CODOP);
  102.                        printf("CODOP = %s\n",codop);
  103.                        erroresCodop(codop);
  104.                        if((encontrado = buscarCodop(cabeza,codop)) == NULL)
  105.                           printf("\tNO SE ENCONTRO EL CODOP DE OPERACION\n");
  106.                        combinacion = verificarCombinacion(fd);
  107.                        if(combinacion == 2)
  108.                        {
  109.                            operando = "null";
  110.                            printf("OPERANDO = %s\n\n",operando);
  111.                        }
  112.                        else
  113.                        {
  114.                            ignorarEspacios(fd);
  115.                            operando = Etiqueta_Codop_Operando(fd,OPERANDO);
  116.                            printf("OPERANDO = %s\n\n",operando);
  117.                        }
  118.                    }
  119.                    break;
  120.             }
  121.         }
  122.         ultimaLinea(codop);
  123.     }
  124.     else
  125.        printf("No se pudo abrir el archivo");
  126.     return 0;
  127. }
  128.  
  129. booleano esComentario(FILE *fd)
  130. {
  131.     int car;
  132.     while((car = fgetc(fd))!= '\n')
  133.     {
  134.         if(car == ';')
  135.            return 0;
  136.     }
  137.     return 1;
  138. }
  139.  
  140. void buscarFinLinea(FILE *fd)
  141. {
  142.     int car;
  143.     while((car = fgetc(fd))!= '\n')
  144.         ;
  145. }
  146.  
  147. void ignorarEspacios(FILE *fd)
  148. {
  149.     int car;
  150.     do
  151.     {
  152.         car = fgetc(fd);
  153.     }while(car == '\t' || car == ' ');
  154. }
  155.  
  156. int verificarCombinacion(FILE *fd)
  157. {
  158.     int car,combinacion;
  159.     fseek(fd,-1,SEEK_CUR);
  160.     if((car = fgetc(fd))== '\n')
  161.        combinacion = 2;
  162.     else
  163.        combinacion = 1;
  164.     return combinacion;
  165. }
  166.  
  167. booleano esLetra(char caracter)
  168. {
  169.     if((caracter >= 'A' && caracter <= 'Z')||(caracter >= 'a' && caracter <= 'z'))
  170.        return 1;
  171.     else
  172.        return 0;
  173. }
  174.  
  175. booleano esNumero(char caracter)
  176. {
  177.     if(caracter >= '0' && caracter <= '9')
  178.        return 1;
  179.     else
  180.        return 0;
  181. }
  182.  
  183. char *Etiqueta_Codop_Operando(FILE *fd,int linea)
  184. {
  185.     int car,lon = 0,pos;
  186.     char *cadena;
  187.     fseek(fd,-1,SEEK_CUR);
  188.     pos = ftell(fd);
  189.     if((linea == ETIQUETA)||(linea == CODOP))
  190.     {
  191.         do
  192.         {
  193.             car = fgetc(fd);
  194.             lon++;
  195.         }while(car != '\t' && car != ' ' && car != '\n');
  196.     }
  197.     else
  198.     {
  199.         do
  200.         {
  201.             car = fgetc(fd);
  202.             lon++;
  203.         }while(car != '\n');
  204.     }
  205.     cadena = calloc(lon+1);
  206.     fseek(fd,pos,SEEK_SET);
  207.     fgets(cadena,lon+1,fd);
  208.     quitarSaltosLinea(cadena);
  209.     return cadena;
  210. }
  211.  
  212. void quitarSaltosLinea(char *cadena)
  213. {
  214.     char *ptr;
  215.     if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
  216.        *ptr = '\0';
  217. }
  218.  
  219. void erroresEtiqueta(char *etiqueta)
  220. {
  221.     int tam,i = 0,esEtiqueta = 1;
  222.     tam = strlen(etiqueta);
  223.     if(tam-1 > LONG_ETIQUETA)
  224.        printf("\tError:la longitud maxima de una etiqueta es de 8 caracteres\n");
  225.     if(!esLetra(etiqueta[i]))
  226.        printf("\tError:la etiqueta debe iniciar con letra\n");
  227.     else
  228.     {
  229.         for(i = 0;(i < tam)&&(esEtiqueta);i++)
  230.         {
  231.            if((!esLetra(etiqueta[i]))&&(!esNumero(etiqueta[i]))&&(etiqueta[i] != '_'))
  232.               esEtiqueta = 0;
  233.         }
  234.         if(!esEtiqueta)
  235.            printf("\tError:los caracteres validos en las etiquetas son letras, digitos(0..9) y el guion bajo\n");
  236.     }
  237. }
  238.  
  239. void erroresCodop(char *codop)
  240. {
  241.     int tam,i = 0,esCodop = 1,punto = 0;
  242.     tam = strlen(codop);
  243.     if(tam > LONG_CODOP)
  244.        printf("\tError:la longitud maxima de un codigo de operacion es de 5 caracteres\n");
  245.     if((strcmp(codop,"null"))== 0)
  246.        printf("\tError:siempre debe de haber un codigo de operacion\n");
  247.     else
  248.     {
  249.         if(!esLetra(codop[i]))
  250.         printf("\tError:los codigos de operacion deben iniciar con letra\n");
  251.         else
  252.         {
  253.             for(i = 1;(i < tam)&&(esCodop)&&(punto>=0&&punto<=1);i++)
  254.             {
  255.                 if((!esLetra(codop[i]))&&(codop[i] != '.'))
  256.                    esCodop = 0;
  257.                 else if(codop[i] == '.')
  258.                    punto++;
  259.             }
  260.             if(!esCodop)
  261.                printf("\tError:los caracteres validos en un codigo de operacion son letras y el caracter punto\n");
  262.             if(punto > 1)
  263.                printf("\tError:los codigos de operacion no pueden tener mas de un punto\n");
  264.         }
  265.     }
  266. }
  267.  
  268. void ultimaLinea(char *codop)
  269. {
  270.     if((strcmp(codop,"END")) != 0)
  271.        printf("Error:No se encontro el END.\n");
  272. }
  273.  
  274. void listaCodops(COD *cabeza)
  275. {
  276.     int car;
  277.     FILE *hc12;
  278.     char *instruccion,*op;
  279.     COD *ultimo;
  280.     if((hc12 = fopen("TABOP.txt","r"))!= NULL)
  281.     {
  282.         while((car = fgetc(hc12))!= EOF)
  283.         {
  284.             if(car != '\t')
  285.             {
  286.                 instruccion = Tabla_Operandos(hc12,INS);
  287.                 op = Tabla_Operandos(hc12,OPE);
  288.                 if(cabeza == NULL)
  289.                    cabeza = crearNodo(instruccion,op);
  290.                 else
  291.                 {
  292.                     ultimo = ultimoElemento(cabeza);
  293.                     insertarFinal(instruccion,op,ultimo);
  294.                 }
  295.             }
  296.             else
  297.                buscarFinLinea(hc12);
  298.         }
  299.         imprimirLista(cabeza);
  300.     }
  301.     else
  302.        printf("No se pudo abrir el archivo\n");
  303. }
  304.  
  305. char *Tabla_Operandos(FILE *hc12,int tabla)
  306. {
  307.     int car,lon = 0,pos;
  308.     char *cadena;
  309.     fseek(hc12,-1,SEEK_CUR);
  310.     pos = ftell(hc12);
  311.     do
  312.     {
  313.         car = fgetc(hc12);
  314.         lon++;
  315.     }while(car != '\t');
  316.     fseek(hc12,pos,SEEK_SET);
  317.     cadena = malloc(lon+1);
  318.     fgets(cadena,lon+1,hc12);
  319.     quitarSaltosLinea(cadena);
  320.     if(tabla == INS)
  321.        ignorarEspacios(hc12);
  322.     else
  323.        buscarFinLinea(hc12);
  324.     return cadena;
  325. }
  326.  
  327. void insertarFinal(char *instruccion,char *op,COD *ultimo)
  328. {
  329.     ultimo->sig = crearNodo(instruccion,op);
  330.     ultimo->sig->sig = NULL;
  331.     ultimo = ultimo->sig;
  332. }
  333.  
  334. COD *ultimoElemento(COD *cabeza)
  335. {
  336.     COD *ptr;
  337.     ptr = cabeza;
  338.     while(ptr->sig != NULL)
  339.        ptr = ptr->sig;
  340.     return ptr;
  341. }
  342.  
  343. COD *crearNodo(char *instruccion,char *op)
  344. {
  345.     COD *x;
  346.     int tam,tam2;
  347.     tam = strlen(instruccion);
  348.     tam2 = strlen(op);
  349.     x = malloc(sizeof(COD));
  350.     x->codigo = malloc((tam+1));
  351.     x->Operando = malloc((tam2+1));
  352.     strcpy(x->codigo,instruccion);
  353.     strcpy(x->Operando,op);
  354.     x->sig = NULL;
  355.     return x;
  356. }
  357.  
  358. COD *buscarCodop(COD *cabeza,char *codop)
  359. {
  360.     COD *ptr;
  361.     for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
  362.     {
  363.         if((strcmp(ptr->codigo,codop)) == 0)
  364.            return ptr;
  365.     }
  366.     return NULL;
  367. }
  368.  
  369. void imprimirLista(COD *cabeza)
  370. {
  371.     COD *ptr;
  372.     for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
  373.     {
  374.         printf("%s\t",ptr->codigo);
  375.         printf("%s\n",ptr->Operando);
  376.     }
  377. }
  378.  

gracias
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 [14] 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 ... 40
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines