blob: 9329ca4d6d6e734078ce65cecaf148066bf48ac7 [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
Mike Klein4b432fa2019-06-06 11:44:05 -05008#include "src/sksl/SkSLParser.h"
John Stilesfbd050b2020-08-03 13:21:46 -04009
10#include <memory>
11#include "stdio.h"
12
13#include "src/sksl/SkSLASTNode.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050014#include "src/sksl/ir/SkSLModifiers.h"
15#include "src/sksl/ir/SkSLSymbolTable.h"
16#include "src/sksl/ir/SkSLType.h"
ethannicholasb3058bd2016-07-01 08:22:01 -070017
Ethan Nicholasb93af7e2018-07-24 11:28:52 -040018#ifndef SKSL_STANDALONE
Mike Kleinc0bd9f92019-04-23 12:05:21 -050019#include "include/private/SkOnce.h"
Ethan Nicholasb93af7e2018-07-24 11:28:52 -040020#endif
21
ethannicholasb3058bd2016-07-01 08:22:01 -070022namespace SkSL {
23
ethannicholascad64162016-10-27 10:54:02 -070024#define MAX_PARSE_DEPTH 50
25
26class AutoDepth {
27public:
28 AutoDepth(Parser* p)
Ethan Nicholascf4deab2019-09-13 16:28:14 -040029 : fParser(p)
30 , fDepth(0) {}
ethannicholascad64162016-10-27 10:54:02 -070031
32 ~AutoDepth() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -040033 fParser->fDepth -= fDepth;
ethannicholascad64162016-10-27 10:54:02 -070034 }
35
Ethan Nicholascf4deab2019-09-13 16:28:14 -040036 bool increase() {
37 ++fDepth;
38 ++fParser->fDepth;
ethannicholascad64162016-10-27 10:54:02 -070039 if (fParser->fDepth > MAX_PARSE_DEPTH) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -070040 fParser->error(fParser->peek(), String("exceeded max parse depth"));
ethannicholascad64162016-10-27 10:54:02 -070041 return false;
42 }
43 return true;
44 }
45
46private:
47 Parser* fParser;
Ethan Nicholascf4deab2019-09-13 16:28:14 -040048 int fDepth;
ethannicholascad64162016-10-27 10:54:02 -070049};
50
Brian Salomon140f3da2018-08-23 13:51:27 +000051std::unordered_map<String, Parser::LayoutToken>* Parser::layoutTokens;
Ethan Nicholasb93af7e2018-07-24 11:28:52 -040052
53void Parser::InitLayoutMap() {
Brian Salomon140f3da2018-08-23 13:51:27 +000054 layoutTokens = new std::unordered_map<String, LayoutToken>;
Brian Salomon23356442018-11-30 15:33:19 -050055 #define TOKEN(name, text) (*layoutTokens)[text] = LayoutToken::name
Ethan Nicholasb93af7e2018-07-24 11:28:52 -040056 TOKEN(LOCATION, "location");
57 TOKEN(OFFSET, "offset");
58 TOKEN(BINDING, "binding");
59 TOKEN(INDEX, "index");
60 TOKEN(SET, "set");
61 TOKEN(BUILTIN, "builtin");
62 TOKEN(INPUT_ATTACHMENT_INDEX, "input_attachment_index");
63 TOKEN(ORIGIN_UPPER_LEFT, "origin_upper_left");
64 TOKEN(OVERRIDE_COVERAGE, "override_coverage");
65 TOKEN(BLEND_SUPPORT_ALL_EQUATIONS, "blend_support_all_equations");
66 TOKEN(BLEND_SUPPORT_MULTIPLY, "blend_support_multiply");
67 TOKEN(BLEND_SUPPORT_SCREEN, "blend_support_screen");
68 TOKEN(BLEND_SUPPORT_OVERLAY, "blend_support_overlay");
69 TOKEN(BLEND_SUPPORT_DARKEN, "blend_support_darken");
70 TOKEN(BLEND_SUPPORT_LIGHTEN, "blend_support_lighten");
71 TOKEN(BLEND_SUPPORT_COLORDODGE, "blend_support_colordodge");
72 TOKEN(BLEND_SUPPORT_COLORBURN, "blend_support_colorburn");
73 TOKEN(BLEND_SUPPORT_HARDLIGHT, "blend_support_hardlight");
74 TOKEN(BLEND_SUPPORT_SOFTLIGHT, "blend_support_softlight");
75 TOKEN(BLEND_SUPPORT_DIFFERENCE, "blend_support_difference");
76 TOKEN(BLEND_SUPPORT_EXCLUSION, "blend_support_exclusion");
77 TOKEN(BLEND_SUPPORT_HSL_HUE, "blend_support_hsl_hue");
78 TOKEN(BLEND_SUPPORT_HSL_SATURATION, "blend_support_hsl_saturation");
79 TOKEN(BLEND_SUPPORT_HSL_COLOR, "blend_support_hsl_color");
80 TOKEN(BLEND_SUPPORT_HSL_LUMINOSITY, "blend_support_hsl_luminosity");
81 TOKEN(PUSH_CONSTANT, "push_constant");
82 TOKEN(POINTS, "points");
83 TOKEN(LINES, "lines");
84 TOKEN(LINE_STRIP, "line_strip");
85 TOKEN(LINES_ADJACENCY, "lines_adjacency");
86 TOKEN(TRIANGLES, "triangles");
87 TOKEN(TRIANGLE_STRIP, "triangle_strip");
88 TOKEN(TRIANGLES_ADJACENCY, "triangles_adjacency");
89 TOKEN(MAX_VERTICES, "max_vertices");
90 TOKEN(INVOCATIONS, "invocations");
Brian Osmanf59a9612020-04-15 14:18:13 -040091 TOKEN(MARKER, "marker");
Ethan Nicholasb93af7e2018-07-24 11:28:52 -040092 TOKEN(WHEN, "when");
93 TOKEN(KEY, "key");
Michael Ludwiga4275592018-08-31 10:52:47 -040094 TOKEN(TRACKED, "tracked");
Brian Osmanb32d66b2020-04-30 17:12:03 -040095 TOKEN(SRGB_UNPREMUL, "srgb_unpremul");
Ethan Nicholas78aceb22018-08-31 16:13:58 -040096 TOKEN(CTYPE, "ctype");
Brian Osmanf28e55d2018-10-03 16:35:54 -040097 TOKEN(SKPMCOLOR4F, "SkPMColor4f");
Mike Reedb26b4e72020-01-22 14:31:21 -050098 TOKEN(SKV4, "SkV4");
Ethan Nicholas78aceb22018-08-31 16:13:58 -040099 TOKEN(SKRECT, "SkRect");
100 TOKEN(SKIRECT, "SkIRect");
101 TOKEN(SKPMCOLOR, "SkPMColor");
Mike Reedb26b4e72020-01-22 14:31:21 -0500102 TOKEN(SKM44, "SkM44");
Ethan Nicholasc1c686b2019-04-02 17:30:23 -0400103 TOKEN(BOOL, "bool");
104 TOKEN(INT, "int");
105 TOKEN(FLOAT, "float");
Ethan Nicholasb93af7e2018-07-24 11:28:52 -0400106 #undef TOKEN
107}
108
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400109Parser::Parser(const char* text, size_t length, SymbolTable& symbols, ErrorReporter& errors)
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700110: fText(text)
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400111, fPushback(Token::Kind::TK_INVALID, -1, -1)
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400112, fSymbols(symbols)
ethannicholasb3058bd2016-07-01 08:22:01 -0700113, fErrors(errors) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700114 fLexer.start(text, length);
Brian Salomon3b83afe2018-08-23 11:04:36 -0400115 static const bool layoutMapInitialized = []{ return (void)InitLayoutMap(), true; }();
116 (void) layoutMapInitialized;
ethannicholasb3058bd2016-07-01 08:22:01 -0700117}
118
Ethan Nicholasfc994162019-06-06 10:04:27 -0400119#define CREATE_NODE(result, ...) \
120 ASTNode::ID result(fFile->fNodes.size()); \
121 fFile->fNodes.emplace_back(&fFile->fNodes, __VA_ARGS__)
122
123#define RETURN_NODE(...) \
124 do { \
125 CREATE_NODE(result, __VA_ARGS__); \
126 return result; \
127 } while (false)
128
129#define CREATE_CHILD(child, target, ...) \
130 CREATE_NODE(child, __VA_ARGS__); \
131 fFile->fNodes[target.fValue].addChild(child)
132
133#define CREATE_EMPTY_CHILD(target) \
134 do { \
135 ASTNode::ID child(fFile->fNodes.size()); \
136 fFile->fNodes.emplace_back(); \
137 fFile->fNodes[target.fValue].addChild(child); \
138 } while (false)
139
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400140/* (directive | section | declaration)* END_OF_FILE */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400141std::unique_ptr<ASTFile> Parser::file() {
John Stilesfbd050b2020-08-03 13:21:46 -0400142 fFile = std::make_unique<ASTFile>();
Ethan Nicholasfc994162019-06-06 10:04:27 -0400143 CREATE_NODE(result, 0, ASTNode::Kind::kFile);
144 fFile->fRoot = result;
ethannicholasb3058bd2016-07-01 08:22:01 -0700145 for (;;) {
146 switch (this->peek().fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400147 case Token::Kind::TK_END_OF_FILE:
Ethan Nicholasfc994162019-06-06 10:04:27 -0400148 return std::move(fFile);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400149 case Token::Kind::TK_DIRECTIVE: {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400150 ASTNode::ID dir = this->directive();
151 if (fErrors.errorCount()) {
152 return nullptr;
153 }
154 if (dir) {
155 getNode(result).addChild(dir);
ethannicholasb3058bd2016-07-01 08:22:01 -0700156 }
157 break;
158 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400159 case Token::Kind::TK_SECTION: {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400160 ASTNode::ID section = this->section();
161 if (fErrors.errorCount()) {
162 return nullptr;
163 }
Ethan Nicholas762466e2017-06-29 10:03:38 -0400164 if (section) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400165 getNode(result).addChild(section);
Ethan Nicholas762466e2017-06-29 10:03:38 -0400166 }
167 break;
168 }
ethannicholasb3058bd2016-07-01 08:22:01 -0700169 default: {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400170 ASTNode::ID decl = this->declaration();
171 if (fErrors.errorCount()) {
172 return nullptr;
ethannicholasb3058bd2016-07-01 08:22:01 -0700173 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400174 if (decl) {
175 getNode(result).addChild(decl);
176 }
ethannicholasb3058bd2016-07-01 08:22:01 -0700177 }
178 }
179 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400180 return std::move(fFile);
ethannicholasb3058bd2016-07-01 08:22:01 -0700181}
182
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700183Token Parser::nextRawToken() {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400184 if (fPushback.fKind != Token::Kind::TK_INVALID) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700185 Token result = fPushback;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400186 fPushback.fKind = Token::Kind::TK_INVALID;
ethannicholasb3058bd2016-07-01 08:22:01 -0700187 return result;
188 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700189 Token result = fLexer.next();
190 return result;
Ethan Nicholas762466e2017-06-29 10:03:38 -0400191}
192
193Token Parser::nextToken() {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700194 Token token = this->nextRawToken();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400195 while (token.fKind == Token::Kind::TK_WHITESPACE ||
196 token.fKind == Token::Kind::TK_LINE_COMMENT ||
197 token.fKind == Token::Kind::TK_BLOCK_COMMENT) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700198 token = this->nextRawToken();
199 }
Ethan Nicholas762466e2017-06-29 10:03:38 -0400200 return token;
ethannicholasb3058bd2016-07-01 08:22:01 -0700201}
202
203void Parser::pushback(Token t) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400204 SkASSERT(fPushback.fKind == Token::Kind::TK_INVALID);
Ethan Nicholas08b79b72017-08-14 10:35:37 -0400205 fPushback = std::move(t);
ethannicholasb3058bd2016-07-01 08:22:01 -0700206}
207
208Token Parser::peek() {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400209 if (fPushback.fKind == Token::Kind::TK_INVALID) {
Brian Osman634624a2017-08-15 11:14:30 -0400210 fPushback = this->nextToken();
211 }
ethannicholasb3058bd2016-07-01 08:22:01 -0700212 return fPushback;
213}
214
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400215bool Parser::checkNext(Token::Kind kind, Token* result) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400216 if (fPushback.fKind != Token::Kind::TK_INVALID && fPushback.fKind != kind) {
Brian Osman634624a2017-08-15 11:14:30 -0400217 return false;
218 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400219 Token next = this->nextToken();
220 if (next.fKind == kind) {
221 if (result) {
222 *result = next;
223 }
224 return true;
225 }
Ethan Nicholas08b79b72017-08-14 10:35:37 -0400226 this->pushback(std::move(next));
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400227 return false;
228}
Ethan Nicholas9e1138d2016-11-21 10:39:35 -0500229
230bool Parser::expect(Token::Kind kind, const char* expected, Token* result) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700231 Token next = this->nextToken();
232 if (next.fKind == kind) {
233 if (result) {
Brian Osman634624a2017-08-15 11:14:30 -0400234 *result = std::move(next);
ethannicholasb3058bd2016-07-01 08:22:01 -0700235 }
236 return true;
237 } else {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700238 this->error(next, "expected " + String(expected) + ", but found '" +
239 this->text(next) + "'");
ethannicholasb3058bd2016-07-01 08:22:01 -0700240 return false;
241 }
242}
243
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700244StringFragment Parser::text(Token token) {
245 return StringFragment(fText + token.fOffset, token.fLength);
Ethan Nicholas9e1138d2016-11-21 10:39:35 -0500246}
247
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700248void Parser::error(Token token, String msg) {
249 this->error(token.fOffset, msg);
ethannicholasb3058bd2016-07-01 08:22:01 -0700250}
251
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700252void Parser::error(int offset, String msg) {
253 fErrors.error(offset, msg);
254}
255
256bool Parser::isType(StringFragment name) {
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400257 const Symbol* s = fSymbols[name];
Ethan Nicholase6592142020-09-08 10:22:09 -0400258 return s && s->kind() == Symbol::Kind::kType;
ethannicholasb3058bd2016-07-01 08:22:01 -0700259}
260
Ethan Nicholas11d53972016-11-28 11:23:23 -0500261/* DIRECTIVE(#version) INT_LITERAL ("es" | "compatibility")? |
ethannicholas5961bc92016-10-12 06:39:56 -0700262 DIRECTIVE(#extension) IDENTIFIER COLON IDENTIFIER */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400263ASTNode::ID Parser::directive() {
ethannicholasb3058bd2016-07-01 08:22:01 -0700264 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400265 if (!this->expect(Token::Kind::TK_DIRECTIVE, "a directive", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400266 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700267 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700268 StringFragment text = this->text(start);
Ethan Nicholasfc994162019-06-06 10:04:27 -0400269 if (text == "#extension") {
ethannicholasb3058bd2016-07-01 08:22:01 -0700270 Token name;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400271 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400272 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700273 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400274 if (!this->expect(Token::Kind::TK_COLON, "':'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400275 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700276 }
277 // FIXME: need to start paying attention to this token
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400278 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400279 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700280 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400281 RETURN_NODE(start.fOffset, ASTNode::Kind::kExtension, this->text(name));
ethannicholasb3058bd2016-07-01 08:22:01 -0700282 } else {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700283 this->error(start, "unsupported directive '" + this->text(start) + "'");
Ethan Nicholasfc994162019-06-06 10:04:27 -0400284 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700285 }
286}
287
Ethan Nicholas762466e2017-06-29 10:03:38 -0400288/* SECTION LBRACE (LPAREN IDENTIFIER RPAREN)? <any sequence of tokens with balanced braces>
289 RBRACE */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400290ASTNode::ID Parser::section() {
Ethan Nicholas762466e2017-06-29 10:03:38 -0400291 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400292 if (!this->expect(Token::Kind::TK_SECTION, "a section token", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400293 return ASTNode::ID::Invalid();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400294 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400295 StringFragment argument;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400296 if (this->peek().fKind == Token::Kind::TK_LPAREN) {
Ethan Nicholas762466e2017-06-29 10:03:38 -0400297 this->nextToken();
298 Token argToken;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400299 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &argToken)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400300 return ASTNode::ID::Invalid();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400301 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700302 argument = this->text(argToken);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400303 if (!this->expect(Token::Kind::TK_RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400304 return ASTNode::ID::Invalid();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400305 }
306 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400307 if (!this->expect(Token::Kind::TK_LBRACE, "'{'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400308 return ASTNode::ID::Invalid();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400309 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400310 StringFragment text;
311 Token codeStart = this->nextRawToken();
312 size_t startOffset = codeStart.fOffset;
313 this->pushback(codeStart);
314 text.fChars = fText + startOffset;
Ethan Nicholas762466e2017-06-29 10:03:38 -0400315 int level = 1;
316 for (;;) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700317 Token next = this->nextRawToken();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400318 switch (next.fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400319 case Token::Kind::TK_LBRACE:
Ethan Nicholas762466e2017-06-29 10:03:38 -0400320 ++level;
321 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400322 case Token::Kind::TK_RBRACE:
Ethan Nicholas762466e2017-06-29 10:03:38 -0400323 --level;
324 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400325 case Token::Kind::TK_END_OF_FILE:
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700326 this->error(start, "reached end of file while parsing section");
Ethan Nicholasfc994162019-06-06 10:04:27 -0400327 return ASTNode::ID::Invalid();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400328 default:
329 break;
330 }
331 if (!level) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400332 text.fLength = next.fOffset - startOffset;
Ethan Nicholas762466e2017-06-29 10:03:38 -0400333 break;
334 }
Ethan Nicholas762466e2017-06-29 10:03:38 -0400335 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700336 StringFragment name = this->text(start);
337 ++name.fChars;
338 --name.fLength;
Ethan Nicholasfc994162019-06-06 10:04:27 -0400339 RETURN_NODE(start.fOffset, ASTNode::Kind::kSection,
340 ASTNode::SectionData(name, argument, text));
Ethan Nicholas762466e2017-06-29 10:03:38 -0400341}
342
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500343/* ENUM CLASS IDENTIFIER LBRACE (IDENTIFIER (EQ expression)? (COMMA IDENTIFIER (EQ expression))*)?
344 RBRACE */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400345ASTNode::ID Parser::enumDeclaration() {
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500346 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400347 if (!this->expect(Token::Kind::TK_ENUM, "'enum'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400348 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500349 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400350 if (!this->expect(Token::Kind::TK_CLASS, "'class'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400351 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500352 }
353 Token name;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400354 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400355 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500356 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400357 if (!this->expect(Token::Kind::TK_LBRACE, "'{'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400358 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500359 }
John Stilesb8cc6652020-10-08 09:12:07 -0400360 fSymbols.add(std::make_unique<Type>(this->text(name), Type::TypeKind::kEnum));
Ethan Nicholasfc994162019-06-06 10:04:27 -0400361 CREATE_NODE(result, name.fOffset, ASTNode::Kind::kEnum, this->text(name));
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400362 if (!this->checkNext(Token::Kind::TK_RBRACE)) {
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500363 Token id;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400364 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &id)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400365 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500366 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400367 if (this->checkNext(Token::Kind::TK_EQ)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400368 ASTNode::ID value = this->assignmentExpression();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500369 if (!value) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400370 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500371 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400372 CREATE_CHILD(child, result, id.fOffset, ASTNode::Kind::kEnumCase, this->text(id));
373 getNode(child).addChild(value);
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500374 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400375 CREATE_CHILD(child, result, id.fOffset, ASTNode::Kind::kEnumCase, this->text(id));
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500376 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400377 while (!this->checkNext(Token::Kind::TK_RBRACE)) {
378 if (!this->expect(Token::Kind::TK_COMMA, "','")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400379 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500380 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400381 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &id)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400382 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500383 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400384 if (this->checkNext(Token::Kind::TK_EQ)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400385 ASTNode::ID value = this->assignmentExpression();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500386 if (!value) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400387 return ASTNode::ID::Invalid();
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500388 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400389 CREATE_CHILD(child, result, id.fOffset, ASTNode::Kind::kEnumCase, this->text(id));
390 getNode(child).addChild(value);
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500391 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400392 CREATE_CHILD(child, result, id.fOffset, ASTNode::Kind::kEnumCase, this->text(id));
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500393 }
394 }
395 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400396 this->expect(Token::Kind::TK_SEMICOLON, "';'");
Ethan Nicholasfc994162019-06-06 10:04:27 -0400397 return result;
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500398}
399
400/* enumDeclaration | modifiers (structVarDeclaration | type IDENTIFIER ((LPAREN parameter
ethannicholasb3058bd2016-07-01 08:22:01 -0700401 (COMMA parameter)* RPAREN (block | SEMICOLON)) | SEMICOLON) | interfaceBlock) */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400402ASTNode::ID Parser::declaration() {
ethannicholasb3058bd2016-07-01 08:22:01 -0700403 Token lookahead = this->peek();
Ethan Nicholasda6320c2020-09-02 14:08:23 -0400404 switch (lookahead.fKind) {
405 case Token::Kind::TK_ENUM:
406 return this->enumDeclaration();
407 case Token::Kind::TK_SEMICOLON:
408 this->error(lookahead.fOffset, "expected a declaration, but found ';'");
409 return ASTNode::ID::Invalid();
410 default:
411 break;
Ethan Nicholasaae47c82017-11-10 15:34:03 -0500412 }
413 Modifiers modifiers = this->modifiers();
414 lookahead = this->peek();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400415 if (lookahead.fKind == Token::Kind::TK_IDENTIFIER && !this->isType(this->text(lookahead))) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700416 // we have an identifier that's not a type, could be the start of an interface block
417 return this->interfaceBlock(modifiers);
418 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400419 if (lookahead.fKind == Token::Kind::TK_STRUCT) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700420 return this->structVarDeclaration(modifiers);
421 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400422 if (lookahead.fKind == Token::Kind::TK_SEMICOLON) {
ethannicholas5961bc92016-10-12 06:39:56 -0700423 this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -0400424 RETURN_NODE(lookahead.fOffset, ASTNode::Kind::kModifiers, modifiers);
ethannicholas5961bc92016-10-12 06:39:56 -0700425 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400426 ASTNode::ID type = this->type();
ethannicholasb3058bd2016-07-01 08:22:01 -0700427 if (!type) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400428 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700429 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400430 if (getNode(type).getTypeData().fIsStructDeclaration &&
431 this->checkNext(Token::Kind::TK_SEMICOLON)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400432 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700433 }
434 Token name;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400435 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400436 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700437 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400438 if (this->checkNext(Token::Kind::TK_LPAREN)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400439 CREATE_NODE(result, name.fOffset, ASTNode::Kind::kFunction);
440 ASTNode::FunctionData fd(modifiers, this->text(name), 0);
441 getNode(result).addChild(type);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400442 if (this->peek().fKind != Token::Kind::TK_RPAREN) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400443 for (;;) {
444 ASTNode::ID parameter = this->parameter();
445 if (!parameter) {
446 return ASTNode::ID::Invalid();
447 }
448 ++fd.fParameterCount;
449 getNode(result).addChild(parameter);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400450 if (!this->checkNext(Token::Kind::TK_COMMA)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400451 break;
ethannicholasb3058bd2016-07-01 08:22:01 -0700452 }
453 }
ethannicholasb3058bd2016-07-01 08:22:01 -0700454 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400455 getNode(result).setFunctionData(fd);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400456 if (!this->expect(Token::Kind::TK_RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400457 return ASTNode::ID::Invalid();
458 }
459 ASTNode::ID body;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400460 if (!this->checkNext(Token::Kind::TK_SEMICOLON)) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700461 body = this->block();
462 if (!body) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400463 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700464 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400465 getNode(result).addChild(body);
ethannicholasb3058bd2016-07-01 08:22:01 -0700466 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400467 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -0700468 } else {
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
473/* modifiers type IDENTIFIER varDeclarationEnd */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400474ASTNode::ID Parser::varDeclarations() {
Ethan Nicholas11d53972016-11-28 11:23:23 -0500475 Modifiers modifiers = this->modifiers();
Ethan Nicholasfc994162019-06-06 10:04:27 -0400476 ASTNode::ID type = this->type();
ethannicholasb3058bd2016-07-01 08:22:01 -0700477 if (!type) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400478 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700479 }
480 Token name;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400481 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400482 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700483 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400484 return this->varDeclarationEnd(modifiers, type, this->text(name));
ethannicholasb3058bd2016-07-01 08:22:01 -0700485}
486
487/* STRUCT IDENTIFIER LBRACE varDeclaration* RBRACE */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400488ASTNode::ID Parser::structDeclaration() {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400489 if (!this->expect(Token::Kind::TK_STRUCT, "'struct'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400490 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700491 }
492 Token name;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400493 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400494 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700495 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400496 if (!this->expect(Token::Kind::TK_LBRACE, "'{'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400497 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700498 }
499 std::vector<Type::Field> fields;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400500 while (this->peek().fKind != Token::Kind::TK_RBRACE) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400501 ASTNode::ID decls = this->varDeclarations();
502 if (!decls) {
503 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700504 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400505 ASTNode& declsNode = getNode(decls);
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400506 const Symbol* symbol = fSymbols[(declsNode.begin() + 1)->getTypeData().fName];
Ethan Nicholase6592142020-09-08 10:22:09 -0400507 SkASSERT(symbol && symbol->kind() == Symbol::Kind::kType);
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400508 const Type* type = (const Type*) symbol;
Ethan Nicholasfc994162019-06-06 10:04:27 -0400509 for (auto iter = declsNode.begin() + 2; iter != declsNode.end(); ++iter) {
510 ASTNode& var = *iter;
511 ASTNode::VarData vd = var.getVarData();
512 for (int j = vd.fSizeCount - 1; j >= 0; j--) {
513 const ASTNode& size = *(var.begin() + j);
514 if (!size || size.fKind != ASTNode::Kind::kInt) {
515 this->error(declsNode.fOffset, "array size in struct field must be a constant");
516 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700517 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400518 uint64_t columns = size.getInt();
John Stilesf621e232020-08-25 13:33:02 -0400519 String typeName = type->name() + "[" + to_string(columns) + "]";
John Stiles3ae071e2020-08-05 15:29:29 -0400520 type = fSymbols.takeOwnershipOfSymbol(
Ethan Nicholase6592142020-09-08 10:22:09 -0400521 std::make_unique<Type>(typeName, Type::TypeKind::kArray, *type,
522 (int)columns));
ethannicholasb3058bd2016-07-01 08:22:01 -0700523 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400524 fields.push_back(Type::Field(declsNode.begin()->getModifiers(), vd.fName, type));
525 if (vd.fSizeCount ? (var.begin() + (vd.fSizeCount - 1))->fNext : var.fFirstChild) {
526 this->error(declsNode.fOffset, "initializers are not permitted on struct fields");
ethannicholasb3058bd2016-07-01 08:22:01 -0700527 }
528 }
529 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400530 if (!this->expect(Token::Kind::TK_RBRACE, "'}'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400531 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700532 }
John Stilesb8cc6652020-10-08 09:12:07 -0400533 fSymbols.add(std::make_unique<Type>(name.fOffset, this->text(name), fields));
Ethan Nicholasfc994162019-06-06 10:04:27 -0400534 RETURN_NODE(name.fOffset, ASTNode::Kind::kType,
535 ASTNode::TypeData(this->text(name), true, false));
ethannicholasb3058bd2016-07-01 08:22:01 -0700536}
537
538/* structDeclaration ((IDENTIFIER varDeclarationEnd) | SEMICOLON) */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400539ASTNode::ID Parser::structVarDeclaration(Modifiers modifiers) {
540 ASTNode::ID type = this->structDeclaration();
ethannicholasb3058bd2016-07-01 08:22:01 -0700541 if (!type) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400542 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700543 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -0400544 Token name;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400545 if (this->checkNext(Token::Kind::TK_IDENTIFIER, &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400546 return this->varDeclarationEnd(modifiers, std::move(type), this->text(name));
ethannicholasb3058bd2016-07-01 08:22:01 -0700547 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400548 this->expect(Token::Kind::TK_SEMICOLON, "';'");
Ethan Nicholasfc994162019-06-06 10:04:27 -0400549 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700550}
551
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400552/* (LBRACKET expression? RBRACKET)* (EQ assignmentExpression)? (COMMA IDENTIFER
553 (LBRACKET expression? RBRACKET)* (EQ assignmentExpression)?)* SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400554ASTNode::ID Parser::varDeclarationEnd(Modifiers mods, ASTNode::ID type, StringFragment name) {
555 CREATE_NODE(result, -1, ASTNode::Kind::kVarDeclarations);
556 CREATE_CHILD(modifiers, result, -1, ASTNode::Kind::kModifiers, mods);
557 getNode(result).addChild(type);
558 CREATE_NODE(currentVar, -1, ASTNode::Kind::kVarDeclaration);
559 ASTNode::VarData vd(name, 0);
560 getNode(result).addChild(currentVar);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400561 while (this->checkNext(Token::Kind::TK_LBRACKET)) {
562 if (this->checkNext(Token::Kind::TK_RBRACKET)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400563 CREATE_EMPTY_CHILD(currentVar);
ethannicholasb3058bd2016-07-01 08:22:01 -0700564 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400565 ASTNode::ID size = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -0700566 if (!size) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400567 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700568 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400569 getNode(currentVar).addChild(size);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400570 if (!this->expect(Token::Kind::TK_RBRACKET, "']'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400571 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700572 }
573 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400574 ++vd.fSizeCount;
ethannicholasb3058bd2016-07-01 08:22:01 -0700575 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400576 getNode(currentVar).setVarData(vd);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400577 if (this->checkNext(Token::Kind::TK_EQ)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400578 ASTNode::ID value = this->assignmentExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -0700579 if (!value) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400580 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700581 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400582 getNode(currentVar).addChild(value);
ethannicholasb3058bd2016-07-01 08:22:01 -0700583 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400584 while (this->checkNext(Token::Kind::TK_COMMA)) {
John Stilesf621e232020-08-25 13:33:02 -0400585 Token identifierName;
586 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &identifierName)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400587 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700588 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400589 currentVar = ASTNode::ID(fFile->fNodes.size());
John Stilesf621e232020-08-25 13:33:02 -0400590 vd = ASTNode::VarData(this->text(identifierName), 0);
Ethan Nicholasfc994162019-06-06 10:04:27 -0400591 fFile->fNodes.emplace_back(&fFile->fNodes, -1, ASTNode::Kind::kVarDeclaration);
592 getNode(result).addChild(currentVar);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400593 while (this->checkNext(Token::Kind::TK_LBRACKET)) {
594 if (this->checkNext(Token::Kind::TK_RBRACKET)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400595 CREATE_EMPTY_CHILD(currentVar);
ethannicholasb3058bd2016-07-01 08:22:01 -0700596 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400597 ASTNode::ID size = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -0700598 if (!size) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400599 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700600 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400601 getNode(currentVar).addChild(size);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400602 if (!this->expect(Token::Kind::TK_RBRACKET, "']'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400603 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700604 }
605 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400606 ++vd.fSizeCount;
ethannicholasb3058bd2016-07-01 08:22:01 -0700607 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400608 getNode(currentVar).setVarData(vd);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400609 if (this->checkNext(Token::Kind::TK_EQ)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400610 ASTNode::ID value = this->assignmentExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -0700611 if (!value) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400612 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700613 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400614 getNode(currentVar).addChild(value);
ethannicholasb3058bd2016-07-01 08:22:01 -0700615 }
616 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400617 if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
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 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -0700621}
622
623/* modifiers type IDENTIFIER (LBRACKET INT_LITERAL RBRACKET)? */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400624ASTNode::ID Parser::parameter() {
Ethan Nicholasc6f5e102017-03-31 14:53:17 -0400625 Modifiers modifiers = this->modifiersWithDefaults(0);
Ethan Nicholasfc994162019-06-06 10:04:27 -0400626 ASTNode::ID type = this->type();
ethannicholasb3058bd2016-07-01 08:22:01 -0700627 if (!type) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400628 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700629 }
630 Token name;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400631 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400632 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700633 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400634 CREATE_NODE(result, name.fOffset, ASTNode::Kind::kParameter);
635 ASTNode::ParameterData pd(modifiers, this->text(name), 0);
636 getNode(result).addChild(type);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400637 while (this->checkNext(Token::Kind::TK_LBRACKET)) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700638 Token sizeToken;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400639 if (!this->expect(Token::Kind::TK_INT_LITERAL, "a positive integer", &sizeToken)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400640 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700641 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400642 CREATE_CHILD(child, result, sizeToken.fOffset, ASTNode::Kind::kInt,
643 SkSL::stoi(this->text(sizeToken)));
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400644 if (!this->expect(Token::Kind::TK_RBRACKET, "']'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400645 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -0700646 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400647 ++pd.fSizeCount;
ethannicholasb3058bd2016-07-01 08:22:01 -0700648 }
Ethan Nicholasfc994162019-06-06 10:04:27 -0400649 getNode(result).setParameterData(pd);
650 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -0700651}
652
Ethan Nicholasd608c092017-10-26 09:30:08 -0400653/** EQ INT_LITERAL */
ethannicholasb3058bd2016-07-01 08:22:01 -0700654int Parser::layoutInt() {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400655 if (!this->expect(Token::Kind::TK_EQ, "'='")) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700656 return -1;
657 }
658 Token resultToken;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400659 if (this->expect(Token::Kind::TK_INT_LITERAL, "a non-negative integer", &resultToken)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700660 return SkSL::stoi(this->text(resultToken));
ethannicholasb3058bd2016-07-01 08:22:01 -0700661 }
662 return -1;
663}
664
Ethan Nicholasd608c092017-10-26 09:30:08 -0400665/** EQ IDENTIFIER */
666StringFragment Parser::layoutIdentifier() {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400667 if (!this->expect(Token::Kind::TK_EQ, "'='")) {
Ethan Nicholasd608c092017-10-26 09:30:08 -0400668 return StringFragment();
669 }
670 Token resultToken;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400671 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &resultToken)) {
Ethan Nicholasd608c092017-10-26 09:30:08 -0400672 return StringFragment();
673 }
674 return this->text(resultToken);
675}
676
677
Ethan Nicholas762466e2017-06-29 10:03:38 -0400678/** EQ <any sequence of tokens with balanced parentheses and no top-level comma> */
Ethan Nicholasfc994162019-06-06 10:04:27 -0400679StringFragment Parser::layoutCode() {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400680 if (!this->expect(Token::Kind::TK_EQ, "'='")) {
Ethan Nicholas762466e2017-06-29 10:03:38 -0400681 return "";
682 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700683 Token start = this->nextRawToken();
Ethan Nicholas08b79b72017-08-14 10:35:37 -0400684 this->pushback(start);
Ethan Nicholasfc994162019-06-06 10:04:27 -0400685 StringFragment code;
686 code.fChars = fText + start.fOffset;
Ethan Nicholas762466e2017-06-29 10:03:38 -0400687 int level = 1;
688 bool done = false;
689 while (!done) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700690 Token next = this->nextRawToken();
Ethan Nicholas762466e2017-06-29 10:03:38 -0400691 switch (next.fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400692 case Token::Kind::TK_LPAREN:
Ethan Nicholas762466e2017-06-29 10:03:38 -0400693 ++level;
694 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400695 case Token::Kind::TK_RPAREN:
Ethan Nicholas762466e2017-06-29 10:03:38 -0400696 --level;
697 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400698 case Token::Kind::TK_COMMA:
Ethan Nicholas762466e2017-06-29 10:03:38 -0400699 if (level == 1) {
700 done = true;
701 }
702 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400703 case Token::Kind::TK_END_OF_FILE:
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700704 this->error(start, "reached end of file while parsing layout");
Ethan Nicholas6d71f492019-06-10 16:58:37 -0400705 return "";
Ethan Nicholas762466e2017-06-29 10:03:38 -0400706 default:
707 break;
708 }
709 if (!level) {
710 done = true;
711 }
Ethan Nicholas08b79b72017-08-14 10:35:37 -0400712 if (done) {
Ethan Nicholasfc994162019-06-06 10:04:27 -0400713 code.fLength = next.fOffset - start.fOffset;
Ethan Nicholas08b79b72017-08-14 10:35:37 -0400714 this->pushback(std::move(next));
715 }
Ethan Nicholas762466e2017-06-29 10:03:38 -0400716 }
717 return code;
718}
719
720/** (EQ IDENTIFIER('identity'))? */
721Layout::Key Parser::layoutKey() {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400722 if (this->peek().fKind == Token::Kind::TK_EQ) {
723 this->expect(Token::Kind::TK_EQ, "'='");
Ethan Nicholas762466e2017-06-29 10:03:38 -0400724 Token key;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400725 if (this->expect(Token::Kind::TK_IDENTIFIER, "an identifer", &key)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700726 if (this->text(key) == "identity") {
Ethan Nicholas762466e2017-06-29 10:03:38 -0400727 return Layout::kIdentity_Key;
728 } else {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700729 this->error(key, "unsupported layout key");
Ethan Nicholas762466e2017-06-29 10:03:38 -0400730 }
731 }
732 }
733 return Layout::kKey_Key;
734}
735
Ethan Nicholas78aceb22018-08-31 16:13:58 -0400736Layout::CType Parser::layoutCType() {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400737 if (this->expect(Token::Kind::TK_EQ, "'='")) {
Ethan Nicholas78aceb22018-08-31 16:13:58 -0400738 Token t = this->nextToken();
739 String text = this->text(t);
740 auto found = layoutTokens->find(text);
741 if (found != layoutTokens->end()) {
742 switch (found->second) {
Brian Osmanf28e55d2018-10-03 16:35:54 -0400743 case LayoutToken::SKPMCOLOR4F:
744 return Layout::CType::kSkPMColor4f;
Mike Reedb26b4e72020-01-22 14:31:21 -0500745 case LayoutToken::SKV4:
746 return Layout::CType::kSkV4;
Ethan Nicholas78aceb22018-08-31 16:13:58 -0400747 case LayoutToken::SKRECT:
748 return Layout::CType::kSkRect;
749 case LayoutToken::SKIRECT:
750 return Layout::CType::kSkIRect;
751 case LayoutToken::SKPMCOLOR:
752 return Layout::CType::kSkPMColor;
Ethan Nicholasc1c686b2019-04-02 17:30:23 -0400753 case LayoutToken::BOOL:
754 return Layout::CType::kBool;
755 case LayoutToken::INT:
756 return Layout::CType::kInt32;
757 case LayoutToken::FLOAT:
758 return Layout::CType::kFloat;
Mike Reedb26b4e72020-01-22 14:31:21 -0500759 case LayoutToken::SKM44:
760 return Layout::CType::kSkM44;
Ethan Nicholas78aceb22018-08-31 16:13:58 -0400761 default:
762 break;
763 }
764 }
765 this->error(t, "unsupported ctype");
766 }
767 return Layout::CType::kDefault;
768}
769
ethannicholas8ac838d2016-11-22 08:39:36 -0800770/* LAYOUT LPAREN IDENTIFIER (EQ INT_LITERAL)? (COMMA IDENTIFIER (EQ INT_LITERAL)?)* RPAREN */
Ethan Nicholas11d53972016-11-28 11:23:23 -0500771Layout Parser::layout() {
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500772 int flags = 0;
ethannicholasb3058bd2016-07-01 08:22:01 -0700773 int location = -1;
Ethan Nicholas19671772016-11-28 16:30:17 -0500774 int offset = -1;
ethannicholasb3058bd2016-07-01 08:22:01 -0700775 int binding = -1;
776 int index = -1;
777 int set = -1;
778 int builtin = -1;
Greg Daniel64773e62016-11-22 09:44:03 -0500779 int inputAttachmentIndex = -1;
Ethan Nicholas11d53972016-11-28 11:23:23 -0500780 Layout::Format format = Layout::Format::kUnspecified;
Ethan Nicholas52cad152017-02-16 16:37:32 -0500781 Layout::Primitive primitive = Layout::kUnspecified_Primitive;
782 int maxVertices = -1;
783 int invocations = -1;
Brian Osmanf59a9612020-04-15 14:18:13 -0400784 StringFragment marker;
Ethan Nicholasfc994162019-06-06 10:04:27 -0400785 StringFragment when;
Ethan Nicholas762466e2017-06-29 10:03:38 -0400786 Layout::Key key = Layout::kNo_Key;
Ethan Nicholas78aceb22018-08-31 16:13:58 -0400787 Layout::CType ctype = Layout::CType::kDefault;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400788 if (this->checkNext(Token::Kind::TK_LAYOUT)) {
789 if (!this->expect(Token::Kind::TK_LPAREN, "'('")) {
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500790 return Layout(flags, location, offset, binding, index, set, builtin,
Brian Osmanf59a9612020-04-15 14:18:13 -0400791 inputAttachmentIndex, format, primitive, maxVertices, invocations, marker,
792 when, key, ctype);
ethannicholasb3058bd2016-07-01 08:22:01 -0700793 }
794 for (;;) {
795 Token t = this->nextToken();
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700796 String text = this->text(t);
Ethan Nicholasb93af7e2018-07-24 11:28:52 -0400797 auto found = layoutTokens->find(text);
798 if (found != layoutTokens->end()) {
799 switch (found->second) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700800 case LayoutToken::LOCATION:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500801 location = this->layoutInt();
802 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700803 case LayoutToken::OFFSET:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500804 offset = this->layoutInt();
805 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700806 case LayoutToken::BINDING:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500807 binding = this->layoutInt();
808 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700809 case LayoutToken::INDEX:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500810 index = this->layoutInt();
811 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700812 case LayoutToken::SET:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500813 set = this->layoutInt();
814 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700815 case LayoutToken::BUILTIN:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500816 builtin = this->layoutInt();
817 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700818 case LayoutToken::INPUT_ATTACHMENT_INDEX:
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500819 inputAttachmentIndex = this->layoutInt();
820 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700821 case LayoutToken::ORIGIN_UPPER_LEFT:
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500822 flags |= Layout::kOriginUpperLeft_Flag;
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500823 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700824 case LayoutToken::OVERRIDE_COVERAGE:
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500825 flags |= Layout::kOverrideCoverage_Flag;
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500826 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700827 case LayoutToken::BLEND_SUPPORT_ALL_EQUATIONS:
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500828 flags |= Layout::kBlendSupportAllEquations_Flag;
829 break;
830 case LayoutToken::BLEND_SUPPORT_MULTIPLY:
831 flags |= Layout::kBlendSupportMultiply_Flag;
832 break;
833 case LayoutToken::BLEND_SUPPORT_SCREEN:
834 flags |= Layout::kBlendSupportScreen_Flag;
835 break;
836 case LayoutToken::BLEND_SUPPORT_OVERLAY:
837 flags |= Layout::kBlendSupportOverlay_Flag;
838 break;
839 case LayoutToken::BLEND_SUPPORT_DARKEN:
840 flags |= Layout::kBlendSupportDarken_Flag;
841 break;
842 case LayoutToken::BLEND_SUPPORT_LIGHTEN:
843 flags |= Layout::kBlendSupportLighten_Flag;
844 break;
845 case LayoutToken::BLEND_SUPPORT_COLORDODGE:
846 flags |= Layout::kBlendSupportColorDodge_Flag;
847 break;
848 case LayoutToken::BLEND_SUPPORT_COLORBURN:
849 flags |= Layout::kBlendSupportColorBurn_Flag;
850 break;
851 case LayoutToken::BLEND_SUPPORT_HARDLIGHT:
852 flags |= Layout::kBlendSupportHardLight_Flag;
853 break;
854 case LayoutToken::BLEND_SUPPORT_SOFTLIGHT:
855 flags |= Layout::kBlendSupportSoftLight_Flag;
856 break;
857 case LayoutToken::BLEND_SUPPORT_DIFFERENCE:
858 flags |= Layout::kBlendSupportDifference_Flag;
859 break;
860 case LayoutToken::BLEND_SUPPORT_EXCLUSION:
861 flags |= Layout::kBlendSupportExclusion_Flag;
862 break;
863 case LayoutToken::BLEND_SUPPORT_HSL_HUE:
864 flags |= Layout::kBlendSupportHSLHue_Flag;
865 break;
866 case LayoutToken::BLEND_SUPPORT_HSL_SATURATION:
867 flags |= Layout::kBlendSupportHSLSaturation_Flag;
868 break;
869 case LayoutToken::BLEND_SUPPORT_HSL_COLOR:
870 flags |= Layout::kBlendSupportHSLColor_Flag;
871 break;
872 case LayoutToken::BLEND_SUPPORT_HSL_LUMINOSITY:
873 flags |= Layout::kBlendSupportHSLLuminosity_Flag;
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500874 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700875 case LayoutToken::PUSH_CONSTANT:
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500876 flags |= Layout::kPushConstant_Flag;
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500877 break;
Michael Ludwiga4275592018-08-31 10:52:47 -0400878 case LayoutToken::TRACKED:
879 flags |= Layout::kTracked_Flag;
880 break;
Brian Osmanb32d66b2020-04-30 17:12:03 -0400881 case LayoutToken::SRGB_UNPREMUL:
882 flags |= Layout::kSRGBUnpremul_Flag;
883 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700884 case LayoutToken::POINTS:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500885 primitive = Layout::kPoints_Primitive;
886 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700887 case LayoutToken::LINES:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500888 primitive = Layout::kLines_Primitive;
889 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700890 case LayoutToken::LINE_STRIP:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500891 primitive = Layout::kLineStrip_Primitive;
892 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700893 case LayoutToken::LINES_ADJACENCY:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500894 primitive = Layout::kLinesAdjacency_Primitive;
895 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700896 case LayoutToken::TRIANGLES:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500897 primitive = Layout::kTriangles_Primitive;
898 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700899 case LayoutToken::TRIANGLE_STRIP:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500900 primitive = Layout::kTriangleStrip_Primitive;
901 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700902 case LayoutToken::TRIANGLES_ADJACENCY:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500903 primitive = Layout::kTrianglesAdjacency_Primitive;
904 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700905 case LayoutToken::MAX_VERTICES:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500906 maxVertices = this->layoutInt();
907 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700908 case LayoutToken::INVOCATIONS:
Ethan Nicholas52cad152017-02-16 16:37:32 -0500909 invocations = this->layoutInt();
910 break;
Brian Osmanf59a9612020-04-15 14:18:13 -0400911 case LayoutToken::MARKER:
912 marker = this->layoutCode();
913 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700914 case LayoutToken::WHEN:
Ethan Nicholas762466e2017-06-29 10:03:38 -0400915 when = this->layoutCode();
916 break;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700917 case LayoutToken::KEY:
Ethan Nicholas762466e2017-06-29 10:03:38 -0400918 key = this->layoutKey();
919 break;
Ethan Nicholasd608c092017-10-26 09:30:08 -0400920 case LayoutToken::CTYPE:
Ethan Nicholas78aceb22018-08-31 16:13:58 -0400921 ctype = this->layoutCType();
922 break;
923 default:
924 this->error(t, ("'" + text + "' is not a valid layout qualifier").c_str());
Ethan Nicholasd608c092017-10-26 09:30:08 -0400925 break;
Ethan Nicholas3614d9a2017-02-15 12:33:30 -0500926 }
Ethan Nicholasb93af7e2018-07-24 11:28:52 -0400927 } else if (Layout::ReadFormat(text, &format)) {
Brian Salomon2a51de82016-11-16 12:06:01 -0500928 // AST::ReadFormat stored the result in 'format'.
ethannicholasb3058bd2016-07-01 08:22:01 -0700929 } else {
Ethan Nicholasb93af7e2018-07-24 11:28:52 -0400930 this->error(t, ("'" + text + "' is not a valid layout qualifier").c_str());
ethannicholasb3058bd2016-07-01 08:22:01 -0700931 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400932 if (this->checkNext(Token::Kind::TK_RPAREN)) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700933 break;
934 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400935 if (!this->expect(Token::Kind::TK_COMMA, "','")) {
ethannicholasb3058bd2016-07-01 08:22:01 -0700936 break;
937 }
938 }
939 }
Ethan Nicholas39204fd2017-11-27 13:12:30 -0500940 return Layout(flags, location, offset, binding, index, set, builtin, inputAttachmentIndex,
Brian Osmanf59a9612020-04-15 14:18:13 -0400941 format, primitive, maxVertices, invocations, marker, when, key, ctype);
ethannicholasb3058bd2016-07-01 08:22:01 -0700942}
943
Brian Salomonf9f45122016-11-29 11:59:17 -0500944/* layout? (UNIFORM | CONST | IN | OUT | INOUT | LOWP | MEDIUMP | HIGHP | FLAT | NOPERSPECTIVE |
Ethan Nicholasa7ceb502019-01-11 10:31:48 -0500945 READONLY | WRITEONLY | COHERENT | VOLATILE | RESTRICT | BUFFER | PLS | PLSIN |
Ethan Nicholasf3c8f5d2020-08-20 13:09:14 +0000946 PLSOUT | VARYING | INLINE)* */
Ethan Nicholas11d53972016-11-28 11:23:23 -0500947Modifiers Parser::modifiers() {
948 Layout layout = this->layout();
ethannicholasb3058bd2016-07-01 08:22:01 -0700949 int flags = 0;
950 for (;;) {
951 // TODO: handle duplicate / incompatible flags
952 switch (peek().fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400953 case Token::Kind::TK_UNIFORM:
ethannicholasb3058bd2016-07-01 08:22:01 -0700954 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500955 flags |= Modifiers::kUniform_Flag;
ethannicholasb3058bd2016-07-01 08:22:01 -0700956 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400957 case Token::Kind::TK_CONST:
ethannicholasb3058bd2016-07-01 08:22:01 -0700958 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500959 flags |= Modifiers::kConst_Flag;
ethannicholasb3058bd2016-07-01 08:22:01 -0700960 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400961 case Token::Kind::TK_IN:
ethannicholasb3058bd2016-07-01 08:22:01 -0700962 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500963 flags |= Modifiers::kIn_Flag;
ethannicholasb3058bd2016-07-01 08:22:01 -0700964 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400965 case Token::Kind::TK_OUT:
ethannicholasb3058bd2016-07-01 08:22:01 -0700966 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500967 flags |= Modifiers::kOut_Flag;
ethannicholasb3058bd2016-07-01 08:22:01 -0700968 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400969 case Token::Kind::TK_INOUT:
ethannicholasb3058bd2016-07-01 08:22:01 -0700970 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500971 flags |= Modifiers::kIn_Flag;
972 flags |= Modifiers::kOut_Flag;
ethannicholasb3058bd2016-07-01 08:22:01 -0700973 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400974 case Token::Kind::TK_FLAT:
ethannicholasf789b382016-08-03 12:43:36 -0700975 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500976 flags |= Modifiers::kFlat_Flag;
ethannicholasf789b382016-08-03 12:43:36 -0700977 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400978 case Token::Kind::TK_NOPERSPECTIVE:
ethannicholasf789b382016-08-03 12:43:36 -0700979 this->nextToken();
Ethan Nicholas11d53972016-11-28 11:23:23 -0500980 flags |= Modifiers::kNoPerspective_Flag;
ethannicholasf789b382016-08-03 12:43:36 -0700981 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400982 case Token::Kind::TK_READONLY:
Brian Salomonf9f45122016-11-29 11:59:17 -0500983 this->nextToken();
984 flags |= Modifiers::kReadOnly_Flag;
985 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400986 case Token::Kind::TK_WRITEONLY:
Brian Salomonf9f45122016-11-29 11:59:17 -0500987 this->nextToken();
988 flags |= Modifiers::kWriteOnly_Flag;
989 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400990 case Token::Kind::TK_COHERENT:
Brian Salomonf9f45122016-11-29 11:59:17 -0500991 this->nextToken();
992 flags |= Modifiers::kCoherent_Flag;
993 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400994 case Token::Kind::TK_VOLATILE:
Brian Salomonf9f45122016-11-29 11:59:17 -0500995 this->nextToken();
996 flags |= Modifiers::kVolatile_Flag;
997 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400998 case Token::Kind::TK_RESTRICT:
Brian Salomonf9f45122016-11-29 11:59:17 -0500999 this->nextToken();
1000 flags |= Modifiers::kRestrict_Flag;
1001 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001002 case Token::Kind::TK_BUFFER:
Ethan Nicholas0dd30d92017-05-01 16:57:07 -04001003 this->nextToken();
1004 flags |= Modifiers::kBuffer_Flag;
1005 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001006 case Token::Kind::TK_HASSIDEEFFECTS:
Ethan Nicholascb670962017-04-20 19:31:52 -04001007 this->nextToken();
1008 flags |= Modifiers::kHasSideEffects_Flag;
1009 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001010 case Token::Kind::TK_PLS:
Ethan Nicholasa7ceb502019-01-11 10:31:48 -05001011 this->nextToken();
1012 flags |= Modifiers::kPLS_Flag;
1013 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001014 case Token::Kind::TK_PLSIN:
Ethan Nicholasa7ceb502019-01-11 10:31:48 -05001015 this->nextToken();
1016 flags |= Modifiers::kPLSIn_Flag;
1017 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001018 case Token::Kind::TK_PLSOUT:
Ethan Nicholasa7ceb502019-01-11 10:31:48 -05001019 this->nextToken();
1020 flags |= Modifiers::kPLSOut_Flag;
1021 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001022 case Token::Kind::TK_VARYING:
Brian Osman3c358422020-03-23 10:44:12 -04001023 this->nextToken();
1024 flags |= Modifiers::kVarying_Flag;
1025 break;
Ethan Nicholasf3c8f5d2020-08-20 13:09:14 +00001026 case Token::Kind::TK_INLINE:
1027 this->nextToken();
1028 flags |= Modifiers::kInline_Flag;
1029 break;
ethannicholasb3058bd2016-07-01 08:22:01 -07001030 default:
Ethan Nicholas11d53972016-11-28 11:23:23 -05001031 return Modifiers(layout, flags);
ethannicholasb3058bd2016-07-01 08:22:01 -07001032 }
1033 }
1034}
1035
Ethan Nicholas11d53972016-11-28 11:23:23 -05001036Modifiers Parser::modifiersWithDefaults(int defaultFlags) {
1037 Modifiers result = this->modifiers();
ethannicholasb3058bd2016-07-01 08:22:01 -07001038 if (!result.fFlags) {
Ethan Nicholas11d53972016-11-28 11:23:23 -05001039 return Modifiers(result.fLayout, defaultFlags);
ethannicholasb3058bd2016-07-01 08:22:01 -07001040 }
1041 return result;
1042}
1043
1044/* ifStatement | forStatement | doStatement | whileStatement | block | expression */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001045ASTNode::ID Parser::statement() {
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04001046 Token start = this->nextToken();
1047 AutoDepth depth(this);
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001048 if (!depth.increase()) {
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04001049 return ASTNode::ID::Invalid();
1050 }
1051 this->pushback(start);
ethannicholasb3058bd2016-07-01 08:22:01 -07001052 switch (start.fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001053 case Token::Kind::TK_IF: // fall through
1054 case Token::Kind::TK_STATIC_IF:
ethannicholasb3058bd2016-07-01 08:22:01 -07001055 return this->ifStatement();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001056 case Token::Kind::TK_FOR:
ethannicholasb3058bd2016-07-01 08:22:01 -07001057 return this->forStatement();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001058 case Token::Kind::TK_DO:
ethannicholasb3058bd2016-07-01 08:22:01 -07001059 return this->doStatement();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001060 case Token::Kind::TK_WHILE:
ethannicholasb3058bd2016-07-01 08:22:01 -07001061 return this->whileStatement();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001062 case Token::Kind::TK_SWITCH: // fall through
1063 case Token::Kind::TK_STATIC_SWITCH:
Ethan Nicholasaf197692017-02-27 13:26:45 -05001064 return this->switchStatement();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001065 case Token::Kind::TK_RETURN:
ethannicholasb3058bd2016-07-01 08:22:01 -07001066 return this->returnStatement();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001067 case Token::Kind::TK_BREAK:
ethannicholasb3058bd2016-07-01 08:22:01 -07001068 return this->breakStatement();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001069 case Token::Kind::TK_CONTINUE:
ethannicholasb3058bd2016-07-01 08:22:01 -07001070 return this->continueStatement();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001071 case Token::Kind::TK_DISCARD:
ethannicholasb3058bd2016-07-01 08:22:01 -07001072 return this->discardStatement();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001073 case Token::Kind::TK_LBRACE:
ethannicholasb3058bd2016-07-01 08:22:01 -07001074 return this->block();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001075 case Token::Kind::TK_SEMICOLON:
Ethan Nicholas11d53972016-11-28 11:23:23 -05001076 this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001077 RETURN_NODE(start.fOffset, ASTNode::Kind::kBlock);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001078 case Token::Kind::TK_CONST:
Ethan Nicholasfc994162019-06-06 10:04:27 -04001079 return this->varDeclarations();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001080 case Token::Kind::TK_IDENTIFIER:
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001081 if (this->isType(this->text(start))) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001082 return this->varDeclarations();
ethannicholasb3058bd2016-07-01 08:22:01 -07001083 }
John Stiles30212b72020-06-11 17:55:07 -04001084 [[fallthrough]];
ethannicholasb3058bd2016-07-01 08:22:01 -07001085 default:
1086 return this->expressionStatement();
Ethan Nicholas11d53972016-11-28 11:23:23 -05001087 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001088}
1089
Ethan Nicholasee1c8a72019-02-22 10:50:47 -05001090/* IDENTIFIER(type) (LBRACKET intLiteral? RBRACKET)* QUESTION? */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001091ASTNode::ID Parser::type() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001092 Token type;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001093 if (!this->expect(Token::Kind::TK_IDENTIFIER, "a type", &type)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001094 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001095 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001096 if (!this->isType(this->text(type))) {
1097 this->error(type, ("no type named '" + this->text(type) + "'").c_str());
Ethan Nicholasfc994162019-06-06 10:04:27 -04001098 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001099 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001100 CREATE_NODE(result, type.fOffset, ASTNode::Kind::kType);
1101 ASTNode::TypeData td(this->text(type), false, false);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001102 while (this->checkNext(Token::Kind::TK_LBRACKET)) {
1103 if (this->peek().fKind != Token::Kind::TK_RBRACKET) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001104 SKSL_INT i;
Ethan Nicholas50afc172017-02-16 14:49:57 -05001105 if (this->intLiteral(&i)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001106 CREATE_CHILD(child, result, -1, ASTNode::Kind::kInt, i);
Ethan Nicholas50afc172017-02-16 14:49:57 -05001107 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001108 return ASTNode::ID::Invalid();
Ethan Nicholas50afc172017-02-16 14:49:57 -05001109 }
1110 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001111 CREATE_EMPTY_CHILD(result);
Ethan Nicholas50afc172017-02-16 14:49:57 -05001112 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001113 this->expect(Token::Kind::TK_RBRACKET, "']'");
Ethan Nicholas50afc172017-02-16 14:49:57 -05001114 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001115 td.fIsNullable = this->checkNext(Token::Kind::TK_QUESTION);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001116 getNode(result).setTypeData(td);
1117 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001118}
1119
John Stiles57a996b2020-04-19 19:05:12 -07001120/* IDENTIFIER LBRACE
1121 varDeclaration+
1122 RBRACE (IDENTIFIER (LBRACKET expression? RBRACKET)*)? SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001123ASTNode::ID Parser::interfaceBlock(Modifiers mods) {
ethannicholasb3058bd2016-07-01 08:22:01 -07001124 Token name;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001125 if (!this->expect(Token::Kind::TK_IDENTIFIER, "an identifier", &name)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001126 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001127 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001128 if (peek().fKind != Token::Kind::TK_LBRACE) {
ethannicholasb3058bd2016-07-01 08:22:01 -07001129 // we only get into interfaceBlock if we found a top-level identifier which was not a type.
Ethan Nicholas11d53972016-11-28 11:23:23 -05001130 // 99% of the time, the user was not actually intending to create an interface block, so
ethannicholasb3058bd2016-07-01 08:22:01 -07001131 // it's better to report it as an unknown type
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001132 this->error(name, "no type named '" + this->text(name) + "'");
Ethan Nicholasfc994162019-06-06 10:04:27 -04001133 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001134 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001135 CREATE_NODE(result, name.fOffset, ASTNode::Kind::kInterfaceBlock);
1136 ASTNode::InterfaceBlockData id(mods, this->text(name), 0, "", 0);
ethannicholasb3058bd2016-07-01 08:22:01 -07001137 this->nextToken();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001138 while (this->peek().fKind != Token::Kind::TK_RBRACE) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001139 ASTNode::ID decl = this->varDeclarations();
ethannicholasb3058bd2016-07-01 08:22:01 -07001140 if (!decl) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001141 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001142 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001143 getNode(result).addChild(decl);
1144 ++id.fDeclarationCount;
ethannicholasb3058bd2016-07-01 08:22:01 -07001145 }
John Stiles57a996b2020-04-19 19:05:12 -07001146 if (id.fDeclarationCount == 0) {
1147 this->error(name, "interface block '" + this->text(name) +
1148 "' must contain at least one member");
1149 return ASTNode::ID::Invalid();
1150 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001151 this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001152 std::vector<ASTNode> sizes;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001153 StringFragment instanceName;
1154 Token instanceNameToken;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001155 if (this->checkNext(Token::Kind::TK_IDENTIFIER, &instanceNameToken)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001156 id.fInstanceName = this->text(instanceNameToken);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001157 while (this->checkNext(Token::Kind::TK_LBRACKET)) {
1158 if (this->peek().fKind != Token::Kind::TK_RBRACKET) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001159 ASTNode::ID size = this->expression();
Ethan Nicholas50afc172017-02-16 14:49:57 -05001160 if (!size) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001161 return ASTNode::ID::Invalid();
Ethan Nicholas50afc172017-02-16 14:49:57 -05001162 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001163 getNode(result).addChild(size);
Ethan Nicholas50afc172017-02-16 14:49:57 -05001164 } else {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001165 CREATE_EMPTY_CHILD(result);
Ethan Nicholas50afc172017-02-16 14:49:57 -05001166 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001167 ++id.fSizeCount;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001168 this->expect(Token::Kind::TK_RBRACKET, "']'");
Ethan Nicholas50afc172017-02-16 14:49:57 -05001169 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001170 instanceName = this->text(instanceNameToken);
ethannicholasb3058bd2016-07-01 08:22:01 -07001171 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001172 getNode(result).setInterfaceBlockData(id);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001173 this->expect(Token::Kind::TK_SEMICOLON, "';'");
Ethan Nicholasfc994162019-06-06 10:04:27 -04001174 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001175}
1176
1177/* IF LPAREN expression RPAREN statement (ELSE statement)? */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001178ASTNode::ID Parser::ifStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001179 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001180 bool isStatic = this->checkNext(Token::Kind::TK_STATIC_IF, &start);
1181 if (!isStatic && !this->expect(Token::Kind::TK_IF, "'if'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001182 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001183 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001184 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kIf, isStatic);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001185 if (!this->expect(Token::Kind::TK_LPAREN, "'('")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001186 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001187 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001188 ASTNode::ID test = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001189 if (!test) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001190 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001191 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001192 getNode(result).addChild(test);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001193 if (!this->expect(Token::Kind::TK_RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001194 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001195 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001196 ASTNode::ID ifTrue = this->statement();
ethannicholasb3058bd2016-07-01 08:22:01 -07001197 if (!ifTrue) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001198 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001199 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001200 getNode(result).addChild(ifTrue);
1201 ASTNode::ID ifFalse;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001202 if (this->checkNext(Token::Kind::TK_ELSE)) {
ethannicholasb3058bd2016-07-01 08:22:01 -07001203 ifFalse = this->statement();
1204 if (!ifFalse) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001205 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001206 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001207 getNode(result).addChild(ifFalse);
ethannicholasb3058bd2016-07-01 08:22:01 -07001208 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001209 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001210}
1211
1212/* DO statement WHILE LPAREN expression RPAREN SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001213ASTNode::ID Parser::doStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001214 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001215 if (!this->expect(Token::Kind::TK_DO, "'do'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001216 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001217 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001218 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kDo);
1219 ASTNode::ID statement = this->statement();
ethannicholasb3058bd2016-07-01 08:22:01 -07001220 if (!statement) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001221 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001222 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001223 getNode(result).addChild(statement);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001224 if (!this->expect(Token::Kind::TK_WHILE, "'while'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001225 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001226 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001227 if (!this->expect(Token::Kind::TK_LPAREN, "'('")) {
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 ASTNode::ID test = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001231 if (!test) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001232 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001233 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001234 getNode(result).addChild(test);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001235 if (!this->expect(Token::Kind::TK_RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001236 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001237 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001238 if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001239 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001240 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001241 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001242}
1243
1244/* WHILE LPAREN expression RPAREN STATEMENT */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001245ASTNode::ID Parser::whileStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001246 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001247 if (!this->expect(Token::Kind::TK_WHILE, "'while'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001248 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001249 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001250 if (!this->expect(Token::Kind::TK_LPAREN, "'('")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001251 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001252 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001253 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kWhile);
1254 ASTNode::ID test = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001255 if (!test) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001256 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001257 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001258 getNode(result).addChild(test);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001259 if (!this->expect(Token::Kind::TK_RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001260 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001261 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001262 ASTNode::ID statement = this->statement();
ethannicholasb3058bd2016-07-01 08:22:01 -07001263 if (!statement) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001264 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001265 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001266 getNode(result).addChild(statement);
1267 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001268}
1269
Ethan Nicholasaf197692017-02-27 13:26:45 -05001270/* CASE expression COLON statement* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001271ASTNode::ID Parser::switchCase() {
Ethan Nicholasaf197692017-02-27 13:26:45 -05001272 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001273 if (!this->expect(Token::Kind::TK_CASE, "'case'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001274 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001275 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001276 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kSwitchCase);
1277 ASTNode::ID value = this->expression();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001278 if (!value) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001279 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001280 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001281 if (!this->expect(Token::Kind::TK_COLON, "':'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001282 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001283 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001284 getNode(result).addChild(value);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001285 while (this->peek().fKind != Token::Kind::TK_RBRACE &&
1286 this->peek().fKind != Token::Kind::TK_CASE &&
1287 this->peek().fKind != Token::Kind::TK_DEFAULT) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001288 ASTNode::ID s = this->statement();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001289 if (!s) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001290 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001291 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001292 getNode(result).addChild(s);
Ethan Nicholasaf197692017-02-27 13:26:45 -05001293 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001294 return result;
Ethan Nicholasaf197692017-02-27 13:26:45 -05001295}
1296
1297/* SWITCH LPAREN expression RPAREN LBRACE switchCase* (DEFAULT COLON statement*)? RBRACE */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001298ASTNode::ID Parser::switchStatement() {
Ethan Nicholasaf197692017-02-27 13:26:45 -05001299 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001300 bool isStatic = this->checkNext(Token::Kind::TK_STATIC_SWITCH, &start);
1301 if (!isStatic && !this->expect(Token::Kind::TK_SWITCH, "'switch'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001302 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001303 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001304 if (!this->expect(Token::Kind::TK_LPAREN, "'('")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001305 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001306 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001307 ASTNode::ID value = this->expression();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001308 if (!value) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001309 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001310 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001311 if (!this->expect(Token::Kind::TK_RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001312 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001313 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001314 if (!this->expect(Token::Kind::TK_LBRACE, "'{'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001315 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001316 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001317 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kSwitch, isStatic);
1318 getNode(result).addChild(value);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001319 while (this->peek().fKind == Token::Kind::TK_CASE) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001320 ASTNode::ID c = this->switchCase();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001321 if (!c) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001322 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001323 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001324 getNode(result).addChild(c);
Ethan Nicholasaf197692017-02-27 13:26:45 -05001325 }
1326 // Requiring default: to be last (in defiance of C and GLSL) was a deliberate decision. Other
1327 // parts of the compiler may rely upon this assumption.
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001328 if (this->peek().fKind == Token::Kind::TK_DEFAULT) {
Ethan Nicholasaf197692017-02-27 13:26:45 -05001329 Token defaultStart;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001330 SkAssertResult(this->expect(Token::Kind::TK_DEFAULT, "'default'", &defaultStart));
1331 if (!this->expect(Token::Kind::TK_COLON, "':'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001332 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001333 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001334 CREATE_CHILD(defaultCase, result, defaultStart.fOffset, ASTNode::Kind::kSwitchCase);
1335 CREATE_EMPTY_CHILD(defaultCase); // empty test to signify default case
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001336 while (this->peek().fKind != Token::Kind::TK_RBRACE) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001337 ASTNode::ID s = this->statement();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001338 if (!s) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001339 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001340 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001341 getNode(defaultCase).addChild(s);
Ethan Nicholasaf197692017-02-27 13:26:45 -05001342 }
Ethan Nicholasaf197692017-02-27 13:26:45 -05001343 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001344 if (!this->expect(Token::Kind::TK_RBRACE, "'}'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001345 return ASTNode::ID::Invalid();
Ethan Nicholasaf197692017-02-27 13:26:45 -05001346 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001347 return result;
Ethan Nicholasaf197692017-02-27 13:26:45 -05001348}
1349
Ethan Nicholas11d53972016-11-28 11:23:23 -05001350/* FOR LPAREN (declaration | expression)? SEMICOLON expression? SEMICOLON expression? RPAREN
ethannicholasb3058bd2016-07-01 08:22:01 -07001351 STATEMENT */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001352ASTNode::ID Parser::forStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001353 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001354 if (!this->expect(Token::Kind::TK_FOR, "'for'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001355 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001356 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001357 if (!this->expect(Token::Kind::TK_LPAREN, "'('")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001358 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001359 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001360 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kFor);
1361 ASTNode::ID initializer;
ethannicholasb3058bd2016-07-01 08:22:01 -07001362 Token nextToken = this->peek();
1363 switch (nextToken.fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001364 case Token::Kind::TK_SEMICOLON:
ethannicholas22f939e2016-10-13 13:25:34 -07001365 this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001366 CREATE_EMPTY_CHILD(result);
ethannicholasb3058bd2016-07-01 08:22:01 -07001367 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001368 case Token::Kind::TK_CONST: {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001369 initializer = this->varDeclarations();
1370 if (!initializer) {
1371 return ASTNode::ID::Invalid();
ethannicholasa54401d2016-10-14 08:37:32 -07001372 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001373 getNode(result).addChild(initializer);
ethannicholasb3058bd2016-07-01 08:22:01 -07001374 break;
ethannicholasa54401d2016-10-14 08:37:32 -07001375 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001376 case Token::Kind::TK_IDENTIFIER: {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001377 if (this->isType(this->text(nextToken))) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001378 initializer = this->varDeclarations();
1379 if (!initializer) {
1380 return ASTNode::ID::Invalid();
ethannicholasa54401d2016-10-14 08:37:32 -07001381 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001382 getNode(result).addChild(initializer);
ethannicholasb3058bd2016-07-01 08:22:01 -07001383 break;
1384 }
John Stiles30212b72020-06-11 17:55:07 -04001385 [[fallthrough]];
1386 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001387 default:
1388 initializer = this->expressionStatement();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001389 if (!initializer) {
1390 return ASTNode::ID::Invalid();
1391 }
1392 getNode(result).addChild(initializer);
ethannicholasb3058bd2016-07-01 08:22:01 -07001393 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001394 ASTNode::ID test;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001395 if (this->peek().fKind != Token::Kind::TK_SEMICOLON) {
ethannicholasb3058bd2016-07-01 08:22:01 -07001396 test = this->expression();
1397 if (!test) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001398 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001399 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001400 getNode(result).addChild(test);
1401 } else {
1402 CREATE_EMPTY_CHILD(result);
ethannicholasb3058bd2016-07-01 08:22:01 -07001403 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001404 if (!this->expect(Token::Kind::TK_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 ASTNode::ID next;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001408 if (this->peek().fKind != Token::Kind::TK_RPAREN) {
ethannicholasb3058bd2016-07-01 08:22:01 -07001409 next = this->expression();
1410 if (!next) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001411 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001412 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001413 getNode(result).addChild(next);
1414 } else {
1415 CREATE_EMPTY_CHILD(result);
ethannicholasb3058bd2016-07-01 08:22:01 -07001416 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001417 if (!this->expect(Token::Kind::TK_RPAREN, "')'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001418 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001419 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001420 ASTNode::ID statement = this->statement();
ethannicholasb3058bd2016-07-01 08:22:01 -07001421 if (!statement) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001422 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001423 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001424 getNode(result).addChild(statement);
1425 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001426}
1427
1428/* RETURN expression? SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001429ASTNode::ID Parser::returnStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001430 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001431 if (!this->expect(Token::Kind::TK_RETURN, "'return'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001432 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001433 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001434 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kReturn);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001435 if (this->peek().fKind != Token::Kind::TK_SEMICOLON) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001436 ASTNode::ID expression = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001437 if (!expression) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001438 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001439 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001440 getNode(result).addChild(expression);
ethannicholasb3058bd2016-07-01 08:22:01 -07001441 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001442 if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001443 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001444 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001445 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001446}
1447
1448/* BREAK SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001449ASTNode::ID Parser::breakStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001450 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001451 if (!this->expect(Token::Kind::TK_BREAK, "'break'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001452 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001453 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001454 if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001455 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001456 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001457 RETURN_NODE(start.fOffset, ASTNode::Kind::kBreak);
ethannicholasb3058bd2016-07-01 08:22:01 -07001458}
1459
1460/* CONTINUE SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001461ASTNode::ID Parser::continueStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001462 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001463 if (!this->expect(Token::Kind::TK_CONTINUE, "'continue'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001464 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001465 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001466 if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001467 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001468 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001469 RETURN_NODE(start.fOffset, ASTNode::Kind::kContinue);
ethannicholasb3058bd2016-07-01 08:22:01 -07001470}
1471
1472/* DISCARD SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001473ASTNode::ID Parser::discardStatement() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001474 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001475 if (!this->expect(Token::Kind::TK_DISCARD, "'continue'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001476 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001477 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001478 if (!this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001479 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001480 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001481 RETURN_NODE(start.fOffset, ASTNode::Kind::kDiscard);
ethannicholasb3058bd2016-07-01 08:22:01 -07001482}
1483
1484/* LBRACE statement* RBRACE */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001485ASTNode::ID Parser::block() {
ethannicholasb3058bd2016-07-01 08:22:01 -07001486 Token start;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001487 if (!this->expect(Token::Kind::TK_LBRACE, "'{'", &start)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001488 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001489 }
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04001490 AutoDepth depth(this);
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001491 if (!depth.increase()) {
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04001492 return ASTNode::ID::Invalid();
1493 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001494 CREATE_NODE(result, start.fOffset, ASTNode::Kind::kBlock);
ethannicholasb3058bd2016-07-01 08:22:01 -07001495 for (;;) {
1496 switch (this->peek().fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001497 case Token::Kind::TK_RBRACE:
ethannicholasb3058bd2016-07-01 08:22:01 -07001498 this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001499 return result;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001500 case Token::Kind::TK_END_OF_FILE:
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001501 this->error(this->peek(), "expected '}', but found end of file");
Ethan Nicholasfc994162019-06-06 10:04:27 -04001502 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001503 default: {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001504 ASTNode::ID statement = this->statement();
ethannicholasb3058bd2016-07-01 08:22:01 -07001505 if (!statement) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001506 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001507 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001508 getNode(result).addChild(statement);
ethannicholasb3058bd2016-07-01 08:22:01 -07001509 }
1510 }
1511 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001512 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001513}
1514
1515/* expression SEMICOLON */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001516ASTNode::ID Parser::expressionStatement() {
1517 ASTNode::ID expr = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001518 if (expr) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001519 if (this->expect(Token::Kind::TK_SEMICOLON, "';'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001520 return expr;
ethannicholasb3058bd2016-07-01 08:22:01 -07001521 }
1522 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001523 return ASTNode::ID::Invalid();
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001524}
1525
1526/* assignmentExpression (COMMA assignmentExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001527ASTNode::ID Parser::expression() {
1528 ASTNode::ID result = this->assignmentExpression();
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001529 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001530 return ASTNode::ID::Invalid();
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001531 }
1532 Token t;
Ethan Nicholasb67d0562020-04-30 16:10:00 -04001533 AutoDepth depth(this);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001534 while (this->checkNext(Token::Kind::TK_COMMA, &t)) {
Ethan Nicholasb67d0562020-04-30 16:10:00 -04001535 if (!depth.increase()) {
1536 return ASTNode::ID::Invalid();
1537 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001538 ASTNode::ID right = this->assignmentExpression();
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001539 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001540 return ASTNode::ID::Invalid();
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001541 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001542 CREATE_NODE(newResult, t.fOffset, ASTNode::Kind::kBinary, std::move(t));
1543 getNode(newResult).addChild(result);
1544 getNode(newResult).addChild(right);
1545 result = newResult;
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001546 }
1547 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001548}
1549
1550/* ternaryExpression ((EQEQ | STAREQ | SLASHEQ | PERCENTEQ | PLUSEQ | MINUSEQ | SHLEQ | SHREQ |
1551 BITWISEANDEQ | BITWISEXOREQ | BITWISEOREQ | LOGICALANDEQ | LOGICALXOREQ | LOGICALOREQ)
1552 assignmentExpression)*
1553 */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001554ASTNode::ID Parser::assignmentExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001555 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001556 ASTNode::ID result = this->ternaryExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001557 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001558 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001559 }
1560 for (;;) {
1561 switch (this->peek().fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001562 case Token::Kind::TK_EQ: // fall through
1563 case Token::Kind::TK_STAREQ: // fall through
1564 case Token::Kind::TK_SLASHEQ: // fall through
1565 case Token::Kind::TK_PERCENTEQ: // fall through
1566 case Token::Kind::TK_PLUSEQ: // fall through
1567 case Token::Kind::TK_MINUSEQ: // fall through
1568 case Token::Kind::TK_SHLEQ: // fall through
1569 case Token::Kind::TK_SHREQ: // fall through
1570 case Token::Kind::TK_BITWISEANDEQ: // fall through
1571 case Token::Kind::TK_BITWISEXOREQ: // fall through
1572 case Token::Kind::TK_BITWISEOREQ: // fall through
1573 case Token::Kind::TK_LOGICALANDEQ: // fall through
1574 case Token::Kind::TK_LOGICALXOREQ: // fall through
1575 case Token::Kind::TK_LOGICALOREQ: {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001576 if (!depth.increase()) {
1577 return ASTNode::ID::Invalid();
1578 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001579 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001580 ASTNode::ID right = this->assignmentExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001581 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001582 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001583 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001584 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary,
1585 std::move(t));
1586 getNode(newResult).addChild(result);
1587 getNode(newResult).addChild(right);
1588 result = newResult;
1589 break;
ethannicholasb3058bd2016-07-01 08:22:01 -07001590 }
1591 default:
1592 return result;
1593 }
1594 }
1595}
1596
1597/* logicalOrExpression ('?' expression ':' assignmentExpression)? */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001598ASTNode::ID Parser::ternaryExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001599 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001600 ASTNode::ID base = this->logicalOrExpression();
1601 if (!base) {
1602 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001603 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001604 if (this->checkNext(Token::Kind::TK_QUESTION)) {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001605 if (!depth.increase()) {
1606 return ASTNode::ID::Invalid();
1607 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001608 ASTNode::ID trueExpr = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001609 if (!trueExpr) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001610 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001611 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001612 if (this->expect(Token::Kind::TK_COLON, "':'")) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001613 ASTNode::ID falseExpr = this->assignmentExpression();
1614 if (!falseExpr) {
1615 return ASTNode::ID::Invalid();
1616 }
1617 CREATE_NODE(ternary, getNode(base).fOffset, ASTNode::Kind::kTernary);
1618 getNode(ternary).addChild(base);
1619 getNode(ternary).addChild(trueExpr);
1620 getNode(ternary).addChild(falseExpr);
1621 return ternary;
ethannicholasb3058bd2016-07-01 08:22:01 -07001622 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001623 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001624 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001625 return base;
ethannicholasb3058bd2016-07-01 08:22:01 -07001626}
1627
1628/* logicalXorExpression (LOGICALOR logicalXorExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001629ASTNode::ID Parser::logicalOrExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001630 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001631 ASTNode::ID result = this->logicalXorExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001632 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001633 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001634 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001635 Token t;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001636 while (this->checkNext(Token::Kind::TK_LOGICALOR, &t)) {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001637 if (!depth.increase()) {
1638 return ASTNode::ID::Invalid();
1639 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001640 ASTNode::ID right = this->logicalXorExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001641 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001642 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001643 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001644 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary, std::move(t));
1645 getNode(newResult).addChild(result);
1646 getNode(newResult).addChild(right);
1647 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001648 }
1649 return result;
1650}
1651
1652/* logicalAndExpression (LOGICALXOR logicalAndExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001653ASTNode::ID Parser::logicalXorExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001654 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001655 ASTNode::ID result = this->logicalAndExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001656 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001657 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001658 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001659 Token t;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001660 while (this->checkNext(Token::Kind::TK_LOGICALXOR, &t)) {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001661 if (!depth.increase()) {
1662 return ASTNode::ID::Invalid();
1663 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001664 ASTNode::ID right = this->logicalAndExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001665 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001666 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001667 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001668 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary, std::move(t));
1669 getNode(newResult).addChild(result);
1670 getNode(newResult).addChild(right);
1671 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001672 }
1673 return result;
1674}
1675
1676/* bitwiseOrExpression (LOGICALAND bitwiseOrExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001677ASTNode::ID Parser::logicalAndExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001678 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001679 ASTNode::ID result = this->bitwiseOrExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001680 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001681 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001682 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001683 Token t;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001684 while (this->checkNext(Token::Kind::TK_LOGICALAND, &t)) {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001685 if (!depth.increase()) {
1686 return ASTNode::ID::Invalid();
1687 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001688 ASTNode::ID right = this->bitwiseOrExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001689 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001690 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001691 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001692 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary, std::move(t));
1693 getNode(newResult).addChild(result);
1694 getNode(newResult).addChild(right);
1695 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001696 }
1697 return result;
1698}
1699
1700/* bitwiseXorExpression (BITWISEOR bitwiseXorExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001701ASTNode::ID Parser::bitwiseOrExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001702 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001703 ASTNode::ID result = this->bitwiseXorExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001704 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001705 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001706 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001707 Token t;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001708 while (this->checkNext(Token::Kind::TK_BITWISEOR, &t)) {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001709 if (!depth.increase()) {
1710 return ASTNode::ID::Invalid();
1711 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001712 ASTNode::ID right = this->bitwiseXorExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001713 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001714 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001715 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001716 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary, std::move(t));
1717 getNode(newResult).addChild(result);
1718 getNode(newResult).addChild(right);
1719 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001720 }
1721 return result;
1722}
1723
1724/* bitwiseAndExpression (BITWISEXOR bitwiseAndExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001725ASTNode::ID Parser::bitwiseXorExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001726 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001727 ASTNode::ID result = this->bitwiseAndExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001728 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001729 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001730 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001731 Token t;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001732 while (this->checkNext(Token::Kind::TK_BITWISEXOR, &t)) {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001733 if (!depth.increase()) {
1734 return ASTNode::ID::Invalid();
1735 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001736 ASTNode::ID right = this->bitwiseAndExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001737 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001738 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001739 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001740 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary, std::move(t));
1741 getNode(newResult).addChild(result);
1742 getNode(newResult).addChild(right);
1743 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001744 }
1745 return result;
1746}
1747
1748/* equalityExpression (BITWISEAND equalityExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001749ASTNode::ID Parser::bitwiseAndExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001750 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001751 ASTNode::ID result = this->equalityExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001752 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001753 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001754 }
Ethan Nicholas0c9d13b2017-05-08 16:18:19 -04001755 Token t;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001756 while (this->checkNext(Token::Kind::TK_BITWISEAND, &t)) {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001757 if (!depth.increase()) {
1758 return ASTNode::ID::Invalid();
1759 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001760 ASTNode::ID right = this->equalityExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001761 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001762 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001763 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001764 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary, std::move(t));
1765 getNode(newResult).addChild(result);
1766 getNode(newResult).addChild(right);
1767 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001768 }
1769 return result;
1770}
1771
1772/* relationalExpression ((EQEQ | NEQ) relationalExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001773ASTNode::ID Parser::equalityExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001774 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001775 ASTNode::ID result = this->relationalExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001776 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001777 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001778 }
1779 for (;;) {
1780 switch (this->peek().fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001781 case Token::Kind::TK_EQEQ: // fall through
1782 case Token::Kind::TK_NEQ: {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001783 if (!depth.increase()) {
1784 return ASTNode::ID::Invalid();
1785 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001786 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001787 ASTNode::ID right = this->relationalExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001788 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001789 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001790 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001791 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary,
1792 std::move(t));
1793 getNode(newResult).addChild(result);
1794 getNode(newResult).addChild(right);
1795 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001796 break;
1797 }
1798 default:
1799 return result;
1800 }
1801 }
1802}
1803
1804/* shiftExpression ((LT | GT | LTEQ | GTEQ) shiftExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001805ASTNode::ID Parser::relationalExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001806 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001807 ASTNode::ID result = this->shiftExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001808 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001809 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001810 }
1811 for (;;) {
1812 switch (this->peek().fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001813 case Token::Kind::TK_LT: // fall through
1814 case Token::Kind::TK_GT: // fall through
1815 case Token::Kind::TK_LTEQ: // fall through
1816 case Token::Kind::TK_GTEQ: {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001817 if (!depth.increase()) {
1818 return ASTNode::ID::Invalid();
1819 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001820 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001821 ASTNode::ID right = this->shiftExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001822 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001823 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001824 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001825 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary,
1826 std::move(t));
1827 getNode(newResult).addChild(result);
1828 getNode(newResult).addChild(right);
1829 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001830 break;
1831 }
1832 default:
1833 return result;
1834 }
1835 }
1836}
1837
1838/* additiveExpression ((SHL | SHR) additiveExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001839ASTNode::ID Parser::shiftExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001840 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001841 ASTNode::ID result = this->additiveExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001842 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001843 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001844 }
1845 for (;;) {
1846 switch (this->peek().fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001847 case Token::Kind::TK_SHL: // fall through
1848 case Token::Kind::TK_SHR: {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001849 if (!depth.increase()) {
1850 return ASTNode::ID::Invalid();
1851 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001852 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001853 ASTNode::ID right = this->additiveExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001854 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001855 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001856 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001857 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary,
1858 std::move(t));
1859 getNode(newResult).addChild(result);
1860 getNode(newResult).addChild(right);
1861 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001862 break;
1863 }
1864 default:
1865 return result;
1866 }
1867 }
1868}
1869
1870/* multiplicativeExpression ((PLUS | MINUS) multiplicativeExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001871ASTNode::ID Parser::additiveExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001872 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001873 ASTNode::ID result = this->multiplicativeExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001874 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001875 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001876 }
1877 for (;;) {
1878 switch (this->peek().fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001879 case Token::Kind::TK_PLUS: // fall through
1880 case Token::Kind::TK_MINUS: {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001881 if (!depth.increase()) {
1882 return ASTNode::ID::Invalid();
1883 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001884 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001885 ASTNode::ID right = this->multiplicativeExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001886 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001887 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001888 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001889 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary,
1890 std::move(t));
1891 getNode(newResult).addChild(result);
1892 getNode(newResult).addChild(right);
1893 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001894 break;
1895 }
1896 default:
1897 return result;
1898 }
1899 }
1900}
1901
1902/* unaryExpression ((STAR | SLASH | PERCENT) unaryExpression)* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001903ASTNode::ID Parser::multiplicativeExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001904 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001905 ASTNode::ID result = this->unaryExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001906 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001907 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001908 }
1909 for (;;) {
1910 switch (this->peek().fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001911 case Token::Kind::TK_STAR: // fall through
1912 case Token::Kind::TK_SLASH: // fall through
1913 case Token::Kind::TK_PERCENT: {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001914 if (!depth.increase()) {
1915 return ASTNode::ID::Invalid();
1916 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001917 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001918 ASTNode::ID right = this->unaryExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001919 if (!right) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001920 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001921 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001922 CREATE_NODE(newResult, getNode(result).fOffset, ASTNode::Kind::kBinary,
1923 std::move(t));
1924 getNode(newResult).addChild(result);
1925 getNode(newResult).addChild(right);
1926 result = newResult;
ethannicholasb3058bd2016-07-01 08:22:01 -07001927 break;
1928 }
1929 default:
1930 return result;
1931 }
1932 }
1933}
1934
1935/* postfixExpression | (PLUS | MINUS | NOT | PLUSPLUS | MINUSMINUS) unaryExpression */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001936ASTNode::ID Parser::unaryExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001937 AutoDepth depth(this);
ethannicholasb3058bd2016-07-01 08:22:01 -07001938 switch (this->peek().fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001939 case Token::Kind::TK_PLUS: // fall through
1940 case Token::Kind::TK_MINUS: // fall through
1941 case Token::Kind::TK_LOGICALNOT: // fall through
1942 case Token::Kind::TK_BITWISENOT: // fall through
1943 case Token::Kind::TK_PLUSPLUS: // fall through
1944 case Token::Kind::TK_MINUSMINUS: {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001945 if (!depth.increase()) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001946 return ASTNode::ID::Invalid();
Ethan Nicholas6dcc3252019-02-20 15:18:36 -05001947 }
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001948 Token t = this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04001949 ASTNode::ID expr = this->unaryExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07001950 if (!expr) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001951 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001952 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001953 CREATE_NODE(result, t.fOffset, ASTNode::Kind::kPrefix, std::move(t));
1954 getNode(result).addChild(expr);
1955 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07001956 }
1957 default:
1958 return this->postfixExpression();
1959 }
1960}
1961
1962/* term suffix* */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001963ASTNode::ID Parser::postfixExpression() {
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001964 AutoDepth depth(this);
Ethan Nicholasfc994162019-06-06 10:04:27 -04001965 ASTNode::ID result = this->term();
ethannicholasb3058bd2016-07-01 08:22:01 -07001966 if (!result) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04001967 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07001968 }
1969 for (;;) {
Ethan Nicholas5a9a0b32019-09-17 16:18:22 -04001970 Token t = this->peek();
1971 switch (t.fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001972 case Token::Kind::TK_FLOAT_LITERAL:
Ethan Nicholas5a9a0b32019-09-17 16:18:22 -04001973 if (this->text(t)[0] != '.') {
1974 return result;
1975 }
John Stiles30212b72020-06-11 17:55:07 -04001976 [[fallthrough]];
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001977 case Token::Kind::TK_LBRACKET:
1978 case Token::Kind::TK_DOT:
1979 case Token::Kind::TK_LPAREN:
1980 case Token::Kind::TK_PLUSPLUS:
1981 case Token::Kind::TK_MINUSMINUS:
1982 case Token::Kind::TK_COLONCOLON:
Ethan Nicholascf4deab2019-09-13 16:28:14 -04001983 if (!depth.increase()) {
1984 return ASTNode::ID::Invalid();
1985 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04001986 result = this->suffix(result);
Ethan Nicholas0c8582e2019-07-19 09:26:46 -04001987 if (!result) {
1988 return ASTNode::ID::Invalid();
1989 }
ethannicholasb3058bd2016-07-01 08:22:01 -07001990 break;
ethannicholasb3058bd2016-07-01 08:22:01 -07001991 default:
1992 return result;
1993 }
1994 }
1995}
1996
Ethan Nicholas11d53972016-11-28 11:23:23 -05001997/* LBRACKET expression? RBRACKET | DOT IDENTIFIER | LPAREN parameters RPAREN |
Ethan Nicholase455f652019-09-13 12:52:55 -04001998 PLUSPLUS | MINUSMINUS | COLONCOLON IDENTIFIER | FLOAT_LITERAL [IDENTIFIER] */
Ethan Nicholasfc994162019-06-06 10:04:27 -04001999ASTNode::ID Parser::suffix(ASTNode::ID base) {
Ethan Nicholas0c8582e2019-07-19 09:26:46 -04002000 SkASSERT(base);
ethannicholasb3058bd2016-07-01 08:22:01 -07002001 Token next = this->nextToken();
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04002002 AutoDepth depth(this);
Ethan Nicholascf4deab2019-09-13 16:28:14 -04002003 if (!depth.increase()) {
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04002004 return ASTNode::ID::Invalid();
2005 }
ethannicholasb3058bd2016-07-01 08:22:01 -07002006 switch (next.fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002007 case Token::Kind::TK_LBRACKET: {
2008 if (this->checkNext(Token::Kind::TK_RBRACKET)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002009 CREATE_NODE(result, next.fOffset, ASTNode::Kind::kIndex);
2010 getNode(result).addChild(base);
2011 return result;
ethannicholas5961bc92016-10-12 06:39:56 -07002012 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04002013 ASTNode::ID e = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07002014 if (!e) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002015 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07002016 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002017 this->expect(Token::Kind::TK_RBRACKET, "']' to complete array access expression");
Ethan Nicholasfc994162019-06-06 10:04:27 -04002018 CREATE_NODE(result, next.fOffset, ASTNode::Kind::kIndex);
2019 getNode(result).addChild(base);
2020 getNode(result).addChild(e);
2021 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07002022 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002023 case Token::Kind::TK_COLONCOLON: {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07002024 int offset = this->peek().fOffset;
2025 StringFragment text;
ethannicholasb3058bd2016-07-01 08:22:01 -07002026 if (this->identifier(&text)) {
Brian Osman6518d772020-09-10 16:50:06 -04002027 CREATE_NODE(result, offset, ASTNode::Kind::kScope, std::move(text));
2028 getNode(result).addChild(base);
2029 return result;
2030 }
2031 return ASTNode::ID::Invalid();
2032 }
2033 case Token::Kind::TK_DOT: {
2034 int offset = this->peek().fOffset;
2035 StringFragment text;
2036 if (this->identifier(&text)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002037 CREATE_NODE(result, offset, ASTNode::Kind::kField, std::move(text));
2038 getNode(result).addChild(base);
2039 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07002040 }
Brian Osman6518d772020-09-10 16:50:06 -04002041 [[fallthrough]];
Ethan Nicholase455f652019-09-13 12:52:55 -04002042 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002043 case Token::Kind::TK_FLOAT_LITERAL: {
Ethan Nicholase455f652019-09-13 12:52:55 -04002044 // Swizzles that start with a constant number, e.g. '.000r', will be tokenized as
2045 // floating point literals, possibly followed by an identifier. Handle that here.
2046 StringFragment field = this->text(next);
2047 SkASSERT(field.fChars[0] == '.');
2048 ++field.fChars;
2049 --field.fLength;
2050 for (size_t i = 0; i < field.fLength; ++i) {
2051 if (field.fChars[i] != '0' && field.fChars[i] != '1') {
2052 this->error(next, "invalid swizzle");
2053 return ASTNode::ID::Invalid();
2054 }
2055 }
2056 // use the next *raw* token so we don't ignore whitespace - we only care about
2057 // identifiers that directly follow the float
2058 Token id = this->nextRawToken();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002059 if (id.fKind == Token::Kind::TK_IDENTIFIER) {
Ethan Nicholase455f652019-09-13 12:52:55 -04002060 field.fLength += id.fLength;
2061 } else {
2062 this->pushback(id);
2063 }
2064 CREATE_NODE(result, next.fOffset, ASTNode::Kind::kField, field);
2065 getNode(result).addChild(base);
2066 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07002067 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002068 case Token::Kind::TK_LPAREN: {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002069 CREATE_NODE(result, next.fOffset, ASTNode::Kind::kCall);
2070 getNode(result).addChild(base);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002071 if (this->peek().fKind != Token::Kind::TK_RPAREN) {
ethannicholasb3058bd2016-07-01 08:22:01 -07002072 for (;;) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002073 ASTNode::ID expr = this->assignmentExpression();
ethannicholasb3058bd2016-07-01 08:22:01 -07002074 if (!expr) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002075 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07002076 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04002077 getNode(result).addChild(expr);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002078 if (!this->checkNext(Token::Kind::TK_COMMA)) {
ethannicholasb3058bd2016-07-01 08:22:01 -07002079 break;
2080 }
ethannicholasb3058bd2016-07-01 08:22:01 -07002081 }
2082 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002083 this->expect(Token::Kind::TK_RPAREN, "')' to complete function parameters");
Ethan Nicholasfc994162019-06-06 10:04:27 -04002084 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07002085 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002086 case Token::Kind::TK_PLUSPLUS: // fall through
2087 case Token::Kind::TK_MINUSMINUS: {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002088 CREATE_NODE(result, next.fOffset, ASTNode::Kind::kPostfix, next);
2089 getNode(result).addChild(base);
2090 return result;
2091 }
ethannicholasb3058bd2016-07-01 08:22:01 -07002092 default: {
Ethan Nicholas0c8582e2019-07-19 09:26:46 -04002093 this->error(next, "expected expression suffix, but found '" + this->text(next) + "'");
Ethan Nicholasfc994162019-06-06 10:04:27 -04002094 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07002095 }
2096 }
2097}
2098
Ethan Nicholasee1c8a72019-02-22 10:50:47 -05002099/* IDENTIFIER | intLiteral | floatLiteral | boolLiteral | NULL_LITERAL | '(' expression ')' */
Ethan Nicholasfc994162019-06-06 10:04:27 -04002100ASTNode::ID Parser::term() {
ethannicholasb3058bd2016-07-01 08:22:01 -07002101 Token t = this->peek();
2102 switch (t.fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002103 case Token::Kind::TK_IDENTIFIER: {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07002104 StringFragment text;
ethannicholasb3058bd2016-07-01 08:22:01 -07002105 if (this->identifier(&text)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002106 RETURN_NODE(t.fOffset, ASTNode::Kind::kIdentifier, std::move(text));
ethannicholasb3058bd2016-07-01 08:22:01 -07002107 }
John Stiles30212b72020-06-11 17:55:07 -04002108 break;
ethannicholasb3058bd2016-07-01 08:22:01 -07002109 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002110 case Token::Kind::TK_INT_LITERAL: {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002111 SKSL_INT i;
ethannicholasb3058bd2016-07-01 08:22:01 -07002112 if (this->intLiteral(&i)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002113 RETURN_NODE(t.fOffset, ASTNode::Kind::kInt, i);
ethannicholasb3058bd2016-07-01 08:22:01 -07002114 }
2115 break;
2116 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002117 case Token::Kind::TK_FLOAT_LITERAL: {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002118 SKSL_FLOAT f;
ethannicholasb3058bd2016-07-01 08:22:01 -07002119 if (this->floatLiteral(&f)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002120 RETURN_NODE(t.fOffset, ASTNode::Kind::kFloat, f);
ethannicholasb3058bd2016-07-01 08:22:01 -07002121 }
2122 break;
2123 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002124 case Token::Kind::TK_TRUE_LITERAL: // fall through
2125 case Token::Kind::TK_FALSE_LITERAL: {
ethannicholasb3058bd2016-07-01 08:22:01 -07002126 bool b;
2127 if (this->boolLiteral(&b)) {
Ethan Nicholasfc994162019-06-06 10:04:27 -04002128 RETURN_NODE(t.fOffset, ASTNode::Kind::kBool, b);
ethannicholasb3058bd2016-07-01 08:22:01 -07002129 }
2130 break;
2131 }
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002132 case Token::Kind::TK_NULL_LITERAL:
Ethan Nicholasee1c8a72019-02-22 10:50:47 -05002133 this->nextToken();
Ethan Nicholasfc994162019-06-06 10:04:27 -04002134 RETURN_NODE(t.fOffset, ASTNode::Kind::kNull);
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002135 case Token::Kind::TK_LPAREN: {
ethannicholasb3058bd2016-07-01 08:22:01 -07002136 this->nextToken();
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04002137 AutoDepth depth(this);
Ethan Nicholascf4deab2019-09-13 16:28:14 -04002138 if (!depth.increase()) {
Ethan Nicholas4e3b0112019-06-07 16:49:07 -04002139 return ASTNode::ID::Invalid();
2140 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04002141 ASTNode::ID result = this->expression();
ethannicholasb3058bd2016-07-01 08:22:01 -07002142 if (result) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002143 this->expect(Token::Kind::TK_RPAREN, "')' to complete expression");
Ethan Nicholasfc994162019-06-06 10:04:27 -04002144 return result;
ethannicholasb3058bd2016-07-01 08:22:01 -07002145 }
2146 break;
2147 }
2148 default:
2149 this->nextToken();
Ethan Nicholas0c8582e2019-07-19 09:26:46 -04002150 this->error(t.fOffset, "expected expression, but found '" + this->text(t) + "'");
ethannicholasb3058bd2016-07-01 08:22:01 -07002151 }
Ethan Nicholasfc994162019-06-06 10:04:27 -04002152 return ASTNode::ID::Invalid();
ethannicholasb3058bd2016-07-01 08:22:01 -07002153}
2154
2155/* INT_LITERAL */
Ethan Nicholasfc994162019-06-06 10:04:27 -04002156bool Parser::intLiteral(SKSL_INT* dest) {
ethannicholasb3058bd2016-07-01 08:22:01 -07002157 Token t;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002158 if (this->expect(Token::Kind::TK_INT_LITERAL, "integer literal", &t)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07002159 *dest = SkSL::stol(this->text(t));
ethannicholasb3058bd2016-07-01 08:22:01 -07002160 return true;
2161 }
2162 return false;
2163}
2164
2165/* FLOAT_LITERAL */
Ethan Nicholasfc994162019-06-06 10:04:27 -04002166bool Parser::floatLiteral(SKSL_FLOAT* dest) {
ethannicholasb3058bd2016-07-01 08:22:01 -07002167 Token t;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002168 if (this->expect(Token::Kind::TK_FLOAT_LITERAL, "float literal", &t)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07002169 *dest = SkSL::stod(this->text(t));
ethannicholasb3058bd2016-07-01 08:22:01 -07002170 return true;
2171 }
2172 return false;
2173}
2174
2175/* TRUE_LITERAL | FALSE_LITERAL */
2176bool Parser::boolLiteral(bool* dest) {
2177 Token t = this->nextToken();
2178 switch (t.fKind) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002179 case Token::Kind::TK_TRUE_LITERAL:
ethannicholasb3058bd2016-07-01 08:22:01 -07002180 *dest = true;
2181 return true;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002182 case Token::Kind::TK_FALSE_LITERAL:
ethannicholasb3058bd2016-07-01 08:22:01 -07002183 *dest = false;
2184 return true;
2185 default:
Ethan Nicholas0c8582e2019-07-19 09:26:46 -04002186 this->error(t, "expected 'true' or 'false', but found '" + this->text(t) + "'");
ethannicholasb3058bd2016-07-01 08:22:01 -07002187 return false;
2188 }
2189}
2190
2191/* IDENTIFIER */
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07002192bool Parser::identifier(StringFragment* dest) {
ethannicholasb3058bd2016-07-01 08:22:01 -07002193 Token t;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04002194 if (this->expect(Token::Kind::TK_IDENTIFIER, "identifier", &t)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07002195 *dest = this->text(t);
ethannicholasb3058bd2016-07-01 08:22:01 -07002196 return true;
2197 }
2198 return false;
2199}
2200
John Stilesa6841be2020-08-06 14:11:56 -04002201} // namespace SkSL