blob: d2e687907c51df2bef9a755a867c9d0ea9bf2e7b [file] [log] [blame]
ethannicholasb3058bd2016-07-01 08:22:01 -07001/*
2 * Copyright 2016 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
Ethan Nicholas11d53972016-11-28 11:23:23 -05007
ethannicholasb3058bd2016-07-01 08:22:01 -07008#include "stdio.h"
Ethan Nicholasfc994162019-06-06 10:04:27 -04009#include "src/sksl/SkSLASTNode.h"
Mike Klein4b432fa2019-06-06 11:44:05 -050010#include "src/sksl/SkSLParser.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050011#include "src/sksl/ir/SkSLModifiers.h"
12#include "src/sksl/ir/SkSLSymbolTable.h"
13#include "src/sksl/ir/SkSLType.h"
ethannicholasb3058bd2016-07-01 08:22:01 -070014
Ethan Nicholasb93af7e2018-07-24 11:28:52 -040015#ifndef SKSL_STANDALONE
Mike Kleinc0bd9f92019-04-23 12:05:21 -050016#include "include/private/SkOnce.h"
Ethan Nicholasb93af7e2018-07-24 11:28:52 -040017#endif
18
ethannicholasb3058bd2016-07-01 08:22:01 -070019namespace SkSL {
20
ethannicholascad64162016-10-27 10:54:02 -070021#define MAX_PARSE_DEPTH 50
22
23class AutoDepth {
24public:
25 AutoDepth(Parser* p)
26 : fParser(p) {
27 fParser->fDepth++;
28 }
29
30 ~AutoDepth() {
31 fParser->fDepth--;
32 }
33
34 bool checkValid() {
35 if (fParser->fDepth > MAX_PARSE_DEPTH) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -070036 fParser->error(fParser->peek(), String("exceeded max parse depth"));
ethannicholascad64162016-10-27 10:54:02 -070037 return false;
38 }
39 return true;
40 }
41
42private:
43 Parser* fParser;
44};
45
Brian Salomon140f3da2018-08-23 13:51:27 +000046std::unordered_map<String, Parser::LayoutToken>* Parser::layoutTokens;
Ethan Nicholasb93af7e2018-07-24 11:28:52 -040047
48void Parser::InitLayoutMap() {
Brian Salomon140f3da2018-08-23 13:51:27 +000049 layoutTokens = new std::unordered_map<String, LayoutToken>;
Brian Salomon23356442018-11-30 15:33:19 -050050 #define TOKEN(name, text) (*layoutTokens)[text] = LayoutToken::name
Ethan Nicholasb93af7e2018-07-24 11:28:52 -040051 TOKEN(LOCATION, "location");
52 TOKEN(OFFSET, "offset");
53 TOKEN(BINDING, "binding");
54 TOKEN(INDEX, "index");
55 TOKEN(SET, "set");
56 TOKEN(BUILTIN, "builtin");
57 TOKEN(INPUT_ATTACHMENT_INDEX, "input_attachment_index");
58 TOKEN(ORIGIN_UPPER_LEFT, "origin_upper_left");
59 TOKEN(OVERRIDE_COVERAGE, "override_coverage");
60 TOKEN(BLEND_SUPPORT_ALL_EQUATIONS, "blend_support_all_equations");
61 TOKEN(BLEND_SUPPORT_MULTIPLY, "blend_support_multiply");
62 TOKEN(BLEND_SUPPORT_SCREEN, "blend_support_screen");
63 TOKEN(BLEND_SUPPORT_OVERLAY, "blend_support_overlay");
64 TOKEN(BLEND_SUPPORT_DARKEN, "blend_support_darken");
65 TOKEN(BLEND_SUPPORT_LIGHTEN, "blend_support_lighten");
66 TOKEN(BLEND_SUPPORT_COLORDODGE, "blend_support_colordodge");
67 TOKEN(BLEND_SUPPORT_COLORBURN, "blend_support_colorburn");
68 TOKEN(BLEND_SUPPORT_HARDLIGHT, "blend_support_hardlight");
69 TOKEN(BLEND_SUPPORT_SOFTLIGHT, "blend_support_softlight");
70 TOKEN(BLEND_SUPPORT_DIFFERENCE, "blend_support_difference");
71 TOKEN(BLEND_SUPPORT_EXCLUSION, "blend_support_exclusion");
72 TOKEN(BLEND_SUPPORT_HSL_HUE, "blend_support_hsl_hue");
73 TOKEN(BLEND_SUPPORT_HSL_SATURATION, "blend_support_hsl_saturation");
74 TOKEN(BLEND_SUPPORT_HSL_COLOR, "blend_support_hsl_color");
75 TOKEN(BLEND_SUPPORT_HSL_LUMINOSITY, "blend_support_hsl_luminosity");
76 TOKEN(PUSH_CONSTANT, "push_constant");
77 TOKEN(POINTS, "points");
78 TOKEN(LINES, "lines");
79 TOKEN(LINE_STRIP, "line_strip");
80 TOKEN(LINES_ADJACENCY, "lines_adjacency");
81 TOKEN(TRIANGLES, "triangles");
82 TOKEN(TRIANGLE_STRIP, "triangle_strip");
83 TOKEN(TRIANGLES_ADJACENCY, "triangles_adjacency");
84 TOKEN(MAX_VERTICES, "max_vertices");
85 TOKEN(INVOCATIONS, "invocations");
86 TOKEN(WHEN, "when");
87 TOKEN(KEY, "key");
Michael Ludwiga4275592018-08-31 10:52:47 -040088 TOKEN(TRACKED, "tracked");
Ethan Nicholas78aceb22018-08-31 16:13:58 -040089 TOKEN(CTYPE, "ctype");
Brian Osmanf28e55d2018-10-03 16:35:54 -040090 TOKEN(SKPMCOLOR4F, "SkPMColor4f");
Brian Salomoneca66b32019-06-01 11:18:15 -040091 TOKEN(SKVECTOR4, "SkVector4");
Ethan Nicholas78aceb22018-08-31 16:13:58 -040092 TOKEN(SKRECT, "SkRect");
93 TOKEN(SKIRECT, "SkIRect");
94 TOKEN(SKPMCOLOR, "SkPMColor");
Ethan Nicholas65e49ba2019-05-30 14:50:08 -040095 TOKEN(SKMATRIX44, "SkMatrix44");
Ethan Nicholasc1c686b2019-04-02 17:30:23 -040096 TOKEN(BOOL, "bool");
97 TOKEN(INT, "int");
98 TOKEN(FLOAT, "float");
Ethan Nicholasb93af7e2018-07-24 11:28:52 -040099 #undef TOKEN
100}
101
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700102Parser::Parser(const char* text, size_t length, SymbolTable& types, ErrorReporter& errors)
103: fText(text)
104, fPushback(Token::INVALID, -1, -1)
ethannicholasb3058bd2016-07-01 08:22:01 -0700105, fTypes(types)
106, fErrors(errors) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700107 fLexer.start(text, length);
Brian Salomon3b83afe2018-08-23 11:04:36 -0400108 static const bool layoutMapInitialized = []{ return (void)InitLayoutMap(), true; }();
109 (void) layoutMapInitialized;
ethannicholasb3058bd2016-07-01 08:22:01 -0700110}
111
Ethan Nicholasfc994162019-06-06 10:04:27 -0400112#define CREATE_NODE(result, ...) \
113 ASTNode::ID result(fFile->fNodes.size()); \
114 fFile->fNodes.emplace_back(&fFile->fNodes, __VA_ARGS__)
115
116#define RETURN_NODE(...) \
117 do { \
118 CREATE_NODE(result, __VA_ARGS__); \
119 return result; \
120 } while (false)
121
122#define CREATE_CHILD(child, target, ...) \
123 CREATE_NODE(child, __VA_ARGS__); \
124 fFile->fNodes[target.fValue].addChild(child)
125
126#define CREATE_EMPTY_CHILD(target) \
127 do { \
128 ASTNode::ID child(fFile->fNodes.size()); \
129 fFile->fNodes.emplace_back(); \
130 fFile->fNodes[target.fValue].addChild(child); \
131 } while (false)
132
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400133/* (directive | section | declaration)* END_OF_FILE */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400134std::unique_ptr<ASTFile> Parser::file() {
135 fFile.reset(new ASTFile());
136 CREATE_NODE(result, 0, ASTNode::Kind::kFile);
137 fFile->fRoot = result;
ethannicholasb3058bd2016-07-01 08:22:01 -0700138 for (;;) {
139 switch (this->peek().fKind) {
140 case Token::END_OF_FILE:
Ethan Nicholasfc994162019-06-06 10:04:27 -0400141 return std::move(fFile);
ethannicholasb3058bd2016-07-01 08:22:01 -0700142 case Token::DIRECTIVE: {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400143 ASTNode::ID dir = this->directive();
144 if (fErrors.errorCount()) {
145 return nullptr;
146 }
147 if (dir) {
148 getNode(result).addChild(dir);
ethannicholasb3058bd2016-07-01 08:22:01 -0700149 }
150 break;
151 }
Ethan Nicholas762466e2017-06-29 10:03:38 -0400152 case Token::SECTION: {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400153 ASTNode::ID section = this->section();
154 if (fErrors.errorCount()) {
155 return nullptr;
156 }
Ethan Nicholas762466e2017-06-29 10:03:38 -0400157 if (section) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400158 getNode(result).addChild(section);
Ethan Nicholas762466e2017-06-29 10:03:38 -0400159 }
160 break;
161 }
ethannicholasb3058bd2016-07-01 08:22:01 -0700162 default: {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400163 ASTNode::ID decl = this->declaration();
164 if (fErrors.errorCount()) {
165 return nullptr;
ethannicholasb3058bd2016-07-01 08:22:01 -0700166 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400167 if (decl) {
168 getNode(result).addChild(decl);
169 }
ethannicholasb3058bd2016-07-01 08:22:01 -0700170 }
171 }
172 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400173 return std::move(fFile);
ethannicholasb3058bd2016-07-01 08:22:01 -0700174}
175
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700176Token Parser::nextRawToken() {
177 if (fPushback.fKind != Token::INVALID) {
178 Token result = fPushback;
179 fPushback.fKind = Token::INVALID;
ethannicholasb3058bd2016-07-01 08:22:01 -0700180 return result;
181 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700182 Token result = fLexer.next();
183 return result;
Ethan Nicholas762466e2017-06-29 10:03:38 -0400184}
185
186Token Parser::nextToken() {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700187 Token token = this->nextRawToken();
188 while (token.fKind == Token::WHITESPACE || token.fKind == Token::LINE_COMMENT ||
189 token.fKind == Token::BLOCK_COMMENT) {
190 token = this->nextRawToken();
191 }
Ethan Nicholas762466e2017-06-29 10:03:38 -0400192 return token;
ethannicholasb3058bd2016-07-01 08:22:01 -0700193}
194
195void Parser::pushback(Token t) {
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400196 SkASSERT(fPushback.fKind == Token::INVALID);
Ethan Nicholas08b79b72017-08-14 10:35:37 -0400197 fPushback = std::move(t);
ethannicholasb3058bd2016-07-01 08:22:01 -0700198}
199
200Token Parser::peek() {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700201 if (fPushback.fKind == Token::INVALID) {
Brian Osman634624a2017-08-15 11:14:30 -0400202 fPushback = this->nextToken();
203 }
ethannicholasb3058bd2016-07-01 08:22:01 -0700204 return fPushback;
205}
206
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400207bool Parser::checkNext(Token::Kind kind, Token* result) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700208 if (fPushback.fKind != Token::INVALID && fPushback.fKind != kind) {
Brian Osman634624a2017-08-15 11:14:30 -0400209 return false;
210 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400211 Token next = this->nextToken();
212 if (next.fKind == kind) {
213 if (result) {
214 *result = next;
215 }
216 return true;
217 }
Ethan Nicholas08b79b72017-08-14 10:35:37 -0400218 this->pushback(std::move(next));
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400219 return false;
220}
Ethan Nicholas9e1138d2016-11-21 10:39:35 -0500221
222bool Parser::expect(Token::Kind kind, const char* expected, Token* result) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700223 Token next = this->nextToken();
224 if (next.fKind == kind) {
225 if (result) {
Brian Osman634624a2017-08-15 11:14:30 -0400226 *result = std::move(next);
ethannicholasb3058bd2016-07-01 08:22:01 -0700227 }
228 return true;
229 } else {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700230 this->error(next, "expected " + String(expected) + ", but found '" +
231 this->text(next) + "'");
ethannicholasb3058bd2016-07-01 08:22:01 -0700232 return false;
233 }
234}
235
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700236StringFragment Parser::text(Token token) {
237 return StringFragment(fText + token.fOffset, token.fLength);
Ethan Nicholas9e1138d2016-11-21 10:39:35 -0500238}
239
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700240void Parser::error(Token token, String msg) {
241 this->error(token.fOffset, msg);
ethannicholasb3058bd2016-07-01 08:22:01 -0700242}
243
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700244void Parser::error(int offset, String msg) {
245 fErrors.error(offset, msg);
246}
247
248bool Parser::isType(StringFragment name) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700249 return nullptr != fTypes[name];
250}
251
Ethan Nicholas11d53972016-11-28 11:23:23 -0500252/* DIRECTIVE(#version) INT_LITERAL ("es" | "compatibility")? |
ethannicholas5961bc92016-10-12 06:39:56 -0700253 DIRECTIVE(#extension) IDENTIFIER COLON IDENTIFIER */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400254ASTNode::ID Parser::directive() {
ethannicholasb3058bd2016-07-01 08:22:01 -0700255 Token start;
256 if (!this->expect(Token::DIRECTIVE, "a directive", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400257 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700258 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700259 StringFragment text = this->text(start);
Ethan Nicholasfc994162019-06-06 10:04:27 -0400260 if (text == "#extension") {
ethannicholasb3058bd2016-07-01 08:22:01 -0700261 Token name;
262 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400263 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700264 }
265 if (!this->expect(Token::COLON, "':'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400266 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700267 }
268 // FIXME: need to start paying attention to this token
269 if (!this->expect(Token::IDENTIFIER, "an identifier")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400270 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700271 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400272 RETURN_NODE(start.fOffset, ASTNode::Kind::kExtension, this->text(name));
ethannicholasb3058bd2016-07-01 08:22:01 -0700273 } else {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700274 this->error(start, "unsupported directive '" + this->text(start) + "'");
Ethan Nicholasfc994162019-06-06 10:04:27 -0400275 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700276 }
277}
278
Ethan Nicholas762466e2017-06-29 10:03:38 -0400279/* SECTION LBRACE (LPAREN IDENTIFIER RPAREN)? <any sequence of tokens with balanced braces>
280 RBRACE */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400281ASTNode::ID Parser::section() {
Ethan Nicholas762466e2017-06-29 10:03:38 -0400282 Token start;
283 if (!this->expect(Token::SECTION, "a section token", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400284 return ASTNode::ID::Invalid();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400285 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400286 StringFragment argument;
Ethan Nicholas762466e2017-06-29 10:03:38 -0400287 if (this->peek().fKind == Token::LPAREN) {
288 this->nextToken();
289 Token argToken;
290 if (!this->expect(Token::IDENTIFIER, "an identifier", &argToken)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400291 return ASTNode::ID::Invalid();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400292 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700293 argument = this->text(argToken);
Ethan Nicholas762466e2017-06-29 10:03:38 -0400294 if (!this->expect(Token::RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400295 return ASTNode::ID::Invalid();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400296 }
297 }
298 if (!this->expect(Token::LBRACE, "'{'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400299 return ASTNode::ID::Invalid();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400300 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400301 StringFragment text;
302 Token codeStart = this->nextRawToken();
303 size_t startOffset = codeStart.fOffset;
304 this->pushback(codeStart);
305 text.fChars = fText + startOffset;
Ethan Nicholas762466e2017-06-29 10:03:38 -0400306 int level = 1;
307 for (;;) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700308 Token next = this->nextRawToken();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400309 switch (next.fKind) {
310 case Token::LBRACE:
311 ++level;
312 break;
313 case Token::RBRACE:
314 --level;
315 break;
316 case Token::END_OF_FILE:
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700317 this->error(start, "reached end of file while parsing section");
Ethan Nicholasfc994162019-06-06 10:04:27 -0400318 return ASTNode::ID::Invalid();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400319 default:
320 break;
321 }
322 if (!level) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400323 text.fLength = next.fOffset - startOffset;
Ethan Nicholas762466e2017-06-29 10:03:38 -0400324 break;
325 }
Ethan Nicholas762466e2017-06-29 10:03:38 -0400326 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700327 StringFragment name = this->text(start);
328 ++name.fChars;
329 --name.fLength;
Ethan Nicholasfc994162019-06-06 10:04:27 -0400330 RETURN_NODE(start.fOffset, ASTNode::Kind::kSection,
331 ASTNode::SectionData(name, argument, text));
Ethan Nicholas762466e2017-06-29 10:03:38 -0400332}
333
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500334/* ENUM CLASS IDENTIFIER LBRACE (IDENTIFIER (EQ expression)? (COMMA IDENTIFIER (EQ expression))*)?
335 RBRACE */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400336ASTNode::ID Parser::enumDeclaration() {
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500337 Token start;
338 if (!this->expect(Token::ENUM, "'enum'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400339 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500340 }
341 if (!this->expect(Token::CLASS, "'class'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400342 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500343 }
344 Token name;
345 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400346 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500347 }
348 if (!this->expect(Token::LBRACE, "'{'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400349 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500350 }
351 fTypes.add(this->text(name), std::unique_ptr<Symbol>(new Type(this->text(name),
352 Type::kEnum_Kind)));
Ethan Nicholasfc994162019-06-06 10:04:27 -0400353 CREATE_NODE(result, name.fOffset, ASTNode::Kind::kEnum, this->text(name));
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500354 if (!this->checkNext(Token::RBRACE)) {
355 Token id;
356 if (!this->expect(Token::IDENTIFIER, "an identifier", &id)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400357 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500358 }
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500359 if (this->checkNext(Token::EQ)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400360 ASTNode::ID value = this->assignmentExpression();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500361 if (!value) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400362 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500363 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400364 CREATE_CHILD(child, result, id.fOffset, ASTNode::Kind::kEnumCase, this->text(id));
365 getNode(child).addChild(value);
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500366 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400367 CREATE_CHILD(child, result, id.fOffset, ASTNode::Kind::kEnumCase, this->text(id));
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500368 }
369 while (!this->checkNext(Token::RBRACE)) {
370 if (!this->expect(Token::COMMA, "','")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400371 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500372 }
373 if (!this->expect(Token::IDENTIFIER, "an identifier", &id)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400374 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500375 }
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500376 if (this->checkNext(Token::EQ)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400377 ASTNode::ID value = this->assignmentExpression();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500378 if (!value) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400379 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500380 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400381 CREATE_CHILD(child, result, id.fOffset, ASTNode::Kind::kEnumCase, this->text(id));
382 getNode(child).addChild(value);
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500383 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400384 CREATE_CHILD(child, result, id.fOffset, ASTNode::Kind::kEnumCase, this->text(id));
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500385 }
386 }
387 }
388 this->expect(Token::SEMICOLON, "';'");
Ethan Nicholasfc994162019-06-06 10:04:27 -0400389 return result;
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500390}
391
392/* enumDeclaration | modifiers (structVarDeclaration | type IDENTIFIER ((LPAREN parameter
ethannicholasb3058bd2016-07-01 08:22:01 -0700393 (COMMA parameter)* RPAREN (block | SEMICOLON)) | SEMICOLON) | interfaceBlock) */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400394ASTNode::ID Parser::declaration() {
ethannicholasb3058bd2016-07-01 08:22:01 -0700395 Token lookahead = this->peek();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500396 if (lookahead.fKind == Token::ENUM) {
397 return this->enumDeclaration();
398 }
399 Modifiers modifiers = this->modifiers();
400 lookahead = this->peek();
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700401 if (lookahead.fKind == Token::IDENTIFIER && !this->isType(this->text(lookahead))) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700402 // we have an identifier that's not a type, could be the start of an interface block
403 return this->interfaceBlock(modifiers);
404 }
405 if (lookahead.fKind == Token::STRUCT) {
406 return this->structVarDeclaration(modifiers);
407 }
ethannicholas5961bc92016-10-12 06:39:56 -0700408 if (lookahead.fKind == Token::SEMICOLON) {
409 this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -0400410 RETURN_NODE(lookahead.fOffset, ASTNode::Kind::kModifiers, modifiers);
ethannicholas5961bc92016-10-12 06:39:56 -0700411 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400412 ASTNode::ID type = this->type();
ethannicholasb3058bd2016-07-01 08:22:01 -0700413 if (!type) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400414 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700415 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400416 if (getNode(type).getTypeData().fIsStructDeclaration && this->checkNext(Token::SEMICOLON)) {
417 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700418 }
419 Token name;
420 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400421 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700422 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400423 if (this->checkNext(Token::LPAREN)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400424 CREATE_NODE(result, name.fOffset, ASTNode::Kind::kFunction);
425 ASTNode::FunctionData fd(modifiers, this->text(name), 0);
426 getNode(result).addChild(type);
427 if (this->peek().fKind != Token::RPAREN) {
428 for (;;) {
429 ASTNode::ID parameter = this->parameter();
430 if (!parameter) {
431 return ASTNode::ID::Invalid();
432 }
433 ++fd.fParameterCount;
434 getNode(result).addChild(parameter);
435 if (!this->checkNext(Token::COMMA)) {
436 break;
ethannicholasb3058bd2016-07-01 08:22:01 -0700437 }
438 }
ethannicholasb3058bd2016-07-01 08:22:01 -0700439 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400440 getNode(result).setFunctionData(fd);
441 if (!this->expect(Token::RPAREN, "')'")) {
442 return ASTNode::ID::Invalid();
443 }
444 ASTNode::ID body;
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400445 if (!this->checkNext(Token::SEMICOLON)) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700446 body = this->block();
447 if (!body) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400448 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700449 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400450 getNode(result).addChild(body);
ethannicholasb3058bd2016-07-01 08:22:01 -0700451 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400452 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -0700453 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400454 return this->varDeclarationEnd(modifiers, type, this->text(name));
ethannicholasb3058bd2016-07-01 08:22:01 -0700455 }
456}
457
458/* modifiers type IDENTIFIER varDeclarationEnd */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400459ASTNode::ID Parser::varDeclarations() {
Ethan Nicholas11d53972016-11-28 11:23:23 -0500460 Modifiers modifiers = this->modifiers();
Ethan Nicholasfc994162019-06-06 10:04:27 -0400461 ASTNode::ID type = this->type();
ethannicholasb3058bd2016-07-01 08:22:01 -0700462 if (!type) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400463 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700464 }
465 Token name;
466 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400467 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700468 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400469 return this->varDeclarationEnd(modifiers, type, this->text(name));
ethannicholasb3058bd2016-07-01 08:22:01 -0700470}
471
472/* STRUCT IDENTIFIER LBRACE varDeclaration* RBRACE */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400473ASTNode::ID Parser::structDeclaration() {
ethannicholasb3058bd2016-07-01 08:22:01 -0700474 if (!this->expect(Token::STRUCT, "'struct'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400475 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700476 }
477 Token name;
478 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400479 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700480 }
481 if (!this->expect(Token::LBRACE, "'{'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400482 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700483 }
484 std::vector<Type::Field> fields;
485 while (this->peek().fKind != Token::RBRACE) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400486 ASTNode::ID decls = this->varDeclarations();
487 if (!decls) {
488 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700489 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400490 ASTNode& declsNode = getNode(decls);
491 auto type = (const Type*) fTypes[(declsNode.begin() + 1)->getTypeData().fName];
492 for (auto iter = declsNode.begin() + 2; iter != declsNode.end(); ++iter) {
493 ASTNode& var = *iter;
494 ASTNode::VarData vd = var.getVarData();
495 for (int j = vd.fSizeCount - 1; j >= 0; j--) {
496 const ASTNode& size = *(var.begin() + j);
497 if (!size || size.fKind != ASTNode::Kind::kInt) {
498 this->error(declsNode.fOffset, "array size in struct field must be a constant");
499 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700500 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400501 uint64_t columns = size.getInt();
Ethan Nicholas0df1b042017-03-31 13:56:23 -0400502 String name = type->name() + "[" + to_string(columns) + "]";
Ethan Nicholas91164d12019-05-15 15:29:54 -0400503 type = (Type*) fTypes.takeOwnership(std::unique_ptr<Symbol>(
504 new Type(name,
505 Type::kArray_Kind,
506 *type,
507 (int) columns)));
ethannicholasb3058bd2016-07-01 08:22:01 -0700508 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400509 fields.push_back(Type::Field(declsNode.begin()->getModifiers(), vd.fName, type));
510 if (vd.fSizeCount ? (var.begin() + (vd.fSizeCount - 1))->fNext : var.fFirstChild) {
511 this->error(declsNode.fOffset, "initializers are not permitted on struct fields");
ethannicholasb3058bd2016-07-01 08:22:01 -0700512 }
513 }
514 }
515 if (!this->expect(Token::RBRACE, "'}'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400516 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700517 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700518 fTypes.add(this->text(name), std::unique_ptr<Type>(new Type(name.fOffset, this->text(name),
519 fields)));
Ethan Nicholasfc994162019-06-06 10:04:27 -0400520 RETURN_NODE(name.fOffset, ASTNode::Kind::kType,
521 ASTNode::TypeData(this->text(name), true, false));
ethannicholasb3058bd2016-07-01 08:22:01 -0700522}
523
524/* structDeclaration ((IDENTIFIER varDeclarationEnd) | SEMICOLON) */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400525ASTNode::ID Parser::structVarDeclaration(Modifiers modifiers) {
526 ASTNode::ID type = this->structDeclaration();
ethannicholasb3058bd2016-07-01 08:22:01 -0700527 if (!type) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400528 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700529 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400530 Token name;
531 if (this->checkNext(Token::IDENTIFIER, &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400532 return this->varDeclarationEnd(modifiers, std::move(type), this->text(name));
ethannicholasb3058bd2016-07-01 08:22:01 -0700533 }
534 this->expect(Token::SEMICOLON, "';'");
Ethan Nicholasfc994162019-06-06 10:04:27 -0400535 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700536}
537
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400538/* (LBRACKET expression? RBRACKET)* (EQ assignmentExpression)? (COMMA IDENTIFER
539 (LBRACKET expression? RBRACKET)* (EQ assignmentExpression)?)* SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400540ASTNode::ID Parser::varDeclarationEnd(Modifiers mods, ASTNode::ID type, StringFragment name) {
541 CREATE_NODE(result, -1, ASTNode::Kind::kVarDeclarations);
542 CREATE_CHILD(modifiers, result, -1, ASTNode::Kind::kModifiers, mods);
543 getNode(result).addChild(type);
544 CREATE_NODE(currentVar, -1, ASTNode::Kind::kVarDeclaration);
545 ASTNode::VarData vd(name, 0);
546 getNode(result).addChild(currentVar);
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400547 while (this->checkNext(Token::LBRACKET)) {
548 if (this->checkNext(Token::RBRACKET)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400549 CREATE_EMPTY_CHILD(currentVar);
ethannicholasb3058bd2016-07-01 08:22:01 -0700550 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400551 ASTNode::ID size = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -0700552 if (!size) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400553 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700554 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400555 getNode(currentVar).addChild(size);
ethannicholasb3058bd2016-07-01 08:22:01 -0700556 if (!this->expect(Token::RBRACKET, "']'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400557 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700558 }
559 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400560 ++vd.fSizeCount;
ethannicholasb3058bd2016-07-01 08:22:01 -0700561 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400562 getNode(currentVar).setVarData(vd);
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400563 if (this->checkNext(Token::EQ)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400564 ASTNode::ID value = this->assignmentExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -0700565 if (!value) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400566 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700567 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400568 getNode(currentVar).addChild(value);
ethannicholasb3058bd2016-07-01 08:22:01 -0700569 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400570 while (this->checkNext(Token::COMMA)) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700571 Token name;
572 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400573 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700574 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400575 currentVar = ASTNode::ID(fFile->fNodes.size());
576 vd = ASTNode::VarData(this->text(name), 0);
577 fFile->fNodes.emplace_back(&fFile->fNodes, -1, ASTNode::Kind::kVarDeclaration);
578 getNode(result).addChild(currentVar);
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400579 while (this->checkNext(Token::LBRACKET)) {
580 if (this->checkNext(Token::RBRACKET)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400581 CREATE_EMPTY_CHILD(currentVar);
ethannicholasb3058bd2016-07-01 08:22:01 -0700582 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400583 ASTNode::ID size = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -0700584 if (!size) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400585 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700586 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400587 getNode(currentVar).addChild(size);
ethannicholasb3058bd2016-07-01 08:22:01 -0700588 if (!this->expect(Token::RBRACKET, "']'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400589 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700590 }
591 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400592 ++vd.fSizeCount;
ethannicholasb3058bd2016-07-01 08:22:01 -0700593 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400594 getNode(currentVar).setVarData(vd);
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400595 if (this->checkNext(Token::EQ)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400596 ASTNode::ID value = this->assignmentExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -0700597 if (!value) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400598 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700599 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400600 getNode(currentVar).addChild(value);
ethannicholasb3058bd2016-07-01 08:22:01 -0700601 }
602 }
603 if (!this->expect(Token::SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400604 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700605 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400606 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -0700607}
608
609/* modifiers type IDENTIFIER (LBRACKET INT_LITERAL RBRACKET)? */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400610ASTNode::ID Parser::parameter() {
Ethan Nicholasc6f5e102017-03-31 14:53:17 -0400611 Modifiers modifiers = this->modifiersWithDefaults(0);
Ethan Nicholasfc994162019-06-06 10:04:27 -0400612 ASTNode::ID type = this->type();
ethannicholasb3058bd2016-07-01 08:22:01 -0700613 if (!type) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400614 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700615 }
616 Token name;
617 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400618 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700619 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400620 CREATE_NODE(result, name.fOffset, ASTNode::Kind::kParameter);
621 ASTNode::ParameterData pd(modifiers, this->text(name), 0);
622 getNode(result).addChild(type);
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400623 while (this->checkNext(Token::LBRACKET)) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700624 Token sizeToken;
625 if (!this->expect(Token::INT_LITERAL, "a positive integer", &sizeToken)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400626 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700627 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400628 CREATE_CHILD(child, result, sizeToken.fOffset, ASTNode::Kind::kInt,
629 SkSL::stoi(this->text(sizeToken)));
ethannicholasb3058bd2016-07-01 08:22:01 -0700630 if (!this->expect(Token::RBRACKET, "']'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400631 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700632 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400633 ++pd.fSizeCount;
ethannicholasb3058bd2016-07-01 08:22:01 -0700634 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400635 getNode(result).setParameterData(pd);
636 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -0700637}
638
Ethan Nicholasd608c092017-10-26 09:30:08 -0400639/** EQ INT_LITERAL */
ethannicholasb3058bd2016-07-01 08:22:01 -0700640int Parser::layoutInt() {
641 if (!this->expect(Token::EQ, "'='")) {
642 return -1;
643 }
644 Token resultToken;
645 if (this->expect(Token::INT_LITERAL, "a non-negative integer", &resultToken)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700646 return SkSL::stoi(this->text(resultToken));
ethannicholasb3058bd2016-07-01 08:22:01 -0700647 }
648 return -1;
649}
650
Ethan Nicholasd608c092017-10-26 09:30:08 -0400651/** EQ IDENTIFIER */
652StringFragment Parser::layoutIdentifier() {
653 if (!this->expect(Token::EQ, "'='")) {
654 return StringFragment();
655 }
656 Token resultToken;
657 if (!this->expect(Token::IDENTIFIER, "an identifier", &resultToken)) {
658 return StringFragment();
659 }
660 return this->text(resultToken);
661}
662
663
Ethan Nicholas762466e2017-06-29 10:03:38 -0400664/** EQ <any sequence of tokens with balanced parentheses and no top-level comma> */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400665StringFragment Parser::layoutCode() {
Ethan Nicholas762466e2017-06-29 10:03:38 -0400666 if (!this->expect(Token::EQ, "'='")) {
667 return "";
668 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700669 Token start = this->nextRawToken();
Ethan Nicholas08b79b72017-08-14 10:35:37 -0400670 this->pushback(start);
Ethan Nicholasfc994162019-06-06 10:04:27 -0400671 StringFragment code;
672 code.fChars = fText + start.fOffset;
Ethan Nicholas762466e2017-06-29 10:03:38 -0400673 int level = 1;
674 bool done = false;
675 while (!done) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700676 Token next = this->nextRawToken();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400677 switch (next.fKind) {
678 case Token::LPAREN:
679 ++level;
680 break;
681 case Token::RPAREN:
682 --level;
683 break;
684 case Token::COMMA:
685 if (level == 1) {
686 done = true;
687 }
688 break;
689 case Token::END_OF_FILE:
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700690 this->error(start, "reached end of file while parsing layout");
Ethan Nicholas6d71f492019-06-10 16:58:37 -0400691 return "";
Ethan Nicholas762466e2017-06-29 10:03:38 -0400692 default:
693 break;
694 }
695 if (!level) {
696 done = true;
697 }
Ethan Nicholas08b79b72017-08-14 10:35:37 -0400698 if (done) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400699 code.fLength = next.fOffset - start.fOffset;
Ethan Nicholas08b79b72017-08-14 10:35:37 -0400700 this->pushback(std::move(next));
701 }
Ethan Nicholas762466e2017-06-29 10:03:38 -0400702 }
703 return code;
704}
705
706/** (EQ IDENTIFIER('identity'))? */
707Layout::Key Parser::layoutKey() {
708 if (this->peek().fKind == Token::EQ) {
709 this->expect(Token::EQ, "'='");
710 Token key;
711 if (this->expect(Token::IDENTIFIER, "an identifer", &key)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700712 if (this->text(key) == "identity") {
Ethan Nicholas762466e2017-06-29 10:03:38 -0400713 return Layout::kIdentity_Key;
714 } else {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700715 this->error(key, "unsupported layout key");
Ethan Nicholas762466e2017-06-29 10:03:38 -0400716 }
717 }
718 }
719 return Layout::kKey_Key;
720}
721
Ethan Nicholas78aceb22018-08-31 16:13:58 -0400722Layout::CType Parser::layoutCType() {
723 if (this->expect(Token::EQ, "'='")) {
724 Token t = this->nextToken();
725 String text = this->text(t);
726 auto found = layoutTokens->find(text);
727 if (found != layoutTokens->end()) {
728 switch (found->second) {
Brian Osmanf28e55d2018-10-03 16:35:54 -0400729 case LayoutToken::SKPMCOLOR4F:
730 return Layout::CType::kSkPMColor4f;
Brian Salomoneca66b32019-06-01 11:18:15 -0400731 case LayoutToken::SKVECTOR4:
732 return Layout::CType::kSkVector4;
Ethan Nicholas78aceb22018-08-31 16:13:58 -0400733 case LayoutToken::SKRECT:
734 return Layout::CType::kSkRect;
735 case LayoutToken::SKIRECT:
736 return Layout::CType::kSkIRect;
737 case LayoutToken::SKPMCOLOR:
738 return Layout::CType::kSkPMColor;
Ethan Nicholasc1c686b2019-04-02 17:30:23 -0400739 case LayoutToken::BOOL:
740 return Layout::CType::kBool;
741 case LayoutToken::INT:
742 return Layout::CType::kInt32;
743 case LayoutToken::FLOAT:
744 return Layout::CType::kFloat;
Ethan Nicholas65e49ba2019-05-30 14:50:08 -0400745 case LayoutToken::SKMATRIX44:
746 return Layout::CType::kSkMatrix44;
Ethan Nicholas78aceb22018-08-31 16:13:58 -0400747 default:
748 break;
749 }
750 }
751 this->error(t, "unsupported ctype");
752 }
753 return Layout::CType::kDefault;
754}
755
ethannicholas8ac838d2016-11-22 08:39:36 -0800756/* LAYOUT LPAREN IDENTIFIER (EQ INT_LITERAL)? (COMMA IDENTIFIER (EQ INT_LITERAL)?)* RPAREN */
Ethan Nicholas11d53972016-11-28 11:23:23 -0500757Layout Parser::layout() {
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500758 int flags = 0;
ethannicholasb3058bd2016-07-01 08:22:01 -0700759 int location = -1;
Ethan Nicholas19671772016-11-28 16:30:17 -0500760 int offset = -1;
ethannicholasb3058bd2016-07-01 08:22:01 -0700761 int binding = -1;
762 int index = -1;
763 int set = -1;
764 int builtin = -1;
Greg Daniel64773e62016-11-22 09:44:03 -0500765 int inputAttachmentIndex = -1;
Ethan Nicholas11d53972016-11-28 11:23:23 -0500766 Layout::Format format = Layout::Format::kUnspecified;
Ethan Nicholas52cad152017-02-16 16:37:32 -0500767 Layout::Primitive primitive = Layout::kUnspecified_Primitive;
768 int maxVertices = -1;
769 int invocations = -1;
Ethan Nicholasfc994162019-06-06 10:04:27 -0400770 StringFragment when;
Ethan Nicholas762466e2017-06-29 10:03:38 -0400771 Layout::Key key = Layout::kNo_Key;
Ethan Nicholas78aceb22018-08-31 16:13:58 -0400772 Layout::CType ctype = Layout::CType::kDefault;
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400773 if (this->checkNext(Token::LAYOUT)) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700774 if (!this->expect(Token::LPAREN, "'('")) {
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500775 return Layout(flags, location, offset, binding, index, set, builtin,
776 inputAttachmentIndex, format, primitive, maxVertices, invocations, when,
777 key, ctype);
ethannicholasb3058bd2016-07-01 08:22:01 -0700778 }
779 for (;;) {
780 Token t = this->nextToken();
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700781 String text = this->text(t);
Ethan Nicholasb93af7e2018-07-24 11:28:52 -0400782 auto found = layoutTokens->find(text);
783 if (found != layoutTokens->end()) {
784 switch (found->second) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700785 case LayoutToken::LOCATION:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500786 location = this->layoutInt();
787 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700788 case LayoutToken::OFFSET:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500789 offset = this->layoutInt();
790 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700791 case LayoutToken::BINDING:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500792 binding = this->layoutInt();
793 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700794 case LayoutToken::INDEX:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500795 index = this->layoutInt();
796 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700797 case LayoutToken::SET:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500798 set = this->layoutInt();
799 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700800 case LayoutToken::BUILTIN:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500801 builtin = this->layoutInt();
802 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700803 case LayoutToken::INPUT_ATTACHMENT_INDEX:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500804 inputAttachmentIndex = this->layoutInt();
805 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700806 case LayoutToken::ORIGIN_UPPER_LEFT:
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500807 flags |= Layout::kOriginUpperLeft_Flag;
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500808 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700809 case LayoutToken::OVERRIDE_COVERAGE:
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500810 flags |= Layout::kOverrideCoverage_Flag;
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500811 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700812 case LayoutToken::BLEND_SUPPORT_ALL_EQUATIONS:
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500813 flags |= Layout::kBlendSupportAllEquations_Flag;
814 break;
815 case LayoutToken::BLEND_SUPPORT_MULTIPLY:
816 flags |= Layout::kBlendSupportMultiply_Flag;
817 break;
818 case LayoutToken::BLEND_SUPPORT_SCREEN:
819 flags |= Layout::kBlendSupportScreen_Flag;
820 break;
821 case LayoutToken::BLEND_SUPPORT_OVERLAY:
822 flags |= Layout::kBlendSupportOverlay_Flag;
823 break;
824 case LayoutToken::BLEND_SUPPORT_DARKEN:
825 flags |= Layout::kBlendSupportDarken_Flag;
826 break;
827 case LayoutToken::BLEND_SUPPORT_LIGHTEN:
828 flags |= Layout::kBlendSupportLighten_Flag;
829 break;
830 case LayoutToken::BLEND_SUPPORT_COLORDODGE:
831 flags |= Layout::kBlendSupportColorDodge_Flag;
832 break;
833 case LayoutToken::BLEND_SUPPORT_COLORBURN:
834 flags |= Layout::kBlendSupportColorBurn_Flag;
835 break;
836 case LayoutToken::BLEND_SUPPORT_HARDLIGHT:
837 flags |= Layout::kBlendSupportHardLight_Flag;
838 break;
839 case LayoutToken::BLEND_SUPPORT_SOFTLIGHT:
840 flags |= Layout::kBlendSupportSoftLight_Flag;
841 break;
842 case LayoutToken::BLEND_SUPPORT_DIFFERENCE:
843 flags |= Layout::kBlendSupportDifference_Flag;
844 break;
845 case LayoutToken::BLEND_SUPPORT_EXCLUSION:
846 flags |= Layout::kBlendSupportExclusion_Flag;
847 break;
848 case LayoutToken::BLEND_SUPPORT_HSL_HUE:
849 flags |= Layout::kBlendSupportHSLHue_Flag;
850 break;
851 case LayoutToken::BLEND_SUPPORT_HSL_SATURATION:
852 flags |= Layout::kBlendSupportHSLSaturation_Flag;
853 break;
854 case LayoutToken::BLEND_SUPPORT_HSL_COLOR:
855 flags |= Layout::kBlendSupportHSLColor_Flag;
856 break;
857 case LayoutToken::BLEND_SUPPORT_HSL_LUMINOSITY:
858 flags |= Layout::kBlendSupportHSLLuminosity_Flag;
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500859 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700860 case LayoutToken::PUSH_CONSTANT:
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500861 flags |= Layout::kPushConstant_Flag;
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500862 break;
Michael Ludwiga4275592018-08-31 10:52:47 -0400863 case LayoutToken::TRACKED:
864 flags |= Layout::kTracked_Flag;
865 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700866 case LayoutToken::POINTS:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500867 primitive = Layout::kPoints_Primitive;
868 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700869 case LayoutToken::LINES:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500870 primitive = Layout::kLines_Primitive;
871 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700872 case LayoutToken::LINE_STRIP:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500873 primitive = Layout::kLineStrip_Primitive;
874 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700875 case LayoutToken::LINES_ADJACENCY:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500876 primitive = Layout::kLinesAdjacency_Primitive;
877 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700878 case LayoutToken::TRIANGLES:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500879 primitive = Layout::kTriangles_Primitive;
880 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700881 case LayoutToken::TRIANGLE_STRIP:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500882 primitive = Layout::kTriangleStrip_Primitive;
883 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700884 case LayoutToken::TRIANGLES_ADJACENCY:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500885 primitive = Layout::kTrianglesAdjacency_Primitive;
886 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700887 case LayoutToken::MAX_VERTICES:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500888 maxVertices = this->layoutInt();
889 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700890 case LayoutToken::INVOCATIONS:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500891 invocations = this->layoutInt();
892 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700893 case LayoutToken::WHEN:
Ethan Nicholas762466e2017-06-29 10:03:38 -0400894 when = this->layoutCode();
895 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700896 case LayoutToken::KEY:
Ethan Nicholas762466e2017-06-29 10:03:38 -0400897 key = this->layoutKey();
898 break;
Ethan Nicholasd608c092017-10-26 09:30:08 -0400899 case LayoutToken::CTYPE:
Ethan Nicholas78aceb22018-08-31 16:13:58 -0400900 ctype = this->layoutCType();
901 break;
902 default:
903 this->error(t, ("'" + text + "' is not a valid layout qualifier").c_str());
Ethan Nicholasd608c092017-10-26 09:30:08 -0400904 break;
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500905 }
Ethan Nicholasb93af7e2018-07-24 11:28:52 -0400906 } else if (Layout::ReadFormat(text, &format)) {
Brian Salomon2a51de82016-11-16 12:06:01 -0500907 // AST::ReadFormat stored the result in 'format'.
ethannicholasb3058bd2016-07-01 08:22:01 -0700908 } else {
Ethan Nicholasb93af7e2018-07-24 11:28:52 -0400909 this->error(t, ("'" + text + "' is not a valid layout qualifier").c_str());
ethannicholasb3058bd2016-07-01 08:22:01 -0700910 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400911 if (this->checkNext(Token::RPAREN)) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700912 break;
913 }
914 if (!this->expect(Token::COMMA, "','")) {
915 break;
916 }
917 }
918 }
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500919 return Layout(flags, location, offset, binding, index, set, builtin, inputAttachmentIndex,
920 format, primitive, maxVertices, invocations, when, key, ctype);
ethannicholasb3058bd2016-07-01 08:22:01 -0700921}
922
Brian Salomonf9f45122016-11-29 11:59:17 -0500923/* layout? (UNIFORM | CONST | IN | OUT | INOUT | LOWP | MEDIUMP | HIGHP | FLAT | NOPERSPECTIVE |
Ethan Nicholasa7ceb502019-01-11 10:31:48 -0500924 READONLY | WRITEONLY | COHERENT | VOLATILE | RESTRICT | BUFFER | PLS | PLSIN |
925 PLSOUT)* */
Ethan Nicholas11d53972016-11-28 11:23:23 -0500926Modifiers Parser::modifiers() {
927 Layout layout = this->layout();
ethannicholasb3058bd2016-07-01 08:22:01 -0700928 int flags = 0;
929 for (;;) {
930 // TODO: handle duplicate / incompatible flags
931 switch (peek().fKind) {
932 case Token::UNIFORM:
933 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500934 flags |= Modifiers::kUniform_Flag;
ethannicholasb3058bd2016-07-01 08:22:01 -0700935 break;
936 case Token::CONST:
937 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500938 flags |= Modifiers::kConst_Flag;
ethannicholasb3058bd2016-07-01 08:22:01 -0700939 break;
940 case Token::IN:
941 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500942 flags |= Modifiers::kIn_Flag;
ethannicholasb3058bd2016-07-01 08:22:01 -0700943 break;
944 case Token::OUT:
945 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500946 flags |= Modifiers::kOut_Flag;
ethannicholasb3058bd2016-07-01 08:22:01 -0700947 break;
948 case Token::INOUT:
949 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500950 flags |= Modifiers::kIn_Flag;
951 flags |= Modifiers::kOut_Flag;
ethannicholasb3058bd2016-07-01 08:22:01 -0700952 break;
ethannicholasf789b382016-08-03 12:43:36 -0700953 case Token::FLAT:
954 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500955 flags |= Modifiers::kFlat_Flag;
ethannicholasf789b382016-08-03 12:43:36 -0700956 break;
957 case Token::NOPERSPECTIVE:
958 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500959 flags |= Modifiers::kNoPerspective_Flag;
ethannicholasf789b382016-08-03 12:43:36 -0700960 break;
Brian Salomonf9f45122016-11-29 11:59:17 -0500961 case Token::READONLY:
962 this->nextToken();
963 flags |= Modifiers::kReadOnly_Flag;
964 break;
965 case Token::WRITEONLY:
966 this->nextToken();
967 flags |= Modifiers::kWriteOnly_Flag;
968 break;
969 case Token::COHERENT:
970 this->nextToken();
971 flags |= Modifiers::kCoherent_Flag;
972 break;
973 case Token::VOLATILE:
974 this->nextToken();
975 flags |= Modifiers::kVolatile_Flag;
976 break;
977 case Token::RESTRICT:
978 this->nextToken();
979 flags |= Modifiers::kRestrict_Flag;
980 break;
Ethan Nicholas0dd30d92017-05-01 16:57:07 -0400981 case Token::BUFFER:
982 this->nextToken();
983 flags |= Modifiers::kBuffer_Flag;
984 break;
Ethan Nicholascb670962017-04-20 19:31:52 -0400985 case Token::HASSIDEEFFECTS:
986 this->nextToken();
987 flags |= Modifiers::kHasSideEffects_Flag;
988 break;
Ethan Nicholasa7ceb502019-01-11 10:31:48 -0500989 case Token::PLS:
990 this->nextToken();
991 flags |= Modifiers::kPLS_Flag;
992 break;
993 case Token::PLSIN:
994 this->nextToken();
995 flags |= Modifiers::kPLSIn_Flag;
996 break;
997 case Token::PLSOUT:
998 this->nextToken();
999 flags |= Modifiers::kPLSOut_Flag;
1000 break;
ethannicholasb3058bd2016-07-01 08:22:01 -07001001 default:
Ethan Nicholas11d53972016-11-28 11:23:23 -05001002 return Modifiers(layout, flags);
ethannicholasb3058bd2016-07-01 08:22:01 -07001003 }
1004 }
1005}
1006
Ethan Nicholas11d53972016-11-28 11:23:23 -05001007Modifiers Parser::modifiersWithDefaults(int defaultFlags) {
1008 Modifiers result = this->modifiers();
ethannicholasb3058bd2016-07-01 08:22:01 -07001009 if (!result.fFlags) {
Ethan Nicholas11d53972016-11-28 11:23:23 -05001010 return Modifiers(result.fLayout, defaultFlags);
ethannicholasb3058bd2016-07-01 08:22:01 -07001011 }
1012 return result;
1013}
1014
1015/* ifStatement | forStatement | doStatement | whileStatement | block | expression */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001016ASTNode::ID Parser::statement() {
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04001017 Token start = this->nextToken();
1018 AutoDepth depth(this);
1019 if (!depth.checkValid()) {
1020 return ASTNode::ID::Invalid();
1021 }
1022 this->pushback(start);
ethannicholasb3058bd2016-07-01 08:22:01 -07001023 switch (start.fKind) {
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001024 case Token::IF: // fall through
1025 case Token::STATIC_IF:
ethannicholasb3058bd2016-07-01 08:22:01 -07001026 return this->ifStatement();
1027 case Token::FOR:
1028 return this->forStatement();
1029 case Token::DO:
1030 return this->doStatement();
1031 case Token::WHILE:
1032 return this->whileStatement();
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001033 case Token::SWITCH: // fall through
1034 case Token::STATIC_SWITCH:
Ethan Nicholasaf197692017-02-27 13:26:45 -05001035 return this->switchStatement();
ethannicholasb3058bd2016-07-01 08:22:01 -07001036 case Token::RETURN:
1037 return this->returnStatement();
1038 case Token::BREAK:
1039 return this->breakStatement();
1040 case Token::CONTINUE:
1041 return this->continueStatement();
1042 case Token::DISCARD:
1043 return this->discardStatement();
1044 case Token::LBRACE:
1045 return this->block();
1046 case Token::SEMICOLON:
Ethan Nicholas11d53972016-11-28 11:23:23 -05001047 this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001048 RETURN_NODE(start.fOffset, ASTNode::Kind::kBlock);
1049 case Token::CONST:
1050 return this->varDeclarations();
ethannicholasb3058bd2016-07-01 08:22:01 -07001051 case Token::IDENTIFIER:
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001052 if (this->isType(this->text(start))) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001053 return this->varDeclarations();
ethannicholasb3058bd2016-07-01 08:22:01 -07001054 }
1055 // fall through
1056 default:
1057 return this->expressionStatement();
Ethan Nicholas11d53972016-11-28 11:23:23 -05001058 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001059}
1060
Ethan Nicholasee1c8a72019-02-22 10:50:47 -05001061/* IDENTIFIER(type) (LBRACKET intLiteral? RBRACKET)* QUESTION? */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001062ASTNode::ID Parser::type() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001063 Token type;
1064 if (!this->expect(Token::IDENTIFIER, "a type", &type)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001065 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001066 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001067 if (!this->isType(this->text(type))) {
1068 this->error(type, ("no type named '" + this->text(type) + "'").c_str());
Ethan Nicholasfc994162019-06-06 10:04:27 -04001069 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001070 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001071 CREATE_NODE(result, type.fOffset, ASTNode::Kind::kType);
1072 ASTNode::TypeData td(this->text(type), false, false);
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001073 while (this->checkNext(Token::LBRACKET)) {
Ethan Nicholas50afc172017-02-16 14:49:57 -05001074 if (this->peek().fKind != Token::RBRACKET) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001075 SKSL_INT i;
Ethan Nicholas50afc172017-02-16 14:49:57 -05001076 if (this->intLiteral(&i)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001077 CREATE_CHILD(child, result, -1, ASTNode::Kind::kInt, i);
Ethan Nicholas50afc172017-02-16 14:49:57 -05001078 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001079 return ASTNode::ID::Invalid();
Ethan Nicholas50afc172017-02-16 14:49:57 -05001080 }
1081 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001082 CREATE_EMPTY_CHILD(result);
Ethan Nicholas50afc172017-02-16 14:49:57 -05001083 }
1084 this->expect(Token::RBRACKET, "']'");
1085 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001086 td.fIsNullable = this->checkNext(Token::QUESTION);
1087 getNode(result).setTypeData(td);
1088 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001089}
1090
Ethan Nicholas50afc172017-02-16 14:49:57 -05001091/* IDENTIFIER LBRACE varDeclaration* RBRACE (IDENTIFIER (LBRACKET expression? RBRACKET)*)? */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001092ASTNode::ID Parser::interfaceBlock(Modifiers mods) {
ethannicholasb3058bd2016-07-01 08:22:01 -07001093 Token name;
1094 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001095 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001096 }
1097 if (peek().fKind != Token::LBRACE) {
1098 // we only get into interfaceBlock if we found a top-level identifier which was not a type.
Ethan Nicholas11d53972016-11-28 11:23:23 -05001099 // 99% of the time, the user was not actually intending to create an interface block, so
ethannicholasb3058bd2016-07-01 08:22:01 -07001100 // it's better to report it as an unknown type
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001101 this->error(name, "no type named '" + this->text(name) + "'");
Ethan Nicholasfc994162019-06-06 10:04:27 -04001102 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001103 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001104 CREATE_NODE(result, name.fOffset, ASTNode::Kind::kInterfaceBlock);
1105 ASTNode::InterfaceBlockData id(mods, this->text(name), 0, "", 0);
ethannicholasb3058bd2016-07-01 08:22:01 -07001106 this->nextToken();
ethannicholasb3058bd2016-07-01 08:22:01 -07001107 while (this->peek().fKind != Token::RBRACE) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001108 ASTNode::ID decl = this->varDeclarations();
ethannicholasb3058bd2016-07-01 08:22:01 -07001109 if (!decl) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001110 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001111 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001112 getNode(result).addChild(decl);
1113 ++id.fDeclarationCount;
ethannicholasb3058bd2016-07-01 08:22:01 -07001114 }
1115 this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001116 std::vector<ASTNode> sizes;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001117 StringFragment instanceName;
1118 Token instanceNameToken;
1119 if (this->checkNext(Token::IDENTIFIER, &instanceNameToken)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001120 id.fInstanceName = this->text(instanceNameToken);
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001121 while (this->checkNext(Token::LBRACKET)) {
Ethan Nicholas50afc172017-02-16 14:49:57 -05001122 if (this->peek().fKind != Token::RBRACKET) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001123 ASTNode::ID size = this->expression();
Ethan Nicholas50afc172017-02-16 14:49:57 -05001124 if (!size) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001125 return ASTNode::ID::Invalid();
Ethan Nicholas50afc172017-02-16 14:49:57 -05001126 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001127 getNode(result).addChild(size);
Ethan Nicholas50afc172017-02-16 14:49:57 -05001128 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001129 CREATE_EMPTY_CHILD(result);
Ethan Nicholas50afc172017-02-16 14:49:57 -05001130 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001131 ++id.fSizeCount;
Ethan Nicholas50afc172017-02-16 14:49:57 -05001132 this->expect(Token::RBRACKET, "']'");
1133 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001134 instanceName = this->text(instanceNameToken);
ethannicholasb3058bd2016-07-01 08:22:01 -07001135 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001136 getNode(result).setInterfaceBlockData(id);
ethannicholasb3058bd2016-07-01 08:22:01 -07001137 this->expect(Token::SEMICOLON, "';'");
Ethan Nicholasfc994162019-06-06 10:04:27 -04001138 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001139}
1140
1141/* IF LPAREN expression RPAREN statement (ELSE statement)? */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001142ASTNode::ID Parser::ifStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001143 Token start;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001144 bool isStatic = this->checkNext(Token::STATIC_IF, &start);
1145 if (!isStatic && !this->expect(Token::IF, "'if'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001146 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001147 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001148 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kIf, isStatic);
ethannicholasb3058bd2016-07-01 08:22:01 -07001149 if (!this->expect(Token::LPAREN, "'('")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001150 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001151 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001152 ASTNode::ID test = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001153 if (!test) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001154 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001155 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001156 getNode(result).addChild(test);
ethannicholasb3058bd2016-07-01 08:22:01 -07001157 if (!this->expect(Token::RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001158 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001159 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001160 ASTNode::ID ifTrue = this->statement();
ethannicholasb3058bd2016-07-01 08:22:01 -07001161 if (!ifTrue) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001162 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001163 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001164 getNode(result).addChild(ifTrue);
1165 ASTNode::ID ifFalse;
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001166 if (this->checkNext(Token::ELSE)) {
ethannicholasb3058bd2016-07-01 08:22:01 -07001167 ifFalse = this->statement();
1168 if (!ifFalse) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001169 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001170 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001171 getNode(result).addChild(ifFalse);
ethannicholasb3058bd2016-07-01 08:22:01 -07001172 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001173 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001174}
1175
1176/* DO statement WHILE LPAREN expression RPAREN SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001177ASTNode::ID Parser::doStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001178 Token start;
1179 if (!this->expect(Token::DO, "'do'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001180 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001181 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001182 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kDo);
1183 ASTNode::ID statement = this->statement();
ethannicholasb3058bd2016-07-01 08:22:01 -07001184 if (!statement) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001185 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001186 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001187 getNode(result).addChild(statement);
ethannicholasb3058bd2016-07-01 08:22:01 -07001188 if (!this->expect(Token::WHILE, "'while'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001189 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001190 }
1191 if (!this->expect(Token::LPAREN, "'('")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001192 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001193 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001194 ASTNode::ID test = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001195 if (!test) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001196 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001197 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001198 getNode(result).addChild(test);
ethannicholasb3058bd2016-07-01 08:22:01 -07001199 if (!this->expect(Token::RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001200 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001201 }
1202 if (!this->expect(Token::SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001203 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001204 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001205 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001206}
1207
1208/* WHILE LPAREN expression RPAREN STATEMENT */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001209ASTNode::ID Parser::whileStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001210 Token start;
1211 if (!this->expect(Token::WHILE, "'while'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001212 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001213 }
1214 if (!this->expect(Token::LPAREN, "'('")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001215 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001216 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001217 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kWhile);
1218 ASTNode::ID test = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001219 if (!test) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001220 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001221 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001222 getNode(result).addChild(test);
ethannicholasb3058bd2016-07-01 08:22:01 -07001223 if (!this->expect(Token::RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001224 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001225 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001226 ASTNode::ID statement = this->statement();
ethannicholasb3058bd2016-07-01 08:22:01 -07001227 if (!statement) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001228 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001229 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001230 getNode(result).addChild(statement);
1231 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001232}
1233
Ethan Nicholasaf197692017-02-27 13:26:45 -05001234/* CASE expression COLON statement* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001235ASTNode::ID Parser::switchCase() {
Ethan Nicholasaf197692017-02-27 13:26:45 -05001236 Token start;
1237 if (!this->expect(Token::CASE, "'case'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001238 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001239 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001240 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kSwitchCase);
1241 ASTNode::ID value = this->expression();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001242 if (!value) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001243 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001244 }
1245 if (!this->expect(Token::COLON, "':'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001246 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001247 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001248 getNode(result).addChild(value);
Ethan Nicholasaf197692017-02-27 13:26:45 -05001249 while (this->peek().fKind != Token::RBRACE && this->peek().fKind != Token::CASE &&
1250 this->peek().fKind != Token::DEFAULT) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001251 ASTNode::ID s = this->statement();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001252 if (!s) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001253 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001254 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001255 getNode(result).addChild(s);
Ethan Nicholasaf197692017-02-27 13:26:45 -05001256 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001257 return result;
Ethan Nicholasaf197692017-02-27 13:26:45 -05001258}
1259
1260/* SWITCH LPAREN expression RPAREN LBRACE switchCase* (DEFAULT COLON statement*)? RBRACE */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001261ASTNode::ID Parser::switchStatement() {
Ethan Nicholasaf197692017-02-27 13:26:45 -05001262 Token start;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001263 bool isStatic = this->checkNext(Token::STATIC_SWITCH, &start);
1264 if (!isStatic && !this->expect(Token::SWITCH, "'switch'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001265 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001266 }
1267 if (!this->expect(Token::LPAREN, "'('")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001268 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001269 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001270 ASTNode::ID value = this->expression();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001271 if (!value) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001272 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001273 }
1274 if (!this->expect(Token::RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001275 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001276 }
1277 if (!this->expect(Token::LBRACE, "'{'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001278 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001279 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001280 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kSwitch, isStatic);
1281 getNode(result).addChild(value);
Ethan Nicholasaf197692017-02-27 13:26:45 -05001282 while (this->peek().fKind == Token::CASE) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001283 ASTNode::ID c = this->switchCase();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001284 if (!c) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001285 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001286 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001287 getNode(result).addChild(c);
Ethan Nicholasaf197692017-02-27 13:26:45 -05001288 }
1289 // Requiring default: to be last (in defiance of C and GLSL) was a deliberate decision. Other
1290 // parts of the compiler may rely upon this assumption.
1291 if (this->peek().fKind == Token::DEFAULT) {
1292 Token defaultStart;
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001293 SkAssertResult(this->expect(Token::DEFAULT, "'default'", &defaultStart));
Ethan Nicholasaf197692017-02-27 13:26:45 -05001294 if (!this->expect(Token::COLON, "':'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001295 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001296 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001297 CREATE_CHILD(defaultCase, result, defaultStart.fOffset, ASTNode::Kind::kSwitchCase);
1298 CREATE_EMPTY_CHILD(defaultCase); // empty test to signify default case
Ethan Nicholasaf197692017-02-27 13:26:45 -05001299 while (this->peek().fKind != Token::RBRACE) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001300 ASTNode::ID s = this->statement();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001301 if (!s) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001302 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001303 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001304 getNode(defaultCase).addChild(s);
Ethan Nicholasaf197692017-02-27 13:26:45 -05001305 }
Ethan Nicholasaf197692017-02-27 13:26:45 -05001306 }
1307 if (!this->expect(Token::RBRACE, "'}'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001308 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001309 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001310 return result;
Ethan Nicholasaf197692017-02-27 13:26:45 -05001311}
1312
Ethan Nicholas11d53972016-11-28 11:23:23 -05001313/* FOR LPAREN (declaration | expression)? SEMICOLON expression? SEMICOLON expression? RPAREN
ethannicholasb3058bd2016-07-01 08:22:01 -07001314 STATEMENT */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001315ASTNode::ID Parser::forStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001316 Token start;
1317 if (!this->expect(Token::FOR, "'for'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001318 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001319 }
1320 if (!this->expect(Token::LPAREN, "'('")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001321 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001322 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001323 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kFor);
1324 ASTNode::ID initializer;
ethannicholasb3058bd2016-07-01 08:22:01 -07001325 Token nextToken = this->peek();
1326 switch (nextToken.fKind) {
Ethan Nicholas11d53972016-11-28 11:23:23 -05001327 case Token::SEMICOLON:
ethannicholas22f939e2016-10-13 13:25:34 -07001328 this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001329 CREATE_EMPTY_CHILD(result);
ethannicholasb3058bd2016-07-01 08:22:01 -07001330 break;
ethannicholasa54401d2016-10-14 08:37:32 -07001331 case Token::CONST: {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001332 initializer = this->varDeclarations();
1333 if (!initializer) {
1334 return ASTNode::ID::Invalid();
ethannicholasa54401d2016-10-14 08:37:32 -07001335 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001336 getNode(result).addChild(initializer);
ethannicholasb3058bd2016-07-01 08:22:01 -07001337 break;
ethannicholasa54401d2016-10-14 08:37:32 -07001338 }
1339 case Token::IDENTIFIER: {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001340 if (this->isType(this->text(nextToken))) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001341 initializer = this->varDeclarations();
1342 if (!initializer) {
1343 return ASTNode::ID::Invalid();
ethannicholasa54401d2016-10-14 08:37:32 -07001344 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001345 getNode(result).addChild(initializer);
ethannicholasb3058bd2016-07-01 08:22:01 -07001346 break;
1347 }
ethannicholasa54401d2016-10-14 08:37:32 -07001348 } // fall through
ethannicholasb3058bd2016-07-01 08:22:01 -07001349 default:
1350 initializer = this->expressionStatement();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001351 if (!initializer) {
1352 return ASTNode::ID::Invalid();
1353 }
1354 getNode(result).addChild(initializer);
ethannicholasb3058bd2016-07-01 08:22:01 -07001355 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001356 ASTNode::ID test;
ethannicholasb3058bd2016-07-01 08:22:01 -07001357 if (this->peek().fKind != Token::SEMICOLON) {
1358 test = this->expression();
1359 if (!test) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001360 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001361 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001362 getNode(result).addChild(test);
1363 } else {
1364 CREATE_EMPTY_CHILD(result);
ethannicholasb3058bd2016-07-01 08:22:01 -07001365 }
1366 if (!this->expect(Token::SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001367 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001368 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001369 ASTNode::ID next;
ethannicholas22f939e2016-10-13 13:25:34 -07001370 if (this->peek().fKind != Token::RPAREN) {
ethannicholasb3058bd2016-07-01 08:22:01 -07001371 next = this->expression();
1372 if (!next) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001373 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001374 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001375 getNode(result).addChild(next);
1376 } else {
1377 CREATE_EMPTY_CHILD(result);
ethannicholasb3058bd2016-07-01 08:22:01 -07001378 }
1379 if (!this->expect(Token::RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001380 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001381 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001382 ASTNode::ID statement = this->statement();
ethannicholasb3058bd2016-07-01 08:22:01 -07001383 if (!statement) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001384 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001385 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001386 getNode(result).addChild(statement);
1387 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001388}
1389
1390/* RETURN expression? SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001391ASTNode::ID Parser::returnStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001392 Token start;
1393 if (!this->expect(Token::RETURN, "'return'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001394 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001395 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001396 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kReturn);
ethannicholasb3058bd2016-07-01 08:22:01 -07001397 if (this->peek().fKind != Token::SEMICOLON) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001398 ASTNode::ID expression = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001399 if (!expression) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001400 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001401 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001402 getNode(result).addChild(expression);
ethannicholasb3058bd2016-07-01 08:22:01 -07001403 }
1404 if (!this->expect(Token::SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001405 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001406 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001407 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001408}
1409
1410/* BREAK SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001411ASTNode::ID Parser::breakStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001412 Token start;
1413 if (!this->expect(Token::BREAK, "'break'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001414 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001415 }
1416 if (!this->expect(Token::SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001417 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001418 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001419 RETURN_NODE(start.fOffset, ASTNode::Kind::kBreak);
ethannicholasb3058bd2016-07-01 08:22:01 -07001420}
1421
1422/* CONTINUE SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001423ASTNode::ID Parser::continueStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001424 Token start;
1425 if (!this->expect(Token::CONTINUE, "'continue'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001426 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001427 }
1428 if (!this->expect(Token::SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001429 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001430 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001431 RETURN_NODE(start.fOffset, ASTNode::Kind::kContinue);
ethannicholasb3058bd2016-07-01 08:22:01 -07001432}
1433
1434/* DISCARD SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001435ASTNode::ID Parser::discardStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001436 Token start;
1437 if (!this->expect(Token::DISCARD, "'continue'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001438 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001439 }
1440 if (!this->expect(Token::SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001441 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001442 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001443 RETURN_NODE(start.fOffset, ASTNode::Kind::kDiscard);
ethannicholasb3058bd2016-07-01 08:22:01 -07001444}
1445
1446/* LBRACE statement* RBRACE */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001447ASTNode::ID Parser::block() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001448 Token start;
1449 if (!this->expect(Token::LBRACE, "'{'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001450 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001451 }
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04001452 AutoDepth depth(this);
1453 if (!depth.checkValid()) {
1454 return ASTNode::ID::Invalid();
1455 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001456 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kBlock);
ethannicholasb3058bd2016-07-01 08:22:01 -07001457 for (;;) {
1458 switch (this->peek().fKind) {
Ethan Nicholas11d53972016-11-28 11:23:23 -05001459 case Token::RBRACE:
ethannicholasb3058bd2016-07-01 08:22:01 -07001460 this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001461 return result;
Ethan Nicholas11d53972016-11-28 11:23:23 -05001462 case Token::END_OF_FILE:
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001463 this->error(this->peek(), "expected '}', but found end of file");
Ethan Nicholasfc994162019-06-06 10:04:27 -04001464 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001465 default: {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001466 ASTNode::ID statement = this->statement();
ethannicholasb3058bd2016-07-01 08:22:01 -07001467 if (!statement) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001468 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001469 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001470 getNode(result).addChild(statement);
ethannicholasb3058bd2016-07-01 08:22:01 -07001471 }
1472 }
1473 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001474 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001475}
1476
1477/* expression SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001478ASTNode::ID Parser::expressionStatement() {
1479 ASTNode::ID expr = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001480 if (expr) {
1481 if (this->expect(Token::SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001482 return expr;
ethannicholasb3058bd2016-07-01 08:22:01 -07001483 }
1484 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001485 return ASTNode::ID::Invalid();
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001486}
1487
1488/* assignmentExpression (COMMA assignmentExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001489ASTNode::ID Parser::expression() {
1490 ASTNode::ID result = this->assignmentExpression();
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001491 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001492 return ASTNode::ID::Invalid();
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001493 }
1494 Token t;
1495 while (this->checkNext(Token::COMMA, &t)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001496 ASTNode::ID right = this->assignmentExpression();
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001497 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001498 return ASTNode::ID::Invalid();
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001499 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001500 CREATE_NODE(newResult, t.fOffset, ASTNode::Kind::kBinary, std::move(t));
1501 getNode(newResult).addChild(result);
1502 getNode(newResult).addChild(right);
1503 result = newResult;
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001504 }
1505 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001506}
1507
1508/* ternaryExpression ((EQEQ | STAREQ | SLASHEQ | PERCENTEQ | PLUSEQ | MINUSEQ | SHLEQ | SHREQ |
1509 BITWISEANDEQ | BITWISEXOREQ | BITWISEOREQ | LOGICALANDEQ | LOGICALXOREQ | LOGICALOREQ)
1510 assignmentExpression)*
1511 */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001512ASTNode::ID Parser::assignmentExpression() {
1513 ASTNode::ID result = this->ternaryExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001514 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001515 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001516 }
1517 for (;;) {
1518 switch (this->peek().fKind) {
1519 case Token::EQ: // fall through
1520 case Token::STAREQ: // fall through
1521 case Token::SLASHEQ: // fall through
1522 case Token::PERCENTEQ: // fall through
1523 case Token::PLUSEQ: // fall through
1524 case Token::MINUSEQ: // fall through
1525 case Token::SHLEQ: // fall through
1526 case Token::SHREQ: // fall through
1527 case Token::BITWISEANDEQ: // fall through
1528 case Token::BITWISEXOREQ: // fall through
1529 case Token::BITWISEOREQ: // fall through
1530 case Token::LOGICALANDEQ: // fall through
1531 case Token::LOGICALXOREQ: // fall through
1532 case Token::LOGICALOREQ: {
1533 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001534 ASTNode::ID right = this->assignmentExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001535 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001536 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001537 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001538 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary,
1539 std::move(t));
1540 getNode(newResult).addChild(result);
1541 getNode(newResult).addChild(right);
1542 result = newResult;
1543 break;
ethannicholasb3058bd2016-07-01 08:22:01 -07001544 }
1545 default:
1546 return result;
1547 }
1548 }
1549}
1550
1551/* logicalOrExpression ('?' expression ':' assignmentExpression)? */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001552ASTNode::ID Parser::ternaryExpression() {
1553 ASTNode::ID base = this->logicalOrExpression();
1554 if (!base) {
1555 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001556 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001557 if (this->checkNext(Token::QUESTION)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001558 ASTNode::ID trueExpr = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001559 if (!trueExpr) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001560 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001561 }
1562 if (this->expect(Token::COLON, "':'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001563 ASTNode::ID falseExpr = this->assignmentExpression();
1564 if (!falseExpr) {
1565 return ASTNode::ID::Invalid();
1566 }
1567 CREATE_NODE(ternary, getNode(base).fOffset, ASTNode::Kind::kTernary);
1568 getNode(ternary).addChild(base);
1569 getNode(ternary).addChild(trueExpr);
1570 getNode(ternary).addChild(falseExpr);
1571 return ternary;
ethannicholasb3058bd2016-07-01 08:22:01 -07001572 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001573 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001574 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001575 return base;
ethannicholasb3058bd2016-07-01 08:22:01 -07001576}
1577
1578/* logicalXorExpression (LOGICALOR logicalXorExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001579ASTNode::ID Parser::logicalOrExpression() {
1580 ASTNode::ID result = this->logicalXorExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001581 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001582 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001583 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001584 Token t;
1585 while (this->checkNext(Token::LOGICALOR, &t)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001586 ASTNode::ID right = this->logicalXorExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001587 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001588 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001589 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001590 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary, std::move(t));
1591 getNode(newResult).addChild(result);
1592 getNode(newResult).addChild(right);
1593 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001594 }
1595 return result;
1596}
1597
1598/* logicalAndExpression (LOGICALXOR logicalAndExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001599ASTNode::ID Parser::logicalXorExpression() {
1600 ASTNode::ID result = this->logicalAndExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001601 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001602 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001603 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001604 Token t;
1605 while (this->checkNext(Token::LOGICALXOR, &t)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001606 ASTNode::ID right = this->logicalAndExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001607 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001608 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001609 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001610 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary, std::move(t));
1611 getNode(newResult).addChild(result);
1612 getNode(newResult).addChild(right);
1613 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001614 }
1615 return result;
1616}
1617
1618/* bitwiseOrExpression (LOGICALAND bitwiseOrExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001619ASTNode::ID Parser::logicalAndExpression() {
1620 ASTNode::ID result = this->bitwiseOrExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001621 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001622 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001623 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001624 Token t;
1625 while (this->checkNext(Token::LOGICALAND, &t)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001626 ASTNode::ID right = this->bitwiseOrExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001627 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001628 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001629 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001630 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary, std::move(t));
1631 getNode(newResult).addChild(result);
1632 getNode(newResult).addChild(right);
1633 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001634 }
1635 return result;
1636}
1637
1638/* bitwiseXorExpression (BITWISEOR bitwiseXorExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001639ASTNode::ID Parser::bitwiseOrExpression() {
1640 ASTNode::ID result = this->bitwiseXorExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001641 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001642 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001643 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001644 Token t;
1645 while (this->checkNext(Token::BITWISEOR, &t)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001646 ASTNode::ID right = this->bitwiseXorExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001647 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001648 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001649 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001650 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary, std::move(t));
1651 getNode(newResult).addChild(result);
1652 getNode(newResult).addChild(right);
1653 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001654 }
1655 return result;
1656}
1657
1658/* bitwiseAndExpression (BITWISEXOR bitwiseAndExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001659ASTNode::ID Parser::bitwiseXorExpression() {
1660 ASTNode::ID result = this->bitwiseAndExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001661 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001662 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001663 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001664 Token t;
1665 while (this->checkNext(Token::BITWISEXOR, &t)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001666 ASTNode::ID right = this->bitwiseAndExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001667 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001668 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001669 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001670 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary, std::move(t));
1671 getNode(newResult).addChild(result);
1672 getNode(newResult).addChild(right);
1673 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001674 }
1675 return result;
1676}
1677
1678/* equalityExpression (BITWISEAND equalityExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001679ASTNode::ID Parser::bitwiseAndExpression() {
1680 ASTNode::ID result = this->equalityExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001681 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001682 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001683 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001684 Token t;
1685 while (this->checkNext(Token::BITWISEAND, &t)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001686 ASTNode::ID right = this->equalityExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001687 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001688 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001689 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001690 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary, std::move(t));
1691 getNode(newResult).addChild(result);
1692 getNode(newResult).addChild(right);
1693 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001694 }
1695 return result;
1696}
1697
1698/* relationalExpression ((EQEQ | NEQ) relationalExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001699ASTNode::ID Parser::equalityExpression() {
1700 ASTNode::ID result = this->relationalExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001701 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001702 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001703 }
1704 for (;;) {
1705 switch (this->peek().fKind) {
1706 case Token::EQEQ: // fall through
1707 case Token::NEQ: {
1708 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001709 ASTNode::ID right = this->relationalExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001710 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001711 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001712 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001713 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary,
1714 std::move(t));
1715 getNode(newResult).addChild(result);
1716 getNode(newResult).addChild(right);
1717 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001718 break;
1719 }
1720 default:
1721 return result;
1722 }
1723 }
1724}
1725
1726/* shiftExpression ((LT | GT | LTEQ | GTEQ) shiftExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001727ASTNode::ID Parser::relationalExpression() {
1728 ASTNode::ID result = this->shiftExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001729 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001730 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001731 }
1732 for (;;) {
1733 switch (this->peek().fKind) {
1734 case Token::LT: // fall through
1735 case Token::GT: // fall through
1736 case Token::LTEQ: // fall through
1737 case Token::GTEQ: {
1738 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001739 ASTNode::ID right = this->shiftExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001740 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001741 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001742 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001743 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary,
1744 std::move(t));
1745 getNode(newResult).addChild(result);
1746 getNode(newResult).addChild(right);
1747 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001748 break;
1749 }
1750 default:
1751 return result;
1752 }
1753 }
1754}
1755
1756/* additiveExpression ((SHL | SHR) additiveExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001757ASTNode::ID Parser::shiftExpression() {
1758 ASTNode::ID result = this->additiveExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001759 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001760 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001761 }
1762 for (;;) {
1763 switch (this->peek().fKind) {
1764 case Token::SHL: // fall through
1765 case Token::SHR: {
1766 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001767 ASTNode::ID right = this->additiveExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001768 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001769 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001770 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001771 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary,
1772 std::move(t));
1773 getNode(newResult).addChild(result);
1774 getNode(newResult).addChild(right);
1775 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001776 break;
1777 }
1778 default:
1779 return result;
1780 }
1781 }
1782}
1783
1784/* multiplicativeExpression ((PLUS | MINUS) multiplicativeExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001785ASTNode::ID Parser::additiveExpression() {
1786 ASTNode::ID result = this->multiplicativeExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001787 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001788 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001789 }
1790 for (;;) {
1791 switch (this->peek().fKind) {
1792 case Token::PLUS: // fall through
1793 case Token::MINUS: {
1794 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001795 ASTNode::ID right = this->multiplicativeExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001796 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001797 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001798 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001799 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary,
1800 std::move(t));
1801 getNode(newResult).addChild(result);
1802 getNode(newResult).addChild(right);
1803 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001804 break;
1805 }
1806 default:
1807 return result;
1808 }
1809 }
1810}
1811
1812/* unaryExpression ((STAR | SLASH | PERCENT) unaryExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001813ASTNode::ID Parser::multiplicativeExpression() {
1814 ASTNode::ID result = this->unaryExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001815 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001816 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001817 }
1818 for (;;) {
1819 switch (this->peek().fKind) {
1820 case Token::STAR: // fall through
1821 case Token::SLASH: // fall through
1822 case Token::PERCENT: {
1823 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001824 ASTNode::ID right = this->unaryExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001825 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001826 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001827 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001828 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary,
1829 std::move(t));
1830 getNode(newResult).addChild(result);
1831 getNode(newResult).addChild(right);
1832 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001833 break;
1834 }
1835 default:
1836 return result;
1837 }
1838 }
1839}
1840
1841/* postfixExpression | (PLUS | MINUS | NOT | PLUSPLUS | MINUSMINUS) unaryExpression */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001842ASTNode::ID Parser::unaryExpression() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001843 switch (this->peek().fKind) {
ethannicholas5961bc92016-10-12 06:39:56 -07001844 case Token::PLUS: // fall through
1845 case Token::MINUS: // fall through
1846 case Token::LOGICALNOT: // fall through
1847 case Token::BITWISENOT: // fall through
1848 case Token::PLUSPLUS: // fall through
ethannicholasb3058bd2016-07-01 08:22:01 -07001849 case Token::MINUSMINUS: {
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04001850 Token t = this->nextToken();
Ethan Nicholas6dcc3252019-02-20 15:18:36 -05001851 AutoDepth depth(this);
1852 if (!depth.checkValid()) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001853 return ASTNode::ID::Invalid();
Ethan Nicholas6dcc3252019-02-20 15:18:36 -05001854 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001855 ASTNode::ID expr = this->unaryExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001856 if (!expr) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001857 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001858 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001859 CREATE_NODE(result, t.fOffset, ASTNode::Kind::kPrefix, std::move(t));
1860 getNode(result).addChild(expr);
1861 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001862 }
1863 default:
1864 return this->postfixExpression();
1865 }
1866}
1867
1868/* term suffix* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001869ASTNode::ID Parser::postfixExpression() {
1870 ASTNode::ID result = this->term();
ethannicholasb3058bd2016-07-01 08:22:01 -07001871 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001872 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001873 }
1874 for (;;) {
1875 switch (this->peek().fKind) {
Ethan Nicholase455f652019-09-13 12:52:55 -04001876 case Token::LBRACKET:
1877 case Token::DOT:
1878 case Token::LPAREN:
1879 case Token::PLUSPLUS:
1880 case Token::MINUSMINUS:
Ethan Nicholasfc994162019-06-06 10:04:27 -04001881 case Token::COLONCOLON:
Ethan Nicholase455f652019-09-13 12:52:55 -04001882 case Token::FLOAT_LITERAL:
Ethan Nicholasfc994162019-06-06 10:04:27 -04001883 result = this->suffix(result);
Ethan Nicholas0c8582e2019-07-19 09:26:46 -04001884 if (!result) {
1885 return ASTNode::ID::Invalid();
1886 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001887 break;
ethannicholasb3058bd2016-07-01 08:22:01 -07001888 default:
1889 return result;
1890 }
1891 }
1892}
1893
Ethan Nicholas11d53972016-11-28 11:23:23 -05001894/* LBRACKET expression? RBRACKET | DOT IDENTIFIER | LPAREN parameters RPAREN |
Ethan Nicholase455f652019-09-13 12:52:55 -04001895 PLUSPLUS | MINUSMINUS | COLONCOLON IDENTIFIER | FLOAT_LITERAL [IDENTIFIER] */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001896ASTNode::ID Parser::suffix(ASTNode::ID base) {
Ethan Nicholas0c8582e2019-07-19 09:26:46 -04001897 SkASSERT(base);
ethannicholasb3058bd2016-07-01 08:22:01 -07001898 Token next = this->nextToken();
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04001899 AutoDepth depth(this);
1900 if (!depth.checkValid()) {
1901 return ASTNode::ID::Invalid();
1902 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001903 switch (next.fKind) {
1904 case Token::LBRACKET: {
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001905 if (this->checkNext(Token::RBRACKET)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001906 CREATE_NODE(result, next.fOffset, ASTNode::Kind::kIndex);
1907 getNode(result).addChild(base);
1908 return result;
ethannicholas5961bc92016-10-12 06:39:56 -07001909 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001910 ASTNode::ID e = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001911 if (!e) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001912 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001913 }
1914 this->expect(Token::RBRACKET, "']' to complete array access expression");
Ethan Nicholasfc994162019-06-06 10:04:27 -04001915 CREATE_NODE(result, next.fOffset, ASTNode::Kind::kIndex);
1916 getNode(result).addChild(base);
1917 getNode(result).addChild(e);
1918 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001919 }
Ethan Nicholasaae47c82017-11-10 15:34:03 -05001920 case Token::DOT: // fall through
1921 case Token::COLONCOLON: {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001922 int offset = this->peek().fOffset;
1923 StringFragment text;
ethannicholasb3058bd2016-07-01 08:22:01 -07001924 if (this->identifier(&text)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001925 CREATE_NODE(result, offset, ASTNode::Kind::kField, std::move(text));
1926 getNode(result).addChild(base);
1927 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001928 }
Ethan Nicholase455f652019-09-13 12:52:55 -04001929 }
1930 case Token::FLOAT_LITERAL: {
1931 // Swizzles that start with a constant number, e.g. '.000r', will be tokenized as
1932 // floating point literals, possibly followed by an identifier. Handle that here.
1933 StringFragment field = this->text(next);
1934 SkASSERT(field.fChars[0] == '.');
1935 ++field.fChars;
1936 --field.fLength;
1937 for (size_t i = 0; i < field.fLength; ++i) {
1938 if (field.fChars[i] != '0' && field.fChars[i] != '1') {
1939 this->error(next, "invalid swizzle");
1940 return ASTNode::ID::Invalid();
1941 }
1942 }
1943 // use the next *raw* token so we don't ignore whitespace - we only care about
1944 // identifiers that directly follow the float
1945 Token id = this->nextRawToken();
1946 if (id.fKind == Token::IDENTIFIER) {
1947 field.fLength += id.fLength;
1948 } else {
1949 this->pushback(id);
1950 }
1951 CREATE_NODE(result, next.fOffset, ASTNode::Kind::kField, field);
1952 getNode(result).addChild(base);
1953 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001954 }
1955 case Token::LPAREN: {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001956 CREATE_NODE(result, next.fOffset, ASTNode::Kind::kCall);
1957 getNode(result).addChild(base);
ethannicholasb3058bd2016-07-01 08:22:01 -07001958 if (this->peek().fKind != Token::RPAREN) {
1959 for (;;) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001960 ASTNode::ID expr = this->assignmentExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001961 if (!expr) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001962 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001963 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001964 getNode(result).addChild(expr);
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001965 if (!this->checkNext(Token::COMMA)) {
ethannicholasb3058bd2016-07-01 08:22:01 -07001966 break;
1967 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001968 }
1969 }
1970 this->expect(Token::RPAREN, "')' to complete function parameters");
Ethan Nicholasfc994162019-06-06 10:04:27 -04001971 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001972 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001973 case Token::PLUSPLUS: // fall through
1974 case Token::MINUSMINUS: {
1975 CREATE_NODE(result, next.fOffset, ASTNode::Kind::kPostfix, next);
1976 getNode(result).addChild(base);
1977 return result;
1978 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001979 default: {
Ethan Nicholas0c8582e2019-07-19 09:26:46 -04001980 this->error(next, "expected expression suffix, but found '" + this->text(next) + "'");
Ethan Nicholasfc994162019-06-06 10:04:27 -04001981 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001982 }
1983 }
1984}
1985
Ethan Nicholasee1c8a72019-02-22 10:50:47 -05001986/* IDENTIFIER | intLiteral | floatLiteral | boolLiteral | NULL_LITERAL | '(' expression ')' */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001987ASTNode::ID Parser::term() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001988 Token t = this->peek();
1989 switch (t.fKind) {
1990 case Token::IDENTIFIER: {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001991 StringFragment text;
ethannicholasb3058bd2016-07-01 08:22:01 -07001992 if (this->identifier(&text)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001993 RETURN_NODE(t.fOffset, ASTNode::Kind::kIdentifier, std::move(text));
ethannicholasb3058bd2016-07-01 08:22:01 -07001994 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001995 }
1996 case Token::INT_LITERAL: {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001997 SKSL_INT i;
ethannicholasb3058bd2016-07-01 08:22:01 -07001998 if (this->intLiteral(&i)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001999 RETURN_NODE(t.fOffset, ASTNode::Kind::kInt, i);
ethannicholasb3058bd2016-07-01 08:22:01 -07002000 }
2001 break;
2002 }
2003 case Token::FLOAT_LITERAL: {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002004 SKSL_FLOAT f;
ethannicholasb3058bd2016-07-01 08:22:01 -07002005 if (this->floatLiteral(&f)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002006 RETURN_NODE(t.fOffset, ASTNode::Kind::kFloat, f);
ethannicholasb3058bd2016-07-01 08:22:01 -07002007 }
2008 break;
2009 }
2010 case Token::TRUE_LITERAL: // fall through
2011 case Token::FALSE_LITERAL: {
2012 bool b;
2013 if (this->boolLiteral(&b)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002014 RETURN_NODE(t.fOffset, ASTNode::Kind::kBool, b);
ethannicholasb3058bd2016-07-01 08:22:01 -07002015 }
2016 break;
2017 }
Ethan Nicholasee1c8a72019-02-22 10:50:47 -05002018 case Token::NULL_LITERAL:
2019 this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04002020 RETURN_NODE(t.fOffset, ASTNode::Kind::kNull);
ethannicholasb3058bd2016-07-01 08:22:01 -07002021 case Token::LPAREN: {
2022 this->nextToken();
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04002023 AutoDepth depth(this);
2024 if (!depth.checkValid()) {
2025 return ASTNode::ID::Invalid();
2026 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04002027 ASTNode::ID result = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07002028 if (result) {
2029 this->expect(Token::RPAREN, "')' to complete expression");
Ethan Nicholasfc994162019-06-06 10:04:27 -04002030 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07002031 }
2032 break;
2033 }
2034 default:
2035 this->nextToken();
Ethan Nicholas0c8582e2019-07-19 09:26:46 -04002036 this->error(t.fOffset, "expected expression, but found '" + this->text(t) + "'");
ethannicholasb3058bd2016-07-01 08:22:01 -07002037 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04002038 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07002039}
2040
2041/* INT_LITERAL */
Ethan Nicholasfc994162019-06-06 10:04:27 -04002042bool Parser::intLiteral(SKSL_INT* dest) {
ethannicholasb3058bd2016-07-01 08:22:01 -07002043 Token t;
2044 if (this->expect(Token::INT_LITERAL, "integer literal", &t)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07002045 *dest = SkSL::stol(this->text(t));
ethannicholasb3058bd2016-07-01 08:22:01 -07002046 return true;
2047 }
2048 return false;
2049}
2050
2051/* FLOAT_LITERAL */
Ethan Nicholasfc994162019-06-06 10:04:27 -04002052bool Parser::floatLiteral(SKSL_FLOAT* dest) {
ethannicholasb3058bd2016-07-01 08:22:01 -07002053 Token t;
2054 if (this->expect(Token::FLOAT_LITERAL, "float literal", &t)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07002055 *dest = SkSL::stod(this->text(t));
ethannicholasb3058bd2016-07-01 08:22:01 -07002056 return true;
2057 }
2058 return false;
2059}
2060
2061/* TRUE_LITERAL | FALSE_LITERAL */
2062bool Parser::boolLiteral(bool* dest) {
2063 Token t = this->nextToken();
2064 switch (t.fKind) {
2065 case Token::TRUE_LITERAL:
2066 *dest = true;
2067 return true;
2068 case Token::FALSE_LITERAL:
2069 *dest = false;
2070 return true;
2071 default:
Ethan Nicholas0c8582e2019-07-19 09:26:46 -04002072 this->error(t, "expected 'true' or 'false', but found '" + this->text(t) + "'");
ethannicholasb3058bd2016-07-01 08:22:01 -07002073 return false;
2074 }
2075}
2076
2077/* IDENTIFIER */
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07002078bool Parser::identifier(StringFragment* dest) {
ethannicholasb3058bd2016-07-01 08:22:01 -07002079 Token t;
2080 if (this->expect(Token::IDENTIFIER, "identifier", &t)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07002081 *dest = this->text(t);
ethannicholasb3058bd2016-07-01 08:22:01 -07002082 return true;
2083 }
2084 return false;
2085}
2086
2087} // namespace