1package h
2
3import (
4 . "github.com/alecthomas/chroma" // nolint
5 "github.com/alecthomas/chroma/lexers/internal"
6)
7
8// Haxe lexer.
9var Haxe = internal.Register(MustNewLexer(
10 &Config{
11 Name: "Haxe",
12 Aliases: []string{"hx", "haxe", "hxsl"},
13 Filenames: []string{"*.hx", "*.hxsl"},
14 MimeTypes: []string{"text/haxe", "text/x-haxe", "text/x-hx"},
15 DotAll: true,
16 },
17 Rules{
18 "root": {
19 Include("spaces"),
20 Include("meta"),
21 {`(?:package)\b`, KeywordNamespace, Push("semicolon", "package")},
22 {`(?:import)\b`, KeywordNamespace, Push("semicolon", "import")},
23 {`(?:using)\b`, KeywordNamespace, Push("semicolon", "using")},
24 {`(?:extern|private)\b`, KeywordDeclaration, nil},
25 {`(?:abstract)\b`, KeywordDeclaration, Push("abstract")},
26 {`(?:class|interface)\b`, KeywordDeclaration, Push("class")},
27 {`(?:enum)\b`, KeywordDeclaration, Push("enum")},
28 {`(?:typedef)\b`, KeywordDeclaration, Push("typedef")},
29 {`(?=.)`, Text, Push("expr-statement")},
30 },
31 "spaces": {
32 {`\s+`, Text, nil},
33 {`//[^\n\r]*`, CommentSingle, nil},
34 {`/\*.*?\*/`, CommentMultiline, nil},
35 {`(#)(if|elseif|else|end|error)\b`, CommentPreproc, MutatorFunc(haxePreProcMutator)},
36 },
37 "string-single-interpol": {
38 {`\$\{`, LiteralStringInterpol, Push("string-interpol-close", "expr")},
39 {`\$\$`, LiteralStringEscape, nil},
40 {`\$(?=(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+))`, LiteralStringInterpol, Push("ident")},
41 Include("string-single"),
42 },
43 "string-single": {
44 {`'`, LiteralStringSingle, Pop(1)},
45 {`\\.`, LiteralStringEscape, nil},
46 {`.`, LiteralStringSingle, nil},
47 },
48 "string-double": {
49 {`"`, LiteralStringDouble, Pop(1)},
50 {`\\.`, LiteralStringEscape, nil},
51 {`.`, LiteralStringDouble, nil},
52 },
53 "string-interpol-close": {
54 {`\$(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, LiteralStringInterpol, nil},
55 {`\}`, LiteralStringInterpol, Pop(1)},
56 },
57 "package": {
58 Include("spaces"),
59 {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameNamespace, nil},
60 {`\.`, Punctuation, Push("import-ident")},
61 Default(Pop(1)),
62 },
63 "import": {
64 Include("spaces"),
65 {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameNamespace, nil},
66 {`\*`, Keyword, nil},
67 {`\.`, Punctuation, Push("import-ident")},
68 {`in`, KeywordNamespace, Push("ident")},
69 Default(Pop(1)),
70 },
71 "import-ident": {
72 Include("spaces"),
73 {`\*`, Keyword, Pop(1)},
74 {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameNamespace, Pop(1)},
75 },
76 "using": {
77 Include("spaces"),
78 {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameNamespace, nil},
79 {`\.`, Punctuation, Push("import-ident")},
80 Default(Pop(1)),
81 },
82 "preproc-error": {
83 {`\s+`, CommentPreproc, nil},
84 {`'`, LiteralStringSingle, Push("#pop", "string-single")},
85 {`"`, LiteralStringDouble, Push("#pop", "string-double")},
86 Default(Pop(1)),
87 },
88 "preproc-expr": {
89 {`\s+`, CommentPreproc, nil},
90 {`\!`, CommentPreproc, nil},
91 {`\(`, CommentPreproc, Push("#pop", "preproc-parenthesis")},
92 {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, CommentPreproc, Pop(1)},
93 {`\.[0-9]+`, LiteralNumberFloat, nil},
94 {`[0-9]+[eE][+\-]?[0-9]+`, LiteralNumberFloat, nil},
95 {`[0-9]+\.[0-9]*[eE][+\-]?[0-9]+`, LiteralNumberFloat, nil},
96 {`[0-9]+\.[0-9]+`, LiteralNumberFloat, nil},
97 {`[0-9]+\.(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)|\.\.)`, LiteralNumberFloat, nil},
98 {`0x[0-9a-fA-F]+`, LiteralNumberHex, nil},
99 {`[0-9]+`, LiteralNumberInteger, nil},
100 {`'`, LiteralStringSingle, Push("#pop", "string-single")},
101 {`"`, LiteralStringDouble, Push("#pop", "string-double")},
102 },
103 "preproc-parenthesis": {
104 {`\s+`, CommentPreproc, nil},
105 {`\)`, CommentPreproc, Pop(1)},
106 Default(Push("preproc-expr-in-parenthesis")),
107 },
108 "preproc-expr-chain": {
109 {`\s+`, CommentPreproc, nil},
110 {`(?:%=|&=|\|=|\^=|\+=|\-=|\*=|/=|<<=|>\s*>\s*=|>\s*>\s*>\s*=|==|!=|<=|>\s*=|&&|\|\||<<|>>>|>\s*>|\.\.\.|<|>|%|&|\||\^|\+|\*|/|\-|=>|=)`, CommentPreproc, Push("#pop", "preproc-expr-in-parenthesis")},
111 Default(Pop(1)),
112 },
113 "preproc-expr-in-parenthesis": {
114 {`\s+`, CommentPreproc, nil},
115 {`\!`, CommentPreproc, nil},
116 {`\(`, CommentPreproc, Push("#pop", "preproc-expr-chain", "preproc-parenthesis")},
117 {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, CommentPreproc, Push("#pop", "preproc-expr-chain")},
118 {`\.[0-9]+`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")},
119 {`[0-9]+[eE][+\-]?[0-9]+`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")},
120 {`[0-9]+\.[0-9]*[eE][+\-]?[0-9]+`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")},
121 {`[0-9]+\.[0-9]+`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")},
122 {`[0-9]+\.(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)|\.\.)`, LiteralNumberFloat, Push("#pop", "preproc-expr-chain")},
123 {`0x[0-9a-fA-F]+`, LiteralNumberHex, Push("#pop", "preproc-expr-chain")},
124 {`[0-9]+`, LiteralNumberInteger, Push("#pop", "preproc-expr-chain")},
125 {`'`, LiteralStringSingle, Push("#pop", "preproc-expr-chain", "string-single")},
126 {`"`, LiteralStringDouble, Push("#pop", "preproc-expr-chain", "string-double")},
127 },
128 "abstract": {
129 Include("spaces"),
130 Default(Pop(1), Push("abstract-body"), Push("abstract-relation"), Push("abstract-opaque"), Push("type-param-constraint"), Push("type-name")),
131 },
132 "abstract-body": {
133 Include("spaces"),
134 {`\{`, Punctuation, Push("#pop", "class-body")},
135 },
136 "abstract-opaque": {
137 Include("spaces"),
138 {`\(`, Punctuation, Push("#pop", "parenthesis-close", "type")},
139 Default(Pop(1)),
140 },
141 "abstract-relation": {
142 Include("spaces"),
143 {`(?:to|from)`, KeywordDeclaration, Push("type")},
144 {`,`, Punctuation, nil},
145 Default(Pop(1)),
146 },
147 "meta": {
148 Include("spaces"),
149 {`@`, NameDecorator, Push("meta-body", "meta-ident", "meta-colon")},
150 },
151 "meta-colon": {
152 Include("spaces"),
153 {`:`, NameDecorator, Pop(1)},
154 Default(Pop(1)),
155 },
156 "meta-ident": {
157 Include("spaces"),
158 {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameDecorator, Pop(1)},
159 },
160 "meta-body": {
161 Include("spaces"),
162 {`\(`, NameDecorator, Push("#pop", "meta-call")},
163 Default(Pop(1)),
164 },
165 "meta-call": {
166 Include("spaces"),
167 {`\)`, NameDecorator, Pop(1)},
168 Default(Pop(1), Push("meta-call-sep"), Push("expr")),
169 },
170 "meta-call-sep": {
171 Include("spaces"),
172 {`\)`, NameDecorator, Pop(1)},
173 {`,`, Punctuation, Push("#pop", "meta-call")},
174 },
175 "typedef": {
176 Include("spaces"),
177 Default(Pop(1), Push("typedef-body"), Push("type-param-constraint"), Push("type-name")),
178 },
179 "typedef-body": {
180 Include("spaces"),
181 {`=`, Operator, Push("#pop", "optional-semicolon", "type")},
182 },
183 "enum": {
184 Include("spaces"),
185 Default(Pop(1), Push("enum-body"), Push("bracket-open"), Push("type-param-constraint"), Push("type-name")),
186 },
187 "enum-body": {
188 Include("spaces"),
189 Include("meta"),
190 {`\}`, Punctuation, Pop(1)},
191 {`(?!(?: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")},
192 },
193 "enum-member": {
194 Include("spaces"),
195 {`\(`, Punctuation, Push("#pop", "semicolon", "flag", "function-param")},
196 Default(Pop(1), Push("semicolon"), Push("flag")),
197 },
198 "class": {
199 Include("spaces"),
200 Default(Pop(1), Push("class-body"), Push("bracket-open"), Push("extends"), Push("type-param-constraint"), Push("type-name")),
201 },
202 "extends": {
203 Include("spaces"),
204 {`(?:extends|implements)\b`, KeywordDeclaration, Push("type")},
205 {`,`, Punctuation, nil},
206 Default(Pop(1)),
207 },
208 "bracket-open": {
209 Include("spaces"),
210 {`\{`, Punctuation, Pop(1)},
211 },
212 "bracket-close": {
213 Include("spaces"),
214 {`\}`, Punctuation, Pop(1)},
215 },
216 "class-body": {
217 Include("spaces"),
218 Include("meta"),
219 {`\}`, Punctuation, Pop(1)},
220 {`(?:static|public|private|override|dynamic|inline|macro)\b`, KeywordDeclaration, nil},
221 Default(Push("class-member")),
222 },
223 "class-member": {
224 Include("spaces"),
225 {`(var)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "var")},
226 {`(function)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "class-method")},
227 },
228 "function-local": {
229 Include("spaces"),
230 {`(?!(?: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")},
231 Default(Pop(1), Push("optional-expr"), Push("flag"), Push("function-param"), Push("parenthesis-open"), Push("type-param-constraint")),
232 },
233 "optional-expr": {
234 Include("spaces"),
235 Include("expr"),
236 Default(Pop(1)),
237 },
238 "class-method": {
239 Include("spaces"),
240 {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, NameFunction, Push("#pop", "optional-expr", "flag", "function-param", "parenthesis-open", "type-param-constraint")},
241 },
242 "function-param": {
243 Include("spaces"),
244 {`\)`, Punctuation, Pop(1)},
245 {`\?`, Punctuation, nil},
246 {`(?!(?: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")},
247 },
248 "function-param-sep": {
249 Include("spaces"),
250 {`\)`, Punctuation, Pop(1)},
251 {`,`, Punctuation, Push("#pop", "function-param")},
252 },
253 "prop-get-set": {
254 Include("spaces"),
255 {`\(`, Punctuation, Push("#pop", "parenthesis-close", "prop-get-set-opt", "comma", "prop-get-set-opt")},
256 Default(Pop(1)),
257 },
258 "prop-get-set-opt": {
259 Include("spaces"),
260 {`(?:default|null|never|dynamic|get|set)\b`, Keyword, Pop(1)},
261 {`(?!(?: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)},
262 },
263 "expr-statement": {
264 Include("spaces"),
265 Default(Pop(1), Push("optional-semicolon"), Push("expr")),
266 },
267 "expr": {
268 Include("spaces"),
269 {`@`, NameDecorator, Push("#pop", "optional-expr", "meta-body", "meta-ident", "meta-colon")},
270 {`(?:\+\+|\-\-|~(?!/)|!|\-)`, Operator, nil},
271 {`\(`, Punctuation, Push("#pop", "expr-chain", "parenthesis")},
272 {`(?:static|public|private|override|dynamic|inline)\b`, KeywordDeclaration, nil},
273 {`(?:function)\b`, KeywordDeclaration, Push("#pop", "expr-chain", "function-local")},
274 {`\{`, Punctuation, Push("#pop", "expr-chain", "bracket")},
275 {`(?:true|false|null)\b`, KeywordConstant, Push("#pop", "expr-chain")},
276 {`(?:this)\b`, Keyword, Push("#pop", "expr-chain")},
277 {`(?:cast)\b`, Keyword, Push("#pop", "expr-chain", "cast")},
278 {`(?:try)\b`, Keyword, Push("#pop", "catch", "expr")},
279 {`(?:var)\b`, KeywordDeclaration, Push("#pop", "var")},
280 {`(?:new)\b`, Keyword, Push("#pop", "expr-chain", "new")},
281 {`(?:switch)\b`, Keyword, Push("#pop", "switch")},
282 {`(?:if)\b`, Keyword, Push("#pop", "if")},
283 {`(?:do)\b`, Keyword, Push("#pop", "do")},
284 {`(?:while)\b`, Keyword, Push("#pop", "while")},
285 {`(?:for)\b`, Keyword, Push("#pop", "for")},
286 {`(?:untyped|throw)\b`, Keyword, nil},
287 {`(?:return)\b`, Keyword, Push("#pop", "optional-expr")},
288 {`(?:macro)\b`, Keyword, Push("#pop", "macro")},
289 {`(?:continue|break)\b`, Keyword, Pop(1)},
290 {`(?:\$\s*[a-z]\b|\$(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)))`, Name, Push("#pop", "dollar")},
291 {`(?!(?: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")},
292 {`\.[0-9]+`, LiteralNumberFloat, Push("#pop", "expr-chain")},
293 {`[0-9]+[eE][+\-]?[0-9]+`, LiteralNumberFloat, Push("#pop", "expr-chain")},
294 {`[0-9]+\.[0-9]*[eE][+\-]?[0-9]+`, LiteralNumberFloat, Push("#pop", "expr-chain")},
295 {`[0-9]+\.[0-9]+`, LiteralNumberFloat, Push("#pop", "expr-chain")},
296 {`[0-9]+\.(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)|\.\.)`, LiteralNumberFloat, Push("#pop", "expr-chain")},
297 {`0x[0-9a-fA-F]+`, LiteralNumberHex, Push("#pop", "expr-chain")},
298 {`[0-9]+`, LiteralNumberInteger, Push("#pop", "expr-chain")},
299 {`'`, LiteralStringSingle, Push("#pop", "expr-chain", "string-single-interpol")},
300 {`"`, LiteralStringDouble, Push("#pop", "expr-chain", "string-double")},
301 {`~/(\\\\|\\/|[^/\n])*/[gimsu]*`, LiteralStringRegex, Push("#pop", "expr-chain")},
302 {`\[`, Punctuation, Push("#pop", "expr-chain", "array-decl")},
303 },
304 "expr-chain": {
305 Include("spaces"),
306 {`(?:\+\+|\-\-)`, Operator, nil},
307 {`(?:%=|&=|\|=|\^=|\+=|\-=|\*=|/=|<<=|>\s*>\s*=|>\s*>\s*>\s*=|==|!=|<=|>\s*=|&&|\|\||<<|>>>|>\s*>|\.\.\.|<|>|%|&|\||\^|\+|\*|/|\-|=>|=)`, Operator, Push("#pop", "expr")},
308 {`(?:in)\b`, Keyword, Push("#pop", "expr")},
309 {`\?`, Operator, Push("#pop", "expr", "ternary", "expr")},
310 {`(\.)((?!(?: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},
311 {`\[`, Punctuation, Push("array-access")},
312 {`\(`, Punctuation, Push("call")},
313 Default(Pop(1)),
314 },
315 "macro": {
316 Include("spaces"),
317 Include("meta"),
318 {`:`, Punctuation, Push("#pop", "type")},
319 {`(?:extern|private)\b`, KeywordDeclaration, nil},
320 {`(?:abstract)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "abstract")},
321 {`(?:class|interface)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "macro-class")},
322 {`(?:enum)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "enum")},
323 {`(?:typedef)\b`, KeywordDeclaration, Push("#pop", "optional-semicolon", "typedef")},
324 Default(Pop(1), Push("expr")),
325 },
326 "macro-class": {
327 {`\{`, Punctuation, Push("#pop", "class-body")},
328 Include("class"),
329 },
330 "cast": {
331 Include("spaces"),
332 {`\(`, Punctuation, Push("#pop", "parenthesis-close", "cast-type", "expr")},
333 Default(Pop(1), Push("expr")),
334 },
335 "cast-type": {
336 Include("spaces"),
337 {`,`, Punctuation, Push("#pop", "type")},
338 Default(Pop(1)),
339 },
340 "catch": {
341 Include("spaces"),
342 {`(?:catch)\b`, Keyword, Push("expr", "function-param", "parenthesis-open")},
343 Default(Pop(1)),
344 },
345 "do": {
346 Include("spaces"),
347 Default(Pop(1), Push("do-while"), Push("expr")),
348 },
349 "do-while": {
350 Include("spaces"),
351 {`(?:while)\b`, Keyword, Push("#pop", "parenthesis", "parenthesis-open")},
352 },
353 "while": {
354 Include("spaces"),
355 {`\(`, Punctuation, Push("#pop", "expr", "parenthesis")},
356 },
357 "for": {
358 Include("spaces"),
359 {`\(`, Punctuation, Push("#pop", "expr", "parenthesis")},
360 },
361 "if": {
362 Include("spaces"),
363 {`\(`, Punctuation, Push("#pop", "else", "optional-semicolon", "expr", "parenthesis")},
364 },
365 "else": {
366 Include("spaces"),
367 {`(?:else)\b`, Keyword, Push("#pop", "expr")},
368 Default(Pop(1)),
369 },
370 "switch": {
371 Include("spaces"),
372 Default(Pop(1), Push("switch-body"), Push("bracket-open"), Push("expr")),
373 },
374 "switch-body": {
375 Include("spaces"),
376 {`(?:case|default)\b`, Keyword, Push("case-block", "case")},
377 {`\}`, Punctuation, Pop(1)},
378 },
379 "case": {
380 Include("spaces"),
381 {`:`, Punctuation, Pop(1)},
382 Default(Pop(1), Push("case-sep"), Push("case-guard"), Push("expr")),
383 },
384 "case-sep": {
385 Include("spaces"),
386 {`:`, Punctuation, Pop(1)},
387 {`,`, Punctuation, Push("#pop", "case")},
388 },
389 "case-guard": {
390 Include("spaces"),
391 {`(?:if)\b`, Keyword, Push("#pop", "parenthesis", "parenthesis-open")},
392 Default(Pop(1)),
393 },
394 "case-block": {
395 Include("spaces"),
396 {`(?!(?:case|default)\b|\})`, Keyword, Push("expr-statement")},
397 Default(Pop(1)),
398 },
399 "new": {
400 Include("spaces"),
401 Default(Pop(1), Push("call"), Push("parenthesis-open"), Push("type")),
402 },
403 "array-decl": {
404 Include("spaces"),
405 {`\]`, Punctuation, Pop(1)},
406 Default(Pop(1), Push("array-decl-sep"), Push("expr")),
407 },
408 "array-decl-sep": {
409 Include("spaces"),
410 {`\]`, Punctuation, Pop(1)},
411 {`,`, Punctuation, Push("#pop", "array-decl")},
412 },
413 "array-access": {
414 Include("spaces"),
415 Default(Pop(1), Push("array-access-close"), Push("expr")),
416 },
417 "array-access-close": {
418 Include("spaces"),
419 {`\]`, Punctuation, Pop(1)},
420 },
421 "comma": {
422 Include("spaces"),
423 {`,`, Punctuation, Pop(1)},
424 },
425 "colon": {
426 Include("spaces"),
427 {`:`, Punctuation, Pop(1)},
428 },
429 "semicolon": {
430 Include("spaces"),
431 {`;`, Punctuation, Pop(1)},
432 },
433 "optional-semicolon": {
434 Include("spaces"),
435 {`;`, Punctuation, Pop(1)},
436 Default(Pop(1)),
437 },
438 "ident": {
439 Include("spaces"),
440 {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Pop(1)},
441 },
442 "dollar": {
443 Include("spaces"),
444 {`\{`, Punctuation, Push("#pop", "expr-chain", "bracket-close", "expr")},
445 Default(Pop(1), Push("expr-chain")),
446 },
447 "type-name": {
448 Include("spaces"),
449 {`_*[A-Z]\w*`, Name, Pop(1)},
450 },
451 "type-full-name": {
452 Include("spaces"),
453 {`\.`, Punctuation, Push("ident")},
454 Default(Pop(1)),
455 },
456 "type": {
457 Include("spaces"),
458 {`\?`, Punctuation, nil},
459 {`(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)`, Name, Push("#pop", "type-check", "type-full-name")},
460 {`\{`, Punctuation, Push("#pop", "type-check", "type-struct")},
461 {`\(`, Punctuation, Push("#pop", "type-check", "type-parenthesis")},
462 },
463 "type-parenthesis": {
464 Include("spaces"),
465 Default(Pop(1), Push("parenthesis-close"), Push("type")),
466 },
467 "type-check": {
468 Include("spaces"),
469 {`->`, Punctuation, Push("#pop", "type")},
470 {`<(?!=)`, Punctuation, Push("type-param")},
471 Default(Pop(1)),
472 },
473 "type-struct": {
474 Include("spaces"),
475 {`\}`, Punctuation, Pop(1)},
476 {`\?`, Punctuation, nil},
477 {`>`, Punctuation, Push("comma", "type")},
478 {`(?!(?: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")},
479 Include("class-body"),
480 },
481 "type-struct-sep": {
482 Include("spaces"),
483 {`\}`, Punctuation, Pop(1)},
484 {`,`, Punctuation, Push("#pop", "type-struct")},
485 },
486 "type-param-type": {
487 {`\.[0-9]+`, LiteralNumberFloat, Pop(1)},
488 {`[0-9]+[eE][+\-]?[0-9]+`, LiteralNumberFloat, Pop(1)},
489 {`[0-9]+\.[0-9]*[eE][+\-]?[0-9]+`, LiteralNumberFloat, Pop(1)},
490 {`[0-9]+\.[0-9]+`, LiteralNumberFloat, Pop(1)},
491 {`[0-9]+\.(?!(?:_*[a-z]\w*|_+[0-9]\w*|_*[A-Z]\w*|_+|\$\w+)|\.\.)`, LiteralNumberFloat, Pop(1)},
492 {`0x[0-9a-fA-F]+`, LiteralNumberHex, Pop(1)},
493 {`[0-9]+`, LiteralNumberInteger, Pop(1)},
494 {`'`, LiteralStringSingle, Push("#pop", "string-single")},
495 {`"`, LiteralStringDouble, Push("#pop", "string-double")},
496 {`~/(\\\\|\\/|[^/\n])*/[gim]*`, LiteralStringRegex, Pop(1)},
497 {`\[`, Operator, Push("#pop", "array-decl")},
498 Include("type"),
499 },
500 "type-param": {
501 Include("spaces"),
502 Default(Pop(1), Push("type-param-sep"), Push("type-param-type")),
503 },
504 "type-param-sep": {
505 Include("spaces"),
506 {`>`, Punctuation, Pop(1)},
507 {`,`, Punctuation, Push("#pop", "type-param")},
508 },
509 "type-param-constraint": {
510 Include("spaces"),
511 {`<(?!=)`, Punctuation, Push("#pop", "type-param-constraint-sep", "type-param-constraint-flag", "type-name")},
512 Default(Pop(1)),
513 },
514 "type-param-constraint-sep": {
515 Include("spaces"),
516 {`>`, Punctuation, Pop(1)},
517 {`,`, Punctuation, Push("#pop", "type-param-constraint-sep", "type-param-constraint-flag", "type-name")},
518 },
519 "type-param-constraint-flag": {
520 Include("spaces"),
521 {`:`, Punctuation, Push("#pop", "type-param-constraint-flag-type")},
522 Default(Pop(1)),
523 },
524 "type-param-constraint-flag-type": {
525 Include("spaces"),
526 {`\(`, Punctuation, Push("#pop", "type-param-constraint-flag-type-sep", "type")},
527 Default(Pop(1), Push("type")),
528 },
529 "type-param-constraint-flag-type-sep": {
530 Include("spaces"),
531 {`\)`, Punctuation, Pop(1)},
532 {`,`, Punctuation, Push("type")},
533 },
534 "parenthesis": {
535 Include("spaces"),
536 Default(Pop(1), Push("parenthesis-close"), Push("flag"), Push("expr")),
537 },
538 "parenthesis-open": {
539 Include("spaces"),
540 {`\(`, Punctuation, Pop(1)},
541 },
542 "parenthesis-close": {
543 Include("spaces"),
544 {`\)`, Punctuation, Pop(1)},
545 },
546 "var": {
547 Include("spaces"),
548 {`(?!(?: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")},
549 },
550 "var-sep": {
551 Include("spaces"),
552 {`,`, Punctuation, Push("#pop", "var")},
553 Default(Pop(1)),
554 },
555 "assign": {
556 Include("spaces"),
557 {`=`, Operator, Push("#pop", "expr")},
558 Default(Pop(1)),
559 },
560 "flag": {
561 Include("spaces"),
562 {`:`, Punctuation, Push("#pop", "type")},
563 Default(Pop(1)),
564 },
565 "ternary": {
566 Include("spaces"),
567 {`:`, Operator, Pop(1)},
568 },
569 "call": {
570 Include("spaces"),
571 {`\)`, Punctuation, Pop(1)},
572 Default(Pop(1), Push("call-sep"), Push("expr")),
573 },
574 "call-sep": {
575 Include("spaces"),
576 {`\)`, Punctuation, Pop(1)},
577 {`,`, Punctuation, Push("#pop", "call")},
578 },
579 "bracket": {
580 Include("spaces"),
581 {`(?!(?:\$\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")},
582 {`'`, LiteralStringSingle, Push("#pop", "bracket-check", "string-single")},
583 {`"`, LiteralStringDouble, Push("#pop", "bracket-check", "string-double")},
584 Default(Pop(1), Push("block")),
585 },
586 "bracket-check": {
587 Include("spaces"),
588 {`:`, Punctuation, Push("#pop", "object-sep", "expr")},
589 Default(Pop(1), Push("block"), Push("optional-semicolon"), Push("expr-chain")),
590 },
591 "block": {
592 Include("spaces"),
593 {`\}`, Punctuation, Pop(1)},
594 Default(Push("expr-statement")),
595 },
596 "object": {
597 Include("spaces"),
598 {`\}`, Punctuation, Pop(1)},
599 Default(Pop(1), Push("object-sep"), Push("expr"), Push("colon"), Push("ident-or-string")),
600 },
601 "ident-or-string": {
602 Include("spaces"),
603 {`(?!(?: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)},
604 {`'`, LiteralStringSingle, Push("#pop", "string-single")},
605 {`"`, LiteralStringDouble, Push("#pop", "string-double")},
606 },
607 "object-sep": {
608 Include("spaces"),
609 {`\}`, Punctuation, Pop(1)},
610 {`,`, Punctuation, Push("#pop", "object")},
611 },
612 },
613))
614
615func haxePreProcMutator(state *LexerState) error {
616 stack, ok := state.Get("haxe-pre-proc").([][]string)
617 if !ok {
618 stack = [][]string{}
619 }
620
621 proc := state.Groups[2]
622 switch proc {
623 case "if":
624 stack = append(stack, state.Stack)
625 case "else", "elseif":
626 if len(stack) > 0 {
627 state.Stack = stack[len(stack)-1]
628 }
629 case "end":
630 stack = stack[:len(stack)-1]
631 }
632
633 if proc == "if" || proc == "elseif" {
634 state.Stack = append(state.Stack, "preproc-expr")
635 }
636
637 if proc == "error" {
638 state.Stack = append(state.Stack, "preproc-error")
639 }
640 state.Set("haxe-pre-proc", stack)
641 return nil
642}