CODEWITHSUNDEEP
c++functionmacros
DsCpp
DsCpp

Reputation: 2489

Using MACROs to get the 'name' of function parameters

I've implemented a log function, that eventually is being used identically all over the code. 

void func(int foo, int bar){
    log_api_call("foo", foo, "bar",bar)
    ...
}

so I've decided to make it easier and just extract the variable names.
so it would be something like 

log_api_call(foo,bar)

or even better

log_api_call()

and it would expand to log_api_call("foo", foo, "bar",bar) somehow.
I have no idea even where to start to 'extract' the function variable names. help would be much appreciated.

Edit:
I understand that what I've asked previously is outside of the C++ preprocessor capabilities, but can C MACROS expand log_api(a,b) to log_api_call("a", a, "b", b) for any number of parameters? for defined number the job is trivial.

Thanks.

Upvotes: 0

Views: 2821

Answers (4)

Basile Starynkevitch
Basile Starynkevitch

Reputation: 1

This is not possible in standard C++11 (or standard C11 - which nearly shares its preprocessor with C++). The C or C++ preprocessor don't know the AST of your code passed to the compiler (because it is running before the actual parsing of your code).

I have no idea even where to start to 'extract' the function variable names.

Notice that variable and function names are known only at compilation time (after preprocessing). So if you want them, you need to work during compilation. At execution time variables and functions names are generally lost (and you could strip your executable).

You could generate your C++ code (e.g.using some other preprocessor like GPP or M4, or writing your own thing).

You could customize your C++ compiler (e.g. with an extension in GCC MELT, or a GCC plugin) to e.g. have log_api_call invoke some new magic builtin (whose processing inside the compiler would do most of the job). This would take months and is very compiler specific, I don't think it is worth the pain.

You could parse DWARF debugging info (that would also take months, so I don't think it would be wise).

(I am implicitly thinking of C++ code compiled on a Linux system)

Read more about aspect programming.

If you want such powerful meta-programming facilities, C++ is the wrong programming language. Read more about the powerful macro system of Common Lisp...

but can C MACROS expand log_api(a,b) to log_api_call("a", a, "b", b) for any number of parameters? for defined number the job is trivial.

No. You need a more powerful preprocessor to do that job (or write your own). For that specific need, you might consider customizing your source code editor (e.g. write a hundred lines of ELisp code doing that extraction & expansion job at edit time for emacs).

PS In practice you could find some library (probably boost) limiting the arguments to some reasonable limit

Upvotes: 3

H Walters
H Walters

Reputation: 2674

This isn't actually too difficult.

I'd recommend a slight change in spec though; instead of:

expand log_api(a,b) to log_api_call("a", a, "b", b)

...it's more useful to expand something like NAMED_VALUES(a,b) to "a",a,"b",b. You can then call log_api(NAMED_VALUES(a,b)), but your log_api can stay more generic (e.g., log_api(NAMED_VALUES(a,b),"entering function") is possible). This approach also avoids a lot of complications about zero-argument cases.

// A preprocessor argument counter
#define COUNT(...) COUNT_I(__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1,)
#define COUNT_I(_9,_8,_7,_6,_5,_4,_3,_2,_1,X,...) X
// Preprocessor paster
#define GLUE(A,B) GLUE_I(A,B)
#define GLUE_I(A,B) A##B
// chained caller
#define NAMED_VALUES(...) GLUE(NAMED_VALUES_,COUNT(__VA_ARGS__))(__VA_ARGS__)
// chain
#define NAMED_VALUES_1(a) #a,a
#define NAMED_VALUES_2(a,...) #a,a,NAMED_VALUES_1(__VA_ARGS__)
#define NAMED_VALUES_3(a,...) #a,a,NAMED_VALUES_2(__VA_ARGS__)
#define NAMED_VALUES_4(a,...) #a,a,NAMED_VALUES_3(__VA_ARGS__)
#define NAMED_VALUES_5(a,...) #a,a,NAMED_VALUES_4(__VA_ARGS__)
#define NAMED_VALUES_6(a,...) #a,a,NAMED_VALUES_5(__VA_ARGS__)
#define NAMED_VALUES_7(a,...) #a,a,NAMED_VALUES_6(__VA_ARGS__)
#define NAMED_VALUES_8(a,...) #a,a,NAMED_VALUES_7(__VA_ARGS__)
#define NAMED_VALUES_9(a,...) #a,a,NAMED_VALUES_8(__VA_ARGS__)

This supports up to 9 arguments, but it should be easy to see how to expand to more.

Upvotes: 6

MikeMB
MikeMB

Reputation: 21166

I think the best you can achieve from inside the language is writing a macro LOG_API_CALL(foo,bar) that expands to log_api_call("foo", foo, "bar", bar):

#define LOG_API_CALL(P1,P2) log_api_call(#P1,P1,#P2,P1)

This gets pretty tricky if you want to support arbitrarily many arguments with a single macro name, but you could also have a separate macro for each number of arguments.

Upvotes: 4

gsamaras
gsamaras

Reputation: 73434

and it would expand to log_api_call("foo", foo, "bar",bar) somehow.

This is not possible in Standard C++.

Upvotes: 2

Related Questions