Yes, you will have to define those other symbols.
And, yes, tagging may know about these #define's, but there are several issues:
1) do you want the tagging engine to do full C Preprocessing
(severely killing performance)?
2) alternatively, do you want the tagging engine to to a database lookup
for every identifier it sees in order to check if it is a #define.
Also, this technique does not work when you are building the
database unless you do two passes, one to collect defines,
and another to do the actual tagging. Either way, it would
kill performance.
4) Some #define's are interesting and useful to expand, others are best
left as is, and others should be ignored. For example:
a) #define SOME_CONSTANT 22
void my_function(int parm = SOME_CONSTANT);
This is best left as-is, otherwise your prototype becomes
void my_function_int(parm=22);
b) #define STUPID_DECL __STUPID_ATTRIBUTE(blah,blah)
#define STUPID_ATTRIBUTE __compiler_specific_attribute_keyword
class STUPID_DECL MyClass { ... };
This is best ignored.
c) And finally, your example is an example of something that should be
expanded otherwise you will be missing critical definitions.
How is the tagging engine supposed to guess what #define's to expand and what not to? In general, it can't. This is why the C Preprocessing dialog exists. It allows you to specify what macros you want to be expanded and how. It also lets you specify that a macro should be ignored, such as the "STUPID_DECL" above. Finally, using it instead of trying to do full preprocessing allows us to keep performance very high.
This may seem like a pain in the neck, and I realize in your case, the preprocessing is coming from a 3rd party library and not your own code, but in general, this is the price you pay when people use the preprocessor to write code instead of using the language as intended. I am so glad that Java and C# and most other modern languages eschew preprocessing. There is so much more tooling that could have been done with C++ if only the preprocessing were not constantly in the way. The same problem is rapidly becoming true for the C++ template system, as people are abusing it in even more clever ways than people have abused the preprocessor.