SecureLang/slcom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
slcom/slangc/parser/Parse.sauce

2400 lines
89 KiB
Plaintext
Raw Permalink Normal View History

Initial commit of main compiler sources (or should I say ... SAUCES!)
2025-06-08 23:58:21 +10:00
package slangc.parser;
public class Parse {
private int maxRecursion = 1000;
public String nodeTypesAsString(NodeType[] types) {
if (types.length == 0) {
return "Nothing?";
} else if (types.length == 1) {
return types[0].name();
} else {
String result = "";
for (int i = 0; i < types.length; i++) {
if (i != 0) {
if (i == types.length - 1) {
result += " or ";
} else {
result += ", ";
}
}
result += types[i].name();
}
return result;
}
}
public Node expectAny(ScanWalker walker, int recursion, NodeType... types) {
return expectAnyArray(walker, recursion, types);
}
public Node expectAnyArray(ScanWalker walker, int recursion, NodeType[] types) {
Node result = parseAnyArray(walker, recursion + 1, types);
if (result == null) {
result = new Branch(NodeType.ERROR_ONLY).annotate(ErrorType.EXPECTING, "Expecting " + nodeTypesAsString(types) + " (got " + walker.peek().getType().name() + ")");
}
return result;
}
public Node parseAny(ScanWalker walker, int recursion, NodeType... types) {
return parseAnyArray(walker, recursion, types);
}
public Node parseAnyArray(ScanWalker walker, int recursion, NodeType[] types) {
for (int i = 0; i < types.length; i++) {
ScanWalker w = walker.clone();
Node result = parseInner(w, recursion + 1, types[i]);
if (result != null) {
walker.reset(w);
ScanWalker.recycle(w);
return result;
}
ScanWalker.recycle(w);
}
return null;
}
public Node parseList(ScanWalker walker, int recursion, NodeType listType, NodeType separator, boolean consumeTailSeparator, NodeType... types) {
return parseListArray(walker, recursion, listType, separator, consumeTailSeparator, types);
}
public Node parseListArray(ScanWalker walker, int recursion, NodeType listType, NodeType separator, boolean consumeTailSeparator, NodeType[] types) {
checkRecursion(walker, recursion);
Branch result = new Branch(listType);
Node n;
boolean first = true;
do {
ScanWalker w = walker.clone();
if (first || separator == null) {
n = parseAnyArray(w, recursion + 1, types);
first = false;
} else {
ScanWalker w2 = w.clone();
Node sep = parseInner(w2, recursion + 1, separator);
if (sep == null) {
n = null;
} else {
n = parseAnyArray(w2, recursion + 1, types);
//System.out.println("Got a "+ n);
if (n != null || consumeTailSeparator) {
result.append(sep);
w.reset(w2);
}
}
ScanWalker.recycle(w2);
}
if (n != null) {
result.append(n);
walker.reset(w);
} else if (consumeTailSeparator) {
walker.reset(w);
}
ScanWalker.recycle(w);
} while (n != null);
return result;
}
public Node parseGenericOnlyList(ScanWalker walker, int recursion, NodeType listType, NodeType separator, boolean consumeTailSeparator, NodeType gentype, NodeType middletype) {
checkRecursion(walker, recursion);
Branch result = new Branch(listType);
Node n;
boolean first = true;
Node lastGenType = null;
ScanWalker lastGenWalker = null;
ScanWalker ogWalker = walker.clone();
int iter = 0;
do {
//System.out.println("XXXXXX" + iter); iter++;
ScanWalker w = walker.clone();
if (first || separator == null) {
n = parseAny(w, recursion + 1, gentype, middletype);
if (n != null && n.getNodeType() == gentype) {
lastGenType = n;
lastGenWalker = w.clone();
}
first = false;
} else {
ScanWalker w2 = w.clone();
Node sep = parseInner(w2, recursion + 1, separator);
if (sep == null) {
n = null;
} else {
n = parseAny(w2, recursion + 1, gentype, middletype);
if (n != null && n.getNodeType() == gentype) {
lastGenType = n;
lastGenWalker = w2.clone();
}
//System.out.println("Got a "+ n);
if (n != null || consumeTailSeparator) {
result.append(sep);
w.reset(w2);
}
}
ScanWalker.recycle(w2);
}
if (n != null) {
result.append(n);
walker.reset(w);
} else if (consumeTailSeparator) {
walker.reset(w);
}
ScanWalker.recycle(w);
} while (n != null);
if (lastGenWalker == null) {
walker.reset(ogWalker);
return null;
} else {
walker.reset(lastGenWalker);
Branch realResult = new Branch(listType);
for (int i = 0; i < result.countSubnodes(); i++) {
realResult.append(result.getSubnode(i));
if (result.getSubnode(i) == lastGenType) {
return realResult;
}
}
throw new Error("Internal error (this should be unreachable)");
}
}
public Token parseToken(ScanWalker walker, int recursion, TokenType type) {
//checkRecursion(walker, recursion);
if (walker.isAtEnd()) {
//System.out.println("AT END");
return null;
}
if (walker.peek().is(type)) {
//System.out.println("Got a match to " + type);
Token result = walker.peek();
walker.advance();
return result;
} else {
//System.out.println("Not a " + type + " but a " + walker.peek());
return null;
}
}
public Token parseToken(ScanWalker walker, int recursion, TokenType type, String value) {
//checkRecursion(walker, recursion);
if (walker.isAtEnd()) {
return null;
}
if (walker.peek().is(type, value)) {
Token result = walker.peek();
walker.advance();
return result;
} else {
return null;
}
}
public Token parseToken(ScanWalker walker, int recursion, Language.Key key) {
//checkRecursion(walker, recursion);
if (walker.isAtEnd()) {
return null;
}
String val = walker.peek().getSnippet().getSource();
if (walker.peek().is(TokenType.KEYWORD) && walker.getScan().getLanguage().matches(key, val)) {
Token result = walker.peek();
walker.advance();
return result;
} else {
return null;
}
}
public Token parseToken(ScanWalker walker, int recursion, String value) {
// Can skip recursion check since we know we won't recurse from here! checkRecursion(walker, recursion);
if (walker.isAtEnd()) {
return null;
}
if (walker.peek().is(value)) {
Token result = walker.peek();
walker.advance();
return result;
} else {
return null;
}
}
public Branch parseTokenBranch(ScanWalker walker, int recursion, NodeType n, TokenType type) {
Token t = parseToken(walker, recursion, type);
//System.out.println("Got " + t);
if (t == null) {
return null;
} else {
return new Branch(n, t);
}
}
public Branch parseTokenBranch(ScanWalker walker, int recursion, NodeType n, Language.Key key) {
Token t = parseToken(walker, recursion, key);
//System.out.println("Got " + t);
if (t == null) {
return null;
} else {
return new Branch(n, t);
}
}
public Branch parseTokenBranch(ScanWalker walker, int recursion, NodeType n, TokenType type, String value) {
Token t = parseToken(walker, recursion, type, value);
if (t == null) {
return null;
} else {
return new Branch(n, t);
}
}
/** This one is used for the special >> and >>> operators (which are actually parsed as a sequence of > operators, to avoid
* conflict with nested template sizeExpression (e.g. Map<String,List<String>>). */
public Branch parseSpecialTokenBranch(ScanWalker walker, int recursion, NodeType n, TokenType type, String value, int number) {
ScanWalker pos = walker.clone();
switch (number) { case 2: case 3: break; default: throw new Error("Internal error: Bad number " + number); }
Token t = parseToken(walker, recursion, type, value);
if (t == null) {
walker.reset(pos);
ScanWalker.recycle(pos);
return null;
} else {
Token t2 = parseToken(walker, recursion, type, value);
if (t2 == null) {
walker.reset(pos);
ScanWalker.recycle(pos);
return null;
} else if (number == 2) {
ScanWalker.recycle(pos);
return new Branch(n, t, t2);
} else { // number == 3
Token t3 = parseToken(walker, recursion, type, value);
if (t3 == null) {
walker.reset(pos);
ScanWalker.recycle(pos);
return null;
} else {
ScanWalker.recycle(pos);
return new Branch(n, t, t2, t3);
}
}
}
}
public Branch parseTokenBranch(ScanWalker walker, int recursion, NodeType n, String value) {
Token t = parseToken(walker, recursion, value);
if (t == null) {
return null;
} else {
return new Branch(n, t);
}
}
public Node parseSimpleBinop(ScanWalker walker, int recursion, NodeType result, NodeType operator, NodeType inner) {
Node lhs = parseInner(walker, recursion + 1, inner);
boolean done = false;
while (lhs != null && !walker.isAtEnd() && !done) {
Node op = parseInner(walker, recursion, operator);
if (op == null) {
done = true;
} else {
lhs = new Branch(result,
lhs,
op,
expectAny(walker, recursion + 1, inner));
}
}
return lhs;
}
public Node parseInner(ScanWalker walker, int recursion, NodeType type) {
checkRecursion(walker, recursion);
if (walker.isAtEnd()) {
return null;
}
switch (type) {
case NodeType.EOF:
return parseTokenBranch(walker, recursion + 1, NodeType.EOF, TokenType.END_OF_FILE);
case NodeType.TOKEN:
if (walker.isAtEnd()) {
return null;
} else {
Token t = walker.peek();
walker.advance();
return t;
}
case NodeType.NAME:
//System.out.println("Parsing name...");
return parseTokenBranch(walker, recursion + 1, NodeType.NAME, TokenType.NAME);
case NodeType.INDEXED_NAME: {
Node n = parseInner(walker, recursion + 1, NodeType.NAME);
if (n == null) {
return null;
} else {
Node o = parseInner(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE);
if (o == null) {
return n;
} else {
while (o != null) {
Node c = expectAny(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE);
n = new Branch(NodeType.INDEXED_NAME, n, o, c);
// Check for next set of braces
o = parseInner(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE);
}
return n;
}
}
}
case NodeType.GENERIC_NAME: {
Node n = parseTokenBranch(walker, recursion + 1, NodeType.NAME, TokenType.NAME);
if (n != null) {
if (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, "<")) {
Node genargs = parseAny(walker, recursion + 1, NodeType.GENERIC_ARGUMENTS);
if (genargs == null) {
return null;
}
return new Branch(NodeType.GENERIC_NAME, n, genargs);
} else {
return null;
}
}
return null;
}
case NodeType.DOT:
return parseTokenBranch(walker, recursion + 1, NodeType.DOT, TokenType.OPERATOR, ".");
case NodeType.WILDCARD:
return parseTokenBranch(walker, recursion + 1, NodeType.WILDCARD, TokenType.OPERATOR, "*");
case NodeType.COMMA:
return parseTokenBranch(walker, recursion + 1, NodeType.COMMA, TokenType.OPERATOR, ",");
case NodeType.SEMICOLON:
return parseTokenBranch(walker, recursion + 1, NodeType.SEMICOLON, TokenType.OPERATOR, ";");
case NodeType.COLON:
return parseTokenBranch(walker, recursion + 1, NodeType.COLON, TokenType.OPERATOR, ":");
case NodeType.DOUBLECOLON:
return parseTokenBranch(walker, recursion + 1, NodeType.DOUBLECOLON, TokenType.OPERATOR, "::");
case NodeType.QUESTIONMARK:
return parseTokenBranch(walker, recursion + 1, NodeType.QUESTIONMARK, TokenType.OPERATOR, "?");
case NodeType.OPEN_ROUND_BRACE:
return parseTokenBranch(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE, TokenType.OPERATOR, "(");
case NodeType.CLOSE_ROUND_BRACE:
return parseTokenBranch(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE, TokenType.OPERATOR, ")");
case NodeType.OPEN_CURLY_BRACE:
return parseTokenBranch(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE, TokenType.OPERATOR, "{");
case NodeType.CLOSE_CURLY_BRACE:
return parseTokenBranch(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE, TokenType.OPERATOR, "}");
case NodeType.OPEN_SQUARE_BRACE:
return parseTokenBranch(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE, TokenType.OPERATOR, "[");
case NodeType.CLOSE_SQUARE_BRACE:
return parseTokenBranch(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE, TokenType.OPERATOR, "]");
case NodeType.OPEN_ANGLE_BRACE:
return parseTokenBranch(walker, recursion + 1, NodeType.OPEN_ANGLE_BRACE, TokenType.OPERATOR, "<");
case NodeType.CLOSE_ANGLE_BRACE:
return parseTokenBranch(walker, recursion + 1, NodeType.CLOSE_ANGLE_BRACE, TokenType.OPERATOR, ">");
case NodeType.PACKAGE_NAME:
return parseList(walker, recursion + 1, NodeType.PACKAGE_NAME, NodeType.DOT, false, NodeType.NAME);
case NodeType.PACKAGE_DECLARATION: {
Token t = parseToken(walker, recursion + 1, Language.Key.MODULE); //TokenType.KEYWORD, "package");
if (t == null) {
return null;
} else {
return new Branch(NodeType.PACKAGE_DECLARATION,
t,
expectAny(walker, recursion + 1, NodeType.PACKAGE_NAME),
expectAny(walker, recursion + 1, NodeType.SEMICOLON));
}
}
case NodeType.IMPORTED_PACKAGE: {
Node n = parseInner(walker, recursion + 1, NodeType.PACKAGE_NAME);
if (n != null) {
Node dot = parseInner(walker, recursion + 1, NodeType.DOT);
if (dot != null) {
return new Branch(NodeType.IMPORTED_PACKAGE,
n,
dot,
expectAny(walker, recursion + 1, NodeType.WILDCARD));
}
}
return null;
}
case NodeType.IMPORTED_TYPE:
return parseList(walker, recursion + 1, NodeType.IMPORTED_TYPE, NodeType.DOT, false, NodeType.NAME);
case NodeType.IMPORT_DECLARATION: {
Token t = parseToken(walker, recursion + 1, Language.Key.IMPORT); //TokenType.KEYWORD, "import");
if (t == null) {
return null;
} else {
Token stat = parseToken(walker, recursion + 1, Language.Key.STATIC); //TokenType.KEYWORD, "static");
if (stat == null) {
return new Branch(NodeType.IMPORT_DECLARATION,
t,
expectAny(walker, recursion + 1, NodeType.IMPORTED_PACKAGE, NodeType.IMPORTED_TYPE),
expectAny(walker, recursion + 1, NodeType.SEMICOLON));
} else {
return new Branch(NodeType.IMPORT_STATIC_DECLARATION,
t,
stat,
expectAny(walker, recursion + 1, NodeType.IMPORTED_PACKAGE, NodeType.IMPORTED_TYPE),
expectAny(walker, recursion + 1, NodeType.SEMICOLON));
}
}
}
case NodeType.TYPE_DECLARATIONS:
return parseList(walker, recursion + 1, NodeType.TYPE_DECLARATIONS, null, false,
NodeType.CLASS_DECLARATION,
NodeType.INTERFACE_DECLARATION,
NodeType.ENUM_DECLARATION,
NodeType.ATTRIBUTE_DECLARATION,
NodeType.SEMICOLON);
case NodeType.INTERFACE_BASES: {
Node keyword = parseToken(walker, recursion + 1, Language.Key.EXTENDS); //TokenType.KEYWORD, "extends");
if (keyword == null) {
return new Branch(NodeType.NO_INTERFACE_BASES);
} else {
return new Branch(NodeType.INTERFACE_BASES, keyword, parseInner(walker, recursion + 1, NodeType.TYPE_REFERENCES));
}
}
case NodeType.CLASS_BASE: {
Node keyword = parseToken(walker, recursion + 1, Language.Key.EXTENDS); //TokenType.KEYWORD, "extends");
if (keyword == null) {
return new Branch(NodeType.NO_CLASS_BASE);
} else {
return new Branch(NodeType.CLASS_BASE, keyword, expectAny(walker, recursion + 1, NodeType.TYPE_REFERENCE));
}
}
case NodeType.CLASS_IMPLEMENTS: {
Node keyword = parseToken(walker, recursion + 1, Language.Key.IMPLEMENTS); //TokenType.KEYWORD, "implements");
if (keyword == null) {
return new Branch(NodeType.NO_CLASS_IMPLEMENTS);
} else {
return new Branch(NodeType.CLASS_IMPLEMENTS, keyword, parseInner(walker, recursion + 1, NodeType.TYPE_REFERENCES));
}
}
case NodeType.TYPE_REFERENCES:
return parseList(walker, recursion + 1, NodeType.TYPE_REFERENCES, NodeType.COMMA, false, NodeType.TYPE_REFERENCE);
case NodeType.TYPE_REFERENCE:
if (!walker.isAtEnd() && walker.peek().is(TokenType.NAME)) {
return parseList(walker, recursion + 1, NodeType.TYPE_REFERENCE, NodeType.DOT, false, NodeType.GENERIC_NAME, NodeType.NAME);
} else {
return null;
}
case NodeType.GENERIC_ONLY_TYPE_REFERENCE:
if (!walker.isAtEnd() && walker.peek().is(TokenType.NAME)) {
return parseGenericOnlyList(walker, recursion + 1, NodeType.TYPE_REFERENCE, NodeType.DOT, false, NodeType.GENERIC_NAME, NodeType.NAME);
} else {
return null;
}
case NodeType.TYPE: {
Node result = null;
result = result != null ? result : parseInner(walker, recursion + 1, NodeType.SIMPLE_TYPE);
result = result != null ? result : parseInner(walker, recursion + 1, NodeType.TYPE_REFERENCE);
while (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, "[") && walker.peekOffset(1) != null && walker.peekOffset(1).is(TokenType.OPERATOR, "]")) {
result = new Branch(NodeType.ARRAY_TYPE,
result,
parseInner(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE),
parseInner(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE));
}
if (result == null) {
return null;
} else {
return new Branch(NodeType.TYPE, result);
}
}
case NodeType.RETURN_TYPE: {
Node voidToken = parseToken(walker, recursion + 1, Language.Key.VOID); //TokenType.KEYWORD, "void");
if (voidToken == null) {
Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
if (t == null) {
return null;
} else {
return new Branch(NodeType.RETURN_TYPE, t);
}
} else {
return new Branch(NodeType.NO_RETURN_TYPE, voidToken);
}
}
case NodeType.ENUM_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node keyword = parseToken(walker, recursion + 1, Language.Key.ENUM); //TokenType.KEYWORD, "enum");
if (keyword == null) {
return null;
} else {
return new Branch(NodeType.ENUM_DECLARATION,
mods,
keyword,
expectAny(walker, recursion + 1, NodeType.NAME),
parseInner(walker, recursion + 1, NodeType.GENERIC_DECLARATIONS),
parseInner(walker, recursion + 1, NodeType.CLASS_BASE),
parseInner(walker, recursion + 1, NodeType.CLASS_IMPLEMENTS),
expectAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE),
parseInner(walker, recursion + 1, NodeType.ENUM_MEMBERS),
parseInner(walker, recursion + 1, NodeType.ENUM_CLASS_MEMBERS),
expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
}
}
case NodeType.INTERFACE_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node keyword = parseToken(walker, recursion + 1, Language.Key.INTERFACE); //TokenType.KEYWORD, "interface");
if (keyword == null) {
return null;
} else {
return new Branch(NodeType.INTERFACE_DECLARATION,
mods,
keyword,
expectAny(walker, recursion + 1, NodeType.NAME),
parseInner(walker, recursion + 1, NodeType.GENERIC_DECLARATIONS),
parseInner(walker, recursion + 1, NodeType.INTERFACE_BASES),
expectAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE),
parseInner(walker, recursion + 1, NodeType.INTERFACE_MEMBERS),
expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
}
}
case NodeType.CLASS_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node keyword = parseToken(walker, recursion + 1, Language.Key.CLASS);//parseToken(walker, recursion + 1, TokenType.KEYWORD, "class");
if (keyword == null) {
return null;
} else {
return new Branch(NodeType.CLASS_DECLARATION,
mods,
keyword,
expectAny(walker, recursion + 1, NodeType.NAME),
parseInner(walker, recursion + 1, NodeType.GENERIC_DECLARATIONS),
parseInner(walker, recursion + 1, NodeType.CLASS_BASE),
parseInner(walker, recursion + 1, NodeType.CLASS_IMPLEMENTS),
expectAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE),
parseInner(walker, recursion + 1, NodeType.CLASS_MEMBERS),
expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
}
}
case NodeType.ATTRIBUTE_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node at = parseToken(walker, recursion + 1, TokenType.OPERATOR, "@");
if (at == null) {
return null;
}
Node keyword = parseToken(walker, recursion + 1, Language.Key.INTERFACE); //TokenType.KEYWORD, "interface");
if (keyword == null) {
return null;
} else {
return new Branch(NodeType.ATTRIBUTE_DECLARATION,
mods,
at,
keyword,
expectAny(walker, recursion + 1, NodeType.NAME),
parseInner(walker, recursion + 1, NodeType.GENERIC_DECLARATIONS),
parseInner(walker, recursion + 1, NodeType.INTERFACE_BASES),
expectAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE),
parseInner(walker, recursion + 1, NodeType.INTERFACE_MEMBERS),
expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
}
}
case NodeType.ENUM_MEMBERS:
return parseList(walker, recursion + 1, NodeType.ENUM_MEMBERS, NodeType.COMMA, true, NodeType.SPECIALISED_ENUM_SUBTYPE, NodeType.SPECIALISED_ENUM_MEMBER, NodeType.ENUM_MEMBER);
case NodeType.ENUM_MEMBER: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node name = parseToken(walker, recursion + 1, TokenType.NAME);
if (name == null) {
return null;
} else {
return new Branch(NodeType.ENUM_MEMBER, mods, name);
}
}
case NodeType.SPECIALISED_ENUM_MEMBER: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node name = parseToken(walker, recursion + 1, TokenType.NAME);
if (name == null) {
return null;
}
Node args = parseAny(walker, recursion + 1, NodeType.ARGUMENTS);
if (args == null) {
return null;
}
return new Branch(NodeType.SPECIALISED_ENUM_MEMBER, mods, name, args);
}
case NodeType.SPECIALISED_ENUM_SUBTYPE: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node name = parseToken(walker, recursion + 1, TokenType.NAME);
if (name == null) {
return null;
}
Node args = parseAny(walker, recursion + 1, NodeType.ARGUMENTS);
//if (args == null) {
// return null;
//}
Node open = parseAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE);
if (open == null) {
return null;
}
Node members = expectAny(walker, recursion + 1, NodeType.CLASS_MEMBERS);
Node close = expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE);
if (args == null) {
return new Branch(NodeType.SPECIALISED_ENUM_SUBTYPE, mods, name, open, members, close);
} else {
return new Branch(NodeType.SPECIALISED_ENUM_SUBTYPE_WITH_ARGS, mods, name, args, open, members, close);
}
}
case NodeType.ENUM_CLASS_MEMBERS: {
//System.out.println("Looking for semicolon got " + walker.peek());
Node semi = parseInner(walker, recursion + 1, NodeType.SEMICOLON);
if (semi == null) {
return new Branch(NodeType.NO_ENUM_CLASS_MEMBERS);
} else {
return new Branch(NodeType.ENUM_CLASS_MEMBERS, semi, parseInner(walker, recursion + 1, NodeType.CLASS_MEMBERS));
}
}
case NodeType.CLASS_MEMBERS: {
// Workaround because empty {...} seems to cause issues
//ScanWalker pos = walker.clone();
//Node emptyEnd = parseAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE);
//if (emptyEnd != null) {
// walker.reset(pos);
// return new Branch(NodeType.CLASS_MEMBERS);
//}
return parseList(walker, recursion + 1, NodeType.CLASS_MEMBERS, null, false,
NodeType.CONSTRUCTOR_DECLARATION,
NodeType.STATIC_CONSTRUCTOR_DECLARATION,
NodeType.METHOD_DECLARATION,
NodeType.FIELD_DECLARATION,
NodeType.CLASS_DECLARATION,
NodeType.INTERFACE_DECLARATION,
NodeType.ENUM_DECLARATION,
NodeType.ATTRIBUTE_DECLARATION,
NodeType.SEMICOLON);
}
case NodeType.INTERFACE_MEMBERS: {
return parseList(walker, recursion + 1, NodeType.INTERFACE_MEMBERS, null, false,
NodeType.STATIC_CONSTRUCTOR_DECLARATION,
NodeType.METHOD_DECLARATION,
NodeType.FIELD_DECLARATION,
NodeType.CLASS_DECLARATION,
NodeType.INTERFACE_DECLARATION,
NodeType.ENUM_DECLARATION,
NodeType.ATTRIBUTE_DECLARATION,
NodeType.SEMICOLON);
}
case NodeType.MODIFIER_LIST:
return parseList(walker, recursion + 1, NodeType.MODIFIER_LIST, null, false, NodeType.SIMPLE_MODIFIER, NodeType.COMPLEX_TAGGED_MODIFIER);
case NodeType.SIMPLE_MODIFIER: {
Node mod = null;
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.PUBLIC);//parseToken(walker, recursion + 1, TokenType.KEYWORD, "public");
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.PROTECTED);//TokenType.KEYWORD, "protected");
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.PRIVATE);//TokenType.KEYWORD, "private");
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.STATIC);//TokenType.KEYWORD, "static");
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.FINAL);//TokenType.KEYWORD, "final");
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.ABSTRACT);//TokenType.KEYWORD, "abstract");
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.SYNCHRONISED);//TokenType.KEYWORD, "synchronized");
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.NATIVE);//TokenType.KEYWORD, "native");
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.TRANSIENT);//TokenType.KEYWORD, "transient");
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.VOLATILE);//TokenType.KEYWORD, "volatile");
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.COMPAT_STRICTFP);//TokenType.KEYWORD, "strictfp");
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.VOLATILE);//TokenType.KEYWORD, "volatile");
mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.DEFAULT);//TokenType.KEYWORD, "default");
return mod == null ? null : new Branch(NodeType.SIMPLE_MODIFIER, mod);
}
case NodeType.BREAK_STATEMENT: {
Node br = parseToken(walker, recursion + 1, Language.Key.BREAK); //TokenType.KEYWORD, "break");
if (br == null) {
return null;
} else {
Node label = parseAny(walker, recursion + 1, NodeType.NAME);
Node semicolon = expectAny(walker, recursion + 1, NodeType.SEMICOLON);
if (label == null) {
return new Branch(NodeType.BREAK_STATEMENT, br, semicolon);
} else {
return new Branch(NodeType.BREAK_TO_STATEMENT, br, label, semicolon);
}
}
}
case NodeType.CONTINUE_STATEMENT: {
Node br = parseToken(walker, recursion + 1, Language.Key.CONTINUE); //TokenType.KEYWORD, "continue");
if (br == null) {
return null;
} else {
Node label = parseAny(walker, recursion + 1, NodeType.NAME);
Node semicolon = expectAny(walker, recursion + 1, NodeType.SEMICOLON);
if (label == null) {
return new Branch(NodeType.CONTINUE_STATEMENT, br, semicolon);
} else {
return new Branch(NodeType.CONTINUE_TO_STATEMENT, br, label, semicolon);
}
}
}
case NodeType.LABEL_STATEMENT: {
Node n = parseAny(walker, recursion + 1, NodeType.NAME);
if (n == null) {
return null;
}
Node s = parseAny(walker, recursion + 1, NodeType.COLON);
if (s == null) {
return null;
} else {
return new Branch(NodeType.LABEL_STATEMENT, n, s);
}
}
case NodeType.COMPLEX_TAGGED_MODIFIER: {
Node tagsymbol = parseToken(walker, recursion + 1, TokenType.OPERATOR, "@");
boolean noAt = (tagsymbol == null);
if (noAt) {
tagsymbol = tagsymbol != null ? tagsymbol : parseToken(walker, recursion + 1, TokenType.OPERATOR, "#");
tagsymbol = tagsymbol != null ? tagsymbol : parseToken(walker, recursion + 1, TokenType.OPERATOR, "##");
}
if (tagsymbol == null) {
return null;
}
Node tagname;
if (noAt) {
tagname = parseAny(walker, recursion + 1, NodeType.NAME, NodeType.STRING_LITERAL_EXPRESSION, NodeType.INTEGER_LITERAL_EXPRESSION);
} else {
tagname = parseAny(walker, recursion + 1, NodeType.TYPE_REFERENCE);
}
if (tagname == null) {
return null;
}
if (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, "(")) {
return new Branch(NodeType.COMPLEX_TAGGED_MODIFIER, tagsymbol, tagname, expectAny(walker, recursion + 1, NodeType.MODIFIER_ARGUMENTS));
} else if (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, ":")) {
Node sep = parseToken(walker, recursion + 1, TokenType.OPERATOR, ":");
return new Branch(NodeType.NAME_TAGGED_MODIFIER, tagsymbol, tagname, sep, expectAny(walker, recursion + 1, NodeType.NAME, NodeType.STRING_LITERAL_EXPRESSION, NodeType.INTEGER_LITERAL_EXPRESSION));
} else {
return new Branch(NodeType.SIMPLE_TAGGED_MODIFIER, tagsymbol, tagname);
}
}
case NodeType.MODIFIER_ARGUMENTS: {
Node open = parseAny(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
if (open == null) {
return null;
}
Node inner = parseAny(walker, recursion + 1, NodeType.MODIFIER_EXPRESSIONS);
Node close = expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE);
return new Branch(NodeType.MODIFIER_ARGUMENTS, open, inner, close);
}
case NodeType.SIMPLE_TYPE: {
Node result = null;
result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.BIT); //TokenType.KEYWORD, "boolean");
result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.BYTE); //TokenType.KEYWORD, "byte");
result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.SHORT); //TokenType.KEYWORD, "short");
result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.COMPAT_CHAR); //TokenType.KEYWORD, "char");
result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.INT); //TokenType.KEYWORD, "int");
result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.LONG); //TokenType.KEYWORD, "long");
result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.FLOAT); //TokenType.KEYWORD, "float");
result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.DOUBLE); //TokenType.KEYWORD, "double");
//result = result != null ? result : parseToken(walker, recursion + 1, TokenType.KEYWORD, "cpuword");
result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.DUCK); //TokenType.KEYWORD, "duck");
return result;
}
case NodeType.ARGUMENT_DECLARATIONS: {
Node start = parseInner(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
if (start == null) {
return null;
} else {
return new Branch(NodeType.ARGUMENT_DECLARATIONS,
start,
parseList(walker, recursion + 1, NodeType.ARGUMENT_DECLARATION_LIST, NodeType.COMMA, false, NodeType.LAZY_ARGUMENT_DECLARATION, NodeType.VARIABLE_ARGUMENT_DECLARATION, NodeType.SIMPLE_ARGUMENT_DECLARATION),
expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE));
}
}
case NodeType.GENERIC_DECLARATIONS: {
Node start = parseInner(walker, recursion + 1, NodeType.OPEN_ANGLE_BRACE);
if (start == null) {
return new Branch(NodeType.NO_GENERIC_DECLARATIONS);
} else {
return new Branch(NodeType.GENERIC_DECLARATIONS,
start,
parseList(walker, recursion + 1, NodeType.GENERIC_DECLARATION_LIST, NodeType.COMMA, false,
NodeType.VARIABLE_TYPED_GENERIC_DECLARATION,
NodeType.VARIABLE_GENERIC_DECLARATION,
NodeType.SIMPLE_TYPED_GENERIC_DECLARATION,
NodeType.SIMPLE_EXTENDED_GENERIC_DECLARATION,
NodeType.SIMPLE_GENERIC_DECLARATION),
expectAny(walker, recursion + 1, NodeType.CLOSE_ANGLE_BRACE));
}
}
case NodeType.METHOD_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node gentype = parseInner(walker, recursion + 1, NodeType.GENERIC_DECLARATIONS);
Node t = parseInner(walker, recursion + 1, NodeType.RETURN_TYPE);
if (t == null) {
return null;
} else {
Node n = parseInner(walker, recursion + 1, NodeType.NAME);
if (n == null) {
return null;
} else {
Node args = parseInner(walker, recursion + 1, NodeType.ARGUMENT_DECLARATIONS);
if (args == null) {
return null;
} else {
return new Branch(NodeType.METHOD_DECLARATION,
mods,
gentype,
t,
n,
args,
parseAny(walker, recursion + 1, NodeType.ARRAY_TYPE_TAIL),
parseInner(walker, recursion + 1, NodeType.THROWS),
expectAny(walker, recursion + 1, NodeType.METHOD_BODY));
}
}
}
}
case NodeType.CONSTRUCTOR_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node n = parseInner(walker, recursion + 1, NodeType.NAME);
if (n == null) {
return null;
} else {
Node args = parseInner(walker, recursion + 1, NodeType.ARGUMENT_DECLARATIONS);
if (args == null) {
return null;
} else {
return new Branch(NodeType.CONSTRUCTOR_DECLARATION,
mods,
n,
args,
parseInner(walker, recursion + 1, NodeType.THROWS),
expectAny(walker, recursion + 1, NodeType.METHOD_BODY));
}
}
}
case NodeType.STATIC_CONSTRUCTOR_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
if (walker.peek().is(TokenType.OPERATOR, "{")) {
Node body = parseInner(walker, recursion + 1, NodeType.METHOD_BODY);
return new Branch(NodeType.STATIC_CONSTRUCTOR_DECLARATION, mods, body);
} else {
return null;
}
}
case NodeType.THROWS: {
Token keyword = parseToken(walker, recursion + 1, Language.Key.THROWS); //TokenType.KEYWORD, "throws");
if (keyword == null) {
return new Branch(NodeType.NO_THROWS);
} else {
return new Branch(NodeType.THROWS, parseInner(walker, recursion + 1, NodeType.TYPE_REFERENCES));
}
}
case NodeType.METHOD_BODY: {
Node semi = parseInner(walker, recursion + 1, NodeType.SEMICOLON);
if (semi == null) {
Node def = parseToken(walker, recursion + 1, Language.Key.DEFAULT); //TokenType.KEYWORD, "default");
if (def != null) {
return new Branch(NodeType.DEFAULT_METHOD_BODY,
def,
expectAny(walker, recursion + 1, NodeType.EXPRESSION),
expectAny(walker, recursion + 1, NodeType.SEMICOLON));
}
return new Branch(NodeType.METHOD_BODY, expectAny(walker, recursion + 1, NodeType.BLOCK_STATEMENT));
} else {
return new Branch(NodeType.NO_METHOD_BODY, semi);
}
}
case NodeType.BLOCK_STATEMENT: {
Node start = parseInner(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE);
if (start == null) {
return null;
} else {
return new Branch(NodeType.BLOCK_STATEMENT,
start,
parseInner(walker, recursion + 1, NodeType.STATEMENTS),
expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
}
}
case NodeType.SWITCH_STATEMENT: {
Node keyword = parseToken(walker, recursion + 1, Language.Key.SWITCH); //TokenType.KEYWORD, "switch");
if (keyword == null) {
return null;
}
Node cond = expectAny(walker, recursion + 1, NodeType.BRACED_EXPRESSION);
Node start = expectAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE);
return new Branch(NodeType.SWITCH_STATEMENT,
keyword,
cond,
start,
parseInner(walker, recursion + 1, NodeType.SWITCH_MEMBERS),
expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
}
case NodeType.ASSERT_STATEMENT: {
Node keyword = parseToken(walker, recursion + 1, Language.Key.ASSERT); //TokenType.KEYWORD, "assert");
if (keyword == null) {
return null;
} else {
Node expr = expectAny(walker, recursion + 1, NodeType.EXPRESSION);
Node colon = parseAny(walker, recursion + 1, NodeType.COLON);
if (colon == null) {
return new Branch(NodeType.ASSERT_STATEMENT,
keyword,
expr,
expectAny(walker, recursion + 1, NodeType.SEMICOLON));
} else {
return new Branch(NodeType.ASSERT_DEBUG_STATEMENT,
keyword,
expr,
colon,
expectAny(walker, recursion + 1, NodeType.EXPRESSION),
expectAny(walker, recursion + 1, NodeType.SEMICOLON));
}
}
}
case NodeType.THROW_STATEMENT: {
Node keyword = parseToken(walker, recursion + 1, Language.Key.THROW); //TokenType.KEYWORD, "throw");
if (keyword == null) {
return null;
} else {
return new Branch(NodeType.THROW_STATEMENT,
keyword,
expectAny(walker, recursion + 1, NodeType.EXPRESSION),
expectAny(walker, recursion + 1, NodeType.SEMICOLON));
}
}
case NodeType.RETURN_EXPRESSION_STATEMENT: {
Node keyword = parseToken(walker, recursion + 1, Language.Key.RETURN); //TokenType.KEYWORD, "return");
if (keyword == null) {
return null;
} else {
Node next = expectAny(walker, recursion + 1, NodeType.EXPRESSION, NodeType.SEMICOLON);
if (next.getNodeType() == NodeType.SEMICOLON) {
return new Branch(NodeType.RETURN_NOTHING_STATEMENT, keyword, next);
} else {
return new Branch(NodeType.RETURN_EXPRESSION_STATEMENT,
keyword,
next,
expectAny(walker, recursion + 1, NodeType.SEMICOLON));
}
}
}
case NodeType.VARIABLE_STATEMENT: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
if (t != null &&!walker.isAtEnd() && walker.peek().is(TokenType.NAME)) {
return new Branch(NodeType.VARIABLE_STATEMENT,
mods,
t,
parseInner(walker, recursion + 1, NodeType.SLOTS),
expectAny(walker, recursion + 1, NodeType.SEMICOLON));
} else {
return null;
}
}
case NodeType.FOR_VARIABLES: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
if (t != null &&!walker.isAtEnd() && walker.peek().is(TokenType.NAME)) {
return new Branch(NodeType.FOR_VARIABLES,
mods,
t,
parseInner(walker, recursion + 1, NodeType.SLOTS));
} else {
return null;
}
}
case NodeType.IF_STATEMENT: {
Token keyword = parseToken(walker, recursion + 1, Language.Key.IF); //TokenType.KEYWORD, "if");
if (keyword == null) {
return null;
} else {
Node cond = expectAny(walker, recursion + 1, NodeType.BRACED_EXPRESSION); // TODO: Change to only bracketed expression
Node cons = expectAny(walker, recursion + 1, NodeType.STATEMENT);
Node els = parseInner(walker, recursion + 1, NodeType.ELSE_CLAUSE);
return new Branch(NodeType.IF_STATEMENT, keyword, cond, cons, els);
}
}
case NodeType.SYNCHRONIZED_STATEMENT: {
Token keyword = parseToken(walker, recursion + 1, Language.Key.SYNCHRONISED); //TokenType.KEYWORD, "synchronized");
if (keyword == null) {
return null;
} else {
Node cond = expectAny(walker, recursion + 1, NodeType.BRACED_EXPRESSION); // TODO: Change to only bracketed expression
Node cons = expectAny(walker, recursion + 1, NodeType.BLOCK_STATEMENT);
return new Branch(NodeType.SYNCHRONIZED_STATEMENT, keyword, cond, cons);
}
}
case NodeType.ELSE_CLAUSE: {
Token keyword = parseToken(walker, recursion + 1, Language.Key.ELSE); //TokenType.KEYWORD, "else");
if (keyword == null) {
return new Branch(NodeType.NO_ELSE_CLAUSE);
} else {
return new Branch(NodeType.ELSE_CLAUSE, keyword,
expectAny(walker, recursion + 1, NodeType.STATEMENT));
}
}
case NodeType.WHILE_STATEMENT: {
Token keyword = parseToken(walker, recursion + 1, Language.Key.WHILE); //TokenType.KEYWORD, "while");
if (keyword == null) {
return null;
} else {
Node cond = expectAny(walker, recursion + 1, NodeType.BRACED_EXPRESSION);
Node cons = expectAny(walker, recursion + 1, NodeType.STATEMENT, NodeType.SEMICOLON);
return new Branch(NodeType.WHILE_STATEMENT, keyword, cond, cons);
}
}
case NodeType.FOR_STATEMENT: {
Token keyword = parseToken(walker, recursion + 1, Language.Key.FOR); //TokenType.KEYWORD, "for");
if (keyword == null) {
return null;
} else {
Node obr = expectAny(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
Node st1 = expectAny(walker, recursion + 1, NodeType.FOR_VARIABLES, NodeType.EXPRESSIONS);
Node firstsep = expectAny(walker, recursion + 1, NodeType.SEMICOLON, NodeType.COLON);
if (firstsep.getNodeType() == NodeType.COLON) {
// Handle for-each variant
Node rangeexpr = parseAny(walker, recursion + 1, NodeType.EXPRESSIONS);
Node cbr = expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE);
Node cons = expectAny(walker, recursion + 1, NodeType.STATEMENT, NodeType.SEMICOLON);
return new Branch(NodeType.FOR_EACH_STATEMENT, keyword, obr, st1, firstsep, rangeexpr, cbr, cons);
} else {
Node st2 = expectAny(walker, recursion + 1, NodeType.EXPRESSIONS);
Node lastsep = expectAny(walker, recursion + 1, NodeType.SEMICOLON);
Node st3 = parseAny(walker, recursion + 1, NodeType.EXPRESSIONS);
Node cbr = expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE);
Node cons = expectAny(walker, recursion + 1, NodeType.STATEMENT, NodeType.SEMICOLON);
return new Branch(NodeType.FOR_STATEMENT, keyword, obr, st1, firstsep, st2, lastsep, st3, cbr, cons);
}
}
}
case NodeType.DO_WHILE_STATEMENT: {
Token keyword = parseToken(walker, recursion + 1, Language.Key.DO); //TokenType.KEYWORD, "do");
if (keyword == null) {
return null;
} else {
Node cons = expectAny(walker, recursion + 1, NodeType.STATEMENT);
Node kw2 = parseToken(walker, recursion + 1, Language.Key.WHILE); //TokenType.KEYWORD, "while");
Node cond = expectAny(walker, recursion + 1, NodeType.BRACED_EXPRESSION);
Node end = expectAny(walker, recursion + 1, NodeType.SEMICOLON);
return new Branch(NodeType.DO_WHILE_STATEMENT, keyword, cons, kw2, cond, end);
}
}
case NodeType.TRY_STATEMENT: {
Token keyword = parseToken(walker, recursion + 1, Language.Key.TRY); //TokenType.KEYWORD, "try");
if (keyword == null) {
return null;
} else {
Node vars = parseAny(walker, recursion + 1, NodeType.TRY_RESOURCES);
Node tries = expectAny(walker, recursion + 1, NodeType.BLOCK_STATEMENT);
Node catches = parseList(walker, recursion + 1, NodeType.CATCH_CLAUSES, null, false, NodeType.CATCH_CLAUSE);
Node fin = parseInner(walker, recursion + 1, NodeType.FINALLY_CLAUSE);
return new Branch(NodeType.TRY_STATEMENT, keyword, vars, tries, catches, fin);
}
}
case NodeType.TRY_RESOURCES: {
Node open = parseAny(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
if (open == null) {
return new Branch(NodeType.NO_TRY_RESOURCES);
}
return new Branch(NodeType.TRY_RESOURCES,
open,
parseList(walker, recursion + 1, NodeType.TRY_RESOURCE_LIST, NodeType.SEMICOLON, false, NodeType.FOR_VARIABLES),
expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE));
}
case NodeType.CATCH_CLAUSE: {
Token keyword = parseToken(walker, recursion + 1, Language.Key.CATCH); //TokenType.KEYWORD, "catch");
if (keyword == null) {
return null;
} else {
Node cond = expectAny(walker, recursion + 1, NodeType.ARGUMENT_DECLARATIONS);
Node cons = expectAny(walker, recursion + 1, NodeType.BLOCK_STATEMENT);
return new Branch(NodeType.CATCH_CLAUSE, keyword, cond, cons);
}
}
case NodeType.FINALLY_CLAUSE: {
Token keyword = parseToken(walker, recursion + 1, Language.Key.FINALLY); //TokenType.KEYWORD, "finally");
if (keyword == null) {
return new Branch(NodeType.NO_FINALLY_CLAUSE);
} else {
Node cons = expectAny(walker, recursion + 1, NodeType.BLOCK_STATEMENT);
return new Branch(NodeType.FINALLY_CLAUSE, keyword, cons);
}
}
case NodeType.EXPRESSION_STATEMENT: {
Node expr = parseAny(walker, recursion + 1, NodeType.EXPRESSION);
if (expr != null) {
/*switch (expr.getNodeType()) {
case NodeType.ASSIGNMENT_EXPRESSION:
case NodeType.COUNT_EXPRESSION:
case NodeType.AUTOMATIC_METHOD_CALL_EXPRESSION:
case NodeType.NORMAL_METHOD_CALL_EXPRESSION:
case NodeType.SUPER_CONSTRUCTOR_CALL_EXPRESSION:
case NodeType.SUPER_METHOD_CALL_EXPRESSION:
case NodeType.THIS_CONSTRUCTOR_CALL_EXPRESSION:
return new Branch(NodeType.EXPRESSION_STATEMENT,
expr,
expectAny(walker, recursion + 1, NodeType.SEMICOLON));
default:
return null;
}*/
return new Branch(NodeType.EXPRESSION_STATEMENT,
expr,
expectAny(walker, recursion + 1, NodeType.SEMICOLON));
} else {
return null;
}
}
case NodeType.STATEMENTS:
return parseList(walker, recursion + 1, NodeType.STATEMENTS, null, false, NodeType.STATEMENT);
case NodeType.SWITCH_MEMBERS:
return parseList(walker, recursion + 1, NodeType.SWITCH_MEMBERS, null, false, NodeType.CASE_LABEL, NodeType.DEFAULT_LABEL, NodeType.STATEMENT);
case NodeType.CASE_LABEL: {
Node keyword = parseToken(walker, recursion + 1, Language.Key.CASE); //TokenType.KEYWORD, "case");
if (keyword == null) {
return null;
} else {
return new Branch(NodeType.CASE_LABEL,
keyword,
expectAny(walker, recursion + 1, NodeType.EXPRESSION),
expectAny(walker, recursion + 1, NodeType.COLON));
}
}
case NodeType.DEFAULT_LABEL: {
Node keyword = parseToken(walker, recursion + 1, Language.Key.DEFAULT); //TokenType.KEYWORD, "default");
if (keyword == null) {
return null;
} else {
return new Branch(NodeType.DEFAULT_LABEL,
keyword,
expectAny(walker, recursion + 1, NodeType.COLON));
}
}
case NodeType.STATEMENT:
return parseAny(walker, recursion + 1,
NodeType.LABEL_STATEMENT,
NodeType.IF_STATEMENT,
NodeType.WHILE_STATEMENT,
NodeType.DO_WHILE_STATEMENT,
NodeType.FOR_STATEMENT,
NodeType.SWITCH_STATEMENT,
NodeType.ASSERT_STATEMENT,
NodeType.THROW_STATEMENT,
NodeType.RETURN_EXPRESSION_STATEMENT,
NodeType.TRY_STATEMENT,
NodeType.VARIABLE_STATEMENT,
NodeType.BLOCK_STATEMENT,
NodeType.EXPRESSION_STATEMENT,
NodeType.SYNCHRONIZED_STATEMENT,
NodeType.BREAK_STATEMENT,
NodeType.CONTINUE_STATEMENT,
NodeType.CLASS_DECLARATION,
NodeType.INTERFACE_DECLARATION,
NodeType.ENUM_DECLARATION,
NodeType.ATTRIBUTE_DECLARATION,
NodeType.SEMICOLON);
case NodeType.FIELD_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
if (t != null &&!walker.isAtEnd() && walker.peek().is(TokenType.NAME)) {
return new Branch(NodeType.FIELD_DECLARATION,
mods,
t,
parseInner(walker, recursion + 1, NodeType.SLOTS),
expectAny(walker, recursion + 1, NodeType.SEMICOLON));
} else {
return null;
}
}
case NodeType.NULL_LITERAL_EXPRESSION: {
Token keyword = parseToken(walker, recursion + 1, Language.Key.NULL); //TokenType.KEYWORD, "null");
if (keyword == null) {
return null;
} else {
return new Branch(NodeType.NULL_LITERAL_EXPRESSION, keyword);
}
}
case NodeType.BOOLEAN_LITERAL_EXPRESSION: {
Token keyword = parseToken(walker, recursion + 1, Language.Key.FALSE); //TokenType.KEYWORD, "false");
if (keyword == null) {
keyword = parseToken(walker, recursion + 1, Language.Key.TRUE); //TokenType.KEYWORD, "true");
}
if (keyword == null) {
return null;
} else {
return new Branch(NodeType.BOOLEAN_LITERAL_EXPRESSION, keyword);
}
}
case NodeType.INTEGER_LITERAL_EXPRESSION: {
Token num = parseToken(walker, recursion + 1, TokenType.DEC_INTEGER);
if (num == null) {
num = parseToken(walker, recursion + 1, TokenType.HEX_INTEGER);
}
if (num == null) {
num = parseToken(walker, recursion + 1, TokenType.BIN_INTEGER);
}
if (num == null) {
return null;
} else {
return new Branch(NodeType.INTEGER_LITERAL_EXPRESSION, num);
}
}
case NodeType.FLOAT_LITERAL_EXPRESSION: {
Token num = parseToken(walker, recursion + 1, TokenType.DEC_FLOAT);
if (num == null) {
num = parseToken(walker, recursion + 1, TokenType.HEX_FLOAT);
}
if (num == null) {
num = parseToken(walker, recursion + 1, TokenType.BIN_FLOAT);
}
if (num == null) {
return null;
} else {
return new Branch(NodeType.FLOAT_LITERAL_EXPRESSION, num);
}
}
case NodeType.STRING_LITERAL_EXPRESSION: {
Token str = parseToken(walker, recursion + 1, TokenType.STRING);
if (str == null) {
return null;
} else {
return new Branch(NodeType.STRING_LITERAL_EXPRESSION, str);
}
}
case NodeType.CHAR_LITERAL_EXPRESSION: {
Token chr = parseToken(walker, recursion + 1, TokenType.CHAR);
if (chr == null) {
return null;
} else {
return new Branch(NodeType.CHAR_LITERAL_EXPRESSION, chr);
}
}
case NodeType.LITERAL_EXPRESSION:
return parseAny(walker, recursion + 1,
NodeType.NULL_LITERAL_EXPRESSION,
NodeType.BOOLEAN_LITERAL_EXPRESSION,
NodeType.INTEGER_LITERAL_EXPRESSION,
NodeType.FLOAT_LITERAL_EXPRESSION,
NodeType.CHAR_LITERAL_EXPRESSION,
NodeType.STRING_LITERAL_EXPRESSION);
case NodeType.REFERENCE_EXPRESSION:
return parseTokenBranch(walker, recursion + 1, NodeType.REFERENCE_EXPRESSION, TokenType.NAME);
case NodeType.GENERIC_REFERENCE_EXPRESSION: {
Node n = parseAny(walker, recursion + 1, NodeType.GENERIC_ONLY_TYPE_REFERENCE);
if (n == null) {
return null;
}
return new Branch(NodeType.GENERIC_REFERENCE_EXPRESSION, n);
}
case NodeType.GENERIC_REFERENCE_NAME: {
Node args = parseAny(walker, recursion + 1, NodeType.GENERIC_ARGUMENTS);
if (args == null) {
return null;
}
Node nam = parseAny(walker, recursion + 1, NodeType.NAME);
if (nam == null) {
return null;
}
return new Branch(NodeType.GENERIC_NAME, args, nam);
}
case NodeType.SUPER:
return parseTokenBranch(walker, recursion + 1, NodeType.SUPER, Language.Key.SUPER); //TokenType.KEYWORD, "super");
case NodeType.THIS_EXPRESSION: {
// TODO: Why'd I put this here?
// Node t = parseInner(walker, recursion + 1, NodeType.TYPE_REFERENCE);
return parseTokenBranch(walker, recursion + 1, NodeType.THIS_EXPRESSION, Language.Key.THIS); //TokenType.KEYWORD, "this");
}
case NodeType.OUTER_THIS_EXPRESSION: {
Node t = parseInner(walker, recursion + 1, NodeType.TYPE_REFERENCE);
if (t == null) {
return null;
}
Node dot = parseInner(walker, recursion + 1, NodeType.DOT);
if (dot == null) {
return null;
}
Node thi = parseTokenBranch(walker, recursion + 1, NodeType.THIS_EXPRESSION, Language.Key.THIS); //TokenType.KEYWORD, "this");
if (thi == null) {
return null;
} else {
return new Branch(NodeType.OUTER_THIS_EXPRESSION, t, dot, thi);
}
}
case NodeType.OUTER_SUPER_CONSTRUCTOR_CALL_EXPRESSION: {
Node outerThis = parseAny(walker, recursion + 1, NodeType.OUTER_THIS_EXPRESSION, NodeType.TYPE);
if (outerThis == null) {
return null;
}
Node dot = parseInner(walker, recursion + 1, NodeType.DOT);
if (dot == null) {
return null;
}
Node sup = parseToken(walker, recursion + 1, Language.Key.SUPER); //TokenType.KEYWORD, "super");
if (sup == null) {
return null;
}
Node argsOrDot = parseAny(walker, recursion + 1, NodeType.DOT, NodeType.ARGUMENTS);
if (argsOrDot == null) {
return null;
}
if (argsOrDot.getNodeType() == NodeType.DOT) {
Node nam = expectAny(walker, recursion + 1, NodeType.NAME);
Node realargs = expectAny(walker, recursion + 1, NodeType.ARGUMENTS);
return new Branch(NodeType.OUTER_SUPER_METHOD_CALL_EXPRESSION, outerThis, dot, sup, argsOrDot, nam, realargs);
}
return new Branch(NodeType.OUTER_THIS_EXPRESSION, outerThis, dot, sup, argsOrDot);
}
case NodeType.TYPE_EXPRESSION: {
Node t = parseAny(walker, recursion + 1, NodeType.TYPE, NodeType.RETURN_TYPE); // RETURN_TYPE handles special case NodeType.of void
if (t == null) {
return null;
}
Node dot = parseInner(walker, recursion + 1, NodeType.DOT);
if (dot == null) {
return null;
}
Node thi = parseToken(walker, recursion + 1, Language.Key.CLASS);//parseToken(walker, recursion + 1, TokenType.KEYWORD, "class");
if (thi == null) {
return null;
} else {
return new Branch(NodeType.TYPE_EXPRESSION, t, dot, thi);
}
}
/*case NodeType.NAMED_LAMBDA_EXPRESSION: {
Node t = parseAny(walker, recursion + 1, NodeType.TYPE);
if (t == null) {
return null;
}
Node dcol = parseAny(walker, recursion + 1, NodeType.DOUBLECOLON);
if (dcol == null) {
return null;
}
Node name = parseToken(walker, recursion + 1, Language.Key.NEW); //TokenType.KEYWORD, "new");
if (name == null) {
name = expectAny(walker, recursion + 1, TokenType.NAME);
}
return new Branch(NodeType.NAMED_LAMBDA_EXPRESSION, t, dcol, name);
}*/
case NodeType.LAMBDA_ARGS: {
Node open = parseAny(walker, recursion + 1, NodeType.NAME, NodeType.OPEN_ROUND_BRACE);
if (open == null) {
return null;
}
if (open.getNodeType() == NodeType.NAME) {
return new Branch(NodeType.LAMBDA_ARGS, open);
}
Node inner = parseList(walker, recursion + 1, NodeType.ARGUMENT_DECLARATION_LIST, NodeType.COMMA, false, NodeType.LAZY_ARGUMENT_DECLARATION, NodeType.VARIABLE_ARGUMENT_DECLARATION, NodeType.SIMPLE_ARGUMENT_DECLARATION, NodeType.NAME);
Node close = parseAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE);
if (close == null) {
return null;
}
return new Branch(NodeType.LAMBDA_ARGS, open, inner, close);
}
case NodeType.LAMBDA_EXPRESSION: {
Node args = parseAny(walker, recursion + 1, NodeType.LAMBDA_ARGS);
if (args == null) {
return null;
}
Node op = parseToken(walker, recursion + 1, TokenType.OPERATOR, "->");
if (op == null) {
return null;
}
Node rhs = expectAny(walker, recursion + 1, NodeType.BLOCK_STATEMENT, NodeType.EXPRESSION);
return new Branch(NodeType.LAMBDA_EXPRESSION, args, op, rhs);
}
case NodeType.SIMPLE_EXPRESSION: {
Node lhs = parseAny(walker, recursion + 1,
NodeType.TYPE_NAMED_LAMBDA_EXPRESSION,
NodeType.SUPER,
NodeType.THIS_EXPRESSION,
NodeType.OUTER_SUPER_CONSTRUCTOR_CALL_EXPRESSION, // A weird edge-case
NodeType.OUTER_THIS_EXPRESSION,
NodeType.TYPE_EXPRESSION,
NodeType.LITERAL_EXPRESSION,
NodeType.BRACED_EXPRESSION,
NodeType.GENERIC_REFERENCE_EXPRESSION,
NodeType.REFERENCE_EXPRESSION,
NodeType.NEW_EXPRESSION);
boolean done = false;
while (lhs != null && !done && !walker.isAtEnd() &&
(walker.peek().is(TokenType.OPERATOR, "[")
|| walker.peek().is(TokenType.OPERATOR, ".")
|| walker.peek().is(TokenType.OPERATOR, "::")
|| walker.peek().is(TokenType.OPERATOR, "("))) {
if ((lhs.getNodeType() == NodeType.REFERENCE_EXPRESSION || lhs.getNodeType() == NodeType.GENERIC_REFERENCE_EXPRESSION) && walker.peek().is(TokenType.OPERATOR, "(")) {
lhs = new Branch(NodeType.AUTOMATIC_METHOD_CALL_EXPRESSION,
lhs,
parseInner(walker, recursion + 1, NodeType.ARGUMENTS));
} else if (lhs.getNodeType() == NodeType.SUPER && walker.peek().is(TokenType.OPERATOR, "(")) {
lhs = new Branch(NodeType.SUPER_CONSTRUCTOR_CALL_EXPRESSION,
lhs,
parseInner(walker, recursion + 1, NodeType.ARGUMENTS));
} else if (lhs.getNodeType() == NodeType.THIS_EXPRESSION && walker.peek().is(TokenType.OPERATOR, "(")) {
lhs = new Branch(NodeType.THIS_CONSTRUCTOR_CALL_EXPRESSION,
lhs,
parseInner(walker, recursion + 1, NodeType.ARGUMENTS));
} else if (walker.peek().is(TokenType.OPERATOR, "::")) {
Node dcol = parseInner(walker, recursion + 1, NodeType.DOUBLECOLON);
Node nam = parseToken(walker, recursion + 1, Language.Key.NEW); //TokenType.KEYWORD, "new");
if (nam == null) {
nam = expectAny(walker, recursion + 1, NodeType.NAME);
}
lhs = new Branch(NodeType.NAMED_LAMBDA_EXPRESSION,
lhs,
dcol,
nam);
} else if (walker.peek().is(TokenType.OPERATOR, ".")) {
boolean isThis = lhs.getNodeType() == NodeType.THIS_EXPRESSION;
boolean isSuper = lhs.getNodeType() == NodeType.SUPER;
Node dot = parseInner(walker, recursion + 1, NodeType.DOT);
Node specialNew = parseAny(walker, recursion + 1, NodeType.NEW_EXPRESSION);
if (specialNew != null) {
lhs = new Branch(NodeType.SPECIAL_NEW_EXPRESSION,
lhs,
dot,
specialNew);
} else {
Node nam = expectAny(walker, recursion + 1, NodeType.NAME, NodeType.THIS_EXPRESSION, NodeType.GENERIC_REFERENCE_NAME);
if (walker.peek().is(TokenType.OPERATOR, "(")) {
lhs = new Branch(isThis ? NodeType.THIS_METHOD_CALL_EXPRESSION : (isSuper ? NodeType.SUPER_METHOD_CALL_EXPRESSION : NodeType.NORMAL_METHOD_CALL_EXPRESSION),
lhs,
dot,
nam,
parseInner(walker, recursion + 1, NodeType.ARGUMENTS));
} else {
lhs = new Branch(/*isThis ? NodeType.THIS_REFERENCE_EXPRESSION : (isSuper ? NodeType.SUPER_REFERENCE_EXPRESSION : */ (NodeType.SUBREFERENCE_EXPRESSION),
lhs,
dot,
nam);
}
}
} else if (lhs.getNodeType() != NodeType.SUPER && lhs.getNodeType() != NodeType.THIS_EXPRESSION && walker.peek().is(TokenType.OPERATOR, "[")) {
Node open = parseInner(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE);
/*if (walker.peek().is(TokenType.OPERATOR, "]")) {
//ScanWalker pos = walker.clone();
Node close = parseInner(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE);
lhs = new Branch(NodeType.SPECIAL_ARRAY_TYPE_EXPRESSION, open, close);
} else {*/
lhs = new Branch(NodeType.ARRAY_INDEX_EXPRESSION,
lhs,
open,
expectAny(walker, recursion + 1, NodeType.EXPRESSION),
expectAny(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE));
//}
} else {
done = true;
}
}
return lhs;
}
case NodeType.TYPE_NAMED_LAMBDA_EXPRESSION: {
Node typ = parseAny(walker, recursion + 1, NodeType.TYPE);
if (typ == null) {
return null;
}
Node dcol = parseAny(walker, recursion + 1, NodeType.DOUBLECOLON);
if (dcol == null) {
return null;
}
Node nam = parseToken(walker, recursion + 1, Language.Key.NEW); //TokenType.KEYWORD, "new");
if (nam == null) {
nam = expectAny(walker, recursion + 1, NodeType.NAME);
}
return new Branch(NodeType.TYPE_NAMED_LAMBDA_EXPRESSION, typ, dcol, nam);
}
case NodeType.NEW_EXPRESSION: {
Node keyword = parseToken(walker, recursion + 1, Language.Key.NEW); //TokenType.KEYWORD, "new");
if (keyword == null) {
return null;
} else {
Node typ = expectAny(walker, recursion + 1, NodeType.TYPE);
if (typ.getNodeType() == NodeType.TYPE && ((Branch)typ).getSubnode(0).getNodeType() == NodeType.ARRAY_TYPE) {
return new Branch(NodeType.NEW_INITIALISED_ARRAY_EXPRESSION,
keyword,
typ,
expectAny(walker, recursion + 1, NodeType.ARRAY_INITIALISER));
}
if (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, "[")) {
Node opener = parseAny(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE);
/*if (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, "]")) {
Node closer = parseAny(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE);
return new Branch(NodeType.NEW_INITIALISED_ARRAY_EXPRESSION,
keyword,
typ,
opener,
closer,
expectAny(walker, recursion + 1, NodeType.ARRAY_INITIALISER));
} else*/ {
return new Branch(NodeType.NEW_CLEARED_ARRAY_EXPRESSION,
keyword,
typ,
opener,
expectAny(walker, recursion + 1, NodeType.EXPRESSION),
expectAny(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE),
expectAny(walker, recursion + 1, NodeType.ARRAY_TYPE_TAIL));
}
} else {
Node args = expectAny(walker, recursion + 1, NodeType.ARGUMENTS);
if (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, "{")) {
return new Branch(NodeType.NEW_CLASS_EXPRESSION,
keyword,
typ,
args,
expectAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE),
parseInner(walker, recursion + 1, NodeType.CLASS_MEMBERS),
expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
} else {
return new Branch(NodeType.NEW_OBJECT_EXPRESSION,
keyword,
typ,
args);
}
/*
return new Branch(NodeType.NEW_OBJECT_EXPRESSION,
keyword,
typ,
expectAny(walker, recursion + 1, NodeType.ARGUMENTS));*/
}
}
}
case NodeType.ARRAY_TYPE_TAIL: {
Node tmp;
Branch result = new Branch(NodeType.ARRAY_TYPE_TAIL);
while ((tmp = parseAny(walker, recursion + 1, NodeType.ARRAY_TYPE_PART)) != null) {
result.append(tmp);
}
return result;
}
case NodeType.ARRAY_TYPE_PART: {
Node open = parseAny(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE);
if (open == null) {
return null;
}
Node close = parseAny(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE);
if (close == null) {
return null;
}
return new Branch(NodeType.ARRAY_TYPE_PART, open, close);
}
case NodeType.UNARY_EXPRESSION: {
Node op = parseInner(walker, recursion + 1, NodeType.UNARY_OPERATOR);
if (op == null) {
Node open = parseInner(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
if (open == null) {
return null;
} else {
Node typ = parseInner(walker, recursion + 1, NodeType.ANDABLE_TYPE);
if (typ == null) {
return null;
} else {
Node close = parseInner(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE);
if (close == null) {
return null;
} else {
// TODO: Should parsing EXPRESSION here really work?
Node expr = parseAny(walker, recursion + 1, NodeType.UNARY_EXPRESSION, NodeType.SIMPLE_EXPRESSION);
if (expr == null) {
return null;
} else {
return new Branch(NodeType.CAST_EXPRESSION, open, typ, close, expr);
}
}
}
}
} else {
Node rhs = parseAny(walker, recursion + 1, NodeType.UNARY_EXPRESSION, NodeType.SIMPLE_EXPRESSION);
if (rhs.getNodeType() == NodeType.STRING_LITERAL_EXPRESSION) {
return null; // XXX This is a bit of a hack to prevent (x) + "str" evaluating as a cast
}
return new Branch(NodeType.UNARY_EXPRESSION,
op,
rhs);
}
}
case NodeType.MULTIPLICATIVE_EXPRESSION: {
Node lhs = parseAny(walker, recursion + 1, NodeType.UNARY_EXPRESSION, NodeType.COUNT_EXPRESSION);
boolean done = false;
while (lhs != null && !walker.isAtEnd() && !done) {
Node op = parseAny(walker, recursion, NodeType.MULTIPLICATIVE_OPERATOR);
if (op == null) {
done = true;
} else {
lhs = new Branch(NodeType.MULTIPLICATIVE_EXPRESSION,
lhs,
op,
expectAny(walker, recursion + 1, NodeType.UNARY_EXPRESSION, NodeType.SIMPLE_EXPRESSION));
}
}
return lhs;
}
case NodeType.ADDITIVE_EXPRESSION: {
Node lhs = parseAny(walker, recursion + 1, NodeType.MULTIPLICATIVE_EXPRESSION);
boolean done = false;
while (lhs != null && !walker.isAtEnd() && !done) {
Node op = parseAny(walker, recursion, NodeType.ADDITIVE_OPERATOR);
if (op == null) {
done = true;
} else {
lhs = new Branch(NodeType.ADDITIVE_EXPRESSION,
lhs,
op,
expectAny(walker, recursion + 1, NodeType.MULTIPLICATIVE_EXPRESSION));
}
}
return lhs;
}
case NodeType.SHIFT_EXPRESSION: {
Node lhs = parseAny(walker, recursion + 1, NodeType.ADDITIVE_EXPRESSION);
boolean done = false;
while (lhs != null && !walker.isAtEnd() && !done) {
Node op = parseAny(walker, recursion, NodeType.SHIFT_OPERATOR);
if (op == null) {
done = true;
} else {
lhs = new Branch(NodeType.SHIFT_EXPRESSION,
lhs,
op,
expectAny(walker, recursion + 1, NodeType.ADDITIVE_EXPRESSION));
}
}
return lhs;
}
case NodeType.COMPARISON_EXPRESSION: {
Node lhs = parseAny(walker, recursion + 1, NodeType.SHIFT_EXPRESSION);
boolean done = false;
while (lhs != null && !walker.isAtEnd() && !done) {
Node op = parseAny(walker, recursion, NodeType.COMPARISON_OPERATOR);
if (op == null) {
done = true;
} else {
lhs = new Branch(NodeType.COMPARISON_EXPRESSION,
lhs,
op,
expectAny(walker, recursion + 1, NodeType.SHIFT_EXPRESSION));
}
}
return lhs;
}
case NodeType.INSTANCEOF_EXPRESSION: {
Node lhs = parseAny(walker, recursion + 1, NodeType.COMPARISON_EXPRESSION);
boolean done = false;
while (lhs != null && !walker.isAtEnd() && !done) {
Node op = parseToken(walker, recursion + 1, Language.Key.INSTANCEOF); //TokenType.KEYWORD, "instanceof");
if (op == null) {
done = true;
} else {
lhs = new Branch(NodeType.INSTANCEOF_EXPRESSION,
lhs,
op,
expectAny(walker, recursion + 1, NodeType.TYPE));
}
}
return lhs;
}
case NodeType.EQUALITY_EXPRESSION: {
Node lhs = parseAny(walker, recursion + 1, NodeType.INSTANCEOF_EXPRESSION);
boolean done = false;
while (lhs != null && !walker.isAtEnd() && !done) {
Node op = parseAny(walker, recursion, NodeType.EQUALITY_OPERATOR);
if (op == null) {
done = true;
} else {
lhs = new Branch(NodeType.EQUALITY_EXPRESSION,
lhs,
op,
expectAny(walker, recursion + 1, NodeType.INSTANCEOF_EXPRESSION));
}
}
return lhs;
}
/*case NodeType.LOGICAL_EXPRESSION: {
Node lhs = parseAny(walker, recursion + 1, NodeType.EQUALITY_EXPRESSION);
boolean done = false;
while (lhs != null && !walker.isAtEnd() && !done) {
Node op = parseAny(walker, recursion, NodeType.LOGICAL_OPERATOR);
if (op == null) {
done = true;
} else {
lhs = new Branch(NodeType.LOGICAL_EXPRESSION,
lhs,
op,
expectAny(walker, recursion + 1, NodeType.EQUALITY_EXPRESSION));
}
}
return lhs;
}*/
case NodeType.BITWISE_AND_EXPRESSION:
return parseSimpleBinop(walker, recursion,
NodeType.BITWISE_AND_EXPRESSION,
NodeType.BITWISE_AND_OPERATOR,
NodeType.EQUALITY_EXPRESSION);
case NodeType.BITWISE_XOR_EXPRESSION:
return parseSimpleBinop(walker, recursion,
NodeType.BITWISE_XOR_EXPRESSION,
NodeType.BITWISE_XOR_OPERATOR,
NodeType.BITWISE_AND_EXPRESSION);
case NodeType.BITWISE_OR_EXPRESSION:
return parseSimpleBinop(walker, recursion,
NodeType.BITWISE_OR_EXPRESSION,
NodeType.BITWISE_OR_OPERATOR,
NodeType.BITWISE_XOR_EXPRESSION);
case NodeType.LOGICAL_AND_EXPRESSION:
return parseSimpleBinop(walker, recursion,
NodeType.LOGICAL_AND_EXPRESSION,
NodeType.LOGICAL_AND_OPERATOR,
NodeType.BITWISE_OR_EXPRESSION);
case NodeType.LOGICAL_OR_EXPRESSION:
return parseSimpleBinop(walker, recursion,
NodeType.LOGICAL_OR_EXPRESSION,
NodeType.LOGICAL_OR_OPERATOR,
NodeType.LOGICAL_AND_EXPRESSION);
case NodeType.CONDITIONAL_EXPRESSION: {
Node cond = parseAny(walker, recursion + 1, NodeType.LOGICAL_OR_EXPRESSION /*NodeType.LOGICAL_EXPRESSION*/); // TODO: Change to only bracketed expression
if (cond == null) {
return null;
}
Node q = parseToken(walker, recursion + 1, TokenType.OPERATOR, "?");
if (q == null) {
return cond;
}
Node opt1 = parseAny(walker, recursion + 1, NodeType.LAMBDA_EXPRESSION, NodeType.CONDITIONAL_EXPRESSION, NodeType.LOGICAL_OR_EXPRESSION);
Node c = parseToken(walker, recursion + 1, TokenType.OPERATOR, ":"); // TODO: Expect
Node opt2 = parseAny(walker, recursion + 1, NodeType.LAMBDA_EXPRESSION, NodeType.CONDITIONAL_EXPRESSION, NodeType.LOGICAL_OR_EXPRESSION);
return new Branch(NodeType.CONDITIONAL_EXPRESSION, cond, q, opt1, c, opt2);
}
case NodeType.ASSIGNMENT_EXPRESSION: {
Node lhs = parseInner(walker, recursion + 1, NodeType.SIMPLE_EXPRESSION);
if (lhs != null && !walker.isAtEnd() && (lhs.getNodeType() == NodeType.REFERENCE_EXPRESSION || lhs.getNodeType() == NodeType.SUBREFERENCE_EXPRESSION || lhs.getNodeType() == NodeType.ARRAY_INDEX_EXPRESSION)) {
Node op = parseInner(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR);
if (op == null) {
//op = parseInner(walker, recursion + 1, NodeType.COUNT_OPERATOR);
//if (op == null) {
return null;
//} else {
//return new Branch(NodeType.COUNT_EXPRESSION, lhs, op);
//}
} else {
return new Branch(NodeType.ASSIGNMENT_EXPRESSION,
lhs,
op,
expectAny(walker, recursion + 1, NodeType.EXPRESSION));
}
} else {
return null;
}
}
case NodeType.COUNT_EXPRESSION: {
Node lhs = parseInner(walker, recursion + 1, NodeType.SIMPLE_EXPRESSION);
if (lhs != null && !walker.isAtEnd()/* && (lhs.getNodeType() == NodeType.REFERENCE_EXPRESSION || lhs.getNodeType() == NodeType.SUBREFERENCE_EXPRESSION || lhs.getNodeType() == NodeType.ARRAY_INDEX_EXPRESSION)*/) {
Node op = parseInner(walker, recursion + 1, NodeType.COUNT_OPERATOR);
if (op == null) {
return lhs;
} else {
return new Branch(NodeType.COUNT_EXPRESSION, lhs, op);
}
} else {
return lhs;
}
}
case NodeType.ASSIGNMENT_OPERATOR: {
Node result = null;
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "+=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "-=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "*=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "/=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "%=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "&=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "|=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "^=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "<<=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, ">>>=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, ">>=");
return result;
}
case NodeType.COUNT_OPERATOR: {
Node result = null;
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COUNT_OPERATOR, TokenType.OPERATOR, "--");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COUNT_OPERATOR, TokenType.OPERATOR, "++");
return result;
}
case NodeType.UNARY_OPERATOR: {
Node result = parseInner(walker, recursion + 1, NodeType.COUNT_OPERATOR);
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.UNARY_OPERATOR, TokenType.OPERATOR, "-");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.UNARY_OPERATOR, TokenType.OPERATOR, "+");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.UNARY_OPERATOR, TokenType.OPERATOR, "!");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.UNARY_OPERATOR, TokenType.OPERATOR, "~");
return result;
}
case NodeType.MULTIPLICATIVE_OPERATOR: {
Node result = null;
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.MULTIPLICATIVE_OPERATOR, TokenType.OPERATOR, "*");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.MULTIPLICATIVE_OPERATOR, TokenType.OPERATOR, "/");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.MULTIPLICATIVE_OPERATOR, TokenType.OPERATOR, "%");
//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.MULTIPLICATIVE_OPERATOR, TokenType.OPERATOR, "&");
//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.MULTIPLICATIVE_OPERATOR, TokenType.OPERATOR, "|");
//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.MULTIPLICATIVE_OPERATOR, TokenType.OPERATOR, "^");
return result;
}
case NodeType.ADDITIVE_OPERATOR: {
Node result = null;
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ADDITIVE_OPERATOR, TokenType.OPERATOR, "+");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ADDITIVE_OPERATOR, TokenType.OPERATOR, "-");
//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ADDITIVE_OPERATOR, TokenType.OPERATOR, "&");
//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ADDITIVE_OPERATOR, TokenType.OPERATOR, "|");
return result;
}
case NodeType.SHIFT_OPERATOR: {
Node result = null;
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.SHIFT_OPERATOR, TokenType.OPERATOR, "<<");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.SHIFT_OPERATOR, TokenType.OPERATOR, ">>");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.SHIFT_OPERATOR, TokenType.OPERATOR, ">>>");
// Special handling of combined ">" characters is required for generics
result = result != null ? result : parseSpecialTokenBranch(walker, recursion + 1, NodeType.SHIFT_OPERATOR, TokenType.OPERATOR, ">", 3);
result = result != null ? result : parseSpecialTokenBranch(walker, recursion + 1, NodeType.SHIFT_OPERATOR, TokenType.OPERATOR, ">", 2);
return result;
}
case NodeType.COMPARISON_OPERATOR: {
Node result = null;
// Specifically fail if we can parse (especially muliple ">" characters) as a shift operator instead
Node shiftop = parseAny(walker, recursion + 1, NodeType.SHIFT_OPERATOR);
if (shiftop != null) {
return null;
}
//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COMPARISON_OPERATOR, TokenType.OPERATOR, "==");
//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COMPARISON_OPERATOR, TokenType.OPERATOR, "!=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COMPARISON_OPERATOR, TokenType.OPERATOR, "<");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COMPARISON_OPERATOR, TokenType.OPERATOR, "<=");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COMPARISON_OPERATOR, TokenType.OPERATOR, ">");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COMPARISON_OPERATOR, TokenType.OPERATOR, ">=");
return result;
}
case NodeType.EQUALITY_OPERATOR: {
Node result = null;
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.EQUALITY_OPERATOR, TokenType.OPERATOR, "==");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.EQUALITY_OPERATOR, TokenType.OPERATOR, "!=");
return result;
}
case NodeType.BITWISE_AND_OPERATOR:
return parseTokenBranch(walker, recursion + 1,
NodeType.BITWISE_AND_OPERATOR, "&");
case NodeType.BITWISE_XOR_OPERATOR:
return parseTokenBranch(walker, recursion + 1,
NodeType.BITWISE_XOR_OPERATOR, "^");
case NodeType.BITWISE_OR_OPERATOR:
return parseTokenBranch(walker, recursion + 1,
NodeType.BITWISE_AND_OPERATOR, "|");
case NodeType.LOGICAL_AND_OPERATOR:
return parseTokenBranch(walker, recursion + 1,
NodeType.LOGICAL_AND_OPERATOR, "&&");
case NodeType.LOGICAL_OR_OPERATOR:
return parseTokenBranch(walker, recursion + 1,
NodeType.LOGICAL_OR_OPERATOR, "||");
case NodeType.LOGICAL_OPERATOR: {
Node result = null;
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.LOGICAL_OPERATOR, TokenType.OPERATOR, "&&");
result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.LOGICAL_OPERATOR, TokenType.OPERATOR, "||");
return result;
}
case NodeType.EXPRESSION:
return parseAny(walker, recursion + 1,
NodeType.LAMBDA_EXPRESSION,
NodeType.ASSIGNMENT_EXPRESSION,
NodeType.CONDITIONAL_EXPRESSION,
NodeType.LOGICAL_OR_EXPRESSION);
case NodeType.EXPRESSIONS:
return parseList(walker, recursion + 1, NodeType.EXPRESSIONS, NodeType.COMMA, false, NodeType.EXPRESSION);
case NodeType.ARRAY_EXPRESSIONS:
return parseList(walker, recursion + 1, NodeType.ARRAY_EXPRESSIONS, NodeType.COMMA, true, NodeType.ARRAY_INITIALISER, NodeType.EXPRESSION);
case NodeType.MODIFIER_EXPRESSIONS:
return parseList(walker, recursion + 1, NodeType.MODIFIER_EXPRESSIONS, NodeType.COMMA, true, NodeType.ARRAY_INITIALISER, NodeType.SIMPLE_ASSIGN, NodeType.EXPRESSION);
case NodeType.SIMPLE_ASSIGN: {
Node nam = parseAny(walker, recursion + 1, NodeType.NAME);
if (nam == null) {
return null;
}
Node eq = parseToken(walker, recursion + 1, TokenType.OPERATOR, "=");
if (eq == null) {
return null;
}
return new Branch(NodeType.SIMPLE_ASSIGN,
nam,
eq,
expectAny(walker, recursion + 1, NodeType.ARRAY_INITIALISER, NodeType.EXPRESSION));
}
case NodeType.SIMPLE_GENERIC_WILDCARD:
return parseTokenBranch(walker, recursion + 1, NodeType.SIMPLE_GENERIC_WILDCARD, TokenType.OPERATOR, "?");
case NodeType.EXTENDED_GENERIC_WILDCARD: {
Node start = parseTokenBranch(walker, recursion + 1, NodeType.QUESTIONMARK, TokenType.OPERATOR, "?");
if (start == null) {
return null;
}
Node ext = parseToken(walker, recursion + 1, Language.Key.EXTENDS); //TokenType.KEYWORD, "extends");
if (ext == null) {
return null;
}
Node typ = expectAny(walker, recursion + 1, NodeType.ANDABLE_TYPE);
return new Branch(NodeType.EXTENDED_GENERIC_WILDCARD, start, ext, typ);
}
case NodeType.ANDABLE_TYPE: {
ScanWalker pos = walker.clone();
Node firstType = parseAny(walker, recursion + 1, NodeType.TYPE);
if (firstType == null) {
return null;
}
walker.reset(pos);
ScanWalker.recycle(pos);
return parseList(walker, recursion + 1, NodeType.ANDABLE_TYPE, NodeType.SINGLE_AND, false, NodeType.TYPE);
}
case NodeType.SINGLE_AND: {
return parseTokenBranch(walker, recursion + 1, NodeType.SINGLE_AND, TokenType.OPERATOR, "&");
}
case NodeType.SUPER_GENERIC_WILDCARD: {
Node start = parseTokenBranch(walker, recursion + 1, NodeType.QUESTIONMARK, TokenType.OPERATOR, "?");
if (start == null) {
return null;
}
Node sup = parseToken(walker, recursion + 1, Language.Key.SUPER); //TokenType.KEYWORD, "super");
if (sup == null) {
return null;
}
Node typ = expectAny(walker, recursion + 1, NodeType.TYPE);
return new Branch(NodeType.SUPER_GENERIC_WILDCARD, start, sup, typ);
}
case NodeType.GENERIC_VALUE:
//return new Branch(NodeType.GENERIC_VALUE,
return parseAny(walker, recursion + 1,
NodeType.TYPE,
NodeType.EXTENDED_GENERIC_WILDCARD,
NodeType.SUPER_GENERIC_WILDCARD,
NodeType.SIMPLE_GENERIC_WILDCARD);//);
case NodeType.GENERIC_EXPRESSIONS:
return parseList(walker, recursion + 1, NodeType.GENERIC_EXPRESSIONS, NodeType.COMMA, false, NodeType.GENERIC_VALUE);
case NodeType.BRACED_EXPRESSION: {
Node start = parseInner(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
if (start == null) {
return null;
} else {
return new Branch(NodeType.BRACED_EXPRESSION,
start,
expectAny(walker, recursion + 1, NodeType.EXPRESSION),
expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE));
}
}
case NodeType.ARGUMENTS: {
Node start = parseInner(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
if (start == null) {
return null;
} else {
return new Branch(NodeType.ARGUMENTS,
start,
parseInner(walker, recursion + 1, NodeType.EXPRESSIONS),
expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE));
}
}
case NodeType.ARRAY_INITIALISER: {
Node start = parseInner(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE);
if (start == null) {
return null;
} else {
return new Branch(NodeType.ARRAY_INITIALISER,
start,
parseInner(walker, recursion + 1, NodeType.ARRAY_EXPRESSIONS),
expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
}
}
case NodeType.GENERIC_ARGUMENTS: {
Node start = parseInner(walker, recursion + 1, NodeType.OPEN_ANGLE_BRACE);
if (start == null) {
return null;
} else {
Node middle = parseAny(walker, recursion + 1, NodeType.GENERIC_EXPRESSIONS);
if (middle == null) {
return null;
}
Node end = parseAny(walker, recursion + 1, NodeType.CLOSE_ANGLE_BRACE);
if (end == null) {
return null;
}
return new Branch(NodeType.GENERIC_ARGUMENTS,
start,
middle,
end);
}
}
case NodeType.SLOTS:
return parseList(walker, recursion + 1, NodeType.SLOTS, NodeType.COMMA, false, NodeType.INITIALISED_SLOT);
case NodeType.INITIALISED_SLOT: {
Node n = parseInner(walker, recursion + 1, NodeType.INDEXED_NAME);
if (n == null) {
return null;
} else {
Token eq = parseToken(walker, recursion + 1, TokenType.OPERATOR, "=");
if (eq == null) {
return new Branch(NodeType.UNINITIALISED_SLOT, n);
} else {
return new Branch(NodeType.INITIALISED_SLOT, n, eq, expectAny(walker, recursion + 1, NodeType.EXPRESSION, NodeType.ARRAY_INITIALISER));
}
}
}
case NodeType.SIMPLE_ARGUMENT_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
if (t == null) {
return null;
} else {
Node n = parseInner(walker, recursion + 1, NodeType.INDEXED_NAME);
if (n == null) {
return null;
} else {
return new Branch(NodeType.SIMPLE_ARGUMENT_DECLARATION, mods, t, n);
}
}
}
case NodeType.LAZY_ARGUMENT_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node t = parseInner(walker, recursion + 1, NodeType.LAZY_TYPE);
if (t == null) {
return null;
} else {
Node n = parseInner(walker, recursion + 1, NodeType.INDEXED_NAME);
if (n == null) {
return null;
} else {
return new Branch(NodeType.SIMPLE_ARGUMENT_DECLARATION, mods, t, n);
}
}
}
case NodeType.LAZY_TYPE: {
Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
if (t == null) {
return null;
}
Node bar = null;
Branch result = null;
while ((bar = parseToken(walker, recursion + 1, TokenType.OPERATOR, "|")) != null) {
Node nextt = parseInner(walker, recursion + 1, NodeType.TYPE);
if (nextt == null) {
return null;
}
if (result == null) {
result = new Branch(NodeType.LAZY_TYPE);
result.append(t);
}
result.append(bar);
result.append(nextt);
}
return result; // Will be null unless one or more "|" followed by another type was found
}
case NodeType.VARIABLE_ARGUMENT_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
if (t == null) {
return null;
} else {
Node dots = parseToken(walker, recursion + 1, TokenType.OPERATOR, "...");
if (dots == null) {
return null;
} else {
Node n = parseInner(walker, recursion + 1, NodeType.INDEXED_NAME);
if (n == null) {
return null;
} else {
return new Branch(NodeType.VARIABLE_ARGUMENT_DECLARATION, mods, t, dots, n);
}
}
}
}
case NodeType.SIMPLE_GENERIC_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node n = parseInner(walker, recursion + 1, NodeType.NAME);
if (n == null) {
return null;
} else {
return new Branch(NodeType.SIMPLE_GENERIC_DECLARATION, mods, n);
}
}
case NodeType.SIMPLE_EXTENDED_GENERIC_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node n = parseInner(walker, recursion + 1, NodeType.NAME);
if (n == null) {
return null;
}
Node ext = parseToken(walker, recursion + 1, Language.Key.EXTENDS); //TokenType.KEYWORD, "extends");
if (ext == null) {
return null;
}
Node typ = expectAny(walker, recursion + 1, NodeType.ANDABLE_TYPE);
return new Branch(NodeType.SIMPLE_EXTENDED_GENERIC_DECLARATION, mods, n, ext, typ);
}
case NodeType.SIMPLE_TYPED_GENERIC_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
if (t == null) {
return null;
} else {
Node n = parseInner(walker, recursion + 1, NodeType.NAME);
if (n == null) {
return null;
} else {
return new Branch(NodeType.SIMPLE_TYPED_GENERIC_DECLARATION, mods, t, n);
}
}
}
case NodeType.VARIABLE_GENERIC_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node dots = parseToken(walker, recursion + 1, TokenType.OPERATOR, "...");
if (dots == null) {
return null;
} else {
Node n = parseInner(walker, recursion + 1, NodeType.NAME);
if (n == null) {
return null;
} else {
return new Branch(NodeType.VARIABLE_GENERIC_DECLARATION, mods, dots, n);
}
}
}
case NodeType.VARIABLE_TYPED_GENERIC_DECLARATION: {
Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
if (t == null) {
return null;
} else {
Node dots = parseToken(walker, recursion + 1, TokenType.OPERATOR, "...");
if (dots == null) {
return null;
} else {
Node n = parseInner(walker, recursion + 1, NodeType.NAME);
if (n == null) {
return null;
} else {
return new Branch(NodeType.VARIABLE_TYPED_GENERIC_DECLARATION, mods, t, dots, n);
}
}
}
}
case NodeType.UNIT:
return new Branch(NodeType.UNIT,
parseInner(walker, recursion + 1, NodeType.PACKAGE_DECLARATION),
parseList(walker, recursion + 1, NodeType.IMPORT_DECLARATIONS, null, false,
NodeType.IMPORT_DECLARATION),
parseInner(walker, recursion + 1, NodeType.TYPE_DECLARATIONS),
expectAny(walker, recursion + 1, NodeType.EOF));
default:
//System.out.println("TODO: Parsing of " + type);
//return new Branch(NodeType.ERROR_ONLY).annotate(ErrorType.INTERNAL_ERROR, "TODO: Parsing of " + type);
return null;
}
}
public Node parseSafely(ScanWalker walker, int recursion, NodeType type) {
checkRecursion(walker, recursion);
ScanWalker w = walker.clone();
Node r = parseInner(walker, recursion + 1, type);
if (r != null) {
walker.reset(w);
}
ScanWalker.recycle(w);
return r;
}
public Node parseUnit(Scan scan) {
ScanWalker w = new ScanWalker(scan);
return parseSafely(w, 0, NodeType.UNIT);
}
public void checkRecursion(ScanWalker walker, int recursion) {
if (recursion >= maxRecursion) {
throw new Error("Recursion got too deep around " + walker.peek());
}
}
}
Reference in New Issue Copy Permalink