1 /*
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 */
7
8 #include "stdio.h"
9 #include "SkSLParser.h"
10 #include "ast/SkSLASTBinaryExpression.h"
11 #include "ast/SkSLASTBlock.h"
12 #include "ast/SkSLASTBoolLiteral.h"
13 #include "ast/SkSLASTBreakStatement.h"
14 #include "ast/SkSLASTCallSuffix.h"
15 #include "ast/SkSLASTContinueStatement.h"
16 #include "ast/SkSLASTDiscardStatement.h"
17 #include "ast/SkSLASTDoStatement.h"
18 #include "ast/SkSLASTEnum.h"
19 #include "ast/SkSLASTExpression.h"
20 #include "ast/SkSLASTExpressionStatement.h"
21 #include "ast/SkSLASTExtension.h"
22 #include "ast/SkSLASTFieldSuffix.h"
23 #include "ast/SkSLASTFloatLiteral.h"
24 #include "ast/SkSLASTForStatement.h"
25 #include "ast/SkSLASTFunction.h"
26 #include "ast/SkSLASTIdentifier.h"
27 #include "ast/SkSLASTIfStatement.h"
28 #include "ast/SkSLASTIndexSuffix.h"
29 #include "ast/SkSLASTInterfaceBlock.h"
30 #include "ast/SkSLASTIntLiteral.h"
31 #include "ast/SkSLASTModifiersDeclaration.h"
32 #include "ast/SkSLASTParameter.h"
33 #include "ast/SkSLASTPrefixExpression.h"
34 #include "ast/SkSLASTReturnStatement.h"
35 #include "ast/SkSLASTSection.h"
36 #include "ast/SkSLASTStatement.h"
37 #include "ast/SkSLASTSuffixExpression.h"
38 #include "ast/SkSLASTSwitchCase.h"
39 #include "ast/SkSLASTSwitchStatement.h"
40 #include "ast/SkSLASTTernaryExpression.h"
41 #include "ast/SkSLASTType.h"
42 #include "ast/SkSLASTVarDeclaration.h"
43 #include "ast/SkSLASTVarDeclarationStatement.h"
44 #include "ast/SkSLASTWhileStatement.h"
45 #include "ir/SkSLSymbolTable.h"
46 #include "ir/SkSLModifiers.h"
47 #include "ir/SkSLType.h"
48
49 #ifndef SKSL_STANDALONE
50 #include "SkOnce.h"
51 #endif
52
53 namespace SkSL {
54
55 #define MAX_PARSE_DEPTH 50
56
57 class AutoDepth {
58 public:
AutoDepth(Parser * p)59 AutoDepth(Parser* p)
60 : fParser(p) {
61 fParser->fDepth++;
62 }
63
~AutoDepth()64 ~AutoDepth() {
65 fParser->fDepth--;
66 }
67
checkValid()68 bool checkValid() {
69 if (fParser->fDepth > MAX_PARSE_DEPTH) {
70 fParser->error(fParser->peek(), String("exceeded max parse depth"));
71 return false;
72 }
73 return true;
74 }
75
76 private:
77 Parser* fParser;
78 };
79
80 std::unordered_map<String, Parser::LayoutToken>* Parser::layoutTokens;
81
InitLayoutMap()82 void Parser::InitLayoutMap() {
83 layoutTokens = new std::unordered_map<String, LayoutToken>;
84 #define TOKEN(name, text) (*layoutTokens)[text] = LayoutToken::name
85 TOKEN(LOCATION, "location");
86 TOKEN(OFFSET, "offset");
87 TOKEN(BINDING, "binding");
88 TOKEN(INDEX, "index");
89 TOKEN(SET, "set");
90 TOKEN(BUILTIN, "builtin");
91 TOKEN(INPUT_ATTACHMENT_INDEX, "input_attachment_index");
92 TOKEN(ORIGIN_UPPER_LEFT, "origin_upper_left");
93 TOKEN(OVERRIDE_COVERAGE, "override_coverage");
94 TOKEN(BLEND_SUPPORT_ALL_EQUATIONS, "blend_support_all_equations");
95 TOKEN(BLEND_SUPPORT_MULTIPLY, "blend_support_multiply");
96 TOKEN(BLEND_SUPPORT_SCREEN, "blend_support_screen");
97 TOKEN(BLEND_SUPPORT_OVERLAY, "blend_support_overlay");
98 TOKEN(BLEND_SUPPORT_DARKEN, "blend_support_darken");
99 TOKEN(BLEND_SUPPORT_LIGHTEN, "blend_support_lighten");
100 TOKEN(BLEND_SUPPORT_COLORDODGE, "blend_support_colordodge");
101 TOKEN(BLEND_SUPPORT_COLORBURN, "blend_support_colorburn");
102 TOKEN(BLEND_SUPPORT_HARDLIGHT, "blend_support_hardlight");
103 TOKEN(BLEND_SUPPORT_SOFTLIGHT, "blend_support_softlight");
104 TOKEN(BLEND_SUPPORT_DIFFERENCE, "blend_support_difference");
105 TOKEN(BLEND_SUPPORT_EXCLUSION, "blend_support_exclusion");
106 TOKEN(BLEND_SUPPORT_HSL_HUE, "blend_support_hsl_hue");
107 TOKEN(BLEND_SUPPORT_HSL_SATURATION, "blend_support_hsl_saturation");
108 TOKEN(BLEND_SUPPORT_HSL_COLOR, "blend_support_hsl_color");
109 TOKEN(BLEND_SUPPORT_HSL_LUMINOSITY, "blend_support_hsl_luminosity");
110 TOKEN(PUSH_CONSTANT, "push_constant");
111 TOKEN(POINTS, "points");
112 TOKEN(LINES, "lines");
113 TOKEN(LINE_STRIP, "line_strip");
114 TOKEN(LINES_ADJACENCY, "lines_adjacency");
115 TOKEN(TRIANGLES, "triangles");
116 TOKEN(TRIANGLE_STRIP, "triangle_strip");
117 TOKEN(TRIANGLES_ADJACENCY, "triangles_adjacency");
118 TOKEN(MAX_VERTICES, "max_vertices");
119 TOKEN(INVOCATIONS, "invocations");
120 TOKEN(WHEN, "when");
121 TOKEN(KEY, "key");
122 TOKEN(TRACKED, "tracked");
123 TOKEN(CTYPE, "ctype");
124 TOKEN(SKPMCOLOR4F, "SkPMColor4f");
125 TOKEN(SKRECT, "SkRect");
126 TOKEN(SKIRECT, "SkIRect");
127 TOKEN(SKPMCOLOR, "SkPMColor");
128 #undef TOKEN
129 }
130
Parser(const char * text,size_t length,SymbolTable & types,ErrorReporter & errors)131 Parser::Parser(const char* text, size_t length, SymbolTable& types, ErrorReporter& errors)
132 : fText(text)
133 , fPushback(Token::INVALID, -1, -1)
134 , fTypes(types)
135 , fErrors(errors) {
136 fLexer.start(text, length);
137 static const bool layoutMapInitialized = []{ return (void)InitLayoutMap(), true; }();
138 (void) layoutMapInitialized;
139 }
140
141 /* (directive | section | declaration)* END_OF_FILE */
file()142 std::vector<std::unique_ptr<ASTDeclaration>> Parser::file() {
143 std::vector<std::unique_ptr<ASTDeclaration>> result;
144 for (;;) {
145 switch (this->peek().fKind) {
146 case Token::END_OF_FILE:
147 return result;
148 case Token::DIRECTIVE: {
149 std::unique_ptr<ASTDeclaration> decl = this->directive();
150 if (decl) {
151 result.push_back(std::move(decl));
152 }
153 break;
154 }
155 case Token::SECTION: {
156 std::unique_ptr<ASTDeclaration> section = this->section();
157 if (section) {
158 result.push_back(std::move(section));
159 }
160 break;
161 }
162 default: {
163 std::unique_ptr<ASTDeclaration> decl = this->declaration();
164 if (!decl) {
165 continue;
166 }
167 result.push_back(std::move(decl));
168 }
169 }
170 }
171 }
172
nextRawToken()173 Token Parser::nextRawToken() {
174 if (fPushback.fKind != Token::INVALID) {
175 Token result = fPushback;
176 fPushback.fKind = Token::INVALID;
177 return result;
178 }
179 Token result = fLexer.next();
180 return result;
181 }
182
nextToken()183 Token Parser::nextToken() {
184 Token token = this->nextRawToken();
185 while (token.fKind == Token::WHITESPACE || token.fKind == Token::LINE_COMMENT ||
186 token.fKind == Token::BLOCK_COMMENT) {
187 token = this->nextRawToken();
188 }
189 return token;
190 }
191
pushback(Token t)192 void Parser::pushback(Token t) {
193 SkASSERT(fPushback.fKind == Token::INVALID);
194 fPushback = std::move(t);
195 }
196
peek()197 Token Parser::peek() {
198 if (fPushback.fKind == Token::INVALID) {
199 fPushback = this->nextToken();
200 }
201 return fPushback;
202 }
203
checkNext(Token::Kind kind,Token * result)204 bool Parser::checkNext(Token::Kind kind, Token* result) {
205 if (fPushback.fKind != Token::INVALID && fPushback.fKind != kind) {
206 return false;
207 }
208 Token next = this->nextToken();
209 if (next.fKind == kind) {
210 if (result) {
211 *result = next;
212 }
213 return true;
214 }
215 this->pushback(std::move(next));
216 return false;
217 }
218
expect(Token::Kind kind,const char * expected,Token * result)219 bool Parser::expect(Token::Kind kind, const char* expected, Token* result) {
220 Token next = this->nextToken();
221 if (next.fKind == kind) {
222 if (result) {
223 *result = std::move(next);
224 }
225 return true;
226 } else {
227 this->error(next, "expected " + String(expected) + ", but found '" +
228 this->text(next) + "'");
229 return false;
230 }
231 }
232
text(Token token)233 StringFragment Parser::text(Token token) {
234 return StringFragment(fText + token.fOffset, token.fLength);
235 }
236
error(Token token,String msg)237 void Parser::error(Token token, String msg) {
238 this->error(token.fOffset, msg);
239 }
240
error(int offset,String msg)241 void Parser::error(int offset, String msg) {
242 fErrors.error(offset, msg);
243 }
244
isType(StringFragment name)245 bool Parser::isType(StringFragment name) {
246 return nullptr != fTypes[name];
247 }
248
249 /* DIRECTIVE(#version) INT_LITERAL ("es" | "compatibility")? |
250 DIRECTIVE(#extension) IDENTIFIER COLON IDENTIFIER */
directive()251 std::unique_ptr<ASTDeclaration> Parser::directive() {
252 Token start;
253 if (!this->expect(Token::DIRECTIVE, "a directive", &start)) {
254 return nullptr;
255 }
256 StringFragment text = this->text(start);
257 if (text == "#version") {
258 this->expect(Token::INT_LITERAL, "a version number");
259 Token next = this->peek();
260 StringFragment nextText = this->text(next);
261 if (nextText == "es" || nextText == "compatibility") {
262 this->nextToken();
263 }
264 // version is ignored for now; it will eventually become an error when we stop pretending
265 // to be GLSL
266 return nullptr;
267 } else if (text == "#extension") {
268 Token name;
269 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
270 return nullptr;
271 }
272 if (!this->expect(Token::COLON, "':'")) {
273 return nullptr;
274 }
275 // FIXME: need to start paying attention to this token
276 if (!this->expect(Token::IDENTIFIER, "an identifier")) {
277 return nullptr;
278 }
279 return std::unique_ptr<ASTDeclaration>(new ASTExtension(start.fOffset,
280 String(this->text(name))));
281 } else {
282 this->error(start, "unsupported directive '" + this->text(start) + "'");
283 return nullptr;
284 }
285 }
286
287 /* SECTION LBRACE (LPAREN IDENTIFIER RPAREN)? <any sequence of tokens with balanced braces>
288 RBRACE */
section()289 std::unique_ptr<ASTDeclaration> Parser::section() {
290 Token start;
291 if (!this->expect(Token::SECTION, "a section token", &start)) {
292 return nullptr;
293 }
294 String argument;
295 if (this->peek().fKind == Token::LPAREN) {
296 this->nextToken();
297 Token argToken;
298 if (!this->expect(Token::IDENTIFIER, "an identifier", &argToken)) {
299 return nullptr;
300 }
301 argument = this->text(argToken);
302 if (!this->expect(Token::RPAREN, "')'")) {
303 return nullptr;
304 }
305 }
306 if (!this->expect(Token::LBRACE, "'{'")) {
307 return nullptr;
308 }
309 String text;
310 int level = 1;
311 for (;;) {
312 Token next = this->nextRawToken();
313 switch (next.fKind) {
314 case Token::LBRACE:
315 ++level;
316 break;
317 case Token::RBRACE:
318 --level;
319 break;
320 case Token::END_OF_FILE:
321 this->error(start, "reached end of file while parsing section");
322 return nullptr;
323 default:
324 break;
325 }
326 if (!level) {
327 break;
328 }
329 text += this->text(next);
330 }
331 StringFragment name = this->text(start);
332 ++name.fChars;
333 --name.fLength;
334 return std::unique_ptr<ASTDeclaration>(new ASTSection(start.fOffset,
335 String(name),
336 argument,
337 text));
338 }
339
340 /* ENUM CLASS IDENTIFIER LBRACE (IDENTIFIER (EQ expression)? (COMMA IDENTIFIER (EQ expression))*)?
341 RBRACE */
enumDeclaration()342 std::unique_ptr<ASTDeclaration> Parser::enumDeclaration() {
343 Token start;
344 if (!this->expect(Token::ENUM, "'enum'", &start)) {
345 return nullptr;
346 }
347 if (!this->expect(Token::CLASS, "'class'")) {
348 return nullptr;
349 }
350 Token name;
351 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
352 return nullptr;
353 }
354 if (!this->expect(Token::LBRACE, "'{'")) {
355 return nullptr;
356 }
357 fTypes.add(this->text(name), std::unique_ptr<Symbol>(new Type(this->text(name),
358 Type::kEnum_Kind)));
359 std::vector<StringFragment> names;
360 std::vector<std::unique_ptr<ASTExpression>> values;
361 if (!this->checkNext(Token::RBRACE)) {
362 Token id;
363 if (!this->expect(Token::IDENTIFIER, "an identifier", &id)) {
364 return nullptr;
365 }
366 names.push_back(this->text(id));
367 if (this->checkNext(Token::EQ)) {
368 std::unique_ptr<ASTExpression> value = this->assignmentExpression();
369 if (!value) {
370 return nullptr;
371 }
372 values.push_back(std::move(value));
373 } else {
374 values.push_back(nullptr);
375 }
376 while (!this->checkNext(Token::RBRACE)) {
377 if (!this->expect(Token::COMMA, "','")) {
378 return nullptr;
379 }
380 if (!this->expect(Token::IDENTIFIER, "an identifier", &id)) {
381 return nullptr;
382 }
383 names.push_back(this->text(id));
384 if (this->checkNext(Token::EQ)) {
385 std::unique_ptr<ASTExpression> value = this->assignmentExpression();
386 if (!value) {
387 return nullptr;
388 }
389 values.push_back(std::move(value));
390 } else {
391 values.push_back(nullptr);
392 }
393 }
394 }
395 this->expect(Token::SEMICOLON, "';'");
396 return std::unique_ptr<ASTDeclaration>(new ASTEnum(name.fOffset, this->text(name), names,
397 std::move(values)));
398 }
399
400 /* enumDeclaration | modifiers (structVarDeclaration | type IDENTIFIER ((LPAREN parameter
401 (COMMA parameter)* RPAREN (block | SEMICOLON)) | SEMICOLON) | interfaceBlock) */
declaration()402 std::unique_ptr<ASTDeclaration> Parser::declaration() {
403 Token lookahead = this->peek();
404 if (lookahead.fKind == Token::ENUM) {
405 return this->enumDeclaration();
406 }
407 Modifiers modifiers = this->modifiers();
408 lookahead = this->peek();
409 if (lookahead.fKind == Token::IDENTIFIER && !this->isType(this->text(lookahead))) {
410 // we have an identifier that's not a type, could be the start of an interface block
411 return this->interfaceBlock(modifiers);
412 }
413 if (lookahead.fKind == Token::STRUCT) {
414 return this->structVarDeclaration(modifiers);
415 }
416 if (lookahead.fKind == Token::SEMICOLON) {
417 this->nextToken();
418 return std::unique_ptr<ASTDeclaration>(new ASTModifiersDeclaration(modifiers));
419 }
420 std::unique_ptr<ASTType> type(this->type());
421 if (!type) {
422 return nullptr;
423 }
424 if (type->fKind == ASTType::kStruct_Kind && this->checkNext(Token::SEMICOLON)) {
425 return nullptr;
426 }
427 Token name;
428 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
429 return nullptr;
430 }
431 if (this->checkNext(Token::LPAREN)) {
432 std::vector<std::unique_ptr<ASTParameter>> parameters;
433 while (this->peek().fKind != Token::RPAREN) {
434 if (parameters.size() > 0) {
435 if (!this->expect(Token::COMMA, "','")) {
436 return nullptr;
437 }
438 }
439 std::unique_ptr<ASTParameter> parameter = this->parameter();
440 if (!parameter) {
441 return nullptr;
442 }
443 parameters.push_back(std::move(parameter));
444 }
445 this->nextToken();
446 std::unique_ptr<ASTBlock> body;
447 if (!this->checkNext(Token::SEMICOLON)) {
448 body = this->block();
449 if (!body) {
450 return nullptr;
451 }
452 }
453 return std::unique_ptr<ASTDeclaration>(new ASTFunction(name.fOffset,
454 modifiers,
455 std::move(type),
456 this->text(name),
457 std::move(parameters),
458 std::move(body)));
459 } else {
460 return this->varDeclarationEnd(modifiers, std::move(type), this->text(name));
461 }
462 }
463
464 /* modifiers type IDENTIFIER varDeclarationEnd */
varDeclarations()465 std::unique_ptr<ASTVarDeclarations> Parser::varDeclarations() {
466 Modifiers modifiers = this->modifiers();
467 std::unique_ptr<ASTType> type(this->type());
468 if (!type) {
469 return nullptr;
470 }
471 Token name;
472 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
473 return nullptr;
474 }
475 return this->varDeclarationEnd(modifiers, std::move(type), this->text(name));
476 }
477
478 /* STRUCT IDENTIFIER LBRACE varDeclaration* RBRACE */
structDeclaration()479 std::unique_ptr<ASTType> Parser::structDeclaration() {
480 if (!this->expect(Token::STRUCT, "'struct'")) {
481 return nullptr;
482 }
483 Token name;
484 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
485 return nullptr;
486 }
487 if (!this->expect(Token::LBRACE, "'{'")) {
488 return nullptr;
489 }
490 std::vector<Type::Field> fields;
491 while (this->peek().fKind != Token::RBRACE) {
492 std::unique_ptr<ASTVarDeclarations> decl = this->varDeclarations();
493 if (!decl) {
494 return nullptr;
495 }
496 for (const auto& var : decl->fVars) {
497 auto type = (const Type*) fTypes[decl->fType->fName];
498 for (int i = (int) var.fSizes.size() - 1; i >= 0; i--) {
499 if (!var.fSizes[i] || var.fSizes[i]->fKind != ASTExpression::kInt_Kind) {
500 this->error(decl->fOffset, "array size in struct field must be a constant");
501 return nullptr;
502 }
503 uint64_t columns = ((ASTIntLiteral&) *var.fSizes[i]).fValue;
504 String name = type->name() + "[" + to_string(columns) + "]";
505 type = new Type(name, Type::kArray_Kind, *type, (int) columns);
506 fTypes.takeOwnership((Type*) type);
507 }
508 fields.push_back(Type::Field(decl->fModifiers, var.fName, type));
509 if (var.fValue) {
510 this->error(decl->fOffset, "initializers are not permitted on struct fields");
511 }
512 }
513 }
514 if (!this->expect(Token::RBRACE, "'}'")) {
515 return nullptr;
516 }
517 fTypes.add(this->text(name), std::unique_ptr<Type>(new Type(name.fOffset, this->text(name),
518 fields)));
519 return std::unique_ptr<ASTType>(new ASTType(name.fOffset, this->text(name),
520 ASTType::kStruct_Kind, std::vector<int>()));
521 }
522
523 /* structDeclaration ((IDENTIFIER varDeclarationEnd) | SEMICOLON) */
structVarDeclaration(Modifiers modifiers)524 std::unique_ptr<ASTVarDeclarations> Parser::structVarDeclaration(Modifiers modifiers) {
525 std::unique_ptr<ASTType> type = this->structDeclaration();
526 if (!type) {
527 return nullptr;
528 }
529 Token name;
530 if (this->checkNext(Token::IDENTIFIER, &name)) {
531 std::unique_ptr<ASTVarDeclarations> result = this->varDeclarationEnd(modifiers,
532 std::move(type),
533 this->text(name));
534 if (result) {
535 for (const auto& var : result->fVars) {
536 if (var.fValue) {
537 this->error(var.fValue->fOffset,
538 "struct variables cannot be initialized");
539 }
540 }
541 }
542 return result;
543 }
544 this->expect(Token::SEMICOLON, "';'");
545 return nullptr;
546 }
547
548 /* (LBRACKET expression? RBRACKET)* (EQ assignmentExpression)? (COMMA IDENTIFER
549 (LBRACKET expression? RBRACKET)* (EQ assignmentExpression)?)* SEMICOLON */
varDeclarationEnd(Modifiers mods,std::unique_ptr<ASTType> type,StringFragment name)550 std::unique_ptr<ASTVarDeclarations> Parser::varDeclarationEnd(Modifiers mods,
551 std::unique_ptr<ASTType> type,
552 StringFragment name) {
553 std::vector<ASTVarDeclaration> vars;
554 std::vector<std::unique_ptr<ASTExpression>> currentVarSizes;
555 while (this->checkNext(Token::LBRACKET)) {
556 if (this->checkNext(Token::RBRACKET)) {
557 currentVarSizes.push_back(nullptr);
558 } else {
559 std::unique_ptr<ASTExpression> size(this->expression());
560 if (!size) {
561 return nullptr;
562 }
563 currentVarSizes.push_back(std::move(size));
564 if (!this->expect(Token::RBRACKET, "']'")) {
565 return nullptr;
566 }
567 }
568 }
569 std::unique_ptr<ASTExpression> value;
570 if (this->checkNext(Token::EQ)) {
571 value = this->assignmentExpression();
572 if (!value) {
573 return nullptr;
574 }
575 }
576 vars.emplace_back(name, std::move(currentVarSizes), std::move(value));
577 while (this->checkNext(Token::COMMA)) {
578 Token name;
579 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
580 return nullptr;
581 }
582 currentVarSizes.clear();
583 value.reset();
584 while (this->checkNext(Token::LBRACKET)) {
585 if (this->checkNext(Token::RBRACKET)) {
586 currentVarSizes.push_back(nullptr);
587 } else {
588 std::unique_ptr<ASTExpression> size(this->expression());
589 if (!size) {
590 return nullptr;
591 }
592 currentVarSizes.push_back(std::move(size));
593 if (!this->expect(Token::RBRACKET, "']'")) {
594 return nullptr;
595 }
596 }
597 }
598 if (this->checkNext(Token::EQ)) {
599 value = this->assignmentExpression();
600 if (!value) {
601 return nullptr;
602 }
603 }
604 vars.emplace_back(this->text(name), std::move(currentVarSizes), std::move(value));
605 }
606 if (!this->expect(Token::SEMICOLON, "';'")) {
607 return nullptr;
608 }
609 return std::unique_ptr<ASTVarDeclarations>(new ASTVarDeclarations(std::move(mods),
610 std::move(type),
611 std::move(vars)));
612 }
613
614 /* modifiers type IDENTIFIER (LBRACKET INT_LITERAL RBRACKET)? */
parameter()615 std::unique_ptr<ASTParameter> Parser::parameter() {
616 Modifiers modifiers = this->modifiersWithDefaults(0);
617 std::unique_ptr<ASTType> type = this->type();
618 if (!type) {
619 return nullptr;
620 }
621 Token name;
622 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
623 return nullptr;
624 }
625 std::vector<int> sizes;
626 while (this->checkNext(Token::LBRACKET)) {
627 Token sizeToken;
628 if (!this->expect(Token::INT_LITERAL, "a positive integer", &sizeToken)) {
629 return nullptr;
630 }
631 sizes.push_back(SkSL::stoi(this->text(sizeToken)));
632 if (!this->expect(Token::RBRACKET, "']'")) {
633 return nullptr;
634 }
635 }
636 return std::unique_ptr<ASTParameter>(new ASTParameter(name.fOffset, modifiers, std::move(type),
637 this->text(name), std::move(sizes)));
638 }
639
640 /** EQ INT_LITERAL */
layoutInt()641 int Parser::layoutInt() {
642 if (!this->expect(Token::EQ, "'='")) {
643 return -1;
644 }
645 Token resultToken;
646 if (this->expect(Token::INT_LITERAL, "a non-negative integer", &resultToken)) {
647 return SkSL::stoi(this->text(resultToken));
648 }
649 return -1;
650 }
651
652 /** EQ IDENTIFIER */
layoutIdentifier()653 StringFragment Parser::layoutIdentifier() {
654 if (!this->expect(Token::EQ, "'='")) {
655 return StringFragment();
656 }
657 Token resultToken;
658 if (!this->expect(Token::IDENTIFIER, "an identifier", &resultToken)) {
659 return StringFragment();
660 }
661 return this->text(resultToken);
662 }
663
664
665 /** EQ <any sequence of tokens with balanced parentheses and no top-level comma> */
layoutCode()666 String Parser::layoutCode() {
667 if (!this->expect(Token::EQ, "'='")) {
668 return "";
669 }
670 Token start = this->nextRawToken();
671 this->pushback(start);
672 String code;
673 int level = 1;
674 bool done = false;
675 while (!done) {
676 Token next = this->nextRawToken();
677 switch (next.fKind) {
678 case Token::LPAREN:
679 ++level;
680 break;
681 case Token::RPAREN:
682 --level;
683 break;
684 case Token::COMMA:
685 if (level == 1) {
686 done = true;
687 }
688 break;
689 case Token::END_OF_FILE:
690 this->error(start, "reached end of file while parsing layout");
691 return nullptr;
692 default:
693 break;
694 }
695 if (!level) {
696 done = true;
697 }
698 if (done) {
699 this->pushback(std::move(next));
700 }
701 else {
702 code += this->text(next);
703 }
704 }
705 return code;
706 }
707
708 /** (EQ IDENTIFIER('identity'))? */
layoutKey()709 Layout::Key Parser::layoutKey() {
710 if (this->peek().fKind == Token::EQ) {
711 this->expect(Token::EQ, "'='");
712 Token key;
713 if (this->expect(Token::IDENTIFIER, "an identifer", &key)) {
714 if (this->text(key) == "identity") {
715 return Layout::kIdentity_Key;
716 } else {
717 this->error(key, "unsupported layout key");
718 }
719 }
720 }
721 return Layout::kKey_Key;
722 }
723
layoutCType()724 Layout::CType Parser::layoutCType() {
725 if (this->expect(Token::EQ, "'='")) {
726 Token t = this->nextToken();
727 String text = this->text(t);
728 auto found = layoutTokens->find(text);
729 if (found != layoutTokens->end()) {
730 switch (found->second) {
731 case LayoutToken::SKPMCOLOR4F:
732 return Layout::CType::kSkPMColor4f;
733 case LayoutToken::SKRECT:
734 return Layout::CType::kSkRect;
735 case LayoutToken::SKIRECT:
736 return Layout::CType::kSkIRect;
737 case LayoutToken::SKPMCOLOR:
738 return Layout::CType::kSkPMColor;
739 default:
740 break;
741 }
742 }
743 this->error(t, "unsupported ctype");
744 }
745 return Layout::CType::kDefault;
746 }
747
748 /* LAYOUT LPAREN IDENTIFIER (EQ INT_LITERAL)? (COMMA IDENTIFIER (EQ INT_LITERAL)?)* RPAREN */
layout()749 Layout Parser::layout() {
750 int flags = 0;
751 int location = -1;
752 int offset = -1;
753 int binding = -1;
754 int index = -1;
755 int set = -1;
756 int builtin = -1;
757 int inputAttachmentIndex = -1;
758 Layout::Format format = Layout::Format::kUnspecified;
759 Layout::Primitive primitive = Layout::kUnspecified_Primitive;
760 int maxVertices = -1;
761 int invocations = -1;
762 String when;
763 Layout::Key key = Layout::kNo_Key;
764 Layout::CType ctype = Layout::CType::kDefault;
765 if (this->checkNext(Token::LAYOUT)) {
766 if (!this->expect(Token::LPAREN, "'('")) {
767 return Layout(flags, location, offset, binding, index, set, builtin,
768 inputAttachmentIndex, format, primitive, maxVertices, invocations, when,
769 key, ctype);
770 }
771 for (;;) {
772 Token t = this->nextToken();
773 String text = this->text(t);
774 auto found = layoutTokens->find(text);
775 if (found != layoutTokens->end()) {
776 switch (found->second) {
777 case LayoutToken::LOCATION:
778 location = this->layoutInt();
779 break;
780 case LayoutToken::OFFSET:
781 offset = this->layoutInt();
782 break;
783 case LayoutToken::BINDING:
784 binding = this->layoutInt();
785 break;
786 case LayoutToken::INDEX:
787 index = this->layoutInt();
788 break;
789 case LayoutToken::SET:
790 set = this->layoutInt();
791 break;
792 case LayoutToken::BUILTIN:
793 builtin = this->layoutInt();
794 break;
795 case LayoutToken::INPUT_ATTACHMENT_INDEX:
796 inputAttachmentIndex = this->layoutInt();
797 break;
798 case LayoutToken::ORIGIN_UPPER_LEFT:
799 flags |= Layout::kOriginUpperLeft_Flag;
800 break;
801 case LayoutToken::OVERRIDE_COVERAGE:
802 flags |= Layout::kOverrideCoverage_Flag;
803 break;
804 case LayoutToken::BLEND_SUPPORT_ALL_EQUATIONS:
805 flags |= Layout::kBlendSupportAllEquations_Flag;
806 break;
807 case LayoutToken::BLEND_SUPPORT_MULTIPLY:
808 flags |= Layout::kBlendSupportMultiply_Flag;
809 break;
810 case LayoutToken::BLEND_SUPPORT_SCREEN:
811 flags |= Layout::kBlendSupportScreen_Flag;
812 break;
813 case LayoutToken::BLEND_SUPPORT_OVERLAY:
814 flags |= Layout::kBlendSupportOverlay_Flag;
815 break;
816 case LayoutToken::BLEND_SUPPORT_DARKEN:
817 flags |= Layout::kBlendSupportDarken_Flag;
818 break;
819 case LayoutToken::BLEND_SUPPORT_LIGHTEN:
820 flags |= Layout::kBlendSupportLighten_Flag;
821 break;
822 case LayoutToken::BLEND_SUPPORT_COLORDODGE:
823 flags |= Layout::kBlendSupportColorDodge_Flag;
824 break;
825 case LayoutToken::BLEND_SUPPORT_COLORBURN:
826 flags |= Layout::kBlendSupportColorBurn_Flag;
827 break;
828 case LayoutToken::BLEND_SUPPORT_HARDLIGHT:
829 flags |= Layout::kBlendSupportHardLight_Flag;
830 break;
831 case LayoutToken::BLEND_SUPPORT_SOFTLIGHT:
832 flags |= Layout::kBlendSupportSoftLight_Flag;
833 break;
834 case LayoutToken::BLEND_SUPPORT_DIFFERENCE:
835 flags |= Layout::kBlendSupportDifference_Flag;
836 break;
837 case LayoutToken::BLEND_SUPPORT_EXCLUSION:
838 flags |= Layout::kBlendSupportExclusion_Flag;
839 break;
840 case LayoutToken::BLEND_SUPPORT_HSL_HUE:
841 flags |= Layout::kBlendSupportHSLHue_Flag;
842 break;
843 case LayoutToken::BLEND_SUPPORT_HSL_SATURATION:
844 flags |= Layout::kBlendSupportHSLSaturation_Flag;
845 break;
846 case LayoutToken::BLEND_SUPPORT_HSL_COLOR:
847 flags |= Layout::kBlendSupportHSLColor_Flag;
848 break;
849 case LayoutToken::BLEND_SUPPORT_HSL_LUMINOSITY:
850 flags |= Layout::kBlendSupportHSLLuminosity_Flag;
851 break;
852 case LayoutToken::PUSH_CONSTANT:
853 flags |= Layout::kPushConstant_Flag;
854 break;
855 case LayoutToken::TRACKED:
856 flags |= Layout::kTracked_Flag;
857 break;
858 case LayoutToken::POINTS:
859 primitive = Layout::kPoints_Primitive;
860 break;
861 case LayoutToken::LINES:
862 primitive = Layout::kLines_Primitive;
863 break;
864 case LayoutToken::LINE_STRIP:
865 primitive = Layout::kLineStrip_Primitive;
866 break;
867 case LayoutToken::LINES_ADJACENCY:
868 primitive = Layout::kLinesAdjacency_Primitive;
869 break;
870 case LayoutToken::TRIANGLES:
871 primitive = Layout::kTriangles_Primitive;
872 break;
873 case LayoutToken::TRIANGLE_STRIP:
874 primitive = Layout::kTriangleStrip_Primitive;
875 break;
876 case LayoutToken::TRIANGLES_ADJACENCY:
877 primitive = Layout::kTrianglesAdjacency_Primitive;
878 break;
879 case LayoutToken::MAX_VERTICES:
880 maxVertices = this->layoutInt();
881 break;
882 case LayoutToken::INVOCATIONS:
883 invocations = this->layoutInt();
884 break;
885 case LayoutToken::WHEN:
886 when = this->layoutCode();
887 break;
888 case LayoutToken::KEY:
889 key = this->layoutKey();
890 break;
891 case LayoutToken::CTYPE:
892 ctype = this->layoutCType();
893 break;
894 default:
895 this->error(t, ("'" + text + "' is not a valid layout qualifier").c_str());
896 break;
897 }
898 } else if (Layout::ReadFormat(text, &format)) {
899 // AST::ReadFormat stored the result in 'format'.
900 } else {
901 this->error(t, ("'" + text + "' is not a valid layout qualifier").c_str());
902 }
903 if (this->checkNext(Token::RPAREN)) {
904 break;
905 }
906 if (!this->expect(Token::COMMA, "','")) {
907 break;
908 }
909 }
910 }
911 return Layout(flags, location, offset, binding, index, set, builtin, inputAttachmentIndex,
912 format, primitive, maxVertices, invocations, when, key, ctype);
913 }
914
915 /* layout? (UNIFORM | CONST | IN | OUT | INOUT | LOWP | MEDIUMP | HIGHP | FLAT | NOPERSPECTIVE |
916 READONLY | WRITEONLY | COHERENT | VOLATILE | RESTRICT | BUFFER | PLS | PLSIN |
917 PLSOUT)* */
modifiers()918 Modifiers Parser::modifiers() {
919 Layout layout = this->layout();
920 int flags = 0;
921 for (;;) {
922 // TODO: handle duplicate / incompatible flags
923 switch (peek().fKind) {
924 case Token::UNIFORM:
925 this->nextToken();
926 flags |= Modifiers::kUniform_Flag;
927 break;
928 case Token::CONST:
929 this->nextToken();
930 flags |= Modifiers::kConst_Flag;
931 break;
932 case Token::IN:
933 this->nextToken();
934 flags |= Modifiers::kIn_Flag;
935 break;
936 case Token::OUT:
937 this->nextToken();
938 flags |= Modifiers::kOut_Flag;
939 break;
940 case Token::INOUT:
941 this->nextToken();
942 flags |= Modifiers::kIn_Flag;
943 flags |= Modifiers::kOut_Flag;
944 break;
945 case Token::LOWP:
946 this->nextToken();
947 flags |= Modifiers::kLowp_Flag;
948 break;
949 case Token::MEDIUMP:
950 this->nextToken();
951 flags |= Modifiers::kMediump_Flag;
952 break;
953 case Token::HIGHP:
954 this->nextToken();
955 flags |= Modifiers::kHighp_Flag;
956 break;
957 case Token::FLAT:
958 this->nextToken();
959 flags |= Modifiers::kFlat_Flag;
960 break;
961 case Token::NOPERSPECTIVE:
962 this->nextToken();
963 flags |= Modifiers::kNoPerspective_Flag;
964 break;
965 case Token::READONLY:
966 this->nextToken();
967 flags |= Modifiers::kReadOnly_Flag;
968 break;
969 case Token::WRITEONLY:
970 this->nextToken();
971 flags |= Modifiers::kWriteOnly_Flag;
972 break;
973 case Token::COHERENT:
974 this->nextToken();
975 flags |= Modifiers::kCoherent_Flag;
976 break;
977 case Token::VOLATILE:
978 this->nextToken();
979 flags |= Modifiers::kVolatile_Flag;
980 break;
981 case Token::RESTRICT:
982 this->nextToken();
983 flags |= Modifiers::kRestrict_Flag;
984 break;
985 case Token::BUFFER:
986 this->nextToken();
987 flags |= Modifiers::kBuffer_Flag;
988 break;
989 case Token::HASSIDEEFFECTS:
990 this->nextToken();
991 flags |= Modifiers::kHasSideEffects_Flag;
992 break;
993 case Token::PLS:
994 this->nextToken();
995 flags |= Modifiers::kPLS_Flag;
996 break;
997 case Token::PLSIN:
998 this->nextToken();
999 flags |= Modifiers::kPLSIn_Flag;
1000 break;
1001 case Token::PLSOUT:
1002 this->nextToken();
1003 flags |= Modifiers::kPLSOut_Flag;
1004 break;
1005 default:
1006 return Modifiers(layout, flags);
1007 }
1008 }
1009 }
1010
modifiersWithDefaults(int defaultFlags)1011 Modifiers Parser::modifiersWithDefaults(int defaultFlags) {
1012 Modifiers result = this->modifiers();
1013 if (!result.fFlags) {
1014 return Modifiers(result.fLayout, defaultFlags);
1015 }
1016 return result;
1017 }
1018
1019 /* ifStatement | forStatement | doStatement | whileStatement | block | expression */
statement()1020 std::unique_ptr<ASTStatement> Parser::statement() {
1021 Token start = this->peek();
1022 switch (start.fKind) {
1023 case Token::IF: // fall through
1024 case Token::STATIC_IF:
1025 return this->ifStatement();
1026 case Token::FOR:
1027 return this->forStatement();
1028 case Token::DO:
1029 return this->doStatement();
1030 case Token::WHILE:
1031 return this->whileStatement();
1032 case Token::SWITCH: // fall through
1033 case Token::STATIC_SWITCH:
1034 return this->switchStatement();
1035 case Token::RETURN:
1036 return this->returnStatement();
1037 case Token::BREAK:
1038 return this->breakStatement();
1039 case Token::CONTINUE:
1040 return this->continueStatement();
1041 case Token::DISCARD:
1042 return this->discardStatement();
1043 case Token::LBRACE:
1044 return this->block();
1045 case Token::SEMICOLON:
1046 this->nextToken();
1047 return std::unique_ptr<ASTStatement>(new ASTBlock(start.fOffset,
1048 std::vector<std::unique_ptr<ASTStatement>>()));
1049 case Token::CONST: // fall through
1050 case Token::HIGHP: // fall through
1051 case Token::MEDIUMP: // fall through
1052 case Token::LOWP: {
1053 auto decl = this->varDeclarations();
1054 if (!decl) {
1055 return nullptr;
1056 }
1057 return std::unique_ptr<ASTStatement>(new ASTVarDeclarationStatement(std::move(decl)));
1058 }
1059 case Token::IDENTIFIER:
1060 if (this->isType(this->text(start))) {
1061 auto decl = this->varDeclarations();
1062 if (!decl) {
1063 return nullptr;
1064 }
1065 return std::unique_ptr<ASTStatement>(new ASTVarDeclarationStatement(
1066 std::move(decl)));
1067 }
1068 // fall through
1069 default:
1070 return this->expressionStatement();
1071 }
1072 }
1073
1074 /* IDENTIFIER(type) (LBRACKET intLiteral? RBRACKET)* */
type()1075 std::unique_ptr<ASTType> Parser::type() {
1076 Token type;
1077 if (!this->expect(Token::IDENTIFIER, "a type", &type)) {
1078 return nullptr;
1079 }
1080 if (!this->isType(this->text(type))) {
1081 this->error(type, ("no type named '" + this->text(type) + "'").c_str());
1082 return nullptr;
1083 }
1084 std::vector<int> sizes;
1085 while (this->checkNext(Token::LBRACKET)) {
1086 if (this->peek().fKind != Token::RBRACKET) {
1087 int64_t i;
1088 if (this->intLiteral(&i)) {
1089 sizes.push_back(i);
1090 } else {
1091 return nullptr;
1092 }
1093 } else {
1094 sizes.push_back(-1);
1095 }
1096 this->expect(Token::RBRACKET, "']'");
1097 }
1098 return std::unique_ptr<ASTType>(new ASTType(type.fOffset, this->text(type),
1099 ASTType::kIdentifier_Kind, sizes));
1100 }
1101
1102 /* IDENTIFIER LBRACE varDeclaration* RBRACE (IDENTIFIER (LBRACKET expression? RBRACKET)*)? */
interfaceBlock(Modifiers mods)1103 std::unique_ptr<ASTDeclaration> Parser::interfaceBlock(Modifiers mods) {
1104 Token name;
1105 if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
1106 return nullptr;
1107 }
1108 if (peek().fKind != Token::LBRACE) {
1109 // we only get into interfaceBlock if we found a top-level identifier which was not a type.
1110 // 99% of the time, the user was not actually intending to create an interface block, so
1111 // it's better to report it as an unknown type
1112 this->error(name, "no type named '" + this->text(name) + "'");
1113 return nullptr;
1114 }
1115 this->nextToken();
1116 std::vector<std::unique_ptr<ASTVarDeclarations>> decls;
1117 while (this->peek().fKind != Token::RBRACE) {
1118 std::unique_ptr<ASTVarDeclarations> decl = this->varDeclarations();
1119 if (!decl) {
1120 return nullptr;
1121 }
1122 decls.push_back(std::move(decl));
1123 }
1124 this->nextToken();
1125 std::vector<std::unique_ptr<ASTExpression>> sizes;
1126 StringFragment instanceName;
1127 Token instanceNameToken;
1128 if (this->checkNext(Token::IDENTIFIER, &instanceNameToken)) {
1129 while (this->checkNext(Token::LBRACKET)) {
1130 if (this->peek().fKind != Token::RBRACKET) {
1131 std::unique_ptr<ASTExpression> size = this->expression();
1132 if (!size) {
1133 return nullptr;
1134 }
1135 sizes.push_back(std::move(size));
1136 } else {
1137 sizes.push_back(nullptr);
1138 }
1139 this->expect(Token::RBRACKET, "']'");
1140 }
1141 instanceName = this->text(instanceNameToken);
1142 }
1143 this->expect(Token::SEMICOLON, "';'");
1144 return std::unique_ptr<ASTDeclaration>(new ASTInterfaceBlock(name.fOffset, mods,
1145 this->text(name),
1146 std::move(decls),
1147 instanceName,
1148 std::move(sizes)));
1149 }
1150
1151 /* IF LPAREN expression RPAREN statement (ELSE statement)? */
ifStatement()1152 std::unique_ptr<ASTIfStatement> Parser::ifStatement() {
1153 Token start;
1154 bool isStatic = this->checkNext(Token::STATIC_IF, &start);
1155 if (!isStatic && !this->expect(Token::IF, "'if'", &start)) {
1156 return nullptr;
1157 }
1158 if (!this->expect(Token::LPAREN, "'('")) {
1159 return nullptr;
1160 }
1161 std::unique_ptr<ASTExpression> test(this->expression());
1162 if (!test) {
1163 return nullptr;
1164 }
1165 if (!this->expect(Token::RPAREN, "')'")) {
1166 return nullptr;
1167 }
1168 std::unique_ptr<ASTStatement> ifTrue(this->statement());
1169 if (!ifTrue) {
1170 return nullptr;
1171 }
1172 std::unique_ptr<ASTStatement> ifFalse;
1173 if (this->checkNext(Token::ELSE)) {
1174 ifFalse = this->statement();
1175 if (!ifFalse) {
1176 return nullptr;
1177 }
1178 }
1179 return std::unique_ptr<ASTIfStatement>(new ASTIfStatement(start.fOffset,
1180 isStatic,
1181 std::move(test),
1182 std::move(ifTrue),
1183 std::move(ifFalse)));
1184 }
1185
1186 /* DO statement WHILE LPAREN expression RPAREN SEMICOLON */
doStatement()1187 std::unique_ptr<ASTDoStatement> Parser::doStatement() {
1188 Token start;
1189 if (!this->expect(Token::DO, "'do'", &start)) {
1190 return nullptr;
1191 }
1192 std::unique_ptr<ASTStatement> statement(this->statement());
1193 if (!statement) {
1194 return nullptr;
1195 }
1196 if (!this->expect(Token::WHILE, "'while'")) {
1197 return nullptr;
1198 }
1199 if (!this->expect(Token::LPAREN, "'('")) {
1200 return nullptr;
1201 }
1202 std::unique_ptr<ASTExpression> test(this->expression());
1203 if (!test) {
1204 return nullptr;
1205 }
1206 if (!this->expect(Token::RPAREN, "')'")) {
1207 return nullptr;
1208 }
1209 if (!this->expect(Token::SEMICOLON, "';'")) {
1210 return nullptr;
1211 }
1212 return std::unique_ptr<ASTDoStatement>(new ASTDoStatement(start.fOffset,
1213 std::move(statement),
1214 std::move(test)));
1215 }
1216
1217 /* WHILE LPAREN expression RPAREN STATEMENT */
whileStatement()1218 std::unique_ptr<ASTWhileStatement> Parser::whileStatement() {
1219 Token start;
1220 if (!this->expect(Token::WHILE, "'while'", &start)) {
1221 return nullptr;
1222 }
1223 if (!this->expect(Token::LPAREN, "'('")) {
1224 return nullptr;
1225 }
1226 std::unique_ptr<ASTExpression> test(this->expression());
1227 if (!test) {
1228 return nullptr;
1229 }
1230 if (!this->expect(Token::RPAREN, "')'")) {
1231 return nullptr;
1232 }
1233 std::unique_ptr<ASTStatement> statement(this->statement());
1234 if (!statement) {
1235 return nullptr;
1236 }
1237 return std::unique_ptr<ASTWhileStatement>(new ASTWhileStatement(start.fOffset,
1238 std::move(test),
1239 std::move(statement)));
1240 }
1241
1242 /* CASE expression COLON statement* */
switchCase()1243 std::unique_ptr<ASTSwitchCase> Parser::switchCase() {
1244 Token start;
1245 if (!this->expect(Token::CASE, "'case'", &start)) {
1246 return nullptr;
1247 }
1248 std::unique_ptr<ASTExpression> value = this->expression();
1249 if (!value) {
1250 return nullptr;
1251 }
1252 if (!this->expect(Token::COLON, "':'")) {
1253 return nullptr;
1254 }
1255 std::vector<std::unique_ptr<ASTStatement>> statements;
1256 while (this->peek().fKind != Token::RBRACE && this->peek().fKind != Token::CASE &&
1257 this->peek().fKind != Token::DEFAULT) {
1258 std::unique_ptr<ASTStatement> s = this->statement();
1259 if (!s) {
1260 return nullptr;
1261 }
1262 statements.push_back(std::move(s));
1263 }
1264 return std::unique_ptr<ASTSwitchCase>(new ASTSwitchCase(start.fOffset, std::move(value),
1265 std::move(statements)));
1266 }
1267
1268 /* SWITCH LPAREN expression RPAREN LBRACE switchCase* (DEFAULT COLON statement*)? RBRACE */
switchStatement()1269 std::unique_ptr<ASTStatement> Parser::switchStatement() {
1270 Token start;
1271 bool isStatic = this->checkNext(Token::STATIC_SWITCH, &start);
1272 if (!isStatic && !this->expect(Token::SWITCH, "'switch'", &start)) {
1273 return nullptr;
1274 }
1275 if (!this->expect(Token::LPAREN, "'('")) {
1276 return nullptr;
1277 }
1278 std::unique_ptr<ASTExpression> value(this->expression());
1279 if (!value) {
1280 return nullptr;
1281 }
1282 if (!this->expect(Token::RPAREN, "')'")) {
1283 return nullptr;
1284 }
1285 if (!this->expect(Token::LBRACE, "'{'")) {
1286 return nullptr;
1287 }
1288 std::vector<std::unique_ptr<ASTSwitchCase>> cases;
1289 while (this->peek().fKind == Token::CASE) {
1290 std::unique_ptr<ASTSwitchCase> c = this->switchCase();
1291 if (!c) {
1292 return nullptr;
1293 }
1294 cases.push_back(std::move(c));
1295 }
1296 // Requiring default: to be last (in defiance of C and GLSL) was a deliberate decision. Other
1297 // parts of the compiler may rely upon this assumption.
1298 if (this->peek().fKind == Token::DEFAULT) {
1299 Token defaultStart;
1300 SkAssertResult(this->expect(Token::DEFAULT, "'default'", &defaultStart));
1301 if (!this->expect(Token::COLON, "':'")) {
1302 return nullptr;
1303 }
1304 std::vector<std::unique_ptr<ASTStatement>> statements;
1305 while (this->peek().fKind != Token::RBRACE) {
1306 std::unique_ptr<ASTStatement> s = this->statement();
1307 if (!s) {
1308 return nullptr;
1309 }
1310 statements.push_back(std::move(s));
1311 }
1312 cases.emplace_back(new ASTSwitchCase(defaultStart.fOffset, nullptr,
1313 std::move(statements)));
1314 }
1315 if (!this->expect(Token::RBRACE, "'}'")) {
1316 return nullptr;
1317 }
1318 return std::unique_ptr<ASTStatement>(new ASTSwitchStatement(start.fOffset,
1319 isStatic,
1320 std::move(value),
1321 std::move(cases)));
1322 }
1323
1324 /* FOR LPAREN (declaration | expression)? SEMICOLON expression? SEMICOLON expression? RPAREN
1325 STATEMENT */
forStatement()1326 std::unique_ptr<ASTForStatement> Parser::forStatement() {
1327 Token start;
1328 if (!this->expect(Token::FOR, "'for'", &start)) {
1329 return nullptr;
1330 }
1331 if (!this->expect(Token::LPAREN, "'('")) {
1332 return nullptr;
1333 }
1334 std::unique_ptr<ASTStatement> initializer;
1335 Token nextToken = this->peek();
1336 switch (nextToken.fKind) {
1337 case Token::SEMICOLON:
1338 this->nextToken();
1339 break;
1340 case Token::CONST: {
1341 std::unique_ptr<ASTVarDeclarations> vd = this->varDeclarations();
1342 if (!vd) {
1343 return nullptr;
1344 }
1345 initializer = std::unique_ptr<ASTStatement>(new ASTVarDeclarationStatement(
1346 std::move(vd)));
1347 break;
1348 }
1349 case Token::IDENTIFIER: {
1350 if (this->isType(this->text(nextToken))) {
1351 std::unique_ptr<ASTVarDeclarations> vd = this->varDeclarations();
1352 if (!vd) {
1353 return nullptr;
1354 }
1355 initializer = std::unique_ptr<ASTStatement>(new ASTVarDeclarationStatement(
1356 std::move(vd)));
1357 break;
1358 }
1359 } // fall through
1360 default:
1361 initializer = this->expressionStatement();
1362 }
1363 std::unique_ptr<ASTExpression> test;
1364 if (this->peek().fKind != Token::SEMICOLON) {
1365 test = this->expression();
1366 if (!test) {
1367 return nullptr;
1368 }
1369 }
1370 if (!this->expect(Token::SEMICOLON, "';'")) {
1371 return nullptr;
1372 }
1373 std::unique_ptr<ASTExpression> next;
1374 if (this->peek().fKind != Token::RPAREN) {
1375 next = this->expression();
1376 if (!next) {
1377 return nullptr;
1378 }
1379 }
1380 if (!this->expect(Token::RPAREN, "')'")) {
1381 return nullptr;
1382 }
1383 std::unique_ptr<ASTStatement> statement(this->statement());
1384 if (!statement) {
1385 return nullptr;
1386 }
1387 return std::unique_ptr<ASTForStatement>(new ASTForStatement(start.fOffset,
1388 std::move(initializer),
1389 std::move(test), std::move(next),
1390 std::move(statement)));
1391 }
1392
1393 /* RETURN expression? SEMICOLON */
returnStatement()1394 std::unique_ptr<ASTReturnStatement> Parser::returnStatement() {
1395 Token start;
1396 if (!this->expect(Token::RETURN, "'return'", &start)) {
1397 return nullptr;
1398 }
1399 std::unique_ptr<ASTExpression> expression;
1400 if (this->peek().fKind != Token::SEMICOLON) {
1401 expression = this->expression();
1402 if (!expression) {
1403 return nullptr;
1404 }
1405 }
1406 if (!this->expect(Token::SEMICOLON, "';'")) {
1407 return nullptr;
1408 }
1409 return std::unique_ptr<ASTReturnStatement>(new ASTReturnStatement(start.fOffset,
1410 std::move(expression)));
1411 }
1412
1413 /* BREAK SEMICOLON */
breakStatement()1414 std::unique_ptr<ASTBreakStatement> Parser::breakStatement() {
1415 Token start;
1416 if (!this->expect(Token::BREAK, "'break'", &start)) {
1417 return nullptr;
1418 }
1419 if (!this->expect(Token::SEMICOLON, "';'")) {
1420 return nullptr;
1421 }
1422 return std::unique_ptr<ASTBreakStatement>(new ASTBreakStatement(start.fOffset));
1423 }
1424
1425 /* CONTINUE SEMICOLON */
continueStatement()1426 std::unique_ptr<ASTContinueStatement> Parser::continueStatement() {
1427 Token start;
1428 if (!this->expect(Token::CONTINUE, "'continue'", &start)) {
1429 return nullptr;
1430 }
1431 if (!this->expect(Token::SEMICOLON, "';'")) {
1432 return nullptr;
1433 }
1434 return std::unique_ptr<ASTContinueStatement>(new ASTContinueStatement(start.fOffset));
1435 }
1436
1437 /* DISCARD SEMICOLON */
discardStatement()1438 std::unique_ptr<ASTDiscardStatement> Parser::discardStatement() {
1439 Token start;
1440 if (!this->expect(Token::DISCARD, "'continue'", &start)) {
1441 return nullptr;
1442 }
1443 if (!this->expect(Token::SEMICOLON, "';'")) {
1444 return nullptr;
1445 }
1446 return std::unique_ptr<ASTDiscardStatement>(new ASTDiscardStatement(start.fOffset));
1447 }
1448
1449 /* LBRACE statement* RBRACE */
block()1450 std::unique_ptr<ASTBlock> Parser::block() {
1451 AutoDepth depth(this);
1452 if (!depth.checkValid()) {
1453 return nullptr;
1454 }
1455 Token start;
1456 if (!this->expect(Token::LBRACE, "'{'", &start)) {
1457 return nullptr;
1458 }
1459 std::vector<std::unique_ptr<ASTStatement>> statements;
1460 for (;;) {
1461 switch (this->peek().fKind) {
1462 case Token::RBRACE:
1463 this->nextToken();
1464 return std::unique_ptr<ASTBlock>(new ASTBlock(start.fOffset,
1465 std::move(statements)));
1466 case Token::END_OF_FILE:
1467 this->error(this->peek(), "expected '}', but found end of file");
1468 return nullptr;
1469 default: {
1470 std::unique_ptr<ASTStatement> statement = this->statement();
1471 if (!statement) {
1472 return nullptr;
1473 }
1474 statements.push_back(std::move(statement));
1475 }
1476 }
1477 }
1478 }
1479
1480 /* expression SEMICOLON */
expressionStatement()1481 std::unique_ptr<ASTExpressionStatement> Parser::expressionStatement() {
1482 std::unique_ptr<ASTExpression> expr = this->expression();
1483 if (expr) {
1484 if (this->expect(Token::SEMICOLON, "';'")) {
1485 ASTExpressionStatement* result = new ASTExpressionStatement(std::move(expr));
1486 return std::unique_ptr<ASTExpressionStatement>(result);
1487 }
1488 }
1489 return nullptr;
1490 }
1491
1492 /* commaExpression */
expression()1493 std::unique_ptr<ASTExpression> Parser::expression() {
1494 AutoDepth depth(this);
1495 if (!depth.checkValid()) {
1496 return nullptr;
1497 }
1498 return this->commaExpression();
1499 }
1500
1501 /* assignmentExpression (COMMA assignmentExpression)* */
commaExpression()1502 std::unique_ptr<ASTExpression> Parser::commaExpression() {
1503 std::unique_ptr<ASTExpression> result = this->assignmentExpression();
1504 if (!result) {
1505 return nullptr;
1506 }
1507 Token t;
1508 while (this->checkNext(Token::COMMA, &t)) {
1509 std::unique_ptr<ASTExpression> right = this->commaExpression();
1510 if (!right) {
1511 return nullptr;
1512 }
1513 result.reset(new ASTBinaryExpression(std::move(result), std::move(t), std::move(right)));
1514 }
1515 return result;
1516 }
1517
1518 /* ternaryExpression ((EQEQ | STAREQ | SLASHEQ | PERCENTEQ | PLUSEQ | MINUSEQ | SHLEQ | SHREQ |
1519 BITWISEANDEQ | BITWISEXOREQ | BITWISEOREQ | LOGICALANDEQ | LOGICALXOREQ | LOGICALOREQ)
1520 assignmentExpression)*
1521 */
assignmentExpression()1522 std::unique_ptr<ASTExpression> Parser::assignmentExpression() {
1523 std::unique_ptr<ASTExpression> result = this->ternaryExpression();
1524 if (!result) {
1525 return nullptr;
1526 }
1527 for (;;) {
1528 switch (this->peek().fKind) {
1529 case Token::EQ: // fall through
1530 case Token::STAREQ: // fall through
1531 case Token::SLASHEQ: // fall through
1532 case Token::PERCENTEQ: // fall through
1533 case Token::PLUSEQ: // fall through
1534 case Token::MINUSEQ: // fall through
1535 case Token::SHLEQ: // fall through
1536 case Token::SHREQ: // fall through
1537 case Token::BITWISEANDEQ: // fall through
1538 case Token::BITWISEXOREQ: // fall through
1539 case Token::BITWISEOREQ: // fall through
1540 case Token::LOGICALANDEQ: // fall through
1541 case Token::LOGICALXOREQ: // fall through
1542 case Token::LOGICALOREQ: {
1543 Token t = this->nextToken();
1544 std::unique_ptr<ASTExpression> right = this->assignmentExpression();
1545 if (!right) {
1546 return nullptr;
1547 }
1548 result = std::unique_ptr<ASTExpression>(new ASTBinaryExpression(std::move(result),
1549 std::move(t),
1550 std::move(right)));
1551 return result;
1552 }
1553 default:
1554 return result;
1555 }
1556 }
1557 }
1558
1559 /* logicalOrExpression ('?' expression ':' assignmentExpression)? */
ternaryExpression()1560 std::unique_ptr<ASTExpression> Parser::ternaryExpression() {
1561 std::unique_ptr<ASTExpression> result = this->logicalOrExpression();
1562 if (!result) {
1563 return nullptr;
1564 }
1565 if (this->checkNext(Token::QUESTION)) {
1566 std::unique_ptr<ASTExpression> trueExpr = this->expression();
1567 if (!trueExpr) {
1568 return nullptr;
1569 }
1570 if (this->expect(Token::COLON, "':'")) {
1571 std::unique_ptr<ASTExpression> falseExpr = this->assignmentExpression();
1572 return std::unique_ptr<ASTExpression>(new ASTTernaryExpression(std::move(result),
1573 std::move(trueExpr),
1574 std::move(falseExpr)));
1575 }
1576 return nullptr;
1577 }
1578 return result;
1579 }
1580
1581 /* logicalXorExpression (LOGICALOR logicalXorExpression)* */
logicalOrExpression()1582 std::unique_ptr<ASTExpression> Parser::logicalOrExpression() {
1583 std::unique_ptr<ASTExpression> result = this->logicalXorExpression();
1584 if (!result) {
1585 return nullptr;
1586 }
1587 Token t;
1588 while (this->checkNext(Token::LOGICALOR, &t)) {
1589 std::unique_ptr<ASTExpression> right = this->logicalXorExpression();
1590 if (!right) {
1591 return nullptr;
1592 }
1593 result.reset(new ASTBinaryExpression(std::move(result), std::move(t), std::move(right)));
1594 }
1595 return result;
1596 }
1597
1598 /* logicalAndExpression (LOGICALXOR logicalAndExpression)* */
logicalXorExpression()1599 std::unique_ptr<ASTExpression> Parser::logicalXorExpression() {
1600 std::unique_ptr<ASTExpression> result = this->logicalAndExpression();
1601 if (!result) {
1602 return nullptr;
1603 }
1604 Token t;
1605 while (this->checkNext(Token::LOGICALXOR, &t)) {
1606 std::unique_ptr<ASTExpression> right = this->logicalAndExpression();
1607 if (!right) {
1608 return nullptr;
1609 }
1610 result.reset(new ASTBinaryExpression(std::move(result), std::move(t), std::move(right)));
1611 }
1612 return result;
1613 }
1614
1615 /* bitwiseOrExpression (LOGICALAND bitwiseOrExpression)* */
logicalAndExpression()1616 std::unique_ptr<ASTExpression> Parser::logicalAndExpression() {
1617 std::unique_ptr<ASTExpression> result = this->bitwiseOrExpression();
1618 if (!result) {
1619 return nullptr;
1620 }
1621 Token t;
1622 while (this->checkNext(Token::LOGICALAND, &t)) {
1623 std::unique_ptr<ASTExpression> right = this->bitwiseOrExpression();
1624 if (!right) {
1625 return nullptr;
1626 }
1627 result.reset(new ASTBinaryExpression(std::move(result), std::move(t), std::move(right)));
1628 }
1629 return result;
1630 }
1631
1632 /* bitwiseXorExpression (BITWISEOR bitwiseXorExpression)* */
bitwiseOrExpression()1633 std::unique_ptr<ASTExpression> Parser::bitwiseOrExpression() {
1634 std::unique_ptr<ASTExpression> result = this->bitwiseXorExpression();
1635 if (!result) {
1636 return nullptr;
1637 }
1638 Token t;
1639 while (this->checkNext(Token::BITWISEOR, &t)) {
1640 std::unique_ptr<ASTExpression> right = this->bitwiseXorExpression();
1641 if (!right) {
1642 return nullptr;
1643 }
1644 result.reset(new ASTBinaryExpression(std::move(result), std::move(t), std::move(right)));
1645 }
1646 return result;
1647 }
1648
1649 /* bitwiseAndExpression (BITWISEXOR bitwiseAndExpression)* */
bitwiseXorExpression()1650 std::unique_ptr<ASTExpression> Parser::bitwiseXorExpression() {
1651 std::unique_ptr<ASTExpression> result = this->bitwiseAndExpression();
1652 if (!result) {
1653 return nullptr;
1654 }
1655 Token t;
1656 while (this->checkNext(Token::BITWISEXOR, &t)) {
1657 std::unique_ptr<ASTExpression> right = this->bitwiseAndExpression();
1658 if (!right) {
1659 return nullptr;
1660 }
1661 result.reset(new ASTBinaryExpression(std::move(result), std::move(t), std::move(right)));
1662 }
1663 return result;
1664 }
1665
1666 /* equalityExpression (BITWISEAND equalityExpression)* */
bitwiseAndExpression()1667 std::unique_ptr<ASTExpression> Parser::bitwiseAndExpression() {
1668 std::unique_ptr<ASTExpression> result = this->equalityExpression();
1669 if (!result) {
1670 return nullptr;
1671 }
1672 Token t;
1673 while (this->checkNext(Token::BITWISEAND, &t)) {
1674 std::unique_ptr<ASTExpression> right = this->equalityExpression();
1675 if (!right) {
1676 return nullptr;
1677 }
1678 result.reset(new ASTBinaryExpression(std::move(result), std::move(t), std::move(right)));
1679 }
1680 return result;
1681 }
1682
1683 /* relationalExpression ((EQEQ | NEQ) relationalExpression)* */
equalityExpression()1684 std::unique_ptr<ASTExpression> Parser::equalityExpression() {
1685 std::unique_ptr<ASTExpression> result = this->relationalExpression();
1686 if (!result) {
1687 return nullptr;
1688 }
1689 for (;;) {
1690 switch (this->peek().fKind) {
1691 case Token::EQEQ: // fall through
1692 case Token::NEQ: {
1693 Token t = this->nextToken();
1694 std::unique_ptr<ASTExpression> right = this->relationalExpression();
1695 if (!right) {
1696 return nullptr;
1697 }
1698 result.reset(new ASTBinaryExpression(std::move(result), std::move(t), std::move(right)));
1699 break;
1700 }
1701 default:
1702 return result;
1703 }
1704 }
1705 }
1706
1707 /* shiftExpression ((LT | GT | LTEQ | GTEQ) shiftExpression)* */
relationalExpression()1708 std::unique_ptr<ASTExpression> Parser::relationalExpression() {
1709 std::unique_ptr<ASTExpression> result = this->shiftExpression();
1710 if (!result) {
1711 return nullptr;
1712 }
1713 for (;;) {
1714 switch (this->peek().fKind) {
1715 case Token::LT: // fall through
1716 case Token::GT: // fall through
1717 case Token::LTEQ: // fall through
1718 case Token::GTEQ: {
1719 Token t = this->nextToken();
1720 std::unique_ptr<ASTExpression> right = this->shiftExpression();
1721 if (!right) {
1722 return nullptr;
1723 }
1724 result.reset(new ASTBinaryExpression(std::move(result), std::move(t),
1725 std::move(right)));
1726 break;
1727 }
1728 default:
1729 return result;
1730 }
1731 }
1732 }
1733
1734 /* additiveExpression ((SHL | SHR) additiveExpression)* */
shiftExpression()1735 std::unique_ptr<ASTExpression> Parser::shiftExpression() {
1736 std::unique_ptr<ASTExpression> result = this->additiveExpression();
1737 if (!result) {
1738 return nullptr;
1739 }
1740 for (;;) {
1741 switch (this->peek().fKind) {
1742 case Token::SHL: // fall through
1743 case Token::SHR: {
1744 Token t = this->nextToken();
1745 std::unique_ptr<ASTExpression> right = this->additiveExpression();
1746 if (!right) {
1747 return nullptr;
1748 }
1749 result.reset(new ASTBinaryExpression(std::move(result), std::move(t),
1750 std::move(right)));
1751 break;
1752 }
1753 default:
1754 return result;
1755 }
1756 }
1757 }
1758
1759 /* multiplicativeExpression ((PLUS | MINUS) multiplicativeExpression)* */
additiveExpression()1760 std::unique_ptr<ASTExpression> Parser::additiveExpression() {
1761 std::unique_ptr<ASTExpression> result = this->multiplicativeExpression();
1762 if (!result) {
1763 return nullptr;
1764 }
1765 for (;;) {
1766 switch (this->peek().fKind) {
1767 case Token::PLUS: // fall through
1768 case Token::MINUS: {
1769 Token t = this->nextToken();
1770 std::unique_ptr<ASTExpression> right = this->multiplicativeExpression();
1771 if (!right) {
1772 return nullptr;
1773 }
1774 result.reset(new ASTBinaryExpression(std::move(result), std::move(t),
1775 std::move(right)));
1776 break;
1777 }
1778 default:
1779 return result;
1780 }
1781 }
1782 }
1783
1784 /* unaryExpression ((STAR | SLASH | PERCENT) unaryExpression)* */
multiplicativeExpression()1785 std::unique_ptr<ASTExpression> Parser::multiplicativeExpression() {
1786 std::unique_ptr<ASTExpression> result = this->unaryExpression();
1787 if (!result) {
1788 return nullptr;
1789 }
1790 for (;;) {
1791 switch (this->peek().fKind) {
1792 case Token::STAR: // fall through
1793 case Token::SLASH: // fall through
1794 case Token::PERCENT: {
1795 Token t = this->nextToken();
1796 std::unique_ptr<ASTExpression> right = this->unaryExpression();
1797 if (!right) {
1798 return nullptr;
1799 }
1800 result.reset(new ASTBinaryExpression(std::move(result), std::move(t),
1801 std::move(right)));
1802 break;
1803 }
1804 default:
1805 return result;
1806 }
1807 }
1808 }
1809
1810 /* postfixExpression | (PLUS | MINUS | NOT | PLUSPLUS | MINUSMINUS) unaryExpression */
unaryExpression()1811 std::unique_ptr<ASTExpression> Parser::unaryExpression() {
1812 switch (this->peek().fKind) {
1813 case Token::PLUS: // fall through
1814 case Token::MINUS: // fall through
1815 case Token::LOGICALNOT: // fall through
1816 case Token::BITWISENOT: // fall through
1817 case Token::PLUSPLUS: // fall through
1818 case Token::MINUSMINUS: {
1819 Token t = this->nextToken();
1820 std::unique_ptr<ASTExpression> expr = this->unaryExpression();
1821 if (!expr) {
1822 return nullptr;
1823 }
1824 return std::unique_ptr<ASTExpression>(new ASTPrefixExpression(std::move(t),
1825 std::move(expr)));
1826 }
1827 default:
1828 return this->postfixExpression();
1829 }
1830 }
1831
1832 /* term suffix* */
postfixExpression()1833 std::unique_ptr<ASTExpression> Parser::postfixExpression() {
1834 std::unique_ptr<ASTExpression> result = this->term();
1835 if (!result) {
1836 return nullptr;
1837 }
1838 for (;;) {
1839 switch (this->peek().fKind) {
1840 case Token::LBRACKET: // fall through
1841 case Token::DOT: // fall through
1842 case Token::LPAREN: // fall through
1843 case Token::PLUSPLUS: // fall through
1844 case Token::MINUSMINUS: // fall through
1845 case Token::COLONCOLON: {
1846 std::unique_ptr<ASTSuffix> s = this->suffix();
1847 if (!s) {
1848 return nullptr;
1849 }
1850 result.reset(new ASTSuffixExpression(std::move(result), std::move(s)));
1851 break;
1852 }
1853 default:
1854 return result;
1855 }
1856 }
1857 }
1858
1859 /* LBRACKET expression? RBRACKET | DOT IDENTIFIER | LPAREN parameters RPAREN |
1860 PLUSPLUS | MINUSMINUS | COLONCOLON IDENTIFIER */
suffix()1861 std::unique_ptr<ASTSuffix> Parser::suffix() {
1862 Token next = this->nextToken();
1863 switch (next.fKind) {
1864 case Token::LBRACKET: {
1865 if (this->checkNext(Token::RBRACKET)) {
1866 return std::unique_ptr<ASTSuffix>(new ASTIndexSuffix(next.fOffset));
1867 }
1868 std::unique_ptr<ASTExpression> e = this->expression();
1869 if (!e) {
1870 return nullptr;
1871 }
1872 this->expect(Token::RBRACKET, "']' to complete array access expression");
1873 return std::unique_ptr<ASTSuffix>(new ASTIndexSuffix(std::move(e)));
1874 }
1875 case Token::DOT: // fall through
1876 case Token::COLONCOLON: {
1877 int offset = this->peek().fOffset;
1878 StringFragment text;
1879 if (this->identifier(&text)) {
1880 return std::unique_ptr<ASTSuffix>(new ASTFieldSuffix(offset, std::move(text)));
1881 }
1882 return nullptr;
1883 }
1884 case Token::LPAREN: {
1885 std::vector<std::unique_ptr<ASTExpression>> parameters;
1886 if (this->peek().fKind != Token::RPAREN) {
1887 for (;;) {
1888 std::unique_ptr<ASTExpression> expr = this->assignmentExpression();
1889 if (!expr) {
1890 return nullptr;
1891 }
1892 parameters.push_back(std::move(expr));
1893 if (!this->checkNext(Token::COMMA)) {
1894 break;
1895 }
1896 }
1897 }
1898 this->expect(Token::RPAREN, "')' to complete function parameters");
1899 return std::unique_ptr<ASTSuffix>(new ASTCallSuffix(next.fOffset,
1900 std::move(parameters)));
1901 }
1902 case Token::PLUSPLUS:
1903 return std::unique_ptr<ASTSuffix>(new ASTSuffix(next.fOffset,
1904 ASTSuffix::kPostIncrement_Kind));
1905 case Token::MINUSMINUS:
1906 return std::unique_ptr<ASTSuffix>(new ASTSuffix(next.fOffset,
1907 ASTSuffix::kPostDecrement_Kind));
1908 default: {
1909 this->error(next, "expected expression suffix, but found '" + this->text(next) +
1910 "'\n");
1911 return nullptr;
1912 }
1913 }
1914 }
1915
1916 /* IDENTIFIER | intLiteral | floatLiteral | boolLiteral | '(' expression ')' */
term()1917 std::unique_ptr<ASTExpression> Parser::term() {
1918 std::unique_ptr<ASTExpression> result;
1919 Token t = this->peek();
1920 switch (t.fKind) {
1921 case Token::IDENTIFIER: {
1922 StringFragment text;
1923 if (this->identifier(&text)) {
1924 result.reset(new ASTIdentifier(t.fOffset, std::move(text)));
1925 }
1926 break;
1927 }
1928 case Token::INT_LITERAL: {
1929 int64_t i;
1930 if (this->intLiteral(&i)) {
1931 result.reset(new ASTIntLiteral(t.fOffset, i));
1932 }
1933 break;
1934 }
1935 case Token::FLOAT_LITERAL: {
1936 double f;
1937 if (this->floatLiteral(&f)) {
1938 result.reset(new ASTFloatLiteral(t.fOffset, f));
1939 }
1940 break;
1941 }
1942 case Token::TRUE_LITERAL: // fall through
1943 case Token::FALSE_LITERAL: {
1944 bool b;
1945 if (this->boolLiteral(&b)) {
1946 result.reset(new ASTBoolLiteral(t.fOffset, b));
1947 }
1948 break;
1949 }
1950 case Token::LPAREN: {
1951 this->nextToken();
1952 result = this->expression();
1953 if (result) {
1954 this->expect(Token::RPAREN, "')' to complete expression");
1955 }
1956 break;
1957 }
1958 default:
1959 this->nextToken();
1960 this->error(t.fOffset, "expected expression, but found '" + this->text(t) + "'\n");
1961 result = nullptr;
1962 }
1963 return result;
1964 }
1965
1966 /* INT_LITERAL */
intLiteral(int64_t * dest)1967 bool Parser::intLiteral(int64_t* dest) {
1968 Token t;
1969 if (this->expect(Token::INT_LITERAL, "integer literal", &t)) {
1970 *dest = SkSL::stol(this->text(t));
1971 return true;
1972 }
1973 return false;
1974 }
1975
1976 /* FLOAT_LITERAL */
floatLiteral(double * dest)1977 bool Parser::floatLiteral(double* dest) {
1978 Token t;
1979 if (this->expect(Token::FLOAT_LITERAL, "float literal", &t)) {
1980 *dest = SkSL::stod(this->text(t));
1981 return true;
1982 }
1983 return false;
1984 }
1985
1986 /* TRUE_LITERAL | FALSE_LITERAL */
boolLiteral(bool * dest)1987 bool Parser::boolLiteral(bool* dest) {
1988 Token t = this->nextToken();
1989 switch (t.fKind) {
1990 case Token::TRUE_LITERAL:
1991 *dest = true;
1992 return true;
1993 case Token::FALSE_LITERAL:
1994 *dest = false;
1995 return true;
1996 default:
1997 this->error(t, "expected 'true' or 'false', but found '" + this->text(t) + "'\n");
1998 return false;
1999 }
2000 }
2001
2002 /* IDENTIFIER */
identifier(StringFragment * dest)2003 bool Parser::identifier(StringFragment* dest) {
2004 Token t;
2005 if (this->expect(Token::IDENTIFIER, "identifier", &t)) {
2006 *dest = this->text(t);
2007 return true;
2008 }
2009 return false;
2010 }
2011
2012 } // namespace
2013