pygments.rb 1.1.2 → 2.0.0

data/vendor/pygments-main/pygments/lexers/c_like.py

@@ -5,7 +5,7 @@
 
     Lexers for other C-like languages.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -20,7 +20,7 @@ from pygments.lexers.c_cpp import CLexer, CppLexer
 from pygments.lexers import _mql_builtins
 
 __all__ = ['PikeLexer', 'NesCLexer', 'ClayLexer', 'ECLexer', 'ValaLexer',
-           'CudaLexer', 'SwigLexer', 'MqlLexer', 'ArduinoLexer']
+           'CudaLexer', 'SwigLexer', 'MqlLexer', 'ArduinoLexer', 'CharmciLexer']
 
 
 class PikeLexer(CppLexer):
@@ -105,7 +105,7 @@ class ClayLexer(RegexLexer):
     tokens = {
         'root': [
             (r'\s', Text),
-            (r'//.*?$', Comment.Singleline),
+            (r'//.*?$', Comment.Single),
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
             (r'\b(public|private|import|as|record|variant|instance'
              r'|define|overload|default|external|alias'
@@ -172,12 +172,7 @@ class ECLexer(CLexer):
             (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
             (r'(null|value|this)\b', Name.Builtin),
             inherit,
-        ],
-        'classname': [
-            (r'[a-zA-Z_]\w*', Name.Class, '#pop'),
-            # template specification
-            (r'\s*(?=>)', Text, '#pop'),
-        ],
+        ]
     }
 
 
@@ -245,7 +240,7 @@ class ValaLexer(RegexLexer):
                 'ulong', 'unichar', 'ushort'), suffix=r'\b'),
              Keyword.Type),
             (r'(true|false|null)\b', Name.Builtin),
-            ('[a-zA-Z_]\w*', Name),
+            (r'[a-zA-Z_]\w*', Name),
         ],
         'root': [
             include('whitespace'),
@@ -291,23 +286,23 @@ class CudaLexer(CLexer):
     aliases = ['cuda', 'cu']
     mimetypes = ['text/x-cuda']
 
-    function_qualifiers = set(('__device__', '__global__', '__host__',
-                               '__noinline__', '__forceinline__'))
-    variable_qualifiers = set(('__device__', '__constant__', '__shared__',
-                               '__restrict__'))
-    vector_types = set(('char1', 'uchar1', 'char2', 'uchar2', 'char3', 'uchar3',
-                        'char4', 'uchar4', 'short1', 'ushort1', 'short2', 'ushort2',
-                        'short3', 'ushort3', 'short4', 'ushort4', 'int1', 'uint1',
-                        'int2', 'uint2', 'int3', 'uint3', 'int4', 'uint4', 'long1',
-                        'ulong1', 'long2', 'ulong2', 'long3', 'ulong3', 'long4',
-                        'ulong4', 'longlong1', 'ulonglong1', 'longlong2',
-                        'ulonglong2', 'float1', 'float2', 'float3', 'float4',
-                        'double1', 'double2', 'dim3'))
-    variables = set(('gridDim', 'blockIdx', 'blockDim', 'threadIdx', 'warpSize'))
-    functions = set(('__threadfence_block', '__threadfence', '__threadfence_system',
-                     '__syncthreads', '__syncthreads_count', '__syncthreads_and',
-                     '__syncthreads_or'))
-    execution_confs = set(('<<<', '>>>'))
+    function_qualifiers = {'__device__', '__global__', '__host__',
+                           '__noinline__', '__forceinline__'}
+    variable_qualifiers = {'__device__', '__constant__', '__shared__',
+                           '__restrict__'}
+    vector_types = {'char1', 'uchar1', 'char2', 'uchar2', 'char3', 'uchar3',
+                    'char4', 'uchar4', 'short1', 'ushort1', 'short2', 'ushort2',
+                    'short3', 'ushort3', 'short4', 'ushort4', 'int1', 'uint1',
+                    'int2', 'uint2', 'int3', 'uint3', 'int4', 'uint4', 'long1',
+                    'ulong1', 'long2', 'ulong2', 'long3', 'ulong3', 'long4',
+                    'ulong4', 'longlong1', 'ulonglong1', 'longlong2',
+                    'ulonglong2', 'float1', 'float2', 'float3', 'float4',
+                    'double1', 'double2', 'dim3'}
+    variables = {'gridDim', 'blockIdx', 'blockDim', 'threadIdx', 'warpSize'}
+    functions = {'__threadfence_block', '__threadfence', '__threadfence_system',
+                 '__syncthreads', '__syncthreads_count', '__syncthreads_and',
+                 '__syncthreads_or'}
+    execution_confs = {'<<<', '>>>'}
 
     def get_tokens_unprocessed(self, text):
         for index, token, value in CLexer.get_tokens_unprocessed(self, text):
@@ -344,7 +339,7 @@ class SwigLexer(CppLexer):
             # SWIG directives
             (r'(%[a-z_][a-z0-9_]*)', Name.Function),
             # Special variables
-            ('\$\**\&?\w+', Name),
+            (r'\$\**\&?\w+', Name),
             # Stringification / additional preprocessor directives
             (r'##*[a-zA-Z_]\w*', Comment.Preproc),
             inherit,
@@ -352,7 +347,7 @@ class SwigLexer(CppLexer):
     }
 
     # This is a far from complete set of SWIG directives
-    swig_directives = set((
+    swig_directives = {
         # Most common directives
         '%apply', '%define', '%director', '%enddef', '%exception', '%extend',
         '%feature', '%fragment', '%ignore', '%immutable', '%import', '%include',
@@ -371,7 +366,7 @@ class SwigLexer(CppLexer):
         '%pythoncallback', '%pythoncode', '%pythondynamic', '%pythonmaybecall',
         '%pythonnondynamic', '%pythonprepend', '%refobject', '%shadow', '%sizeof',
         '%trackobjects', '%types', '%unrefobject', '%varargs', '%warn',
-        '%warnfilter'))
+        '%warnfilter'}
 
     def analyse_text(text):
         rv = 0
@@ -412,6 +407,7 @@ class MqlLexer(CppLexer):
         ],
     }
 
+
 class ArduinoLexer(CppLexer):
     """
     For `Arduino(tm) <https://arduino.cc/>`_ source.
@@ -428,13 +424,13 @@ class ArduinoLexer(CppLexer):
     mimetypes = ['text/x-arduino']
 
     # Language sketch main structure functions
-    structure = set(('setup', 'loop'))
+    structure = {'setup', 'loop'}
 
     # Language operators
-    operators = set(('not', 'or', 'and', 'xor'))
+    operators = {'not', 'or', 'and', 'xor'}
 
     # Language 'variables'
-    variables = set((
+    variables = {
         'DIGITAL_MESSAGE', 'FIRMATA_STRING', 'ANALOG_MESSAGE', 'REPORT_DIGITAL',
         'REPORT_ANALOG', 'INPUT_PULLUP', 'SET_PIN_MODE', 'INTERNAL2V56', 'SYSTEM_RESET',
         'LED_BUILTIN', 'INTERNAL1V1', 'SYSEX_START', 'INTERNAL', 'EXTERNAL', 'HIGH',
@@ -451,10 +447,10 @@ class ArduinoLexer(CppLexer):
         'signed', 'inline', 'delete', '_Bool', 'complex', '_Complex', '_Imaginary',
         'atomic_bool', 'atomic_char', 'atomic_schar', 'atomic_uchar', 'atomic_short',
         'atomic_ushort', 'atomic_int', 'atomic_uint', 'atomic_long', 'atomic_ulong',
-        'atomic_llong', 'atomic_ullong', 'PROGMEM'))
+        'atomic_llong', 'atomic_ullong', 'PROGMEM'}
 
     # Language shipped functions and class ( )
-    functions = set((
+    functions = {
         'KeyboardController', 'MouseController', 'SoftwareSerial', 'EthernetServer',
         'EthernetClient', 'LiquidCrystal', 'RobotControl', 'GSMVoiceCall',
         'EthernetUDP', 'EsploraTFT', 'HttpClient', 'RobotMotor', 'WiFiClient',
@@ -514,16 +510,15 @@ class ArduinoLexer(CppLexer):
         'peek', 'beep', 'rect', 'line', 'open', 'seek', 'fill', 'size', 'turn', 'stop',
         'home', 'find', 'step', 'tone', 'sqrt', 'RSSI', 'SSID', 'end', 'bit', 'tan',
         'cos', 'sin', 'pow', 'map', 'abs', 'max', 'min', 'get', 'run', 'put',
-        'isAlphaNumeric', 'isAlpha', 'isAscii', 'isWhitespace', 'isControl', 'isDigit', 
-        'isGraph', 'isLowerCase', 'isPrintable', 'isPunct', 'isSpace', 'isUpperCase', 
-        'isHexadecimalDigit'))    
+        'isAlphaNumeric', 'isAlpha', 'isAscii', 'isWhitespace', 'isControl', 'isDigit',
+        'isGraph', 'isLowerCase', 'isPrintable', 'isPunct', 'isSpace', 'isUpperCase',
+        'isHexadecimalDigit'}
 
     # do not highlight
-    suppress_highlight = set((
-        'namespace', 'template', 'mutable', 'using', 'asm', 'typeid', 
-        'typename', 'this', 'alignof', 'constexpr', 'decltype', 'noexcept', 
-        'static_assert', 'thread_local', 'restrict'))
-
+    suppress_highlight = {
+        'namespace', 'template', 'mutable', 'using', 'asm', 'typeid',
+        'typename', 'this', 'alignof', 'constexpr', 'decltype', 'noexcept',
+        'static_assert', 'thread_local', 'restrict'}
 
     def get_tokens_unprocessed(self, text):
         for index, token, value in CppLexer.get_tokens_unprocessed(self, text):
@@ -539,3 +534,33 @@ class ArduinoLexer(CppLexer):
                 yield index, Name.Function, value
             else:
                 yield index, token, value
+
+
+class CharmciLexer(CppLexer):
+    """
+    For `Charm++ <https://charm.cs.illinois.edu>`_ interface files (.ci).
+
+    .. versionadded:: 2.4
+    """
+
+    name = 'Charmci'
+    aliases = ['charmci']
+    filenames = ['*.ci']
+
+    mimetypes = []
+
+    tokens = {
+        'statements': [
+            (r'(module)(\s+)', bygroups(Keyword, Text), 'classname'),
+            (words(('mainmodule', 'mainchare', 'chare', 'array', 'group',
+                    'nodegroup', 'message', 'conditional')), Keyword),
+            (words(('entry', 'aggregate', 'threaded', 'sync', 'exclusive',
+                    'nokeep', 'notrace', 'immediate', 'expedited', 'inline',
+                    'local', 'python', 'accel', 'readwrite', 'writeonly',
+                    'accelblock', 'memcritical', 'packed', 'varsize',
+                    'initproc', 'initnode', 'initcall', 'stacksize',
+                    'createhere', 'createhome', 'reductiontarget', 'iget',
+                    'nocopy', 'mutable', 'migratable', 'readonly')), Keyword),
+            inherit,
+        ],
+    }

data/vendor/pygments-main/pygments/lexers/capnproto.py

@@ -5,15 +5,14 @@
 
     Lexers for the Cap'n Proto schema language.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 import re
 
-from pygments.lexer import RegexLexer, bygroups, words
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Literal
+from pygments.lexer import RegexLexer, default
+from pygments.token import Text, Comment, Keyword, Name, Literal
 
 __all__ = ['CapnProtoLexer']
 
@@ -30,7 +29,6 @@ class CapnProtoLexer(RegexLexer):
 
     flags = re.MULTILINE | re.UNICODE
 
-
     tokens = {
         'root': [
             (r'#.*?$', Comment.Single),
@@ -38,42 +36,43 @@ class CapnProtoLexer(RegexLexer):
             (r'=', Literal, 'expression'),
             (r':', Name.Class, 'type'),
             (r'\$', Name.Attribute, 'annotation'),
-            (r'(struct|enum|interface|union|import|using|const|annotation|extends|in|of|on|as|with|from|fixed)\b',
-                Keyword),
-            (r'[a-zA-Z0-9_.]+', Name),
-            (r'[^#@=:$a-zA-Z0-9_]+', Text),
+            (r'(struct|enum|interface|union|import|using|const|annotation|'
+             r'extends|in|of|on|as|with|from|fixed)\b',
+             Keyword),
+            (r'[\w.]+', Name),
+            (r'[^#@=:$\w]+', Text),
         ],
         'type': [
             (r'[^][=;,(){}$]+', Name.Class),
-            (r'[[(]', Name.Class, 'parentype'),
-            (r'', Name.Class, '#pop')
+            (r'[\[(]', Name.Class, 'parentype'),
+            default('#pop'),
         ],
         'parentype': [
             (r'[^][;()]+', Name.Class),
-            (r'[[(]', Name.Class, '#push'),
+            (r'[\[(]', Name.Class, '#push'),
             (r'[])]', Name.Class, '#pop'),
-            (r'', Name.Class, '#pop')
+            default('#pop'),
         ],
         'expression': [
             (r'[^][;,(){}$]+', Literal),
-            (r'[[(]', Literal, 'parenexp'),
-            (r'', Literal, '#pop')
+            (r'[\[(]', Literal, 'parenexp'),
+            default('#pop'),
         ],
         'parenexp': [
             (r'[^][;()]+', Literal),
-            (r'[[(]', Literal, '#push'),
+            (r'[\[(]', Literal, '#push'),
             (r'[])]', Literal, '#pop'),
-            (r'', Literal, '#pop')
+            default('#pop'),
         ],
         'annotation': [
             (r'[^][;,(){}=:]+', Name.Attribute),
-            (r'[[(]', Name.Attribute, 'annexp'),
-            (r'', Name.Attribute, '#pop')
+            (r'[\[(]', Name.Attribute, 'annexp'),
+            default('#pop'),
         ],
         'annexp': [
             (r'[^][;()]+', Name.Attribute),
-            (r'[[(]', Name.Attribute, '#push'),
+            (r'[\[(]', Name.Attribute, '#push'),
             (r'[])]', Name.Attribute, '#pop'),
-            (r'', Name.Attribute, '#pop')
+            default('#pop'),
         ],
     }

data/vendor/pygments-main/pygments/lexers/chapel.py

@@ -5,7 +5,7 @@
 
     Lexer for the Chapel language.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -18,7 +18,7 @@ __all__ = ['ChapelLexer']
 
 class ChapelLexer(RegexLexer):
     """
-    For `Chapel <http://chapel.cray.com/>`_ source.
+    For `Chapel <https://chapel-lang.org/>`_ source.
 
     .. versionadded:: 2.0
     """
@@ -38,21 +38,31 @@ class ChapelLexer(RegexLexer):
 
             (r'(config|const|in|inout|out|param|ref|type|var)\b',
              Keyword.Declaration),
-            (r'(false|nil|true)\b', Keyword.Constant),
-            (r'(bool|complex|imag|int|opaque|range|real|string|uint)\b',
+            (r'(false|nil|none|true)\b', Keyword.Constant),
+            (r'(bool|bytes|complex|imag|int|nothing|opaque|range|real|string|uint|void)\b',
              Keyword.Type),
             (words((
-                'align', 'as', 'atomic', 'begin', 'break', 'by', 'cobegin',
-                'coforall', 'continue', 'delete', 'dmapped', 'do', 'domain',
-                'else', 'enum', 'except', 'export', 'extern', 'for', 'forall',
-                'if', 'index', 'inline', 'iter', 'label', 'lambda', 'let',
-                'local', 'new', 'noinit', 'on', 'only', 'otherwise', 'pragma',
-                'private', 'public', 'reduce', 'require', 'return', 'scan',
-                'select', 'serial', 'single', 'sparse', 'subdomain', 'sync',
-                'then', 'use', 'when', 'where', 'while', 'with', 'yield',
+                'align', 'as', 'atomic',
+                'begin', 'borrowed', 'break', 'by',
+                'catch', 'cobegin', 'coforall', 'continue',
+                'defer', 'delete', 'dmapped', 'do', 'domain',
+                'else', 'enum', 'except', 'export', 'extern',
+                'for', 'forall', 'forwarding',
+                'if', 'import', 'index', 'init', 'inline',
+                'label', 'lambda', 'let', 'lifetime', 'local', 'locale'
+                'new', 'noinit',
+                'on', 'only', 'otherwise', 'override', 'owned',
+                'pragma', 'private', 'prototype', 'public',
+                'reduce', 'require', 'return',
+                'scan', 'select', 'serial', 'shared', 'single', 'sparse', 'subdomain', 'sync',
+                'then', 'this', 'throw', 'throws', 'try',
+                'unmanaged', 'use',
+                'when', 'where', 'while', 'with',
+                'yield',
                 'zip'), suffix=r'\b'),
              Keyword),
-            (r'(proc)((?:\s|\\\s)+)', bygroups(Keyword, Text), 'procname'),
+            (r'(iter)((?:\s)+)', bygroups(Keyword, Text), 'procname'),
+            (r'(proc)((?:\s)+)', bygroups(Keyword, Text), 'procname'),
             (r'(class|module|record|union)(\s+)', bygroups(Keyword, Text),
              'classname'),
 
@@ -96,6 +106,7 @@ class ChapelLexer(RegexLexer):
             (r'[a-zA-Z_][\w$]*', Name.Class, '#pop'),
         ],
         'procname': [
-            (r'[a-zA-Z_][\w$]*', Name.Function, '#pop'),
+            (r'([a-zA-Z_][.\w$]*|\~[a-zA-Z_][.\w$]*|[+*/!~%<>=&^|\-]{1,2})',
+             Name.Function, '#pop'),
         ],
     }

data/vendor/pygments-main/pygments/lexers/clean.py

@@ -5,14 +5,13 @@
 
     Lexer for the Clean language.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-from pygments.lexer import ExtendedRegexLexer, LexerContext, \
-    bygroups, words, include, default
-from pygments.token import Comment, Keyword, Literal, Name, Number, Operator, \
-    Punctuation, String, Text, Whitespace
+from pygments.lexer import ExtendedRegexLexer, words, default, include, bygroups
+from pygments.token import Comment, Error, Keyword, Literal, Name, Number, \
+    Operator, Punctuation, String, Whitespace
 
 __all__ = ['CleanLexer']
 
@@ -28,261 +27,153 @@ class CleanLexer(ExtendedRegexLexer):
     aliases = ['clean']
     filenames = ['*.icl', '*.dcl']
 
-    def get_tokens_unprocessed(self, text=None, context=None):
-        ctx = LexerContext(text, 0)
-        ctx.indent = 0
-        return ExtendedRegexLexer.get_tokens_unprocessed(self, text, context=ctx)
+    keywords = (
+        'case', 'ccall', 'class', 'code', 'code inline', 'derive', 'export',
+        'foreign', 'generic', 'if', 'in', 'infix', 'infixl', 'infixr',
+        'instance', 'let', 'of', 'otherwise', 'special', 'stdcall', 'where',
+        'with')
 
-    def check_class_not_import(lexer, match, ctx):
-        if match.group(0) == 'import':
-            yield match.start(), Keyword.Namespace, match.group(0)
-            ctx.stack = ctx.stack[:-1] + ['fromimportfunc']
-        else:
-            yield match.start(), Name.Class, match.group(0)
-        ctx.pos = match.end()
+    modulewords = ('implementation', 'definition', 'system')
 
-    def check_instance_class(lexer, match, ctx):
-        if match.group(0) == 'instance' or match.group(0) == 'class':
-            yield match.start(), Keyword, match.group(0)
-        else:
-            yield match.start(), Name.Function, match.group(0)
-            ctx.stack = ctx.stack + ['fromimportfunctype']
-        ctx.pos = match.end()
-
-    @staticmethod
-    def indent_len(text):
-        # Tabs are four spaces:
-        # https://svn.cs.ru.nl/repos/clean-platform/trunk/doc/STANDARDS.txt
-        text = text.replace('\n', '')
-        return len(text.replace('\t', '    ')), len(text)
-
-    def store_indent(lexer, match, ctx):
-        ctx.indent, _ = CleanLexer.indent_len(match.group(0))
-        ctx.pos = match.end()
-        yield match.start(), Text, match.group(0)
-
-    def check_indent1(lexer, match, ctx):
-        indent, reallen = CleanLexer.indent_len(match.group(0))
-        if indent > ctx.indent:
-            yield match.start(), Whitespace, match.group(0)
-            ctx.pos = match.start() + reallen + 1
-        else:
-            ctx.indent = 0
-            ctx.pos = match.start()
-            ctx.stack = ctx.stack[:-1]
-            yield match.start(), Whitespace, match.group(0)[1:]
-
-    def check_indent2(lexer, match, ctx):
-        indent, reallen = CleanLexer.indent_len(match.group(0))
-        if indent > ctx.indent:
-            yield match.start(), Whitespace, match.group(0)
-            ctx.pos = match.start() + reallen + 1
-        else:
-            ctx.indent = 0
-            ctx.pos = match.start()
-            ctx.stack = ctx.stack[:-2]
-
-    def check_indent3(lexer, match, ctx):
-        indent, reallen = CleanLexer.indent_len(match.group(0))
-        if indent > ctx.indent:
-            yield match.start(), Whitespace, match.group(0)
-            ctx.pos = match.start() + reallen + 1
-        else:
-            ctx.indent = 0
-            ctx.pos = match.start()
-            ctx.stack = ctx.stack[:-3]
-            yield match.start(), Whitespace, match.group(0)[1:]
-            if match.group(0) == '\n\n':
-                ctx.pos = ctx.pos + 1
-
-    def skip(lexer, match, ctx):
-        ctx.stack = ctx.stack[:-1]
-        ctx.pos = match.end()
-        yield match.start(), Comment, match.group(0)
-
-    keywords = ('class', 'instance', 'where', 'with', 'let', 'let!',
-                'in', 'case', 'of', 'infix', 'infixr', 'infixl', 'generic',
-                'derive', 'otherwise', 'code', 'inline')
+    lowerId = r'[a-z`][\w`]*'
+    upperId = r'[A-Z`][\w`]*'
+    funnyId = r'[~@#$%\^?!+\-*<>\\/|&=:]+'
+    scoreUpperId = r'_' + upperId
+    scoreLowerId = r'_' + lowerId
+    moduleId = r'[a-zA-Z_][a-zA-Z0-9_.`]+'
+    classId = '|'.join([lowerId, upperId, funnyId])
 
     tokens = {
-        'common': [
-            (r';', Punctuation, '#pop'),
-            (r'//', Comment, 'singlecomment'),
-        ],
         'root': [
-            # Comments
+            include('comments'),
+            include('keywords'),
+            include('module'),
+            include('import'),
+            include('whitespace'),
+            include('literals'),
+            include('operators'),
+            include('delimiters'),
+            include('names'),
+        ],
+        'whitespace': [
+            (r'\s+', Whitespace),
+        ],
+        'comments': [
             (r'//.*\n', Comment.Single),
-            (r'(?s)/\*\*.*?\*/', Comment.Special),
-            (r'(?s)/\*.*?\*/', Comment.Multi),
-
-            # Modules, imports, etc.
-            (r'\b((?:implementation|definition|system)\s+)?(module)(\s+)([\w`\.]+)',
-                bygroups(Keyword.Namespace, Keyword.Namespace, Text, Name.Class)),
-            (r'(?<=\n)import(?=\s)', Keyword.Namespace, 'import'),
-            (r'(?<=\n)from(?=\s)', Keyword.Namespace, 'fromimport'),
-
-            # Keywords
-            # We cannot use (?s)^|(?<=\s) as prefix, so need to repeat this
-            (words(keywords, prefix=r'(?<=\s)', suffix=r'(?=\s)'), Keyword),
-            (words(keywords, prefix=r'^', suffix=r'(?=\s)'), Keyword),
-
-            # Function definitions
-            (r'(?=\{\|)', Whitespace, 'genericfunction'),
-            (r'(?<=\n)([ \t]*)([\w`$()=\-<>~*\^|+&%]+)((?:\s+\w)*)(\s*)(::)',
-             bygroups(store_indent, Name.Function, Keyword.Type, Whitespace,
-                      Punctuation),
-             'functiondefargs'),
-
-            # Type definitions
-            (r'(?<=\n)([ \t]*)(::)', bygroups(store_indent, Punctuation), 'typedef'),
-            (r'^([ \t]*)(::)', bygroups(store_indent, Punctuation), 'typedef'),
-
-            # Literals
-            (r'\'\\?.(?<!\\)\'', String.Char),
-            (r'\'\\\d+\'', String.Char),
-            (r'\'\\\\\'', String.Char), # (special case for '\\')
-            (r'[+\-~]?\s*\d+\.\d+(E[+\-~]?\d+)?\b', Number.Float),
-            (r'[+\-~]?\s*0[0-7]\b', Number.Oct),
-            (r'[+\-~]?\s*0x[0-9a-fA-F]\b', Number.Hex),
-            (r'[+\-~]?\s*\d+\b', Number.Integer),
-            (r'"', String.Double, 'doubleqstring'),
-            (words(('True', 'False'), prefix=r'(?<=\s)', suffix=r'(?=\s)'),
-             Literal),
-
-            # Qualified names
-            (r'(\')([\w\.]+)(\'\.)',
-                bygroups(Punctuation, Name.Namespace, Punctuation)),
-
-            # Everything else is some name
-            (r'([\w`$%\/\?@]+\.?)*[\w`$%\/\?@]+', Name),
-
-            # Punctuation
-            (r'[{}()\[\],:;.#]', Punctuation),
-            (r'[+\-=!<>|&~*\^/]', Operator),
-            (r'\\\\', Operator),
-
-            # Lambda expressions
-            (r'\\.*?(->|\.|=)', Name.Function),
-
-            # Whitespace
-            (r'\s', Whitespace),
-
-            include('common'),
+            (r'/\*', Comment.Multi, 'comments.in'),
+            (r'/\*\*', Comment.Special, 'comments.in'),
         ],
-        'fromimport': [
-            include('common'),
-            (r'([\w`\.]+)', check_class_not_import),
-            (r'\n', Whitespace, '#pop'),
-            (r'\s', Whitespace),
+        'comments.in': [
+            (r'\*\/', Comment.Multi, '#pop'),
+            (r'/\*', Comment.Multi, '#push'),
+            (r'[^*/]+', Comment.Multi),
+            (r'\*(?!/)', Comment.Multi),
+            (r'/', Comment.Multi),
         ],
-        'fromimportfunc': [
-            include('common'),
-            (r'(::)\s+([^,\s]+)', bygroups(Punctuation, Keyword.Type)),
-            (r'([\w`$()=\-<>~*\^|+&%\/]+)', check_instance_class),
-            (r',', Punctuation),
-            (r'\n', Whitespace, '#pop'),
-            (r'\s', Whitespace),
+        'keywords': [
+            (words(keywords, prefix=r'\b', suffix=r'\b'), Keyword),
         ],
-        'fromimportfunctype': [
-            include('common'),
-            (r'[{(\[]', Punctuation, 'combtype'),
-            (r',', Punctuation, '#pop'),
-            (r'[:;.#]', Punctuation),
-            (r'\n', Whitespace, '#pop:2'),
-            (r'[^\S\n]+', Whitespace),
-            (r'\S+', Keyword.Type),
+        'module': [
+            (words(modulewords, prefix=r'\b', suffix=r'\b'), Keyword.Namespace),
+            (r'\bmodule\b', Keyword.Namespace, 'module.name'),
         ],
-        'combtype': [
-            include('common'),
-            (r'[})\]]', Punctuation, '#pop'),
-            (r'[{(\[]', Punctuation, '#pop'),
-            (r'[,:;.#]', Punctuation),
-            (r'\s+', Whitespace),
-            (r'\S+', Keyword.Type),
+        'module.name': [
+            include('whitespace'),
+            (moduleId, Name.Class, '#pop'),
         ],
         'import': [
-            include('common'),
-            (words(('from', 'import', 'as', 'qualified'),
-                   prefix='(?<=\s)', suffix='(?=\s)'), Keyword.Namespace),
-            (r'[\w`\.]+', Name.Class),
-            (r'\n', Whitespace, '#pop'),
-            (r',', Punctuation),
-            (r'[^\S\n]+', Whitespace),
-        ],
-        'singlecomment': [
-            (r'(.)(?=\n)', skip),
-            (r'.+(?!\n)', Comment),
-        ],
-        'doubleqstring': [
-            (r'[^\\"]+', String.Double),
-            (r'"', String.Double, '#pop'),
-            (r'\\.', String.Double),
+            (r'\b(import)\b(\s*)', bygroups(Keyword, Whitespace), 'import.module'),
+            (r'\b(from)\b(\s*)\b(' + moduleId + r')\b(\s*)\b(import)\b',
+                bygroups(Keyword, Whitespace, Name.Class, Whitespace, Keyword),
+                'import.what'),
+        ],
+        'import.module': [
+            (r'\b(qualified)\b(\s*)', bygroups(Keyword, Whitespace)),
+            (r'(\s*)\b(as)\b', bygroups(Whitespace, Keyword), ('#pop', 'import.module.as')),
+            (moduleId, Name.Class),
+            (r'(\s*)(,)(\s*)', bygroups(Whitespace, Punctuation, Whitespace)),
+            (r'\s+', Whitespace),
+            default('#pop'),
         ],
-        'typedef': [
-            include('common'),
-            (r'[\w`]+', Keyword.Type),
-            (r'[:=|(),\[\]{}!*]', Punctuation),
-            (r'->', Punctuation),
-            (r'\n(?=[^\s|])', Whitespace, '#pop'),
-            (r'\s', Whitespace),
-            (r'.', Keyword.Type),
+        'import.module.as': [
+            include('whitespace'),
+            (lowerId, Name.Class, '#pop'),
+            (upperId, Name.Class, '#pop'),
+        ],
+        'import.what': [
+            (r'\b(class)\b(\s+)(' + classId + r')',
+                bygroups(Keyword, Whitespace, Name.Class), 'import.what.class'),
+            (r'\b(instance)(\s+)(' + classId + r')(\s+)',
+                bygroups(Keyword, Whitespace, Name.Class, Whitespace), 'import.what.instance'),
+            (r'(::)(\s*)\b(' + upperId + r')\b',
+                bygroups(Punctuation, Whitespace, Name.Class), 'import.what.type'),
+            (r'\b(generic)\b(\s+)\b(' + lowerId + '|' + upperId + r')\b',
+                bygroups(Keyword, Whitespace, Name)),
+            include('names'),
+            (r'(,)(\s+)', bygroups(Punctuation, Whitespace)),
+            (r'$', Whitespace, '#pop'),
+            include('whitespace'),
+        ],
+        'import.what.class': [
+            (r',', Punctuation, '#pop'),
+            (r'\(', Punctuation, 'import.what.class.members'),
+            (r'$', Whitespace, '#pop:2'),
+            include('whitespace'),
         ],
-        'genericfunction': [
-            include('common'),
-            (r'\{\|', Punctuation),
-            (r'\|\}', Punctuation, '#pop'),
+        'import.what.class.members': [
             (r',', Punctuation),
-            (r'->', Punctuation),
-            (r'(\s+of\s+)(\{)', bygroups(Keyword, Punctuation), 'genericftypes'),
-            (r'\s', Whitespace),
-            (r'[\w`\[\]{}!]+', Keyword.Type),
-            (r'[*()]', Punctuation),
+            (r'\.\.', Punctuation),
+            (r'\)', Punctuation, '#pop'),
+            include('names'),
+        ],
+        'import.what.instance': [
+            (r'[,)]', Punctuation, '#pop'),
+            (r'\(', Punctuation, 'import.what.instance'),
+            (r'$', Whitespace, '#pop:2'),
+            include('whitespace'),
+            include('names'),
+        ],
+        'import.what.type': [
+            (r',', Punctuation, '#pop'),
+            (r'[({]', Punctuation, 'import.what.type.consesandfields'),
+            (r'$', Whitespace, '#pop:2'),
+            include('whitespace'),
         ],
-        'genericftypes': [
-            include('common'),
-            (r'[\w`]+', Keyword.Type),
+        'import.what.type.consesandfields': [
             (r',', Punctuation),
-            (r'\s', Whitespace),
-            (r'\}', Punctuation, '#pop'),
-        ],
-        'functiondefargs': [
-            include('common'),
-            (r'\n(\s*)', check_indent1),
-            (r'[!{}()\[\],:;.#]', Punctuation),
-            (r'->', Punctuation, 'functiondefres'),
-            (r'^(?=\S)', Whitespace, '#pop'),
-            (r'\S', Keyword.Type),
-            (r'\s', Whitespace),
-        ],
-        'functiondefres': [
-            include('common'),
-            (r'\n(\s*)', check_indent2),
-            (r'^(?=\S)', Whitespace, '#pop:2'),
-            (r'[!{}()\[\],:;.#]', Punctuation),
-            (r'\|', Punctuation, 'functiondefclasses'),
-            (r'\S', Keyword.Type),
-            (r'\s', Whitespace),
-        ],
-        'functiondefclasses': [
-            include('common'),
-            (r'\n(\s*)', check_indent3),
-            (r'^(?=\S)', Whitespace, '#pop:3'),
-            (r'[,&]', Punctuation),
-            (r'\[', Punctuation, 'functiondefuniquneq'),
-            (r'[\w`$()=\-<>~*\^|+&%\/{}\[\]@]', Name.Function, 'functionname'),
-            (r'\s+', Whitespace),
-        ],
-        'functiondefuniquneq': [
-            include('common'),
-            (r'[a-z]+', Keyword.Type),
-            (r'\s+', Whitespace),
-            (r'<=|,', Punctuation),
-            (r'\]', Punctuation, '#pop')
-        ],
-        'functionname': [
-            include('common'),
-            (r'[\w`$()=\-<>~*\^|+&%\/]+', Name.Function),
-            (r'(?=\{\|)', Punctuation, 'genericfunction'),
-            default('#pop'),
+            (r'\.\.', Punctuation),
+            (r'[)}]', Punctuation, '#pop'),
+            include('names'),
+        ],
+        'literals': [
+            (r'\'([^\'\\]|\\(x[\da-fA-F]+|\d+|.))\'', Literal.Char),
+            (r'[+~-]?0[0-7]+\b', Number.Oct),
+            (r'[+~-]?\d+\.\d+(E[+-]?\d+)?', Number.Float),
+            (r'[+~-]?\d+\b', Number.Integer),
+            (r'[+~-]?0x[\da-fA-F]+\b', Number.Hex),
+            (r'True|False', Literal),
+            (r'"', String.Double, 'literals.stringd'),
+        ],
+        'literals.stringd': [
+            (r'[^\\"\n]+', String.Double),
+            (r'"', String.Double, '#pop'),
+            (r'\\.', String.Double),
+            (r'[$\n]', Error, '#pop'),
+        ],
+        'operators': [
+            (r'[-~@#$%\^?!+*<>\\/|&=:.]+', Operator),
+            (r'\b_+\b', Operator),
+        ],
+        'delimiters': [
+            (r'[,;(){}\[\]]', Punctuation),
+            (r'(\')([\w`.]+)(\')',
+                bygroups(Punctuation, Name.Class, Punctuation)),
+        ],
+        'names': [
+            (lowerId, Name),
+            (scoreLowerId, Name),
+            (funnyId, Name.Function),
+            (upperId, Name.Class),
+            (scoreUpperId, Name.Class),
         ]
     }