| ... | ... | @@ -7713,167 +7713,508 @@ fn readU32Be() u32 {} |
| 7713 | 7713 | <p>For some discussion on the rationale behind these design decisions, see <a href="https://github.com/ziglang/zig/issues/663">issue #663</a></p> |
| 7714 | 7714 | {#header_close#} |
| 7715 | 7715 | {#header_open|Grammar#} |
| 7716 | | <pre><code class="nohighlight">Root = many(TopLevelItem) EOF |
| 7716 | <pre><code class="nohighlight"> |
| 7717 | Root <- skip ContainerMembers eof |
| 7717 | 7718 | |
| 7718 | | TopLevelItem = CompTimeExpression(Block) | TopLevelDecl | TestDecl |
| 7719 | # *** Top level *** |
| 7720 | ContainerMembers |
| 7721 | <- TestDecl ContainerMembers |
| 7722 | / TopLevelComptime ContainerMembers |
| 7723 | / KEYWORD_pub? TopLevelDecl ContainerMembers |
| 7724 | / KEYWORD_pub? ContainerField COMMA ContainerMembers |
| 7725 | / KEYWORD_pub? ContainerField |
| 7726 | / |
| 7719 | 7727 | |
| 7720 | | TestDecl = "test" String Block |
| 7728 | TestDecl <- KEYWORD_test STRINGLITERAL Block |
| 7721 | 7729 | |
| 7722 | | TopLevelDecl = option("pub") (FnDef | ExternDecl | GlobalVarDecl | UseDecl) |
| 7730 | TopLevelComptime <- KEYWORD_comptime BlockExpr |
| 7723 | 7731 | |
| 7724 | | GlobalVarDecl = option("export") VariableDeclaration ";" |
| 7732 | TopLevelDecl |
| 7733 | <- (KEYWORD_export / KEYWORD_extern STRINGLITERAL? / KEYWORD_inline)? FnProto (SEMICOLON / Block) |
| 7734 | / (KEYWORD_export / KEYWORD_extern STRINGLITERAL?)? VarDecl |
| 7735 | / KEYWORD_use Expr SEMICOLON |
| 7725 | 7736 | |
| 7726 | | LocalVarDecl = option("comptime") VariableDeclaration |
| 7737 | FnProto <- FnCC? KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? Section? EXCLAMATIONMARK? (KEYWORD_var / TypeExpr) |
| 7727 | 7738 | |
| 7728 | | VariableDeclaration = ("var" | "const") Symbol option(":" TypeExpr) option("align" "(" Expression ")") option("section" "(" Expression ")") "=" Expression |
| 7739 | VarDecl <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? Section? (EQUAL Expr)? SEMICOLON |
| 7729 | 7740 | |
| 7730 | | ContainerMember = (ContainerField | FnDef | GlobalVarDecl) |
| 7741 | ContainerField <- IDENTIFIER (COLON TypeExpr)? (EQUAL Expr)? |
| 7731 | 7742 | |
| 7732 | | ContainerField = Symbol option(":" PrefixOpExpression) option("=" PrefixOpExpression) "," |
| 7743 | # *** Block Level *** |
| 7744 | Statement |
| 7745 | <- KEYWORD_comptime? VarDecl |
| 7746 | / KEYWORD_comptime BlockExprStatement |
| 7747 | / KEYWORD_suspend (SEMICOLON / BlockExprStatement) |
| 7748 | / KEYWORD_defer BlockExprStatement |
| 7749 | / KEYWORD_errdefer BlockExprStatement |
| 7750 | / IfStatement |
| 7751 | / LabeledStatement |
| 7752 | / SwitchExpr |
| 7753 | / AssignExpr SEMICOLON |
| 7733 | 7754 | |
| 7734 | | UseDecl = "use" Expression ";" |
| 7755 | IfStatement |
| 7756 | <- IfPrefix BlockExpr ( KEYWORD_else Payload? Statement )? |
| 7757 | / IfPrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement ) |
| 7735 | 7758 | |
| 7736 | | ExternDecl = "extern" option(String) (FnProto | VariableDeclaration) ";" |
| 7759 | LabeledStatement <- BlockLabel? (Block / LoopStatement) |
| 7737 | 7760 | |
| 7738 | | FnProto = option("nakedcc" | "stdcallcc" | "extern" | ("async" option("&lt;" Expression "&gt;"))) "fn" option(Symbol) ParamDeclList option("align" "(" Expression ")") option("section" "(" Expression ")") option("!") (TypeExpr | "var") |
| 7761 | LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement) |
| 7739 | 7762 | |
| 7740 | | FnDef = option("inline" | "export") FnProto Block |
| 7763 | ForStatement |
| 7764 | <- ForPrefix BlockExpr ( KEYWORD_else Statement )? |
| 7765 | / ForPrefix AssignExpr ( SEMICOLON / KEYWORD_else Statement ) |
| 7741 | 7766 | |
| 7742 | | ParamDeclList = "(" list(ParamDecl, ",") ")" |
| 7767 | WhileStatement |
| 7768 | <- WhilePrefix BlockExpr ( KEYWORD_else Payload? Statement )? |
| 7769 | / WhilePrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement ) |
| 7743 | 7770 | |
| 7744 | | ParamDecl = option("noalias" | "comptime") option(Symbol ":") (TypeExpr | "var" | "...") |
| 7771 | BlockExprStatement |
| 7772 | <- BlockExpr |
| 7773 | / AssignExpr SEMICOLON |
| 7745 | 7774 | |
| 7746 | | Block = option(Symbol ":") "{" many(Statement) "}" |
| 7775 | BlockExpr <- BlockLabel? Block |
| 7747 | 7776 | |
| 7748 | | Statement = LocalVarDecl ";" | Defer(Block) | Defer(Expression) ";" | BlockExpression(Block) | Expression ";" | ";" |
| 7777 | # *** Expression Level *** |
| 7778 | AssignExpr <- Expr (AssignOp Expr)? |
| 7749 | 7779 | |
| 7750 | | TypeExpr = (PrefixOpExpression "!" PrefixOpExpression) | PrefixOpExpression |
| 7780 | Expr <- KEYWORD_try* BoolOrExpr |
| 7751 | 7781 | |
| 7752 | | BlockOrExpression = Block | Expression |
| 7782 | BoolOrExpr <- BoolAndExpr (KEYWORD_or BoolAndExpr)* |
| 7753 | 7783 | |
| 7754 | | Expression = TryExpression | ReturnExpression | BreakExpression | AssignmentExpression | CancelExpression | ResumeExpression |
| 7784 | BoolAndExpr <- CompareExpr (KEYWORD_and CompareExpr)* |
| 7755 | 7785 | |
| 7756 | | AsmExpression = "asm" option("volatile") "(" String option(AsmOutput) ")" |
| 7786 | CompareExpr <- BitwiseExpr (CompareOp BitwiseExpr)? |
| 7757 | 7787 | |
| 7758 | | AsmOutput = ":" list(AsmOutputItem, ",") option(AsmInput) |
| 7788 | BitwiseExpr <- BitShiftExpr (BitwiseOp BitShiftExpr)* |
| 7759 | 7789 | |
| 7760 | | AsmInput = ":" list(AsmInputItem, ",") option(AsmClobbers) |
| 7790 | BitShiftExpr <- AdditionExpr (BitShiftOp AdditionExpr)* |
| 7761 | 7791 | |
| 7762 | | AsmOutputItem = "[" Symbol "]" String "(" (Symbol | "-&gt;" TypeExpr) ")" |
| 7792 | AdditionExpr <- MultiplyExpr (AdditionOp MultiplyExpr)* |
| 7763 | 7793 | |
| 7764 | | AsmInputItem = "[" Symbol "]" String "(" Expression ")" |
| 7794 | MultiplyExpr <- PrefixExpr (MultiplyOp PrefixExpr)* |
| 7765 | 7795 | |
| 7766 | | AsmClobbers= ":" list(String, ",") |
| 7796 | PrefixExpr <- PrefixOp* PrimaryExpr |
| 7767 | 7797 | |
| 7768 | | UnwrapExpression = BoolOrExpression (UnwrapOptional | UnwrapError) | BoolOrExpression |
| 7798 | PrimaryExpr |
| 7799 | <- AsmExpr |
| 7800 | / IfExpr |
| 7801 | / KEYWORD_break BreakLabel? Expr? |
| 7802 | / KEYWORD_cancel Expr |
| 7803 | / KEYWORD_comptime Expr |
| 7804 | / KEYWORD_continue BreakLabel? |
| 7805 | / KEYWORD_resume Expr |
| 7806 | / KEYWORD_return Expr? |
| 7807 | / LabeledExpr |
| 7808 | / CurlySuffixExpr |
| 7769 | 7809 | |
| 7770 | | UnwrapOptional = "orelse" Expression |
| 7810 | IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)? |
| 7771 | 7811 | |
| 7772 | | UnwrapError = "catch" option("|" Symbol "|") Expression |
| 7812 | LabeledExpr <- BlockLabel? (Block / LoopExpr) |
| 7773 | 7813 | |
| 7774 | | AssignmentExpression = UnwrapExpression AssignmentOperator UnwrapExpression | UnwrapExpression |
| 7814 | Block <- LBRACE Statement* RBRACE |
| 7775 | 7815 | |
| 7776 | | AssignmentOperator = "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "&lt;&lt;=" | "&gt;&gt;=" | "&amp;=" | "^=" | "|=" | "*%=" | "+%=" | "-%=" |
| 7816 | LoopExpr <- KEYWORD_inline? (ForExpr / WhileExpr) |
| 7777 | 7817 | |
| 7778 | | BlockExpression(body) = Block | IfExpression(body) | IfErrorExpression(body) | TestExpression(body) | WhileExpression(body) | ForExpression(body) | SwitchExpression | CompTimeExpression(body) | SuspendExpression(body) |
| 7818 | ForExpr <- ForPrefix Expr (KEYWORD_else Expr)? |
| 7779 | 7819 | |
| 7780 | | CompTimeExpression(body) = "comptime" body |
| 7820 | WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)? |
| 7781 | 7821 | |
| 7782 | | SwitchExpression = "switch" "(" Expression ")" "{" many(SwitchProng) "}" |
| 7822 | CurlySuffixExpr <- TypeExpr InitList? |
| 7783 | 7823 | |
| 7784 | | SwitchProng = (list(SwitchItem, ",") | "else") "=&gt;" option("|" option("*") Symbol "|") Expression "," |
| 7824 | InitList |
| 7825 | <- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE |
| 7826 | / LBRACE Expr (COMMA Expr)* COMMA? RBRACE |
| 7827 | / LBRACE RBRACE |
| 7785 | 7828 | |
| 7786 | | SwitchItem = Expression | (Expression "..." Expression) |
| 7829 | TypeExpr <- PrefixTypeOp* ErrorUnionExpr |
| 7787 | 7830 | |
| 7788 | | ForExpression(body) = option(Symbol ":") option("inline") "for" "(" Expression ")" option("|" option("*") Symbol option("," Symbol) "|") body option("else" BlockExpression(body)) |
| 7831 | ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr)? |
| 7789 | 7832 | |
| 7790 | | BoolOrExpression = BoolAndExpression "or" BoolOrExpression | BoolAndExpression |
| 7833 | SuffixExpr |
| 7834 | <- AsyncPrefix PrimaryTypeExpr SuffixOp* FnCallArgumnets |
| 7835 | / PrimaryTypeExpr (SuffixOp / FnCallArgumnets)* |
| 7791 | 7836 | |
| 7792 | | ReturnExpression = "return" option(Expression) |
| 7837 | PrimaryTypeExpr |
| 7838 | <- BUILTININDENTIFIER FnCallArgumnets |
| 7839 | / CHAR_LITERAL |
| 7840 | / ContainerDecl |
| 7841 | / ErrorSetDecl |
| 7842 | / FLOAT |
| 7843 | / FnProto |
| 7844 | / GroupedExpr |
| 7845 | / LabeledTypeExpr |
| 7846 | / IDENTIFIER |
| 7847 | / IfTypeExpr |
| 7848 | / INTEGER |
| 7849 | / KEYWORD_anyerror |
| 7850 | / KEYWORD_comptime TypeExpr |
| 7851 | / KEYWORD_error DOT IDENTIFIER |
| 7852 | / KEYWORD_false |
| 7853 | / KEYWORD_null |
| 7854 | / KEYWORD_promise |
| 7855 | / KEYWORD_true |
| 7856 | / KEYWORD_undefined |
| 7857 | / KEYWORD_unreachable |
| 7858 | / STRINGLITERAL |
| 7859 | / SwitchExpr |
| 7793 | 7860 | |
| 7794 | | TryExpression = "try" Expression |
| 7861 | ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto |
| 7795 | 7862 | |
| 7796 | | AwaitExpression = "await" Expression |
| 7863 | ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE |
| 7797 | 7864 | |
| 7798 | | BreakExpression = "break" option(":" Symbol) option(Expression) |
| 7865 | GroupedExpr <- LPAREN Expr RPAREN |
| 7799 | 7866 | |
| 7800 | | CancelExpression = "cancel" Expression; |
| 7867 | IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)? |
| 7801 | 7868 | |
| 7802 | | ResumeExpression = "resume" Expression; |
| 7869 | LabeledTypeExpr |
| 7870 | <- BlockLabel Block |
| 7871 | / BlockLabel? LoopTypeExpr |
| 7803 | 7872 | |
| 7804 | | Defer(body) = ("defer" | "errdefer") body |
| 7873 | LoopTypeExpr <- KEYWORD_inline? (ForTypeExpr / WhileTypeExpr) |
| 7805 | 7874 | |
| 7806 | | IfExpression(body) = "if" "(" Expression ")" body option("else" BlockExpression(body)) |
| 7875 | ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr)? |
| 7807 | 7876 | |
| 7808 | | SuspendExpression(body) = "suspend" option( body ) |
| 7877 | WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)? |
| 7809 | 7878 | |
| 7810 | | IfErrorExpression(body) = "if" "(" Expression ")" option("|" option("*") Symbol "|") body "else" "|" Symbol "|" BlockExpression(body) |
| 7879 | SwitchExpr <- KEYWORD_switch LPAREN Expr RPAREN LBRACE SwitchProngList RBRACE |
| 7811 | 7880 | |
| 7812 | | TestExpression(body) = "if" "(" Expression ")" option("|" option("*") Symbol "|") body option("else" BlockExpression(body)) |
| 7881 | # *** Assembly *** |
| 7882 | AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN STRINGLITERAL AsmOutput? RPAREN |
| 7813 | 7883 | |
| 7814 | | WhileExpression(body) = option(Symbol ":") option("inline") "while" "(" Expression ")" option("|" option("*") Symbol "|") option(":" "(" Expression ")") body option("else" option("|" Symbol "|") BlockExpression(body)) |
| 7884 | AsmOutput <- COLON AsmOutputList AsmInput? |
| 7815 | 7885 | |
| 7816 | | BoolAndExpression = ComparisonExpression "and" BoolAndExpression | ComparisonExpression |
| 7886 | AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN |
| 7817 | 7887 | |
| 7818 | | ComparisonExpression = BinaryOrExpression ComparisonOperator BinaryOrExpression | BinaryOrExpression |
| 7888 | AsmInput <- COLON AsmInputList AsmCloppers? |
| 7819 | 7889 | |
| 7820 | | ComparisonOperator = "==" | "!=" | "&lt;" | "&gt;" | "&lt;=" | "&gt;=" |
| 7890 | AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN Expr RPAREN |
| 7821 | 7891 | |
| 7822 | | BinaryOrExpression = BinaryXorExpression "|" BinaryOrExpression | BinaryXorExpression |
| 7892 | AsmCloppers <- COLON StringList |
| 7823 | 7893 | |
| 7824 | | BinaryXorExpression = BinaryAndExpression "^" BinaryXorExpression | BinaryAndExpression |
| 7894 | # *** Helper grammar *** |
| 7895 | BreakLabel <- COLON IDENTIFIER |
| 7825 | 7896 | |
| 7826 | | BinaryAndExpression = BitShiftExpression "&amp;" BinaryAndExpression | BitShiftExpression |
| 7897 | BlockLabel <- IDENTIFIER COLON |
| 7827 | 7898 | |
| 7828 | | BitShiftExpression = AdditionExpression BitShiftOperator BitShiftExpression | AdditionExpression |
| 7899 | FieldInit <- DOT IDENTIFIER EQUAL Expr |
| 7829 | 7900 | |
| 7830 | | BitShiftOperator = "&lt;&lt;" | "&gt;&gt;" |
| 7901 | WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN |
| 7831 | 7902 | |
| 7832 | | AdditionExpression = MultiplyExpression AdditionOperator AdditionExpression | MultiplyExpression |
| 7903 | Section <- KEYWORD_section LPAREN Expr RPAREN |
| 7833 | 7904 | |
| 7834 | | AdditionOperator = "+" | "-" | "++" | "+%" | "-%" |
| 7905 | # Fn specific |
| 7906 | FnCC |
| 7907 | <- KEYWORD_nakedcc |
| 7908 | / KEYWORD_stdcallcc |
| 7909 | / KEYWORD_extern |
| 7910 | / KEYWORD_async (LARROW TypeExpr RARROW)? |
| 7835 | 7911 | |
| 7836 | | MultiplyExpression = CurlySuffixExpression MultiplyOperator MultiplyExpression | CurlySuffixExpression |
| 7912 | ParamDecl <- (KEYWORD_noalias / KEYWORD_comptime)? (IDENTIFIER COLON)? ParamType |
| 7837 | 7913 | |
| 7838 | | CurlySuffixExpression = TypeExpr option(ContainerInitExpression) |
| 7914 | ParamType |
| 7915 | <- KEYWORD_var |
| 7916 | / DOT3 |
| 7917 | / TypeExpr |
| 7839 | 7918 | |
| 7840 | | MultiplyOperator = "||" | "*" | "/" | "%" | "**" | "*%" |
| 7919 | # Control flow prefixes |
| 7920 | IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload? |
| 7841 | 7921 | |
| 7842 | | PrefixOpExpression = PrefixOp TypeExpr | SuffixOpExpression |
| 7922 | WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr? |
| 7843 | 7923 | |
| 7844 | | SuffixOpExpression = ("async" option("&lt;" SuffixOpExpression "&gt;") SuffixOpExpression FnCallExpression) | PrimaryExpression option(FnCallExpression | ArrayAccessExpression | FieldAccessExpression | SliceExpression | ".*" | ".?") |
| 7924 | ForPrefix <- KEYWORD_for LPAREN Expr RPAREN PtrIndexPayload |
| 7845 | 7925 | |
| 7846 | | FieldAccessExpression = "." Symbol |
| 7926 | # Payloads |
| 7927 | Payload <- PIPE IDENTIFIER PIPE |
| 7847 | 7928 | |
| 7848 | | FnCallExpression = "(" list(Expression, ",") ")" |
| 7929 | PtrPayload <- PIPE ASTERISK? IDENTIFIER PIPE |
| 7849 | 7930 | |
| 7850 | | ArrayAccessExpression = "[" Expression "]" |
| 7931 | PtrIndexPayload <- PIPE ASTERISK? IDENTIFIER (COMMA IDENTIFIER)? PIPE |
| 7851 | 7932 | |
| 7852 | | SliceExpression = "[" Expression ".." option(Expression) "]" |
| 7853 | 7933 | |
| 7854 | | ContainerInitExpression = "{" ContainerInitBody "}" |
| 7934 | # Switch specific |
| 7935 | SwitchProng <- SwitchCase EQUALRARROW PtrPayload? AssignExpr |
| 7855 | 7936 | |
| 7856 | | ContainerInitBody = list(StructLiteralField, ",") | list(Expression, ",") |
| 7937 | SwitchCase |
| 7938 | <- SwitchItem (COMMA SwitchItem)* COMMA? |
| 7939 | / KEYWORD_else |
| 7857 | 7940 | |
| 7858 | | StructLiteralField = "." Symbol "=" Expression |
| 7941 | SwitchItem <- Expr (DOT3 Expr)? |
| 7859 | 7942 | |
| 7860 | | PrefixOp = "!" | "-" | "~" | (("*" | "[*]") option("align" "(" Expression option(":" Integer ":" Integer) ")" ) option("const") option("volatile")) | "?" | "-%" | "try" | "await" |
| 7943 | # Operators |
| 7944 | AssignOp |
| 7945 | <- ASTERISKEQUAL |
| 7946 | / SLASHEQUAL |
| 7947 | / PERCENTEQUAL |
| 7948 | / PLUSEQUAL |
| 7949 | / MINUSEQUAL |
| 7950 | / LARROW2EQUAL |
| 7951 | / RARROW2EQUAL |
| 7952 | / AMPERSANDEQUAL |
| 7953 | / CARETEQUAL |
| 7954 | / PIPEEQUAL |
| 7955 | / ASTERISKPERCENTEQUAL |
| 7956 | / PLUSPERCENTEQUAL |
| 7957 | / MINUSPERCENTEQUAL |
| 7958 | / EQUAL |
| 7861 | 7959 | |
| 7862 | | PrimaryExpression = Integer | Float | String | CharLiteral | KeywordLiteral | GroupedExpression | BlockExpression(BlockOrExpression) | Symbol | ("@" Symbol FnCallExpression) | ArrayType | FnProto | AsmExpression | ContainerDecl | ("continue" option(":" Symbol)) | ErrorSetDecl | PromiseType |
| 7960 | CompareOp |
| 7961 | <- EQUALEQUAL |
| 7962 | / EXCLAMATIONMARKEQUAL |
| 7963 | / LARROW |
| 7964 | / RARROW |
| 7965 | / LARROWEQUAL |
| 7966 | / RARROWEQUAL |
| 7863 | 7967 | |
| 7864 | | PromiseType = "promise" option("-&gt;" TypeExpr) |
| 7968 | BitwiseOp |
| 7969 | <- AMPERSAND |
| 7970 | / CARET |
| 7971 | / PIPE |
| 7972 | / KEYWORD_orelse |
| 7973 | / KEYWORD_catch Payload? |
| 7865 | 7974 | |
| 7866 | | ArrayType : "[" option(Expression) "]" option("align" "(" Expression option(":" Integer ":" Integer) ")")) option("const") option("volatile") TypeExpr |
| 7975 | BitShiftOp |
| 7976 | <- LARROW2 |
| 7977 | / RARROW2 |
| 7867 | 7978 | |
| 7868 | | GroupedExpression = "(" Expression ")" |
| 7869 | | |
| 7870 | | KeywordLiteral = "true" | "false" | "null" | "undefined" | "error" | "unreachable" | "suspend" |
| 7871 | | |
| 7872 | | ErrorSetDecl = "error" "{" list(Symbol, ",") "}" |
| 7873 | | |
| 7874 | | ContainerDecl = option("extern" | "packed") |
| 7875 | | ("struct" option(GroupedExpression) | "union" option("enum" option(GroupedExpression) | GroupedExpression) | ("enum" option(GroupedExpression))) |
| 7876 | | "{" many(ContainerMember) "}"</code></pre> |
| 7979 | AdditionOp |
| 7980 | <- PLUS |
| 7981 | / MINUS |
| 7982 | / PLUS2 |
| 7983 | / PLUSPERCENT |
| 7984 | / MINUSPERCENT |
| 7985 | |
| 7986 | MultiplyOp |
| 7987 | <- PIPE2 |
| 7988 | / ASTERISK |
| 7989 | / SLASH |
| 7990 | / PERCENT |
| 7991 | / ASTERISK2 |
| 7992 | / ASTERISKPERCENT |
| 7993 | |
| 7994 | PrefixOp |
| 7995 | <- EXCLAMATIONMARK |
| 7996 | / MINUS |
| 7997 | / TILDE |
| 7998 | / MINUSPERCENT |
| 7999 | / AMPERSAND |
| 8000 | / KEYWORD_try |
| 8001 | / KEYWORD_await |
| 8002 | |
| 8003 | PrefixTypeOp |
| 8004 | <- QUESTIONMARK |
| 8005 | / KEYWORD_promise MINUSRARROW |
| 8006 | / ArrayTypeStart (ByteAlign / KEYWORD_const / KEYWORD_volatile)* |
| 8007 | / PtrTypeStart (KEYWORD_align LPAREN Expr (COLON INTEGER COLON INTEGER)? RPAREN / KEYWORD_const / KEYWORD_volatile)* |
| 8008 | |
| 8009 | SuffixOp |
| 8010 | <- LBRACKET Expr (DOT2 Expr?)? RBRACKET |
| 8011 | / DOT IDENTIFIER |
| 8012 | / DOTASTERISK |
| 8013 | / DOTQUESTIONMARK |
| 8014 | |
| 8015 | AsyncPrefix <- KEYWORD_async (LARROW PrefixExpr RARROW)? |
| 8016 | |
| 8017 | FnCallArgumnets <- LPAREN ExprList RPAREN |
| 8018 | |
| 8019 | # Ptr specific |
| 8020 | ArrayTypeStart <- LBRACKET Expr? RBRACKET |
| 8021 | |
| 8022 | PtrTypeStart |
| 8023 | <- ASTERISK |
| 8024 | / ASTERISK2 |
| 8025 | / LBRACKET ASTERISK RBRACKET |
| 8026 | |
| 8027 | # ContainerDecl specific |
| 8028 | ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE |
| 8029 | |
| 8030 | ContainerDeclType |
| 8031 | <- (KEYWORD_struct / KEYWORD_enum) (LPAREN Expr RPAREN)? |
| 8032 | / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)? |
| 8033 | |
| 8034 | # Alignment |
| 8035 | ByteAlign <- KEYWORD_align LPAREN Expr RPAREN |
| 8036 | |
| 8037 | # Lists |
| 8038 | IdentifierList <- (IDENTIFIER COMMA)* IDENTIFIER? |
| 8039 | |
| 8040 | SwitchProngList <- (SwitchProng COMMA)* SwitchProng? |
| 8041 | |
| 8042 | AsmOutputList <- (AsmOutputItem COMMA)* AsmOutputItem? |
| 8043 | |
| 8044 | AsmInputList <- (AsmInputItem COMMA)* AsmInputItem? |
| 8045 | |
| 8046 | StringList <- (STRINGLITERAL COMMA)* STRINGLITERAL? |
| 8047 | |
| 8048 | ParamDeclList <- (ParamDecl COMMA)* ParamDecl? |
| 8049 | |
| 8050 | ExprList <- (Expr COMMA)* Expr? |
| 8051 | |
| 8052 | # *** Tokens *** |
| 8053 | eof <- !. |
| 8054 | hex <- [0-9a-fA-F] |
| 8055 | char_escape |
| 8056 | <- "\\x" hex hex |
| 8057 | / "\\u" hex hex hex hex |
| 8058 | / "\\U" hex hex hex hex hex hex |
| 8059 | / "\\" [nr\\t'"] |
| 8060 | char_char |
| 8061 | <- char_escape |
| 8062 | / [^\\'\n] |
| 8063 | string_char |
| 8064 | <- char_escape |
| 8065 | / [^\\"\n] |
| 8066 | |
| 8067 | line_comment <- '//'[^\n]* |
| 8068 | line_string <- ("\\\\" [^\n]* [ \n]*)+ |
| 8069 | line_cstring <- ("c\\\\" [^\n]* [ \n]*)+ |
| 8070 | skip <- ([ \n] / line_comment)* |
| 8071 | |
| 8072 | CHAR_LITERAL <- "'" char_char "'" skip |
| 8073 | FLOAT |
| 8074 | <- "0b" [01]+ "." [01]+ ([eE] [-+]? [01]+)? skip |
| 8075 | / "0o" [0-7]+ "." [0-7]+ ([eE] [-+]? [0-7]+)? skip |
| 8076 | / "0x" hex+ "." hex+ ([pP] [-+]? hex+)? skip |
| 8077 | / [0-9]+ "." [0-9]+ ([eE] [-+]? [0-9]+)? skip |
| 8078 | / "0b" [01]+ "."? [eE] [-+]? [01]+ skip |
| 8079 | / "0o" [0-7]+ "."? [eE] [-+]? [0-7]+ skip |
| 8080 | / "0x" hex+ "."? [pP] [-+]? hex+ skip |
| 8081 | / [0-9]+ "."? [eE] [-+]? [0-9]+ skip |
| 8082 | INTEGER |
| 8083 | <- "0b" [01]+ skip |
| 8084 | / "0o" [0-7]+ skip |
| 8085 | / "0x" hex+ skip |
| 8086 | / [0-9]+ skip |
| 8087 | STRINGLITERAL |
| 8088 | <- "c"? "\"" string_char* "\"" skip |
| 8089 | / line_string skip |
| 8090 | / line_cstring skip |
| 8091 | IDENTIFIER |
| 8092 | <- !keyword ("c" !["\\] / [A-Zabd-z_]) [A-Za-z0-9_]* skip |
| 8093 | / "@\"" string_char* "\"" skip |
| 8094 | BUILTININDENTIFIER <- "@"[A-Za-z_][A-Za-z0-9_]* skip |
| 8095 | |
| 8096 | |
| 8097 | AMPERSAND <- '&' ![=] skip |
| 8098 | AMPERSANDEQUAL <- '&=' skip |
| 8099 | ASTERISK <- '*' ![*%=] skip |
| 8100 | ASTERISK2 <- '**' skip |
| 8101 | ASTERISKEQUAL <- '*=' skip |
| 8102 | ASTERISKPERCENT <- '*%' ![=] skip |
| 8103 | ASTERISKPERCENTEQUAL <- '*%=' skip |
| 8104 | CARET <- '^' ![=] skip |
| 8105 | CARETEQUAL <- '^=' skip |
| 8106 | COLON <- ':' skip |
| 8107 | COMMA <- ',' skip |
| 8108 | DOT <- '.' ![*.?] skip |
| 8109 | DOT2 <- '..' ![.] skip |
| 8110 | DOT3 <- '...' skip |
| 8111 | DOTASTERISK <- '.*' skip |
| 8112 | DOTQUESTIONMARK <- '.?' skip |
| 8113 | EQUAL <- '=' ![>=] skip |
| 8114 | EQUALEQUAL <- '==' skip |
| 8115 | EQUALRARROW <- '=>' skip |
| 8116 | EXCLAMATIONMARK <- '!' ![=] skip |
| 8117 | EXCLAMATIONMARKEQUAL <- '!=' skip |
| 8118 | LARROW <- '<' ![<=] skip |
| 8119 | LARROW2 <- '<<' ![=] skip |
| 8120 | LARROW2EQUAL <- '<<=' skip |
| 8121 | LARROWEQUAL <- '<=' skip |
| 8122 | LBRACE <- '{' skip |
| 8123 | LBRACKET <- '[' skip |
| 8124 | LPAREN <- '(' skip |
| 8125 | MINUS <- '-' ![%=>] skip |
| 8126 | MINUSEQUAL <- '-=' skip |
| 8127 | MINUSPERCENT <- '-%' ![=] skip |
| 8128 | MINUSPERCENTEQUAL <- '-%=' skip |
| 8129 | MINUSRARROW <- '->' skip |
| 8130 | PERCENT <- '%' ![=] skip |
| 8131 | PERCENTEQUAL <- '%=' skip |
| 8132 | PIPE <- '|' ![|=] skip |
| 8133 | PIPE2 <- '||' skip |
| 8134 | PIPEEQUAL <- '|=' skip |
| 8135 | PLUS <- '+' ![%+=] skip |
| 8136 | PLUS2 <- '++' skip |
| 8137 | PLUSEQUAL <- '+=' skip |
| 8138 | PLUSPERCENT <- '+%' ![=] skip |
| 8139 | PLUSPERCENTEQUAL <- '+%=' skip |
| 8140 | QUESTIONMARK <- '?' skip |
| 8141 | RARROW <- '>' ![>=] skip |
| 8142 | RARROW2 <- '>>' ![=] skip |
| 8143 | RARROW2EQUAL <- '>>=' skip |
| 8144 | RARROWEQUAL <- '>=' skip |
| 8145 | RBRACE <- '}' skip |
| 8146 | RBRACKET <- ']' skip |
| 8147 | RPAREN <- ')' skip |
| 8148 | SEMICOLON <- ';' skip |
| 8149 | SLASH <- '/' ![=] skip |
| 8150 | SLASHEQUAL <- '/=' skip |
| 8151 | TILDE <- '~' skip |
| 8152 | |
| 8153 | end_of_word <- ![a-zA-Z0-9_] skip |
| 8154 | KEYWORD_align <- 'align' end_of_word |
| 8155 | KEYWORD_and <- 'and' end_of_word |
| 8156 | KEYWORD_anyerror <- 'anyerror' end_of_word |
| 8157 | KEYWORD_asm <- 'asm' end_of_word |
| 8158 | KEYWORD_async <- 'async' end_of_word |
| 8159 | KEYWORD_await <- 'await' end_of_word |
| 8160 | KEYWORD_break <- 'break' end_of_word |
| 8161 | KEYWORD_cancel <- 'cancel' end_of_word |
| 8162 | KEYWORD_catch <- 'catch' end_of_word |
| 8163 | KEYWORD_comptime <- 'comptime' end_of_word |
| 8164 | KEYWORD_const <- 'const' end_of_word |
| 8165 | KEYWORD_continue <- 'continue' end_of_word |
| 8166 | KEYWORD_defer <- 'defer' end_of_word |
| 8167 | KEYWORD_else <- 'else' end_of_word |
| 8168 | KEYWORD_enum <- 'enum' end_of_word |
| 8169 | KEYWORD_errdefer <- 'errdefer' end_of_word |
| 8170 | KEYWORD_error <- 'error' end_of_word |
| 8171 | KEYWORD_export <- 'export' end_of_word |
| 8172 | KEYWORD_extern <- 'extern' end_of_word |
| 8173 | KEYWORD_false <- 'false' end_of_word |
| 8174 | KEYWORD_fn <- 'fn' end_of_word |
| 8175 | KEYWORD_for <- 'for' end_of_word |
| 8176 | KEYWORD_if <- 'if' end_of_word |
| 8177 | KEYWORD_inline <- 'inline' end_of_word |
| 8178 | KEYWORD_nakedcc <- 'nakedcc' end_of_word |
| 8179 | KEYWORD_noalias <- 'noalias' end_of_word |
| 8180 | KEYWORD_null <- 'null' end_of_word |
| 8181 | KEYWORD_or <- 'or' end_of_word |
| 8182 | KEYWORD_orelse <- 'orelse' end_of_word |
| 8183 | KEYWORD_packed <- 'packed' end_of_word |
| 8184 | KEYWORD_promise <- 'promise' end_of_word |
| 8185 | KEYWORD_pub <- 'pub' end_of_word |
| 8186 | KEYWORD_resume <- 'resume' end_of_word |
| 8187 | KEYWORD_return <- 'return' end_of_word |
| 8188 | KEYWORD_section <- 'section' end_of_word |
| 8189 | KEYWORD_stdcallcc <- 'stdcallcc' end_of_word |
| 8190 | KEYWORD_struct <- 'struct' end_of_word |
| 8191 | KEYWORD_suspend <- 'suspend' end_of_word |
| 8192 | KEYWORD_switch <- 'switch' end_of_word |
| 8193 | KEYWORD_test <- 'test' end_of_word |
| 8194 | KEYWORD_true <- 'true' end_of_word |
| 8195 | KEYWORD_try <- 'try' end_of_word |
| 8196 | KEYWORD_undefined <- 'undefined' end_of_word |
| 8197 | KEYWORD_union <- 'union' end_of_word |
| 8198 | KEYWORD_unreachable <- 'unreachable' end_of_word |
| 8199 | KEYWORD_use <- 'use' end_of_word |
| 8200 | KEYWORD_var <- 'var' end_of_word |
| 8201 | KEYWORD_volatile <- 'volatile' end_of_word |
| 8202 | KEYWORD_while <- 'while' end_of_word |
| 8203 | |
| 8204 | keyword <- KEYWORD_align / KEYWORD_and / KEYWORD_anyerror / KEYWORD_asm |
| 8205 | / KEYWORD_async / KEYWORD_await / KEYWORD_break / KEYWORD_cancel |
| 8206 | / KEYWORD_catch / KEYWORD_comptime / KEYWORD_const / KEYWORD_continue |
| 8207 | / KEYWORD_defer / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer |
| 8208 | / KEYWORD_error / KEYWORD_export / KEYWORD_extern / KEYWORD_false |
| 8209 | / KEYWORD_fn / KEYWORD_for / KEYWORD_if / KEYWORD_inline |
| 8210 | / KEYWORD_nakedcc / KEYWORD_noalias / KEYWORD_null / KEYWORD_or |
| 8211 | / KEYWORD_orelse / KEYWORD_packed / KEYWORD_promise / KEYWORD_pub |
| 8212 | / KEYWORD_resume / KEYWORD_return / KEYWORD_section |
| 8213 | / KEYWORD_stdcallcc / KEYWORD_struct / KEYWORD_suspend |
| 8214 | / KEYWORD_switch / KEYWORD_test / KEYWORD_true / KEYWORD_try |
| 8215 | / KEYWORD_undefined / KEYWORD_union / KEYWORD_unreachable |
| 8216 | / KEYWORD_use / KEYWORD_var / KEYWORD_volatile / KEYWORD_while |
| 8217 | </code></pre> |
| 7877 | 8218 | {#header_close#} |
| 7878 | 8219 | {#header_open|Zen#} |
| 7879 | 8220 | <ul> |