private final List<CppLexerToken> tokens;

private int pos = 0;

public Parser(List<CppLexerToken> tokens) {

this.tokens = tokens;

}

public static CompilationUnit parse(String source) {

List<CppLexerToken> tokens = new CppLexer(source).tokenize();

return new Parser(tokens).parseCompilationUnit();

}

/** Test-only entry point: parses a single TypeRef from source text in isolation. */

static TypeRef parseTypeRefFromString(String source) {

List<CppLexerToken> tokens = new CppLexer(source).tokenize();

return new Parser(tokens).parseTypeRef();

}

// ----- Core cursor helpers -----------------------------------------

//

// peek()/peek(ahead)/advance() transparently skip over comment tokens.

// This is deliberate and fixes a real bug class found via real-corpus

// testing: a line comment can legally appear in the MIDDLE of a

// multi-line expression (e.g. a function call whose arguments are each

// commented, confirmed real by Move_Eye.pde's

// "camera(x, y, z, // eyeX, eyeY, eyeZ \n ...)"). The original design

// only collected leading comments at statement/declaration boundaries

// via consumeLeadingComments(), which left every OTHER parse point

// (inside parseArgList, parsePostfix, anywhere mid-expression) just as

// comment-blind as the regex passes this parser exists to replace.

// Routing comment-skipping through the cursor primitives themselves

// fixes every call site at once instead of needing a fix at each one.

//

// consumeLeadingComments() still exists and is still called explicitly

// at statement/declaration start -- it now serves only to COLLECT the

// comment tokens for attachment to the next node's leadingComments

// field, not to make parsing work correctly (that's now peek/advance's

// job). It works correctly alongside this since skipCommentsAt() is

// idempotent -- calling it twice in a row from the same position is a

// no-op the second time.

private void skipCommentsAt() {

while (pos < tokens.size()

&& (tokens.get(pos).type() == CppLexerTokenType.LINE_COMMENT

|| tokens.get(pos).type() == CppLexerTokenType.BLOCK_COMMENT)) {

pos++;

}

}

private CppLexerToken peek() {

skipCommentsAt();

return tokens.get(pos);

}

private CppLexerToken peek(int ahead) {

// Walk forward from pos, skipping comment tokens, to find the

// "ahead"-th real (non-comment) token after the current position.

skipCommentsAt();

int p = pos;

int remaining = ahead;

while (remaining > 0 && p < tokens.size() - 1) {

p++;

while (p < tokens.size() && (tokens.get(p).type() == CppLexerTokenType.LINE_COMMENT

|| tokens.get(p).type() == CppLexerTokenType.BLOCK_COMMENT)) {

p++;

}

remaining--;

}

return p < tokens.size() ? tokens.get(p) : tokens.get(tokens.size() - 1);

}

private CppLexerToken advance() {

skipCommentsAt();

CppLexerToken t = tokens.get(pos);

if (t.type() != CppLexerTokenType.EOF) pos++;

return t;

}

private boolean isAtEnd() {

return peek().type() == CppLexerTokenType.EOF;

}

private boolean check(CppLexerTokenType type) {

return peek().type() == type;

}

private boolean checkKeyword(String kw) {

return peek().isKeyword(kw);

}

private boolean checkPunct(String p) {

return peek().isPunct(p);

}

private boolean checkOp(String op) {

return peek().isOp(op);

}

private boolean matchKeyword(String kw) {

if (checkKeyword(kw)) { advance(); return true; }

return false;

}

private boolean matchPunct(String p) {

if (checkPunct(p)) { advance(); return true; }

return false;

}

private boolean matchOp(String op) {

if (checkOp(op)) { advance(); return true; }

return false;

}

private CppLexerToken expectPunct(String p) {

if (checkPunct(p)) return advance();

throw error("expected '" + p + "' but found '" + peek().text() + "'");

}

private CppLexerToken expectOp(String op) {

if (checkOp(op)) return advance();

throw error("expected '" + op + "' but found '" + peek().text() + "'");

}

private CppLexerToken expectKeyword(String kw) {

if (checkKeyword(kw)) return advance();

throw error("expected '" + kw + "' but found '" + peek().text() + "'");

}

private CppLexerToken expectIdentifier() {

if (check(CppLexerTokenType.IDENTIFIER)) return advance();

throw error("expected identifier but found '" + peek().text() + "'");

}

private ParseException error(String message) {

CppLexerToken t = peek();

return new ParseException(message, t.line(), t.col());

}

/**

/**

private List<CppLexerToken> consumeLeadingComments() {

List<CppLexerToken> comments = new ArrayList<>();

while (pos < tokens.size()

&& (tokens.get(pos).type() == CppLexerTokenType.LINE_COMMENT

|| tokens.get(pos).type() == CppLexerTokenType.BLOCK_COMMENT)) {

comments.add(tokens.get(pos));

pos++;

}

return comments;

}

// ----- Entry point ---------------------------------------------------

public CompilationUnit parseCompilationUnit() {

List<TopLevelItem> items = new ArrayList<>();

consumeLeadingComments(); // leading file-level comments currently dropped

// at EOF if nothing follows; fine for now

while (!isAtEnd()) {

List<CppLexerToken> comments = consumeLeadingComments();

if (isAtEnd()) break;

items.addAll(parseTopLevelItem(comments));

}

return new CompilationUnit(items);

}

/**

private List<TopLevelItem> parseTopLevelItem(List<CppLexerToken> leadingComments) {

if (check(CppLexerTokenType.PREPROCESSOR_DIRECTIVE)) {

CppLexerToken t = advance();

return List.of(new PreprocessorLine(t.text(), t.line(), t.col(), leadingComments));

}

List<String> templateParams = List.of();

if (checkKeyword("template")) {

templateParams = parseTemplateParamList();

consumeLeadingComments();

}

if (checkKeyword("class") || checkKeyword("struct")) {

return List.of(parseTypeDef(leadingComments, templateParams));

}

if (checkKeyword("enum")) {

return List.of(parseEnumDecl(leadingComments));

}

if (checkKeyword("namespace")) {

return List.of(parseNamespaceDecl(leadingComments));

}

if (checkKeyword("using") && peek(1).isKeyword("namespace")) {

return List.of(parseUsingNamespaceDecl(leadingComments));

}

// Destructor: "~Name() { ... }" or "virtual ~Name() { ... }" -- only

// valid inside a class body in real C++, but the parser doesn't

// enforce that positional rule; a later semantic pass can if it

// matters. Must look past an optional leading "virtual", same as

// the parseClassMember dispatch.

if (checkOp("~") || (checkKeyword("virtual") && peek(1).isOp("~"))) {

return List.of(parseFunctionOrConstructorOrDestructor(leadingComments, templateParams));

}

return parseFunctionOrVariable(leadingComments, templateParams, true);

}

/** "template<typename T, typename U, ...>" -- returns just the param names. */

private List<String> parseTemplateParamList() {

expectKeyword("template");

expectOp("<");

List<String> params = new ArrayList<>();

if (!checkOp(">")) {

params.add(parseTemplateParamName());

while (matchPunct(",")) {

params.add(parseTemplateParamName());

}

}

if (checkOp(">>")) {

splitTrailingShiftIntoTwoCloseAngles();

}

expectOp(">");

return params;

}

private String parseTemplateParamName() {

if (!matchKeyword("typename")) {

matchKeyword("class"); // "template<class T>" is also valid C++, accept both spellings

}

return expectIdentifier().text();

}

/**

private TypeDef parseTypeDef(List<CppLexerToken> leadingComments, List<String> templateParams) {

CppLexerToken start = peek();

String kind = checkKeyword("class") ? "class" : "struct";

advance();

String name = expectIdentifier().text();

List<String> baseClasses = new ArrayList<>();

if (matchPunct(":")) {

baseClasses.add(parseBaseClassEntry());

while (matchPunct(",")) {

baseClasses.add(parseBaseClassEntry());

}

}

expectPunct("{");

List<TopLevelItem> members = new ArrayList<>();

while (!checkPunct("}")) {

if (isAtEnd()) throw error("unexpected end of input inside class/struct body for '" + name + "'");

List<CppLexerToken> comments = consumeLeadingComments();

if (checkPunct("}")) break;

if (matchKeyword("public") || matchKeyword("private") || matchKeyword("protected")) {

expectPunct(":");

continue;

}

members.addAll(parseClassMember(comments, name));

}

expectPunct("}");

// The trailing ';' after a class/struct body is standard C++, but

// confirmed OPTIONAL in real .pde input -- Scrollbar.pde's

// "class HScrollbar { ... }" has no trailing ';' at all. Processing's

// own preprocessing tolerates this; this parser does too rather than

// hard-requiring strict C++ grammar here.

matchPunct(";");

return new TypeDef(kind, name, templateParams, baseClasses, members, start.line(), start.col(), leadingComments);

}

/** "public BaseName" / "private BaseName" / "protected BaseName" / bare "BaseName". */

private String parseBaseClassEntry() {

matchKeyword("public");

if (!checkKeyword("public")) {

matchKeyword("private");

matchKeyword("protected");

}

return parseQualifiedTypeName();

}

/**

private List<TopLevelItem> parseClassMember(List<CppLexerToken> leadingComments, String enclosingClassName) {

if (check(CppLexerTokenType.PREPROCESSOR_DIRECTIVE)) {

CppLexerToken t = advance();

return List.of(new PreprocessorLine(t.text(), t.line(), t.col(), leadingComments));

}

List<String> templateParams = List.of();

if (checkKeyword("template")) {

templateParams = parseTemplateParamList();

consumeLeadingComments();

}

if (checkKeyword("class") || checkKeyword("struct")) {

return List.of(parseTypeDef(leadingComments, templateParams));

}

if (checkKeyword("enum")) {

return List.of(parseEnumDecl(leadingComments));

}

// Destructor dispatch: "~Name() {...}" or "virtual ~Name() {...}" --

// must look one token past an optional leading "virtual", since that

// keyword (confirmed common on destructors, e.g. "virtual ~LSystem()")

// precedes the '~' that would otherwise be the dispatch signal.

if (checkOp("~") || (checkKeyword("virtual") && peek(1).isOp("~"))) {

return List.of(parseFunctionOrConstructorOrDestructor(leadingComments, templateParams));

}

// Constructor dispatch: identifier matching the enclosing class name,

// directly followed by '(' with no return type preceding it. Also

// allow an optional leading "virtual" for symmetry, though

// constructors can't actually be virtual in real C++ -- tolerated

// here rather than rejected, since enforcing that isn't this parser's

// job (see grammar-scope notes on not modeling full C++ semantics).

if (check(CppLexerTokenType.IDENTIFIER) && peek().text().equals(enclosingClassName) && peek(1).isPunct("(")) {

return List.of(parseFunctionOrConstructorOrDestructor(leadingComments, templateParams));

}

return parseFunctionOrVariable(leadingComments, templateParams, false);

}

/**

private FunctionDecl parseFunctionOrConstructorOrDestructor(List<CppLexerToken> leadingComments, List<String> templateParams) {

CppLexerToken start = peek();

boolean isVirtual = matchKeyword("virtual");

boolean isDestructor = matchOp("~");

String name = expectIdentifier().text();

if (isDestructor) name = "~" + name;

List<Param> params = parseParamList();

boolean isConst = matchKeyword("const");

boolean isOverride = matchKeyword("override");

// order-flexible: also accept override before const, just in case

if (!isConst) isConst = matchKeyword("const");

List<FunctionDecl.ConstructorInit> initList = new ArrayList<>();

if (!isDestructor && matchPunct(":")) {

initList.add(parseConstructorInitEntry());

while (matchPunct(",")) {

initList.add(parseConstructorInitEntry());

}

}

Block body = checkPunct("{") ? parseBlock() : null;

if (body == null) expectPunct(";");

return new FunctionDecl(null, name, templateParams, params, initList, body,

!isDestructor, isDestructor, isVirtual, isOverride, isConst, false,

start.line(), start.col(), leadingComments);

}

private FunctionDecl.ConstructorInit parseConstructorInitEntry() {

String memberName = expectIdentifier().text();

expectPunct("(");

List<Expr> args = new ArrayList<>();

if (!checkPunct(")")) {

args.add(parseExpr());

while (matchPunct(",")) {

args.add(parseExpr());

}

}

expectPunct(")");

return new FunctionDecl.ConstructorInit(memberName, args);

}

/**

private List<TopLevelItem> parseFunctionOrVariable(List<CppLexerToken> leadingComments, List<String> templateParams, boolean isTopLevel) {

CppLexerToken start = peek();

// Bare top-level statement fallback (Processing "static mode" sketches,

// confirmed real by the example corpus's Coordinates.pde -- a flat

// sequence of statements like "size(640, 360);" with no enclosing

// setup()/draw() at all). Distinguished from a real declaration by

// lookahead: a declaration is "TypeName Identifier ...", whereas a

// bare call statement is "identifier(" with nothing in between. This

// check must run before any of virtual/static/const are consumed,

// since none of those prefix a bare statement. Only ever applies at

// true top level -- see isTopLevel notes above.

if (isTopLevel && !looksLikeTopLevelDeclarationOrFunction()) {

Statement stmt = parseStatement(List.of());

return List.of(new TopLevelStatement(stmt, start.line(), start.col(), leadingComments));

}

boolean isVirtual = matchKeyword("virtual");

boolean isStatic = matchKeyword("static");

boolean isConst = matchKeyword("const");

if (!isStatic) isStatic = matchKeyword("static"); // tolerate either order

// Raw function-pointer variable declaration: "Type (*name)(Params) = init;"

if (looksLikeFunctionPointerVariable()) {

TypeRef returnType = parseTypeRef();

NameAndFunctionPointerType decl = parseFunctionPointerDeclaratorTail(returnType);

Expr initializer = null;

if (matchOp("=")) {

initializer = parseExpr();

}

expectPunct(";");

return List.of(new VariableDecl(decl.type(), decl.name(), List.of(), initializer,

isConst, isStatic, start.line(), start.col(), leadingComments));

}

TypeRef type = parseTypeRef();

String name = parseFunctionOrVariableName();

if (checkPunct("(") && !looksLikeFunctionPointerDeclarator() && looksLikeParamList()) {

List<Param> params = parseParamList();

boolean isOverride = false;

boolean isMethodConst = false;

// trailing const/override may appear in either order

for (int i = 0; i < 2; i++) {

if (matchKeyword("const")) { isMethodConst = true; continue; }

if (matchKeyword("override")) { isOverride = true; continue; }

}

Block body = checkPunct("{") ? parseBlock() : null;

if (body == null) expectPunct(";");

FunctionDecl fn = new FunctionDecl(type, name, templateParams, params, List.of(), body,

false, false, isVirtual, isOverride, isMethodConst, isStatic,

start.line(), start.col(), leadingComments);

return List.of(fn);

}

// Variable declaration, possibly multi-declarator.

List<TopLevelItem> result = new ArrayList<>();

result.add(parseOneTopLevelDeclarator(type, name, isConst, isStatic, start, leadingComments));

while (matchPunct(",")) {

// Each declarator after the first comma can carry its OWN

// leading "*"/"&" markers, independent of every other

// declarator on the line -- real, standard C++ syntax

// ("int* a, b;" -- only a is a pointer; "int* a, *b;" --

// both are pointers). Confirmed real and necessary by

// Scrollbar.pde's real "HScrollbar* hs1, * hs2;", found via

// RealHeaderStressTest after fixing the boolean/null

// test-fidelity gap let parsing get further into that file.

//

// Build each declarator's type from the base type's

// NAME/TEMPLATE-ARGS/CONST ONLY -- never reuse "type"'s own

// pointerDepth/isReference, which already belongs

// EXCLUSIVELY to the first declarator (parseTypeRef consumes

// a "*"/"&" immediately after the base type name, before the

// first declarator's name is even parsed). Adding each

// subsequent declarator's marker count ON TOP of that would

// produce "HScrollbar**" for the second declarator instead

// of the correct "HScrollbar*" -- caught by checking

// rendered output, not just parse success.

int extraPointerDepth = 0;

boolean extraIsReference = false;

while (checkOp("*") || checkOp("&")) {

if (matchOp("*")) extraPointerDepth++;

else { matchOp("&"); extraIsReference = true; }

}

String nextName = expectIdentifier().text();

TypeRef declaratorType = type;

if (type instanceof NamedType nt) {

declaratorType = new NamedType(nt.baseName(), nt.templateArgs(),

extraPointerDepth, extraIsReference, nt.isConst());

}

result.add(parseOneTopLevelDeclarator(declaratorType, nextName, isConst, isStatic, start, List.of()));

}

expectPunct(";");

return result;

}

/**

private boolean looksLikeTopLevelDeclarationOrFunction() {

int save = pos;

try {

matchKeyword("virtual");

matchKeyword("static");

matchKeyword("const");

matchKeyword("static"); // tolerate either order, mirroring the real parse path

if (looksLikeFunctionPointerVariable()) return true;

if (!(check(CppLexerTokenType.IDENTIFIER) || check(CppLexerTokenType.KEYWORD))) return false;

TypeRef type;

try {

type = parseTypeRef();

} catch (ParseException e) {

return false;

}

// "operator==" style names: 'operator' is lexed as a KEYWORD.

// Two cases reach here:

// (a) "operator" itself was parsed as the bare "type" (when

// there's no separate return type before it -- not

// actually valid C++ for operator overloads but tolerated

// defensively), OR

// (b) more commonly, a real return type was already consumed

// ("bool", "Handle", etc.) and the CURRENT token is now

// "operator" itself, e.g. "bool operator==(...)" --

// confirmed real and previously missed by the

// oop_features.cpp fixture's Handle::operator==.

// Either way, this is unambiguously a declaration.

if ((type instanceof NamedType nt && nt.baseName().equals("operator"))

|| checkKeyword("operator")) {

return true;

}

return check(CppLexerTokenType.IDENTIFIER);

} finally {

pos = save;

}

}

/**

private String parseFunctionOrVariableName() {

if (checkKeyword("operator")) {

CppLexerToken opKw = advance();

CppLexerToken opTok = advance(); // the operator symbol itself, e.g. "==", "+", "<<"

return opKw.text() + opTok.text();

}

String name = expectIdentifier().text();

while (checkPunct("::")) {

advance();

name += "::" + expectIdentifier().text();

}

return name;

}

private VariableDecl parseOneTopLevelDeclarator(TypeRef type, String name, boolean isConst, boolean isStatic,

CppLexerToken start, List<CppLexerToken> leadingComments) {

List<Expr> dims = parseOptionalArrayDims();

Expr initializer = null;

if (matchOp("=")) {

initializer = checkPunct("{") ? parseInitializerList() : parseExpr();

} else if (checkPunct("(")) {

initializer = parseDirectInitAsCall(name);

} else if (checkPunct("{")) {

// Brace-direct-init: "Type name{args};" -- the unambiguous,

// most-vexing-parse-proof sibling of paren-direct-init

// ("Type name(args);"). Confirmed necessary by this project's

// own CodeGen, which deliberately renders the self-named-

// CallExpr direct-init shape using braces rather than parens

// (see CodeGen.emitDeclaratorTail's notes on why) -- without

// this branch, the parser couldn't read its own generated

// output back, which a round-trip test caught immediately.

// Represented with the exact same CallExpr shape as the paren

// form (callee = an Identifier matching the declarator's own

// name), since semantically they mean the same thing and

// CodeGen already knows how to render that shape as braces.

initializer = parseDirectInitAsCall(name);

}

return new VariableDecl(type, name, dims, initializer, isConst, isStatic,

start.line(), start.col(), leadingComments);

}

/**

private boolean looksLikeParamList() {

int save = pos;

try {

expectPunct("(");

if (checkPunct(")")) return true; // "()" -- ambiguous but treated as a function with no params, matching prior behavior

if (!(check(CppLexerTokenType.IDENTIFIER) || check(CppLexerTokenType.KEYWORD))) return false;

try {

parseTypeRef();

} catch (ParseException e) {

return false;

}

// A real parameter needs a name after its type (or a function-

// pointer declarator's own "(" -- not modeled here since no

// corpus fixture nests a function-pointer param inside a

// direct-init-ambiguous position; flagged as a known gap if it

// ever occurs).

return check(CppLexerTokenType.IDENTIFIER);

} finally {

pos = save;

}

}

private List<Param> parseParamList() {

expectPunct("(");

List<Param> params = new ArrayList<>();

if (!checkPunct(")")) {

params.add(parseParam());

while (matchPunct(",")) {

params.add(parseParam());

}

}

expectPunct(")");

return params;

}

/**

private boolean looksLikeFunctionPointerVariable() {

int save = pos;

try {

if (!(check(CppLexerTokenType.IDENTIFIER) || check(CppLexerTokenType.KEYWORD))) return false;

try {

parseTypeRef();

} catch (ParseException e) {

return false;

}

return looksLikeFunctionPointerDeclarator();

} finally {

pos = save;

}

}

private EnumDecl parseEnumDecl(List<CppLexerToken> leadingComments) {

CppLexerToken start = expectKeyword("enum");

boolean isScoped = matchKeyword("class");

String name = expectIdentifier().text();

expectPunct("{");

List<String> values = new ArrayList<>();

if (!checkPunct("}")) {

values.add(expectIdentifier().text());

while (matchPunct(",")) {

if (checkPunct("}")) break; // tolerate a trailing comma

values.add(expectIdentifier().text());

}

}

expectPunct("}");

expectPunct(";");

return new EnumDecl(name, isScoped, values, start.line(), start.col(), leadingComments);

}

private NamespaceDecl parseNamespaceDecl(List<CppLexerToken> leadingComments) {

CppLexerToken start = expectKeyword("namespace");

String name = expectIdentifier().text();

expectPunct("{");

List<TopLevelItem> items = new ArrayList<>();

while (!checkPunct("}")) {

if (isAtEnd()) throw error("unexpected end of input inside namespace '" + name + "'");

List<CppLexerToken> comments = consumeLeadingComments();

if (checkPunct("}")) break;

items.addAll(parseTopLevelItem(comments));

}

expectPunct("}");

return new NamespaceDecl(name, items, start.line(), start.col(), leadingComments);

}

private UsingNamespaceDecl parseUsingNamespaceDecl(List<CppLexerToken> leadingComments) {

CppLexerToken start = expectKeyword("using");

expectKeyword("namespace");

String name = parseQualifiedTypeName();

expectPunct(";");

return new UsingNamespaceDecl(name, start.line(), start.col(), leadingComments);

}

// ----- Type references ------------------------------------------------

/**

private TypeRef parseTypeRef() {

boolean isConst = matchKeyword("const");

String baseName = parseQualifiedTypeName();

List<TypeRef> templateArgs = List.of();

if (checkOp("<")) {

templateArgs = parseTemplateArgList();

}

int pointerDepth = 0;

while (matchOp("*")) {

pointerDepth++;

}

boolean isReference = matchOp("&");

return new NamedType(baseName, templateArgs, pointerDepth, isReference, isConst);

}

/**

/**

private String parseQualifiedTypeName() {

StringBuilder sb = new StringBuilder();

sb.append(parseTypeNameSegment());

// Compound integer-type keyword combinations: greedily consume any

// run of signed/unsigned/long/short/int/char that follows, since

// these only ever combine with each other (never with a separate

// user type name in the same position) -- e.g. "unsigned long long

// int" is valid C++, "unsigned long long ArrayList" never occurs.

while ((check(CppLexerTokenType.KEYWORD))

&& isIntegerTypeModifierOrBase(peek().text())

&& isIntegerTypeModifierOrBase(sb.toString())) {

sb.append(' ').append(parseTypeNameSegment());

}

while (checkPunct("::")) {

advance();

sb.append("::").append(parseTypeNameSegment());

}

return sb.toString();

}

private static final java.util.Set<String> INTEGER_TYPE_WORDS = java.util.Set.of(

"signed", "unsigned", "long", "short", "int", "char"

);

/** True if every space-separated word in s is one of the integer-type-modifier/base words. */

private boolean isIntegerTypeModifierOrBase(String s) {

for (String word : s.split(" ")) {

if (!INTEGER_TYPE_WORDS.contains(word)) return false;

}

return true;

}

private String parseTypeNameSegment() {

CppLexerToken t = peek();

if (t.type() == CppLexerTokenType.IDENTIFIER || t.type() == CppLexerTokenType.KEYWORD) {

advance();

return t.text();

}

throw error("expected a type name but found '" + t.text() + "'");

}

/**

private List<TypeRef> parseTemplateArgList() {

expectOp("<");

List<TypeRef> args = new ArrayList<>();

if (!checkOp(">")) {

args.add(parseTemplateArg());

while (matchPunct(",")) {

args.add(parseTemplateArg());

}

}

// Note: ">>" closing two nested template lists at once (e.g.

// "Pair<int, ArrayList<T>>") is lexed as a single ">>" OPERATOR token

// by the lexer's longest-match rule, not as two separate '>' tokens --

// the corpus's "template angle brackets vs shift/comparison ambiguity"

// smoke test confirmed ">>" lexes as one token. We must special-case

// that here: a closing ">>" needs to close *this* list and leave a

// single '>' behind for the enclosing list to consume.

if (checkOp(">>")) {

splitTrailingShiftIntoTwoCloseAngles();

}

expectOp(">");

return args;

}

/**

private void splitTrailingShiftIntoTwoCloseAngles() {

CppLexerToken shift = tokens.get(pos);

CppLexerToken first = new CppLexerToken(CppLexerTokenType.OPERATOR, ">", shift.line(), shift.col());

CppLexerToken second = new CppLexerToken(CppLexerTokenType.OPERATOR, ">", shift.line(), shift.col() + 1);

tokens.set(pos, first);

tokens.add(pos + 1, second);

}

private TypeRef parseTemplateArg() {

TypeRef maybeReturnType = parseTypeRef();

// If a '(' follows immediately, this was actually the return type of a

// bare function-signature template arg (std::function<void(int)>),

// not a complete type by itself -- reinterpret.

if (checkPunct("(")) {

return parseFunctionSignatureTail(maybeReturnType);

}

return maybeReturnType;

}

/** Parses "(ParamType, ...)" given an already-parsed return type, producing a FunctionSignatureType. */

private FunctionSignatureType parseFunctionSignatureTail(TypeRef returnType) {

expectPunct("(");

List<TypeRef> paramTypes = new ArrayList<>();

if (!checkPunct(")")) {

paramTypes.add(parseTypeRef());

while (matchPunct(",")) {

paramTypes.add(parseTypeRef());

}

}

expectPunct(")");

return new FunctionSignatureType(returnType, paramTypes);

}

/**

private boolean looksLikeFunctionPointerDeclarator() {

return checkPunct("(") && peek(1).isOp("*")

&& peek(2).type() == CppLexerTokenType.IDENTIFIER

&& peek(3).isPunct(")");

}

/**

private NameAndFunctionPointerType parseFunctionPointerDeclaratorTail(TypeRef returnType) {

expectPunct("(");

expectOp("*");

String name = expectIdentifier().text();

expectPunct(")");

expectPunct("(");

List<TypeRef> paramTypes = new ArrayList<>();

if (!checkPunct(")")) {

paramTypes.add(parseTypeRef());

while (matchPunct(",")) {

paramTypes.add(parseTypeRef());

}

}

expectPunct(")");

return new NameAndFunctionPointerType(name, new FunctionPointerType(returnType, paramTypes));

}

private record NameAndFunctionPointerType(String name, FunctionPointerType type) {

}

// ----- Expressions (precedence climbing, low to high) -----------------

//

// assignment -> ternary (("=") assignment)? [right-assoc]

// ternary -> logicalOr ("?" expr ":" ternary)?

// logicalOr -> logicalAnd ("||" logicalAnd)*

// logicalAnd -> bitOr ("&&" bitOr)*

// bitOr -> bitXor ("|" bitXor)*

// bitXor -> bitAnd ("^" bitAnd)*

// bitAnd -> equality ("&" equality)*

// equality -> relational (("=="|"!=") relational)*

// relational -> shift (("<"|">"|"<="|">=") shift)*

// shift -> additive (("<<"|">>") additive)*

// additive -> multiplicative (("+"|"-") multiplicative)*

// multiplicative -> unary (("*"|"/"|"%") unary)*

// unary -> ("-"|"!"|"&"|"~"|"++"|"--") unary | postfix

// postfix -> primary (call | member | index | "++" | "--")*

// primary -> literal | identifier | scopedName | "(" expr ")"

// | lambda | new | cast | initializerList

private static final java.util.Set<String> COMPOUND_ASSIGN_OPS = java.util.Set.of(

"+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>="

);

Expr parseExpr() {

return parseAssignment();

}

private Expr parseAssignment() {

Expr left = parseTernary();

if (checkOp("=")) {

CppLexerToken t = advance();

Expr right = parseAssignment(); // right-associative

return new AssignExpr(left, right, t.line(), t.col(), List.of());

}

if (peek().type() == CppLexerTokenType.OPERATOR && COMPOUND_ASSIGN_OPS.contains(peek().text())) {

CppLexerToken t = advance();

Expr right = parseAssignment();

return new BinaryExpr(t.text(), left, right, t.line(), t.col(), List.of());

}

return left;