Restoring authorship annotation for <ilezhankin@yandex-team.ru>. Commit 2 of 2.

1 files changed, 590 insertions, 590 deletions

diff --git a/contrib/python/Pygments/py3/pygments/lexers/dsls.py b/contrib/python/Pygments/py3/pygments/lexers/dsls.py
index 98c9a2c056..b6847d0447 100644
--- a/contrib/python/Pygments/py3/pygments/lexers/dsls.py
+++ b/contrib/python/Pygments/py3/pygments/lexers/dsls.py
@@ -1,208 +1,208 @@
-""" 
-    pygments.lexers.dsls 
-    ~~~~~~~~~~~~~~~~~~~~ 
- 
-    Lexers for various domain-specific languages. 
- 
+"""
+    pygments.lexers.dsls
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for various domain-specific languages.
+
     :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details. 
-""" 
- 
-import re 
- 
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
 from pygments.lexer import ExtendedRegexLexer, RegexLexer, bygroups, words, \
     include, default, this, using, combined
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \ 
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
     Number, Punctuation, Whitespace
- 
+
 __all__ = ['ProtoBufLexer', 'ZeekLexer', 'PuppetLexer', 'RslLexer',
-           'MscgenLexer', 'VGLLexer', 'AlloyLexer', 'PanLexer', 
+           'MscgenLexer', 'VGLLexer', 'AlloyLexer', 'PanLexer',
            'CrmshLexer', 'ThriftLexer', 'FlatlineLexer', 'SnowballLexer']
- 
- 
-class ProtoBufLexer(RegexLexer): 
-    """ 
-    Lexer for `Protocol Buffer <http://code.google.com/p/protobuf/>`_ 
-    definition files. 
- 
-    .. versionadded:: 1.4 
-    """ 
- 
-    name = 'Protocol Buffer' 
-    aliases = ['protobuf', 'proto'] 
-    filenames = ['*.proto'] 
- 
-    tokens = { 
-        'root': [ 
+
+
+class ProtoBufLexer(RegexLexer):
+    """
+    Lexer for `Protocol Buffer <http://code.google.com/p/protobuf/>`_
+    definition files.
+
+    .. versionadded:: 1.4
+    """
+
+    name = 'Protocol Buffer'
+    aliases = ['protobuf', 'proto']
+    filenames = ['*.proto']
+
+    tokens = {
+        'root': [
             (r'[ \t]+', Whitespace),
             (r'[,;{}\[\]()<>]', Punctuation),
-            (r'/(\\\n)?/(\n|(.|\n)*?[^\\]\n)', Comment.Single), 
-            (r'/(\\\n)?\*(.|\n)*?\*(\\\n)?/', Comment.Multiline), 
-            (words(( 
+            (r'/(\\\n)?/(\n|(.|\n)*?[^\\]\n)', Comment.Single),
+            (r'/(\\\n)?\*(.|\n)*?\*(\\\n)?/', Comment.Multiline),
+            (words((
                 'import', 'option', 'optional', 'required', 'repeated',
                 'reserved', 'default', 'packed', 'ctype', 'extensions', 'to',
                 'max', 'rpc', 'returns', 'oneof', 'syntax'), prefix=r'\b', suffix=r'\b'),
-             Keyword), 
-            (words(( 
-                'int32', 'int64', 'uint32', 'uint64', 'sint32', 'sint64', 
-                'fixed32', 'fixed64', 'sfixed32', 'sfixed64', 
-                'float', 'double', 'bool', 'string', 'bytes'), suffix=r'\b'), 
-             Keyword.Type), 
-            (r'(true|false)\b', Keyword.Constant), 
+             Keyword),
+            (words((
+                'int32', 'int64', 'uint32', 'uint64', 'sint32', 'sint64',
+                'fixed32', 'fixed64', 'sfixed32', 'sfixed64',
+                'float', 'double', 'bool', 'string', 'bytes'), suffix=r'\b'),
+             Keyword.Type),
+            (r'(true|false)\b', Keyword.Constant),
             (r'(package)(\s+)', bygroups(Keyword.Namespace, Whitespace), 'package'),
-            (r'(message|extend)(\s+)', 
+            (r'(message|extend)(\s+)',
              bygroups(Keyword.Declaration, Whitespace), 'message'),
-            (r'(enum|group|service)(\s+)', 
+            (r'(enum|group|service)(\s+)',
              bygroups(Keyword.Declaration, Whitespace), 'type'),
-            (r'\".*?\"', String), 
-            (r'\'.*?\'', String), 
-            (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*', Number.Float), 
-            (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float), 
-            (r'(\-?(inf|nan))\b', Number.Float), 
-            (r'0x[0-9a-fA-F]+[LlUu]*', Number.Hex), 
-            (r'0[0-7]+[LlUu]*', Number.Oct), 
-            (r'\d+[LlUu]*', Number.Integer), 
-            (r'[+-=]', Operator), 
-            (r'([a-zA-Z_][\w.]*)([ \t]*)(=)', 
+            (r'\".*?\"', String),
+            (r'\'.*?\'', String),
+            (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*', Number.Float),
+            (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
+            (r'(\-?(inf|nan))\b', Number.Float),
+            (r'0x[0-9a-fA-F]+[LlUu]*', Number.Hex),
+            (r'0[0-7]+[LlUu]*', Number.Oct),
+            (r'\d+[LlUu]*', Number.Integer),
+            (r'[+-=]', Operator),
+            (r'([a-zA-Z_][\w.]*)([ \t]*)(=)',
              bygroups(Name.Attribute, Whitespace, Operator)),
             (r'[a-zA-Z_][\w.]*', Name),
-        ], 
-        'package': [ 
-            (r'[a-zA-Z_]\w*', Name.Namespace, '#pop'), 
-            default('#pop'), 
-        ], 
-        'message': [ 
-            (r'[a-zA-Z_]\w*', Name.Class, '#pop'), 
-            default('#pop'), 
-        ], 
-        'type': [ 
-            (r'[a-zA-Z_]\w*', Name, '#pop'), 
-            default('#pop'), 
-        ], 
-    } 
- 
- 
-class ThriftLexer(RegexLexer): 
-    """ 
-    For `Thrift <https://thrift.apache.org/>`__ interface definitions. 
- 
-    .. versionadded:: 2.1 
-    """ 
-    name = 'Thrift' 
-    aliases = ['thrift'] 
-    filenames = ['*.thrift'] 
-    mimetypes = ['application/x-thrift'] 
- 
-    tokens = { 
-        'root': [ 
-            include('whitespace'), 
-            include('comments'), 
-            (r'"', String.Double, combined('stringescape', 'dqs')), 
-            (r'\'', String.Single, combined('stringescape', 'sqs')), 
-            (r'(namespace)(\s+)', 
+        ],
+        'package': [
+            (r'[a-zA-Z_]\w*', Name.Namespace, '#pop'),
+            default('#pop'),
+        ],
+        'message': [
+            (r'[a-zA-Z_]\w*', Name.Class, '#pop'),
+            default('#pop'),
+        ],
+        'type': [
+            (r'[a-zA-Z_]\w*', Name, '#pop'),
+            default('#pop'),
+        ],
+    }
+
+
+class ThriftLexer(RegexLexer):
+    """
+    For `Thrift <https://thrift.apache.org/>`__ interface definitions.
+
+    .. versionadded:: 2.1
+    """
+    name = 'Thrift'
+    aliases = ['thrift']
+    filenames = ['*.thrift']
+    mimetypes = ['application/x-thrift']
+
+    tokens = {
+        'root': [
+            include('whitespace'),
+            include('comments'),
+            (r'"', String.Double, combined('stringescape', 'dqs')),
+            (r'\'', String.Single, combined('stringescape', 'sqs')),
+            (r'(namespace)(\s+)',
                 bygroups(Keyword.Namespace, Whitespace), 'namespace'),
-            (r'(enum|union|struct|service|exception)(\s+)', 
+            (r'(enum|union|struct|service|exception)(\s+)',
                 bygroups(Keyword.Declaration, Whitespace), 'class'),
-            (r'((?:(?:[^\W\d]|\$)[\w.\[\]$<>]*\s+)+?)'  # return arguments 
-             r'((?:[^\W\d]|\$)[\w$]*)'                  # method name 
-             r'(\s*)(\()',                              # signature start 
+            (r'((?:(?:[^\W\d]|\$)[\w.\[\]$<>]*\s+)+?)'  # return arguments
+             r'((?:[^\W\d]|\$)[\w$]*)'                  # method name
+             r'(\s*)(\()',                              # signature start
              bygroups(using(this), Name.Function, Whitespace, Operator)),
-            include('keywords'), 
-            include('numbers'), 
-            (r'[&=]', Operator), 
+            include('keywords'),
+            include('numbers'),
+            (r'[&=]', Operator),
             (r'[:;,{}()<>\[\]]', Punctuation),
             (r'[a-zA-Z_](\.\w|\w)*', Name),
-        ], 
-        'whitespace': [ 
+        ],
+        'whitespace': [
             (r'\n', Whitespace),
             (r'\s+', Whitespace),
-        ], 
-        'comments': [ 
-            (r'#.*$', Comment), 
-            (r'//.*?\n', Comment), 
-            (r'/\*[\w\W]*?\*/', Comment.Multiline), 
-        ], 
-        'stringescape': [ 
-            (r'\\([\\nrt"\'])', String.Escape), 
-        ], 
-        'dqs': [ 
-            (r'"', String.Double, '#pop'), 
-            (r'[^\\"\n]+', String.Double), 
-        ], 
-        'sqs': [ 
-            (r"'", String.Single, '#pop'), 
-            (r'[^\\\'\n]+', String.Single), 
-        ], 
-        'namespace': [ 
+        ],
+        'comments': [
+            (r'#.*$', Comment),
+            (r'//.*?\n', Comment),
+            (r'/\*[\w\W]*?\*/', Comment.Multiline),
+        ],
+        'stringescape': [
+            (r'\\([\\nrt"\'])', String.Escape),
+        ],
+        'dqs': [
+            (r'"', String.Double, '#pop'),
+            (r'[^\\"\n]+', String.Double),
+        ],
+        'sqs': [
+            (r"'", String.Single, '#pop'),
+            (r'[^\\\'\n]+', String.Single),
+        ],
+        'namespace': [
             (r'[a-z*](\.\w|\w)*', Name.Namespace, '#pop'),
-            default('#pop'), 
-        ], 
-        'class': [ 
-            (r'[a-zA-Z_]\w*', Name.Class, '#pop'), 
-            default('#pop'), 
-        ], 
-        'keywords': [ 
-            (r'(async|oneway|extends|throws|required|optional)\b', Keyword), 
-            (r'(true|false)\b', Keyword.Constant), 
-            (r'(const|typedef)\b', Keyword.Declaration), 
-            (words(( 
-                'cpp_namespace', 'cpp_include', 'cpp_type', 'java_package', 
-                'cocoa_prefix', 'csharp_namespace', 'delphi_namespace', 
-                'php_namespace', 'py_module', 'perl_package', 
-                'ruby_namespace', 'smalltalk_category', 'smalltalk_prefix', 
-                'xsd_all', 'xsd_optional', 'xsd_nillable', 'xsd_namespace', 
-                'xsd_attrs', 'include'), suffix=r'\b'), 
-             Keyword.Namespace), 
-            (words(( 
-                'void', 'bool', 'byte', 'i16', 'i32', 'i64', 'double', 
+            default('#pop'),
+        ],
+        'class': [
+            (r'[a-zA-Z_]\w*', Name.Class, '#pop'),
+            default('#pop'),
+        ],
+        'keywords': [
+            (r'(async|oneway|extends|throws|required|optional)\b', Keyword),
+            (r'(true|false)\b', Keyword.Constant),
+            (r'(const|typedef)\b', Keyword.Declaration),
+            (words((
+                'cpp_namespace', 'cpp_include', 'cpp_type', 'java_package',
+                'cocoa_prefix', 'csharp_namespace', 'delphi_namespace',
+                'php_namespace', 'py_module', 'perl_package',
+                'ruby_namespace', 'smalltalk_category', 'smalltalk_prefix',
+                'xsd_all', 'xsd_optional', 'xsd_nillable', 'xsd_namespace',
+                'xsd_attrs', 'include'), suffix=r'\b'),
+             Keyword.Namespace),
+            (words((
+                'void', 'bool', 'byte', 'i16', 'i32', 'i64', 'double',
                 'string', 'binary', 'map', 'list', 'set', 'slist',
-                'senum'), suffix=r'\b'), 
-             Keyword.Type), 
-            (words(( 
-                'BEGIN', 'END', '__CLASS__', '__DIR__', '__FILE__', 
-                '__FUNCTION__', '__LINE__', '__METHOD__', '__NAMESPACE__', 
-                'abstract', 'alias', 'and', 'args', 'as', 'assert', 'begin', 
-                'break', 'case', 'catch', 'class', 'clone', 'continue', 
-                'declare', 'def', 'default', 'del', 'delete', 'do', 'dynamic', 
-                'elif', 'else', 'elseif', 'elsif', 'end', 'enddeclare', 
-                'endfor', 'endforeach', 'endif', 'endswitch', 'endwhile', 
-                'ensure', 'except', 'exec', 'finally', 'float', 'for', 
-                'foreach', 'function', 'global', 'goto', 'if', 'implements', 
-                'import', 'in', 'inline', 'instanceof', 'interface', 'is', 
-                'lambda', 'module', 'native', 'new', 'next', 'nil', 'not', 
-                'or', 'pass', 'public', 'print', 'private', 'protected', 
-                'raise', 'redo', 'rescue', 'retry', 'register', 'return', 
-                'self', 'sizeof', 'static', 'super', 'switch', 'synchronized', 
-                'then', 'this', 'throw', 'transient', 'try', 'undef', 
-                'unless', 'unsigned', 'until', 'use', 'var', 'virtual', 
-                'volatile', 'when', 'while', 'with', 'xor', 'yield'), 
-                prefix=r'\b', suffix=r'\b'), 
-             Keyword.Reserved), 
-        ], 
-        'numbers': [ 
-            (r'[+-]?(\d+\.\d+([eE][+-]?\d+)?|\.?\d+[eE][+-]?\d+)', Number.Float), 
-            (r'[+-]?0x[0-9A-Fa-f]+', Number.Hex), 
-            (r'[+-]?[0-9]+', Number.Integer), 
-        ], 
-    } 
- 
- 
+                'senum'), suffix=r'\b'),
+             Keyword.Type),
+            (words((
+                'BEGIN', 'END', '__CLASS__', '__DIR__', '__FILE__',
+                '__FUNCTION__', '__LINE__', '__METHOD__', '__NAMESPACE__',
+                'abstract', 'alias', 'and', 'args', 'as', 'assert', 'begin',
+                'break', 'case', 'catch', 'class', 'clone', 'continue',
+                'declare', 'def', 'default', 'del', 'delete', 'do', 'dynamic',
+                'elif', 'else', 'elseif', 'elsif', 'end', 'enddeclare',
+                'endfor', 'endforeach', 'endif', 'endswitch', 'endwhile',
+                'ensure', 'except', 'exec', 'finally', 'float', 'for',
+                'foreach', 'function', 'global', 'goto', 'if', 'implements',
+                'import', 'in', 'inline', 'instanceof', 'interface', 'is',
+                'lambda', 'module', 'native', 'new', 'next', 'nil', 'not',
+                'or', 'pass', 'public', 'print', 'private', 'protected',
+                'raise', 'redo', 'rescue', 'retry', 'register', 'return',
+                'self', 'sizeof', 'static', 'super', 'switch', 'synchronized',
+                'then', 'this', 'throw', 'transient', 'try', 'undef',
+                'unless', 'unsigned', 'until', 'use', 'var', 'virtual',
+                'volatile', 'when', 'while', 'with', 'xor', 'yield'),
+                prefix=r'\b', suffix=r'\b'),
+             Keyword.Reserved),
+        ],
+        'numbers': [
+            (r'[+-]?(\d+\.\d+([eE][+-]?\d+)?|\.?\d+[eE][+-]?\d+)', Number.Float),
+            (r'[+-]?0x[0-9A-Fa-f]+', Number.Hex),
+            (r'[+-]?[0-9]+', Number.Integer),
+        ],
+    }
+
+
 class ZeekLexer(RegexLexer):
-    """ 
+    """
     For `Zeek <https://www.zeek.org/>`_ scripts.
- 
+
     .. versionadded:: 2.5
-    """ 
+    """
     name = 'Zeek'
     aliases = ['zeek', 'bro']
     filenames = ['*.zeek', '*.bro']
- 
+
     _hex = r'[0-9a-fA-F]'
-    _float = r'((\d*\.?\d+)|(\d+\.?\d*))([eE][-+]?\d+)?' 
-    _h = r'[A-Za-z0-9][-A-Za-z0-9]*' 
- 
-    tokens = { 
-        'root': [ 
+    _float = r'((\d*\.?\d+)|(\d+\.?\d*))([eE][-+]?\d+)?'
+    _h = r'[A-Za-z0-9][-A-Za-z0-9]*'
+
+    tokens = {
+        'root': [
             include('whitespace'),
             include('comments'),
             include('directives'),
@@ -288,7 +288,7 @@ class ZeekLexer(RegexLexer):
             # operator.
             (r'/(?=.*/)', String.Regex, 'regex'),
 
-            (r'(T|F)\b', Keyword.Constant), 
+            (r'(T|F)\b', Keyword.Constant),
 
             # Port
             (r'\d{1,5}/(udp|tcp|icmp|unknown)\b', Number),
@@ -305,13 +305,13 @@ class ZeekLexer(RegexLexer):
             (_float + r'\b', Number.Float),
             (r'(\d+)\b', Number.Integer),
 
-            # Hostnames 
-            (_h + r'(\.' + _h + r')+', String), 
+            # Hostnames
+            (_h + r'(\.' + _h + r')+', String),
         ],
 
         'operators': [
             (r'[!%*/+<=>~|&^-]', Operator),
-            (r'([-+=&|]{2}|[+=!><-]=)', Operator), 
+            (r'([-+=&|]{2}|[+=!><-]=)', Operator),
             (r'(in|as|is|of)\b', Operator.Word),
             (r'\??\$', Operator),
         ],
@@ -327,456 +327,456 @@ class ZeekLexer(RegexLexer):
 
         'identifiers': [
             (r'([a-zA-Z_]\w*)(::)', bygroups(Name, Punctuation)),
-            (r'[a-zA-Z_]\w*', Name) 
-        ], 
+            (r'[a-zA-Z_]\w*', Name)
+        ],
 
-        'string': [ 
+        'string': [
             (r'\\.', String.Escape),
             (r'%-?[0-9]*(\.[0-9]+)?[DTd-gsx]', String.Escape),
-            (r'"', String, '#pop'), 
+            (r'"', String, '#pop'),
             (r'.', String),
-        ], 
+        ],
 
-        'regex': [ 
+        'regex': [
             (r'\\.', String.Escape),
-            (r'/', String.Regex, '#pop'), 
+            (r'/', String.Regex, '#pop'),
             (r'.', String.Regex),
         ],
-    } 
- 
- 
+    }
+
+
 BroLexer = ZeekLexer
 
 
-class PuppetLexer(RegexLexer): 
-    """ 
-    For `Puppet <http://puppetlabs.com/>`__ configuration DSL. 
- 
-    .. versionadded:: 1.6 
-    """ 
-    name = 'Puppet' 
-    aliases = ['puppet'] 
-    filenames = ['*.pp'] 
- 
-    tokens = { 
-        'root': [ 
-            include('comments'), 
-            include('keywords'), 
-            include('names'), 
-            include('numbers'), 
-            include('operators'), 
-            include('strings'), 
- 
-            (r'[]{}:(),;[]', Punctuation), 
+class PuppetLexer(RegexLexer):
+    """
+    For `Puppet <http://puppetlabs.com/>`__ configuration DSL.
+
+    .. versionadded:: 1.6
+    """
+    name = 'Puppet'
+    aliases = ['puppet']
+    filenames = ['*.pp']
+
+    tokens = {
+        'root': [
+            include('comments'),
+            include('keywords'),
+            include('names'),
+            include('numbers'),
+            include('operators'),
+            include('strings'),
+
+            (r'[]{}:(),;[]', Punctuation),
             (r'\s+', Whitespace),
-        ], 
- 
-        'comments': [ 
+        ],
+
+        'comments': [
             (r'(\s*)(#.*)$', bygroups(Whitespace, Comment)),
-            (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline), 
-        ], 
- 
-        'operators': [ 
-            (r'(=>|\?|<|>|=|\+|-|/|\*|~|!|\|)', Operator), 
-            (r'(in|and|or|not)\b', Operator.Word), 
-        ], 
- 
-        'names': [ 
+            (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
+        ],
+
+        'operators': [
+            (r'(=>|\?|<|>|=|\+|-|/|\*|~|!|\|)', Operator),
+            (r'(in|and|or|not)\b', Operator.Word),
+        ],
+
+        'names': [
             (r'[a-zA-Z_]\w*', Name.Attribute),
-            (r'(\$\S+)(\[)(\S+)(\])', bygroups(Name.Variable, Punctuation, 
-                                               String, Punctuation)), 
-            (r'\$\S+', Name.Variable), 
-        ], 
- 
-        'numbers': [ 
-            # Copypasta from the Python lexer 
-            (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?', Number.Float), 
-            (r'\d+[eE][+-]?[0-9]+j?', Number.Float), 
-            (r'0[0-7]+j?', Number.Oct), 
-            (r'0[xX][a-fA-F0-9]+', Number.Hex), 
-            (r'\d+L', Number.Integer.Long), 
-            (r'\d+j?', Number.Integer) 
-        ], 
- 
-        'keywords': [ 
-            # Left out 'group' and 'require' 
-            # Since they're often used as attributes 
-            (words(( 
-                'absent', 'alert', 'alias', 'audit', 'augeas', 'before', 'case', 
-                'check', 'class', 'computer', 'configured', 'contained', 
-                'create_resources', 'crit', 'cron', 'debug', 'default', 
-                'define', 'defined', 'directory', 'else', 'elsif', 'emerg', 
-                'err', 'exec', 'extlookup', 'fail', 'false', 'file', 
-                'filebucket', 'fqdn_rand', 'generate', 'host', 'if', 'import', 
-                'include', 'info', 'inherits', 'inline_template', 'installed', 
-                'interface', 'k5login', 'latest', 'link', 'loglevel', 
-                'macauthorization', 'mailalias', 'maillist', 'mcx', 'md5', 
-                'mount', 'mounted', 'nagios_command', 'nagios_contact', 
-                'nagios_contactgroup', 'nagios_host', 'nagios_hostdependency', 
-                'nagios_hostescalation', 'nagios_hostextinfo', 'nagios_hostgroup', 
-                'nagios_service', 'nagios_servicedependency', 'nagios_serviceescalation', 
-                'nagios_serviceextinfo', 'nagios_servicegroup', 'nagios_timeperiod', 
-                'node', 'noop', 'notice', 'notify', 'package', 'present', 'purged', 
-                'realize', 'regsubst', 'resources', 'role', 'router', 'running', 
-                'schedule', 'scheduled_task', 'search', 'selboolean', 'selmodule', 
-                'service', 'sha1', 'shellquote', 'split', 'sprintf', 
-                'ssh_authorized_key', 'sshkey', 'stage', 'stopped', 'subscribe', 
-                'tag', 'tagged', 'template', 'tidy', 'true', 'undef', 'unmounted', 
-                'user', 'versioncmp', 'vlan', 'warning', 'yumrepo', 'zfs', 'zone', 
-                'zpool'), prefix='(?i)', suffix=r'\b'), 
-             Keyword), 
-        ], 
- 
-        'strings': [ 
-            (r'"([^"])*"', String), 
-            (r"'(\\'|[^'])*'", String), 
-        ], 
- 
-    } 
- 
- 
-class RslLexer(RegexLexer): 
-    """ 
-    `RSL <http://en.wikipedia.org/wiki/RAISE>`_ is the formal specification 
-    language used in RAISE (Rigorous Approach to Industrial Software Engineering) 
-    method. 
- 
-    .. versionadded:: 2.0 
-    """ 
-    name = 'RSL' 
-    aliases = ['rsl'] 
-    filenames = ['*.rsl'] 
-    mimetypes = ['text/rsl'] 
- 
-    flags = re.MULTILINE | re.DOTALL 
- 
-    tokens = { 
-        'root': [ 
-            (words(( 
-                'Bool', 'Char', 'Int', 'Nat', 'Real', 'Text', 'Unit', 'abs', 
-                'all', 'always', 'any', 'as', 'axiom', 'card', 'case', 'channel', 
-                'chaos', 'class', 'devt_relation', 'dom', 'elems', 'else', 'elif', 
-                'end', 'exists', 'extend', 'false', 'for', 'hd', 'hide', 'if', 
-                'in', 'is', 'inds', 'initialise', 'int', 'inter', 'isin', 'len', 
-                'let', 'local', 'ltl_assertion', 'object', 'of', 'out', 'post', 
-                'pre', 'read', 'real', 'rng', 'scheme', 'skip', 'stop', 'swap', 
-                'then', 'theory', 'test_case', 'tl', 'transition_system', 'true', 
-                'type', 'union', 'until', 'use', 'value', 'variable', 'while', 
-                'with', 'write', '~isin', '-inflist', '-infset', '-list', 
-                '-set'), prefix=r'\b', suffix=r'\b'), 
-             Keyword), 
-            (r'(variable|value)\b', Keyword.Declaration), 
-            (r'--.*?\n', Comment), 
-            (r'<:.*?:>', Comment), 
-            (r'\{!.*?!\}', Comment), 
-            (r'/\*.*?\*/', Comment), 
+            (r'(\$\S+)(\[)(\S+)(\])', bygroups(Name.Variable, Punctuation,
+                                               String, Punctuation)),
+            (r'\$\S+', Name.Variable),
+        ],
+
+        'numbers': [
+            # Copypasta from the Python lexer
+            (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?', Number.Float),
+            (r'\d+[eE][+-]?[0-9]+j?', Number.Float),
+            (r'0[0-7]+j?', Number.Oct),
+            (r'0[xX][a-fA-F0-9]+', Number.Hex),
+            (r'\d+L', Number.Integer.Long),
+            (r'\d+j?', Number.Integer)
+        ],
+
+        'keywords': [
+            # Left out 'group' and 'require'
+            # Since they're often used as attributes
+            (words((
+                'absent', 'alert', 'alias', 'audit', 'augeas', 'before', 'case',
+                'check', 'class', 'computer', 'configured', 'contained',
+                'create_resources', 'crit', 'cron', 'debug', 'default',
+                'define', 'defined', 'directory', 'else', 'elsif', 'emerg',
+                'err', 'exec', 'extlookup', 'fail', 'false', 'file',
+                'filebucket', 'fqdn_rand', 'generate', 'host', 'if', 'import',
+                'include', 'info', 'inherits', 'inline_template', 'installed',
+                'interface', 'k5login', 'latest', 'link', 'loglevel',
+                'macauthorization', 'mailalias', 'maillist', 'mcx', 'md5',
+                'mount', 'mounted', 'nagios_command', 'nagios_contact',
+                'nagios_contactgroup', 'nagios_host', 'nagios_hostdependency',
+                'nagios_hostescalation', 'nagios_hostextinfo', 'nagios_hostgroup',
+                'nagios_service', 'nagios_servicedependency', 'nagios_serviceescalation',
+                'nagios_serviceextinfo', 'nagios_servicegroup', 'nagios_timeperiod',
+                'node', 'noop', 'notice', 'notify', 'package', 'present', 'purged',
+                'realize', 'regsubst', 'resources', 'role', 'router', 'running',
+                'schedule', 'scheduled_task', 'search', 'selboolean', 'selmodule',
+                'service', 'sha1', 'shellquote', 'split', 'sprintf',
+                'ssh_authorized_key', 'sshkey', 'stage', 'stopped', 'subscribe',
+                'tag', 'tagged', 'template', 'tidy', 'true', 'undef', 'unmounted',
+                'user', 'versioncmp', 'vlan', 'warning', 'yumrepo', 'zfs', 'zone',
+                'zpool'), prefix='(?i)', suffix=r'\b'),
+             Keyword),
+        ],
+
+        'strings': [
+            (r'"([^"])*"', String),
+            (r"'(\\'|[^'])*'", String),
+        ],
+
+    }
+
+
+class RslLexer(RegexLexer):
+    """
+    `RSL <http://en.wikipedia.org/wiki/RAISE>`_ is the formal specification
+    language used in RAISE (Rigorous Approach to Industrial Software Engineering)
+    method.
+
+    .. versionadded:: 2.0
+    """
+    name = 'RSL'
+    aliases = ['rsl']
+    filenames = ['*.rsl']
+    mimetypes = ['text/rsl']
+
+    flags = re.MULTILINE | re.DOTALL
+
+    tokens = {
+        'root': [
+            (words((
+                'Bool', 'Char', 'Int', 'Nat', 'Real', 'Text', 'Unit', 'abs',
+                'all', 'always', 'any', 'as', 'axiom', 'card', 'case', 'channel',
+                'chaos', 'class', 'devt_relation', 'dom', 'elems', 'else', 'elif',
+                'end', 'exists', 'extend', 'false', 'for', 'hd', 'hide', 'if',
+                'in', 'is', 'inds', 'initialise', 'int', 'inter', 'isin', 'len',
+                'let', 'local', 'ltl_assertion', 'object', 'of', 'out', 'post',
+                'pre', 'read', 'real', 'rng', 'scheme', 'skip', 'stop', 'swap',
+                'then', 'theory', 'test_case', 'tl', 'transition_system', 'true',
+                'type', 'union', 'until', 'use', 'value', 'variable', 'while',
+                'with', 'write', '~isin', '-inflist', '-infset', '-list',
+                '-set'), prefix=r'\b', suffix=r'\b'),
+             Keyword),
+            (r'(variable|value)\b', Keyword.Declaration),
+            (r'--.*?\n', Comment),
+            (r'<:.*?:>', Comment),
+            (r'\{!.*?!\}', Comment),
+            (r'/\*.*?\*/', Comment),
             (r'^([ \t]*)([\w]+)([ \t]*)(:[^:])', bygroups(Whitespace,
                 Name.Function, Whitespace, Name.Function)),
             (r'(^[ \t]*)([\w]+)([ \t]*)(\([\w\s,]*\))([ \t]*)(is|as)',
              bygroups(Whitespace, Name.Function, Whitespace, Text,
                  Whitespace, Keyword)),
-            (r'\b[A-Z]\w*\b', Keyword.Type), 
-            (r'(true|false)\b', Keyword.Constant), 
-            (r'".*"', String), 
-            (r'\'.\'', String.Char), 
-            (r'(><|->|-m->|/\\|<=|<<=|<\.|\|\||\|\^\||-~->|-~m->|\\/|>=|>>|' 
-             r'\.>|\+\+|-\\|<->|=>|:-|~=|\*\*|<<|>>=|\+>|!!|\|=\||#)', 
-             Operator), 
-            (r'[0-9]+\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float), 
-            (r'0x[0-9a-f]+', Number.Hex), 
-            (r'[0-9]+', Number.Integer), 
+            (r'\b[A-Z]\w*\b', Keyword.Type),
+            (r'(true|false)\b', Keyword.Constant),
+            (r'".*"', String),
+            (r'\'.\'', String.Char),
+            (r'(><|->|-m->|/\\|<=|<<=|<\.|\|\||\|\^\||-~->|-~m->|\\/|>=|>>|'
+             r'\.>|\+\+|-\\|<->|=>|:-|~=|\*\*|<<|>>=|\+>|!!|\|=\||#)',
+             Operator),
+            (r'[0-9]+\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
+            (r'0x[0-9a-f]+', Number.Hex),
+            (r'[0-9]+', Number.Integer),
             (r'\s+', Whitespace),
-            (r'.', Text), 
-        ], 
-    } 
- 
-    def analyse_text(text): 
-        """ 
-        Check for the most common text in the beginning of a RSL file. 
-        """ 
-        if re.search(r'scheme\s*.*?=\s*class\s*type', text, re.I) is not None: 
-            return 1.0 
- 
- 
-class MscgenLexer(RegexLexer): 
-    """ 
-    For `Mscgen <http://www.mcternan.me.uk/mscgen/>`_ files. 
- 
-    .. versionadded:: 1.6 
-    """ 
-    name = 'Mscgen' 
-    aliases = ['mscgen', 'msc'] 
-    filenames = ['*.msc'] 
- 
-    _var = r'(\w+|"(?:\\"|[^"])*")' 
- 
-    tokens = { 
-        'root': [ 
-            (r'msc\b', Keyword.Type), 
-            # Options 
-            (r'(hscale|HSCALE|width|WIDTH|wordwraparcs|WORDWRAPARCS' 
-             r'|arcgradient|ARCGRADIENT)\b', Name.Property), 
-            # Operators 
-            (r'(abox|ABOX|rbox|RBOX|box|BOX|note|NOTE)\b', Operator.Word), 
-            (r'(\.|-|\|){3}', Keyword), 
-            (r'(?:-|=|\.|:){2}' 
-             r'|<<=>>|<->|<=>|<<>>|<:>' 
-             r'|->|=>>|>>|=>|:>|-x|-X' 
-             r'|<-|<<=|<<|<=|<:|x-|X-|=', Operator), 
-            # Names 
-            (r'\*', Name.Builtin), 
-            (_var, Name.Variable), 
-            # Other 
-            (r'\[', Punctuation, 'attrs'), 
-            (r'\{|\}|,|;', Punctuation), 
-            include('comments') 
-        ], 
-        'attrs': [ 
-            (r'\]', Punctuation, '#pop'), 
-            (_var + r'(\s*)(=)(\s*)' + _var, 
+            (r'.', Text),
+        ],
+    }
+
+    def analyse_text(text):
+        """
+        Check for the most common text in the beginning of a RSL file.
+        """
+        if re.search(r'scheme\s*.*?=\s*class\s*type', text, re.I) is not None:
+            return 1.0
+
+
+class MscgenLexer(RegexLexer):
+    """
+    For `Mscgen <http://www.mcternan.me.uk/mscgen/>`_ files.
+
+    .. versionadded:: 1.6
+    """
+    name = 'Mscgen'
+    aliases = ['mscgen', 'msc']
+    filenames = ['*.msc']
+
+    _var = r'(\w+|"(?:\\"|[^"])*")'
+
+    tokens = {
+        'root': [
+            (r'msc\b', Keyword.Type),
+            # Options
+            (r'(hscale|HSCALE|width|WIDTH|wordwraparcs|WORDWRAPARCS'
+             r'|arcgradient|ARCGRADIENT)\b', Name.Property),
+            # Operators
+            (r'(abox|ABOX|rbox|RBOX|box|BOX|note|NOTE)\b', Operator.Word),
+            (r'(\.|-|\|){3}', Keyword),
+            (r'(?:-|=|\.|:){2}'
+             r'|<<=>>|<->|<=>|<<>>|<:>'
+             r'|->|=>>|>>|=>|:>|-x|-X'
+             r'|<-|<<=|<<|<=|<:|x-|X-|=', Operator),
+            # Names
+            (r'\*', Name.Builtin),
+            (_var, Name.Variable),
+            # Other
+            (r'\[', Punctuation, 'attrs'),
+            (r'\{|\}|,|;', Punctuation),
+            include('comments')
+        ],
+        'attrs': [
+            (r'\]', Punctuation, '#pop'),
+            (_var + r'(\s*)(=)(\s*)' + _var,
              bygroups(Name.Attribute, Whitespace, Operator, Whitespace,
-                      String)), 
-            (r',', Punctuation), 
-            include('comments') 
-        ], 
-        'comments': [ 
-            (r'(?://|#).*?\n', Comment.Single), 
-            (r'/\*(?:.|\n)*?\*/', Comment.Multiline), 
+                      String)),
+            (r',', Punctuation),
+            include('comments')
+        ],
+        'comments': [
+            (r'(?://|#).*?\n', Comment.Single),
+            (r'/\*(?:.|\n)*?\*/', Comment.Multiline),
             (r'[ \t\r\n]+', Whitespace)
-        ] 
-    } 
- 
- 
-class VGLLexer(RegexLexer): 
-    """ 
-    For `SampleManager VGL <http://www.thermoscientific.com/samplemanager>`_ 
-    source code. 
- 
-    .. versionadded:: 1.6 
-    """ 
-    name = 'VGL' 
-    aliases = ['vgl'] 
-    filenames = ['*.rpf'] 
- 
-    flags = re.MULTILINE | re.DOTALL | re.IGNORECASE 
- 
-    tokens = { 
-        'root': [ 
-            (r'\{[^}]*\}', Comment.Multiline), 
-            (r'declare', Keyword.Constant), 
-            (r'(if|then|else|endif|while|do|endwhile|and|or|prompt|object' 
-             r'|create|on|line|with|global|routine|value|endroutine|constant' 
-             r'|global|set|join|library|compile_option|file|exists|create|copy' 
-             r'|delete|enable|windows|name|notprotected)(?! *[=<>.,()])', 
-             Keyword), 
-            (r'(true|false|null|empty|error|locked)', Keyword.Constant), 
-            (r'[~^*#!%&\[\]()<>|+=:;,./?-]', Operator), 
-            (r'"[^"]*"', String), 
-            (r'(\.)([a-z_$][\w$]*)', bygroups(Operator, Name.Attribute)), 
-            (r'[0-9][0-9]*(\.[0-9]+(e[+\-]?[0-9]+)?)?', Number), 
-            (r'[a-z_$][\w$]*', Name), 
+        ]
+    }
+
+
+class VGLLexer(RegexLexer):
+    """
+    For `SampleManager VGL <http://www.thermoscientific.com/samplemanager>`_
+    source code.
+
+    .. versionadded:: 1.6
+    """
+    name = 'VGL'
+    aliases = ['vgl']
+    filenames = ['*.rpf']
+
+    flags = re.MULTILINE | re.DOTALL | re.IGNORECASE
+
+    tokens = {
+        'root': [
+            (r'\{[^}]*\}', Comment.Multiline),
+            (r'declare', Keyword.Constant),
+            (r'(if|then|else|endif|while|do|endwhile|and|or|prompt|object'
+             r'|create|on|line|with|global|routine|value|endroutine|constant'
+             r'|global|set|join|library|compile_option|file|exists|create|copy'
+             r'|delete|enable|windows|name|notprotected)(?! *[=<>.,()])',
+             Keyword),
+            (r'(true|false|null|empty|error|locked)', Keyword.Constant),
+            (r'[~^*#!%&\[\]()<>|+=:;,./?-]', Operator),
+            (r'"[^"]*"', String),
+            (r'(\.)([a-z_$][\w$]*)', bygroups(Operator, Name.Attribute)),
+            (r'[0-9][0-9]*(\.[0-9]+(e[+\-]?[0-9]+)?)?', Number),
+            (r'[a-z_$][\w$]*', Name),
             (r'[\r\n]+', Whitespace),
             (r'\s+', Whitespace)
-        ] 
-    } 
- 
- 
-class AlloyLexer(RegexLexer): 
-    """ 
-    For `Alloy <http://alloy.mit.edu>`_ source code. 
- 
-    .. versionadded:: 2.0 
-    """ 
- 
-    name = 'Alloy' 
-    aliases = ['alloy'] 
-    filenames = ['*.als'] 
-    mimetypes = ['text/x-alloy'] 
- 
-    flags = re.MULTILINE | re.DOTALL 
- 
-    iden_rex = r'[a-zA-Z_][\w\']*' 
+        ]
+    }
+
+
+class AlloyLexer(RegexLexer):
+    """
+    For `Alloy <http://alloy.mit.edu>`_ source code.
+
+    .. versionadded:: 2.0
+    """
+
+    name = 'Alloy'
+    aliases = ['alloy']
+    filenames = ['*.als']
+    mimetypes = ['text/x-alloy']
+
+    flags = re.MULTILINE | re.DOTALL
+
+    iden_rex = r'[a-zA-Z_][\w\']*'
     text_tuple = (r'[^\S\n]+', Whitespace)
- 
-    tokens = { 
-        'sig': [ 
-            (r'(extends)\b', Keyword, '#pop'), 
-            (iden_rex, Name), 
-            text_tuple, 
-            (r',', Punctuation), 
-            (r'\{', Operator, '#pop'), 
-        ], 
-        'module': [ 
-            text_tuple, 
-            (iden_rex, Name, '#pop'), 
-        ], 
-        'fun': [ 
-            text_tuple, 
-            (r'\{', Operator, '#pop'), 
-            (iden_rex, Name, '#pop'), 
-        ], 
-        'root': [ 
-            (r'--.*?$', Comment.Single), 
-            (r'//.*?$', Comment.Single), 
-            (r'/\*.*?\*/', Comment.Multiline), 
-            text_tuple, 
+
+    tokens = {
+        'sig': [
+            (r'(extends)\b', Keyword, '#pop'),
+            (iden_rex, Name),
+            text_tuple,
+            (r',', Punctuation),
+            (r'\{', Operator, '#pop'),
+        ],
+        'module': [
+            text_tuple,
+            (iden_rex, Name, '#pop'),
+        ],
+        'fun': [
+            text_tuple,
+            (r'\{', Operator, '#pop'),
+            (iden_rex, Name, '#pop'),
+        ],
+        'root': [
+            (r'--.*?$', Comment.Single),
+            (r'//.*?$', Comment.Single),
+            (r'/\*.*?\*/', Comment.Multiline),
+            text_tuple,
             (r'(module|open)(\s+)', bygroups(Keyword.Namespace, Whitespace),
-                'module'), 
+                'module'),
             (r'(sig|enum)(\s+)', bygroups(Keyword.Declaration, Whitespace), 'sig'),
-            (r'(iden|univ|none)\b', Keyword.Constant), 
-            (r'(int|Int)\b', Keyword.Type), 
-            (r'(this|abstract|extends|set|seq|one|lone|let)\b', Keyword), 
-            (r'(all|some|no|sum|disj|when|else)\b', Keyword), 
-            (r'(run|check|for|but|exactly|expect|as)\b', Keyword), 
-            (r'(and|or|implies|iff|in)\b', Operator.Word), 
+            (r'(iden|univ|none)\b', Keyword.Constant),
+            (r'(int|Int)\b', Keyword.Type),
+            (r'(this|abstract|extends|set|seq|one|lone|let)\b', Keyword),
+            (r'(all|some|no|sum|disj|when|else)\b', Keyword),
+            (r'(run|check|for|but|exactly|expect|as)\b', Keyword),
+            (r'(and|or|implies|iff|in)\b', Operator.Word),
             (r'(fun|pred|fact|assert)(\s+)', bygroups(Keyword, Whitespace), 'fun'),
-            (r'!|#|&&|\+\+|<<|>>|>=|<=>|<=|\.|->', Operator), 
-            (r'[-+/*%=<>&!^|~{}\[\]().]', Operator), 
-            (iden_rex, Name), 
-            (r'[:,]', Punctuation), 
-            (r'[0-9]+', Number.Integer), 
+            (r'!|#|&&|\+\+|<<|>>|>=|<=>|<=|\.|->', Operator),
+            (r'[-+/*%=<>&!^|~{}\[\]().]', Operator),
+            (iden_rex, Name),
+            (r'[:,]', Punctuation),
+            (r'[0-9]+', Number.Integer),
             (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
             (r'\n', Whitespace),
-        ] 
-    } 
- 
- 
-class PanLexer(RegexLexer): 
-    """ 
+        ]
+    }
+
+
+class PanLexer(RegexLexer):
+    """
     Lexer for `pan <https://github.com/quattor/pan/>`_ source files.
- 
-    Based on tcsh lexer. 
- 
-    .. versionadded:: 2.0 
-    """ 
- 
-    name = 'Pan' 
-    aliases = ['pan'] 
-    filenames = ['*.pan'] 
- 
-    tokens = { 
-        'root': [ 
-            include('basic'), 
-            (r'\(', Keyword, 'paren'), 
-            (r'\{', Keyword, 'curly'), 
-            include('data'), 
-        ], 
-        'basic': [ 
-            (words(( 
-                'if', 'for', 'with', 'else', 'type', 'bind', 'while', 'valid', 'final', 
-                'prefix', 'unique', 'object', 'foreach', 'include', 'template', 
-                'function', 'variable', 'structure', 'extensible', 'declaration'), 
+
+    Based on tcsh lexer.
+
+    .. versionadded:: 2.0
+    """
+
+    name = 'Pan'
+    aliases = ['pan']
+    filenames = ['*.pan']
+
+    tokens = {
+        'root': [
+            include('basic'),
+            (r'\(', Keyword, 'paren'),
+            (r'\{', Keyword, 'curly'),
+            include('data'),
+        ],
+        'basic': [
+            (words((
+                'if', 'for', 'with', 'else', 'type', 'bind', 'while', 'valid', 'final',
+                'prefix', 'unique', 'object', 'foreach', 'include', 'template',
+                'function', 'variable', 'structure', 'extensible', 'declaration'),
                 prefix=r'\b', suffix=r'\b'),
-             Keyword), 
-            (words(( 
-                'file_contents', 'format', 'index', 'length', 'match', 'matches', 
-                'replace', 'splice', 'split', 'substr', 'to_lowercase', 'to_uppercase', 
-                'debug', 'error', 'traceback', 'deprecated', 'base64_decode', 
-                'base64_encode', 'digest', 'escape', 'unescape', 'append', 'create', 
-                'first', 'nlist', 'key', 'list', 'merge', 'next', 'prepend', 'is_boolean', 
-                'is_defined', 'is_double', 'is_list', 'is_long', 'is_nlist', 'is_null', 
-                'is_number', 'is_property', 'is_resource', 'is_string', 'to_boolean', 
-                'to_double', 'to_long', 'to_string', 'clone', 'delete', 'exists', 
-                'path_exists', 'if_exists', 'return', 'value'), 
+             Keyword),
+            (words((
+                'file_contents', 'format', 'index', 'length', 'match', 'matches',
+                'replace', 'splice', 'split', 'substr', 'to_lowercase', 'to_uppercase',
+                'debug', 'error', 'traceback', 'deprecated', 'base64_decode',
+                'base64_encode', 'digest', 'escape', 'unescape', 'append', 'create',
+                'first', 'nlist', 'key', 'list', 'merge', 'next', 'prepend', 'is_boolean',
+                'is_defined', 'is_double', 'is_list', 'is_long', 'is_nlist', 'is_null',
+                'is_number', 'is_property', 'is_resource', 'is_string', 'to_boolean',
+                'to_double', 'to_long', 'to_string', 'clone', 'delete', 'exists',
+                'path_exists', 'if_exists', 'return', 'value'),
                 prefix=r'\b', suffix=r'\b'),
-             Name.Builtin), 
-            (r'#.*', Comment), 
-            (r'\\[\w\W]', String.Escape), 
+             Name.Builtin),
+            (r'#.*', Comment),
+            (r'\\[\w\W]', String.Escape),
             (r'(\b\w+)(\s*)(=)', bygroups(Name.Variable, Whitespace, Operator)),
-            (r'[\[\]{}()=]+', Operator), 
-            (r'<<\s*(\'?)\\?(\w+)[\w\W]+?\2', String), 
-            (r';', Punctuation), 
-        ], 
-        'data': [ 
-            (r'(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double), 
-            (r"(?s)'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single), 
+            (r'[\[\]{}()=]+', Operator),
+            (r'<<\s*(\'?)\\?(\w+)[\w\W]+?\2', String),
+            (r';', Punctuation),
+        ],
+        'data': [
+            (r'(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double),
+            (r"(?s)'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single),
             (r'\s+', Whitespace),
-            (r'[^=\s\[\]{}()$"\'`\\;#]+', Text), 
-            (r'\d+(?= |\Z)', Number), 
-        ], 
-        'curly': [ 
-            (r'\}', Keyword, '#pop'), 
-            (r':-', Keyword), 
-            (r'\w+', Name.Variable), 
-            (r'[^}:"\'`$]+', Punctuation), 
-            (r':', Punctuation), 
-            include('root'), 
-        ], 
-        'paren': [ 
-            (r'\)', Keyword, '#pop'), 
-            include('root'), 
-        ], 
-    } 
- 
- 
-class CrmshLexer(RegexLexer): 
-    """ 
-    Lexer for `crmsh <http://crmsh.github.io/>`_ configuration files 
-    for Pacemaker clusters. 
- 
-    .. versionadded:: 2.1 
-    """ 
-    name = 'Crmsh' 
-    aliases = ['crmsh', 'pcmk'] 
-    filenames = ['*.crmsh', '*.pcmk'] 
-    mimetypes = [] 
- 
-    elem = words(( 
-        'node', 'primitive', 'group', 'clone', 'ms', 'location', 
-        'colocation', 'order', 'fencing_topology', 'rsc_ticket', 
-        'rsc_template', 'property', 'rsc_defaults', 
-        'op_defaults', 'acl_target', 'acl_group', 'user', 'role', 
-        'tag'), suffix=r'(?![\w#$-])') 
-    sub = words(( 
-        'params', 'meta', 'operations', 'op', 'rule', 
-        'attributes', 'utilization'), suffix=r'(?![\w#$-])') 
-    acl = words(('read', 'write', 'deny'), suffix=r'(?![\w#$-])') 
-    bin_rel = words(('and', 'or'), suffix=r'(?![\w#$-])') 
-    un_ops = words(('defined', 'not_defined'), suffix=r'(?![\w#$-])') 
-    date_exp = words(('in_range', 'date', 'spec', 'in'), suffix=r'(?![\w#$-])') 
-    acl_mod = (r'(?:tag|ref|reference|attribute|type|xpath)') 
-    bin_ops = (r'(?:lt|gt|lte|gte|eq|ne)') 
-    val_qual = (r'(?:string|version|number)') 
-    rsc_role_action = (r'(?:Master|Started|Slave|Stopped|' 
-                       r'start|promote|demote|stop)') 
- 
-    tokens = { 
-        'root': [ 
+            (r'[^=\s\[\]{}()$"\'`\\;#]+', Text),
+            (r'\d+(?= |\Z)', Number),
+        ],
+        'curly': [
+            (r'\}', Keyword, '#pop'),
+            (r':-', Keyword),
+            (r'\w+', Name.Variable),
+            (r'[^}:"\'`$]+', Punctuation),
+            (r':', Punctuation),
+            include('root'),
+        ],
+        'paren': [
+            (r'\)', Keyword, '#pop'),
+            include('root'),
+        ],
+    }
+
+
+class CrmshLexer(RegexLexer):
+    """
+    Lexer for `crmsh <http://crmsh.github.io/>`_ configuration files
+    for Pacemaker clusters.
+
+    .. versionadded:: 2.1
+    """
+    name = 'Crmsh'
+    aliases = ['crmsh', 'pcmk']
+    filenames = ['*.crmsh', '*.pcmk']
+    mimetypes = []
+
+    elem = words((
+        'node', 'primitive', 'group', 'clone', 'ms', 'location',
+        'colocation', 'order', 'fencing_topology', 'rsc_ticket',
+        'rsc_template', 'property', 'rsc_defaults',
+        'op_defaults', 'acl_target', 'acl_group', 'user', 'role',
+        'tag'), suffix=r'(?![\w#$-])')
+    sub = words((
+        'params', 'meta', 'operations', 'op', 'rule',
+        'attributes', 'utilization'), suffix=r'(?![\w#$-])')
+    acl = words(('read', 'write', 'deny'), suffix=r'(?![\w#$-])')
+    bin_rel = words(('and', 'or'), suffix=r'(?![\w#$-])')
+    un_ops = words(('defined', 'not_defined'), suffix=r'(?![\w#$-])')
+    date_exp = words(('in_range', 'date', 'spec', 'in'), suffix=r'(?![\w#$-])')
+    acl_mod = (r'(?:tag|ref|reference|attribute|type|xpath)')
+    bin_ops = (r'(?:lt|gt|lte|gte|eq|ne)')
+    val_qual = (r'(?:string|version|number)')
+    rsc_role_action = (r'(?:Master|Started|Slave|Stopped|'
+                       r'start|promote|demote|stop)')
+
+    tokens = {
+        'root': [
             (r'^(#.*)(\n)?', bygroups(Comment, Whitespace)),
-            # attr=value (nvpair) 
-            (r'([\w#$-]+)(=)("(?:""|[^"])*"|\S+)', 
-                bygroups(Name.Attribute, Punctuation, String)), 
-            # need this construct, otherwise numeric node ids 
-            # are matched as scores 
-            # elem id: 
-            (r'(node)(\s+)([\w#$-]+)(:)', 
-                bygroups(Keyword, Whitespace, Name, Punctuation)), 
-            # scores 
-            (r'([+-]?([0-9]+|inf)):', Number), 
-            # keywords (elements and other) 
-            (elem, Keyword), 
-            (sub, Keyword), 
-            (acl, Keyword), 
-            # binary operators 
-            (r'(?:%s:)?(%s)(?![\w#$-])' % (val_qual, bin_ops), Operator.Word), 
-            # other operators 
-            (bin_rel, Operator.Word), 
-            (un_ops, Operator.Word), 
-            (date_exp, Operator.Word), 
-            # builtin attributes (e.g. #uname) 
-            (r'#[a-z]+(?![\w#$-])', Name.Builtin), 
-            # acl_mod:blah 
-            (r'(%s)(:)("(?:""|[^"])*"|\S+)' % acl_mod, 
-             bygroups(Keyword, Punctuation, Name)), 
-            # rsc_id[:(role|action)] 
-            # NB: this matches all other identifiers 
-            (r'([\w#$-]+)(?:(:)(%s))?(?![\w#$-])' % rsc_role_action, 
-             bygroups(Name, Punctuation, Operator.Word)), 
-            # punctuation 
+            # attr=value (nvpair)
+            (r'([\w#$-]+)(=)("(?:""|[^"])*"|\S+)',
+                bygroups(Name.Attribute, Punctuation, String)),
+            # need this construct, otherwise numeric node ids
+            # are matched as scores
+            # elem id:
+            (r'(node)(\s+)([\w#$-]+)(:)',
+                bygroups(Keyword, Whitespace, Name, Punctuation)),
+            # scores
+            (r'([+-]?([0-9]+|inf)):', Number),
+            # keywords (elements and other)
+            (elem, Keyword),
+            (sub, Keyword),
+            (acl, Keyword),
+            # binary operators
+            (r'(?:%s:)?(%s)(?![\w#$-])' % (val_qual, bin_ops), Operator.Word),
+            # other operators
+            (bin_rel, Operator.Word),
+            (un_ops, Operator.Word),
+            (date_exp, Operator.Word),
+            # builtin attributes (e.g. #uname)
+            (r'#[a-z]+(?![\w#$-])', Name.Builtin),
+            # acl_mod:blah
+            (r'(%s)(:)("(?:""|[^"])*"|\S+)' % acl_mod,
+             bygroups(Keyword, Punctuation, Name)),
+            # rsc_id[:(role|action)]
+            # NB: this matches all other identifiers
+            (r'([\w#$-]+)(?:(:)(%s))?(?![\w#$-])' % rsc_role_action,
+             bygroups(Name, Punctuation, Operator.Word)),
+            # punctuation
             (r'(\\(?=\n)|[\[\](){}/:@])', Punctuation),
-            (r'\s+|\n', Whitespace), 
-        ], 
-    } 
+            (r'\s+|\n', Whitespace),
+        ],
+    }
 
 
 class FlatlineLexer(RegexLexer):