__func__ and __PRETTY_FUNCTION__ not always expanded - c

Question

I have a log library that uses a macro to trace a message. This macro makes use of predefined macros like __func__ and __PRETTY_FUNCTION__ to indicate in which function/method the message was logged.
The macro of my log library is defined in the main header of my log library, outside any function.
For some reason, the preprocessed code contains __func__ (or __PRETTY_FUNCTION__ if i'm using this one) litterally, just like if these predefined macros didn't exist. But i know they DO exist because if i'm using them without using my lib's trace macro, they work !
Here is my libs macro :
#if _MSC_VER >= 1400 // If >= VS2005
#define _TRACE_FUNC_SIGNATURE __FUNCSIG__
#elif defined(__ANDROID__) || defined( __GNUC__ ) && defined( __cplusplus ) // If G++ and/or Android NDK
#define _TRACE_FUNC_SIGNATURE __func__
#else
#error // Unsupported compiler
#endif
// Forces the reprocessing of x to properly expand __VA_ARGS__ when using MSVC compiler
#define _TRACE_REPROCESS( x ) x
#define _TRACE_X( _methodName_, _logCatPtr_, ... ) \
do { \
::dbg::LogCategory * const _catPtrVal_ = (::dbg::LogCategory *)(_logCatPtr_); \
if( NULL != _catPtrVal_ && _catPtrVal_->IsEnabled() ) \
{ \
_TRACE_REPROCESS( _catPtrVal_->_methodName_( _TRACE_FUNC_SIGNATURE " - " __VA_ARGS__ ); ) \
} \
} while( false )
#define TRACE_E( _logCatPtr_, ... ) _TRACE_X( Error, _logCatPtr_, __VA_ARGS__ )
#define TRACE_W( _logCatPtr_, ... ) _TRACE_X( Warning, _logCatPtr_, __VA_ARGS__ )
#define TRACE_I( _logCatPtr_, ... ) _TRACE_X( Info, _logCatPtr_, __VA_ARGS__ )
I know that these macros have no reason to be defined outside a function, but since i'm only using my trace macro inside functions/methods, then it should be defined there !
I'm using the default Android NDK compiler provided with eclipse, which as I read is some kind of extended G++.
EDIT : If I replace __func__ by an actual string litteral, it works, no syntax error. This lets me think that __func__ is definately not defined when used in my macro.

Answer 1

In some implementations, __func__ is a variable, not a macro (at least in gcc). So, you cannot use it as if it were a string literal.
So, this :
_TRACE_REPROCESS( _catPtrVal_->_methodName_( _TRACE_FUNC_SIGNATURE " - " __VA_ARGS__ ); )
will have to be written differently. I don't know how _catPtrVal_->_methodName_ is implemented, but if it can take multiple parameters, then something like this will probably do the trick :
_TRACE_REPROCESS( _catPtrVal_->_methodName_( _TRACE_FUNC_SIGNATURE, " - " __VA_ARGS__ ); )
If not, then you'll have to use some other way of concatenating __func__ with the rest of the log line (using a std::stringstream eg.).
More details
The C standard specifies __func__ like this :
The identifier __func__ shall be implicitly declared by the translator as if,
immediately following the opening brace of each function definition, the declaration
static const char __func__[] = "function-name";
appeared, where function-name is the name of the lexically-enclosing function.
Ie. it leaves it up to the implementation whether to provide it as a variable, or a macro (as long as it behaves as if it were defined as shown above).
As an example, gcc provides it as a variable, and MSVC provides it as a macro.

Answer 2

I thought I'd add my two cents - it IS possible to use the function signature in preprocessor directives, but you have to capture it first. Here's an example working up to a comparison of __PRETTY_FUNCTION__ and the preprocessor alternative.
#include <stdio.h>
#define CAT(X,Y) X ## Y
#define VAR(X) X
#define VAR_(X) VAR(X)
#define VAL(X) #X
#define VAL_(X) VAL(X)
/* Alias for constexpr cstring */
#define SZ const char*
#define CE_SZ constexpr SZ
/* Alias for assignment with appended log statement */
#define LOG(X, Y) X = Y; CE_SZ VAR_(CAT(INFO_, X)) = \
VAL_(X) " = " VAL_(Y) " (" __FILE__ VAL_(:__LINE__) ")"
/* SZ_A has no preprocessor value */
CE_SZ SZ_A = "Value of SZ_A";
/* SZ_B only has value to the preprocessor during LOG
(no define from inside a define, macro, etc.) */
CE_SZ LOG(SZ_B, "Value of SZ_B");
/* SZ_C has a global preprocessor name and value, but no compile time name */
#define SZ_C "Value of SZ_C"
/* SZ_D associates a compile time name with the value of SZ_C */
CE_SZ LOG(SZ_D, SZ_C);
/*
__PRETTY_FUNCTION__ and __func__ don't expand to string literals, but
to references to strings initialized by the compiler. If you capture the
signature in a preprocessor define, it's available globally; if you pass
it to a preprocessor macro, it's available within the scope of the macro.
__PRETTY_FUNCTION__ depends on compiler implementation (if it's defined
at all) - parameter names will be missing, template typenames and values
will be enumerated, etc.
*/
#define SIG template<typename T = SZ> void test(T caller)
SIG {
/* int main(int, const char**) */
printf(" Called function: %s\n", caller);
/* void test(T) [with T = const char*] */
printf(" Current function: %s\n", __PRETTY_FUNCTION__);
/* template<typename T = const char*> void test(T caller) */
printf(" Preprocessor signature: " VAL_(SIG) "\n");
}
CE_SZ LOG(SZ_E, VAL_(SIG));
int main(int argc, const char *argv[]) {
/* SZ_A = "Value of SZ_A" */
printf("%s = \"%s\"\n", VAL_(SZ_A), SZ_A);
/* SZ_B = "Value of SZ_B" (main.cpp:26) */
printf("%s\n", INFO_SZ_B);
/* SZ_C = "Value of SZ_C" */
printf("%s\n", "SZ_C = " VAL_(SZ_C));
/* SZ_D = "Value of SZ_D" (main.cpp:32) */
printf("%s\n\n", INFO_SZ_D);
test(__PRETTY_FUNCTION__);
/* SZ_E = "template..." (main.cpp:53) */
printf("\n%s\n", INFO_SZ_E);
}