package lexers import ( . "github.com/alecthomas/chroma/v2" // nolint ) // Haxe lexer. var Haxe = Register(MustNewLexer( &Config{ Name: "Haxe", Aliases: []string{"hx", "haxe", "hxsl"}, Filenames: []string{"*.hx", "*.hxsl"}, MimeTypes: []string{"text/haxe", "text/x-haxe", "text/x-hx"}, DotAll: true, }, haxeRules, )) func haxeRules() Rules { return Rules{ "root": { Include("spaces"), Include("meta"), {`(?:package)\b`, KeywordNamespace, Push("semicolon", "package")}, {`(?:import)\b`, KeywordNamespace, Push("semicolon", "import")}, {`(?:using)\b`, KeywordNamespace, Push("semicolon", "using")}, {`(?:extern|private)\b`, KeywordDeclaration, nil}, {`(?:abstract)\b`, KeywordDeclaration, Push("abstract")}, {`(?:class|interface)\b`, KeywordDeclaration, Push("class")}, {`(?:enum)\b`, KeywordDeclaration, Push("enum")}, {`(?:typedef)\b`, KeywordDeclaration, Push("typedef")}, {`(?=.)`, Text, Push("expr-statement")}, }, "spaces": { {`\s+`, Text, nil}, {`//[^\n\r]*`, CommentSingle, nil}, {`/\*.*?\*/`, CommentMultiline, nil}, {`(#)(if|elseif|else|end|error)\b`, CommentPreproc, MutatorFunc(haxePreProcMutator)}, }, "string-single-interpol": { {`\$\{`, LiteralStringInterpol, Push("string-interpol-close", "expr")}, {`\$\$`, LiteralStringEscape, nil}, {`\$(?=(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+))`, LiteralStringInterpol, Push("ident")}, Include("string-single"), }, "string-single": { {`'`, LiteralStringSingle, Pop(1)}, {`\\.`, LiteralStringEscape, nil}, {`.`, LiteralStringSingle, nil}, }, "string-double": { {`"`, LiteralStringDouble, Pop(1)}, {`\\.`, LiteralStringEscape, nil}, {`.`, LiteralStringDouble, nil}, }, "string-interpol-close": { {`\$(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, LiteralStringInterpol, nil}, {`\}`, LiteralStringInterpol, Pop(1)}, }, "package": { Include("spaces"), {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameNamespace, nil}, {`\.`, Punctuation, Push("import-ident")}, Default(Pop(1)), }, "import": { Include("spaces"), {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameNamespace, nil}, {`\*`, Keyword, nil}, {`\.`, Punctuation, Push("import-ident")}, {`in`, KeywordNamespace, Push("ident")}, Default(Pop(1)), }, "import-ident": { Include("spaces"), {`\*`, Keyword, Pop(1)}, {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameNamespace, Pop(1)}, }, "using": { Include("spaces"), {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameNamespace, nil}, {`\.`, Punctuation, Push("import-ident")}, Default(Pop(1)), }, "preproc-error": { {`\s+`, CommentPreproc, nil}, {`'`, LiteralStringSingle, Push("#pop", "string-single")}, {`"`, LiteralStringDouble, Push("#pop", "string-double")}, Default(Pop(1)), }, "preproc-expr": { {`\s+`, CommentPreproc, nil}, {`\!`, CommentPreproc, nil}, {`\(`, CommentPreproc, Push("#pop", "preproc-parenthesis")}, {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, CommentPreproc, Pop(1)}, {`\.[0-9]+`, LiteralNumberFloat, nil}, {`[0-9]+[eE][+\-]?[0-9]+`, LiteralNumberFloat, nil}, {`[0-9]+\.[0-9]*[eE][+\-]?[0-9]+`, LiteralNumberFloat, nil}, {`[0-9]+\.[0-9]+`, LiteralNumberFloat, nil}, {`[0-9]+\.(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)|\.\.)`, LiteralNumberFloat, nil}, {`0x[0-9a-fA-F]+`, LiteralNumberHex, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`'`, LiteralStringSingle, Push("#pop", "string-single")}, {`"`, LiteralStringDouble, Push("#pop", "string-double")}, }, "preproc-parenthesis": { {`\s+`, CommentPreproc, nil}, {`\)`, CommentPreproc, Pop(1)}, Default(Push("preproc-expr-in-parenthesis")), }, "preproc-expr-chain": { {`\s+`, CommentPreproc, nil}, {`(?:%=|&=|\|=|\^=|\+=|\-=|\*=|/=|<<=|>\s*>\s*=|>\s*>\s*>\s*=|==|!=|<=|>\s*=|&&|\|\||<<|>>>|>\s*>|\.\.\.|<|>|%|&|\||\^|\+|\*|/|\-|=>|=)`, CommentPreproc, Push("#pop", "preproc-expr-in-parenthesis")}, Default(Pop(1)), }, "preproc-expr-in-parenthesis": { {`\s+`, CommentPreproc, nil}, {`\!`, CommentPreproc, nil}, {`\(`, CommentPreproc, Push("#pop", "preproc-expr-chain", "preproc-parenthesis")}, {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, CommentPreproc, Push("#pop", "preproc-expr-chain")}, {`\.[0-9]+`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")}, {`[0-9]+[eE][+\-]?[0-9]+`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")}, {`[0-9]+\.[0-9]*[eE][+\-]?[0-9]+`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")}, {`[0-9]+\.[0-9]+`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")}, {`[0-9]+\.(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)|\.\.)`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")}, {`0x[0-9a-fA-F]+`, LiteralNumberHex, Push("#pop", "preproc-expr-chain")}, {`[0-9]+`, LiteralNumberInteger, Push("#pop", "preproc-expr-chain")}, {`'`, LiteralStringSingle, Push("#pop", "preproc-expr-chain", "string-single")}, {`"`, LiteralStringDouble, Push("#pop", "preproc-expr-chain", "string-double")}, }, "abstract": { Include("spaces"), Default(Pop(1), Push("abstract-body"), Push("abstract-relation"), Push("abstract-opaque"), Push("type-param-constraint"), Push("type-name")), }, "abstract-body": { Include("spaces"), {`\{`, Punctuation, Push("#pop", "class-body")}, }, "abstract-opaque": { Include("spaces"), {`\(`, Punctuation, Push("#pop", "parenthesis-close", "type")}, Default(Pop(1)), }, "abstract-relation": { Include("spaces"), {`(?:to|from)`, KeywordDeclaration, Push("type")}, {`,`, Punctuation, nil}, Default(Pop(1)), }, "meta": { Include("spaces"), {`@`, NameDecorator, Push("meta-body", "meta-ident", "meta-colon")}, }, "meta-colon": { Include("spaces"), {`:`, NameDecorator, Pop(1)}, Default(Pop(1)), }, "meta-ident": { Include("spaces"), {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameDecorator, Pop(1)}, }, "meta-body": { Include("spaces"), {`\(`, NameDecorator, Push("#pop", "meta-call")}, Default(Pop(1)), }, "meta-call": { Include("spaces"), {`\)`, NameDecorator, Pop(1)}, Default(Pop(1), Push("meta-call-sep"), Push("expr")), }, "meta-call-sep": { Include("spaces"), {`\)`, NameDecorator, Pop(1)}, {`,`, Punctuation, Push("#pop", "meta-call")}, }, "typedef": { Include("spaces"), Default(Pop(1), Push("typedef-body"), Push("type-param-constraint"), Push("type-name")), }, "typedef-body": { Include("spaces"), {`=`, Operator, Push("#pop", "optional-semicolon", "type")}, }, "enum": { Include("spaces"), Default(Pop(1), Push("enum-body"), Push("bracket-open"), Push("type-param-constraint"), Push("type-name")), }, "enum-body": { Include("spaces"), Include("meta"), {`\}`, Punctuation, Pop(1)}, {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("enum-member", "type-param-constraint")}, }, "enum-member": { Include("spaces"), {`\(`, Punctuation, Push("#pop", "semicolon", "flag", "function-param")}, Default(Pop(1), Push("semicolon"), Push("flag")), }, "class": { Include("spaces"), Default(Pop(1), Push("class-body"), Push("bracket-open"), Push("extends"), Push("type-param-constraint"), Push("type-name")), }, "extends": { Include("spaces"), {`(?:extends|implements)\b`, KeywordDeclaration, Push("type")}, {`,`, Punctuation, nil}, Default(Pop(1)), }, "bracket-open": { Include("spaces"), {`\{`, Punctuation, Pop(1)}, }, "bracket-close": { Include("spaces"), {`\}`, Punctuation, Pop(1)}, }, "class-body": { Include("spaces"), Include("meta"), {`\}`, Punctuation, Pop(1)}, {`(?:static|public|private|override|dynamic|inline|macro)\b`, KeywordDeclaration, nil}, Default(Push("class-member")), }, "class-member": { Include("spaces"), {`(var)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "var")}, {`(function)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "class-method")}, }, "function-local": { Include("spaces"), {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameFunction, Push("#pop", "optional-expr", "flag", "function-param", "parenthesis-open", "type-param-constraint")}, Default(Pop(1), Push("optional-expr"), Push("flag"), Push("function-param"), Push("parenthesis-open"), Push("type-param-constraint")), }, "optional-expr": { Include("spaces"), Include("expr"), Default(Pop(1)), }, "class-method": { Include("spaces"), {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameFunction, Push("#pop", "optional-expr", "flag", "function-param", "parenthesis-open", "type-param-constraint")}, }, "function-param": { Include("spaces"), {`\)`, Punctuation, Pop(1)}, {`\?`, Punctuation, nil}, {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("#pop", "function-param-sep", "assign", "flag")}, }, "function-param-sep": { Include("spaces"), {`\)`, Punctuation, Pop(1)}, {`,`, Punctuation, Push("#pop", "function-param")}, }, "prop-get-set": { Include("spaces"), {`\(`, Punctuation, Push("#pop", "parenthesis-close", "prop-get-set-opt", "comma", "prop-get-set-opt")}, Default(Pop(1)), }, "prop-get-set-opt": { Include("spaces"), {`(?:default|null|never|dynamic|get|set)\b`, Keyword, Pop(1)}, {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Text, Pop(1)}, }, "expr-statement": { Include("spaces"), Default(Pop(1), Push("optional-semicolon"), Push("expr")), }, "expr": { Include("spaces"), {`@`, NameDecorator, Push("#pop", "optional-expr", "meta-body", "meta-ident", "meta-colon")}, {`(?:\+\+|\-\-|~(?!/)|!|\-)`, Operator, nil}, {`\(`, Punctuation, Push("#pop", "expr-chain", "parenthesis")}, {`(?:static|public|private|override|dynamic|inline)\b`, KeywordDeclaration, nil}, {`(?:function)\b`, KeywordDeclaration, Push("#pop", "expr-chain", "function-local")}, {`\{`, Punctuation, Push("#pop", "expr-chain", "bracket")}, {`(?:true|false|null)\b`, KeywordConstant, Push("#pop", "expr-chain")}, {`(?:this)\b`, Keyword, Push("#pop", "expr-chain")}, {`(?:cast)\b`, Keyword, Push("#pop", "expr-chain", "cast")}, {`(?:try)\b`, Keyword, Push("#pop", "catch", "expr")}, {`(?:var)\b`, KeywordDeclaration, Push("#pop", "var")}, {`(?:new)\b`, Keyword, Push("#pop", "expr-chain", "new")}, {`(?:switch)\b`, Keyword, Push("#pop", "switch")}, {`(?:if)\b`, Keyword, Push("#pop", "if")}, {`(?:do)\b`, Keyword, Push("#pop", "do")}, {`(?:while)\b`, Keyword, Push("#pop", "while")}, {`(?:for)\b`, Keyword, Push("#pop", "for")}, {`(?:untyped|throw)\b`, Keyword, nil}, {`(?:return)\b`, Keyword, Push("#pop", "optional-expr")}, {`(?:macro)\b`, Keyword, Push("#pop", "macro")}, {`(?:continue|break)\b`, Keyword, Pop(1)}, {`(?:\$\s*[a-z]\b|\$(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)))`, Name, Push("#pop", "dollar")}, {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("#pop", "expr-chain")}, {`\.[0-9]+`, LiteralNumberFloat, Push("#pop", "expr-chain")}, {`[0-9]+[eE][+\-]?[0-9]+`, LiteralNumberFloat, Push("#pop", "expr-chain")}, {`[0-9]+\.[0-9]*[eE][+\-]?[0-9]+`, LiteralNumberFloat, Push("#pop", "expr-chain")}, {`[0-9]+\.[0-9]+`, LiteralNumberFloat, Push("#pop", "expr-chain")}, {`[0-9]+\.(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)|\.\.)`, LiteralNumberFloat, Push("#pop", "expr-chain")}, {`0x[0-9a-fA-F]+`, LiteralNumberHex, Push("#pop", "expr-chain")}, {`[0-9]+`, LiteralNumberInteger, Push("#pop", "expr-chain")}, {`'`, LiteralStringSingle, Push("#pop", "expr-chain", "string-single-interpol")}, {`"`, LiteralStringDouble, Push("#pop", "expr-chain", "string-double")}, {`~/(\\\\|\\/|[^/\n])*/[gimsu]*`, LiteralStringRegex, Push("#pop", "expr-chain")}, {`\[`, Punctuation, Push("#pop", "expr-chain", "array-decl")}, }, "expr-chain": { Include("spaces"), {`(?:\+\+|\-\-)`, Operator, nil}, {`(?:%=|&=|\|=|\^=|\+=|\-=|\*=|/=|<<=|>\s*>\s*=|>\s*>\s*>\s*=|==|!=|<=|>\s*=|&&|\|\||<<|>>>|>\s*>|\.\.\.|<|>|%|&|\||\^|\+|\*|/|\-|=>|=)`, Operator, Push("#pop", "expr")}, {`(?:in)\b`, Keyword, Push("#pop", "expr")}, {`\?`, Operator, Push("#pop", "expr", "ternary", "expr")}, {`(\.)((?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+))`, ByGroups(Punctuation, Name), nil}, {`\[`, Punctuation, Push("array-access")}, {`\(`, Punctuation, Push("call")}, Default(Pop(1)), }, "macro": { Include("spaces"), Include("meta"), {`:`, Punctuation, Push("#pop", "type")}, {`(?:extern|private)\b`, KeywordDeclaration, nil}, {`(?:abstract)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "abstract")}, {`(?:class|interface)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "macro-class")}, {`(?:enum)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "enum")}, {`(?:typedef)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "typedef")}, Default(Pop(1), Push("expr")), }, "macro-class": { {`\{`, Punctuation, Push("#pop", "class-body")}, Include("class"), }, "cast": { Include("spaces"), {`\(`, Punctuation, Push("#pop", "parenthesis-close", "cast-type", "expr")}, Default(Pop(1), Push("expr")), }, "cast-type": { Include("spaces"), {`,`, Punctuation, Push("#pop", "type")}, Default(Pop(1)), }, "catch": { Include("spaces"), {`(?:catch)\b`, Keyword, Push("expr", "function-param", "parenthesis-open")}, Default(Pop(1)), }, "do": { Include("spaces"), Default(Pop(1), Push("do-while"), Push("expr")), }, "do-while": { Include("spaces"), {`(?:while)\b`, Keyword, Push("#pop", "parenthesis", "parenthesis-open")}, }, "while": { Include("spaces"), {`\(`, Punctuation, Push("#pop", "expr", "parenthesis")}, }, "for": { Include("spaces"), {`\(`, Punctuation, Push("#pop", "expr", "parenthesis")}, }, "if": { Include("spaces"), {`\(`, Punctuation, Push("#pop", "else", "optional-semicolon", "expr", "parenthesis")}, }, "else": { Include("spaces"), {`(?:else)\b`, Keyword, Push("#pop", "expr")}, Default(Pop(1)), }, "switch": { Include("spaces"), Default(Pop(1), Push("switch-body"), Push("bracket-open"), Push("expr")), }, "switch-body": { Include("spaces"), {`(?:case|default)\b`, Keyword, Push("case-block", "case")}, {`\}`, Punctuation, Pop(1)}, }, "case": { Include("spaces"), {`:`, Punctuation, Pop(1)}, Default(Pop(1), Push("case-sep"), Push("case-guard"), Push("expr")), }, "case-sep": { Include("spaces"), {`:`, Punctuation, Pop(1)}, {`,`, Punctuation, Push("#pop", "case")}, }, "case-guard": { Include("spaces"), {`(?:if)\b`, Keyword, Push("#pop", "parenthesis", "parenthesis-open")}, Default(Pop(1)), }, "case-block": { Include("spaces"), {`(?!(?:case|default)\b|\})`, Keyword, Push("expr-statement")}, Default(Pop(1)), }, "new": { Include("spaces"), Default(Pop(1), Push("call"), Push("parenthesis-open"), Push("type")), }, "array-decl": { Include("spaces"), {`\]`, Punctuation, Pop(1)}, Default(Pop(1), Push("array-decl-sep"), Push("expr")), }, "array-decl-sep": { Include("spaces"), {`\]`, Punctuation, Pop(1)}, {`,`, Punctuation, Push("#pop", "array-decl")}, }, "array-access": { Include("spaces"), Default(Pop(1), Push("array-access-close"), Push("expr")), }, "array-access-close": { Include("spaces"), {`\]`, Punctuation, Pop(1)}, }, "comma": { Include("spaces"), {`,`, Punctuation, Pop(1)}, }, "colon": { Include("spaces"), {`:`, Punctuation, Pop(1)}, }, "semicolon": { Include("spaces"), {`;`, Punctuation, Pop(1)}, }, "optional-semicolon": { Include("spaces"), {`;`, Punctuation, Pop(1)}, Default(Pop(1)), }, "ident": { Include("spaces"), {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Pop(1)}, }, "dollar": { Include("spaces"), {`\{`, Punctuation, Push("#pop", "expr-chain", "bracket-close", "expr")}, Default(Pop(1), Push("expr-chain")), }, "type-name": { Include("spaces"), {`_*[A-Z]\w*`, Name, Pop(1)}, }, "type-full-name": { Include("spaces"), {`\.`, Punctuation, Push("ident")}, Default(Pop(1)), }, "type": { Include("spaces"), {`\?`, Punctuation, nil}, {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("#pop", "type-check", "type-full-name")}, {`\{`, Punctuation, Push("#pop", "type-check", "type-struct")}, {`\(`, Punctuation, Push("#pop", "type-check", "type-parenthesis")}, }, "type-parenthesis": { Include("spaces"), Default(Pop(1), Push("parenthesis-close"), Push("type")), }, "type-check": { Include("spaces"), {`->`, Punctuation, Push("#pop", "type")}, {`<(?!=)`, Punctuation, Push("type-param")}, Default(Pop(1)), }, "type-struct": { Include("spaces"), {`\}`, Punctuation, Pop(1)}, {`\?`, Punctuation, nil}, {`>`, Punctuation, Push("comma", "type")}, {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("#pop", "type-struct-sep", "type", "colon")}, Include("class-body"), }, "type-struct-sep": { Include("spaces"), {`\}`, Punctuation, Pop(1)}, {`,`, Punctuation, Push("#pop", "type-struct")}, }, "type-param-type": { {`\.[0-9]+`, LiteralNumberFloat, Pop(1)}, {`[0-9]+[eE][+\-]?[0-9]+`, LiteralNumberFloat, Pop(1)}, {`[0-9]+\.[0-9]*[eE][+\-]?[0-9]+`, LiteralNumberFloat, Pop(1)}, {`[0-9]+\.[0-9]+`, LiteralNumberFloat, Pop(1)}, {`[0-9]+\.(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)|\.\.)`, LiteralNumberFloat, Pop(1)}, {`0x[0-9a-fA-F]+`, LiteralNumberHex, Pop(1)}, {`[0-9]+`, LiteralNumberInteger, Pop(1)}, {`'`, LiteralStringSingle, Push("#pop", "string-single")}, {`"`, LiteralStringDouble, Push("#pop", "string-double")}, {`~/(\\\\|\\/|[^/\n])*/[gim]*`, LiteralStringRegex, Pop(1)}, {`\[`, Operator, Push("#pop", "array-decl")}, Include("type"), }, "type-param": { Include("spaces"), Default(Pop(1), Push("type-param-sep"), Push("type-param-type")), }, "type-param-sep": { Include("spaces"), {`>`, Punctuation, Pop(1)}, {`,`, Punctuation, Push("#pop", "type-param")}, }, "type-param-constraint": { Include("spaces"), {`<(?!=)`, Punctuation, Push("#pop", "type-param-constraint-sep", "type-param-constraint-flag", "type-name")}, Default(Pop(1)), }, "type-param-constraint-sep": { Include("spaces"), {`>`, Punctuation, Pop(1)}, {`,`, Punctuation, Push("#pop", "type-param-constraint-sep", "type-param-constraint-flag", "type-name")}, }, "type-param-constraint-flag": { Include("spaces"), {`:`, Punctuation, Push("#pop", "type-param-constraint-flag-type")}, Default(Pop(1)), }, "type-param-constraint-flag-type": { Include("spaces"), {`\(`, Punctuation, Push("#pop", "type-param-constraint-flag-type-sep", "type")}, Default(Pop(1), Push("type")), }, "type-param-constraint-flag-type-sep": { Include("spaces"), {`\)`, Punctuation, Pop(1)}, {`,`, Punctuation, Push("type")}, }, "parenthesis": { Include("spaces"), Default(Pop(1), Push("parenthesis-close"), Push("flag"), Push("expr")), }, "parenthesis-open": { Include("spaces"), {`\(`, Punctuation, Pop(1)}, }, "parenthesis-close": { Include("spaces"), {`\)`, Punctuation, Pop(1)}, }, "var": { Include("spaces"), {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Text, Push("#pop", "var-sep", "assign", "flag", "prop-get-set")}, }, "var-sep": { Include("spaces"), {`,`, Punctuation, Push("#pop", "var")}, Default(Pop(1)), }, "assign": { Include("spaces"), {`=`, Operator, Push("#pop", "expr")}, Default(Pop(1)), }, "flag": { Include("spaces"), {`:`, Punctuation, Push("#pop", "type")}, Default(Pop(1)), }, "ternary": { Include("spaces"), {`:`, Operator, Pop(1)}, }, "call": { Include("spaces"), {`\)`, Punctuation, Pop(1)}, Default(Pop(1), Push("call-sep"), Push("expr")), }, "call-sep": { Include("spaces"), {`\)`, Punctuation, Pop(1)}, {`,`, Punctuation, Push("#pop", "call")}, }, "bracket": { Include("spaces"), {`(?!(?:\$\s*[a-z]\b|\$(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+))))(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("#pop", "bracket-check")}, {`'`, LiteralStringSingle, Push("#pop", "bracket-check", "string-single")}, {`"`, LiteralStringDouble, Push("#pop", "bracket-check", "string-double")}, Default(Pop(1), Push("block")), }, "bracket-check": { Include("spaces"), {`:`, Punctuation, Push("#pop", "object-sep", "expr")}, Default(Pop(1), Push("block"), Push("optional-semicolon"), Push("expr-chain")), }, "block": { Include("spaces"), {`\}`, Punctuation, Pop(1)}, Default(Push("expr-statement")), }, "object": { Include("spaces"), {`\}`, Punctuation, Pop(1)}, Default(Pop(1), Push("object-sep"), Push("expr"), Push("colon"), Push("ident-or-string")), }, "ident-or-string": { Include("spaces"), {`(?!(?:function|class|static|var|if|else|while|do|for|break|return|continue|extends|implements|import|switch|case|default|public|private|try|untyped|catch|new|this|throw|extern|enum|in|interface|cast|override|dynamic|typedef|package|inline|using|null|true|false|abstract)\b)(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Pop(1)}, {`'`, LiteralStringSingle, Push("#pop", "string-single")}, {`"`, LiteralStringDouble, Push("#pop", "string-double")}, }, "object-sep": { Include("spaces"), {`\}`, Punctuation, Pop(1)}, {`,`, Punctuation, Push("#pop", "object")}, }, } } func haxePreProcMutator(state *LexerState) error { stack, ok := state.Get("haxe-pre-proc").([][]string) if !ok { stack = [][]string{} } proc := state.Groups[2] switch proc { case "if": stack = append(stack, state.Stack) case "else", "elseif": if len(stack) > 0 { state.Stack = stack[len(stack)-1] } case "end": if len(stack) > 0 { stack = stack[:len(stack)-1] } } if proc == "if" || proc == "elseif" { state.Stack = append(state.Stack, "preproc-expr") } if proc == "error" { state.Stack = append(state.Stack, "preproc-error") } state.Set("haxe-pre-proc", stack) return nil }