pygments.rb 0.6.3 → 1.0.0

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

@@ -5,15 +5,15 @@
 
     Lexers for hardware descriptor languages.
 
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 import re
-from pygments.lexer import RegexLexer, bygroups, include, using, this
-from pygments.token import \
-     Text, Comment, Operator, Keyword, Name, String, Number, Punctuation, \
-     Error
+
+from pygments.lexer import RegexLexer, bygroups, include, using, this, words
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Error
 
 __all__ = ['VerilogLexer', 'SystemVerilogLexer', 'VhdlLexer']
 
@@ -37,7 +37,7 @@ class VerilogLexer(RegexLexer):
             (r'^\s*`define', Comment.Preproc, 'macro'),
             (r'\n', Text),
             (r'\s+', Text),
-            (r'\\\n', Text), # line continuation
+            (r'\\\n', Text),  # line continuation
             (r'/(\\\n)?/(\n|(.|\n)*?[^\\]\n)', Comment.Single),
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
             (r'[{}#@]', Punctuation),
@@ -46,7 +46,7 @@ class VerilogLexer(RegexLexer):
             (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)[0-1]+', Number.Bin),
+            (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),
@@ -60,51 +60,63 @@ class VerilogLexer(RegexLexer):
             (r'^(\s*)(import)(\s+)', bygroups(Text, Keyword.Namespace, Text),
              'import'),
 
-            (r'(always|always_comb|always_ff|always_latch|and|assign|automatic|'
-             r'begin|break|buf|bufif0|bufif1|case|casex|casez|cmos|const|'
-             r'continue|deassign|default|defparam|disable|do|edge|else|end|endcase|'
-             r'endfunction|endgenerate|endmodule|endpackage|endprimitive|endspecify|'
-             r'endtable|endtask|enum|event|final|for|force|forever|fork|function|'
-             r'generate|genvar|highz0|highz1|if|initial|inout|input|'
-             r'integer|join|large|localparam|macromodule|medium|module|'
-             r'nand|negedge|nmos|nor|not|notif0|notif1|or|output|packed|'
-             r'parameter|pmos|posedge|primitive|pull0|pull1|pulldown|pullup|rcmos|'
-             r'ref|release|repeat|return|rnmos|rpmos|rtran|rtranif0|'
-             r'rtranif1|scalared|signed|small|specify|specparam|strength|'
-             r'string|strong0|strong1|struct|table|task|'
-             r'tran|tranif0|tranif1|type|typedef|'
-             r'unsigned|var|vectored|void|wait|weak0|weak1|while|'
-             r'xnor|xor)\b', Keyword),
-
-            (r'`(accelerate|autoexpand_vectornets|celldefine|default_nettype|'
-             r'else|elsif|endcelldefine|endif|endprotect|endprotected|'
-             r'expand_vectornets|ifdef|ifndef|include|noaccelerate|noexpand_vectornets|'
-             r'noremove_gatenames|noremove_netnames|nounconnected_drive|'
-             r'protect|protected|remove_gatenames|remove_netnames|resetall|'
-             r'timescale|unconnected_drive|undef)\b', Comment.Preproc),
-
-            (r'\$(bits|bitstoreal|bitstoshortreal|countdrivers|display|fclose|'
-             r'fdisplay|finish|floor|fmonitor|fopen|fstrobe|fwrite|'
-             r'getpattern|history|incsave|input|itor|key|list|log|'
-             r'monitor|monitoroff|monitoron|nokey|nolog|printtimescale|'
-             r'random|readmemb|readmemh|realtime|realtobits|reset|reset_count|'
-             r'reset_value|restart|rtoi|save|scale|scope|shortrealtobits|'
-             r'showscopes|showvariables|showvars|sreadmemb|sreadmemh|'
-             r'stime|stop|strobe|time|timeformat|write)\b', Name.Builtin),
-
-            (r'(byte|shortint|int|longint|integer|time|'
-             r'bit|logic|reg|'
-             r'supply0|supply1|tri|triand|trior|tri0|tri1|trireg|uwire|wire|wand|wor'
-             r'shortreal|real|realtime)\b', Keyword.Type),
-            ('[a-zA-Z_]\w*:(?!:)', Name.Label),
-            ('[a-zA-Z_]\w*', Name),
+            (words((
+                'always', 'always_comb', 'always_ff', 'always_latch', 'and',
+                'assign', 'automatic', 'begin', 'break', 'buf', 'bufif0', 'bufif1',
+                'case', 'casex', 'casez', 'cmos', 'const', 'continue', 'deassign',
+                'default', 'defparam', 'disable', 'do', 'edge', 'else', 'end', 'endcase',
+                'endfunction', 'endgenerate', 'endmodule', 'endpackage', 'endprimitive',
+                'endspecify', 'endtable', 'endtask', 'enum', 'event', 'final', 'for',
+                'force', 'forever', 'fork', 'function', 'generate', 'genvar', 'highz0',
+                'highz1', 'if', 'initial', 'inout', 'input', 'integer', 'join', 'large',
+                'localparam', 'macromodule', 'medium', 'module', 'nand', 'negedge',
+                'nmos', 'nor', 'not', 'notif0', 'notif1', 'or', 'output', 'packed',
+                'parameter', 'pmos', 'posedge', 'primitive', 'pull0', 'pull1',
+                'pulldown', 'pullup', 'rcmos', 'ref', 'release', 'repeat', 'return',
+                'rnmos', 'rpmos', 'rtran', 'rtranif0', 'rtranif1', 'scalared', 'signed',
+                'small', 'specify', 'specparam', 'strength', 'string', 'strong0',
+                'strong1', 'struct', 'table', 'task', 'tran', 'tranif0', 'tranif1',
+                'type', 'typedef', 'unsigned', 'var', 'vectored', 'void', 'wait',
+                'weak0', 'weak1', 'while', 'xnor', 'xor'), suffix=r'\b'),
+             Keyword),
+
+            (words((
+                'accelerate', 'autoexpand_vectornets', 'celldefine', 'default_nettype',
+                'else', 'elsif', 'endcelldefine', 'endif', 'endprotect', 'endprotected',
+                'expand_vectornets', 'ifdef', 'ifndef', 'include', 'noaccelerate',
+                'noexpand_vectornets', 'noremove_gatenames', 'noremove_netnames',
+                'nounconnected_drive', 'protect', 'protected', 'remove_gatenames',
+                'remove_netnames', 'resetall', 'timescale', 'unconnected_drive',
+                'undef'), prefix=r'`', suffix=r'\b'),
+             Comment.Preproc),
+
+            (words((
+                'bits', 'bitstoreal', 'bitstoshortreal', 'countdrivers', 'display', 'fclose',
+                'fdisplay', 'finish', 'floor', 'fmonitor', 'fopen', 'fstrobe', 'fwrite',
+                'getpattern', 'history', 'incsave', 'input', 'itor', 'key', 'list', 'log',
+                'monitor', 'monitoroff', 'monitoron', 'nokey', 'nolog', 'printtimescale',
+                'random', 'readmemb', 'readmemh', 'realtime', 'realtobits', 'reset',
+                'reset_count', 'reset_value', 'restart', 'rtoi', 'save', 'scale', 'scope',
+                'shortrealtobits', 'showscopes', 'showvariables', 'showvars', 'sreadmemb',
+                'sreadmemh', 'stime', 'stop', 'strobe', 'time', 'timeformat', 'write'),
+                prefix=r'\$', suffix=r'\b'),
+             Name.Builtin),
+
+            (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),
         ],
         'string': [
             (r'"', String, '#pop'),
             (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape),
-            (r'[^\\"\n]+', String), # all other characters
-            (r'\\\n', String), # line continuation
-            (r'\\', String), # stray backslash
+            (r'[^\\"\n]+', String),  # all other characters
+            (r'\\\n', String),  # line continuation
+            (r'\\', String),  # stray backslash
         ],
         'macro': [
             (r'[^/\n]+', Comment.Preproc),
@@ -121,7 +133,7 @@ class VerilogLexer(RegexLexer):
 
     def get_tokens_unprocessed(self, text):
         for index, token, value in \
-            RegexLexer.get_tokens_unprocessed(self, text):
+                RegexLexer.get_tokens_unprocessed(self, text):
             # Convention: mark all upper case names as constants
             if token is Name:
                 if value.isupper():
@@ -152,7 +164,7 @@ class SystemVerilogLexer(RegexLexer):
 
             (r'\n', Text),
             (r'\s+', Text),
-            (r'\\\n', Text), # line continuation
+            (r'\\\n', Text),  # line continuation
             (r'/(\\\n)?/(\n|(.|\n)*?[^\\]\n)', Comment.Single),
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
             (r'[{}#@]', Punctuation),
@@ -161,7 +173,7 @@ class SystemVerilogLexer(RegexLexer):
             (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)[0-1]+', Number.Bin),
+            (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),
@@ -171,67 +183,75 @@ class SystemVerilogLexer(RegexLexer):
             (r'[()\[\],.;\']', Punctuation),
             (r'`[a-zA-Z_]\w*', Name.Constant),
 
-            (r'(accept_on|alias|always|always_comb|always_ff|always_latch|'
-             r'and|assert|assign|assume|automatic|before|begin|bind|bins|'
-             r'binsof|bit|break|buf|bufif0|bufif1|byte|case|casex|casez|'
-             r'cell|chandle|checker|class|clocking|cmos|config|const|constraint|'
-             r'context|continue|cover|covergroup|coverpoint|cross|deassign|'
-             r'default|defparam|design|disable|dist|do|edge|else|end|endcase|'
-             r'endchecker|endclass|endclocking|endconfig|endfunction|endgenerate|'
-             r'endgroup|endinterface|endmodule|endpackage|endprimitive|'
-             r'endprogram|endproperty|endsequence|endspecify|endtable|'
-             r'endtask|enum|event|eventually|expect|export|extends|extern|'
-             r'final|first_match|for|force|foreach|forever|fork|forkjoin|'
-             r'function|generate|genvar|global|highz0|highz1|if|iff|ifnone|'
-             r'ignore_bins|illegal_bins|implies|import|incdir|include|'
-             r'initial|inout|input|inside|instance|int|integer|interface|'
-             r'intersect|join|join_any|join_none|large|let|liblist|library|'
-             r'local|localparam|logic|longint|macromodule|matches|medium|'
-             r'modport|module|nand|negedge|new|nexttime|nmos|nor|noshowcancelled|'
-             r'not|notif0|notif1|null|or|output|package|packed|parameter|'
-             r'pmos|posedge|primitive|priority|program|property|protected|'
-             r'pull0|pull1|pulldown|pullup|pulsestyle_ondetect|pulsestyle_onevent|'
-             r'pure|rand|randc|randcase|randsequence|rcmos|real|realtime|'
-             r'ref|reg|reject_on|release|repeat|restrict|return|rnmos|'
-             r'rpmos|rtran|rtranif0|rtranif1|s_always|s_eventually|s_nexttime|'
-             r's_until|s_until_with|scalared|sequence|shortint|shortreal|'
-             r'showcancelled|signed|small|solve|specify|specparam|static|'
-             r'string|strong|strong0|strong1|struct|super|supply0|supply1|'
-             r'sync_accept_on|sync_reject_on|table|tagged|task|this|throughout|'
-             r'time|timeprecision|timeunit|tran|tranif0|tranif1|tri|tri0|'
-             r'tri1|triand|trior|trireg|type|typedef|union|unique|unique0|'
-             r'unsigned|until|until_with|untyped|use|uwire|var|vectored|'
-             r'virtual|void|wait|wait_order|wand|weak|weak0|weak1|while|'
-             r'wildcard|wire|with|within|wor|xnor|xor)\b', Keyword ),
-
-            (r'(`__FILE__|`__LINE__|`begin_keywords|`celldefine|`default_nettype|'
-             r'`define|`else|`elsif|`end_keywords|`endcelldefine|`endif|'
-             r'`ifdef|`ifndef|`include|`line|`nounconnected_drive|`pragma|'
-             r'`resetall|`timescale|`unconnected_drive|`undef|`undefineall)\b',
-             Comment.Preproc ),
-
-            (r'(\$display|\$displayb|\$displayh|\$displayo|\$dumpall|\$dumpfile|'
-             r'\$dumpflush|\$dumplimit|\$dumpoff|\$dumpon|\$dumpports|'
-             r'\$dumpportsall|\$dumpportsflush|\$dumpportslimit|\$dumpportsoff|'
-             r'\$dumpportson|\$dumpvars|\$fclose|\$fdisplay|\$fdisplayb|'
-             r'\$fdisplayh|\$fdisplayo|\$feof|\$ferror|\$fflush|\$fgetc|'
-             r'\$fgets|\$finish|\$fmonitor|\$fmonitorb|\$fmonitorh|\$fmonitoro|'
-             r'\$fopen|\$fread|\$fscanf|\$fseek|\$fstrobe|\$fstrobeb|\$fstrobeh|'
-             r'\$fstrobeo|\$ftell|\$fwrite|\$fwriteb|\$fwriteh|\$fwriteo|'
-             r'\$monitor|\$monitorb|\$monitorh|\$monitoro|\$monitoroff|'
-             r'\$monitoron|\$plusargs|\$random\|$readmemb|\$readmemh|\$rewind|'
-             r'\$sformat|\$sformatf|\$sscanf|\$strobe|\$strobeb|\$strobeh|\$strobeo|'
-             r'\$swrite|\$swriteb|\$swriteh|\$swriteo|\$test|\$ungetc|'
-             r'\$value\$plusargs|\$write|\$writeb|\$writeh|\$writememb|'
-             r'\$writememh|\$writeo)\b' , Name.Builtin ),
+            (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'),
+             Keyword),
+
+            (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'),
+             Name.Builtin),
 
             (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
-            (r'(byte|shortint|int|longint|integer|time|'
-             r'bit|logic|reg|'
-             r'supply0|supply1|tri|triand|trior|tri0|tri1|trireg|uwire|wire|wand|wor'
-             r'shortreal|real|realtime)\b', Keyword.Type),
-            ('[a-zA-Z_]\w*:(?!:)', Name.Label),
-            ('[a-zA-Z_]\w*', Name),
+            (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'),
@@ -239,9 +259,9 @@ class SystemVerilogLexer(RegexLexer):
         'string': [
             (r'"', String, '#pop'),
             (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape),
-            (r'[^\\"\n]+', String), # all other characters
-            (r'\\\n', String), # line continuation
-            (r'\\', String), # stray backslash
+            (r'[^\\"\n]+', String),  # all other characters
+            (r'\\\n', String),  # line continuation
+            (r'\\', String),  # stray backslash
         ],
         'macro': [
             (r'[^/\n]+', Comment.Preproc),
@@ -258,17 +278,13 @@ class SystemVerilogLexer(RegexLexer):
 
     def get_tokens_unprocessed(self, text):
         for index, token, value in \
-            RegexLexer.get_tokens_unprocessed(self, text):
+                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):
-        if text.startswith('//') or text.startswith('/*'):
-            return 0.5
-
 
 class VhdlLexer(RegexLexer):
     """
@@ -286,26 +302,33 @@ class VhdlLexer(RegexLexer):
         'root': [
             (r'\n', Text),
             (r'\s+', Text),
-            (r'\\\n', Text), # line continuation
-            (r'--(?![!#$%&*+./<=>?@\^|_~]).*?$', Comment.Single),
+            (r'\\\n', Text),  # line continuation
+            (r'--.*?$', Comment.Single),
             (r"'(U|X|0|1|Z|W|L|H|-)'", String.Char),
             (r'[~!%^&*+=|?:<>/-]', Operator),
             (r"'[a-z_]\w*", Name.Attribute),
             (r'[()\[\],.;\']', Punctuation),
-            (r'"[^\n\\]*"', String),
+            (r'"[^\n\\"]*"', String),
 
             (r'(library)(\s+)([a-z_]\w*)',
              bygroups(Keyword, Text, Name.Namespace)),
             (r'(use)(\s+)(entity)', bygroups(Keyword, Text, Keyword)),
-            (r'(use)(\s+)([a-z_][\.\w]*)',
+            (r'(use)(\s+)([a-z_][\w.]*\.)(all)',
+             bygroups(Keyword, Text, Name.Namespace, Keyword)),
+            (r'(use)(\s+)([a-z_][\w.]*)',
              bygroups(Keyword, Text, Name.Namespace)),
+            (r'(std|ieee)(\.[a-z_]\w*)',
+             bygroups(Name.Namespace, Name.Namespace)),
+            (words(('std', 'ieee', 'work'), suffix=r'\b'),
+             Name.Namespace),
             (r'(entity|component)(\s+)([a-z_]\w*)',
              bygroups(Keyword, Text, Name.Class)),
             (r'(architecture|configuration)(\s+)([a-z_]\w*)(\s+)'
              r'(of)(\s+)([a-z_]\w*)(\s+)(is)',
              bygroups(Keyword, Text, Name.Class, Text, Keyword, Text,
                       Name.Class, Text, Keyword)),
-
+            (r'([a-z_]\w*)(:)(\s+)(process|for)',
+             bygroups(Name.Class, Operator, Text, Keyword)),
             (r'(end)(\s+)', bygroups(using(this), Text), 'endblock'),
 
             include('types'),
@@ -321,35 +344,39 @@ class VhdlLexer(RegexLexer):
             (r';', Punctuation, '#pop'),
         ],
         'types': [
-            (r'(boolean|bit|character|severity_level|integer|time|delay_length|'
-             r'natural|positive|string|bit_vector|file_open_kind|'
-             r'file_open_status|std_ulogic|std_ulogic_vector|std_logic|'
-             r'std_logic_vector)\b', Keyword.Type),
+            (words((
+                'boolean', 'bit', 'character', 'severity_level', 'integer', 'time',
+                'delay_length', 'natural', 'positive', 'string', 'bit_vector',
+                'file_open_kind', 'file_open_status', 'std_ulogic', 'std_ulogic_vector',
+                'std_logic', 'std_logic_vector', 'signed', 'unsigned'), suffix=r'\b'),
+             Keyword.Type),
         ],
         'keywords': [
-            (r'(abs|access|after|alias|all|and|'
-             r'architecture|array|assert|attribute|begin|block|'
-             r'body|buffer|bus|case|component|configuration|'
-             r'constant|disconnect|downto|else|elsif|end|'
-             r'entity|exit|file|for|function|generate|'
-             r'generic|group|guarded|if|impure|in|'
-             r'inertial|inout|is|label|library|linkage|'
-             r'literal|loop|map|mod|nand|new|'
-             r'next|nor|not|null|of|on|'
-             r'open|or|others|out|package|port|'
-             r'postponed|procedure|process|pure|range|record|'
-             r'register|reject|return|rol|ror|select|'
-             r'severity|signal|shared|sla|sli|sra|'
-             r'srl|subtype|then|to|transport|type|'
-             r'units|until|use|variable|wait|when|'
-             r'while|with|xnor|xor)\b', Keyword),
+            (words((
+                'abs', 'access', 'after', 'alias', 'all', 'and',
+                'architecture', 'array', 'assert', 'attribute', 'begin', 'block',
+                'body', 'buffer', 'bus', 'case', 'component', 'configuration',
+                'constant', 'disconnect', 'downto', 'else', 'elsif', 'end',
+                'entity', 'exit', 'file', 'for', 'function', 'generate',
+                'generic', 'group', 'guarded', 'if', 'impure', 'in',
+                'inertial', 'inout', 'is', 'label', 'library', 'linkage',
+                'literal', 'loop', 'map', 'mod', 'nand', 'new',
+                'next', 'nor', 'not', 'null', 'of', 'on',
+                'open', 'or', 'others', 'out', 'package', 'port',
+                'postponed', 'procedure', 'process', 'pure', 'range', 'record',
+                'register', 'reject', 'rem', 'return', 'rol', 'ror', 'select',
+                'severity', 'signal', 'shared', 'sla', 'sll', 'sra',
+                'srl', 'subtype', 'then', 'to', 'transport', 'type',
+                'units', 'until', 'use', 'variable', 'wait', 'when',
+                'while', 'with', 'xnor', 'xor'), suffix=r'\b'),
+             Keyword),
         ],
         'numbers': [
             (r'\d{1,2}#[0-9a-f_]+#?', Number.Integer),
             (r'\d+', Number.Integer),
-            (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+', Number.Float),
+            (r'(\d+\.\d*|\.\d+|\d+)E[+-]?\d+', Number.Float),
             (r'X"[0-9a-f_]+"', Number.Hex),
             (r'O"[0-7_]+"', Number.Oct),
-            (r'B"[0-1_]+"', Number.Bin),
+            (r'B"[01_]+"', Number.Bin),
         ],
     }

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

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.hexdump
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for hexadecimal dumps.
+
+    :copyright: Copyright 2006-2015 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
+
+__all__ = ['HexdumpLexer']
+
+
+class HexdumpLexer(RegexLexer):
+    """
+    For typical hex dump output formats by the UNIX and GNU/Linux tools ``hexdump``,
+    ``hd``, ``hexcat``, ``od`` and ``xxd``, and the DOS tool ``DEBUG``. For example:
+
+    .. sourcecode:: hexdump
+
+        00000000  7f 45 4c 46 02 01 01 00  00 00 00 00 00 00 00 00  |.ELF............|
+        00000010  02 00 3e 00 01 00 00 00  c5 48 40 00 00 00 00 00  |..>......H@.....|
+
+    The specific supported formats are the outputs of:
+
+    * ``hexdump FILE``
+    * ``hexdump -C FILE`` -- the `canonical` format used in the example.
+    * ``hd FILE`` -- same as ``hexdump -C FILE``.
+    * ``hexcat FILE``
+    * ``od -t x1z FILE``
+    * ``xxd FILE``
+    * ``DEBUG.EXE FILE.COM`` and entering ``d`` to the prompt.
+    
+    .. versionadded:: 2.1
+    """
+    name = 'Hexdump'
+    aliases = ['hexdump']
+
+    hd = r'[0-9A-Ha-h]'
+
+    tokens = {
+        'root': [
+            (r'\n', Text),
+            include('offset'),
+            (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})(.{1,15})$', bygroups(Text, String)),
+            (r'(\s{2,3})(.{16}|.{20})$', bygroups(Text, String), 'nonpiped-strings'),
+            (r'\s', Text),
+            (r'^\*', Punctuation),
+        ],
+        'offset': [
+            (r'^('+hd+'+)(:)', bygroups(Name.Label, Punctuation), 'offset-mode'),
+            (r'^'+hd+'+', Name.Label),
+        ],
+        'offset-mode': [
+            (r'\s', Text, '#pop'),
+            (hd+'+', Name.Label),
+            (r':', Punctuation)
+        ],
+        'piped-strings': [
+            (r'\n', Text),
+            include('offset'),
+            (hd+r'{2}', Number.Hex),
+            (r'(\s{2,3})(\|)(.{1,16})(\|)$', bygroups(Text, Punctuation, String, Punctuation)),
+            (r'\s', Text),
+            (r'^\*', Punctuation),
+        ],
+        'bracket-strings': [
+            (r'\n', Text),
+            include('offset'),
+            (hd+r'{2}', Number.Hex),
+            (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)),
+            (hd+r'{2}', Number.Hex),
+            (r'(\s{19,})(.{1,20}?)$', bygroups(Text, String)),
+            (r'(\s{2,3})(.{1,20})$', bygroups(Text, String)),
+            (r'\s', Text),
+            (r'^\*', Punctuation),
+        ],
+    }