Cpp.OffsetofExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the offsetof_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.OffsetofExpression represents the node offsetof_expression in the syntax tree of your code. It models an offsetof(type, member) expression in C/C++.

#include <cstddef>

struct MyStruct {
  int field;
  double anotherField;
};

void foo() {
  std::size_t offset1 = offsetof(MyStruct, field);
  std::size_t offset2 = offsetof(MyStruct, anotherField);
}

The two offsetof(MyStruct, ...) expressions in foo correspond to offsetof_expression nodes and are the nodes matched by Cpp.OffsetofExpression class.

Predicates

expand all

Type

Type	Raisable	Printable
`OffsetofExpression`	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 OffsetofExpression &oe)`	Checks whether a node in the query is an `offsetof_expression` and binds it to `oe`. Use it to start working directly with an `offsetof` node.	This PQL defect checks for any `offsetof` expression node. defect find_offsetof = when Cpp.OffsetofExpression.is(&oe) and oe.nodeText(&txt) raise "Found offsetof: \"{txt}\"" on oe In this C++ code, the defect finds each `offsetof(MyStruct, ...)` call in the function. #include <cstddef> struct MyStruct { int field; }; int main() { std::size_t o = offsetof(MyStruct, field); (void)o; return 0; }
`cast(Cpp.Node.Node node, required OffsetofExpression &cast)`	Binds `cast` to the `offsetof_expression` if the given `node` is such an expression. Use when you already have a generic `Node` and need the specific `OffsetofExpression`.	This PQL defect checks for an `offsetof` node within the descendant nodes of a compound statement. defect cast_node_to_offsetof = when Cpp.CompoundStatement.is(&cs) and cs.getADescendant(&node) and Cpp.OffsetofExpression.cast(node, &oe) and oe.nodeText(&txt) raise "Cast to offsetof matched: \"{txt}\"" on oe In this C++ code, the defect finds the `offsetof`statement in within a compound statement. #include <cstddef> struct S { int a; }; int main() { std::size_t off = offsetof(S, a); (void)off; return 0; }
`isa(Cpp.Node.Node node)`	Returns true if the given generic `node` is an `offsetof_expression`. Use in boolean checks or negations where you have a `Node`.	This PQL defect checks for `offsetof` nodes among generic syntax nodes using the `isa` predicate. defect cast_node_to_offsetof = when Cpp.CompoundStatement.is(&cs) and cs.getADescendant(&node) and Cpp.OffsetofExpression.isa(node) and node.nodeText(&txt) raise " offsetof matched: \"{txt}\"" on node In this C++ code, the defect finds the `offsetof`statement in within a compound statement. #include <cstddef> struct T { double x; }; int main() { std::size_t o = offsetof(T, x); (void)o; return 0; }
`type(OffsetofExpression self, Cpp.Node.Node &child)`	Binds `child` to the type node used as the first argument of the `offsetof`. Use it to inspect the type whose member offset is taken.	This PQL defect checks for the type component inside an `offsetof` expression. defect offsetof_type = when Cpp.OffsetofExpression.is(&oe) and oe.type(&tp) and tp.nodeText(&txt) raise "offsetof type: \"{txt}\"" on oe In this C++ code, the defect extracts `MyStruct` as the type argument of `offsetof(MyStruct, field)`. #include <cstddef> struct MyStruct { int field; }; int main() { std::size_t x = offsetof(MyStruct, field); (void)x; return 0; }
`member(OffsetofExpression self, Cpp.Node.Node &child)`	Binds `child` to the member node used as the second argument of the `offsetof`. Use it to inspect which member's offset is requested.	This PQL defect checks for the member identifier inside an `offsetof` expression. defect offsetof_member = when Cpp.OffsetofExpression.is(&oe) and oe.member(&mb) and mb.nodeText(&txt) raise "offsetof member: \"{txt}\"" on oe In this C++ code, the defect extracts `field` as the member argument of `offsetof(MyStruct, field)`. #include <cstddef> struct MyStruct { int field; }; int main() { std::size_t y = offsetof(MyStruct, field); (void)y; return 0; }
`getEnclosingOffsetofExpression(Cpp.Node.Node child, required OffsetofExpression &parent)`	Finds the nearest `offsetof_expression` ancestor of `child` and binds it to `parent`. Use it when you have a subnode and need the surrounding `offsetof`.	This PQL defect checks for an `offsetof` expression that encloses a type identifier subnode. defect find_enclosing_offsetof = when Cpp.TypeIdentifier.is(&id) and id.toNode(&node) and Cpp.OffsetofExpression.getEnclosingOffsetofExpression(node, &oe) and oe.nodeText(&txt) raise "Enclosing offsetof: \"{txt}\"" on oe In this C++ code, the defect starts from the type identifier node `MyStruct` and finds the enclosing `offsetof(MyStruct, field)` expression. #include <cstddef> struct MyStruct { int field; }; int main() { std::size_t z = offsetof(MyStruct, field); (void)z; return 0; }
`isEnclosedInOffsetofExpression(Cpp.Node.Node child)`	Returns true when the given `child` node has an `offsetof_expression` as an ancestor. Use it to test whether a node appears inside an `offsetof`.	This PQL defect checks whether a node is inside any `offsetof` expression. defect inside_offsetof = when Cpp.FieldIdentifier.is(&id) and id.toNode(&node) and Cpp.OffsetofExpression.isEnclosedInOffsetofExpression(node) raise "Field Identifier is inside an offsetof" on node In this C++ code, the defect detects that the identifier `field` occurs inside the `offsetof(MyStruct, field)` call. #include <cstddef> struct MyStruct { int field; }; int main() { std::size_t k = offsetof(MyStruct, field); (void)k; return 0; }

Version History

Introduced in R2026a