Mercurial Repositories > eric / file comparison
comparison: eric6/ThirdParty/Pygments/pygments/lexers/parsers.py
eric6/ThirdParty/Pygments/pygments/lexers/parsers.py
- changeset 7701
- 25f42e208e08
- parent 7547
- 21b0534faebc
- child 7983
- 54c5cfbb1e29
equal
deleted
inserted
replaced
| 7700:a3cf077a8db3 | 7701:25f42e208e08 |
|---|---|
| 3 pygments.lexers.parsers | 3 pygments.lexers.parsers |
| 4 ~~~~~~~~~~~~~~~~~~~~~~~ | 4 ~~~~~~~~~~~~~~~~~~~~~~~ |
| 5 | 5 |
| 6 Lexers for parser generators. | 6 Lexers for parser generators. |
| 7 | 7 |
| 8 :copyright: Copyright 2006-2019 by the Pygments team, see AUTHORS. | 8 :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS. |
| 9 :license: BSD, see LICENSE for details. | 9 :license: BSD, see LICENSE for details. |
| 10 """ | 10 """ |
| 11 | 11 |
| 12 import re | 12 import re |
| 13 | 13 |
| 26 | 26 |
| 27 __all__ = ['RagelLexer', 'RagelEmbeddedLexer', 'RagelCLexer', 'RagelDLexer', | 27 __all__ = ['RagelLexer', 'RagelEmbeddedLexer', 'RagelCLexer', 'RagelDLexer', |
| 28 'RagelCppLexer', 'RagelObjectiveCLexer', 'RagelRubyLexer', | 28 'RagelCppLexer', 'RagelObjectiveCLexer', 'RagelRubyLexer', |
| 29 'RagelJavaLexer', 'AntlrLexer', 'AntlrPythonLexer', | 29 'RagelJavaLexer', 'AntlrLexer', 'AntlrPythonLexer', |
| 30 'AntlrPerlLexer', 'AntlrRubyLexer', 'AntlrCppLexer', | 30 'AntlrPerlLexer', 'AntlrRubyLexer', 'AntlrCppLexer', |
| 31 # 'AntlrCLexer', | |
| 32 'AntlrCSharpLexer', 'AntlrObjectiveCLexer', | 31 'AntlrCSharpLexer', 'AntlrObjectiveCLexer', |
| 33 'AntlrJavaLexer', 'AntlrActionScriptLexer', | 32 'AntlrJavaLexer', 'AntlrActionScriptLexer', |
| 34 'TreetopLexer', 'EbnfLexer'] | 33 'TreetopLexer', 'EbnfLexer'] |
| 35 | 34 |
| 36 | 35 |
| 220 name = 'Ragel in Ruby Host' | 219 name = 'Ragel in Ruby Host' |
| 221 aliases = ['ragel-ruby', 'ragel-rb'] | 220 aliases = ['ragel-ruby', 'ragel-rb'] |
| 222 filenames = ['*.rl'] | 221 filenames = ['*.rl'] |
| 223 | 222 |
| 224 def __init__(self, **options): | 223 def __init__(self, **options): |
| 225 super(RagelRubyLexer, self).__init__(RubyLexer, RagelEmbeddedLexer, | 224 super().__init__(RubyLexer, RagelEmbeddedLexer, **options) |
| 226 **options) | |
| 227 | 225 |
| 228 def analyse_text(text): | 226 def analyse_text(text): |
| 229 return '@LANG: ruby' in text | 227 return '@LANG: ruby' in text |
| 230 | 228 |
| 231 | 229 |
| 239 name = 'Ragel in C Host' | 237 name = 'Ragel in C Host' |
| 240 aliases = ['ragel-c'] | 238 aliases = ['ragel-c'] |
| 241 filenames = ['*.rl'] | 239 filenames = ['*.rl'] |
| 242 | 240 |
| 243 def __init__(self, **options): | 241 def __init__(self, **options): |
| 244 super(RagelCLexer, self).__init__(CLexer, RagelEmbeddedLexer, | 242 super().__init__(CLexer, RagelEmbeddedLexer, **options) |
| 245 **options) | |
| 246 | 243 |
| 247 def analyse_text(text): | 244 def analyse_text(text): |
| 248 return '@LANG: c' in text | 245 return '@LANG: c' in text |
| 249 | 246 |
| 250 | 247 |
| 258 name = 'Ragel in D Host' | 255 name = 'Ragel in D Host' |
| 259 aliases = ['ragel-d'] | 256 aliases = ['ragel-d'] |
| 260 filenames = ['*.rl'] | 257 filenames = ['*.rl'] |
| 261 | 258 |
| 262 def __init__(self, **options): | 259 def __init__(self, **options): |
| 263 super(RagelDLexer, self).__init__(DLexer, RagelEmbeddedLexer, **options) | 260 super().__init__(DLexer, RagelEmbeddedLexer, **options) |
| 264 | 261 |
| 265 def analyse_text(text): | 262 def analyse_text(text): |
| 266 return '@LANG: d' in text | 263 return '@LANG: d' in text |
| 267 | 264 |
| 268 | 265 |
| 276 name = 'Ragel in CPP Host' | 273 name = 'Ragel in CPP Host' |
| 277 aliases = ['ragel-cpp'] | 274 aliases = ['ragel-cpp'] |
| 278 filenames = ['*.rl'] | 275 filenames = ['*.rl'] |
| 279 | 276 |
| 280 def __init__(self, **options): | 277 def __init__(self, **options): |
| 281 super(RagelCppLexer, self).__init__(CppLexer, RagelEmbeddedLexer, **options) | 278 super().__init__(CppLexer, RagelEmbeddedLexer, **options) |
| 282 | 279 |
| 283 def analyse_text(text): | 280 def analyse_text(text): |
| 284 return '@LANG: c++' in text | 281 return '@LANG: c++' in text |
| 285 | 282 |
| 286 | 283 |
| 294 name = 'Ragel in Objective C Host' | 291 name = 'Ragel in Objective C Host' |
| 295 aliases = ['ragel-objc'] | 292 aliases = ['ragel-objc'] |
| 296 filenames = ['*.rl'] | 293 filenames = ['*.rl'] |
| 297 | 294 |
| 298 def __init__(self, **options): | 295 def __init__(self, **options): |
| 299 super(RagelObjectiveCLexer, self).__init__(ObjectiveCLexer, | 296 super().__init__(ObjectiveCLexer, RagelEmbeddedLexer, **options) |
| 300 RagelEmbeddedLexer, | |
| 301 **options) | |
| 302 | 297 |
| 303 def analyse_text(text): | 298 def analyse_text(text): |
| 304 return '@LANG: objc' in text | 299 return '@LANG: objc' in text |
| 305 | 300 |
| 306 | 301 |
| 314 name = 'Ragel in Java Host' | 309 name = 'Ragel in Java Host' |
| 315 aliases = ['ragel-java'] | 310 aliases = ['ragel-java'] |
| 316 filenames = ['*.rl'] | 311 filenames = ['*.rl'] |
| 317 | 312 |
| 318 def __init__(self, **options): | 313 def __init__(self, **options): |
| 319 super(RagelJavaLexer, self).__init__(JavaLexer, RagelEmbeddedLexer, | 314 super().__init__(JavaLexer, RagelEmbeddedLexer, **options) |
| 320 **options) | |
| 321 | 315 |
| 322 def analyse_text(text): | 316 def analyse_text(text): |
| 323 return '@LANG: java' in text | 317 return '@LANG: java' in text |
| 324 | 318 |
| 325 | 319 |
| 513 } | 507 } |
| 514 | 508 |
| 515 def analyse_text(text): | 509 def analyse_text(text): |
| 516 return re.search(r'^\s*grammar\s+[a-zA-Z0-9]+\s*;', text, re.M) | 510 return re.search(r'^\s*grammar\s+[a-zA-Z0-9]+\s*;', text, re.M) |
| 517 | 511 |
| 512 | |
| 518 # http://www.antlr.org/wiki/display/ANTLR3/Code+Generation+Targets | 513 # http://www.antlr.org/wiki/display/ANTLR3/Code+Generation+Targets |
| 519 | |
| 520 # TH: I'm not aware of any language features of C++ that will cause | |
| 521 # incorrect lexing of C files. Antlr doesn't appear to make a distinction, | |
| 522 # so just assume they're C++. No idea how to make Objective C work in the | |
| 523 # future. | |
| 524 | |
| 525 # class AntlrCLexer(DelegatingLexer): | |
| 526 # """ | |
| 527 # ANTLR with C Target | |
| 528 # | |
| 529 # .. versionadded:: 1.1 | |
| 530 # """ | |
| 531 # | |
| 532 # name = 'ANTLR With C Target' | |
| 533 # aliases = ['antlr-c'] | |
| 534 # filenames = ['*.G', '*.g'] | |
| 535 # | |
| 536 # def __init__(self, **options): | |
| 537 # super(AntlrCLexer, self).__init__(CLexer, AntlrLexer, **options) | |
| 538 # | |
| 539 # def analyse_text(text): | |
| 540 # return re.match(r'^\s*language\s*=\s*C\s*;', text) | |
| 541 | |
| 542 | 514 |
| 543 class AntlrCppLexer(DelegatingLexer): | 515 class AntlrCppLexer(DelegatingLexer): |
| 544 """ | 516 """ |
| 545 `ANTLR`_ with CPP Target | 517 `ANTLR`_ with CPP Target |
| 546 | 518 |
| 550 name = 'ANTLR With CPP Target' | 522 name = 'ANTLR With CPP Target' |
| 551 aliases = ['antlr-cpp'] | 523 aliases = ['antlr-cpp'] |
| 552 filenames = ['*.G', '*.g'] | 524 filenames = ['*.G', '*.g'] |
| 553 | 525 |
| 554 def __init__(self, **options): | 526 def __init__(self, **options): |
| 555 super(AntlrCppLexer, self).__init__(CppLexer, AntlrLexer, **options) | 527 super().__init__(CppLexer, AntlrLexer, **options) |
| 556 | 528 |
| 557 def analyse_text(text): | 529 def analyse_text(text): |
| 558 return AntlrLexer.analyse_text(text) and \ | 530 return AntlrLexer.analyse_text(text) and \ |
| 559 re.search(r'^\s*language\s*=\s*C\s*;', text, re.M) | 531 re.search(r'^\s*language\s*=\s*C\s*;', text, re.M) |
| 560 | 532 |
| 569 name = 'ANTLR With ObjectiveC Target' | 541 name = 'ANTLR With ObjectiveC Target' |
| 570 aliases = ['antlr-objc'] | 542 aliases = ['antlr-objc'] |
| 571 filenames = ['*.G', '*.g'] | 543 filenames = ['*.G', '*.g'] |
| 572 | 544 |
| 573 def __init__(self, **options): | 545 def __init__(self, **options): |
| 574 super(AntlrObjectiveCLexer, self).__init__(ObjectiveCLexer, | 546 super().__init__(ObjectiveCLexer, AntlrLexer, **options) |
| 575 AntlrLexer, **options) | |
| 576 | 547 |
| 577 def analyse_text(text): | 548 def analyse_text(text): |
| 578 return AntlrLexer.analyse_text(text) and \ | 549 return AntlrLexer.analyse_text(text) and \ |
| 579 re.search(r'^\s*language\s*=\s*ObjC\s*;', text) | 550 re.search(r'^\s*language\s*=\s*ObjC\s*;', text) |
| 580 | 551 |
| 589 name = 'ANTLR With C# Target' | 560 name = 'ANTLR With C# Target' |
| 590 aliases = ['antlr-csharp', 'antlr-c#'] | 561 aliases = ['antlr-csharp', 'antlr-c#'] |
| 591 filenames = ['*.G', '*.g'] | 562 filenames = ['*.G', '*.g'] |
| 592 | 563 |
| 593 def __init__(self, **options): | 564 def __init__(self, **options): |
| 594 super(AntlrCSharpLexer, self).__init__(CSharpLexer, AntlrLexer, | 565 super().__init__(CSharpLexer, AntlrLexer, **options) |
| 595 **options) | |
| 596 | 566 |
| 597 def analyse_text(text): | 567 def analyse_text(text): |
| 598 return AntlrLexer.analyse_text(text) and \ | 568 return AntlrLexer.analyse_text(text) and \ |
| 599 re.search(r'^\s*language\s*=\s*CSharp2\s*;', text, re.M) | 569 re.search(r'^\s*language\s*=\s*CSharp2\s*;', text, re.M) |
| 600 | 570 |
| 609 name = 'ANTLR With Python Target' | 579 name = 'ANTLR With Python Target' |
| 610 aliases = ['antlr-python'] | 580 aliases = ['antlr-python'] |
| 611 filenames = ['*.G', '*.g'] | 581 filenames = ['*.G', '*.g'] |
| 612 | 582 |
| 613 def __init__(self, **options): | 583 def __init__(self, **options): |
| 614 super(AntlrPythonLexer, self).__init__(PythonLexer, AntlrLexer, | 584 super().__init__(PythonLexer, AntlrLexer, **options) |
| 615 **options) | |
| 616 | 585 |
| 617 def analyse_text(text): | 586 def analyse_text(text): |
| 618 return AntlrLexer.analyse_text(text) and \ | 587 return AntlrLexer.analyse_text(text) and \ |
| 619 re.search(r'^\s*language\s*=\s*Python\s*;', text, re.M) | 588 re.search(r'^\s*language\s*=\s*Python\s*;', text, re.M) |
| 620 | 589 |
| 629 name = 'ANTLR With Java Target' | 598 name = 'ANTLR With Java Target' |
| 630 aliases = ['antlr-java'] | 599 aliases = ['antlr-java'] |
| 631 filenames = ['*.G', '*.g'] | 600 filenames = ['*.G', '*.g'] |
| 632 | 601 |
| 633 def __init__(self, **options): | 602 def __init__(self, **options): |
| 634 super(AntlrJavaLexer, self).__init__(JavaLexer, AntlrLexer, | 603 super().__init__(JavaLexer, AntlrLexer, **options) |
| 635 **options) | |
| 636 | 604 |
| 637 def analyse_text(text): | 605 def analyse_text(text): |
| 638 # Antlr language is Java by default | 606 # Antlr language is Java by default |
| 639 return AntlrLexer.analyse_text(text) and 0.9 | 607 return AntlrLexer.analyse_text(text) and 0.9 |
| 640 | 608 |
| 649 name = 'ANTLR With Ruby Target' | 617 name = 'ANTLR With Ruby Target' |
| 650 aliases = ['antlr-ruby', 'antlr-rb'] | 618 aliases = ['antlr-ruby', 'antlr-rb'] |
| 651 filenames = ['*.G', '*.g'] | 619 filenames = ['*.G', '*.g'] |
| 652 | 620 |
| 653 def __init__(self, **options): | 621 def __init__(self, **options): |
| 654 super(AntlrRubyLexer, self).__init__(RubyLexer, AntlrLexer, | 622 super().__init__(RubyLexer, AntlrLexer, **options) |
| 655 **options) | |
| 656 | 623 |
| 657 def analyse_text(text): | 624 def analyse_text(text): |
| 658 return AntlrLexer.analyse_text(text) and \ | 625 return AntlrLexer.analyse_text(text) and \ |
| 659 re.search(r'^\s*language\s*=\s*Ruby\s*;', text, re.M) | 626 re.search(r'^\s*language\s*=\s*Ruby\s*;', text, re.M) |
| 660 | 627 |
| 669 name = 'ANTLR With Perl Target' | 636 name = 'ANTLR With Perl Target' |
| 670 aliases = ['antlr-perl'] | 637 aliases = ['antlr-perl'] |
| 671 filenames = ['*.G', '*.g'] | 638 filenames = ['*.G', '*.g'] |
| 672 | 639 |
| 673 def __init__(self, **options): | 640 def __init__(self, **options): |
| 674 super(AntlrPerlLexer, self).__init__(PerlLexer, AntlrLexer, | 641 super().__init__(PerlLexer, AntlrLexer, **options) |
| 675 **options) | |
| 676 | 642 |
| 677 def analyse_text(text): | 643 def analyse_text(text): |
| 678 return AntlrLexer.analyse_text(text) and \ | 644 return AntlrLexer.analyse_text(text) and \ |
| 679 re.search(r'^\s*language\s*=\s*Perl5\s*;', text, re.M) | 645 re.search(r'^\s*language\s*=\s*Perl5\s*;', text, re.M) |
| 680 | 646 |
| 690 aliases = ['antlr-as', 'antlr-actionscript'] | 656 aliases = ['antlr-as', 'antlr-actionscript'] |
| 691 filenames = ['*.G', '*.g'] | 657 filenames = ['*.G', '*.g'] |
| 692 | 658 |
| 693 def __init__(self, **options): | 659 def __init__(self, **options): |
| 694 from pygments.lexers.actionscript import ActionScriptLexer | 660 from pygments.lexers.actionscript import ActionScriptLexer |
| 695 super(AntlrActionScriptLexer, self).__init__(ActionScriptLexer, | 661 super().__init__(ActionScriptLexer, AntlrLexer, **options) |
| 696 AntlrLexer, **options) | |
| 697 | 662 |
| 698 def analyse_text(text): | 663 def analyse_text(text): |
| 699 return AntlrLexer.analyse_text(text) and \ | 664 return AntlrLexer.analyse_text(text) and \ |
| 700 re.search(r'^\s*language\s*=\s*ActionScript\s*;', text, re.M) | 665 re.search(r'^\s*language\s*=\s*ActionScript\s*;', text, re.M) |
| 701 | 666 |
| 779 name = 'Treetop' | 744 name = 'Treetop' |
| 780 aliases = ['treetop'] | 745 aliases = ['treetop'] |
| 781 filenames = ['*.treetop', '*.tt'] | 746 filenames = ['*.treetop', '*.tt'] |
| 782 | 747 |
| 783 def __init__(self, **options): | 748 def __init__(self, **options): |
| 784 super(TreetopLexer, self).__init__(RubyLexer, TreetopBaseLexer, **options) | 749 super().__init__(RubyLexer, TreetopBaseLexer, **options) |
| 785 | 750 |
| 786 | 751 |
| 787 class EbnfLexer(RegexLexer): | 752 class EbnfLexer(RegexLexer): |
| 788 """ | 753 """ |
| 789 Lexer for `ISO/IEC 14977 EBNF | 754 Lexer for `ISO/IEC 14977 EBNF |
