如何避免 GNU Make 和 shell 在定义变量时解开逗号和撇号

Question

I have a variable called SELF in my makefile that I want to pass to my GCC compiler through the -D option to define a macro. This macro can only have a single character in [0-9a-zA-Z] - but this is another problem in itself I won't try to discuss here -. I'm having trouble to find a workaround for avoiding both GNU Make and the shell to remove the commas in the definition. An example how it is defined would be:

#include <stdio.h>

#define str(x) #x
#define xstr(x) str(x)
    
#ifndef SELF  
# define SELF '0'
#endif
#pragma message("SELF is: " xstr(SELF))

int main(void){
    return 0;
}

The makefile looks like this:

CC = gcc
WFLAGS = -Wall -Wextra

ifdef SELF
DSELF = -DSELF=$(SELF)
endif
CFLAGS = -std=c99 $(DSELF)

all: clean test

%: %.o

.PHONY: clean
clean:
    -rm -v test

If you execute the makefile with make , a note will appear that will tokenize the definition of SELF :

test.c:9:9: note: ‘#pragma message: SELF is: '0'’
    9 | #pragma message("SELF is: " xstr(SELF))
      |         ^~~~~~~

On the other hand, executing make SELF='0' will destroy the apostrophes, as you can see in the verbose output of GNU Make:

gcc -std=c99 -DSELF=0    test.c   -o test

If you try to wrap the apostrophes with quotes, like make SELF="'0'" , the definition will pass to GCC, but even the shell removes the apostrophes since the #pragma message will still display 0 . BUT if you execute directly gcc -std=c99 -DSELF="'0'" test.c -o test , the definition will be successfully be done:

test.c:9:9: note: ‘#pragma message: SELF is: '0'’
    9 | #pragma message("SELF is: " xstr(SELF))
      |         ^~~~~~~

How can you avoid all this from happening? Does this mean you can't define string of the same sorts?

Answer 1

Your question is very confusing because at first you're talking about commas, then you start talking about apostrophes which are completely different.

In computer-ese, we generally call the ' character a "single quote", not an apostrophe, which often refers to a different character in a full character set.

Anyway, since neither the shell nor make care about commas I can only assume you meant single quotes throughout your question.

The answer is, make doesn't care about quotes at all and won't strip them. But, the shell very much does care about them and will strip them for you: it's important to understand that the shell removes quotes before it starts the program, so the program has no chance to even know whether the quotes existed or not. Take your first example:

make SELF='0'

Here, the shell will remove the quotes before invoking make. Make cannot know whether you ran make SELF=0 or make SELF='0' because by the time make is invoked, the quotes are removed.

Then, when make runs a shell command to start the compiler, that shell command will also remove quotes before the compiler is invoked. So you have a command like this that make runs:

gcc -std=c99 -DSELF='0'    test.c   -o test

the shell removes the quotes and the compiler will get the argument -DSELF=0 .

How do you defend against this? You need to escape the quotes. In your situation you want to preserve the single quotes so you need to either use backslashes or double quotes around them (as you've found).

It's not exactly clear what you want to do, but assuming you'd like to be able to run make like this:

make SELF=0

then you'll need to add both the single quotes and escape them in the makefile. You can put those into your makefile like this:

ifdef SELF
DSELF = -DSELF="'$(SELF)'"
endif
CFLAGS = -std=c99 $(DSELF)

Now the compiler will be invoked with -DSELF="'0'" , then shell will remove the outer quotes, and your program will be invoked with -DSELF='0' which is what you want.