Cpp.PreprocIfdef Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the preproc_ifdef nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.PreprocIfdef represents the node preproc_ifdef in the syntax tree of your code.

#define FOO
#ifdef FOO
int x = 1;
#else
int x = 2;
#endif

The #ifdef ... #else ... #endif block in the example corresponds to the preproc_ifdef node and is represented by Cpp.PreprocIfdef.

Predicates

expand all

Type

Type	Raisable	Printable
`PreprocIfdef`	Yes	No

Syntaxes

This class defines these predicates that act on the objects of this class. In addition, objects of this class can access the predicates defined by the base class AstNodeProperties. An object of this class is an object of AstNodeProperties class.

Predicates	Description	Example
`is(required PreprocIfdef &preprocIfdef)`	Matches a `preproc_ifdef` node and returns it as `preprocIfdef`.	This PQL defect checks for occurrences of `preproc_ifdef` nodes. defect preprocifdef_is = when Cpp.PreprocIfdef.is(&ifdef) raise "found ifdef" on ifdef In this C++ code, the defect finds the `#ifdef` block. #ifdef FOO int x = 1; #endif
`cast(Cpp.Node.Node node, required PreprocIfdef &cast)`	Checks whether a generic `Node` is a `preproc_ifdef` and if so returns it as `cast`.	This PQL defect checks whether a given `Node` is a `preproc_ifdef`. defect d = when Cpp.Node.is(&node, &,&,&) and Cpp.PreprocIfdef.cast(node, &ifdef) raise "node is PreprocIfdef" on ifdef In this code, the defect finds the `#ifdef` block. #ifdef BAR void bar() {} #endif
`isa(Cpp.Node.Node node)`	Tests whether a `Node` is a `preproc_ifdef`.	This PQL defect checks whether a generic node is a `preproc_ifdef` block. defect d = when Cpp.Node.is(&node, &,&,&) and Cpp.PreprocIfdef.isa(node) raise "isa confirms PreprocIfdef" on tmp The check detects the `#ifdef` node by asking if a `Node` is that type. #ifdef BAZ #include <vector> #endif
`alternative(PreprocIfdef self, Cpp.Node.Node &child)`	Matches the alternative branch (`#else` or `#elif`) of the `preproc_ifdef` and returns it as `child`.	This PQL defect checks for the presence of an `#else` or `#elif` branch inside a `preproc_ifdef`. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.alternative(&alt) raise "found alternative branch" on alt In this code, the defect locates the `#else` branch inside the `#ifdef` block. #ifdef FOO int x = 1; #else int x = 2; #endif
`name(PreprocIfdef self, Cpp.Node.Node &child)`	Matches the macro identifier used in the `#ifdef`/`#ifndef` directive and returns it as `child`.	This PQL defect checks for the macro name token within a `preproc_ifdef`. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.name(&n) raise "macro name found" on n In this code, the defect identifies the macro token following `#ifdef`. #ifdef CONFIG_ENABLED int x; #endif
`functionDefinition(PreprocIfdef self, Cpp.Node.Node &child)`	Matches a function definition located inside the `preproc_ifdef` block and returns it as `child`.	This PQL defect checks for function definitions that appear within an `#ifdef` region. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.functionDefinition(&fn) raise "function inside ifdef" on fn In this code, the defect finds functions that are conditionally compiled inside the `#ifdef`. #ifdef BAR void bar() {} #endif
`linkageSpecification(PreprocIfdef self, Cpp.Node.Node &child)`	Matches a linkage specification (for example `extern "C" { ... }`) within the `preproc_ifdef` and returns it as `child`.	This PQL defect checks for linkage specifications inside `preproc_ifdef` blocks. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.linkageSpecification(&link) raise "linkage spec in ifdef" on link In this code, the defect detects `extern "C"` sections that are conditionally compiled. #ifdef USE_C extern "C" { void c_func(); } #endif
`namespaceAliasDefinition(PreprocIfdef self, Cpp.Node.Node &child)`	Matches a namespace alias declaration inside the `preproc_ifdef` and returns it as `child`.	This PQL defect checks for namespace alias declarations within conditional blocks. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.namespaceAliasDefinition(&alias) raise "namespace alias in ifdef" on alias In this code, the defect finds `namespace X = Y;` declarations hidden by preprocessor guards. #ifdef ALIAS namespace ns2 = ns1; #endif
`namespaceDefinition(PreprocIfdef self, Cpp.Node.Node &child)`	Matches a `namespace` block inside the `preproc_ifdef` and returns it as `child`.	This PQL defect checks for namespace definitions that are conditionally compiled. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.namespaceDefinition(&ns) raise "namespace in ifdef" on ns In this code, the defect detects namespaces introduced only under certain macros. #ifdef ADD_NS namespace extra { int a; } #endif
`preprocCall(PreprocIfdef self, Cpp.Node.Node &child)`	Matches nested preprocessor calls inside the `preproc_ifdef` and binds them to `child`.	This PQL defect checks for other preprocessor directives within a `preproc_ifdef`. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.preprocCall(&pc) raise "preprocessor call inside ifdef" on pc In this code, the defect finds directives like `#define` or `#undef` that appear inside the `#ifdef` block. #ifdef FOO #define X 1 #endif
`preprocDef(PreprocIfdef self, Cpp.Node.Node &child)`	Matches a `#define` directive inside the `preproc_ifdef` and returns it as `child`.	This PQL defect checks specifically for `#define` definitions inside conditional blocks. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.preprocDef(&ddef) raise "define in ifdef" on ddef In this code, the defect spots macros defined only when a guard is active. #ifdef ENABLE_FEATURE #define FEATURE_FLAG 42 #endif
`preprocFunctionDef(PreprocIfdef self, Cpp.Node.Node &child)`	Matches a preprocessor function-like macro definition inside the `preproc_ifdef` and returns it as `child`.	This PQL defect checks for function-like macro definitions within `preproc_ifdef`. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.preprocFunctionDef(&m) raise "function-like macro in ifdef" on m In this code, the defect detects macros declared with parameters inside the conditional. #ifdef MF #define LOG(fmt, ...) printf(fmt, ##__VA_ARGS__) #endif
`preprocIf(PreprocIfdef self, Cpp.Node.Node &child)`	Matches nested `#if`, `#ifdef`, or `#ifndef` inside the `preproc_ifdef` and returns it as `child`.	This PQL defect checks for nested preprocessor conditional blocks. defect d = when Cpp.PreprocIfdef.is(&outer) and outer.preprocIf(&inner) raise "nested preproc_if" on inner In this code, the defect finds inner `#if` blocks nested within an outer `#ifdef`. #ifdef OUTER #if INNER int x; #endif #endif
`preprocIfdef(PreprocIfdef self, Cpp.Node.Node &child)`	Matches nested `preproc_ifdef` nodes (another `#ifdef`/`#else`/`#endif`) inside this `preproc_ifdef` and returns it as `child`.	This PQL defect checks for another `preproc_ifdef` nested inside the current one. defect d = when Cpp.PreprocIfdef.is(&outer) and outer.preprocIfdef(&inner) raise "nested ifdef" on inner In this code, the defect locates nested `#ifdef` blocks that are conditionally compiled. #ifdef A #ifdef B int y; #endif #endif
`preprocInclude(PreprocIfdef self, Cpp.Node.Node &child)`	Matches `#include` directives inside the `preproc_ifdef` and binds them to `child`.	This PQL defect checks for headers included conditionally inside an `#ifdef`. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.preprocInclude(&inc) raise "include in ifdef" on inc In this code, the defect detects `#include` that only occurs when a macro is defined. #ifdef BAZ #include <vector> #endif
`statement(PreprocIfdef self, Cpp.Node.Node &child)`	Matches a top-level statement or declaration inside the `preproc_ifdef` and returns it as `child`.	This PQL defect checks for general statements or declarations inside the `preproc_ifdef`. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.statement(&stmt) raise "statement in ifdef" on stmt In this code, the defect finds ordinary code statements that are conditionally compiled. #ifdef FOO int x = 1; #endif
`staticAssertDeclaration(PreprocIfdef self, Cpp.Node.Node &child)`	Matches `static_assert` declarations inside the `preproc_ifdef` and binds them to `child`.	This PQL defect checks for `static_assert` statements guarded by preprocessor macros. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.staticAssertDeclaration(&sa) raise "static_assert in ifdef" on sa In this code, the defect detects compile-time assertions present only when a macro is set. #ifdef CHECK static_assert(sizeof(int) == 4, "int must be 4 bytes"); #endif
`templateDeclaration(PreprocIfdef self, Cpp.Node.Node &child)`	Matches `template` declarations inside the `preproc_ifdef` and binds them to `child`.	This PQL defect checks for template declarations that are conditionally compiled. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.templateDeclaration(&td) raise "template in ifdef" on td In this code, the defect finds class or function templates present only under certain macros. #ifdef USE_TEMPL template<typename T> struct S { T v; }; #endif
`templateInstantiation(PreprocIfdef self, Cpp.Node.Node &child)`	Matches explicit template instantiations inside the `preproc_ifdef` and binds them to `child`.	This PQL defect checks for `template` instantiation statements inside preprocessor guards. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.templateInstantiation(&ti) raise "template instantiation in ifdef" on ti In this code, the defect flags `template class Foo<int>;` that appear only when a macro is defined. #ifdef INST template class std::vector<int>; #endif
`typeDefinition(PreprocIfdef self, Cpp.Node.Node &child)`	Matches `typedef` or `using` type definitions inside the `preproc_ifdef` and binds them to `child`.	This PQL defect checks for type aliases and typedefs inside conditional blocks. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.typeDefinition(&td) raise "type definition in ifdef" on td In this code, the defect detects types defined only when a macro is active. #ifdef TDEF using size_t_alias = std::size_t; #endif
`accessSpecifier(PreprocIfdef self, Cpp.Node.Node &child)`	Matches `public`, `protected`, or `private` labels inside a class body within the `preproc_ifdef` and binds them to `child`.	This PQL defect checks for access specifiers that are conditionally compiled inside a class. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.accessSpecifier(&as) raise "access specifier in ifdef" on as In this code, the defect finds `public:` or `private:` lines that appear depending on macros. class C { #ifdef MAKE_PUBLIC public: #else private: #endif int v; };
`typeSpecifier(PreprocIfdef self, Cpp.Node.Node &child)`	Matches type specifiers (like `int`, `struct X`) inside the `preproc_ifdef` and binds them to `child`.	This PQL defect checks for type specifiers inside guarded regions. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.typeSpecifier(&ts) raise "type specifier in ifdef" on ts In this code, the defect locates type declarations included conditionally. #ifdef USE_INT int conditional_var; #endif
`aliasDeclaration(PreprocIfdef self, Cpp.Node.Node &child)`	Matches `using` alias declarations inside the `preproc_ifdef` and binds them to `child`.	This PQL defect checks for alias declarations that are conditionally compiled. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.aliasDeclaration(&ad) raise "alias in ifdef" on ad In this code, the defect detects `using name = type;` only present under macros. #ifdef ALIAS_T using myint = int; #endif
`usingDeclaration(PreprocIfdef self, Cpp.Node.Node &child)`	Matches `using` declarations (e.g., `using std::swap;`) inside the `preproc_ifdef` and binds them to `child`.	This PQL defect checks for `using` declarations inside conditional blocks. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.usingDeclaration(&ud) raise "using declaration in ifdef" on ud In this code, the defect finds `using` statements that are enabled only by a macro. #ifdef USE_SWAP using std::swap; #endif
`conceptDefinition(PreprocIfdef self, Cpp.Node.Node &child)`	Matches C++20 `concept` definitions inside the `preproc_ifdef` and binds them to `child`.	This PQL defect checks for `concept` declarations inside preprocessor guards. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.conceptDefinition(&c) raise "concept in ifdef" on c In this code, the defect detects `concept` definitions that are conditionally compiled. #ifdef USE_CONCEPT template<typename T> concept C = requires(T t) { t.size(); }; #endif
`declaration(PreprocIfdef self, Cpp.Node.Node &child)`	Matches any declaration (variable, function, type) inside the `preproc_ifdef` and returns it as `child`.	This PQL defect checks for declarations inside the `preproc_ifdef`. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.declaration(&decl) raise "declaration in ifdef" on decl In this code, the defect finds declarations that exist only when a guard macro is defined. #ifdef DECL extern int ex; #endif
`enumerator(PreprocIfdef self, Cpp.Node.Node &child)`	Matches enum enumerators defined inside the `preproc_ifdef` and binds them to `child`.	This PQL defect checks for enum members declared under preprocessor guards. defect d = when Cpp.PreprocIfdef.is(&ifdef) and ifdef.enumerator(&e) raise "enumerator in ifdef" on e In this code, the defect identifies enum entries inside an `#ifdef`. `#ifdef DECL enum E { A, B, D }; #endif`
`friendDeclaration(PreprocIfdef self, Cpp.Node.Node &child)`	Find `friend` declarations inside the `preproc_ifdef` block.	This PQL defect checks for friend declarations inside a `preproc_ifdef`. defect d = when Cpp.PreprocIfdef.is(&pi) and pi.friendDeclaration(&fr) raise "Found friend declaration" on pi In this C++ code, the defect matches `friend class Bar;`. #ifdef FOO class X { friend class Bar; }; #endif
`getEnclosingPreprocIfdef (Cpp.Node.Node child, required PreprocIfdef &parent)`	Find the closest `preproc_ifdef` ancestor `parent` to the node `child`.	This PQL defect checks for the preprocessor `#ifdef` blocks that encloses a generic child node. defect detect_enclosing_field = when Cpp.Node.is(&node, &,&,&) and Cpp.PreprocIfdef.getEnclosingFieldDeclaration(node, &fd) and fd.nodeText(&txt) raise "Enclosing PreprocIfdef: {txt}" on fd In this C++ code the defect locates the preprocessor `#ifdef` block. #ifdef FOO #include <bar.h> #endif
`isEnclosedInPreprocIfdef (Cpp.Node.Node child)`	Find all nodes that have an ancestor `preproc_ifdef`	This PQL defect checks for if a generic node is enclosed in a `#ifdef` blocks defect detect_enclosing_field = when Cpp.Node.is(&node, &,&,&) and Cpp.PreprocIf.getEnclosingFieldDeclaration(node, &fd) and fd.nodeText(&txt) raise "Enclosing PreprocIf: {txt}" on fd In this C++ code the defect finds the syntax nodes that are inside the preprocessor `#if` block. #if FOO #include <bar.h> #endif

Version History

Introduced in R2026a