pygments.rb 1.1.0 → 2.0.0.rc2

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

@@ -5,7 +5,7 @@
 
     Lexers for Haxe and related stuff.
 
-    :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.
 """
 
@@ -43,7 +43,7 @@ class HaxeLexer(ExtendedRegexLexer):
     typeid = r'_*[A-Z]\w*'
 
     # combined ident and dollar and idtype
-    ident = r'(?:_*[a-z]\w*|_+[0-9]\w*|' + typeid + '|_+|\$\w+)'
+    ident = r'(?:_*[a-z]\w*|_+[0-9]\w*|' + typeid + r'|_+|\$\w+)'
 
     binop = (r'(?:%=|&=|\|=|\^=|\+=|\-=|\*=|/=|<<=|>\s*>\s*=|>\s*>\s*>\s*=|==|'
              r'!=|<=|>\s*=|&&|\|\||<<|>>>|>\s*>|\.\.\.|<|>|%|&|\||\^|\+|\*|'
@@ -182,7 +182,7 @@ class HaxeLexer(ExtendedRegexLexer):
             (r'[0-9]+[eE][+\-]?[0-9]+', Number.Float),
             (r'[0-9]+\.[0-9]*[eE][+\-]?[0-9]+', Number.Float),
             (r'[0-9]+\.[0-9]+', Number.Float),
-            (r'[0-9]+\.(?!' + ident + '|\.\.)', Number.Float),
+            (r'[0-9]+\.(?!' + ident + r'|\.\.)', Number.Float),
 
             # Int
             (r'0x[0-9a-fA-F]+', Number.Hex),
@@ -219,7 +219,7 @@ class HaxeLexer(ExtendedRegexLexer):
             (r'[0-9]+[eE][+\-]?[0-9]+', Number.Float, ('#pop', 'preproc-expr-chain')),
             (r'[0-9]+\.[0-9]*[eE][+\-]?[0-9]+', Number.Float, ('#pop', 'preproc-expr-chain')),
             (r'[0-9]+\.[0-9]+', Number.Float, ('#pop', 'preproc-expr-chain')),
-            (r'[0-9]+\.(?!' + ident + '|\.\.)', Number.Float, ('#pop', 'preproc-expr-chain')),
+            (r'[0-9]+\.(?!' + ident + r'|\.\.)', Number.Float, ('#pop', 'preproc-expr-chain')),
 
             # Int
             (r'0x[0-9a-fA-F]+', Number.Hex, ('#pop', 'preproc-expr-chain')),
@@ -456,7 +456,7 @@ class HaxeLexer(ExtendedRegexLexer):
             (r'[0-9]+[eE][+\-]?[0-9]+', Number.Float, ('#pop', 'expr-chain')),
             (r'[0-9]+\.[0-9]*[eE][+\-]?[0-9]+', Number.Float, ('#pop', 'expr-chain')),
             (r'[0-9]+\.[0-9]+', Number.Float, ('#pop', 'expr-chain')),
-            (r'[0-9]+\.(?!' + ident + '|\.\.)', Number.Float, ('#pop', 'expr-chain')),
+            (r'[0-9]+\.(?!' + ident + r'|\.\.)', Number.Float, ('#pop', 'expr-chain')),
 
             # Int
             (r'0x[0-9a-fA-F]+', Number.Hex, ('#pop', 'expr-chain')),
@@ -711,7 +711,7 @@ class HaxeLexer(ExtendedRegexLexer):
             (r'[0-9]+[eE][+\-]?[0-9]+', Number.Float, '#pop'),
             (r'[0-9]+\.[0-9]*[eE][+\-]?[0-9]+', Number.Float, '#pop'),
             (r'[0-9]+\.[0-9]+', Number.Float, '#pop'),
-            (r'[0-9]+\.(?!' + ident + '|\.\.)', Number.Float, '#pop'),
+            (r'[0-9]+\.(?!' + ident + r'|\.\.)', Number.Float, '#pop'),
 
             # Int
             (r'0x[0-9a-fA-F]+', Number.Hex, '#pop'),

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

@@ -5,7 +5,7 @@
 
     Lexers for hardware descriptor 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.
 """
 
@@ -105,11 +105,12 @@ class VerilogLexer(RegexLexer):
             (words((
                 'byte', 'shortint', 'int', 'longint', 'integer', 'time',
                 'bit', 'logic', 'reg', 'supply0', 'supply1', 'tri', 'triand',
-                'trior', 'tri0', 'tri1', 'trireg', 'uwire', 'wire', 'wand', 'wo'
+                'trior', 'tri0', 'tri1', 'trireg', 'uwire', 'wire', 'wand', 'wor'
                 'shortreal', 'real', 'realtime'), suffix=r'\b'),
              Keyword.Type),
             (r'[a-zA-Z_]\w*:(?!:)', Name.Label),
             (r'\$?[a-zA-Z_]\w*', Name),
+            (r'\\(\S+)', Name),
         ],
         'string': [
             (r'"', String, '#pop'),
@@ -131,14 +132,18 @@ class VerilogLexer(RegexLexer):
         ]
     }
 
-    def get_tokens_unprocessed(self, text):
-        for index, token, value in \
-                RegexLexer.get_tokens_unprocessed(self, text):
-            # Convention: mark all upper case names as constants
-            if token is Name:
-                if value.isupper():
-                    token = Name.Constant
-            yield index, token, value
+    def analyse_text(text):
+        """Verilog code will use one of reg/wire/assign for sure, and that
+        is not common elsewhere."""
+        result = 0
+        if 'reg' in text:
+            result += 0.1
+        if 'wire' in text:
+            result += 0.1
+        if 'assign' in text:
+            result += 0.1
+
+        return result
 
 
 class SystemVerilogLexer(RegexLexer):
@@ -170,91 +175,185 @@ class SystemVerilogLexer(RegexLexer):
             (r'[{}#@]', Punctuation),
             (r'L?"', String, 'string'),
             (r"L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'", String.Char),
+
             (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
             (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
-            (r'([0-9]+)|(\'h)[0-9a-fA-F]+', Number.Hex),
-            (r'([0-9]+)|(\'b)[01]+', Number.Bin),
-            (r'([0-9]+)|(\'d)[0-9]+', Number.Integer),
-            (r'([0-9]+)|(\'o)[0-7]+', Number.Oct),
-            (r'\'[01xz]', Number),
-            (r'\d+[Ll]?', Number.Integer),
+
+            (r'([1-9][_0-9]*)?\s*\'[sS]?[bB]\s*[xXzZ?01][_xXzZ?01]*',
+             Number.Bin),
+            (r'([1-9][_0-9]*)?\s*\'[sS]?[oO]\s*[xXzZ?0-7][_xXzZ?0-7]*',
+             Number.Oct),
+            (r'([1-9][_0-9]*)?\s*\'[sS]?[dD]\s*[xXzZ?0-9][_xXzZ?0-9]*',
+             Number.Integer),
+            (r'([1-9][_0-9]*)?\s*\'[sS]?[hH]\s*[xXzZ?0-9a-fA-F][_xXzZ?0-9a-fA-F]*',
+             Number.Hex),
+
+            (r'\'[01xXzZ]', Number),
+            (r'[0-9][_0-9]*', Number.Integer),
+
             (r'\*/', Error),
+
             (r'[~!%^&*+=|?:<>/-]', Operator),
-            (r'[()\[\],.;\']', Punctuation),
+            (words(('inside', 'dist'), suffix=r'\b'), Operator.Word),
+
+            (r'[()\[\],.;\'$]', Punctuation),
             (r'`[a-zA-Z_]\w*', Name.Constant),
 
             (words((
-                'accept_on', 'alias', 'always', 'always_comb', 'always_ff', 'always_latch',
-                'and', 'assert', 'assign', 'assume', 'automatic', 'before', 'begin', 'bind', 'bins',
-                'binsof', 'bit', 'break', 'buf', 'bufif0', 'bufif1', 'byte', 'case', 'casex', 'casez',
-                'cell', 'chandle', 'checker', 'class', 'clocking', 'cmos', 'config', 'const', 'constraint',
-                'context', 'continue', 'cover', 'covergroup', 'coverpoint', 'cross', 'deassign',
-                'default', 'defparam', 'design', 'disable', 'dist', 'do', 'edge', 'else', 'end', 'endcase',
-                'endchecker', 'endclass', 'endclocking', 'endconfig', 'endfunction', 'endgenerate',
-                'endgroup', 'endinterface', 'endmodule', 'endpackage', 'endprimitive',
-                'endprogram', 'endproperty', 'endsequence', 'endspecify', 'endtable',
-                'endtask', 'enum', 'event', 'eventually', 'expect', 'export', 'extends', 'extern',
-                'final', 'first_match', 'for', 'force', 'foreach', 'forever', 'fork', 'forkjoin',
-                'function', 'generate', 'genvar', 'global', 'highz0', 'highz1', 'if', 'iff', 'ifnone',
-                'ignore_bins', 'illegal_bins', 'implies', 'import', 'incdir', 'include',
-                'initial', 'inout', 'input', 'inside', 'instance', 'int', 'integer', 'interface',
-                'intersect', 'join', 'join_any', 'join_none', 'large', 'let', 'liblist', 'library',
-                'local', 'localparam', 'logic', 'longint', 'macromodule', 'matches', 'medium',
-                'modport', 'module', 'nand', 'negedge', 'new', 'nexttime', 'nmos', 'nor', 'noshowcancelled',
-                'not', 'notif0', 'notif1', 'null', 'or', 'output', 'package', 'packed', 'parameter',
-                'pmos', 'posedge', 'primitive', 'priority', 'program', 'property', 'protected',
-                'pull0', 'pull1', 'pulldown', 'pullup', 'pulsestyle_ondetect', 'pulsestyle_onevent',
-                'pure', 'rand', 'randc', 'randcase', 'randsequence', 'rcmos', 'real', 'realtime',
-                'ref', 'reg', 'reject_on', 'release', 'repeat', 'restrict', 'return', 'rnmos',
-                'rpmos', 'rtran', 'rtranif0', 'rtranif1', 's_always', 's_eventually', 's_nexttime',
-                's_until', 's_until_with', 'scalared', 'sequence', 'shortint', 'shortreal',
-                'showcancelled', 'signed', 'small', 'solve', 'specify', 'specparam', 'static',
-                'string', 'strong', 'strong0', 'strong1', 'struct', 'super', 'supply0', 'supply1',
-                'sync_accept_on', 'sync_reject_on', 'table', 'tagged', 'task', 'this', 'throughout',
-                'time', 'timeprecision', 'timeunit', 'tran', 'tranif0', 'tranif1', 'tri', 'tri0',
-                'tri1', 'triand', 'trior', 'trireg', 'type', 'typedef', 'union', 'unique', 'unique0',
-                'unsigned', 'until', 'until_with', 'untyped', 'use', 'uwire', 'var', 'vectored',
-                'virtual', 'void', 'wait', 'wait_order', 'wand', 'weak', 'weak0', 'weak1', 'while',
-                'wildcard', 'wire', 'with', 'within', 'wor', 'xnor', 'xor'), suffix=r'\b'),
+                'accept_on', 'alias', 'always', 'always_comb', 'always_ff',
+                'always_latch', 'and', 'assert', 'assign', 'assume', 'automatic',
+                'before', 'begin', 'bind', 'bins', 'binsof', 'break', 'buf',
+                'bufif0', 'bufif1', 'case', 'casex', 'casez', 'cell',
+                'checker', 'clocking', 'cmos', 'config',
+                'constraint', 'context', 'continue', 'cover', 'covergroup',
+                'coverpoint', 'cross', 'deassign', 'default', 'defparam', 'design',
+                'disable', 'do', 'edge', 'else', 'end', 'endcase',
+                'endchecker', 'endclocking', 'endconfig', 'endfunction',
+                'endgenerate', 'endgroup', 'endinterface', 'endmodule', 'endpackage',
+                'endprimitive', 'endprogram', 'endproperty', 'endsequence',
+                'endspecify', 'endtable', 'endtask', 'enum', 'eventually',
+                'expect', 'export', 'extern', 'final', 'first_match',
+                'for', 'force', 'foreach', 'forever', 'fork', 'forkjoin', 'function',
+                'generate', 'genvar', 'global', 'highz0', 'highz1', 'if', 'iff',
+                'ifnone', 'ignore_bins', 'illegal_bins', 'implies', 'implements', 'import',
+                'incdir', 'include', 'initial', 'inout', 'input',
+                'instance', 'interconnect', 'interface', 'intersect', 'join',
+                'join_any', 'join_none', 'large', 'let', 'liblist', 'library',
+                'local', 'localparam', 'macromodule', 'matches',
+                'medium', 'modport', 'module', 'nand', 'negedge', 'nettype', 'new', 'nexttime',
+                'nmos', 'nor', 'noshowcancelled', 'not', 'notif0', 'notif1', 'null',
+                'or', 'output', 'package', 'packed', 'parameter', 'pmos', 'posedge',
+                'primitive', 'priority', 'program', 'property', 'protected', 'pull0',
+                'pull1', 'pulldown', 'pullup', 'pulsestyle_ondetect',
+                'pulsestyle_onevent', 'pure', 'rand', 'randc', 'randcase',
+                'randsequence', 'rcmos', 'ref',
+                'reject_on', 'release', 'repeat', 'restrict', 'return', 'rnmos',
+                'rpmos', 'rtran', 'rtranif0', 'rtranif1', 's_always', 's_eventually',
+                's_nexttime', 's_until', 's_until_with', 'scalared', 'sequence',
+                'showcancelled', 'small', 'soft', 'solve',
+                'specify', 'specparam', 'static', 'strong', 'strong0',
+                'strong1', 'struct', 'super', 'sync_accept_on',
+                'sync_reject_on', 'table', 'tagged', 'task', 'this', 'throughout',
+                'timeprecision', 'timeunit', 'tran', 'tranif0', 'tranif1',
+                'typedef', 'union', 'unique', 'unique0', 'until',
+                'until_with', 'untyped', 'use', 'vectored',
+                'virtual', 'wait', 'wait_order', 'weak', 'weak0',
+                'weak1', 'while', 'wildcard', 'with', 'within',
+                'xnor', 'xor'),
+                suffix=r'\b'),
              Keyword),
 
+            (r'(class)(\s+)([a-zA-Z_]\w*)',
+             bygroups(Keyword.Declaration, Text, Name.Class)),
+            (r'(extends)(\s+)([a-zA-Z_]\w*)',
+             bygroups(Keyword.Declaration, Text, Name.Class)),
+            (r'(endclass\b)(?:(\s*)(:)(\s*)([a-zA-Z_]\w*))?',
+             bygroups(Keyword.Declaration, Text, Punctuation, Text, Name.Class)),
+
             (words((
-                '`__FILE__', '`__LINE__', '`begin_keywords', '`celldefine', '`default_nettype',
-                '`define', '`else', '`elsif', '`end_keywords', '`endcelldefine', '`endif',
-                '`ifdef', '`ifndef', '`include', '`line', '`nounconnected_drive', '`pragma',
-                '`resetall', '`timescale', '`unconnected_drive', '`undef', '`undefineall'),
+                # Variable types
+                'bit', 'byte', 'chandle', 'const', 'event', 'int', 'integer',
+                'logic', 'longint', 'real', 'realtime', 'reg', 'shortint',
+                'shortreal', 'signed', 'string', 'time', 'type', 'unsigned',
+                'var', 'void',
+                # Net types
+                'supply0', 'supply1', 'tri', 'triand', 'trior', 'trireg',
+                'tri0', 'tri1', 'uwire', 'wand', 'wire', 'wor'),
+                suffix=r'\b'),
+             Keyword.Type),
+
+            (words((
+                '`__FILE__', '`__LINE__', '`begin_keywords', '`celldefine',
+                '`default_nettype', '`define', '`else', '`elsif', '`end_keywords',
+                '`endcelldefine', '`endif', '`ifdef', '`ifndef', '`include',
+                '`line', '`nounconnected_drive', '`pragma', '`resetall',
+                '`timescale', '`unconnected_drive', '`undef', '`undefineall'),
                 suffix=r'\b'),
              Comment.Preproc),
 
             (words((
-                '$display', '$displayb', '$displayh', '$displayo', '$dumpall', '$dumpfile',
-                '$dumpflush', '$dumplimit', '$dumpoff', '$dumpon', '$dumpports',
-                '$dumpportsall', '$dumpportsflush', '$dumpportslimit', '$dumpportsoff',
-                '$dumpportson', '$dumpvars', '$fclose', '$fdisplay', '$fdisplayb',
-                '$fdisplayh', '$fdisplayo', '$feof', '$ferror', '$fflush', '$fgetc',
-                '$fgets', '$finish', '$fmonitor', '$fmonitorb', '$fmonitorh', '$fmonitoro',
-                '$fopen', '$fread', '$fscanf', '$fseek', '$fstrobe', '$fstrobeb', '$fstrobeh',
-                '$fstrobeo', '$ftell', '$fwrite', '$fwriteb', '$fwriteh', '$fwriteo',
-                '$monitor', '$monitorb', '$monitorh', '$monitoro', '$monitoroff',
-                '$monitoron', '$plusargs', '$random', '$readmemb', '$readmemh', '$rewind',
-                '$sformat', '$sformatf', '$sscanf', '$strobe', '$strobeb', '$strobeh', '$strobeo',
-                '$swrite', '$swriteb', '$swriteh', '$swriteo', '$test', '$ungetc',
-                '$value$plusargs', '$write', '$writeb', '$writeh', '$writememb',
-                '$writememh', '$writeo'), suffix=r'\b'),
+                # Simulation control tasks (20.2)
+                '$exit', '$finish', '$stop',
+                # Simulation time functions (20.3)
+                '$realtime', '$stime', '$time',
+                # Timescale tasks (20.4)
+                '$printtimescale', '$timeformat',
+                # Conversion functions
+                '$bitstoreal', '$bitstoshortreal', '$cast', '$itor',
+                '$realtobits', '$rtoi', '$shortrealtobits', '$signed',
+                '$unsigned',
+                # Data query functions (20.6)
+                '$bits', '$isunbounded', '$typename',
+                # Array query functions (20.7)
+                '$dimensions', '$high', '$increment', '$left', '$low', '$right',
+                '$size', '$unpacked_dimensions',
+                # Math functions (20.8)
+                '$acos', '$acosh', '$asin', '$asinh', '$atan', '$atan2',
+                '$atanh', '$ceil', '$clog2', '$cos', '$cosh', '$exp', '$floor',
+                '$hypot', '$ln', '$log10', '$pow', '$sin', '$sinh', '$sqrt',
+                '$tan', '$tanh',
+                # Bit vector system functions (20.9)
+                '$countbits', '$countones', '$isunknown', '$onehot', '$onehot0',
+                # Severity tasks (20.10)
+                '$info', '$error', '$fatal', '$warning',
+                # Assertion control tasks (20.12)
+                '$assertcontrol', '$assertfailoff', '$assertfailon',
+                '$assertkill', '$assertnonvacuouson', '$assertoff', '$asserton',
+                '$assertpassoff', '$assertpasson', '$assertvacuousoff',
+                # Sampled value system functions (20.13)
+                '$changed', '$changed_gclk', '$changing_gclk', '$falling_gclk',
+                '$fell', '$fell_gclk', '$future_gclk', '$past', '$past_gclk',
+                '$rising_gclk', '$rose', '$rose_gclk', '$sampled', '$stable',
+                '$stable_gclk', '$steady_gclk',
+                # Coverage control functions (20.14)
+                '$coverage_control', '$coverage_get', '$coverage_get_max',
+                '$coverage_merge', '$coverage_save', '$get_coverage',
+                '$load_coverage_db', '$set_coverage_db_name',
+                # Probabilistic distribution functions (20.15)
+                '$dist_chi_square', '$dist_erlang', '$dist_exponential',
+                '$dist_normal', '$dist_poisson', '$dist_t', '$dist_uniform',
+                '$random',
+                # Stochastic analysis tasks and functions (20.16)
+                '$q_add', '$q_exam', '$q_full', '$q_initialize', '$q_remove',
+                # PLA modeling tasks (20.17)
+                '$async$and$array', '$async$and$plane', '$async$nand$array',
+                '$async$nand$plane', '$async$nor$array', '$async$nor$plane',
+                '$async$or$array', '$async$or$plane', '$sync$and$array',
+                '$sync$and$plane', '$sync$nand$array', '$sync$nand$plane',
+                '$sync$nor$array', '$sync$nor$plane', '$sync$or$array',
+                '$sync$or$plane',
+                # Miscellaneous tasks and functions (20.18)
+                '$system',
+                # Display tasks (21.2)
+                '$display', '$displayb', '$displayh', '$displayo', '$monitor',
+                '$monitorb', '$monitorh', '$monitoro', '$monitoroff',
+                '$monitoron', '$strobe', '$strobeb', '$strobeh', '$strobeo',
+                '$write', '$writeb', '$writeh', '$writeo',
+                # File I/O tasks and functions (21.3)
+                '$fclose', '$fdisplay', '$fdisplayb', '$fdisplayh',
+                '$fdisplayo', '$feof', '$ferror', '$fflush', '$fgetc', '$fgets',
+                '$fmonitor', '$fmonitorb', '$fmonitorh', '$fmonitoro', '$fopen',
+                '$fread', '$fscanf', '$fseek', '$fstrobe', '$fstrobeb',
+                '$fstrobeh', '$fstrobeo', '$ftell', '$fwrite', '$fwriteb',
+                '$fwriteh', '$fwriteo', '$rewind', '$sformat', '$sformatf',
+                '$sscanf', '$swrite', '$swriteb', '$swriteh', '$swriteo',
+                '$ungetc',
+                # Memory load tasks (21.4)
+                '$readmemb', '$readmemh',
+                # Memory dump tasks (21.5)
+                '$writememb', '$writememh',
+                # Command line input (21.6)
+                '$test$plusargs', '$value$plusargs',
+                # VCD tasks (21.7)
+                '$dumpall', '$dumpfile', '$dumpflush', '$dumplimit', '$dumpoff',
+                '$dumpon', '$dumpports', '$dumpportsall', '$dumpportsflush',
+                '$dumpportslimit', '$dumpportsoff', '$dumpportson', '$dumpvars',
+                ), suffix=r'\b'),
              Name.Builtin),
 
-            (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
-            (words((
-                'byte', 'shortint', 'int', 'longint', 'integer', 'time',
-                'bit', 'logic', 'reg', 'supply0', 'supply1', 'tri', 'triand',
-                'trior', 'tri0', 'tri1', 'trireg', 'uwire', 'wire', 'wand', 'wo'
-                'shortreal', 'real', 'realtime'), suffix=r'\b'),
-             Keyword.Type),
             (r'[a-zA-Z_]\w*:(?!:)', Name.Label),
             (r'\$?[a-zA-Z_]\w*', Name),
-        ],
-        'classname': [
-            (r'[a-zA-Z_]\w*', Name.Class, '#pop'),
+            (r'\\(\S+)', Name),
         ],
         'string': [
             (r'"', String, '#pop'),
@@ -276,15 +375,6 @@ class SystemVerilogLexer(RegexLexer):
         ]
     }
 
-    def get_tokens_unprocessed(self, text):
-        for index, token, value in \
-                RegexLexer.get_tokens_unprocessed(self, text):
-            # Convention: mark all upper case names as constants
-            if token is Name:
-                if value.isupper():
-                    token = Name.Constant
-            yield index, token, value
-
 
 class VhdlLexer(RegexLexer):
     """

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

@@ -5,12 +5,10 @@
 
     Lexers for hexadecimal dumps.
 
-    :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, include
 from pygments.token import Text, Name, Number, String, Punctuation
 
@@ -36,7 +34,7 @@ class HexdumpLexer(RegexLexer):
     * ``od -t x1z FILE``
     * ``xxd FILE``
     * ``DEBUG.EXE FILE.COM`` and entering ``d`` to the prompt.
-    
+
     .. versionadded:: 2.1
     """
     name = 'Hexdump'
@@ -48,12 +46,17 @@ class HexdumpLexer(RegexLexer):
         'root': [
             (r'\n', Text),
             include('offset'),
-            (r'('+hd+r'{2})(\-)('+hd+r'{2})', bygroups(Number.Hex, Punctuation, Number.Hex)),
+            (r'('+hd+r'{2})(\-)('+hd+r'{2})',
+             bygroups(Number.Hex, Punctuation, Number.Hex)),
             (hd+r'{2}', Number.Hex),
-            (r'(\s{2,3})(\>)(.{16})(\<)$', bygroups(Text, Punctuation, String, Punctuation), 'bracket-strings'),
-            (r'(\s{2,3})(\|)(.{16})(\|)$', bygroups(Text, Punctuation, String, Punctuation), 'piped-strings'),
-            (r'(\s{2,3})(\>)(.{1,15})(\<)$', bygroups(Text, Punctuation, String, Punctuation)),
-            (r'(\s{2,3})(\|)(.{1,15})(\|)$', bygroups(Text, Punctuation, String, Punctuation)),
+            (r'(\s{2,3})(\>)(.{16})(\<)$',
+             bygroups(Text, Punctuation, String, Punctuation), 'bracket-strings'),
+            (r'(\s{2,3})(\|)(.{16})(\|)$',
+             bygroups(Text, Punctuation, String, Punctuation), 'piped-strings'),
+            (r'(\s{2,3})(\>)(.{1,15})(\<)$',
+             bygroups(Text, Punctuation, String, Punctuation)),
+            (r'(\s{2,3})(\|)(.{1,15})(\|)$',
+             bygroups(Text, Punctuation, String, Punctuation)),
             (r'(\s{2,3})(.{1,15})$', bygroups(Text, String)),
             (r'(\s{2,3})(.{16}|.{20})$', bygroups(Text, String), 'nonpiped-strings'),
             (r'\s', Text),
@@ -72,7 +75,8 @@ class HexdumpLexer(RegexLexer):
             (r'\n', Text),
             include('offset'),
             (hd+r'{2}', Number.Hex),
-            (r'(\s{2,3})(\|)(.{1,16})(\|)$', bygroups(Text, Punctuation, String, Punctuation)),
+            (r'(\s{2,3})(\|)(.{1,16})(\|)$',
+             bygroups(Text, Punctuation, String, Punctuation)),
             (r'\s', Text),
             (r'^\*', Punctuation),
         ],
@@ -80,14 +84,16 @@ class HexdumpLexer(RegexLexer):
             (r'\n', Text),
             include('offset'),
             (hd+r'{2}', Number.Hex),
-            (r'(\s{2,3})(\>)(.{1,16})(\<)$', bygroups(Text, Punctuation, String, Punctuation)),
+            (r'(\s{2,3})(\>)(.{1,16})(\<)$',
+             bygroups(Text, Punctuation, String, Punctuation)),
             (r'\s', Text),
             (r'^\*', Punctuation),
         ],
         'nonpiped-strings': [
             (r'\n', Text),
             include('offset'),
-            (r'('+hd+r'{2})(\-)('+hd+r'{2})', bygroups(Number.Hex, Punctuation, Number.Hex)),
+            (r'('+hd+r'{2})(\-)('+hd+r'{2})',
+             bygroups(Number.Hex, Punctuation, Number.Hex)),
             (hd+r'{2}', Number.Hex),
             (r'(\s{19,})(.{1,20}?)$', bygroups(Text, String)),
             (r'(\s{2,3})(.{1,20})$', bygroups(Text, String)),

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

@@ -5,7 +5,7 @@
 
     Lexers for HTML, XML and related markup.
 
-    :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.
 """
 
@@ -77,12 +77,24 @@ class HtmlLexer(RegexLexer):
              bygroups(Punctuation, Text, Punctuation, Text, Name.Tag, Text,
                       Punctuation), '#pop'),
             (r'.+?(?=<\s*/\s*script\s*>)', using(JavascriptLexer)),
+            # fallback cases for when there is no closing script tag
+            # first look for newline and then go back into root state
+            # if that fails just read the rest of the file
+            # this is similar to the error handling logic in lexer.py
+            (r'.+?\n', using(JavascriptLexer), '#pop'),
+            (r'.+', using(JavascriptLexer), '#pop'),
         ],
         'style-content': [
             (r'(<)(\s*)(/)(\s*)(style)(\s*)(>)',
              bygroups(Punctuation, Text, Punctuation, Text, Name.Tag, Text,
                       Punctuation),'#pop'),
             (r'.+?(?=<\s*/\s*style\s*>)', using(CssLexer)),
+            # fallback cases for when there is no closing style tag
+            # first look for newline and then go back into root state
+            # if that fails just read the rest of the file
+            # this is similar to the error handling logic in lexer.py
+            (r'.+?\n', using(CssLexer), '#pop'),
+            (r'.+', using(CssLexer), '#pop'),
         ],
         'attr': [
             ('".*?"', String, '#pop'),
@@ -220,7 +232,7 @@ class XmlLexer(RegexLexer):
             (r'/?\s*>', Name.Tag, '#pop'),
         ],
         'attr': [
-            ('\s+', Text),
+            (r'\s+', Text),
             ('".*?"', String, '#pop'),
             ("'.*?'", String, '#pop'),
             (r'[^\s>]+', String, '#pop'),
@@ -244,7 +256,7 @@ class XsltLexer(XmlLexer):
     filenames = ['*.xsl', '*.xslt', '*.xpl']  # xpl is XProc
     mimetypes = ['application/xsl+xml', 'application/xslt+xml']
 
-    EXTRA_KEYWORDS = set((
+    EXTRA_KEYWORDS = {
         'apply-imports', 'apply-templates', 'attribute',
         'attribute-set', 'call-template', 'choose', 'comment',
         'copy', 'copy-of', 'decimal-format', 'element', 'fallback',
@@ -253,7 +265,7 @@ class XsltLexer(XmlLexer):
         'preserve-space', 'processing-instruction', 'sort',
         'strip-space', 'stylesheet', 'template', 'text', 'transform',
         'value-of', 'variable', 'when', 'with-param'
-    ))
+    }
 
     def get_tokens_unprocessed(self, text):
         for index, token, value in XmlLexer.get_tokens_unprocessed(self, text):
@@ -313,7 +325,7 @@ class HamlLexer(ExtendedRegexLexer):
             include('css'),
             (r'%[\w:-]+', Name.Tag, 'tag'),
             (r'!!!' + _dot + r'*\n', Name.Namespace, '#pop'),
-            (r'(/)(\[' + _dot + '*?\])(' + _dot + r'*\n)',
+            (r'(/)(\[' + _dot + r'*?\])(' + _dot + r'*\n)',
              bygroups(Comment, Comment.Special, Comment),
              '#pop'),
             (r'/' + _dot + r'*\n', _starts_block(Comment, 'html-comment-block'),
@@ -330,8 +342,8 @@ class HamlLexer(ExtendedRegexLexer):
 
         'tag': [
             include('css'),
-            (r'\{(,\n|' + _dot + ')*?\}', using(RubyLexer)),
-            (r'\[' + _dot + '*?\]', using(RubyLexer)),
+            (r'\{(,\n|' + _dot + r')*?\}', using(RubyLexer)),
+            (r'\[' + _dot + r'*?\]', using(RubyLexer)),
             (r'\(', Text, 'html-attributes'),
             (r'/[ \t]*\n', Punctuation, '#pop:2'),
             (r'[<>]{1,2}(?=[ \t=])', Punctuation),
@@ -340,7 +352,7 @@ class HamlLexer(ExtendedRegexLexer):
 
         'plain': [
             (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Text),
-            (r'(#\{)(' + _dot + '*?)(\})',
+            (r'(#\{)(' + _dot + r'*?)(\})',
              bygroups(String.Interpol, using(RubyLexer), String.Interpol)),
             (r'\n', Text, 'root'),
         ],
@@ -373,7 +385,7 @@ class HamlLexer(ExtendedRegexLexer):
 
         'filter-block': [
             (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Name.Decorator),
-            (r'(#\{)(' + _dot + '*?)(\})',
+            (r'(#\{)(' + _dot + r'*?)(\})',
              bygroups(String.Interpol, using(RubyLexer), String.Interpol)),
             (r'\n', Text, 'root'),
         ],
@@ -422,7 +434,7 @@ class ScamlLexer(ExtendedRegexLexer):
             include('css'),
             (r'%[\w:-]+', Name.Tag, 'tag'),
             (r'!!!' + _dot + r'*\n', Name.Namespace, '#pop'),
-            (r'(/)(\[' + _dot + '*?\])(' + _dot + r'*\n)',
+            (r'(/)(\[' + _dot + r'*?\])(' + _dot + r'*\n)',
              bygroups(Comment, Comment.Special, Comment),
              '#pop'),
             (r'/' + _dot + r'*\n', _starts_block(Comment, 'html-comment-block'),
@@ -442,8 +454,8 @@ class ScamlLexer(ExtendedRegexLexer):
 
         'tag': [
             include('css'),
-            (r'\{(,\n|' + _dot + ')*?\}', using(ScalaLexer)),
-            (r'\[' + _dot + '*?\]', using(ScalaLexer)),
+            (r'\{(,\n|' + _dot + r')*?\}', using(ScalaLexer)),
+            (r'\[' + _dot + r'*?\]', using(ScalaLexer)),
             (r'\(', Text, 'html-attributes'),
             (r'/[ \t]*\n', Punctuation, '#pop:2'),
             (r'[<>]{1,2}(?=[ \t=])', Punctuation),
@@ -452,7 +464,7 @@ class ScamlLexer(ExtendedRegexLexer):
 
         'plain': [
             (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Text),
-            (r'(#\{)(' + _dot + '*?)(\})',
+            (r'(#\{)(' + _dot + r'*?)(\})',
              bygroups(String.Interpol, using(ScalaLexer), String.Interpol)),
             (r'\n', Text, 'root'),
         ],
@@ -485,7 +497,7 @@ class ScamlLexer(ExtendedRegexLexer):
 
         'filter-block': [
             (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Name.Decorator),
-            (r'(#\{)(' + _dot + '*?)(\})',
+            (r'(#\{)(' + _dot + r'*?)(\})',
              bygroups(String.Interpol, using(ScalaLexer), String.Interpol)),
             (r'\n', Text, 'root'),
         ],
@@ -530,7 +542,7 @@ class PugLexer(ExtendedRegexLexer):
         'content': [
             include('css'),
             (r'!!!' + _dot + r'*\n', Name.Namespace, '#pop'),
-            (r'(/)(\[' + _dot + '*?\])(' + _dot + r'*\n)',
+            (r'(/)(\[' + _dot + r'*?\])(' + _dot + r'*\n)',
              bygroups(Comment, Comment.Special, Comment),
              '#pop'),
             (r'/' + _dot + r'*\n', _starts_block(Comment, 'html-comment-block'),
@@ -551,8 +563,8 @@ class PugLexer(ExtendedRegexLexer):
 
         'tag': [
             include('css'),
-            (r'\{(,\n|' + _dot + ')*?\}', using(ScalaLexer)),
-            (r'\[' + _dot + '*?\]', using(ScalaLexer)),
+            (r'\{(,\n|' + _dot + r')*?\}', using(ScalaLexer)),
+            (r'\[' + _dot + r'*?\]', using(ScalaLexer)),
             (r'\(', Text, 'html-attributes'),
             (r'/[ \t]*\n', Punctuation, '#pop:2'),
             (r'[<>]{1,2}(?=[ \t=])', Punctuation),
@@ -561,7 +573,7 @@ class PugLexer(ExtendedRegexLexer):
 
         'plain': [
             (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Text),
-            (r'(#\{)(' + _dot + '*?)(\})',
+            (r'(#\{)(' + _dot + r'*?)(\})',
              bygroups(String.Interpol, using(ScalaLexer), String.Interpol)),
             (r'\n', Text, 'root'),
         ],
@@ -594,7 +606,7 @@ class PugLexer(ExtendedRegexLexer):
 
         'filter-block': [
             (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Name.Decorator),
-            (r'(#\{)(' + _dot + '*?)(\})',
+            (r'(#\{)(' + _dot + r'*?)(\})',
              bygroups(String.Interpol, using(ScalaLexer), String.Interpol)),
             (r'\n', Text, 'root'),
         ],