Find out if exists #define by it's name

Detecting C/C++ Preprocessor #define Macros by Name

Explore various techniques to programmatically determine if a specific #define macro exists in C/C++ code, covering preprocessor directives, build system integration, and advanced parsing methods.

In C and C++, preprocessor macros (#define) are powerful tools for conditional compilation, constant definition, and code generation. Often, you might need to check for the existence of a specific macro by its name, either within the code itself or as part of a build process. This article delves into different strategies for achieving this, from direct preprocessor checks to more sophisticated parsing techniques.

1. Using Preprocessor Directives (#ifdef, #ifndef, #if defined)

The most straightforward and common way to check for a macro's existence is directly within your C/C++ source code using preprocessor directives. These directives allow you to conditionally compile blocks of code based on whether a macro is defined or not. This is particularly useful for platform-specific code, feature toggles, or debugging.

#include <stdio.h>

// Example macro definitions
#define FEATURE_A
#define VERSION 100

int main() {
    #ifdef FEATURE_A
        printf("FEATURE_A is defined.\n");
    #endif

    #ifndef FEATURE_B
        printf("FEATURE_B is NOT defined.\n");
    #endif

    #if defined(VERSION) && (VERSION > 50)
        printf("VERSION is defined and greater than 50.\n");
    #endif

    #if !defined(DEBUG_MODE)
        printf("DEBUG_MODE is NOT defined.\n");
    #endif

    return 0;
}

Checking macro existence using #ifdef, #ifndef, and #if defined

2. External Checks via Build Systems (CMake, QMake, Makefiles)

Sometimes, you need to know if a macro is defined before compilation, perhaps to configure your build system or generate source files. Build systems like CMake, QMake, and Makefiles offer mechanisms to pass macro definitions to the compiler or to perform checks themselves.

flowchart TD
    A[Start Build Process] --> B{Check for Macro Definition?}
    B -- Yes --> C[Build System (e.g., CMake, QMake)]
    C --> D{Query Compiler/Environment}
    D -- Macro Found --> E[Define Macro for Compiler (-D)]
    D -- Macro Not Found --> F[Conditional Logic in Build Script]
    E --> G[Compile Source Code]
    F --> G
    G --> H[End Build Process]

Flowchart of external macro checking within a build system

CMake Example

CMake can check for compiler definitions or define them based on conditions. You can use check_c_source_compiles or add_definitions.

cmake_minimum_required(VERSION 3.10)
project(MacroCheck C)

# Define a macro for demonstration
add_definitions(-DMACRO_FROM_CMAKE)

# Check if a macro is defined (e.g., by the compiler or previous add_definitions)
# This is more complex for checking *if* something was defined externally
# For checking if a feature is available, check_c_source_compiles is better.

# To check if a specific macro was passed to the compiler:
# You'd typically rely on the compiler to define it, or pass it explicitly.
# For example, if you want to know if 'MY_FEATURE' is defined:
# You'd usually define it in CMake and then check it in C++.

# Let's simulate checking for a macro that might be defined externally
# This often involves trying to compile a small test program.

# Example: Check if a specific function exists (similar concept)
# include(CheckCSourceCompiles)
# check_c_source_compiles(
#   "#ifdef SOME_EXTERNAL_MACRO\nint main(){return 0;}\n#else\n#error SOME_EXTERNAL_MACRO not defined\n#endif"
#   SOME_EXTERNAL_MACRO_DEFINED
# )

# A simpler approach for CMake to define based on its own logic:
if(DEFINED ENV{MY_ENV_VAR})
    message(STATUS "MY_ENV_VAR is set in environment, defining ENV_MACRO")
    add_definitions(-DENV_MACRO)
else()
    message(STATUS "MY_ENV_VAR is NOT set in environment")
endif()

add_executable(my_app main.c)

CMakeLists.txt demonstrating macro definition and conditional logic

QMake Example

QMake uses its own syntax for conditional logic based on defines.

CONFIG += console
CONFIG -= app_bundle

SOURCES += main.cpp

# Define a macro
DEFINES += MY_QMAKE_MACRO

# Check if a macro is defined
# QMake's 'DEFINES' variable holds all defined macros
# You can check for their presence in the list.

# This checks if 'MY_QMAKE_MACRO' is in the DEFINES list
contains(DEFINES, MY_QMAKE_MACRO) {
    message("MY_QMAKE_MACRO is defined by QMake")
}

# You can also check for specific configurations
# For example, if a macro was passed via command line: qmake DEFINES+=EXTERNAL_MACRO
contains(DEFINES, EXTERNAL_MACRO) {
    message("EXTERNAL_MACRO is defined (e.g., via command line)")
}

# Conditional compilation based on OS
win32 {
    DEFINES += OS_WINDOWS
}
else:unix {
    DEFINES += OS_UNIX
}

QMake .pro file demonstrating macro definition and checks

3. Advanced Parsing and Static Analysis

For more complex scenarios, such as analyzing third-party codebases or performing static analysis, you might need to parse the C/C++ source files to identify all #define directives. This goes beyond simple preprocessor checks and involves understanding the syntax and semantics of the language.

Tools and libraries that can help with this include:

• Clang LibTooling/LibClang: Provides a robust API for parsing C/C++/Objective-C code, building Abstract Syntax Trees (ASTs), and accessing preprocessor information.
• GCC's preprocessor output: You can run the C preprocessor (cpp) separately to expand all macros and then parse its output, though this might lose information about where a macro was defined.
• Custom parsers: For very specific needs, you might write a simple parser, but this is generally discouraged due to the complexity of C/C++ grammar.

# Example: Using GCC's preprocessor to see defined macros
# This will expand all macros and show the result, but not directly list *all* #defines
# To see the defines that are active, you'd typically look at the compiler's output

# To get a list of predefined macros by GCC:
# echo | gcc -dM -E -

# To preprocess a file and see the expanded output:
# gcc -E your_file.c

# To check if a specific macro is defined during compilation (indirectly):
# Compile a small test file that uses #error if the macro is NOT defined
# For example, create check_macro.c:
# #ifndef MY_MACRO
# #error "MY_MACRO is not defined!"
# #endif
# int main() { return 0; }

# Then compile it:
# gcc check_macro.c -o check_macro
# If MY_MACRO is not defined, compilation will fail with the #error message.
# If it is defined (e.g., via -DMY_MACRO), it will compile successfully.

# Example of defining a macro via command line
# gcc -DMY_MACRO check_macro.c -o check_macro

Using GCC's preprocessor and command-line options for macro checks

Conclusion

Determining the existence of a #define macro by its name can be approached in several ways, depending on your context. For in-code conditional logic, #ifdef, #ifndef, and #if defined() are the standard. For build-time configuration, integrating with your build system (CMake, QMake, Makefiles) is key. For deep analysis or complex tooling, leveraging compiler frontends like Clang provides the most robust solution. Choose the method that best fits your specific requirements and the complexity of your project.