Grammar

  1. Root <- skip ContainerMembers eof
  3. # *** Top level ***
  4. ContainerMembers
  5.     <- TestDecl ContainerMembers
  6.      / TopLevelComptime ContainerMembers
  7.      / KEYWORD_pub? TopLevelDecl ContainerMembers
  8.      / KEYWORD_pub? ContainerField COMMA ContainerMembers
  9.      / KEYWORD_pub? ContainerField
  10.      /
  12. TestDecl <- KEYWORD_test STRINGLITERAL Block
  14. TopLevelComptime <- KEYWORD_comptime BlockExpr
  16. TopLevelDecl
  17.     <- (KEYWORD_export / KEYWORD_extern STRINGLITERAL? / KEYWORD_inline)? FnProto (SEMICOLON / Block)
  18.      / (KEYWORD_export / KEYWORD_extern STRINGLITERAL?)? KEYWORD_threadlocal? VarDecl
  19.      / KEYWORD_use Expr SEMICOLON
  21. FnProto <- FnCC? KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? LinkSection? EXCLAMATIONMARK? (KEYWORD_var / TypeExpr)
  23. VarDecl <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? LinkSection? (EQUAL Expr)? SEMICOLON
  25. ContainerField <- IDENTIFIER (COLON TypeExpr)? (EQUAL Expr)?
  27. # *** Block Level ***
  28. Statement
  29.     <- KEYWORD_comptime? VarDecl
  30.      / KEYWORD_comptime BlockExprStatement
  31.      / KEYWORD_suspend (SEMICOLON / BlockExprStatement)
  32.      / KEYWORD_defer BlockExprStatement
  33.      / KEYWORD_errdefer BlockExprStatement
  34.      / IfStatement
  35.      / LabeledStatement
  36.      / SwitchExpr
  37.      / AssignExpr SEMICOLON
  39. IfStatement
  40.     <- IfPrefix BlockExpr ( KEYWORD_else Payload? Statement )?
  41.      / IfPrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
  43. LabeledStatement <- BlockLabel? (Block / LoopStatement)
  45. LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement)
  47. ForStatement
  48.     <- ForPrefix BlockExpr ( KEYWORD_else Statement )?
  49.      / ForPrefix AssignExpr ( SEMICOLON / KEYWORD_else Statement )
  51. WhileStatement
  52.     <- WhilePrefix BlockExpr ( KEYWORD_else Payload? Statement )?
  53.      / WhilePrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
  55. BlockExprStatement
  56.     <- BlockExpr
  57.      / AssignExpr SEMICOLON
  59. BlockExpr <- BlockLabel? Block
  61. # *** Expression Level ***
  62. AssignExpr <- Expr (AssignOp Expr)?
  64. Expr <- KEYWORD_try* BoolOrExpr
  66. BoolOrExpr <- BoolAndExpr (KEYWORD_or BoolAndExpr)*
  68. BoolAndExpr <- CompareExpr (KEYWORD_and CompareExpr)*
  70. CompareExpr <- BitwiseExpr (CompareOp BitwiseExpr)?
  72. BitwiseExpr <- BitShiftExpr (BitwiseOp BitShiftExpr)*
  74. BitShiftExpr <- AdditionExpr (BitShiftOp AdditionExpr)*
  76. AdditionExpr <- MultiplyExpr (AdditionOp MultiplyExpr)*
  78. MultiplyExpr <- PrefixExpr (MultiplyOp PrefixExpr)*
  80. PrefixExpr <- PrefixOp* PrimaryExpr
  82. PrimaryExpr
  83.     <- AsmExpr
  84.      / IfExpr
  85.      / KEYWORD_break BreakLabel? Expr?
  86.      / KEYWORD_cancel Expr
  87.      / KEYWORD_comptime Expr
  88.      / KEYWORD_continue BreakLabel?
  89.      / KEYWORD_resume Expr
  90.      / KEYWORD_return Expr?
  91.      / BlockLabel? LoopExpr
  92.      / Block
  93.      / CurlySuffixExpr
  95. IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)?
  97. LabeledExpr <- BlockLabel? (Block / LoopExpr)
  99. Block <- LBRACE Statement* RBRACE
  101. LoopExpr <- KEYWORD_inline? (ForExpr / WhileExpr)
  103. ForExpr <- ForPrefix Expr (KEYWORD_else Expr)?
  105. WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)?
  107. InitList
  108.     <- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
  109.      / LBRACE Expr (COMMA Expr)* COMMA? RBRACE
  110.      / LBRACE RBRACE
  112. TypeExpr <- PrefixTypeOp* ErrorUnionExpr
  114. ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr)?
  116. SuffixExpr
  117.     <- AsyncPrefix PrimaryTypeExpr SuffixOp* FnCallArguments
  118.      / PrimaryTypeExpr (SuffixOp / FnCallArguments)*
  120. PrimaryTypeExpr
  121.     <- BUILTINIDENTIFIER FnCallArguments
  122.      / CHAR_LITERAL
  123.      / ContainerDecl
  124.      / ErrorSetDecl
  125.      / FLOAT
  126.      / FnProto
  127.      / GroupedExpr
  128.      / LabeledTypeExpr
  129.      / IDENTIFIER
  130.      / IfTypeExpr
  131.      / INTEGER
  132.      / KEYWORD_anyerror
  133.      / KEYWORD_comptime TypeExpr
  134.      / KEYWORD_error DOT IDENTIFIER
  135.      / KEYWORD_false
  136.      / KEYWORD_null
  137.      / KEYWORD_promise
  138.      / KEYWORD_true
  139.      / KEYWORD_undefined
  140.      / KEYWORD_unreachable
  141.      / STRINGLITERAL
  142.      / SwitchExpr
  144. ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto
  146. ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE
  148. GroupedExpr <- LPAREN Expr RPAREN
  150. IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
  152. LabeledTypeExpr
  153.     <- BlockLabel Block
  154.      / BlockLabel? LoopTypeExpr
  156. LoopTypeExpr <- KEYWORD_inline? (ForTypeExpr / WhileTypeExpr)
  158. ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr)?
  160. WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
  162. SwitchExpr <- KEYWORD_switch LPAREN Expr RPAREN LBRACE SwitchProngList RBRACE
  164. # *** Assembly ***
  165. AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN STRINGLITERAL AsmOutput? RPAREN
  167. AsmOutput <- COLON AsmOutputList AsmInput?
  169. AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
  171. AsmInput <- COLON AsmInputList AsmClobbers?
  173. AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN Expr RPAREN
  175. AsmClobbers <- COLON StringList
  177. # *** Helper grammar ***
  178. BreakLabel <- COLON IDENTIFIER
  180. BlockLabel <- IDENTIFIER COLON
  182. FieldInit <- DOT IDENTIFIER EQUAL Expr
  184. WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN
  186. LinkSection <- KEYWORD_linksection LPAREN Expr RPAREN
  188. # Fn specific
  189. FnCC
  190.     <- KEYWORD_nakedcc
  191.      / KEYWORD_stdcallcc
  192.      / KEYWORD_extern
  193.      / KEYWORD_async (LARROW TypeExpr RARROW)?
  195. ParamDecl <- (KEYWORD_noalias / KEYWORD_comptime)? (IDENTIFIER COLON)? ParamType
  197. ParamType
  198.     <- KEYWORD_var
  199.      / DOT3
  200.      / TypeExpr
  202. # Control flow prefixes
  203. IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
  205. WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
  207. ForPrefix <- KEYWORD_for LPAREN Expr RPAREN PtrIndexPayload
  209. # Payloads
  210. Payload <- PIPE IDENTIFIER PIPE
  212. PtrPayload <- PIPE ASTERISK? IDENTIFIER PIPE
  214. PtrIndexPayload <- PIPE ASTERISK? IDENTIFIER (COMMA IDENTIFIER)? PIPE
  217. # Switch specific
  218. SwitchProng <- SwitchCase EQUALRARROW PtrPayload? AssignExpr
  220. SwitchCase
  221.     <- SwitchItem (COMMA SwitchItem)* COMMA?
  222.      / KEYWORD_else
  224. SwitchItem <- Expr (DOT3 Expr)?
  226. # Operators
  227. AssignOp
  228.     <- ASTERISKEQUAL
  229.      / SLASHEQUAL
  230.      / PERCENTEQUAL
  231.      / PLUSEQUAL
  232.      / MINUSEQUAL
  233.      / LARROW2EQUAL
  234.      / RARROW2EQUAL
  235.      / AMPERSANDEQUAL
  236.      / CARETEQUAL
  237.      / PIPEEQUAL
  238.      / ASTERISKPERCENTEQUAL
  239.      / PLUSPERCENTEQUAL
  240.      / MINUSPERCENTEQUAL
  241.      / EQUAL
  243. CompareOp
  244.     <- EQUALEQUAL
  245.      / EXCLAMATIONMARKEQUAL
  246.      / LARROW
  247.      / RARROW
  248.      / LARROWEQUAL
  249.      / RARROWEQUAL
  251. BitwiseOp
  252.     <- AMPERSAND
  253.      / CARET
  254.      / PIPE
  255.      / KEYWORD_orelse
  256.      / KEYWORD_catch Payload?
  258. BitShiftOp
  259.     <- LARROW2
  260.      / RARROW2
  262. AdditionOp
  263.     <- PLUS
  264.      / MINUS
  265.      / PLUS2
  266.      / PLUSPERCENT
  267.      / MINUSPERCENT
  269. MultiplyOp
  270.     <- PIPE2
  271.      / ASTERISK
  272.      / SLASH
  273.      / PERCENT
  274.      / ASTERISK2
  275.      / ASTERISKPERCENT
  277. PrefixOp
  278.     <- EXCLAMATIONMARK
  279.      / MINUS
  280.      / TILDE
  281.      / MINUSPERCENT
  282.      / AMPERSAND
  283.      / KEYWORD_try
  284.      / KEYWORD_await
  286. PrefixTypeOp
  287.     <- QUESTIONMARK
  288.      / KEYWORD_promise MINUSRARROW
  289.      / ArrayTypeStart (ByteAlign / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
  290.      / PtrTypeStart (KEYWORD_align LPAREN Expr (COLON INTEGER COLON INTEGER)? RPAREN / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
  292. SuffixOp
  293.     <- LBRACKET Expr (DOT2 Expr?)? RBRACKET
  294.      / DOT IDENTIFIER
  295.      / DOTASTERISK
  296.      / DOTQUESTIONMARK
  298. AsyncPrefix <- KEYWORD_async (LARROW PrefixExpr RARROW)?
  300. FnCallArguments <- LPAREN ExprList RPAREN
  302. # Ptr specific
  303. ArrayTypeStart <- LBRACKET Expr? RBRACKET
  305. PtrTypeStart
  306.     <- ASTERISK
  307.      / ASTERISK2
  308.      / PTRUNKNOWN
  309.      / PTRC
  311. # ContainerDecl specific
  312. ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE
  314. ContainerDeclType
  315.     <- (KEYWORD_struct / KEYWORD_enum) (LPAREN Expr RPAREN)?
  316.      / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
  318. # Alignment
  319. ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
  321. # Lists
  322. IdentifierList <- (IDENTIFIER COMMA)* IDENTIFIER?
  324. SwitchProngList <- (SwitchProng COMMA)* SwitchProng?
  326. AsmOutputList <- (AsmOutputItem COMMA)* AsmOutputItem?
  328. AsmInputList <- (AsmInputItem COMMA)* AsmInputItem?
  330. StringList <- (STRINGLITERAL COMMA)* STRINGLITERAL?
  332. ParamDeclList <- (ParamDecl COMMA)* ParamDecl?
  334. ExprList <- (Expr COMMA)* Expr?
  336. # *** Tokens ***
  337. eof <- !.
  338. hex <- [0-9a-fA-F]
  339. char_escape
  340.     <- "\\x" hex hex
  341.      / "\\u" hex hex hex hex
  342.      / "\\U" hex hex hex hex hex hex
  343.      / "\\" [nr\\t'"]
  344. char_char
  345.     <- char_escape
  346.      / [^\\'\n]
  347. string_char
  348.     <- char_escape
  349.      / [^\\"\n]
  351. line_comment <- '//'[^\n]*
  352. line_string <- ("\\\\" [^\n]* [ \n]*)+
  353. line_cstring <- ("c\\\\" [^\n]* [ \n]*)+
  354. skip <- ([ \n] / line_comment)*
  356. CHAR_LITERAL <- "'" char_char "'" skip
  357. FLOAT
  358.     <- "0x" hex+   "." hex+   ([pP] [-+]? hex+)?   skip
  359.      /      [0-9]+ "." [0-9]+ ([eE] [-+]? [0-9]+)? skip
  360.      / "0x" hex+   "."? [pP] [-+]? hex+   skip
  361.      /      [0-9]+ "."? [eE] [-+]? [0-9]+ skip
  362. INTEGER
  363.     <- "0b" [01]+  skip
  364.      / "0o" [0-7]+ skip
  365.      / "0x" hex+   skip
  366.      /      [0-9]+ skip
  367. STRINGLITERAL
  368.     <- "c"? "\"" string_char* "\"" skip
  369.      / line_string                 skip
  370.      / line_cstring                skip
  371. IDENTIFIER
  372.     <- !keyword ("c" !["\\] / [A-Zabd-z_]) [A-Za-z0-9_]* skip
  373.      / "@\"" string_char* "\""                            skip
  374. BUILTINIDENTIFIER <- "@"[A-Za-z_][A-Za-z0-9_]* skip
  377. AMPERSAND            <- '&'      ![=]      skip
  378. AMPERSANDEQUAL       <- '&='               skip
  379. ASTERISK             <- '*'      ![*%=]    skip
  380. ASTERISK2            <- '**'               skip
  381. ASTERISKEQUAL        <- '*='               skip
  382. ASTERISKPERCENT      <- '*%'     ![=]      skip
  383. ASTERISKPERCENTEQUAL <- '*%='              skip
  384. CARET                <- '^'      ![=]      skip
  385. CARETEQUAL           <- '^='               skip
  386. COLON                <- ':'                skip
  387. COMMA                <- ','                skip
  388. DOT                  <- '.'      ![*.?]    skip
  389. DOT2                 <- '..'     ![.]      skip
  390. DOT3                 <- '...'              skip
  391. DOTASTERISK          <- '.*'               skip
  392. DOTQUESTIONMARK      <- '.?'               skip
  393. EQUAL                <- '='      ![>=]     skip
  394. EQUALEQUAL           <- '=='               skip
  395. EQUALRARROW          <- '=>'               skip
  396. EXCLAMATIONMARK      <- '!'      ![=]      skip
  397. EXCLAMATIONMARKEQUAL <- '!='               skip
  398. LARROW               <- '<'      ![<=]     skip
  399. LARROW2              <- '<<'     ![=]      skip
  400. LARROW2EQUAL         <- '<<='              skip
  401. LARROWEQUAL          <- '<='               skip
  402. LBRACE               <- '{'                skip
  403. LBRACKET             <- '['      ![*]      skip
  404. LPAREN               <- '('                skip
  405. MINUS                <- '-'      ![%=>]    skip
  406. MINUSEQUAL           <- '-='               skip
  407. MINUSPERCENT         <- '-%'     ![=]      skip
  408. MINUSPERCENTEQUAL    <- '-%='              skip
  409. MINUSRARROW          <- '->'               skip
  410. PERCENT              <- '%'      ![=]      skip
  411. PERCENTEQUAL         <- '%='               skip
  412. PIPE                 <- '|'      ![|=]     skip
  413. PIPE2                <- '||'               skip
  414. PIPEEQUAL            <- '|='               skip
  415. PLUS                 <- '+'      ![%+=]    skip
  416. PLUS2                <- '++'               skip
  417. PLUSEQUAL            <- '+='               skip
  418. PLUSPERCENT          <- '+%'     ![=]      skip
  419. PLUSPERCENTEQUAL     <- '+%='              skip
  420. PTRC                 <- '[*c]'             skip
  421. PTRUNKNOWN           <- '[*]'              skip
  422. QUESTIONMARK         <- '?'                skip
  423. RARROW               <- '>'      ![>=]     skip
  424. RARROW2              <- '>>'     ![=]      skip
  425. RARROW2EQUAL         <- '>>='              skip
  426. RARROWEQUAL          <- '>='               skip
  427. RBRACE               <- '}'                skip
  428. RBRACKET             <- ']'                skip
  429. RPAREN               <- ')'                skip
  430. SEMICOLON            <- ';'                skip
  431. SLASH                <- '/'      ![=]      skip
  432. SLASHEQUAL           <- '/='               skip
  433. TILDE                <- '~'                skip
  435. end_of_word <- ![a-zA-Z0-9_] skip
  436. KEYWORD_align       <- 'align'       end_of_word
  437. KEYWORD_allowzero   <- 'allowzero'   end_of_word
  438. KEYWORD_and         <- 'and'         end_of_word
  439. KEYWORD_anyerror    <- 'anyerror'    end_of_word
  440. KEYWORD_asm         <- 'asm'         end_of_word
  441. KEYWORD_async       <- 'async'       end_of_word
  442. KEYWORD_await       <- 'await'       end_of_word
  443. KEYWORD_break       <- 'break'       end_of_word
  444. KEYWORD_cancel      <- 'cancel'      end_of_word
  445. KEYWORD_catch       <- 'catch'       end_of_word
  446. KEYWORD_comptime    <- 'comptime'    end_of_word
  447. KEYWORD_const       <- 'const'       end_of_word
  448. KEYWORD_continue    <- 'continue'    end_of_word
  449. KEYWORD_defer       <- 'defer'       end_of_word
  450. KEYWORD_else        <- 'else'        end_of_word
  451. KEYWORD_enum        <- 'enum'        end_of_word
  452. KEYWORD_errdefer    <- 'errdefer'    end_of_word
  453. KEYWORD_error       <- 'error'       end_of_word
  454. KEYWORD_export      <- 'export'      end_of_word
  455. KEYWORD_extern      <- 'extern'      end_of_word
  456. KEYWORD_false       <- 'false'       end_of_word
  457. KEYWORD_fn          <- 'fn'          end_of_word
  458. KEYWORD_for         <- 'for'         end_of_word
  459. KEYWORD_if          <- 'if'          end_of_word
  460. KEYWORD_inline      <- 'inline'      end_of_word
  461. KEYWORD_nakedcc     <- 'nakedcc'     end_of_word
  462. KEYWORD_noalias     <- 'noalias'     end_of_word
  463. KEYWORD_null        <- 'null'        end_of_word
  464. KEYWORD_or          <- 'or'          end_of_word
  465. KEYWORD_orelse      <- 'orelse'      end_of_word
  466. KEYWORD_packed      <- 'packed'      end_of_word
  467. KEYWORD_promise     <- 'promise'     end_of_word
  468. KEYWORD_pub         <- 'pub'         end_of_word
  469. KEYWORD_resume      <- 'resume'      end_of_word
  470. KEYWORD_return      <- 'return'      end_of_word
  471. KEYWORD_linksection <- 'linksection' end_of_word
  472. KEYWORD_stdcallcc   <- 'stdcallcc'   end_of_word
  473. KEYWORD_struct      <- 'struct'      end_of_word
  474. KEYWORD_suspend     <- 'suspend'     end_of_word
  475. KEYWORD_switch      <- 'switch'      end_of_word
  476. KEYWORD_test        <- 'test'        end_of_word
  477. KEYWORD_threadlocal <- 'threadlocal' end_of_word
  478. KEYWORD_true        <- 'true'        end_of_word
  479. KEYWORD_try         <- 'try'         end_of_word
  480. KEYWORD_undefined   <- 'undefined'   end_of_word
  481. KEYWORD_union       <- 'union'       end_of_word
  482. KEYWORD_unreachable <- 'unreachable' end_of_word
  483. KEYWORD_use         <- 'use'         end_of_word
  484. KEYWORD_var         <- 'var'         end_of_word
  485. KEYWORD_volatile    <- 'volatile'    end_of_word
  486. KEYWORD_while       <- 'while'       end_of_word
  488. keyword <- KEYWORD_align / KEYWORD_and / KEYWORD_allowzero / KEYWORD_anyerror / KEYWORD_asm
  489.          / KEYWORD_async / KEYWORD_await / KEYWORD_break / KEYWORD_cancel
  490.          / KEYWORD_catch / KEYWORD_comptime / KEYWORD_const / KEYWORD_continue
  491.          / KEYWORD_defer / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer
  492.          / KEYWORD_error / KEYWORD_export / KEYWORD_extern / KEYWORD_false
  493.          / KEYWORD_fn / KEYWORD_for / KEYWORD_if / KEYWORD_inline
  494.          / KEYWORD_nakedcc / KEYWORD_noalias / KEYWORD_null / KEYWORD_or
  495.          / KEYWORD_orelse / KEYWORD_packed / KEYWORD_promise / KEYWORD_pub
  496.          / KEYWORD_resume / KEYWORD_return / KEYWORD_linksection
  497.          / KEYWORD_stdcallcc / KEYWORD_struct / KEYWORD_suspend
  498.          / KEYWORD_switch / KEYWORD_test / KEYWORD_threadlocal / KEYWORD_true / KEYWORD_try
  499.          / KEYWORD_undefined / KEYWORD_union / KEYWORD_unreachable
  500.          / KEYWORD_use / KEYWORD_var / KEYWORD_volatile / KEYWORD_while