gracias erest0r por tu respuesta, ya cambie el printf que me estaba dando problemas ahora me queda una duda, para comparar cadenas tengo que usar strcmp pero si tengo que verificar si la cadena es "X","Y","SP" o "PC", no habra una manera de reducir el codigo en esa parte donde tengo los strcmps en el if??:

int direccionamientoIndexado(char *operando)
{
    int i;
    char *cadena = NULL,c[2];
    cadena = calloc(2,sizeof(char));
    for(i = 3;operando[i] != ']';i++)
    {
        sprintf(c,"%c",operando[i]);
        strcat(cadena,c);
    }
    printf("%s",cadena);
    if((strcmp(cadena,"X") == 0)||(strcmp(cadena,"Y") == 0)||(strcmp(cadena,"SP") == 0)||(strcmp(cadena,"PC") == 0))
       return 1;
    else
       return 0;
}
 

gracias

Saludos, tengo el siguiente codigo que dado un operando (una cadena) tiene que verificar que modo de direccionamiento es, puede ser inmediato,directo o indexado, yo ahora estoy verificando cuando un operando es indexado, esto es: que el primer caracter sea un corchete [, que el segundo caracter sea una d ó D, que el tercer caracter sea una coma, y ya que verificaste los primeros 3 el termino que va despues de la coma puede ser X,Y,SP,PC, o sea algo como:

[D,X], [D,Y], [D,SP], [D,PC]  

el problema lo tengo en la funcion direccionamientoIndexado() que se supone que me tiene que imprimir el termino que va despues de la coma, pero cuando los operandos son: [D,SP] o [D,PC] el segundo termino lo imprime como SSP en vez de SP y no entiendo por qué. EL codigo va leyendo desde la coma hasta el corcheta ] y lo que se encuentre entre estos dos los guarda en una cadena

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define INMEDIATO '#'
#define DIRECTO '$'
#define INDEXADO '['
 
void modoDireccionamiento(char *operando);
void direccionamientoIndexado(char *operando);
int esNumeroBase16(char caracter);
int esLetraBase16(char caracter);
int esOctal(char caracter);
int esBinario(char caracter);
 
int main()
{
    char *operando = "[D,PC]";
    modoDireccionamiento(operando);
    return 0;
}
 
void modoDireccionamiento(char *operando)
{
    int car,esInmediato,esDirecto,esIndexado,tam,i;
    tam = strlen(operando);
    car = operando[0];
    switch(car)
    {
        case INMEDIATO:
           esInmediato = 1;
           car = operando[1];
           switch(car)
           {
               case '\0':
                  printf("Es un formato invalido para un modo de direccionamiento inmediato\n");
                  break;
               case '$':
                  for(i = 2;((i < tam)&&(esInmediato));i++)
                  {
                      if((!esNumeroBase16(operando[i]))&&(!esLetraBase16(operando[i])))
                         esInmediato = 0;
                  }
                  if(!esInmediato)
                     printf("Se encontro un digito invalido para un numero de base 16");
                  break;
               case '@':
                  for(i = 2;((i < tam)&&(esInmediato));i++)
                  {
                      if(!esOctal(operando[i]))
                         esInmediato = 0;
                  }
                  if(!esInmediato)
                     printf("Se encontro un digito invalido para un numero de base 8");
                  break;
               case '%':
                  for(i = 2;((i < tam)&&(esInmediato));i++)
                  {
                      if(!esBinario(operando[i]))
                         esInmediato = 0;
                  }
                  if(!esInmediato)
                     printf("Se encontro un digito invalido para un numero de base 2");
                  break;
               default:
                  printf("Error");
           }
           break;
        case DIRECTO:
           esDirecto = 1;
           if(operando[1] == '\0')
              printf("Es un formato invalido para un modo de direccionamiento directo\n");
           else
           {
               for(i = 2;((i < tam)&&(esDirecto));i++)
               {
                   if((!esNumeroBase16(operando[i]))&&(!esLetraBase16(operando[i])))
                      esDirecto = 0;
               }
               if(!esDirecto)
                  printf("Se encontro un digito invalido para un numero de base 16");
           }
           break;
        case INDEXADO:
           esIndexado = 1;
           car = operando[1];
           switch(car)
           {
               case '\0':
                  printf("Es un formato invalido para un modo de direccionamiento indexado\n");
                  break;
               case ',':
                  printf("No puede haber una instruccion vacia antes de la coma");
                  break;
               case 'd':
               case 'D':
                  if(operando[2] == ',')
                  {
                      direccionamientoIndexado(operando);
                         //esIndexado = 0;
                  }
                  //if(!esIndexado)
                     //printf("Es un formato invalido para direccionamiento indexado");
                  break;
               default:
                  printf("Error");
           }
           break;
        default:
           printf("Error: es un formato invalido para los modos de direccionamiento inmediato\n");
    }
}
 
int esNumeroBase16(char caracter)
{
    if(caracter >= '0' && caracter <= '9')
       return 1;
    else
       return 0;
}
 
int esLetraBase16(char caracter)
{
    if((caracter >= 'A' && caracter <= 'F')||(caracter >= 'a' && caracter <= 'f'))
       return 1;
    else
       return 0;
}
 
int esOctal(char caracter)
{
    if(caracter >= '0' && caracter <= '7')
       return 1;
    else
       return 0;
}
 
int esBinario(char caracter)
{
    if(caracter == '1' || caracter == '0')
       return 1;
    else
       return 0;
}
 
void direccionamientoIndexado(char *operando)
{
    int i;
    char *cadena = NULL,c[2];
    cadena = calloc(2,sizeof(char));
    for(i = 3;operando[i] != ']';i++)
    {
        sprintf(c,"%c",operando[i]);
        strcat(cadena,c);
        printf("%s",cadena);
    }
}
 

si alguien me pudiera decir donde esta el error se lo agradeceria mucho

Saludos, tengo una duda acerca de cómo se pueden usar unas MACROS en lenguaje C, es posible que el nombre de la MACRO tenga asignado mas de un valor?? por ejemplo:

NOMBRE '#','$','@'

muchas gracias leosansan por tu respuesta, en vez de usar el gets le puse una funcion para quitarle el salto de linea '\n' y ya con esto ya lo hace correctamente. Una ultima duda, si yo quisiera que al escribirse el nombre del archivo a abrir, no necesariamente tenga que ser identicamente a como se encuentra el original y que pudiera hacerse indistintamente con combinaciones de mayúsculas y minúsculas, ¿cómo lo podría hacer? alguna idea??

Saludos, tengo el siguiente código que me tiene que abrir un archivo que se llama P1ASM.txt, pero el programa me tiene que preguntar el nombre del archivo para ver si se encuentra, pero me imprime No se pudo abrir el archivo y no entiendo por que si el archivo se encuentra en la misma carpeta donde tengo el codigo no deberia de haber errores

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 40
 
int main()
{
   FILE *fd;
    char nombre[MAX],archivo[MAX];
    printf("Que archivo quieres abrir: ");
    fgets(nombre,MAX,stdin);
    sprintf(archivo,"%s.txt",nombre);
    if((fd = fopen(archivo,"r"))!= NULL)
       printf("Si se encontro");
    else
       printf("No se pudo abrir el archivo");
   return 0;
}
 

gracias

Saludos

necesito que alguien me recomiende un libro que hable sobre la computación tolerante a fallas, especificamente de los temas capacidad de proceso y especificacion de operacion, tengo que hacer unos resúmenes de estos temas pero no encuentro informacion que me ayude

gracias de antemano

Saludos x64Core el problema es que no se usar el depurador de codeblocks :S lo intente con un tutorial pero no pude

Saludos, tengo problemas con unos fseeks que tengo dentro de un ciclo while que me lee un archivo, pero a la hora de imprimir el archivo no lo hace correctamente

este es el codigo:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 8
 
typedef enum {INS,OP,DIR,MAQ,CALCULADO,CALCULAR,TOTAL} tabla;
 
void buscarFinLinea(FILE *hc12);
void listaTABOP();
char *Tabla_Operandos(FILE *hc12,int tabla);
void ignorarEspacios(FILE *hc12);
void quitarSaltosLinea(char *cadena);
 
int main()
{
    listaTABOP();
    return 0;
}
 
void buscarFinLinea(FILE *hc12)
{
    int car;
    while((car = fgetc(hc12))!= '\n')
        ;
}
 
void quitarSaltosLinea(char *c)
{
    char *ptr;
    if(((ptr = strchr(c,'\n'))!= NULL)||((ptr = strchr(c,'\t'))!= NULL)||((ptr = strchr(c,' '))!= NULL))
       *ptr = '\0';
}
 
void listaTABOP()
{
    int car,i,pos,n;
    FILE *hc12;
    COD *ultimo = NULL;
    char *ins,*op,**dir,**maq,**cal,**x_cal,**sum;
    if((hc12 = fopen("Tabla_OP.txt","r"))!= NULL)
    {
        while((car = fgetc(hc12))!= EOF)
        {
            i = 0;
            fseek(hc12,-1,SEEK_CUR);
            ins = Tabla_Operandos(hc12,INS);
            printf("[%s]\t",ins);
            ignorarEspacios(hc12);
            op = Tabla_Operandos(hc12,OP);
            printf("[%s]",op);
            pos = ftell(hc12);
            buscarFinLinea(hc12);
            if((car = fgetc(hc12)) != '\t')
            {
                n = 0;
                fseek(hc12,pos,SEEK_SET);
                ignorarEspacios(hc12);
                dir = (char**)malloc(sizeof(char*));
                dir[i] = Tabla_Operandos(hc12,DIR);
                printf("\t[%s]\t",dir[i]);
                ignorarEspacios(hc12);
                maq = (char**)malloc(sizeof(char*));
                maq[i] = Tabla_Operandos(hc12,MAQ);
                printf("[%s]\t",maq[i]);
                ignorarEspacios(hc12);
                cal = (char**)malloc(sizeof(char*));
                cal[i] = Tabla_Operandos(hc12,CALCULADO);
                printf("[%s]\t",cal[i]);
                ignorarEspacios(hc12);
                x_cal = (char**)malloc(sizeof(char*));
                x_cal[i] = Tabla_Operandos(hc12,CALCULAR);
                printf("[%s]\t",x_cal[i]);
                ignorarEspacios(hc12);
                sum = (char**)malloc(sizeof(char*));
                sum[i] = Tabla_Operandos(hc12,TOTAL);
                printf("[%s]\n",sum[i]);
                buscarFinLinea(hc12);
            }
            else
            {
                n = 1;
                fseek(hc12,pos,SEEK_SET);
                dir = (char**)malloc(MAX*sizeof(char*));
                maq = (char**)malloc(MAX*sizeof(char*));
                cal = (char**)malloc(MAX*sizeof(char*));
                x_cal = (char**)malloc(MAX*sizeof(char*));
                sum = (char**)malloc(MAX*sizeof(char*));
                do
                {
                    ignorarEspacios(hc12);
                    dir[i] = Tabla_Operandos(hc12,DIR);
                    printf("\t[%s]\t",dir[i]);
                    ignorarEspacios(hc12);
                    maq[i] = Tabla_Operandos(hc12,MAQ);
                    printf("[%s]\t",maq[i]);
                    ignorarEspacios(hc12);
                    cal[i] = Tabla_Operandos(hc12,CALCULADO);
                    printf("[%s]\t",cal[i]);
                    ignorarEspacios(hc12);
                    x_cal[i] = Tabla_Operandos(hc12,CALCULAR);
                    printf("[%s]\t",x_cal[i]);
                    ignorarEspacios(hc12);
                    sum[i] = Tabla_Operandos(hc12,TOTAL);
                    printf("[%s]\n",sum[i]);
                    buscarFinLinea(hc12);
                    i++;
                    printf("\t");
                }while((car = fgetc(hc12)) == '\t');
            }
        }
    }
    else
       printf("No se pudo abrir el archivo");
}
 
void ignorarEspacios(FILE *hc12)
{
    int car;
    do
    {
        car = fgetc(hc12);
    }while(car == '\t' || car == ' ');
}
 
char *Tabla_Operandos(FILE *hc12,int tabla)
{
    int car,lon = 0,pos;
    char *c;
    fseek(hc12,-1,SEEK_CUR);
    pos = ftell(hc12);
    if((tabla==INS)||(tabla==OP)||(tabla==DIR)||(tabla==MAQ)||(tabla==CALCULADO)||(tabla==CALCULAR))
    {
        do
        {
            car = fgetc(hc12);
            lon++;
        }while(car != '\t' && car != EOF);
    }
    else
    {
        do
        {
            car = fgetc(hc12);
            lon++;
        }while(car != '\n' && car != EOF);
        lon--;
    }
    fseek(hc12,pos,SEEK_SET);
    c = (char*)calloc((lon+1),sizeof(char));
    fgets(c,lon+1,hc12);
    quitarSaltosLinea(c);
    return c;
}
 

[
y el archivo es
quote]ABA         NO   INH      1806      2   0   2
          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[/quote]
el problema es que  cuando llega al codop ADCA no me imprime toda la linea solo me imprime

[]....[ADCA]...[SI]...[IMM]...[89ii]....[1]...[1]

 esto se arregla si le quito el primer fseek() que aparece en el while() de la funcion listaTABOP, pero si se lo quito ahora los codops siguientes al ADCA los imprime sin la primer letra, se la come,entonces como puedo arreglar este problema

gracias

Saludos, tengo un problema con el siguiente codigo que creo que ya habia posteado antes, pero lo que pasa es que de repente la pantalla se me congelo y cuando reinicie la maquina ya no tenia codigo, se me borro todo y ahora estoy empezandolo a hacer de nuevo todo, el codigo me lee de un archivo todos los codigos de operacion y me hace una lista simplemente ligada, esto si funciona bien, pero a la hora de que le pido que busque un codigo de operacion en la lista siempre me imprime que no lo encuentra, y no entiendo por que? si alguien me pudiera ayudar se lo agradeceria mucho

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LONG_ETIQUETA 8
#define LONG_CODOP 5
#define COMENTARIO ';'
#define TABULADOR '\t'
#define ESPACIOS_ ' '
#define MAX 8
 
typedef enum {FALSO,VERDADERO} booleano;
typedef enum {ETIQUETA,CODOP,OPERANDO} linea;
 
typedef struct nodo
{
    char *instruccion;
    struct nodo *sig;
}COD;
 
void imprimirLista(COD *cabeza);
int verificarCombinacion(FILE *fd);
booleano esComentario(FILE *fd);
char *Etiqueta_Codop_Operando(FILE *fd,int linea);
void ultimaLinea(char *codop);
void buscarFinLinea(FILE *fd);
void ignorarEspacios(FILE *fd);
void listaTABOP(COD **cabeza);
COD *ultimoElemento(COD **cabeza);
COD *crearNodo(char *ins);
void insertarFinal(char *ins,COD *ultimo);
char *Tabla_Operandos(FILE *hc12);
COD *buscarCodop(COD *cabeza,char *codop);
void quitarSaltosLinea(char *cadena);
booleano esNumero(char caracter);
booleano esLetra(char caracter);
 
int main()
{
    FILE *fd;
    int car,combinacion;
    COD *cabeza = NULL,*encontrado = NULL;
    char *etiqueta,*codop,*operando;
    listaTABOP(&cabeza);
    //imprimirLista(cabeza);
    if((fd = fopen("ejemplo_errores.txt","r"))!= NULL)
    {
        while((car = fgetc(fd))!= EOF)
        {
            switch(car)
            {
                case COMENTARIO:
                   if(esComentario(fd))
                      printf("COMENTARIO\n\n");
                   else
                      buscarFinLinea(fd);
                   break;
                case ESPACIOS_:
                case TABULADOR:
                   etiqueta = "null";
                   printf("ETIQUETA = %s\n",etiqueta);
                   ignorarEspacios(fd);
                   codop = Etiqueta_Codop_Operando(fd,CODOP);
                   printf("CODOP = %s\n",codop);
                   erroresCodop(codop);
                   combinacion = verificarCombinacion(fd);
                   if(combinacion == 2)
                   {
                       operando = "null";
                       printf("OPERANDO = %s\n\n",operando);
                   }
                   else
                   {
                       ignorarEspacios(fd);
                       operando = Etiqueta_Codop_Operando(fd,OPERANDO);
                       printf("OPERANDO = %s\n\n",operando);
                   }
                   break;
                default:
                   etiqueta = Etiqueta_Codop_Operando(fd,ETIQUETA);
                   printf("ETIQUETA = %s\n",etiqueta);
                   erroresEtiqueta(etiqueta);
                   combinacion = verificarCombinacion(fd);
                   if(combinacion == 2)
                   {
                       codop = "null";
                       printf("CODOP = %s\n",codop);
                       erroresCodop(codop);
                       operando = "null";
                       printf("OPERANDO = %s\n\n",operando);
                   }
                   else
                   {
                       ignorarEspacios(fd);
                       codop = Etiqueta_Codop_Operando(fd,CODOP);
                       printf("CODOP = %s\n",codop);
                       erroresCodop(codop);
                       combinacion = verificarCombinacion(fd);
                       if(combinacion == 2)
                       {
                           operando = "null";
                           printf("OPERANDO = %s\n\n",operando);
                       }
                       else
                       {
                           ignorarEspacios(fd);
                           operando = Etiqueta_Codop_Operando(fd,OPERANDO);
                           printf("OPERANDO = %s\n\n",operando);
                       }
                   }
                   break;
            }
            if((encontrado = buscarCodop(cabeza,codop)) == NULL)
               printf("NO SE ENCONTRO EL CODOP DE OPERACION\n");
        }
        ultimaLinea(codop);
    }
    else
       printf("No se pudo abrir el archivo");
    return 0;
}
 
booleano esComentario(FILE *fd)
{
    int car;
    while((car = fgetc(fd))!= '\n')
    {
        if(car == ';')
           return 0;
    }
    return 1;
}
 
void buscarFinLinea(FILE *fd)
{
    int car;
    while((car = fgetc(fd))!= '\n')
        ;
}
 
void ignorarEspacios(FILE *fd)
{
    int car;
    do
    {
        car = fgetc(fd);
    }while(car == '\t' || car == ' ');
}
 
int verificarCombinacion(FILE *fd)
{
    int car,combinacion;
    fseek(fd,-1,SEEK_CUR);
    if((car = fgetc(fd))== '\n')
       combinacion = 2;
    else
       combinacion = 1;
    return combinacion;
}
 
booleano esLetra(char caracter)
{
    if((caracter >= 'A' && caracter <= 'Z')||(caracter >= 'a' && caracter <= 'z'))
       return 1;
    else
       return 0;
}
 
booleano esNumero(char caracter)
{
    if(caracter >= '0' && caracter <= '9')
       return 1;
    else
       return 0;
}
 
char *Etiqueta_Codop_Operando(FILE *fd,int linea)
{
    int car,lon = 0,pos;
    char *cadena,*ptr;
    fseek(fd,-1,SEEK_CUR);
    pos = ftell(fd);
    if((linea == ETIQUETA)||(linea == CODOP))
    {
        do
        {
            car = fgetc(fd);
            lon++;
        }while(car != '\t' && car != ' ' && car != '\n');
    }
    else
    {
        do
        {
            car = fgetc(fd);
            lon++;
        }while(car != '\n');
    }
    cadena = (char*)calloc((lon+1),sizeof(char));
    fseek(fd,pos,SEEK_SET);
    fgets(cadena,lon+1,fd);
    if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
       *ptr = '\0';
    return cadena;
}
 
void ultimaLinea(char *codop)
{
    if((strcmp(codop,"end")) != 0)
       printf("Error:No se encontro el END.\n");
}
 
void quitarSaltosLinea(char *cadena)
{
    char *ptr;
    if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
       *ptr = '\0';
}
 
void listaTABOP(COD **cabeza)
{
    int car;
    FILE *hc12;
    COD *ultimo = NULL;
    char *ins;
    if((hc12 = fopen("Tabla_OP.txt","r"))!= NULL)
    {
         while((car = fgetc(hc12))!= EOF)
        {
            if(car != '\t')
            {
                ins = Tabla_Operandos(hc12);
                buscarFinLinea(hc12);
                if(*cabeza == NULL)
                   *cabeza = crearNodo(ins);
                else
                {
                    ultimo = ultimoElemento(cabeza);
                    insertarFinal(ins,ultimo);
                }
            }
            else
               buscarFinLinea(hc12);
        }
    }
    else
       printf("No se pudo abrir el archivo");
}
 
COD *ultimoElemento(COD **cabeza)
{
    COD *ptr;
    ptr = *cabeza;
    while(ptr->sig != NULL)
       ptr = ptr->sig;
    return ptr;
}
 
char *Tabla_Operandos(FILE *hc12)
{
    int car,lon = 0,pos;
    char *cadena;
    fseek(hc12,-1,SEEK_CUR);
    pos = ftell(hc12);
        do
        {
            car = fgetc(hc12);
            lon++;
        }while(car != '\t');
    fseek(hc12,pos,SEEK_SET);
    cadena = calloc((lon+1));
    fgets(cadena,lon+1,hc12);
    quitarSaltosLinea(cadena);
    return cadena;
}
 
COD *buscarCodop(COD *cabeza,char *codop)
{
    COD *ptr;
    for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
    {
        if(ptr->instruccion == codop)
           return ptr;
    }
    return NULL;
}
 
void insertarFinal(char *ins,COD *ultimo)
{
    ultimo->sig = crearNodo(ins);
    ultimo->sig->sig = NULL;
    ultimo = ultimo->sig;
}
 
COD *crearNodo(char *ins)
{
    int tam;
    COD *x;
    x = (COD*)malloc(sizeof(COD));
    tam = strlen(ins);
    x->instruccion = malloc(tam);
    strcpy(x->instruccion,ins);
    x->sig = NULL;
    return x;
}
 

Saludos tengo una variable que es de tipo char** p, esto es para que sea un arreglo que contenga cadenas de tamaño variable y despues estas variables asignarselas al elemento nombre del mismo tipo que esta en una estructura, el problema es que el codigo me truena y no se por que

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 4
 
typedef struct
{
    char **nombre;
}CODOP;
 
int main()
{
    int tam,tam1,tam2,tam3,i;
    CODOP *x;
    char **p;
    x = (CODOP*)malloc(sizeof(CODOP));
    p = (char**)malloc(MAX*sizeof(char*));
    p[0] = "anita";
    p[1] = "lava";
    p[2] = "la";
    p[3] = "tina";
    tam = strlen(p[0]);
    tam1 = strlen(p[1]);
    tam2 = strlen(p[2]);
    tam3 = strlen(p[3]);
    x->nombre = (char**)malloc(MAX*sizeof(char*));
    x->nombre[0] = (char*)malloc((tam+1)*sizeof(char));
    x->nombre[1] = (char*)malloc((tam1+1)*sizeof(char));
    x->nombre[2] = (char*)malloc((tam2+1)*sizeof(char));
    x->nombre[3] = (char*)malloc((tam3+1)*sizeof(char));
    strcpy(x->nombre[0],p[0]);
    strcpy(x->nombre[1],p[1]);
    strcpy(x->nombre[2],p[2]);
    strcpy(x->nombre[3],p[3]);
    for(i = 0;i < MAX;i++)
       printf("%s\n",x->nombre[i]);
    return 0;
}
 

gracias de antemano