pygments.rb 1.2.1 → 2.2.0

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

@@ -0,0 +1,115 @@
+"""
+    pygments.lexers.whiley
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the Whiley language.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups, words
+from pygments.token import Comment, Keyword, Name, Number, Operator, \
+    Punctuation, String, Text
+
+__all__ = ['WhileyLexer']
+
+
+class WhileyLexer(RegexLexer):
+    """
+    Lexer for the Whiley programming language.
+
+    .. versionadded:: 2.2
+    """
+    name = 'Whiley'
+    filenames = ['*.whiley']
+    aliases = ['whiley']
+    mimetypes = ['text/x-whiley']
+
+    # See the language specification:
+    # http://whiley.org/download/WhileyLanguageSpec.pdf
+
+    tokens = {
+        'root': [
+            # Whitespace
+            (r'\s+', Text),
+
+            # Comments
+            (r'//.*', Comment.Single),
+            # don't parse empty comment as doc comment
+            (r'/\*\*/', Comment.Multiline),
+            (r'(?s)/\*\*.*?\*/', String.Doc),
+            (r'(?s)/\*.*?\*/', Comment.Multiline),
+
+            # Keywords
+            (words((
+                'if', 'else', 'while', 'for', 'do', 'return',
+                'switch', 'case', 'default', 'break', 'continue',
+                'requires', 'ensures', 'where', 'assert', 'assume',
+                'all', 'no', 'some', 'in', 'is', 'new',
+                'throw', 'try', 'catch', 'debug', 'skip', 'fail',
+                'finite', 'total'), suffix=r'\b'), Keyword.Reserved),
+            (words((
+                'function', 'method', 'public', 'private', 'protected',
+                'export', 'native'), suffix=r'\b'), Keyword.Declaration),
+            # "constant" & "type" are not keywords unless used in declarations
+            (r'(constant|type)(\s+)([a-zA-Z_]\w*)(\s+)(is)\b',
+             bygroups(Keyword.Declaration, Text, Name, Text, Keyword.Reserved)),
+            (r'(true|false|null)\b', Keyword.Constant),
+            (r'(bool|byte|int|real|any|void)\b', Keyword.Type),
+            # "from" is not a keyword unless used with import
+            (r'(import)(\s+)(\*)([^\S\n]+)(from)\b',
+             bygroups(Keyword.Namespace, Text, Punctuation, Text, Keyword.Namespace)),
+            (r'(import)(\s+)([a-zA-Z_]\w*)([^\S\n]+)(from)\b',
+             bygroups(Keyword.Namespace, Text, Name, Text, Keyword.Namespace)),
+            (r'(package|import)\b', Keyword.Namespace),
+
+            # standard library: https://github.com/Whiley/WhileyLibs/
+            (words((
+                # types defined in whiley.lang.Int
+                'i8', 'i16', 'i32', 'i64',
+                'u8', 'u16', 'u32', 'u64',
+                'uint', 'nat',
+
+                # whiley.lang.Any
+                'toString'), suffix=r'\b'), Name.Builtin),
+
+            # byte literal
+            (r'[01]+b', Number.Bin),
+
+            # decimal literal
+            (r'[0-9]+\.[0-9]+', Number.Float),
+            # match "1." but not ranges like "3..5"
+            (r'[0-9]+\.(?!\.)', Number.Float),
+
+            # integer literal
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+            (r'[0-9]+', Number.Integer),
+
+            # character literal
+            (r"""'[^\\]'""", String.Char),
+            (r"""(')(\\['"\\btnfr])(')""",
+             bygroups(String.Char, String.Escape, String.Char)),
+
+            # string literal
+            (r'"', String, 'string'),
+
+            # operators and punctuation
+            (r'[{}()\[\],.;]', Punctuation),
+            (r'[+\-*/%&|<>^!~@=:?'
+             # unicode operators
+             r'\u2200\u2203\u2205\u2282\u2286\u2283\u2287'
+             r'\u222A\u2229\u2264\u2265\u2208\u2227\u2228'
+             r']', Operator),
+
+            # identifier
+            (r'[a-zA-Z_]\w*', Name),
+        ],
+        'string': [
+            (r'"', String, '#pop'),
+            (r'\\[btnfr]', String.Escape),
+            (r'\\u[0-9a-fA-F]{4}', String.Escape),
+            (r'\\.', String),
+            (r'[^\\"]+', String),
+        ],
+    }

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

@@ -0,0 +1,68 @@
+"""
+    pygments.lexers.x10
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the X10 programming language.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Error
+
+__all__ = ['X10Lexer']
+
+class X10Lexer(RegexLexer):
+    """
+    For the X10 language.
+
+    .. versionadded:: 0.1
+    """
+
+    name = 'X10'
+    aliases = ['x10', 'xten']
+    filenames = ['*.x10']
+    mimetypes = ['text/x-x10']
+
+    keywords = (
+        'as', 'assert', 'async', 'at', 'athome', 'ateach', 'atomic',
+        'break', 'case', 'catch', 'class', 'clocked', 'continue',
+        'def', 'default', 'do', 'else', 'final', 'finally', 'finish',
+        'for', 'goto', 'haszero', 'here', 'if', 'import', 'in',
+        'instanceof', 'interface', 'isref', 'new', 'offer',
+        'operator', 'package', 'return', 'struct', 'switch', 'throw',
+        'try', 'type', 'val', 'var', 'when', 'while'
+    )
+
+    types = (
+        'void'
+    )
+
+    values = (
+        'false', 'null', 'self', 'super', 'this', 'true'
+    )
+
+    modifiers = (
+        'abstract', 'extends', 'implements', 'native', 'offers',
+        'private', 'property', 'protected', 'public', 'static',
+        'throws', 'transient'
+    )
+
+    tokens = {
+        'root': [
+            (r'[^\S\n]+', Text),
+            (r'//.*?\n', Comment.Single),
+            (r'/\*(.|\n)*?\*/', Comment.Multiline),
+            (r'\b(%s)\b' % '|'.join(keywords), Keyword),
+            (r'\b(%s)\b' % '|'.join(types), Keyword.Type),
+            (r'\b(%s)\b' % '|'.join(values), Keyword.Constant),
+            (r'\b(%s)\b' % '|'.join(modifiers), Keyword.Declaration),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+            (r"'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'", String.Char),
+            (r'.', Text)
+        ],
+    }

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

@@ -0,0 +1,36 @@
+"""
+    pygments.lexers.xorg
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Xorg configs.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups
+from pygments.token import Comment, String, Name, Text
+
+__all__ = ['XorgLexer']
+
+
+class XorgLexer(RegexLexer):
+    """Lexer for xorg.conf file."""
+    name = 'Xorg'
+    aliases = ['xorg.conf']
+    filenames = ['xorg.conf']
+    mimetypes = []
+
+    tokens = {
+        'root': [
+            (r'\s+', Text),
+            (r'#.*$', Comment),
+
+            (r'((?:Sub)?Section)(\s+)("\w+")',
+             bygroups(String.Escape, Text, String.Escape)),
+            (r'(End(?:Sub)?Section)', String.Escape),
+
+            (r'(\w+)(\s+)([^\n#]+)',
+             bygroups(Name.Builtin, Text, Name.Constant)),
+        ],
+    }

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

@@ -0,0 +1,103 @@
+"""
+    pygments.lexers.yang
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the YANG 1.1 modeling language. See :rfc:`7950`.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import (RegexLexer, bygroups, words)
+from pygments.token import (Text, Token, Name, String, Comment,
+                            Number)
+
+__all__ = ['YangLexer']
+
+class YangLexer(RegexLexer):
+    """
+    Lexer for `YANG <https://tools.ietf.org/html/rfc7950/>`_, based on RFC7950
+
+    .. versionadded:: 2.7
+    """
+    name = 'YANG'
+    aliases = ['yang']
+    filenames = ['*.yang']
+    mimetypes = ['application/yang']
+
+    #Keywords from RFC7950 ; oriented at BNF style
+    TOP_STMTS_KEYWORDS = ("module", "submodule")
+    MODULE_HEADER_STMT_KEYWORDS = ("belongs-to", "namespace", "prefix", "yang-version")
+    META_STMT_KEYWORDS = ("contact", "description", "organization",
+                          "reference", "revision")
+    LINKAGE_STMTS_KEYWORDS = ("import", "include", "revision-date")
+    BODY_STMT_KEYWORDS = ("action", "argument", "augment", "deviation",
+                          "extension", "feature", "grouping", "identity",
+                          "if-feature", "input", "notification", "output",
+                          "rpc", "typedef")
+    DATA_DEF_STMT_KEYWORDS = ("anydata", "anyxml", "case", "choice",
+                              "config", "container", "deviate", "leaf",
+                              "leaf-list", "list", "must", "presence",
+                              "refine", "uses", "when")
+    TYPE_STMT_KEYWORDS = ("base", "bit", "default", "enum", "error-app-tag",
+                          "error-message", "fraction-digits", "length",
+                          "max-elements", "min-elements", "modifier",
+                          "ordered-by", "path", "pattern", "position",
+                          "range", "require-instance", "status", "type",
+                          "units", "value", "yin-element")
+    LIST_STMT_KEYWORDS = ("key", "mandatory", "unique")
+
+    #RFC7950 other keywords
+    CONSTANTS_KEYWORDS = ("add", "current", "delete", "deprecated", "false",
+                          "invert-match", "max", "min", "not-supported",
+                          "obsolete", "replace", "true", "unbounded", "user")
+
+    #RFC7950 Built-In Types
+    TYPES = ("binary", "bits", "boolean", "decimal64", "empty", "enumeration",
+             "identityref", "instance-identifier", "int16", "int32", "int64",
+             "int8", "leafref", "string", "uint16", "uint32", "uint64",
+             "uint8", "union")
+
+    suffix_re_pattern = r'(?=[^\w\-:])'
+
+    tokens = {
+        'comments': [
+            (r'[^*/]', Comment),
+            (r'/\*', Comment, '#push'),
+            (r'\*/', Comment, '#pop'),
+            (r'[*/]', Comment),
+        ],
+        "root": [
+            (r'\s+', Text.Whitespace),
+            (r'[{};]+', Token.Punctuation),
+            (r'(?<![\-\w])(and|or|not|\+|\.)(?![\-\w])', Token.Operator),
+
+            (r'"(?:\\"|[^"])*?"', String.Double),
+            (r"'(?:\\'|[^'])*?'", String.Single),
+
+            (r'/\*', Comment, 'comments'),
+            (r'//.*?$', Comment),
+
+            #match BNF stmt for `node-identifier` with [ prefix ":"]
+            (r'(?:^|(?<=[\s{};]))([\w.-]+)(:)([\w.-]+)(?=[\s{};])',
+             bygroups(Name.Namespace, Token.Punctuation, Name.Variable)),
+
+            #match BNF stmt `date-arg-str`
+            (r'([0-9]{4}\-[0-9]{2}\-[0-9]{2})(?=[\s{};])', Name.Label),
+            (r'([0-9]+\.[0-9]+)(?=[\s{};])', Number.Float),
+            (r'([0-9]+)(?=[\s{};])', Number.Integer),
+
+            (words(TOP_STMTS_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(MODULE_HEADER_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(META_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(LINKAGE_STMTS_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(BODY_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(DATA_DEF_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(TYPE_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(LIST_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(TYPES, suffix=suffix_re_pattern), Name.Class),
+            (words(CONSTANTS_KEYWORDS, suffix=suffix_re_pattern), Name.Class),
+
+            (r'[^;{}\s\'"]+', Name.Variable),
+        ]
+    }

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

@@ -0,0 +1,123 @@
+"""
+    pygments.lexers.zig
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Zig.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, words
+from pygments.token import Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Whitespace
+
+__all__ = ['ZigLexer']
+
+
+class ZigLexer(RegexLexer):
+    """
+    For `Zig <http://www.ziglang.org>`_ source code.
+
+    grammar: https://ziglang.org/documentation/master/#Grammar
+    """
+    name = 'Zig'
+    aliases = ['zig']
+    filenames = ['*.zig']
+    mimetypes = ['text/zig']
+
+    type_keywords = (
+        words(('bool', 'f16', 'f32', 'f64', 'f128', 'void', 'noreturn', 'type',
+               'anyerror', 'promise', 'i0', 'u0', 'isize',  'usize', 'comptime_int',
+               'comptime_float', 'c_short', 'c_ushort', 'c_int', 'c_uint', 'c_long',
+               'c_ulong', 'c_longlong', 'c_ulonglong', 'c_longdouble', 'c_void'
+               'i8', 'u8', 'i16', 'u16', 'i32', 'u32', 'i64', 'u64', 'i128',
+               'u128'), suffix=r'\b'),
+        Keyword.Type)
+
+    storage_keywords = (
+        words(('const', 'var', 'extern', 'packed', 'export', 'pub', 'noalias',
+               'inline', 'comptime', 'nakedcc', 'stdcallcc', 'volatile', 'allowzero',
+               'align', 'linksection', 'threadlocal'), suffix=r'\b'),
+        Keyword.Reserved)
+
+    structure_keywords = (
+        words(('struct', 'enum', 'union', 'error'), suffix=r'\b'),
+        Keyword)
+
+    statement_keywords = (
+        words(('break', 'return', 'continue', 'asm', 'defer', 'errdefer',
+               'unreachable', 'try', 'catch', 'async', 'await', 'suspend',
+               'resume', 'cancel'), suffix=r'\b'),
+        Keyword)
+
+    conditional_keywords = (
+        words(('if', 'else', 'switch', 'and', 'or', 'orelse'), suffix=r'\b'),
+        Keyword)
+
+    repeat_keywords = (
+        words(('while', 'for'), suffix=r'\b'),
+        Keyword)
+
+    other_keywords = (
+        words(('fn', 'usingnamespace', 'test'), suffix=r'\b'),
+        Keyword)
+
+    constant_keywords = (
+        words(('true', 'false', 'null', 'undefined'), suffix=r'\b'),
+        Keyword.Constant)
+
+    tokens = {
+        'root': [
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+            (r'//.*?\n', Comment.Single),
+
+            # Keywords
+            statement_keywords,
+            storage_keywords,
+            structure_keywords,
+            repeat_keywords,
+            type_keywords,
+            constant_keywords,
+            conditional_keywords,
+            other_keywords,
+
+            # Floats
+            (r'0x[0-9a-fA-F]+\.[0-9a-fA-F]+([pP][\-+]?[0-9a-fA-F]+)?', Number.Float),
+            (r'0x[0-9a-fA-F]+\.?[pP][\-+]?[0-9a-fA-F]+', Number.Float),
+            (r'[0-9]+\.[0-9]+([eE][-+]?[0-9]+)?', Number.Float),
+            (r'[0-9]+\.?[eE][-+]?[0-9]+', Number.Float),
+
+            # Integers
+            (r'0b[01]+', Number.Bin),
+            (r'0o[0-7]+', Number.Oct),
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+            (r'[0-9]+', Number.Integer),
+
+            # Identifier
+            (r'@[a-zA-Z_]\w*', Name.Builtin),
+            (r'[a-zA-Z_]\w*', Name),
+
+            # Characters
+            (r'\'\\\'\'', String.Escape),
+            (r'\'\\(x[a-fA-F0-9]{2}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{6}|[nr\\t\'"])\'',
+             String.Escape),
+            (r'\'[^\\\']\'', String),
+
+            # Strings
+            (r'\\\\[^\n]*', String.Heredoc),
+            (r'c\\\\[^\n]*', String.Heredoc),
+            (r'c?"', String, 'string'),
+
+            # Operators, Punctuation
+            (r'[+%=><|^!?/\-*&~:]', Operator),
+            (r'[{}()\[\],.;]', Punctuation)
+        ],
+        'string': [
+            (r'\\(x[a-fA-F0-9]{2}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{6}|[nr\\t\'"])',
+             String.Escape),
+            (r'[^\\"\n]+', String),
+            (r'"', String, '#pop')
+        ]
+    }