pygments.rb 2.0.0.rc3 → 2.3.0

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.c_like
     ~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for other C-like languages.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -14,13 +13,14 @@ import re
 from pygments.lexer import RegexLexer, include, bygroups, inherit, words, \
     default
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+    Number, Punctuation, Whitespace
 
 from pygments.lexers.c_cpp import CLexer, CppLexer
 from pygments.lexers import _mql_builtins
 
 __all__ = ['PikeLexer', 'NesCLexer', 'ClayLexer', 'ECLexer', 'ValaLexer',
-           'CudaLexer', 'SwigLexer', 'MqlLexer', 'ArduinoLexer', 'CharmciLexer']
+           'CudaLexer', 'SwigLexer', 'MqlLexer', 'ArduinoLexer', 'CharmciLexer',
+           'OmgIdlLexer']
 
 
 class PikeLexer(CppLexer):
@@ -335,6 +335,11 @@ class SwigLexer(CppLexer):
     priority = 0.04  # Lower than C/C++ and Objective C/C++
 
     tokens = {
+        'root': [
+            # Match it here so it won't be matched as a function in the rest of root
+            (r'\$\**\&?\w+', Name),
+            inherit
+        ],
         'statements': [
             # SWIG directives
             (r'(%[a-z_][a-z0-9_]*)', Name.Function),
@@ -550,7 +555,7 @@ class CharmciLexer(CppLexer):
     mimetypes = []
 
     tokens = {
-        'statements': [
+        'keywords': [
             (r'(module)(\s+)', bygroups(Keyword, Text), 'classname'),
             (words(('mainmodule', 'mainchare', 'chare', 'array', 'group',
                     'nodegroup', 'message', 'conditional')), Keyword),
@@ -564,3 +569,96 @@ class CharmciLexer(CppLexer):
             inherit,
         ],
     }
+
+
+class OmgIdlLexer(CLexer):
+    """
+    Lexer for `Object Management Group Interface Definition Language <https://www.omg.org/spec/IDL/About-IDL/>`_.
+
+    .. versionadded:: 2.9
+    """
+
+    name = 'OMG Interface Definition Language'
+    aliases = ['omg-idl']
+    filenames = ['*.idl', '*.pidl']
+    mimetypes = []
+
+    scoped_name = r'((::)?\w+)+'
+
+    tokens = {
+        'values': [
+            (words(('true', 'false'), prefix=r'(?i)', suffix=r'\b'), Number),
+            (r'([Ll]?)(")', bygroups(String.Affix, String.Double), 'string'),
+            (r'([Ll]?)(\')(\\[^\']+)(\')',
+                bygroups(String.Affix, String.Char, String.Escape, String.Char)),
+            (r'([Ll]?)(\')(\\\')(\')',
+                bygroups(String.Affix, String.Char, String.Escape, String.Char)),
+            (r'([Ll]?)(\'.\')', bygroups(String.Affix, String.Char)),
+            (r'[+-]?\d+(\.\d*)?[Ee][+-]?\d+', Number.Float),
+            (r'[+-]?(\d+\.\d*)|(\d*\.\d+)([Ee][+-]?\d+)?', Number.Float),
+            (r'(?i)[+-]?0x[0-9a-f]+', Number.Hex),
+            (r'[+-]?[1-9]\d*', Number.Integer),
+            (r'[+-]?0[0-7]*', Number.Oct),
+            (r'[\+\-\*\/%^&\|~]', Operator),
+            (words(('<<', '>>')), Operator),
+            (scoped_name, Name),
+            (r'[{};:,<>\[\]]', Punctuation),
+        ],
+        'annotation_params': [
+            include('whitespace'),
+            (r'\(', Punctuation, '#push'),
+            include('values'),
+            (r'=', Punctuation),
+            (r'\)', Punctuation, '#pop'),
+        ],
+        'annotation_params_maybe': [
+            (r'\(', Punctuation, 'annotation_params'),
+            include('whitespace'),
+            default('#pop'),
+        ],
+        'annotation_appl': [
+            (r'@' + scoped_name, Name.Decorator, 'annotation_params_maybe'),
+        ],
+        'enum': [
+            include('whitespace'),
+            (r'[{,]', Punctuation),
+            (r'\w+', Name.Constant),
+            include('annotation_appl'),
+            (r'\}', Punctuation, '#pop'),
+        ],
+        'root': [
+            include('whitespace'),
+            (words((
+                'typedef', 'const',
+                'in', 'out', 'inout', 'local',
+            ), prefix=r'(?i)', suffix=r'\b'), Keyword.Declaration),
+            (words((
+                'void', 'any', 'native', 'bitfield',
+                'unsigned', 'boolean', 'char', 'wchar', 'octet', 'short', 'long',
+                'int8', 'uint8', 'int16', 'int32', 'int64', 'uint16', 'uint32', 'uint64',
+                'float', 'double', 'fixed',
+                'sequence', 'string', 'wstring', 'map',
+            ), prefix=r'(?i)', suffix=r'\b'), Keyword.Type),
+            (words((
+                '@annotation', 'struct', 'union', 'bitset', 'interface',
+                'exception', 'valuetype', 'eventtype', 'component',
+            ), prefix=r'(?i)', suffix=r'(\s+)(\w+)'), bygroups(Keyword, Whitespace, Name.Class)),
+            (words((
+                'abstract', 'alias', 'attribute', 'case', 'connector',
+                'consumes', 'context', 'custom', 'default', 'emits', 'factory',
+                'finder', 'getraises', 'home', 'import', 'manages', 'mirrorport',
+                'multiple', 'Object', 'oneway', 'primarykey', 'private', 'port',
+                'porttype', 'provides', 'public', 'publishes', 'raises',
+                'readonly', 'setraises', 'supports', 'switch', 'truncatable',
+                'typeid', 'typename', 'typeprefix', 'uses', 'ValueBase',
+            ), prefix=r'(?i)', suffix=r'\b'), Keyword),
+            (r'(?i)(enum|bitmask)(\s+)(\w+)',
+                bygroups(Keyword, Whitespace, Name.Class), 'enum'),
+            (r'(?i)(module)(\s+)(\w+)',
+                bygroups(Keyword.Namespace, Whitespace, Name.Namespace)),
+            (r'(\w+)(\s*)(=)', bygroups(Name.Constant, Whitespace, Operator)),
+            (r'[\(\)]', Punctuation),
+            include('values'),
+            include('annotation_appl'),
+        ],
+    }

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.capnproto
     ~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for the Cap'n Proto schema language.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 

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

@@ -0,0 +1,190 @@
+"""
+    pygments.lexers.cddl
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the Concise data definition language (CDDL), a notational
+    convention to express CBOR and JSON data structures.
+
+    More information:
+    https://datatracker.ietf.org/doc/rfc8610/
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+__all__ = ['CddlLexer']
+
+from pygments.lexer import RegexLexer, bygroups, include, words
+from pygments.token import (
+    Comment,
+    Error,
+    Keyword,
+    Name,
+    Number,
+    Operator,
+    Punctuation,
+    String,
+    Text,
+)
+
+
+class CddlLexer(RegexLexer):
+    """
+    Lexer for CDDL definitions.
+
+    .. versionadded:: 2.8
+    """
+    name = "CDDL"
+    aliases = ["cddl"]
+    filenames = ["*.cddl"]
+    mimetypes = ["text/x-cddl"]
+
+    _prelude_types = [
+        "any",
+        "b64legacy",
+        "b64url",
+        "bigfloat",
+        "bigint",
+        "bignint",
+        "biguint",
+        "bool",
+        "bstr",
+        "bytes",
+        "cbor-any",
+        "decfrac",
+        "eb16",
+        "eb64legacy",
+        "eb64url",
+        "encoded-cbor",
+        "false",
+        "float",
+        "float16",
+        "float16-32",
+        "float32",
+        "float32-64",
+        "float64",
+        "int",
+        "integer",
+        "mime-message",
+        "nil",
+        "nint",
+        "null",
+        "number",
+        "regexp",
+        "tdate",
+        "text",
+        "time",
+        "true",
+        "tstr",
+        "uint",
+        "undefined",
+        "unsigned",
+        "uri",
+    ]
+
+    _controls = [
+        ".and",
+        ".bits",
+        ".cbor",
+        ".cborseq",
+        ".default",
+        ".eq",
+        ".ge",
+        ".gt",
+        ".le",
+        ".lt",
+        ".ne",
+        ".regexp",
+        ".size",
+        ".within",
+    ]
+
+    _re_id = (
+        r"[$@A-Z_a-z]"
+        r"(?:[\-\.]*[$@0-9A-Z_a-z]|[$@0-9A-Z_a-z])*"
+    )
+
+    # While the spec reads more like "an int must not start with 0" we use a
+    # lookahead here that says "after a 0 there must be no digit". This makes the
+    # '0' the invalid character in '01', which looks nicer when highlighted.
+    _re_uint = r"(?:0b[01]+|0x[0-9a-fA-F]+|[1-9]\d*|0(?!\d))"
+    _re_int = r"-?" + _re_uint
+
+    flags = re.UNICODE | re.MULTILINE
+
+    tokens = {
+        "commentsandwhitespace": [(r"\s+", Text), (r";.+$", Comment.Single)],
+        "root": [
+            include("commentsandwhitespace"),
+            # tag types
+            (r"#(\d\.{uint})?".format(uint=_re_uint), Keyword.Type),  # type or any
+            # occurence
+            (
+                r"({uint})?(\*)({uint})?".format(uint=_re_uint),
+                bygroups(Number, Operator, Number),
+            ),
+            (r"\?|\+", Operator),  # occurrence
+            (r"\^", Operator),  # cuts
+            (r"(\.\.\.|\.\.)", Operator),  # rangeop
+            (words(_controls, suffix=r"\b"), Operator.Word),  # ctlops
+            # into choice op
+            (r"&(?=\s*({groupname}|\())".format(groupname=_re_id), Operator),
+            (r"~(?=\s*{})".format(_re_id), Operator),  # unwrap op
+            (r"//|/(?!/)", Operator),  # double und single slash
+            (r"=>|/==|/=|=", Operator),
+            (r"[\[\]{}\(\),<>:]", Punctuation),
+            # Bytestrings
+            (r"(b64)(')", bygroups(String.Affix, String.Single), "bstrb64url"),
+            (r"(h)(')", bygroups(String.Affix, String.Single), "bstrh"),
+            (r"'", String.Single, "bstr"),
+            # Barewords as member keys (must be matched before values, types, typenames,
+            # groupnames).
+            # Token type is String as barewords are always interpreted as such.
+            (
+                r"({bareword})(\s*)(:)".format(bareword=_re_id),
+                bygroups(String, Text, Punctuation),
+            ),
+            # predefined types
+            (
+                words(_prelude_types, prefix=r"(?![\-_$@])\b", suffix=r"\b(?![\-_$@])"),
+                Name.Builtin,
+            ),
+            # user-defined groupnames, typenames
+            (_re_id, Name.Class),
+            # values
+            (r"0b[01]+", Number.Bin),
+            (r"0o[0-7]+", Number.Oct),
+            (r"0x[0-9a-fA-F]+(\.[0-9a-fA-F]+)?p[+-]?\d+", Number.Hex),  # hexfloat
+            (r"0x[0-9a-fA-F]+", Number.Hex),  # hex
+            # Float
+            (
+                r"{int}(?=(\.\d|e[+-]?\d))(?:\.\d+)?(?:e[+-]?\d+)?".format(int=_re_int),
+                Number.Float,
+            ),
+            # Int
+            (_re_int, Number.Integer),
+            (r'"(\\\\|\\"|[^"])*"', String.Double),
+        ],
+        "bstrb64url": [
+            (r"'", String.Single, "#pop"),
+            include("commentsandwhitespace"),
+            (r"\\.", String.Escape),
+            (r"[0-9a-zA-Z\-_=]+", String.Single),
+            (r".", Error),
+            # (r";.+$", Token.Other),
+        ],
+        "bstrh": [
+            (r"'", String.Single, "#pop"),
+            include("commentsandwhitespace"),
+            (r"\\.", String.Escape),
+            (r"[0-9a-fA-F]+", String.Single),
+            (r".", Error),
+        ],
+        "bstr": [
+            (r"'", String.Single, "#pop"),
+            (r"\\.", String.Escape),
+            (r"[^']", String.Single),
+        ],
+    }

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.chapel
     ~~~~~~~~~~~~~~~~~~~~~~
 
     Lexer for the Chapel language.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -27,6 +26,38 @@ class ChapelLexer(RegexLexer):
     aliases = ['chapel', 'chpl']
     # mimetypes = ['text/x-chapel']
 
+    known_types = ('bool', 'bytes', 'complex', 'imag', 'int', 'locale',
+                   'nothing', 'opaque', 'range', 'real', 'string', 'uint',
+                   'void')
+
+    type_modifiers_par = ('atomic', 'single', 'sync')
+    type_modifiers_mem = ('borrowed', 'owned', 'shared', 'unmanaged')
+    type_modifiers = (*type_modifiers_par, *type_modifiers_mem)
+
+    declarations = ('config', 'const', 'in', 'inout', 'out', 'param', 'ref',
+                    'type', 'var')
+
+    constants = ('false', 'nil', 'none', 'true')
+
+    other_keywords = ('align', 'as',
+                      'begin', 'break', 'by',
+                      'catch', 'cobegin', 'coforall', 'continue',
+                      'defer', 'delete', 'dmapped', 'do', 'domain',
+                      'else', 'enum', 'except', 'export', 'extern',
+                      'for', 'forall', 'foreach', 'forwarding',
+                      'if', 'implements', 'import', 'index', 'init', 'inline',
+                      'label', 'lambda', 'let', 'lifetime', 'local',
+                      'new', 'noinit',
+                      'on', 'only', 'otherwise', 'override',
+                      'pragma', 'primitive', 'private', 'prototype', 'public',
+                      'reduce', 'require', 'return',
+                      'scan', 'select', 'serial', 'sparse', 'subdomain',
+                      'then', 'this', 'throw', 'throws', 'try',
+                      'use',
+                      'when', 'where', 'while', 'with',
+                      'yield',
+                      'zip')
+
     tokens = {
         'root': [
             (r'\n', Text),
@@ -36,34 +67,15 @@ class ChapelLexer(RegexLexer):
             (r'//(.*?)\n', Comment.Single),
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
 
-            (r'(config|const|in|inout|out|param|ref|type|var)\b',
-             Keyword.Declaration),
-            (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', '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),
+            (words(declarations, suffix=r'\b'), Keyword.Declaration),
+            (words(constants, suffix=r'\b'), Keyword.Constant),
+            (words(known_types, suffix=r'\b'), Keyword.Type),
+            (words((*type_modifiers, *other_keywords), suffix=r'\b'), Keyword),
+
             (r'(iter)((?:\s)+)', bygroups(Keyword, Text), 'procname'),
             (r'(proc)((?:\s)+)', bygroups(Keyword, Text), 'procname'),
-            (r'(class|module|record|union)(\s+)', bygroups(Keyword, Text),
+            (r'(operator)((?:\s)+)', bygroups(Keyword, Text), 'procname'),
+            (r'(class|interface|module|record|union)(\s+)', bygroups(Keyword, Text),
              'classname'),
 
             # imaginary integers
@@ -106,7 +118,18 @@ class ChapelLexer(RegexLexer):
             (r'[a-zA-Z_][\w$]*', Name.Class, '#pop'),
         ],
         'procname': [
-            (r'([a-zA-Z_][.\w$]*|\~[a-zA-Z_][.\w$]*|[+*/!~%<>=&^|\-]{1,2})',
+            (r'([a-zA-Z_][.\w$]*|'  # regular function name, including secondary
+             r'\~[a-zA-Z_][.\w$]*|'  # support for legacy destructors
+             r'[+*/!~%<>=&^|\-:]{1,2})',  # operators
              Name.Function, '#pop'),
+
+            # allow `proc (atomic T).foo`
+            (r'\(', Punctuation, "receivertype"),
+            (r'\)+\.', Punctuation),
+        ],
+        'receivertype': [
+            (words(type_modifiers, suffix=r'\b'), Keyword),
+            (words(known_types, suffix=r'\b'), Keyword.Type),
+            (r'[^()]*', Name.Other, '#pop'),
         ],
     }

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.clean
     ~~~~~~~~~~~~~~~~~~~~~
 
     Lexer for the Clean language.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -60,15 +59,15 @@ class CleanLexer(ExtendedRegexLexer):
         ],
         'comments': [
             (r'//.*\n', Comment.Single),
-            (r'/\*', Comment.Multi, 'comments.in'),
+            (r'/\*', Comment.Multiline, 'comments.in'),
             (r'/\*\*', Comment.Special, 'comments.in'),
         ],
         'comments.in': [
-            (r'\*\/', Comment.Multi, '#pop'),
-            (r'/\*', Comment.Multi, '#push'),
-            (r'[^*/]+', Comment.Multi),
-            (r'\*(?!/)', Comment.Multi),
-            (r'/', Comment.Multi),
+            (r'\*\/', Comment.Multiline, '#pop'),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'[^*/]+', Comment.Multiline),
+            (r'\*(?!/)', Comment.Multiline),
+            (r'/', Comment.Multiline),
         ],
         'keywords': [
             (words(keywords, prefix=r'\b', suffix=r'\b'), Keyword),

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.compiled
     ~~~~~~~~~~~~~~~~~~~~~~~~
 
     Just export lexer classes previously contained in this module.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """