eric: comparison ThirdParty/Pygments/pygments/lexers/qvt.py

-:f0d08bdeacf4
+:6762afd9f963
 pygments.lexers.qvt
 ~~~~~~~~~~~~~~~~~~~
 Lexer for QVT Operational language.
-:copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
-from pygments.lexer import RegexLexer, bygroups, include, combined
+from pygments.lexer import RegexLexer, bygroups, include, combined, default, \
+words
 from pygments.token import Text, Comment, Operator, Keyword, Punctuation, \
 Name, String, Number
 __all__ = ['QVToLexer']
 (r'[^\S\n]+', Text),
 (r'(--|//)(\s*)(directive:)?(.*)$',
 bygroups(Comment, Comment, Comment.Preproc, Comment)),
 # Uncomment the following if you want to distinguish between
 # '/*' and '/**', à la javadoc
-#(r'/[*]{2}(.|\n)*?[*]/', Comment.Multiline),
+# (r'/[*]{2}(.|\n)*?[*]/', Comment.Multiline),
 (r'/[*](.|\n)*?[*]/', Comment.Multiline),
 (r'\\\n', Text),
 (r'(and|not|or|xor|##?)\b', Operator.Word),
-(r'([:]{1-2}=|[-+]=)\b', Operator.Word),
+(r'(:{1,2}=|[-+]=)\b', Operator.Word),
-(r'(@|<<|>>)\b', Keyword), # stereotypes
+(r'(@|<<|>>)\b', Keyword),  # stereotypes
-(r'!=|<>|=|==|!->|->|>=|<=|[.]{3}|[+/*%=<>&|.~]', Operator),
+(r'!=|<>|==|=|!->|->|>=|<=|[.]{3}|[+/*%=<>&|.~]', Operator),
 (r'[]{}:(),;[]', Punctuation),
 (r'(true|false|unlimited|null)\b', Keyword.Constant),
 (r'(this|self|result)\b', Name.Builtin.Pseudo),
 (r'(var)\b', Keyword.Declaration),
 (r'(from|import)\b', Keyword.Namespace, 'fromimport'),
-(r'(metamodel|class|exception|primitive|enum|transformation|library)(\s+)([a-zA-Z0-9_]+)',
+(r'(metamodel|class|exception|primitive|enum|transformation|'
+r'library)(\s+)(\w+)',
 bygroups(Keyword.Word, Text, Name.Class)),
-(r'(exception)(\s+)([a-zA-Z0-9_]+)', bygroups(Keyword.Word, Text, Name.Exception)),
+(r'(exception)(\s+)(\w+)',
+bygroups(Keyword.Word, Text, Name.Exception)),
 (r'(main)\b', Name.Function),
-(r'(mapping|helper|query)(\s+)', bygroups(Keyword.Declaration, Text), 'operation'),
+(r'(mapping|helper|query)(\s+)',
+bygroups(Keyword.Declaration, Text), 'operation'),
 (r'(assert)(\s+)\b', bygroups(Keyword, Text), 'assert'),
 (r'(Bag|Collection|Dict|OrderedSet|Sequence|Set|Tuple|List)\b',
 Keyword.Type),
 include('keywords'),
 ('"', String, combined('stringescape', 'dqs')),
 ("'", String, combined('stringescape', 'sqs')),
 include('name'),
 include('numbers'),
-# (r'([a-zA-Z_][a-zA-Z0-9_]*)(::)([a-zA-Z_][a-zA-Z0-9_]*)',
+# (r'([a-zA-Z_]\w*)(::)([a-zA-Z_]\w*)',
 # bygroups(Text, Text, Text)),
 ],
 'fromimport': [
 (r'(?:[ \t]|\\\n)+', Text),
-(r'[a-zA-Z_][a-zA-Z0-9_.]*', Name.Namespace),
+(r'[a-zA-Z_][\w.]*', Name.Namespace),
-(r'', Text, '#pop'),
+default('#pop'),
 ],
 'operation': [
 (r'::', Text),
-(r'(.*::)([a-zA-Z_][a-zA-Z0-9_]*)[ \t]*(\()', bygroups(Text,Name.Function, Text), '#pop')
+(r'(.*::)([a-zA-Z_]\w*)([ \t]*)(\()',
-],
+bygroups(Text, Name.Function, Text, Punctuation), '#pop')
+],
 'assert': [
 (r'(warning|error|fatal)\b', Keyword, '#pop'),
-(r'', Text, '#pop') # all else: go back
+default('#pop'),  # all else: go back
 ],
 'keywords': [
-(r'(abstract|access|any|assert|'
+(words((
-r'blackbox|break|case|collect|collectNested|'
+'abstract', 'access', 'any', 'assert', 'blackbox', 'break',
-r'collectOne|collectselect|collectselectOne|composes|'
+'case', 'collect', 'collectNested', 'collectOne', 'collectselect',
-r'compute|configuration|constructor|continue|datatype|'
+'collectselectOne', 'composes', 'compute', 'configuration',
-r'default|derived|disjuncts|do|elif|else|end|'
+'constructor', 'continue', 'datatype', 'default', 'derived',
-r'endif|except|exists|extends|'
+'disjuncts', 'do', 'elif', 'else', 'end', 'endif', 'except',
-r'forAll|forEach|forOne|from|if|'
+'exists', 'extends', 'forAll', 'forEach', 'forOne', 'from', 'if',
-r'implies|in|inherits|init|inout|'
+'implies', 'in', 'inherits', 'init', 'inout', 'intermediate',
-r'intermediate|invresolve|invresolveIn|invresolveone|'
+'invresolve', 'invresolveIn', 'invresolveone', 'invresolveoneIn',
-r'invresolveoneIn|isUnique|iterate|late|let|'
+'isUnique', 'iterate', 'late', 'let', 'literal', 'log', 'map',
-r'literal|log|map|merges|'
+'merges', 'modeltype', 'new', 'object', 'one', 'ordered', 'out',
-r'modeltype|new|object|one|'
+'package', 'population', 'property', 'raise', 'readonly',
-r'ordered|out|package|population|'
+'references', 'refines', 'reject', 'resolve', 'resolveIn',
-r'property|raise|readonly|references|refines|'
+'resolveone', 'resolveoneIn', 'return', 'select', 'selectOne',
-r'reject|resolve|resolveIn|resolveone|resolveoneIn|'
+'sortedBy', 'static', 'switch', 'tag', 'then', 'try', 'typedef',
-r'return|select|selectOne|sortedBy|static|switch|'
+'unlimited', 'uses', 'when', 'where', 'while', 'with', 'xcollect',
-r'tag|then|try|typedef|'
+'xmap', 'xselect'), suffix=r'\b'), Keyword),
-r'unlimited|uses|when|where|while|with|'
-r'xcollect|xmap|xselect)\b', Keyword),
 ],
 # There is no need to distinguish between String.Single and
 # String.Double: 'strings' is factorised for 'dqs' and 'sqs'
 'strings': [
 (r'[\'"\\]', String),
 ],
 'stringescape': [
 (r'\\([\\btnfr"\']|u[0-3][0-7]{2}|u[0-7]{1,2})', String.Escape)
 ],
-'dqs': [ # double-quoted string
+'dqs': [  # double-quoted string
 (r'"', String, '#pop'),
 (r'\\\\|\\"', String.Escape),
 include('strings')
 ],
-'sqs': [ # single-quoted string
+'sqs': [  # single-quoted string
 (r"'", String, '#pop'),
 (r"\\\\|\\'", String.Escape),
 include('strings')
 ],
 'name': [
-('[a-zA-Z_][a-zA-Z0-9_]*', Name),
+('[a-zA-Z_]\w*', Name),
 ],
 # numbers: excerpt taken from the python lexer
 'numbers': [
 (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float),
 (r'\d+[eE][+-]?[0-9]+', Number.Float),
 (r'\d+', Number.Integer)
 ],
 }

Mercurial Repositories > eric / file comparison

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

ThirdParty/Pygments/pygments/lexers/qvt.py