Cpp.CharLiteral Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the char_literal nodes in the syntax tree of your code

Since R2026a

Description

The PQL class CharLiteral represents the node char_literal in the syntax tree of your code.

// Demonstrates various char_literal nodes
#include <iostream>

void char_literals() {
    char a = 'a';
    char newline = '\n';
    char hex = '\x20';
    char octal = '\101';
    char quote = '\'';
    char backslash = '\\';
    char unicode = u'\u00E9';
    char wide = L'a';
    char utf8 = u8'a';
    char utf16 = u'a';
    char utf32 = U'a';
    (void)a; (void)newline; (void)hex; (void)octal;
    (void)quote; (void)backslash; (void)unicode;
    (void)wide; (void)utf8; (void)utf16; (void)utf32;
}
int main() { return 0; }

The C++ sample contains multiple char_literal instances, such as 'a', '\n' and '\x20'. These syntax nodes are matched by PQL CharLiteral class.

Predicates

expand all

Type

Type	Raisable	Printable
`CharLiteral`	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 CharLiteral &lit)`	Checks whether a node is a `char_literal` node and returns it as `lit`. Use this to directly match character literals.	This PQL defect checks for plain character literals anywhere in the code. defect find_char_literal = when Cpp.CharLiteral.is(&lit) and lit.nodeText(&txt) raise "Found char literal: {txt}" on lit In this C++ code, the defect finds direct character literals like `'a'` and `'\n'`. #include <iostream> void f() { char c = 'a'; char n = '\n'; (void)c; (void)n; } int main() { return 0; }
`cast(Cpp.Node.Node node, required CharLiteral &cast)`	Checks whether an arbitrary `node` is a `char_literal` and, if so, returns it as `cast`. Use when you start from a generic AST node.	This PQL defect checks for nodes that can be interpreted as `char_literal`. defect cast_from_node = when Cpp.Node.is(&node, &,&,&) and Cpp.CharLiteral.cast(node, &lit) and lit.nodeText(&txt) raise "Casted node to char literal: {txt}" on lit In this C++ code, the defect finds a `char_literal` even if the query begins from a generic AST node. void g() { char x = 'x'; (void)x; } int main() { return 0; }
`isa(Cpp.Node.Node node)`	Returns true if `node` is a `char_literal`. Useful for negative checks like `not Cpp.CharLiteral.isa(n)`.	This PQL defect checks for a generic nodes that are not `char_literal`. defect check_not_char_literal = when Cpp.Node.is(&node, &,&,&) and not Cpp.CharLiteral.isa(node) raise "Node is not a char literal" on node In this C++ code, the defect finds the syntax nodes that are not `char_literal` nodes. void h() { int i = 0; char z = 'z'; (void)i; (void)z; } int main() { return 0; }
`character(CharLiteral self, Cpp.Character.Character &content)`	Extracts the raw character content from a `char_literal`. That is, from the character literal `'lit'`, this predicate retrieves the content `lit` and returns it as `content`.	This PQL defect checks for `char_literal` nodes and extracts their inner character token. defect extract_char_value = when Cpp.CharLiteral.is(&lit) and lit.character(&content) and content.nodeText(&val) raise "Char literal value: {val}" on lit In this C++ code, the defect retrieves the inner token for `'a'`. The character literal `'\n'` contains no character child node. Instead, `'\n'` has an escape sequence child node. void k() { char a = 'a'; // matches and fetches the character a char nl = '\n'; // does not match (void)a; (void)nl; } int main() { return 0; }
`escapeSequence(CharLiteral self, Cpp.EscapeSequence.EscapeSequence &escape)`	Finds an escape sequence inside a `char_literal` (like `'\n'`, `'\\'`, `'\x20'`) and returns it as `escape`.	This PQL defect checks for character literals that contain an escape sequence. defect find_escape_sequence = when Cpp.CharLiteral.is(&lit) and lit.escapeSequence(&escape) and escape.nodeText(&val) raise "Escape sequence in char literal: {val}" on lit In this C++ code, the defect retrieves the inner token for `'\n'`. The character literal `'a'` does not contain an escape sequence. void k() { char a = 'a'; // does not match char nl = '\n'; // matches and fetches the token \n (void)a; (void)nl; } int main() { return 0; }
`getEnclosingCharLiteral(Cpp.Node.Node child, required CharLiteral &parent)`	Finds the nearest enclosing `char_literal` that contains the given child node and returns it as `parent`.	This PQL defect checks for nodes that are inside a `char_literal` and returns that outer literal. defect enclosing_char_literal = when Cpp.Node.is(&inner, &,&,&) and Cpp.CharLiteral.getEnclosingCharLiteral(inner, &lit) and lit.nodeText(&txt) raise "Inner node is inside char literal: {txt}" on lit In this C++ code, the defect locates the `char_literal` that encloses a child token. void n() { char nl = '\n'; (void)nl; }
`isEnclosedInCharLiteral(Cpp.Node.Node child)`	Returns true when the given `child` node has a `char_literal` ancestor. Use for finding nodes that appear inside character literals.	This PQL defect checks whether a node sits somewhere within a `char_literal`. defect node_within_char_literal = when Cpp.Node.is(&inner, &,&,&) and Cpp.CharLiteral.isEnclosedInCharLiteral(inner) raise "Node is enclosed in a char literal" on inner In this C++ code, the defect finds all child nodes of a `char_literal`. void p() { char t = '\t'; (void)t; }

Version History

Introduced in R2026a