Cpp.PreprocIf Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the preproc_if nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.PreprocIf represents the node preproc_if in the syntax tree of your code.

#if FOO
int x = 1;
#else
int x = 2;
#endif

The example contains a preproc_if block that corresponds to Cpp.PreprocIf. The whole #if ... #else ... #endif region is the node matched by this class.

Predicates

expand all

Type

Type	Raisable	Printable
`PreprocIf`	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 PreprocIf &preprocIf)`	Match a `preproc_if` node and return as output variable. Use when you want to select whole preprocessor-if blocks.	This PQL defect checks for any top-level `preproc_if` nodes. defect d = when Cpp.PreprocIf.is(&pi) raise "Found preproc_if" on pi In this C++ code, the defect finds the `#if FOO ... #endif` block. #define FOO 1 #if FOO int x = 1; #endif
`cast(Cpp.Node.Node node, required PreprocIf &cast)`	Check whether a generic `Node` is a `preproc_if` and if so return it as a `PreprocIf` for further predicates.	This PQL defect checks whether a general node is a `preproc_if` node. defect d = when Cpp.Node.is(&n, &,&,&) and Cpp.PreprocIf.cast(n, &pi) raise "Node is PreprocIf" on pi In this C++ code, the defect converts the generic AST node covering the `#if` into a `PreprocIf`. #if defined(BAR) int y = 3; #endif
`isa(Cpp.Node.Node node)`	Return true if the given `Node` is a `preproc_if` node. Use when you only need a boolean check.	This PQL defect checks whether a node is a `preproc_if` using a boolean test. defect d = when Cpp.Node.is(&n, &,&,&) and Cpp.PreprocIf.isa(n) raise "Node isa PreprocIf" on n In this C++ code, the predicate recognizes the `#if` region as a `preproc_if` node. #if FOO int x = 1; #endif
`alternative(PreprocIf self, Cpp.Node.Node &child)`	Finds the `#else` or `#elif` alternative branch node inside the `preproc_if`.	This PQL defect checks for the presence of an alternative branch inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.alternative(&alt) raise "Found alternative branch" on pi In this C++ code, the defect finds the `#else` branch. #if FOO int x = 1; #else int x = 2; #endif
`condition(PreprocIf self, Cpp.Node.Node &child)`	Find the conditional expression of the `#if` or `#elif` such as `defined(X)` or macro names.	This PQL defect checks for the condition expression inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.condition(&cond) raise "Found preproc_if condition" on pi In this C++ code, the defect inspects the `defined(BAR)` condition. #if defined(BAR) int y = 3; #endif
`statement(PreprocIf self, Cpp.Node.Node &child)`	Find a normal statement or declaration node contained directly in the `preproc_if` body.	This PQL defect checks for executable statements inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.statement(&stmt) raise "Found statement in preproc_if" on pi In this C++ code, the defect finds the `int x = 1;` statement inside the `#if`. #if FOO int x = 1; #endif
`staticAssertDeclaration(PreprocIf self, Cpp.Node.Node &child)`	Find `static_assert` declarations that appear inside the `preproc_if` body.	This PQL defect checks for `static_assert` inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.staticAssertDeclaration(&sa) raise "Found static_assert" on pi In this C++ code, the defect matches the `static_assert` line. #if FOO static_assert(sizeof(int) == 4); #endif
`templateDeclaration(PreprocIf self, Cpp.Node.Node &child)`	Find template declarations appearing inside the `preproc_if`, such as `template <...> struct`.	This PQL defect checks for template declarations inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.templateDeclaration(&td) raise "Found template declaration" on pi In this C++ code, the defect finds the template `struct S`. #if FOO template<typename T> struct S {}; #endif
`templateInstantiation(PreprocIf self, Cpp.Node.Node &child)`	Find template instantiation expressions inside the `preproc_if`, e.g., `S<int> s;`.	This PQL defect checks for template instantiations within a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.templateInstantiation(&ti) raise "Found template instantiation" on pi In this C++ code, the defect finds `S<int> s;` as an instantiation. #if FOO S<int> s; #endif
`typeDefinition(PreprocIf self, Cpp.Node.Node &child)`	Find type definition nodes inside the `preproc_if` such as `typedef` or `using`-alias definitions.	This PQL defect checks for type definitions inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.typeDefinition(&td) raise "Found type definition" on pi In this C++ code, the defect matches the `typedef int myint;`. #if FOO typedef int myint; #endif
`accessSpecifier(PreprocIf self, Cpp.Node.Node &child)`	Find access specifier labels such as `public:`, `protected:`, or `private:` inside the `preproc_if`.	This PQL defect checks for access specifiers inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.accessSpecifier(&as) raise "Found access specifier" on pi In this C++ code, the defect finds a `public:` label. #if FOO class C { public: int x; }; #endif
`typeSpecifier(PreprocIf self, Cpp.Node.Node &child)`	Find a type specifier node inside the `preproc_if` such as `int`, `double`, or a class name used as a type.	This PQL defect checks for type specifiers inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.typeSpecifier(&ts) raise "Found type specifier" on pi In this C++ code, the defect sees the `int` type specifier. #if FOO int; #endif
`aliasDeclaration(PreprocIf self, Cpp.Node.Node &child)`	Find `using alias = type;` alias declarations appearing inside the `preproc_if`.	This PQL defect checks for alias declarations inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.aliasDeclaration(&ad) raise "Found alias declaration" on pi In this C++ code, the defect matches `using myint = int;`. #if FOO using myint = int; #endif
`usingDeclaration(PreprocIf self, Cpp.Node.Node &child)`	Find `using` declarations such as type introductions or `using namespace` declarations inside the `preproc_if`.	This PQL defect checks for `using` declarations inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.usingDeclaration(&ud) raise "Found using declaration" on pi In this C++ code, the defect finds `using MyType = int;`. #if FOO using MyType = int; #endif
`conceptDefinition(PreprocIf self, Cpp.Node.Node &child)`	Find concept definitions inside the `preproc_if` such as `template<...> concept C = ...`.	This PQL defect checks for concept definitions inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.conceptDefinition(&cd) raise "Found concept definition" on pi In this C++ code, the defect matches the `concept C` declaration. #if FOO template<typename T> concept C = requires(T t) { t.foo(); }; #endif
`declaration(PreprocIf self, Cpp.Node.Node &child)`	Find general declarations such as variable or typedef declarations inside the `preproc_if`.	This PQL defect checks for declarations inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.declaration(&decl) raise "Found declaration" on pi In this C++ code, the defect finds `int z;` declared under the preprocessor condition. #if FOO int z; #endif
`enumerator(PreprocIf self, Cpp.Node.Node &child)`	Find enumerator entries inside an `enum` that is located within the `preproc_if`.	This PQL defect checks for enum members inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.enumerator(&e) raise "Found enumerator" on pi In this C++ code, the defect matches `A, B, D` members of the `enum`. #if FOO enum E { A, B, D }; #endif
`fieldDeclaration(PreprocIf self, Cpp.Node.Node &child)`	Find members declared inside a class or struct that appear within the `preproc_if`.	This PQL defect checks for field declarations inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.fieldDeclaration(&fd) raise "Found field declaration" on pi In this C++ code, the defect finds a class field such as `int field;`. #if FOO class C { int field; }; #endif
`friendDeclaration(PreprocIf self, Cpp.Node.Node &child)`	Find `friend` declarations inside the `preproc_if` block.	This PQL defect checks for friend declarations inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.friendDeclaration(&fr) raise "Found friend declaration" on pi In this C++ code, the defect matches `friend class Bar;`. #if FOO class X { friend class Bar; }; #endif
`functionDefinition(PreprocIf self, Cpp.Node.Node &child)`	Find function definitions inside the `preproc_if` block.	This PQL defect checks for function definitions inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.functionDefinition(&fd) raise "Found function definition" on pi In this C++ code, the defect finds `void foo() {}` placed inside the `#if`. #if FOO void foo() {} #endif
`linkageSpecification(PreprocIf self, Cpp.Node.Node &child)`	Find linkage specifications such as `extern "C" { ... }` that appear inside the `preproc_if`.	This PQL defect checks for linkage specifications inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.linkageSpecification(&ls) raise "Found linkage specification" on pi In this C++ code, the defect recognizes `extern "C" { int x; }`. #if FOO extern "C" { int x3; } #endif
`namespaceAliasDefinition(PreprocIf self, Cpp.Node.Node &child)`	Find namespace alias definitions inside the `preproc_if` such as `namespace foo = bar;`.	This PQL defect checks for namespace alias definitions inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.namespaceAliasDefinition(&nad) raise "Found namespace alias" on pi In this C++ code, the defect finds `namespace sfoo = std;`. #if FOO namespace sfoo = std; #endif
`namespaceDefinition(PreprocIf self, Cpp.Node.Node &child)`	Find nested namespace definitions inside the `preproc_if`.	This PQL defect checks for namespace definitions inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.namespaceDefinition(&nd) raise "Found namespace definition" on pi In this C++ code, the defect matches `namespace bar { int x; }`. #if FOO namespace bar { int x; } #endif
`preprocCall(PreprocIf self, Cpp.Node.Node &child)`	Find preprocessor directive calls inside the `preproc_if` such as `#pragma` lines.	This PQL defect checks for preprocessor calls inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.preprocCall(&pc) raise "Found preproc call" on pi In this C++ code, the defect finds `#pragma once` inside the conditional. #if FOO #pragma once #endif
`preprocDef(PreprocIf self, Cpp.Node.Node &child)`	Find preprocessor `#define` definitions that appear within the `preproc_if`.	This PQL defect checks for macro definitions inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.preprocDef(&pd) raise "Found preproc define" on pi In this C++ code, the defect matches `#define BAR 1`. #if FOO #define BAR 1 #endif
`preprocFunctionDef(PreprocIf self, Cpp.Node.Node &child)`	Find function-like macro definitions inside the `preproc_if` such as `#define FOO(x) ...`.	This PQL defect checks for function-style macro definitions inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.preprocFunctionDef(&pfd) raise "Found function-like macro" on pi In this C++ code, the defect sees `#define FOO(x) (x+1)` inside the `#if`. #if FOO #define FOO(x) (x+1) #endif
`preprocIf(PreprocIf self, Cpp.Node.Node &child)`	Find nested preprocessor `if` blocks located inside the current `preproc_if`.	This PQL defect checks for nested `#if` blocks inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.preprocIf(&pif) raise "Found nested preproc_if" on pi In this C++ code, the defect matches the inner `#if BAR` nested in the outer `#if FOO`. #if FOO #if BAR int y; #endif #endif
`preprocIfdef(PreprocIf self, Cpp.Node.Node &child)`	Find nested preprocessor `ifdef` blocks located inside the current `preproc_if`	This PQL defect checks for nested `#ifdef` blocks inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.preprocIfdef(&pif) raise "Found nested ideff" on pi In this C++ code, the defect matches the inner `#ifdef BAR` nested in the outer `#if FOO`. #if FOO #ifdef BAR int y; #endif #endif
`preprocInclude(PreprocIf self, Cpp.Node.Node &child)`	Find preprocessor `#include` located inside the current `preproc_if`	This PQL defect checks for nested `#include` blocks inside a `preproc_if`. defect d = when Cpp.PreprocIf.is(&pi) and pi.preprocInclude(&pif) raise "Found nested include" on pi In this C++ code, the defect matches the inner `#ifdef BAR` nested in the outer `#if FOO`. #if FOO #include <bar.h> #endif
`getEnclosingPreprocIf (Cpp.Node.Node child, required PreprocIf &parent)`	Find the closest `preproc_if` ancestor `parent` to the node `child`.	This PQL defect checks for the preprocessor `#if` blocks that encloses a generic child node. 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 locates the preprocessor `#if` block. #if FOO #include <bar.h> #endif
`isEnclosedInPreprocIf (Cpp.Node.Node child)`	Find all nodes that have an ancestor `preproc_if`	This PQL defect checks for if a generic node is enclosed in a `#if` 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