Mercurial Repositories > eric / file comparison

comparison: ThirdParty/Pygments/pygments/lexers/haxe.py

ThirdParty/Pygments/pygments/lexers/haxe.py

changeset 4172
4f20dba37ab6
child 4697
c2e9bf425554
equal deleted inserted replaced
4170:8bc578136279 4172:4f20dba37ab6
1 # -*- coding: utf-8 -*-
2 """
3 pygments.lexers.haxe
4 ~~~~~~~~~~~~~~~~~~~~
5
6 Lexers for Haxe and related stuff.
7
8 :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
9 :license: BSD, see LICENSE for details.
10 """
11
12 import re
13
14 from pygments.lexer import ExtendedRegexLexer, RegexLexer, include, bygroups, \
15 default
16 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
17 Number, Punctuation, Generic, Whitespace
18
19 __all__ = ['HaxeLexer', 'HxmlLexer']
20
21
22 class HaxeLexer(ExtendedRegexLexer):
23 """
24 For Haxe source code (http://haxe.org/).
25
26 .. versionadded:: 1.3
27 """
28
29 name = 'Haxe'
30 aliases = ['hx', 'haxe', 'hxsl']
31 filenames = ['*.hx', '*.hxsl']
32 mimetypes = ['text/haxe', 'text/x-haxe', 'text/x-hx']
33
34 # keywords extracted from lexer.mll in the haxe compiler source
35 keyword = (r'(?:function|class|static|var|if|else|while|do|for|'
36 r'break|return|continue|extends|implements|import|'
37 r'switch|case|default|public|private|try|untyped|'
38 r'catch|new|this|throw|extern|enum|in|interface|'
39 r'cast|override|dynamic|typedef|package|'
40 r'inline|using|null|true|false|abstract)\b')
41
42 # idtype in lexer.mll
43 typeid = r'_*[A-Z]\w*'
44
45 # combined ident and dollar and idtype
46 ident = r'(?:_*[a-z]\w*|_+[0-9]\w*|' + typeid + '|_+|\$\w+)'
47
48 binop = (r'(?:%=|&=|\|=|\^=|\+=|\-=|\*=|/=|<<=|>\s*>\s*=|>\s*>\s*>\s*=|==|'
49 r'!=|<=|>\s*=|&&|\|\||<<|>>>|>\s*>|\.\.\.|<|>|%|&|\||\^|\+|\*|'
50 r'/|\-|=>|=)')
51
52 # ident except keywords
53 ident_no_keyword = r'(?!' + keyword + ')' + ident
54
55 flags = re.DOTALL | re.MULTILINE
56
57 preproc_stack = []
58
59 def preproc_callback(self, match, ctx):
60 proc = match.group(2)
61
62 if proc == 'if':
63 # store the current stack
64 self.preproc_stack.append(ctx.stack[:])
65 elif proc in ['else', 'elseif']:
66 # restore the stack back to right before #if
67 if self.preproc_stack:
68 ctx.stack = self.preproc_stack[-1][:]
69 elif proc == 'end':
70 # remove the saved stack of previous #if
71 if self.preproc_stack:
72 self.preproc_stack.pop()
73
74 # #if and #elseif should follow by an expr
75 if proc in ['if', 'elseif']:
76 ctx.stack.append('preproc-expr')
77
78 # #error can be optionally follow by the error msg
79 if proc in ['error']:
80 ctx.stack.append('preproc-error')
81
82 yield match.start(), Comment.Preproc, '#' + proc
83 ctx.pos = match.end()
84
85 tokens = {
86 'root': [
87 include('spaces'),
88 include('meta'),
89 (r'(?:package)\b', Keyword.Namespace, ('semicolon', 'package')),
90 (r'(?:import)\b', Keyword.Namespace, ('semicolon', 'import')),
91 (r'(?:using)\b', Keyword.Namespace, ('semicolon', 'using')),
92 (r'(?:extern|private)\b', Keyword.Declaration),
93 (r'(?:abstract)\b', Keyword.Declaration, 'abstract'),
94 (r'(?:class|interface)\b', Keyword.Declaration, 'class'),
95 (r'(?:enum)\b', Keyword.Declaration, 'enum'),
96 (r'(?:typedef)\b', Keyword.Declaration, 'typedef'),
97
98 # top-level expression
99 # although it is not supported in haxe, but it is common to write
100 # expression in web pages the positive lookahead here is to prevent
101 # an infinite loop at the EOF
102 (r'(?=.)', Text, 'expr-statement'),
103 ],
104
105 # space/tab/comment/preproc
106 'spaces': [
107 (r'\s+', Text),
108 (r'//[^\n\r]*', Comment.Single),
109 (r'/\*.*?\*/', Comment.Multiline),
110 (r'(#)(if|elseif|else|end|error)\b', preproc_callback),
111 ],
112
113 'string-single-interpol': [
114 (r'\$\{', String.Interpol, ('string-interpol-close', 'expr')),
115 (r'\$\$', String.Escape),
116 (r'\$(?=' + ident + ')', String.Interpol, 'ident'),
117 include('string-single'),
118 ],
119
120 'string-single': [
121 (r"'", String.Single, '#pop'),
122 (r'\\.', String.Escape),
123 (r'.', String.Single),
124 ],
125
126 'string-double': [
127 (r'"', String.Double, '#pop'),
128 (r'\\.', String.Escape),
129 (r'.', String.Double),
130 ],
131
132 'string-interpol-close': [
133 (r'\$'+ident, String.Interpol),
134 (r'\}', String.Interpol, '#pop'),
135 ],
136
137 'package': [
138 include('spaces'),
139 (ident, Name.Namespace),
140 (r'\.', Punctuation, 'import-ident'),
141 default('#pop'),
142 ],
143
144 'import': [
145 include('spaces'),
146 (ident, Name.Namespace),
147 (r'\*', Keyword), # wildcard import
148 (r'\.', Punctuation, 'import-ident'),
149 (r'in', Keyword.Namespace, 'ident'),
150 default('#pop'),
151 ],
152
153 'import-ident': [
154 include('spaces'),
155 (r'\*', Keyword, '#pop'), # wildcard import
156 (ident, Name.Namespace, '#pop'),
157 ],
158
159 'using': [
160 include('spaces'),
161 (ident, Name.Namespace),
162 (r'\.', Punctuation, 'import-ident'),
163 default('#pop'),
164 ],
165
166 'preproc-error': [
167 (r'\s+', Comment.Preproc),
168 (r"'", String.Single, ('#pop', 'string-single')),
169 (r'"', String.Double, ('#pop', 'string-double')),
170 default('#pop'),
171 ],
172
173 'preproc-expr': [
174 (r'\s+', Comment.Preproc),
175 (r'\!', Comment.Preproc),
176 (r'\(', Comment.Preproc, ('#pop', 'preproc-parenthesis')),
177
178 (ident, Comment.Preproc, '#pop'),
179
180 # Float
181 (r'\.[0-9]+', Number.Float),
182 (r'[0-9]+[eE][+\-]?[0-9]+', Number.Float),
183 (r'[0-9]+\.[0-9]*[eE][+\-]?[0-9]+', Number.Float),
184 (r'[0-9]+\.[0-9]+', Number.Float),
185 (r'[0-9]+\.(?!' + ident + '|\.\.)', Number.Float),
186
187 # Int
188 (r'0x[0-9a-fA-F]+', Number.Hex),
189 (r'[0-9]+', Number.Integer),
190
191 # String
192 (r"'", String.Single, ('#pop', 'string-single')),
193 (r'"', String.Double, ('#pop', 'string-double')),
194 ],
195
196 'preproc-parenthesis': [
197 (r'\s+', Comment.Preproc),
198 (r'\)', Comment.Preproc, '#pop'),
199 default('preproc-expr-in-parenthesis'),
200 ],
201
202 'preproc-expr-chain': [
203 (r'\s+', Comment.Preproc),
204 (binop, Comment.Preproc, ('#pop', 'preproc-expr-in-parenthesis')),
205 default('#pop'),
206 ],
207
208 # same as 'preproc-expr' but able to chain 'preproc-expr-chain'
209 'preproc-expr-in-parenthesis': [
210 (r'\s+', Comment.Preproc),
211 (r'\!', Comment.Preproc),
212 (r'\(', Comment.Preproc,
213 ('#pop', 'preproc-expr-chain', 'preproc-parenthesis')),
214
215 (ident, Comment.Preproc, ('#pop', 'preproc-expr-chain')),
216
217 # Float
218 (r'\.[0-9]+', Number.Float, ('#pop', 'preproc-expr-chain')),
219 (r'[0-9]+[eE][+\-]?[0-9]+', Number.Float, ('#pop', 'preproc-expr-chain')),
220 (r'[0-9]+\.[0-9]*[eE][+\-]?[0-9]+', Number.Float, ('#pop', 'preproc-expr-chain')),
221 (r'[0-9]+\.[0-9]+', Number.Float, ('#pop', 'preproc-expr-chain')),
222 (r'[0-9]+\.(?!' + ident + '|\.\.)', Number.Float, ('#pop', 'preproc-expr-chain')),
223
224 # Int
225 (r'0x[0-9a-fA-F]+', Number.Hex, ('#pop', 'preproc-expr-chain')),
226 (r'[0-9]+', Number.Integer, ('#pop', 'preproc-expr-chain')),
227
228 # String
229 (r"'", String.Single,
230 ('#pop', 'preproc-expr-chain', 'string-single')),
231 (r'"', String.Double,
232 ('#pop', 'preproc-expr-chain', 'string-double')),
233 ],
234
235 'abstract': [
236 include('spaces'),
237 default(('#pop', 'abstract-body', 'abstract-relation',
238 'abstract-opaque', 'type-param-constraint', 'type-name')),
239 ],
240
241 'abstract-body': [
242 include('spaces'),
243 (r'\{', Punctuation, ('#pop', 'class-body')),
244 ],
245
246 'abstract-opaque': [
247 include('spaces'),
248 (r'\(', Punctuation, ('#pop', 'parenthesis-close', 'type')),
249 default('#pop'),
250 ],
251
252 'abstract-relation': [
253 include('spaces'),
254 (r'(?:to|from)', Keyword.Declaration, 'type'),
255 (r',', Punctuation),
256 default('#pop'),
257 ],
258
259 'meta': [
260 include('spaces'),
261 (r'@', Name.Decorator, ('meta-body', 'meta-ident', 'meta-colon')),
262 ],
263
264 # optional colon
265 'meta-colon': [
266 include('spaces'),
267 (r':', Name.Decorator, '#pop'),
268 default('#pop'),
269 ],
270
271 # same as 'ident' but set token as Name.Decorator instead of Name
272 'meta-ident': [
273 include('spaces'),
274 (ident, Name.Decorator, '#pop'),
275 ],
276
277 'meta-body': [
278 include('spaces'),
279 (r'\(', Name.Decorator, ('#pop', 'meta-call')),
280 default('#pop'),
281 ],
282
283 'meta-call': [
284 include('spaces'),
285 (r'\)', Name.Decorator, '#pop'),
286 default(('#pop', 'meta-call-sep', 'expr')),
287 ],
288
289 'meta-call-sep': [
290 include('spaces'),
291 (r'\)', Name.Decorator, '#pop'),
292 (r',', Punctuation, ('#pop', 'meta-call')),
293 ],
294
295 'typedef': [
296 include('spaces'),
297 default(('#pop', 'typedef-body', 'type-param-constraint',
298 'type-name')),
299 ],
300
301 'typedef-body': [
302 include('spaces'),
303 (r'=', Operator, ('#pop', 'optional-semicolon', 'type')),
304 ],
305
306 'enum': [
307 include('spaces'),
308 default(('#pop', 'enum-body', 'bracket-open',
309 'type-param-constraint', 'type-name')),
310 ],
311
312 'enum-body': [
313 include('spaces'),
314 include('meta'),
315 (r'\}', Punctuation, '#pop'),
316 (ident_no_keyword, Name, ('enum-member', 'type-param-constraint')),
317 ],
318
319 'enum-member': [
320 include('spaces'),
321 (r'\(', Punctuation,
322 ('#pop', 'semicolon', 'flag', 'function-param')),
323 default(('#pop', 'semicolon', 'flag')),
324 ],
325
326 'class': [
327 include('spaces'),
328 default(('#pop', 'class-body', 'bracket-open', 'extends',
329 'type-param-constraint', 'type-name')),
330 ],
331
332 'extends': [
333 include('spaces'),
334 (r'(?:extends|implements)\b', Keyword.Declaration, 'type'),
335 (r',', Punctuation), # the comma is made optional here, since haxe2
336 # requires the comma but haxe3 does not allow it
337 default('#pop'),
338 ],
339
340 'bracket-open': [
341 include('spaces'),
342 (r'\{', Punctuation, '#pop'),
343 ],
344
345 'bracket-close': [
346 include('spaces'),
347 (r'\}', Punctuation, '#pop'),
348 ],
349
350 'class-body': [
351 include('spaces'),
352 include('meta'),
353 (r'\}', Punctuation, '#pop'),
354 (r'(?:static|public|private|override|dynamic|inline|macro)\b',
355 Keyword.Declaration),
356 default('class-member'),
357 ],
358
359 'class-member': [
360 include('spaces'),
361 (r'(var)\b', Keyword.Declaration,
362 ('#pop', 'optional-semicolon', 'var')),
363 (r'(function)\b', Keyword.Declaration,
364 ('#pop', 'optional-semicolon', 'class-method')),
365 ],
366
367 # local function, anonymous or not
368 'function-local': [
369 include('spaces'),
370 (ident_no_keyword, Name.Function,
371 ('#pop', 'optional-expr', 'flag', 'function-param',
372 'parenthesis-open', 'type-param-constraint')),
373 default(('#pop', 'optional-expr', 'flag', 'function-param',
374 'parenthesis-open', 'type-param-constraint')),
375 ],
376
377 'optional-expr': [
378 include('spaces'),
379 include('expr'),
380 default('#pop'),
381 ],
382
383 'class-method': [
384 include('spaces'),
385 (ident, Name.Function, ('#pop', 'optional-expr', 'flag',
386 'function-param', 'parenthesis-open',
387 'type-param-constraint')),
388 ],
389
390 # function arguments
391 'function-param': [
392 include('spaces'),
393 (r'\)', Punctuation, '#pop'),
394 (r'\?', Punctuation),
395 (ident_no_keyword, Name,
396 ('#pop', 'function-param-sep', 'assign', 'flag')),
397 ],
398
399 'function-param-sep': [
400 include('spaces'),
401 (r'\)', Punctuation, '#pop'),
402 (r',', Punctuation, ('#pop', 'function-param')),
403 ],
404
405 'prop-get-set': [
406 include('spaces'),
407 (r'\(', Punctuation, ('#pop', 'parenthesis-close',
408 'prop-get-set-opt', 'comma', 'prop-get-set-opt')),
409 default('#pop'),
410 ],
411
412 'prop-get-set-opt': [
413 include('spaces'),
414 (r'(?:default|null|never|dynamic|get|set)\b', Keyword, '#pop'),
415 (ident_no_keyword, Text, '#pop'), # custom getter/setter
416 ],
417
418 'expr-statement': [
419 include('spaces'),
420 # makes semicolon optional here, just to avoid checking the last
421 # one is bracket or not.
422 default(('#pop', 'optional-semicolon', 'expr')),
423 ],
424
425 'expr': [
426 include('spaces'),
427 (r'@', Name.Decorator, ('#pop', 'optional-expr', 'meta-body',
428 'meta-ident', 'meta-colon')),
429 (r'(?:\+\+|\-\-|~(?!/)|!|\-)', Operator),
430 (r'\(', Punctuation, ('#pop', 'expr-chain', 'parenthesis')),
431 (r'(?:static|public|private|override|dynamic|inline)\b',
432 Keyword.Declaration),
433 (r'(?:function)\b', Keyword.Declaration, ('#pop', 'expr-chain',
434 'function-local')),
435 (r'\{', Punctuation, ('#pop', 'expr-chain', 'bracket')),
436 (r'(?:true|false|null)\b', Keyword.Constant, ('#pop', 'expr-chain')),
437 (r'(?:this)\b', Keyword, ('#pop', 'expr-chain')),
438 (r'(?:cast)\b', Keyword, ('#pop', 'expr-chain', 'cast')),
439 (r'(?:try)\b', Keyword, ('#pop', 'catch', 'expr')),
440 (r'(?:var)\b', Keyword.Declaration, ('#pop', 'var')),
441 (r'(?:new)\b', Keyword, ('#pop', 'expr-chain', 'new')),
442 (r'(?:switch)\b', Keyword, ('#pop', 'switch')),
443 (r'(?:if)\b', Keyword, ('#pop', 'if')),
444 (r'(?:do)\b', Keyword, ('#pop', 'do')),
445 (r'(?:while)\b', Keyword, ('#pop', 'while')),
446 (r'(?:for)\b', Keyword, ('#pop', 'for')),
447 (r'(?:untyped|throw)\b', Keyword),
448 (r'(?:return)\b', Keyword, ('#pop', 'optional-expr')),
449 (r'(?:macro)\b', Keyword, ('#pop', 'macro')),
450 (r'(?:continue|break)\b', Keyword, '#pop'),
451 (r'(?:\$\s*[a-z]\b|\$(?!'+ident+'))', Name, ('#pop', 'dollar')),
452 (ident_no_keyword, Name, ('#pop', 'expr-chain')),
453
454 # Float
455 (r'\.[0-9]+', Number.Float, ('#pop', 'expr-chain')),
456 (r'[0-9]+[eE][+\-]?[0-9]+', Number.Float, ('#pop', 'expr-chain')),
457 (r'[0-9]+\.[0-9]*[eE][+\-]?[0-9]+', Number.Float, ('#pop', 'expr-chain')),
458 (r'[0-9]+\.[0-9]+', Number.Float, ('#pop', 'expr-chain')),
459 (r'[0-9]+\.(?!' + ident + '|\.\.)', Number.Float, ('#pop', 'expr-chain')),
460
461 # Int
462 (r'0x[0-9a-fA-F]+', Number.Hex, ('#pop', 'expr-chain')),
463 (r'[0-9]+', Number.Integer, ('#pop', 'expr-chain')),
464
465 # String
466 (r"'", String.Single, ('#pop', 'expr-chain', 'string-single-interpol')),
467 (r'"', String.Double, ('#pop', 'expr-chain', 'string-double')),
468
469 # EReg
470 (r'~/(\\\\|\\/|[^/\n])*/[gimsu]*', String.Regex, ('#pop', 'expr-chain')),
471
472 # Array
473 (r'\[', Punctuation, ('#pop', 'expr-chain', 'array-decl')),
474 ],
475
476 'expr-chain': [
477 include('spaces'),
478 (r'(?:\+\+|\-\-)', Operator),
479 (binop, Operator, ('#pop', 'expr')),
480 (r'(?:in)\b', Keyword, ('#pop', 'expr')),
481 (r'\?', Operator, ('#pop', 'expr', 'ternary', 'expr')),
482 (r'(\.)(' + ident_no_keyword + ')', bygroups(Punctuation, Name)),
483 (r'\[', Punctuation, 'array-access'),
484 (r'\(', Punctuation, 'call'),
485 default('#pop'),
486 ],
487
488 # macro reification
489 'macro': [
490 include('spaces'),
491 include('meta'),
492 (r':', Punctuation, ('#pop', 'type')),
493
494 (r'(?:extern|private)\b', Keyword.Declaration),
495 (r'(?:abstract)\b', Keyword.Declaration, ('#pop', 'optional-semicolon', 'abstract')),
496 (r'(?:class|interface)\b', Keyword.Declaration, ('#pop', 'optional-semicolon', 'macro-class')),
497 (r'(?:enum)\b', Keyword.Declaration, ('#pop', 'optional-semicolon', 'enum')),
498 (r'(?:typedef)\b', Keyword.Declaration, ('#pop', 'optional-semicolon', 'typedef')),
499
500 default(('#pop', 'expr')),
501 ],
502
503 'macro-class': [
504 (r'\{', Punctuation, ('#pop', 'class-body')),
505 include('class')
506 ],
507
508 # cast can be written as "cast expr" or "cast(expr, type)"
509 'cast': [
510 include('spaces'),
511 (r'\(', Punctuation, ('#pop', 'parenthesis-close',
512 'cast-type', 'expr')),
513 default(('#pop', 'expr')),
514 ],
515
516 # optionally give a type as the 2nd argument of cast()
517 'cast-type': [
518 include('spaces'),
519 (r',', Punctuation, ('#pop', 'type')),
520 default('#pop'),
521 ],
522
523 'catch': [
524 include('spaces'),
525 (r'(?:catch)\b', Keyword, ('expr', 'function-param',
526 'parenthesis-open')),
527 default('#pop'),
528 ],
529
530 # do-while loop
531 'do': [
532 include('spaces'),
533 default(('#pop', 'do-while', 'expr')),
534 ],
535
536 # the while after do
537 'do-while': [
538 include('spaces'),
539 (r'(?:while)\b', Keyword, ('#pop', 'parenthesis',
540 'parenthesis-open')),
541 ],
542
543 'while': [
544 include('spaces'),
545 (r'\(', Punctuation, ('#pop', 'expr', 'parenthesis')),
546 ],
547
548 'for': [
549 include('spaces'),
550 (r'\(', Punctuation, ('#pop', 'expr', 'parenthesis')),
551 ],
552
553 'if': [
554 include('spaces'),
555 (r'\(', Punctuation, ('#pop', 'else', 'optional-semicolon', 'expr',
556 'parenthesis')),
557 ],
558
559 'else': [
560 include('spaces'),
561 (r'(?:else)\b', Keyword, ('#pop', 'expr')),
562 default('#pop'),
563 ],
564
565 'switch': [
566 include('spaces'),
567 default(('#pop', 'switch-body', 'bracket-open', 'expr')),
568 ],
569
570 'switch-body': [
571 include('spaces'),
572 (r'(?:case|default)\b', Keyword, ('case-block', 'case')),
573 (r'\}', Punctuation, '#pop'),
574 ],
575
576 'case': [
577 include('spaces'),
578 (r':', Punctuation, '#pop'),
579 default(('#pop', 'case-sep', 'case-guard', 'expr')),
580 ],
581
582 'case-sep': [
583 include('spaces'),
584 (r':', Punctuation, '#pop'),
585 (r',', Punctuation, ('#pop', 'case')),
586 ],
587
588 'case-guard': [
589 include('spaces'),
590 (r'(?:if)\b', Keyword, ('#pop', 'parenthesis', 'parenthesis-open')),
591 default('#pop'),
592 ],
593
594 # optional multiple expr under a case
595 'case-block': [
596 include('spaces'),
597 (r'(?!(?:case|default)\b|\})', Keyword, 'expr-statement'),
598 default('#pop'),
599 ],
600
601 'new': [
602 include('spaces'),
603 default(('#pop', 'call', 'parenthesis-open', 'type')),
604 ],
605
606 'array-decl': [
607 include('spaces'),
608 (r'\]', Punctuation, '#pop'),
609 default(('#pop', 'array-decl-sep', 'expr')),
610 ],
611
612 'array-decl-sep': [
613 include('spaces'),
614 (r'\]', Punctuation, '#pop'),
615 (r',', Punctuation, ('#pop', 'array-decl')),
616 ],
617
618 'array-access': [
619 include('spaces'),
620 default(('#pop', 'array-access-close', 'expr')),
621 ],
622
623 'array-access-close': [
624 include('spaces'),
625 (r'\]', Punctuation, '#pop'),
626 ],
627
628 'comma': [
629 include('spaces'),
630 (r',', Punctuation, '#pop'),
631 ],
632
633 'colon': [
634 include('spaces'),
635 (r':', Punctuation, '#pop'),
636 ],
637
638 'semicolon': [
639 include('spaces'),
640 (r';', Punctuation, '#pop'),
641 ],
642
643 'optional-semicolon': [
644 include('spaces'),
645 (r';', Punctuation, '#pop'),
646 default('#pop'),
647 ],
648
649 # identity that CAN be a Haxe keyword
650 'ident': [
651 include('spaces'),
652 (ident, Name, '#pop'),
653 ],
654
655 'dollar': [
656 include('spaces'),
657 (r'\{', Punctuation, ('#pop', 'expr-chain', 'bracket-close', 'expr')),
658 default(('#pop', 'expr-chain')),
659 ],
660
661 'type-name': [
662 include('spaces'),
663 (typeid, Name, '#pop'),
664 ],
665
666 'type-full-name': [
667 include('spaces'),
668 (r'\.', Punctuation, 'ident'),
669 default('#pop'),
670 ],
671
672 'type': [
673 include('spaces'),
674 (r'\?', Punctuation),
675 (ident, Name, ('#pop', 'type-check', 'type-full-name')),
676 (r'\{', Punctuation, ('#pop', 'type-check', 'type-struct')),
677 (r'\(', Punctuation, ('#pop', 'type-check', 'type-parenthesis')),
678 ],
679
680 'type-parenthesis': [
681 include('spaces'),
682 default(('#pop', 'parenthesis-close', 'type')),
683 ],
684
685 'type-check': [
686 include('spaces'),
687 (r'->', Punctuation, ('#pop', 'type')),
688 (r'<(?!=)', Punctuation, 'type-param'),
689 default('#pop'),
690 ],
691
692 'type-struct': [
693 include('spaces'),
694 (r'\}', Punctuation, '#pop'),
695 (r'\?', Punctuation),
696 (r'>', Punctuation, ('comma', 'type')),
697 (ident_no_keyword, Name, ('#pop', 'type-struct-sep', 'type', 'colon')),
698 include('class-body'),
699 ],
700
701 'type-struct-sep': [
702 include('spaces'),
703 (r'\}', Punctuation, '#pop'),
704 (r',', Punctuation, ('#pop', 'type-struct')),
705 ],
706
707 # type-param can be a normal type or a constant literal...
708 'type-param-type': [
709 # Float
710 (r'\.[0-9]+', Number.Float, '#pop'),
711 (r'[0-9]+[eE][+\-]?[0-9]+', Number.Float, '#pop'),
712 (r'[0-9]+\.[0-9]*[eE][+\-]?[0-9]+', Number.Float, '#pop'),
713 (r'[0-9]+\.[0-9]+', Number.Float, '#pop'),
714 (r'[0-9]+\.(?!' + ident + '|\.\.)', Number.Float, '#pop'),
715
716 # Int
717 (r'0x[0-9a-fA-F]+', Number.Hex, '#pop'),
718 (r'[0-9]+', Number.Integer, '#pop'),
719
720 # String
721 (r"'", String.Single, ('#pop', 'string-single')),
722 (r'"', String.Double, ('#pop', 'string-double')),
723
724 # EReg
725 (r'~/(\\\\|\\/|[^/\n])*/[gim]*', String.Regex, '#pop'),
726
727 # Array
728 (r'\[', Operator, ('#pop', 'array-decl')),
729
730 include('type'),
731 ],
732
733 # type-param part of a type
734 # ie. the <A,B> path in Map<A,B>
735 'type-param': [
736 include('spaces'),
737 default(('#pop', 'type-param-sep', 'type-param-type')),
738 ],
739
740 'type-param-sep': [
741 include('spaces'),
742 (r'>', Punctuation, '#pop'),
743 (r',', Punctuation, ('#pop', 'type-param')),
744 ],
745
746 # optional type-param that may include constraint
747 # ie. <T:Constraint, T2:(ConstraintA,ConstraintB)>
748 'type-param-constraint': [
749 include('spaces'),
750 (r'<(?!=)', Punctuation, ('#pop', 'type-param-constraint-sep',
751 'type-param-constraint-flag', 'type-name')),
752 default('#pop'),
753 ],
754
755 'type-param-constraint-sep': [
756 include('spaces'),
757 (r'>', Punctuation, '#pop'),
758 (r',', Punctuation, ('#pop', 'type-param-constraint-sep',
759 'type-param-constraint-flag', 'type-name')),
760 ],
761
762 # the optional constraint inside type-param
763 'type-param-constraint-flag': [
764 include('spaces'),
765 (r':', Punctuation, ('#pop', 'type-param-constraint-flag-type')),
766 default('#pop'),
767 ],
768
769 'type-param-constraint-flag-type': [
770 include('spaces'),
771 (r'\(', Punctuation, ('#pop', 'type-param-constraint-flag-type-sep',
772 'type')),
773 default(('#pop', 'type')),
774 ],
775
776 'type-param-constraint-flag-type-sep': [
777 include('spaces'),
778 (r'\)', Punctuation, '#pop'),
779 (r',', Punctuation, 'type'),
780 ],
781
782 # a parenthesis expr that contain exactly one expr
783 'parenthesis': [
784 include('spaces'),
785 default(('#pop', 'parenthesis-close', 'flag', 'expr')),
786 ],
787
788 'parenthesis-open': [
789 include('spaces'),
790 (r'\(', Punctuation, '#pop'),
791 ],
792
793 'parenthesis-close': [
794 include('spaces'),
795 (r'\)', Punctuation, '#pop'),
796 ],
797
798 'var': [
799 include('spaces'),
800 (ident_no_keyword, Text, ('#pop', 'var-sep', 'assign', 'flag', 'prop-get-set')),
801 ],
802
803 # optional more var decl.
804 'var-sep': [
805 include('spaces'),
806 (r',', Punctuation, ('#pop', 'var')),
807 default('#pop'),
808 ],
809
810 # optional assignment
811 'assign': [
812 include('spaces'),
813 (r'=', Operator, ('#pop', 'expr')),
814 default('#pop'),
815 ],
816
817 # optional type flag
818 'flag': [
819 include('spaces'),
820 (r':', Punctuation, ('#pop', 'type')),
821 default('#pop'),
822 ],
823
824 # colon as part of a ternary operator (?:)
825 'ternary': [
826 include('spaces'),
827 (r':', Operator, '#pop'),
828 ],
829
830 # function call
831 'call': [
832 include('spaces'),
833 (r'\)', Punctuation, '#pop'),
834 default(('#pop', 'call-sep', 'expr')),
835 ],
836
837 # after a call param
838 'call-sep': [
839 include('spaces'),
840 (r'\)', Punctuation, '#pop'),
841 (r',', Punctuation, ('#pop', 'call')),
842 ],
843
844 # bracket can be block or object
845 'bracket': [
846 include('spaces'),
847 (r'(?!(?:\$\s*[a-z]\b|\$(?!'+ident+')))' + ident_no_keyword, Name,
848 ('#pop', 'bracket-check')),
849 (r"'", String.Single, ('#pop', 'bracket-check', 'string-single')),
850 (r'"', String.Double, ('#pop', 'bracket-check', 'string-double')),
851 default(('#pop', 'block')),
852 ],
853
854 'bracket-check': [
855 include('spaces'),
856 (r':', Punctuation, ('#pop', 'object-sep', 'expr')), # is object
857 default(('#pop', 'block', 'optional-semicolon', 'expr-chain')), # is block
858 ],
859
860 # code block
861 'block': [
862 include('spaces'),
863 (r'\}', Punctuation, '#pop'),
864 default('expr-statement'),
865 ],
866
867 # object in key-value pairs
868 'object': [
869 include('spaces'),
870 (r'\}', Punctuation, '#pop'),
871 default(('#pop', 'object-sep', 'expr', 'colon', 'ident-or-string'))
872 ],
873
874 # a key of an object
875 'ident-or-string': [
876 include('spaces'),
877 (ident_no_keyword, Name, '#pop'),
878 (r"'", String.Single, ('#pop', 'string-single')),
879 (r'"', String.Double, ('#pop', 'string-double')),
880 ],
881
882 # after a key-value pair in object
883 'object-sep': [
884 include('spaces'),
885 (r'\}', Punctuation, '#pop'),
886 (r',', Punctuation, ('#pop', 'object')),
887 ],
888
889
890
891 }
892
893 def analyse_text(text):
894 if re.match(r'\w+\s*:\s*\w', text):
895 return 0.3
896
897
898 class HxmlLexer(RegexLexer):
899 """
900 Lexer for `haXe build <http://haxe.org/doc/compiler>`_ files.
901
902 .. versionadded:: 1.6
903 """
904 name = 'Hxml'
905 aliases = ['haxeml', 'hxml']
906 filenames = ['*.hxml']
907
908 tokens = {
909 'root': [
910 # Seperator
911 (r'(--)(next)', bygroups(Punctuation, Generic.Heading)),
912 # Compiler switches with one dash
913 (r'(-)(prompt|debug|v)', bygroups(Punctuation, Keyword.Keyword)),
914 # Compilerswitches with two dashes
915 (r'(--)(neko-source|flash-strict|flash-use-stage|no-opt|no-traces|'
916 r'no-inline|times|no-output)', bygroups(Punctuation, Keyword)),
917 # Targets and other options that take an argument
918 (r'(-)(cpp|js|neko|x|as3|swf9?|swf-lib|php|xml|main|lib|D|resource|'
919 r'cp|cmd)( +)(.+)',
920 bygroups(Punctuation, Keyword, Whitespace, String)),
921 # Options that take only numerical arguments
922 (r'(-)(swf-version)( +)(\d+)',
923 bygroups(Punctuation, Keyword, Number.Integer)),
924 # An Option that defines the size, the fps and the background
925 # color of an flash movie
926 (r'(-)(swf-header)( +)(\d+)(:)(\d+)(:)(\d+)(:)([A-Fa-f0-9]{6})',
927 bygroups(Punctuation, Keyword, Whitespace, Number.Integer,
928 Punctuation, Number.Integer, Punctuation, Number.Integer,
929 Punctuation, Number.Hex)),
930 # options with two dashes that takes arguments
931 (r'(--)(js-namespace|php-front|php-lib|remap|gen-hx-classes)( +)'
932 r'(.+)', bygroups(Punctuation, Keyword, Whitespace, String)),
933 # Single line comment, multiline ones are not allowed.
934 (r'#.*', Comment.Single)
935 ]
936 }

Mercurial Repository: eric

eric ide

mercurial