Cpp.PointerExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the pointer_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.PointerExpression represents the node pointer_expression in the syntax tree of your code.

int foo(int *p) {
  int x = 42;
  int *q = &x;
  return *q;
}

The demo contains pointer_expression nodes for int *p, int *q, &x, and *q. These correspond to the Cpp.PointerExpression PQL class.

Predicates

Type

Type	Raisable	Printable
PointerExpression	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 PointerExpression &pe)	Matches a pointer_expression node and binds it to pe for further queries.	This PQL defect checks for any pointer expression node in the code. defect PointerExprIs = when Cpp.PointerExpression.is(&pe) and pe.nodeText(&txt) raise "Found pointer expression: \"{txt}\"" on pe In this C++ code, the defect finds each pointer expression such as declarations, unary &, and unary *. int foo(int *p) { int x = 0; int *q = &x; return *q; }
cast(Cpp.Node.Node node, required PointerExpression &cast)	Checks whether a given Node is a pointer_expression and if so binds it to cast for inspection.	This PQL defect checks whether a generic Node in a return statement is a pointer_expression. defect PointerExprCast = when Cpp.ReturnStatement.is(&rt) and rt.getADescendant(&node) and Cpp.PointerExpression.cast(node, &pe) and pe.nodeText(&txt) raise "Node cast to pointer expression: \"{txt}\"" on pe In this C++ code, the defect demonstrates converting a different node to Node and then detecting a pointer expression like int *p. int foo(int *p) { int x = 42; int *q = &x; return *q; }
isa(Cpp.Node.Node node)	Tests whether a given Node is a pointer_expression. Use this for boolean checks or negation.	This PQL defect checks if a Node is a pointer expression. defect PointerExpris = when Cpp.ReturnStatement.is(&rt) and rt.getADescendant(&node) and Cpp.PointerExpression.is(node) and node.nodeText(&txt) raise "Node is a pointer expression: \"{txt}\"" on ode In this C++ code, the defect finds a pointer expression inside a return statement. int foo(int *p) { int x = 42; int *q = &x; return *q; }
argument(PointerExpression self, Cpp.Node.Node &child)	Binds child to the operand of the pointer expression for example the x in *x or &x.	This PQL defect checks for pointer expressions and extracts their operand node. defect PointerExprArgument = when Cpp.PointerExpression.is(&pe) and pe.argument(&arg) and arg.nodeText(&txt) raise "Pointer expression operand: \"{txt}\"" on pe In this C++ code, the defect finds the operand x in &x and q in *q. int foo() { int x = 1; int *p = &x; // operand is x return *p; // operand is p }
operator(PointerExpression self, Cpp.Node.Node &child)	Binds child to the operator token node of the pointer expression such as * or &.	This PQL defect checks pointer expressions and extracts the operator token. defect PointerExprOperator = when Cpp.PointerExpression.is(&pe) and pe.operator(&op) and op.nodeText(&txt) raise "Pointer expression operator: \"{txt}\"" on op In this C++ code, the defect finds the & operator in &x and * in *q. int foo() { int x = 2; int *p = &x; // operator is & return *p; // operator is * }
getEnclosingPointerExpression(Cpp.Node.Node child, required PointerExpression &parent)	Finds the nearest ancestor pointer_expression that encloses the supplied child node and binds it to parent.	This PQL defect checks for the closest pointer expression ancestor of a given node converted to Node. defect EnclosingPointerExpr = when Cpp.Identifier.is(&id) and id.toNode(&node) and Cpp.PointerExpression.getEnclosingPointerExpression(node, &pe) and pe.nodeText(&txt) raise "Enclosing pointer expression: \"{txt}\" for identifier" on id In this C++ code, the defect finds that x is enclosed by &x and reports the enclosing pointer expression. int foo() { int x = 5; int *p = &x; // identifier x is enclosed by pointer expression &x return 0; }
isEnclosedInPointerExpression(Cpp.Node.Node child)	True if the given Node has any pointer_expression ancestor in the syntax tree.	This PQL defect checks whether a node is inside any pointer expression. defect IdentifierInPointerExpr = when Cpp.Identifier.is(&id) and id.toNode(&node) and Cpp.PointerExpression.isEnclosedInPointerExpression(node) raise "Identifier is inside a pointer expression" on id In this C++ code, the defect flags identifiers like x when they appear inside &x or *x. int foo() { int x = 0; int *p = &x; // identifier x is enclosed in pointer expression &x return *p; // identifier p is enclosed in pointer expression *p }

Version History

Introduced in R2026a