Ast.PreprocInclude Class

Namespace: Ast
Superclasses: AstNodeProperties

Represents the preproc_include nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.PreprocInclude represents the node preproc_include in the syntax tree of your code.

#include <iostream>
#include "myheader.h"
#define AN_INCLUDE "<cstdint>"
#include AN_INCLUDE

int main() {
    std::cout << "hello\n";
    return 0;
}

The three #include lines generate preproc_include nodes in the tree. Each directive in the demo corresponds to a Cpp.PreprocInclude node.

Predicates

expand all

Type

Type	Raisable	Printable
`PreprocInclude`	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 PreprocInclude &include)`	Matches a `preproc_include` node and returns it as `include` so you can inspect it.	This PQL defect checks for any `#include` directive in the source. defect includeFound = when Cpp.PreprocInclude.is(&inc) and inc.nodeText(&txt) raise "Found include: \"{txt}\"" on inc In this C++ code the defect finds each `#include` directive and reports its source text. #include <iostream> #include "myheader.h" int main() { return 0; }
`cast(Cpp.Node.Node node, required PreprocInclude &cast)`	Checks whether a `Cpp.Node.Node` is a `preproc_include` and if so returns it as a `PreprocInclude`.	This PQL defect checks for nodes that can be converted to `preproc_include` by a cast. defect includeViaNode = when Cpp.Node.is(&n,&,&,&) and Cpp.PreprocInclude.cast(n, &cast) and cast.path(&p) and p.nodeText(&txt) raise "Cast to PreprocInclude matched path: \"{txt}\"" on cast In this C++ code the defect finds a`preproc_include` node #include "myheader.h" int main() { return 0; }
`isa(Cpp.Node.Node node)`	Returns true when the given `Cpp.Node.Node` is a `preproc_include`. Useful for negation or guards.	This PQL defect checks whether a generic node is a `preproc_include`. defect notInclude = when Cpp.Node.is(&n,&,&,&) and not Cpp.PreprocInclude.isa(n) raise "Node is not a PreprocInclude" on n In this C++ code the defect reports all nodes that are not `preproc_include`. #include <iostream> int main() { return 0; }
`path(PreprocInclude self, Cpp.Node.Node &child)`	Finds the path inside the include and returns it as `child`.	This PQL defect checks for the string or token that represents the include path inside a `preproc_include`. defect includePathNode = when Cpp.PreprocInclude.is(&inc) and inc.path(&p) and p.nodeText(&txt) raise "Include path node text: \"{txt}\"" on p In this C++ code the defect extracts the `"myheader.h"` token from the `#include` and reports its text. #include "myheader.h" int main() { return 0; }
`isSystemInclude(PreprocInclude self)`	Returns true when the include uses angle brackets (system header) such as `<...>`.	This PQL defect checks for system style `#include` directives. defect systemInclude = when Cpp.PreprocInclude.is(&inc) and inc.isSystemInclude() and inc.pathString(&f) and f == "iostream" raise "System include: \"{f}\"" on inc In this C++ code the defect finds the `#include <iostream>` directive and matches it as a system include. #include <iostream> int main() { return 0; }
`isUserInclude(PreprocInclude self)`	Returns true when the include uses double quotes (user header) such as "..." .	This PQL defect checks for user style `#include` directives. defect userInclude = when Cpp.PreprocInclude.is(&inc) and inc.isUserInclude() and inc.pathString(&f) and f == "myheader.h" raise "User include: \"{f}\"" on inc In this C++ code the defect finds the `#include "myheader.h"` directive and reports the filename. #include "myheader.h" int main() { return 0; }
`pathString(PreprocInclude self, required Lang.String &file)`	Extracts the include file name as a plain string without surrounding `<>` or `""`.	This PQL defect checks the normalized include name for comparison or filtering. defect includeNameCheck = when Cpp.PreprocInclude.is(&inc) and inc.pathString(&name) and name == "cstdint" raise "Include name is cstdint" on inc In this C++ code the defect will match a `#include <cstdint>` after removing angle brackets. #include <cstdint> int main() { return 0; }

Version History

Introduced in R2026a