how to debug macro? - c

Question

having this code:
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#define check(x) ({int _val = (x); (_val ==-1? \
({fprintf(stderr, "Error (" __FILE__ ":%d) -- " \
"%s\n",__LINE__,strerror(errno)); \
exit(-1);-1;}) : _val); })
int main (int argc, char **argv) {
if (argc!=2){
fprintf(stderr, "usage: %s <filename>\n", argv[0]);
exit(-1);
}
int fd;
fd=open(argv[1], O_RDONLY);
if(fd<0){
perror("open");
fprintf(stderr,"errno = %s\n",strerror(errno));
exit(-1);
}
for(char c;check(read(fd,&c,1))>0;) //macro "check(x)" HERE
fputc(c,stdout);
return 0;
}
It compiles without an error, but I can see the macro does not output error messeges (__FILE__, neither __LINE__), as define it the macro. How to fix that? (And for general, how to debug macro, how at least output some error for it)?
$cc -pedantic a.c
a.c: In function ‘main’:
a.c:10:2: warning: ISO C forbids braced-groups within expressions [-Wpedantic]
({fprintf(stderr, "Error (" __FILE__ ":%d) -- " \
^
a.c:30:13: note: in expansion of macro ‘check’
for(char c;check(read(fd,&c,1))>0;)
^~~~~
a.c:9:18: warning: ISO C forbids braced-groups within expressions [-Wpedantic]
#define check(x) ({int _val = (x); (_val ==-1? \
^
a.c:30:13: note: in expansion of macro ‘check’
for(char c;check(read(fd,&c,1))>0;)
not single mention about for loop (only its location, because the macro is in there, but that is not error) statment. Only about macro. So please focus on macro problem and not about the for loop.
EDIT1:
the macro actually comes from this guy:
youtube tutorial (at the end of the video), well he uses clang, so I do not know what clang uses as a preprocessor (and therefor it works for him).
EDIT2 (output from a.i - preprocessed output):
# 304 "/usr/include/fcntl.h" 3 4
# 8 "a.c" 2
# 14 "a.c"
int main (int argc, char **argv) {
I have deleted all the noise. But you can see between #include <fcntl.h> and int main, there is nothing. But there should be the #define check(x).... So it does not tell me WHY is it missing.

Answer 1

how to debug macro?
Read more about C, in particular the Modern C book then this site.
Most C compilers have a way to show the preprocessed form of a translation unit.
Read the documentation of your C compiler.
For GCC, see this. For Clang, see that. The GCC preprocessor is documented here.
If you use gcc as your C compiler on file foo.c run it as gcc -C -E -H -Wall foo.c > foo.i to obtain into foo.i the preprocessed form of foo.c (but most comments are kept, and you could add more of them). Then look with a pager or an editor (I recommend GNU emacs, but feel free to use vim, gedit, more, less, most etc...) into that generated foo.i file.
I can see the macro does not output error messeges
A macro is not outputting any messages, it is just expanded.
If you use a build automation tool such as GNU make or ninja, read its documentation.
If you use some IDE, read its documentation. Many IDEs offer a way to show the preprocessed form, and some might even make the macro expansion on the fly.
Don't forget that in some cases, you may want to use some other preprocessor, such as GPP or GNU m4, or generate some C code programmatically (like GNU bison, or lemon, or SWIG does). Many transpilers (such as Chicken-Scheme or Bigloo) are generating C code, and in Bismon I am doing that at run time, then dynamically loading the generated plugin, using dlopen(3). In RefPerSys we want to generate C++ code at runtime, and later use libgccjit.
You can find lots of open source C preprocessors, even standalone ones like mcpp. You could study their source code and improve them for your needs. And tinycc or nwcc is a small enough open source C compiler (with their preprocessor embedded inside) that you could improve in a few days.
If you use a recent GCC, you could extend it with your own plugin, perhaps adding your own _Pragma (used in your macros) which would display things after preprocessing.
Some clever debuggers (e.g. a suitably configured recent GDB) are capable of macro expansion (thrn compile your C code with gcc -O0 -g3 -Wall)
In Bismon, I use lots of quite long C macros. They might be inspirational. And so is the container-macros library. And also GTK whose macros are very readable.
My experience: to debug a macro, remove many lines from it, till you are satisfied with its expansion. Grow that macro in small steps. Use git on your source code.
$cc -pedantic a.c
I recommend using gcc -Wall -Wextra -g3 -H -pedantic a.c on Linux then use a recent gdb.

Answer 2

Generally speaking you can't debug a macro as macro is not something which is executed.
But there should be the #define check(x).... So it does not tell me
WHY is it missing.
Your macro was preprocessed - ie textually replaced by the preprocessor.
After the preprocessing it is expanded to:
for(char c;({int _val = (read(fd,&c,1)); (_val ==-1? ({fprintf(
stderr
, "Error (" "./example.c" ":%d) -- " "%s\n",30,strerror(
(*__errno_location ())
)); exit(-1);-1;}) : _val); })>0;)
fputc(c,
stdout
);

Answer 3

You can't debug a macro in the sense that a high level debugger will step through the macro code. What you can do is temporarily expand the macro in the source code and use a debugger to see what is going wrong.
One idea is to use a code formatter, like clang-format to beautify the macro so that you can understand it better an use the debugger. Applying this idea, transform the macro into a function and let the formatter do its job:
$ clang-format -i macro.c
results in:
void check1(x) {
({
int _val = (x);
(_val == -1 ? ({
fprintf(stderr,
"Error (" __FILE__ ":%d) -- "
"%s\n",
__LINE__, strerror(errno));
exit(-1);
-1;
})
: _val);
})
}
The code you originally posted actually compiles and executes properly here. I made a version with a few cuts to be able to test the macro:
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define check(x) ({int _val = (x); (_val ==-1? \
({fprintf(stderr, "Error (" __FILE__ ":%d) -- " \
"%s\n",__LINE__,strerror(errno)); \
exit(-1);-1;}) : _val); })
int main (int argc, char **argv)
{
check(-1);
return 0;
}
results in:
$ gcc a.c && ./a.out
Error (a.c:13) -- Success

Answer 4

This may be a little late, but I wanted to say that you didn't place a check where you want the code to be checked (opening the file).
Change this:
fd = open(argv[1], O_RDONLY);
To this:
check(fd=open(argv[1], O_RDONLY));
That's what Jacob is doing in its video. He is additionally adding the check in the read operation, but that's completely secondary and aimed to catch errors that came after the file was opened successfully (No example of this kind of errors was shown in the video).