Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/pygments/lexers/haxe.py: 60%

1"""

2 pygments.lexers.haxe

3 ~~~~~~~~~~~~~~~~~~~~

5 Lexers for Haxe and related stuff.

8 :license: BSD, see LICENSE for details.

9"""

11import re

13from pygments.lexer import ExtendedRegexLexer, RegexLexer, include, bygroups, \

14 default

15from pygments.token import Text, Comment, Operator, Keyword, Name, String, \

16 Number, Punctuation, Generic, Whitespace

18__all__ = ['HaxeLexer', 'HxmlLexer']

21class HaxeLexer(ExtendedRegexLexer):

22 """

23 For Haxe source code.

25 .. versionadded:: 1.3

26 """

28 name = 'Haxe'

29 url = 'http://haxe.org/'

30 aliases = ['haxe', 'hxsl', 'hx']

31 filenames = ['*.hx', '*.hxsl']

32 mimetypes = ['text/haxe', 'text/x-haxe', 'text/x-hx']

34 # keywords extracted from lexer.mll in the haxe compiler source

35 keyword = (r'(?:function|class|static|var|if|else|while|do|for|'

42 # idtype in lexer.mll

43 typeid = r'_*[A-Z]\w*'

45 # combined ident and dollar and idtype

46 ident = r'(?:_*[a-z]\w*|_+[0-9]\w*|' + typeid + r'|_+|\$\w+)'

48 binop = (r'(?:%=|&=|\|=|\^=|\+=|\-=|\*=|/=|<<=|>\s*>\s*=|>\s*>\s*>\s*=|==|'

49 r'!=|<=|>\s*=|&&|\|\||<<|>>>|>\s*>|\.\.\.|<|>|%|&|\||\^|\+|\*|'

50 r'/|\-|=>|=)')

52 # ident except keywords

53 ident_no_keyword = r'(?!' + keyword + ')' + ident

55 flags = re.DOTALL | re.MULTILINE

57 preproc_stack = []

59 def preproc_callback(self, match, ctx):

60 proc = match.group(2)

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()

74 # #if and #elseif should follow by an expr

75 if proc in ['if', 'elseif']:

76 ctx.stack.append('preproc-expr')

78 # #error can be optionally follow by the error msg

79 if proc in ['error']:

80 ctx.stack.append('preproc-error')

82 yield match.start(), Comment.Preproc, '#' + proc

83 ctx.pos = match.end()

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'),

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+', Whitespace),

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+', Whitespace),

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+', Whitespace),

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 + r'|\.\.)', 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+', Whitespace),

198 (r'\)', Comment.Preproc, '#pop'),

199 default('preproc-expr-in-parenthesis'),

200 ],

201

202 'preproc-expr-chain': [

203 (r'\s+', Whitespace),

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+', Whitespace),

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 + r'|\.\.)', 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'),

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'),

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')),

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 + r'|\.\.)', 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 + r'|\.\.)', 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 ],

891 }

893 def analyse_text(text):

894 if re.match(r'\w+\s*:\s*\w', text):

895 return 0.3

896

897

898class HxmlLexer(RegexLexer):

899 """

900 Lexer for haXe build files.

901

902 .. versionadded:: 1.6

903 """

904 name = 'Hxml'

905 url = 'https://haxe.org/manual/compiler-usage-hxml.html'

906 aliases = ['haxeml', 'hxml']

907 filenames = ['*.hxml']

908

909 tokens = {

910 'root': [

911 # Separator

912 (r'(--)(next)', bygroups(Punctuation, Generic.Heading)),

913 # Compiler switches with one dash

914 (r'(-)(prompt|debug|v)', bygroups(Punctuation, Keyword.Keyword)),

915 # Compilerswitches with two dashes

917 r'no-inline|times|no-output)', bygroups(Punctuation, Keyword)),

918 # Targets and other options that take an argument

919 (r'(-)(cpp|js|neko|x|as3|swf9?|swf-lib|php|xml|main|lib|D|resource|'

920 r'cp|cmd)( +)(.+)',

921 bygroups(Punctuation, Keyword, Whitespace, String)),

922 # Options that take only numerical arguments

923 (r'(-)(swf-version)( +)(\d+)',

924 bygroups(Punctuation, Keyword, Whitespace, Number.Integer)),

925 # An Option that defines the size, the fps and the background

926 # color of an flash movie

927 (r'(-)(swf-header)( +)(\d+)(:)(\d+)(:)(\d+)(:)([A-Fa-f0-9]{6})',

928 bygroups(Punctuation, Keyword, Whitespace, Number.Integer,

929 Punctuation, Number.Integer, Punctuation, Number.Integer,

930 Punctuation, Number.Hex)),

931 # options with two dashes that takes arguments

932 (r'(--)(js-namespace|php-front|php-lib|remap|gen-hx-classes)( +)'

933 r'(.+)', bygroups(Punctuation, Keyword, Whitespace, String)),

934 # Single line comment, multiline ones are not allowed.

935 (r'#.*', Comment.Single)

936 ]

937 }