SkSLParser.cpp 71 KB

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