Question

I have a piece of code that checks to see if a macro is already defined, and if it isn’t then it allocates memory for a new macro and adds it onto the current list. If it is already defined then it just changes the macro body, and keeps the name the same.

static struct macro *macro_lookup(char *name){
  struct macro * temp = &macro_list;
  while(temp->next != NULL){
    if(strcmp(temp->macro_name,name) == 0){
      return temp;
    }
  }
  return NULL;
}

void macro_set(char *name, char *body){
  //Need to check to see if a macro is already set for the name if so just change the body
  struct macro * p = macro_lookup(name); //Will return NULL if macro is not in the list. This line gives me the error of segmentation fault 11, if I comment it out the program works.
  //Need to make a new macro and add it to the list
  if(p == NULL){ 
    //Make a new macro
    struct macro * new_macro = (struct macro *)  Malloc(sizeof(struct macro)); //Malloc is my version of malloc, it works just fine.
    if(new_macro == NULL){
      fprintf(stderr,"Error while allocating space for the new marco.\n");
      exit(EXIT_FAILURE);
    }
    new_macro->macro_name = name;
    new_macro->macro_body = body;
    //Create a pointer to the list and traverse it until the end and put the new macro there
    struct macro * temp = &macro_list;
    while(temp->next != NULL){
      temp = temp->next;
    }
    temp->next = new_macro;
  }
  //The macro already exists and p is pointing to it
  else{
    //Just change the body of the macro
    p->macro_body = body;
  }
}

I don’t know why the error line above gives me a problem, I can statically set p to null and test it and it works fine, but when I use the macro_lookup function it gets a seg fault.

Answer 1

This is likely the problem:

new_macro->macro_name = name;
new_macro->macro_body = body;

You should normally allocate enough space for the strings and then copy them. You can’t simply hand them over like that unless the calling code does the memory allocation and releases the information to the macro_set() function.

It would have been helpful if you had shown the definitions of your macro structure. I’m assuming that it is roughly:

struct macro
{
    char *macro_name;
    char *macro_body;
};

Rather than:

struct macro
{
    char macro_name[MAX_MACRO_NAME_LEN];
    char macro_body[MAX_MACRO_BODY_LEN];
};

If it were the latter, you’d only need to use strcpy(), but you would have to check for overflows before doing so.