Grammar

  1. Root <- skip container_doc_comment? ContainerMembers eof
  3. # *** Top level ***
  4. ContainerMembers <- ContainerDeclarations (ContainerField COMMA)* (ContainerField / ContainerDeclarations)
  6. ContainerDeclarations
  7.     <- TestDecl ContainerDeclarations
  8.      / TopLevelComptime ContainerDeclarations
  9.      / doc_comment? KEYWORD_pub? TopLevelDecl ContainerDeclarations
  10.      /
  12. TestDecl <- doc_comment? KEYWORD_test STRINGLITERALSINGLE? Block
  14. TopLevelComptime <- doc_comment? KEYWORD_comptime BlockExpr
  16. TopLevelDecl
  17.     <- (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE? / (KEYWORD_inline / KEYWORD_noinline))? FnProto (SEMICOLON / Block)
  18.      / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? VarDecl
  19.      / KEYWORD_usingnamespace Expr SEMICOLON
  21. FnProto <- KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? LinkSection? CallConv? EXCLAMATIONMARK? TypeExpr
  23. VarDecl <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? LinkSection? (EQUAL Expr)? SEMICOLON
  25. ContainerField <- doc_comment? KEYWORD_comptime? IDENTIFIER (COLON (KEYWORD_anytype / TypeExpr) ByteAlign?)? (EQUAL Expr)?
  27. # *** Block Level ***
  28. Statement
  29.     <- KEYWORD_comptime? VarDecl
  30.      / KEYWORD_comptime BlockExprStatement
  31.      / KEYWORD_nosuspend BlockExprStatement
  32.      / KEYWORD_suspend BlockExprStatement
  33.      / KEYWORD_defer BlockExprStatement
  34.      / KEYWORD_errdefer Payload? BlockExprStatement
  35.      / IfStatement
  36.      / LabeledStatement
  37.      / SwitchExpr
  38.      / AssignExpr SEMICOLON
  40. IfStatement
  41.     <- IfPrefix BlockExpr ( KEYWORD_else Payload? Statement )?
  42.      / IfPrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
  44. LabeledStatement <- BlockLabel? (Block / LoopStatement)
  46. LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement)
  48. ForStatement
  49.     <- ForPrefix BlockExpr ( KEYWORD_else Statement )?
  50.      / ForPrefix AssignExpr ( SEMICOLON / KEYWORD_else Statement )
  52. WhileStatement
  53.     <- WhilePrefix BlockExpr ( KEYWORD_else Payload? Statement )?
  54.      / WhilePrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
  56. BlockExprStatement
  57.     <- BlockExpr
  58.      / AssignExpr SEMICOLON
  60. BlockExpr <- BlockLabel? Block
  62. # *** Expression Level ***
  63. AssignExpr <- Expr (AssignOp Expr)?
  65. Expr <- BoolOrExpr
  67. BoolOrExpr <- BoolAndExpr (KEYWORD_or BoolAndExpr)*
  69. BoolAndExpr <- CompareExpr (KEYWORD_and CompareExpr)*
  71. CompareExpr <- BitwiseExpr (CompareOp BitwiseExpr)?
  73. BitwiseExpr <- BitShiftExpr (BitwiseOp BitShiftExpr)*
  75. BitShiftExpr <- AdditionExpr (BitShiftOp AdditionExpr)*
  77. AdditionExpr <- MultiplyExpr (AdditionOp MultiplyExpr)*
  79. MultiplyExpr <- PrefixExpr (MultiplyOp PrefixExpr)*
  81. PrefixExpr <- PrefixOp* PrimaryExpr
  83. PrimaryExpr
  84.     <- AsmExpr
  85.      / IfExpr
  86.      / KEYWORD_break BreakLabel? Expr?
  87.      / KEYWORD_comptime Expr
  88.      / KEYWORD_nosuspend Expr
  89.      / KEYWORD_continue BreakLabel?
  90.      / KEYWORD_resume Expr
  91.      / KEYWORD_return Expr?
  92.      / BlockLabel? LoopExpr
  93.      / Block
  94.      / CurlySuffixExpr
  96. IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)?
  98. Block <- LBRACE Statement* RBRACE
  100. LoopExpr <- KEYWORD_inline? (ForExpr / WhileExpr)
  102. ForExpr <- ForPrefix Expr (KEYWORD_else Expr)?
  104. WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)?
  106. CurlySuffixExpr <- TypeExpr InitList?
  108. InitList
  109.     <- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
  110.      / LBRACE Expr (COMMA Expr)* COMMA? RBRACE
  111.      / LBRACE RBRACE
  113. TypeExpr <- PrefixTypeOp* ErrorUnionExpr
  115. ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr)?
  117. SuffixExpr
  118.     <- KEYWORD_async PrimaryTypeExpr SuffixOp* FnCallArguments
  119.      / PrimaryTypeExpr (SuffixOp / FnCallArguments)*
  121. PrimaryTypeExpr
  122.     <- BUILTINIDENTIFIER FnCallArguments
  123.      / CHAR_LITERAL
  124.      / ContainerDecl
  125.      / DOT IDENTIFIER
  126.      / DOT InitList
  127.      / ErrorSetDecl
  128.      / FLOAT
  129.      / FnProto
  130.      / GroupedExpr
  131.      / LabeledTypeExpr
  132.      / IDENTIFIER
  133.      / IfTypeExpr
  134.      / INTEGER
  135.      / KEYWORD_comptime TypeExpr
  136.      / KEYWORD_error DOT IDENTIFIER
  137.      / KEYWORD_false
  138.      / KEYWORD_null
  139.      / KEYWORD_anyframe
  140.      / KEYWORD_true
  141.      / KEYWORD_undefined
  142.      / KEYWORD_unreachable
  143.      / STRINGLITERAL
  144.      / SwitchExpr
  146. ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto
  148. ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE
  150. GroupedExpr <- LPAREN Expr RPAREN
  152. IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
  154. LabeledTypeExpr
  155.     <- BlockLabel Block
  156.      / BlockLabel? LoopTypeExpr
  158. LoopTypeExpr <- KEYWORD_inline? (ForTypeExpr / WhileTypeExpr)
  160. ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr)?
  162. WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
  164. SwitchExpr <- KEYWORD_switch LPAREN Expr RPAREN LBRACE SwitchProngList RBRACE
  166. # *** Assembly ***
  167. AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN Expr AsmOutput? RPAREN
  169. AsmOutput <- COLON AsmOutputList AsmInput?
  171. AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
  173. AsmInput <- COLON AsmInputList AsmClobbers?
  175. AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN Expr RPAREN
  177. AsmClobbers <- COLON StringList
  179. # *** Helper grammar ***
  180. BreakLabel <- COLON IDENTIFIER
  182. BlockLabel <- IDENTIFIER COLON
  184. FieldInit <- DOT IDENTIFIER EQUAL Expr
  186. WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN
  188. LinkSection <- KEYWORD_linksection LPAREN Expr RPAREN
  190. # Fn specific
  191. CallConv <- KEYWORD_callconv LPAREN Expr RPAREN
  193. ParamDecl
  194.     <- doc_comment? (KEYWORD_noalias / KEYWORD_comptime)? (IDENTIFIER COLON)? ParamType
  195.      / DOT3
  197. ParamType
  198.     <- KEYWORD_anytype
  199.      / TypeExpr
  201. # Control flow prefixes
  202. IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
  204. WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
  206. ForPrefix <- KEYWORD_for LPAREN Expr RPAREN PtrIndexPayload
  208. # Payloads
  209. Payload <- PIPE IDENTIFIER PIPE
  211. PtrPayload <- PIPE ASTERISK? IDENTIFIER PIPE
  213. PtrIndexPayload <- PIPE ASTERISK? IDENTIFIER (COMMA IDENTIFIER)? PIPE
  216. # Switch specific
  217. SwitchProng <- SwitchCase EQUALRARROW PtrPayload? AssignExpr
  219. SwitchCase
  220.     <- SwitchItem (COMMA SwitchItem)* COMMA?
  221.      / KEYWORD_else
  223. SwitchItem <- Expr (DOT3 Expr)?
  225. # Operators
  226. AssignOp
  227.     <- ASTERISKEQUAL
  228.      / SLASHEQUAL
  229.      / PERCENTEQUAL
  230.      / PLUSEQUAL
  231.      / MINUSEQUAL
  232.      / LARROW2EQUAL
  233.      / RARROW2EQUAL
  234.      / AMPERSANDEQUAL
  235.      / CARETEQUAL
  236.      / PIPEEQUAL
  237.      / ASTERISKPERCENTEQUAL
  238.      / PLUSPERCENTEQUAL
  239.      / MINUSPERCENTEQUAL
  240.      / EQUAL
  242. CompareOp
  243.     <- EQUALEQUAL
  244.      / EXCLAMATIONMARKEQUAL
  245.      / LARROW
  246.      / RARROW
  247.      / LARROWEQUAL
  248.      / RARROWEQUAL
  250. BitwiseOp
  251.     <- AMPERSAND
  252.      / CARET
  253.      / PIPE
  254.      / KEYWORD_orelse
  255.      / KEYWORD_catch Payload?
  257. BitShiftOp
  258.     <- LARROW2
  259.      / RARROW2
  261. AdditionOp
  262.     <- PLUS
  263.      / MINUS
  264.      / PLUS2
  265.      / PLUSPERCENT
  266.      / MINUSPERCENT
  268. MultiplyOp
  269.     <- PIPE2
  270.      / ASTERISK
  271.      / SLASH
  272.      / PERCENT
  273.      / ASTERISK2
  274.      / ASTERISKPERCENT
  276. PrefixOp
  277.     <- EXCLAMATIONMARK
  278.      / MINUS
  279.      / TILDE
  280.      / MINUSPERCENT
  281.      / AMPERSAND
  282.      / KEYWORD_try
  283.      / KEYWORD_await
  285. PrefixTypeOp
  286.     <- QUESTIONMARK
  287.      / KEYWORD_anyframe MINUSRARROW
  288.      / SliceTypeStart (ByteAlign / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
  289.      / PtrTypeStart (KEYWORD_align LPAREN Expr (COLON INTEGER COLON INTEGER)? RPAREN / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
  290.      / ArrayTypeStart
  292. SuffixOp
  293.     <- LBRACKET Expr (DOT2 (Expr? (COLON Expr)?)?)? RBRACKET
  294.      / DOT IDENTIFIER
  295.      / DOTASTERISK
  296.      / DOTQUESTIONMARK
  298. FnCallArguments <- LPAREN ExprList RPAREN
  300. # Ptr specific
  301. SliceTypeStart <- LBRACKET (COLON Expr)? RBRACKET
  303. PtrTypeStart
  304.     <- ASTERISK
  305.      / ASTERISK2
  306.      / LBRACKET ASTERISK (LETTERC / COLON Expr)? RBRACKET
  308. ArrayTypeStart <- LBRACKET Expr (COLON Expr)? RBRACKET
  310. # ContainerDecl specific
  311. ContainerDeclAuto <- ContainerDeclType LBRACE container_doc_comment? ContainerMembers RBRACE
  313. ContainerDeclType
  314.     <- KEYWORD_struct
  315.      / KEYWORD_opaque
  316.      / KEYWORD_enum (LPAREN Expr RPAREN)?
  317.      / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
  319. # Alignment
  320. ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
  322. # Lists
  323. IdentifierList <- (doc_comment? IDENTIFIER COMMA)* (doc_comment? IDENTIFIER)?
  325. SwitchProngList <- (SwitchProng COMMA)* SwitchProng?
  327. AsmOutputList <- (AsmOutputItem COMMA)* AsmOutputItem?
  329. AsmInputList <- (AsmInputItem COMMA)* AsmInputItem?
  331. StringList <- (STRINGLITERAL COMMA)* STRINGLITERAL?
  333. ParamDeclList <- (ParamDecl COMMA)* ParamDecl?
  335. ExprList <- (Expr COMMA)* Expr?
  337. # *** Tokens ***
  338. eof <- !.
  339. bin <- [01]
  340. bin_ <- '_'? bin
  341. oct <- [0-7]
  342. oct_ <- '_'? oct
  343. hex <- [0-9a-fA-F]
  344. hex_ <- '_'? hex
  345. dec <- [0-9]
  346. dec_ <- '_'? dec
  348. bin_int <- bin bin_*
  349. oct_int <- oct oct_*
  350. dec_int <- dec dec_*
  351. hex_int <- hex hex_*
  353. ox80_oxBF <- [\200-\277]
  354. oxF4 <- '\364'
  355. ox80_ox8F <- [\200-\217]
  356. oxF1_oxF3 <- [\361-\363]
  357. oxF0 <- '\360'
  358. ox90_0xBF <- [\220-\277]
  359. oxEE_oxEF <- [\356-\357]
  360. oxED <- '\355'
  361. ox80_ox9F <- [\200-\237]
  362. oxE1_oxEC <- [\341-\354]
  363. oxE0 <- '\340'
  364. oxA0_oxBF <- [\240-\277]
  365. oxC2_oxDF <- [\302-\337]
  367. # From https://lemire.me/blog/2018/05/09/how-quickly-can-you-check-that-a-string-is-valid-unicode-utf-8/
  368. # First Byte      Second Byte     Third Byte      Fourth Byte
  369. # [0x00,0x7F]
  370. # [0xC2,0xDF]     [0x80,0xBF]
  371. #    0xE0         [0xA0,0xBF]     [0x80,0xBF]
  372. # [0xE1,0xEC]     [0x80,0xBF]     [0x80,0xBF]
  373. #    0xED         [0x80,0x9F]     [0x80,0xBF]
  374. # [0xEE,0xEF]     [0x80,0xBF]     [0x80,0xBF]
  375. #    0xF0         [0x90,0xBF]     [0x80,0xBF]     [0x80,0xBF]
  376. # [0xF1,0xF3]     [0x80,0xBF]     [0x80,0xBF]     [0x80,0xBF]
  377. #    0xF4         [0x80,0x8F]     [0x80,0xBF]     [0x80,0xBF]
  379. mb_utf8_literal <-
  380.        oxF4      ox80_ox8F ox80_oxBF ox80_oxBF
  381.      / oxF1_oxF3 ox80_oxBF ox80_oxBF ox80_oxBF
  382.      / oxF0      ox90_0xBF ox80_oxBF ox80_oxBF
  383.      / oxEE_oxEF ox80_oxBF ox80_oxBF
  384.      / oxED      ox80_ox9F ox80_oxBF
  385.      / oxE1_oxEC ox80_oxBF ox80_oxBF
  386.      / oxE0      oxA0_oxBF ox80_oxBF
  387.      / oxC2_oxDF ox80_oxBF
  389. ascii_char_not_nl_slash_squote <- [\000-\011\013-\046-\050-\133\135-\177]
  391. char_escape
  392.     <- "\\x" hex hex
  393.      / "\\u{" hex+ "}"
  394.      / "\\" [nr\\t'"]
  395. char_char
  396.     <- mb_utf8_literal
  397.      / char_escape
  398.      / ascii_char_not_nl_slash_squote
  400. string_char
  401.     <- char_escape
  402.      / [^\\"\n]
  404. container_doc_comment <- ('//!' [^\n]* [ \n]*)+
  405. doc_comment <- ('///' [^\n]* [ \n]*)+
  406. line_comment <- '//' ![!/][^\n]* / '////' [^\n]*
  407. line_string <- ("\\\\" [^\n]* [ \n]*)+
  408. skip <- ([ \n] / line_comment)*
  410. CHAR_LITERAL <- "'" char_char "'" skip
  411. FLOAT
  412.     <- "0x" hex_int "." hex_int ([pP] [-+]? dec_int)? skip
  413.      /      dec_int "." dec_int ([eE] [-+]? dec_int)? skip
  414.      / "0x" hex_int "."? [pP] [-+]? dec_int skip
  415.      /      dec_int "."? [eE] [-+]? dec_int skip
  416. INTEGER
  417.     <- "0b" bin_int skip
  418.      / "0o" oct_int skip
  419.      / "0x" hex_int skip
  420.      /      dec_int   skip
  421. STRINGLITERALSINGLE <- "\"" string_char* "\"" skip
  422. STRINGLITERAL
  423.     <- STRINGLITERALSINGLE
  424.      / (line_string                 skip)+
  425. IDENTIFIER
  426.     <- !keyword [A-Za-z_] [A-Za-z0-9_]* skip
  427.      / "@\"" string_char* "\""                            skip
  428. BUILTINIDENTIFIER <- "@"[A-Za-z_][A-Za-z0-9_]* skip
  431. AMPERSAND            <- '&'      ![=]      skip
  432. AMPERSANDEQUAL       <- '&='               skip
  433. ASTERISK             <- '*'      ![*%=]    skip
  434. ASTERISK2            <- '**'               skip
  435. ASTERISKEQUAL        <- '*='               skip
  436. ASTERISKPERCENT      <- '*%'     ![=]      skip
  437. ASTERISKPERCENTEQUAL <- '*%='              skip
  438. CARET                <- '^'      ![=]      skip
  439. CARETEQUAL           <- '^='               skip
  440. COLON                <- ':'                skip
  441. COMMA                <- ','                skip
  442. DOT                  <- '.'      ![*.?]    skip
  443. DOT2                 <- '..'     ![.]      skip
  444. DOT3                 <- '...'              skip
  445. DOTASTERISK          <- '.*'               skip
  446. DOTQUESTIONMARK      <- '.?'               skip
  447. EQUAL                <- '='      ![>=]     skip
  448. EQUALEQUAL           <- '=='               skip
  449. EQUALRARROW          <- '=>'               skip
  450. EXCLAMATIONMARK      <- '!'      ![=]      skip
  451. EXCLAMATIONMARKEQUAL <- '!='               skip
  452. LARROW               <- '<'      ![<=]     skip
  453. LARROW2              <- '<<'     ![=]      skip
  454. LARROW2EQUAL         <- '<<='              skip
  455. LARROWEQUAL          <- '<='               skip
  456. LBRACE               <- '{'                skip
  457. LBRACKET             <- '['                skip
  458. LPAREN               <- '('                skip
  459. MINUS                <- '-'      ![%=>]    skip
  460. MINUSEQUAL           <- '-='               skip
  461. MINUSPERCENT         <- '-%'     ![=]      skip
  462. MINUSPERCENTEQUAL    <- '-%='              skip
  463. MINUSRARROW          <- '->'               skip
  464. PERCENT              <- '%'      ![=]      skip
  465. PERCENTEQUAL         <- '%='               skip
  466. PIPE                 <- '|'      ![|=]     skip
  467. PIPE2                <- '||'               skip
  468. PIPEEQUAL            <- '|='               skip
  469. PLUS                 <- '+'      ![%+=]    skip
  470. PLUS2                <- '++'               skip
  471. PLUSEQUAL            <- '+='               skip
  472. PLUSPERCENT          <- '+%'     ![=]      skip
  473. PLUSPERCENTEQUAL     <- '+%='              skip
  474. LETTERC              <- 'c'                skip
  475. QUESTIONMARK         <- '?'                skip
  476. RARROW               <- '>'      ![>=]     skip
  477. RARROW2              <- '>>'     ![=]      skip
  478. RARROW2EQUAL         <- '>>='              skip
  479. RARROWEQUAL          <- '>='               skip
  480. RBRACE               <- '}'                skip
  481. RBRACKET             <- ']'                skip
  482. RPAREN               <- ')'                skip
  483. SEMICOLON            <- ';'                skip
  484. SLASH                <- '/'      ![=]      skip
  485. SLASHEQUAL           <- '/='               skip
  486. TILDE                <- '~'                skip
  488. end_of_word <- ![a-zA-Z0-9_] skip
  489. KEYWORD_align       <- 'align'       end_of_word
  490. KEYWORD_allowzero   <- 'allowzero'   end_of_word
  491. KEYWORD_and         <- 'and'         end_of_word
  492. KEYWORD_anyframe    <- 'anyframe'    end_of_word
  493. KEYWORD_anytype     <- 'anytype'     end_of_word
  494. KEYWORD_asm         <- 'asm'         end_of_word
  495. KEYWORD_async       <- 'async'       end_of_word
  496. KEYWORD_await       <- 'await'       end_of_word
  497. KEYWORD_break       <- 'break'       end_of_word
  498. KEYWORD_callconv    <- 'callconv'    end_of_word
  499. KEYWORD_catch       <- 'catch'       end_of_word
  500. KEYWORD_comptime    <- 'comptime'    end_of_word
  501. KEYWORD_const       <- 'const'       end_of_word
  502. KEYWORD_continue    <- 'continue'    end_of_word
  503. KEYWORD_defer       <- 'defer'       end_of_word
  504. KEYWORD_else        <- 'else'        end_of_word
  505. KEYWORD_enum        <- 'enum'        end_of_word
  506. KEYWORD_errdefer    <- 'errdefer'    end_of_word
  507. KEYWORD_error       <- 'error'       end_of_word
  508. KEYWORD_export      <- 'export'      end_of_word
  509. KEYWORD_extern      <- 'extern'      end_of_word
  510. KEYWORD_false       <- 'false'       end_of_word
  511. KEYWORD_fn          <- 'fn'          end_of_word
  512. KEYWORD_for         <- 'for'         end_of_word
  513. KEYWORD_if          <- 'if'          end_of_word
  514. KEYWORD_inline      <- 'inline'      end_of_word
  515. KEYWORD_noalias     <- 'noalias'     end_of_word
  516. KEYWORD_nosuspend   <- 'nosuspend'   end_of_word
  517. KEYWORD_noinline    <- 'noinline'    end_of_word
  518. KEYWORD_null        <- 'null'        end_of_word
  519. KEYWORD_opaque      <- 'opaque'      end_of_word
  520. KEYWORD_or          <- 'or'          end_of_word
  521. KEYWORD_orelse      <- 'orelse'      end_of_word
  522. KEYWORD_packed      <- 'packed'      end_of_word
  523. KEYWORD_pub         <- 'pub'         end_of_word
  524. KEYWORD_resume      <- 'resume'      end_of_word
  525. KEYWORD_return      <- 'return'      end_of_word
  526. KEYWORD_linksection <- 'linksection' end_of_word
  527. KEYWORD_struct      <- 'struct'      end_of_word
  528. KEYWORD_suspend     <- 'suspend'     end_of_word
  529. KEYWORD_switch      <- 'switch'      end_of_word
  530. KEYWORD_test        <- 'test'        end_of_word
  531. KEYWORD_threadlocal <- 'threadlocal' end_of_word
  532. KEYWORD_true        <- 'true'        end_of_word
  533. KEYWORD_try         <- 'try'         end_of_word
  534. KEYWORD_undefined   <- 'undefined'   end_of_word
  535. KEYWORD_union       <- 'union'       end_of_word
  536. KEYWORD_unreachable <- 'unreachable' end_of_word
  537. KEYWORD_usingnamespace <- 'usingnamespace' end_of_word
  538. KEYWORD_var         <- 'var'         end_of_word
  539. KEYWORD_volatile    <- 'volatile'    end_of_word
  540. KEYWORD_while       <- 'while'       end_of_word
  542. keyword <- KEYWORD_align / KEYWORD_allowzero / KEYWORD_and / KEYWORD_anyframe
  543.          / KEYWORD_anytype / KEYWORD_asm / KEYWORD_async / KEYWORD_await
  544.          / KEYWORD_break / KEYWORD_callconv / KEYWORD_catch / KEYWORD_comptime
  545.          / KEYWORD_const / KEYWORD_continue / KEYWORD_defer / KEYWORD_else
  546.          / KEYWORD_enum / KEYWORD_errdefer / KEYWORD_error / KEYWORD_export
  547.          / KEYWORD_extern / KEYWORD_false / KEYWORD_fn / KEYWORD_for / KEYWORD_if
  548.          / KEYWORD_inline / KEYWORD_noalias / KEYWORD_nosuspend / KEYWORD_noinline
  549.          / KEYWORD_null / KEYWORD_opaque / KEYWORD_or / KEYWORD_orelse / KEYWORD_packed
  550.          / KEYWORD_pub / KEYWORD_resume / KEYWORD_return / KEYWORD_linksection
  551.          / KEYWORD_struct / KEYWORD_suspend / KEYWORD_switch
  552.          / KEYWORD_test / KEYWORD_threadlocal / KEYWORD_true / KEYWORD_try
  553.          / KEYWORD_undefined / KEYWORD_union / KEYWORD_unreachable
  554.          / KEYWORD_usingnamespace / KEYWORD_var / KEYWORD_volatile / KEYWORD_while