pygments.rb 2.3.1 → 2.4.0

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

@@ -4,16 +4,16 @@
 
     Lexers for Haskell and related languages.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 import re
 
 from pygments.lexer import Lexer, RegexLexer, bygroups, do_insertions, \
-    default, include, inherit
+    default, include, inherit, line_re
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Generic
+    Number, Punctuation, Generic, Whitespace
 from pygments import unistring as uni
 
 __all__ = ['HaskellLexer', 'HspecLexer', 'IdrisLexer', 'AgdaLexer', 'CryptolLexer',
@@ -21,9 +21,6 @@ __all__ = ['HaskellLexer', 'HspecLexer', 'IdrisLexer', 'AgdaLexer', 'CryptolLexe
            'LiterateCryptolLexer', 'KokaLexer']
 
 
-line_re = re.compile('.*?\n')
-
-
 class HaskellLexer(RegexLexer):
     """
     A Haskell lexer based on the lexemes defined in the Haskell 98 Report.
@@ -31,12 +28,11 @@ class HaskellLexer(RegexLexer):
     .. versionadded:: 0.8
     """
     name = 'Haskell'
+    url = 'https://www.haskell.org/'
     aliases = ['haskell', 'hs']
     filenames = ['*.hs']
     mimetypes = ['text/x-haskell']
 
-    flags = re.MULTILINE | re.UNICODE
-
     reserved = ('case', 'class', 'data', 'default', 'deriving', 'do', 'else',
                 'family', 'if', 'in', 'infix[lr]?', 'instance',
                 'let', 'newtype', 'of', 'then', 'type', 'where', '_')
@@ -48,7 +44,7 @@ class HaskellLexer(RegexLexer):
     tokens = {
         'root': [
             # Whitespace:
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             # (r'--\s*|.*$', Comment.Doc),
             (r'--(?![!#$%&*+./<=>?@^|_~:\\]).*?$', Comment.Single),
             (r'\{-', Comment.Multiline, 'comment'),
@@ -91,31 +87,31 @@ class HaskellLexer(RegexLexer):
         ],
         'import': [
             # Import statements
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'"', String, 'string'),
             # after "funclist" state
             (r'\)', Punctuation, '#pop'),
             (r'qualified\b', Keyword),
             # import X as Y
             (r'([' + uni.Lu + r'][\w.]*)(\s+)(as)(\s+)([' + uni.Lu + r'][\w.]*)',
-             bygroups(Name.Namespace, Text, Keyword, Text, Name), '#pop'),
+             bygroups(Name.Namespace, Whitespace, Keyword, Whitespace, Name), '#pop'),
             # import X hiding (functions)
             (r'([' + uni.Lu + r'][\w.]*)(\s+)(hiding)(\s+)(\()',
-             bygroups(Name.Namespace, Text, Keyword, Text, Punctuation), 'funclist'),
+             bygroups(Name.Namespace, Whitespace, Keyword, Whitespace, Punctuation), 'funclist'),
             # import X (functions)
             (r'([' + uni.Lu + r'][\w.]*)(\s+)(\()',
-             bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
+             bygroups(Name.Namespace, Whitespace, Punctuation), 'funclist'),
             # import X
             (r'[\w.]+', Name.Namespace, '#pop'),
         ],
         'module': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'([' + uni.Lu + r'][\w.]*)(\s+)(\()',
-             bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
+             bygroups(Name.Namespace, Whitespace, Punctuation), 'funclist'),
             (r'[' + uni.Lu + r'][\w.]*', Name.Namespace, '#pop'),
         ],
         'funclist': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'[' + uni.Lu + r']\w*', Keyword.Type),
             (r'(_[\w\']+|[' + uni.Ll + r'][\w\']*)', Name.Function),
             (r'--(?![!#$%&*+./<=>?@^|_~:\\]).*?$', Comment.Single),
@@ -153,7 +149,7 @@ class HaskellLexer(RegexLexer):
             (r'o[0-7]+', String.Escape, '#pop'),
             (r'x[\da-fA-F]+', String.Escape, '#pop'),
             (r'\d+', String.Escape, '#pop'),
-            (r'\s+\\', String.Escape, '#pop'),
+            (r'(\s+)(\\)', bygroups(Whitespace, String.Escape), '#pop'),
         ],
     }
 
@@ -167,14 +163,14 @@ class HspecLexer(HaskellLexer):
 
     name = 'Hspec'
     aliases = ['hspec']
-    filenames = []
+    filenames = ['*Spec.hs']
     mimetypes = []
 
     tokens = {
         'root': [
-            (r'(it\s*)("[^"]*")', bygroups(Text, String.Doc)),
-            (r'(describe\s*)("[^"]*")', bygroups(Text, String.Doc)),
-            (r'(context\s*)("[^"]*")', bygroups(Text, String.Doc)),
+            (r'(it)(\s*)("[^"]*")', bygroups(Text, Whitespace, String.Doc)),
+            (r'(describe)(\s*)("[^"]*")', bygroups(Text, Whitespace, String.Doc)),
+            (r'(context)(\s*)("[^"]*")', bygroups(Text, Whitespace, String.Doc)),
             inherit,
         ],
     }
@@ -189,6 +185,7 @@ class IdrisLexer(RegexLexer):
     .. versionadded:: 2.0
     """
     name = 'Idris'
+    url = 'https://www.idris-lang.org/'
     aliases = ['idris', 'idr']
     filenames = ['*.idr']
     mimetypes = ['text/x-idris']
@@ -215,16 +212,16 @@ class IdrisLexer(RegexLexer):
         'root': [
             # Comments
             (r'^(\s*)(%%(%s))' % '|'.join(directives),
-             bygroups(Text, Keyword.Reserved)),
-            (r'(\s*)(--(?![!#$%&*+./<=>?@^|_~:\\]).*?)$', bygroups(Text, Comment.Single)),
-            (r'(\s*)(\|{3}.*?)$', bygroups(Text, Comment.Single)),
-            (r'(\s*)(\{-)', bygroups(Text, Comment.Multiline), 'comment'),
+             bygroups(Whitespace, Keyword.Reserved)),
+            (r'(\s*)(--(?![!#$%&*+./<=>?@^|_~:\\]).*?)$', bygroups(Whitespace, Comment.Single)),
+            (r'(\s*)(\|{3}.*?)$', bygroups(Whitespace, Comment.Single)),
+            (r'(\s*)(\{-)', bygroups(Whitespace, Comment.Multiline), 'comment'),
             # Declaration
             (r'^(\s*)([^\s(){}]+)(\s*)(:)(\s*)',
-             bygroups(Text, Name.Function, Text, Operator.Word, Text)),
+             bygroups(Whitespace, Name.Function, Whitespace, Operator.Word, Whitespace)),
             #  Identifiers
             (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
-            (r'(import|module)(\s+)', bygroups(Keyword.Reserved, Text), 'module'),
+            (r'(import|module)(\s+)', bygroups(Keyword.Reserved, Whitespace), 'module'),
             (r"('')?[A-Z][\w\']*", Keyword.Type),
             (r'[a-z][\w\']*', Text),
             #  Special Symbols
@@ -239,16 +236,16 @@ class IdrisLexer(RegexLexer):
             (r"'", String.Char, 'character'),
             (r'"', String, 'string'),
             (r'[^\s(){}]+', Text),
-            (r'\s+?', Text),  # Whitespace
+            (r'\s+?', Whitespace),  # Whitespace
         ],
         'module': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'([A-Z][\w.]*)(\s+)(\()',
-             bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
+             bygroups(Name.Namespace, Whitespace, Punctuation), 'funclist'),
             (r'[A-Z][\w.]*', Name.Namespace, '#pop'),
         ],
         'funclist': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'[A-Z]\w*', Keyword.Type),
             (r'(_[\w\']+|[a-z][\w\']*)', Name.Function),
             (r'--.*$', Comment.Single),
@@ -286,37 +283,41 @@ class IdrisLexer(RegexLexer):
             (r'o[0-7]+', String.Escape, '#pop'),
             (r'x[\da-fA-F]+', String.Escape, '#pop'),
             (r'\d+', String.Escape, '#pop'),
-            (r'\s+\\', String.Escape, '#pop')
+            (r'(\s+)(\\)', bygroups(Whitespace, String.Escape), '#pop')
         ],
     }
 
 
 class AgdaLexer(RegexLexer):
     """
-    For the `Agda <http://wiki.portal.chalmers.se/agda/pmwiki.php>`_
-    dependently typed functional programming language and proof assistant.
+    For the Agda dependently typed functional programming language and
+    proof assistant.
 
     .. versionadded:: 2.0
     """
 
     name = 'Agda'
+    url = 'http://wiki.portal.chalmers.se/agda/pmwiki.php'
     aliases = ['agda']
     filenames = ['*.agda']
     mimetypes = ['text/x-agda']
 
-    reserved = ['abstract', 'codata', 'coinductive', 'constructor', 'data',
-                'field', 'forall', 'hiding', 'in', 'inductive', 'infix',
-                'infixl', 'infixr', 'instance', 'let', 'mutual', 'open',
-                'pattern', 'postulate', 'primitive', 'private',
-                'quote', 'quoteGoal', 'quoteTerm',
-                'record', 'renaming', 'rewrite', 'syntax', 'tactic',
-                'unquote', 'unquoteDecl', 'using', 'where', 'with']
+    reserved = (
+        'abstract', 'codata', 'coinductive', 'constructor', 'data', 'do',
+        'eta-equality', 'field', 'forall', 'hiding', 'in', 'inductive', 'infix',
+        'infixl', 'infixr', 'instance', 'interleaved', 'let', 'macro', 'mutual',
+        'no-eta-equality', 'open', 'overlap', 'pattern', 'postulate', 'primitive',
+        'private', 'quote', 'quoteTerm', 'record', 'renaming', 'rewrite',
+        'syntax', 'tactic', 'unquote', 'unquoteDecl', 'unquoteDef', 'using',
+        'variable', 'where', 'with',
+    )
 
     tokens = {
         'root': [
             # Declaration
             (r'^(\s*)([^\s(){}]+)(\s*)(:)(\s*)',
-             bygroups(Text, Name.Function, Text, Operator.Word, Text)),
+             bygroups(Whitespace, Name.Function, Whitespace,
+                      Operator.Word, Whitespace)),
             # Comments
             (r'--(?![!#$%&*+./<=>?@^|_~:\\]).*?$', Comment.Single),
             (r'\{-', Comment.Multiline, 'comment'),
@@ -325,7 +326,8 @@ class AgdaLexer(RegexLexer):
             # Lexemes:
             #  Identifiers
             (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
-            (r'(import|module)(\s+)', bygroups(Keyword.Reserved, Text), 'module'),
+            (r'(import|module)(\s+)', bygroups(Keyword.Reserved, Whitespace),
+             'module'),
             (r'\b(Set|Prop)[\u2080-\u2089]*\b', Keyword.Type),
             #  Special Symbols
             (r'(\(|\)|\{|\})', Operator),
@@ -339,7 +341,7 @@ class AgdaLexer(RegexLexer):
             (r"'", String.Char, 'character'),
             (r'"', String, 'string'),
             (r'[^\s(){}]+', Text),
-            (r'\s+?', Text),  # Whitespace
+            (r'\s+?', Whitespace),  # Whitespace
         ],
         'hole': [
             # Holes
@@ -350,7 +352,7 @@ class AgdaLexer(RegexLexer):
         ],
         'module': [
             (r'\{-', Comment.Multiline, 'comment'),
-            (r'[a-zA-Z][\w.]*', Name, '#pop'),
+            (r'[a-zA-Z][\w.\']*', Name, '#pop'),
             (r'[\W0-9_]+', Text)
         ],
         'comment': HaskellLexer.tokens['comment'],
@@ -383,7 +385,7 @@ class CryptolLexer(RegexLexer):
     tokens = {
         'root': [
             # Whitespace:
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             # (r'--\s*|.*$', Comment.Doc),
             (r'//.*$', Comment.Single),
             (r'/\*', Comment.Multiline, 'comment'),
@@ -417,31 +419,31 @@ class CryptolLexer(RegexLexer):
         ],
         'import': [
             # Import statements
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'"', String, 'string'),
             # after "funclist" state
             (r'\)', Punctuation, '#pop'),
             (r'qualified\b', Keyword),
             # import X as Y
             (r'([A-Z][\w.]*)(\s+)(as)(\s+)([A-Z][\w.]*)',
-             bygroups(Name.Namespace, Text, Keyword, Text, Name), '#pop'),
+             bygroups(Name.Namespace, Whitespace, Keyword, Whitespace, Name), '#pop'),
             # import X hiding (functions)
             (r'([A-Z][\w.]*)(\s+)(hiding)(\s+)(\()',
-             bygroups(Name.Namespace, Text, Keyword, Text, Punctuation), 'funclist'),
+             bygroups(Name.Namespace, Whitespace, Keyword, Whitespace, Punctuation), 'funclist'),
             # import X (functions)
             (r'([A-Z][\w.]*)(\s+)(\()',
-             bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
+             bygroups(Name.Namespace, Whitespace, Punctuation), 'funclist'),
             # import X
             (r'[\w.]+', Name.Namespace, '#pop'),
         ],
         'module': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'([A-Z][\w.]*)(\s+)(\()',
-             bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
+             bygroups(Name.Namespace, Whitespace, Punctuation), 'funclist'),
             (r'[A-Z][\w.]*', Name.Namespace, '#pop'),
         ],
         'funclist': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'[A-Z]\w*', Keyword.Type),
             (r'(_[\w\']+|[a-z][\w\']*)', Name.Function),
             # TODO: these don't match the comments in docs, remove.
@@ -478,7 +480,7 @@ class CryptolLexer(RegexLexer):
             (r'o[0-7]+', String.Escape, '#pop'),
             (r'x[\da-fA-F]+', String.Escape, '#pop'),
             (r'\d+', String.Escape, '#pop'),
-            (r'\s+\\', String.Escape, '#pop'),
+            (r'(\s+)(\\)', bygroups(Whitespace, String.Escape), '#pop'),
         ],
     }
 
@@ -655,13 +657,13 @@ class LiterateCryptolLexer(LiterateLexer):
 
 class KokaLexer(RegexLexer):
     """
-    Lexer for the `Koka <http://koka.codeplex.com>`_
-    language.
+    Lexer for the Koka language.
 
     .. versionadded:: 1.6
     """
 
     name = 'Koka'
+    url = 'https://koka-lang.github.io/koka/doc/index.html'
     aliases = ['koka']
     filenames = ['*.kk', '*.kki']
     mimetypes = ['text/x-koka']
@@ -720,30 +722,30 @@ class KokaLexer(RegexLexer):
 
             # go into type mode
             (r'::?' + sboundary, tokenType, 'type'),
-            (r'(alias)(\s+)([a-z]\w*)?', bygroups(Keyword, Text, tokenTypeDef),
+            (r'(alias)(\s+)([a-z]\w*)?', bygroups(Keyword, Whitespace, tokenTypeDef),
              'alias-type'),
-            (r'(struct)(\s+)([a-z]\w*)?', bygroups(Keyword, Text, tokenTypeDef),
+            (r'(struct)(\s+)([a-z]\w*)?', bygroups(Keyword, Whitespace, tokenTypeDef),
              'struct-type'),
             ((r'(%s)' % '|'.join(typeStartKeywords)) +
-             r'(\s+)([a-z]\w*)?', bygroups(Keyword, Text, tokenTypeDef),
+             r'(\s+)([a-z]\w*)?', bygroups(Keyword, Whitespace, tokenTypeDef),
              'type'),
 
             # special sequences of tokens (we use ?: for non-capturing group as
             # required by 'bygroups')
-            (r'(module)(\s+)(interface\s+)?((?:[a-z]\w*/)*[a-z]\w*)',
-             bygroups(Keyword, Text, Keyword, Name.Namespace)),
+            (r'(module)(\s+)(interface(?=\s))?(\s+)?((?:[a-z]\w*/)*[a-z]\w*)',
+             bygroups(Keyword, Whitespace, Keyword, Whitespace, Name.Namespace)),
             (r'(import)(\s+)((?:[a-z]\w*/)*[a-z]\w*)'
-             r'(?:(\s*)(=)(\s*)((?:qualified\s*)?)'
+             r'(?:(\s*)(=)(\s*)(qualified)?(\s*)'
              r'((?:[a-z]\w*/)*[a-z]\w*))?',
-             bygroups(Keyword, Text, Name.Namespace, Text, Keyword, Text,
-                      Keyword, Name.Namespace)),
+             bygroups(Keyword, Whitespace, Name.Namespace, Whitespace, Keyword, Whitespace,
+                      Keyword, Whitespace, Name.Namespace)),
 
-            (r'(^(?:(?:public|private)\s*)?(?:function|fun|val))'
+            (r'^(public|private)?(\s+)?(function|fun|val)'
              r'(\s+)([a-z]\w*|\((?:' + symbols + r'|/)\))',
-             bygroups(Keyword, Text, Name.Function)),
-            (r'(^(?:(?:public|private)\s*)?external)(\s+)(inline\s+)?'
+             bygroups(Keyword, Whitespace, Keyword, Whitespace, Name.Function)),
+            (r'^(?:(public|private)(?=\s+external))?((?<!^)\s+)?(external)(\s+)(inline(?=\s))?(\s+)?'
              r'([a-z]\w*|\((?:' + symbols + r'|/)\))',
-             bygroups(Keyword, Text, Keyword, Name.Function)),
+             bygroups(Keyword, Whitespace, Keyword, Whitespace, Keyword, Whitespace, Name.Function)),
 
             # keywords
             (r'(%s)' % '|'.join(typekeywords) + boundary, Keyword.Type),
@@ -800,7 +802,7 @@ class KokaLexer(RegexLexer):
             (r'[(\[<]', tokenType, 'type-nested'),
             (r',', tokenType),
             (r'([a-z]\w*)(\s*)(:)(?!:)',
-             bygroups(Name, Text, tokenType)),  # parameter name
+             bygroups(Name, Whitespace, tokenType)),  # parameter name
             include('type-content')
         ],
 
@@ -833,8 +835,8 @@ class KokaLexer(RegexLexer):
 
         # comments and literals
         'whitespace': [
-            (r'\n\s*#.*$', Comment.Preproc),
-            (r'\s+', Text),
+            (r'(\n\s*)(#.*)$', bygroups(Whitespace, Comment.Preproc)),
+            (r'\s+', Whitespace),
             (r'/\*', Comment.Multiline, 'comment'),
             (r'//.*$', Comment.Single)
         ],

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

@@ -4,7 +4,7 @@
 
     Lexers for Haxe and related stuff.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -20,12 +20,13 @@ __all__ = ['HaxeLexer', 'HxmlLexer']
 
 class HaxeLexer(ExtendedRegexLexer):
     """
-    For Haxe source code (http://haxe.org/).
+    For Haxe source code.
 
     .. versionadded:: 1.3
     """
 
     name = 'Haxe'
+    url = 'http://haxe.org/'
     aliases = ['haxe', 'hxsl', 'hx']
     filenames = ['*.hx', '*.hxsl']
     mimetypes = ['text/haxe', 'text/x-haxe', 'text/x-hx']
@@ -103,7 +104,7 @@ class HaxeLexer(ExtendedRegexLexer):
 
         # space/tab/comment/preproc
         'spaces': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'//[^\n\r]*', Comment.Single),
             (r'/\*.*?\*/', Comment.Multiline),
             (r'(#)(if|elseif|else|end|error)\b', preproc_callback),
@@ -163,14 +164,14 @@ class HaxeLexer(ExtendedRegexLexer):
         ],
 
         'preproc-error': [
-            (r'\s+', Comment.Preproc),
+            (r'\s+', Whitespace),
             (r"'", String.Single, ('#pop', 'string-single')),
             (r'"', String.Double, ('#pop', 'string-double')),
             default('#pop'),
         ],
 
         'preproc-expr': [
-            (r'\s+', Comment.Preproc),
+            (r'\s+', Whitespace),
             (r'\!', Comment.Preproc),
             (r'\(', Comment.Preproc, ('#pop', 'preproc-parenthesis')),
 
@@ -193,20 +194,20 @@ class HaxeLexer(ExtendedRegexLexer):
         ],
 
         'preproc-parenthesis': [
-            (r'\s+', Comment.Preproc),
+            (r'\s+', Whitespace),
             (r'\)', Comment.Preproc, '#pop'),
             default('preproc-expr-in-parenthesis'),
         ],
 
         'preproc-expr-chain': [
-            (r'\s+', Comment.Preproc),
+            (r'\s+', Whitespace),
             (binop, Comment.Preproc, ('#pop', 'preproc-expr-in-parenthesis')),
             default('#pop'),
         ],
 
         # same as 'preproc-expr' but able to chain 'preproc-expr-chain'
         'preproc-expr-in-parenthesis': [
-            (r'\s+', Comment.Preproc),
+            (r'\s+', Whitespace),
             (r'\!', Comment.Preproc),
             (r'\(', Comment.Preproc,
              ('#pop', 'preproc-expr-chain', 'preproc-parenthesis')),
@@ -896,17 +897,18 @@ class HaxeLexer(ExtendedRegexLexer):
 
 class HxmlLexer(RegexLexer):
     """
-    Lexer for `haXe build <http://haxe.org/doc/compiler>`_ files.
+    Lexer for haXe build files.
 
     .. versionadded:: 1.6
     """
     name = 'Hxml'
+    url = 'https://haxe.org/manual/compiler-usage-hxml.html'
     aliases = ['haxeml', 'hxml']
     filenames = ['*.hxml']
 
     tokens = {
         'root': [
-            # Seperator
+            # Separator
             (r'(--)(next)', bygroups(Punctuation, Generic.Heading)),
             # Compiler switches with one dash
             (r'(-)(prompt|debug|v)', bygroups(Punctuation, Keyword.Keyword)),
@@ -919,7 +921,7 @@ class HxmlLexer(RegexLexer):
              bygroups(Punctuation, Keyword, Whitespace, String)),
             # Options that take only numerical arguments
             (r'(-)(swf-version)( +)(\d+)',
-             bygroups(Punctuation, Keyword, Number.Integer)),
+             bygroups(Punctuation, Keyword, Whitespace, Number.Integer)),
             # An Option that defines the size, the fps and the background
             # color of an flash movie
             (r'(-)(swf-header)( +)(\d+)(:)(\d+)(:)(\d+)(:)([A-Fa-f0-9]{6})',

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

@@ -4,7 +4,7 @@
 
     Lexers for hardware descriptor languages.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -12,7 +12,7 @@ import re
 
 from pygments.lexer import RegexLexer, bygroups, include, using, this, words
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+    Number, Punctuation, Whitespace
 
 __all__ = ['VerilogLexer', 'SystemVerilogLexer', 'VhdlLexer']
 
@@ -34,9 +34,8 @@ class VerilogLexer(RegexLexer):
     tokens = {
         'root': [
             (r'^\s*`define', Comment.Preproc, 'macro'),
-            (r'\n', Text),
-            (r'\s+', Text),
-            (r'\\\n', Text),  # line continuation
+            (r'\s+', Whitespace),
+            (r'(\\)(\n)', bygroups(String.Escape, Whitespace)),  # line continuation
             (r'/(\\\n)?/(\n|(.|\n)*?[^\\]\n)', Comment.Single),
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
             (r'[{}#@]', Punctuation),
@@ -54,8 +53,8 @@ class VerilogLexer(RegexLexer):
             (r'[()\[\],.;\']', Punctuation),
             (r'`[a-zA-Z_]\w*', Name.Constant),
 
-            (r'^(\s*)(package)(\s+)', bygroups(Text, Keyword.Namespace, Text)),
-            (r'^(\s*)(import)(\s+)', bygroups(Text, Keyword.Namespace, Text),
+            (r'^(\s*)(package)(\s+)', bygroups(Whitespace, Keyword.Namespace, Text)),
+            (r'^(\s*)(import)(\s+)', bygroups(Whitespace, Keyword.Namespace, Text),
              'import'),
 
             (words((
@@ -114,7 +113,7 @@ class VerilogLexer(RegexLexer):
             (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'(\\)(\n)', bygroups(String.Escape, Whitespace)),  # line continuation
             (r'\\', String),  # stray backslash
         ],
         'macro': [
@@ -123,7 +122,7 @@ class VerilogLexer(RegexLexer):
             (r'//.*?\n', Comment.Single, '#pop'),
             (r'/', Comment.Preproc),
             (r'(?<=\\)\n', Comment.Preproc),
-            (r'\n', Comment.Preproc, '#pop'),
+            (r'\n', Whitespace, '#pop'),
         ],
         'import': [
             (r'[\w:]+\*?', Name.Namespace, '#pop')
@@ -161,13 +160,12 @@ class SystemVerilogLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'^\s*`define', Comment.Preproc, 'macro'),
-            (r'^(\s*)(package)(\s+)', bygroups(Text, Keyword.Namespace, Text)),
-            (r'^(\s*)(import)(\s+)', bygroups(Text, Keyword.Namespace, Text), 'import'),
+            (r'^(\s*)(`define)', bygroups(Whitespace, Comment.Preproc), 'macro'),
+            (r'^(\s*)(package)(\s+)', bygroups(Whitespace, Keyword.Namespace, Whitespace)),
+            (r'^(\s*)(import)(\s+)', bygroups(Whitespace, Keyword.Namespace, Whitespace), 'import'),
 
-            (r'\n', Text),
-            (r'\s+', Text),
-            (r'\\\n', Text),  # line continuation
+            (r'\s+', Whitespace),
+            (r'(\\)(\n)', bygroups(String.Escape, Whitespace)),  # line continuation
             (r'/(\\\n)?/(\n|(.|\n)*?[^\\]\n)', Comment.Single),
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
             (r'[{}#@]', Punctuation),
@@ -240,11 +238,11 @@ class SystemVerilogLexer(RegexLexer):
              Keyword),
 
             (r'(class)(\s+)([a-zA-Z_]\w*)',
-             bygroups(Keyword.Declaration, Text, Name.Class)),
+             bygroups(Keyword.Declaration, Whitespace, Name.Class)),
             (r'(extends)(\s+)([a-zA-Z_]\w*)',
-             bygroups(Keyword.Declaration, Text, Name.Class)),
+             bygroups(Keyword.Declaration, Whitespace, Name.Class)),
             (r'(endclass\b)(?:(\s*)(:)(\s*)([a-zA-Z_]\w*))?',
-             bygroups(Keyword.Declaration, Text, Punctuation, Text, Name.Class)),
+             bygroups(Keyword.Declaration, Whitespace, Punctuation, Whitespace, Name.Class)),
 
             (words((
                 # Variable types
@@ -355,16 +353,16 @@ class SystemVerilogLexer(RegexLexer):
             (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'(\\)(\n)', bygroups(String.Escape, Whitespace)),  # line continuation
             (r'\\', String),  # stray backslash
         ],
         'macro': [
             (r'[^/\n]+', Comment.Preproc),
             (r'/[*](.|\n)*?[*]/', Comment.Multiline),
-            (r'//.*?\n', Comment.Single, '#pop'),
+            (r'//.*?$', Comment.Single, '#pop'),
             (r'/', Comment.Preproc),
             (r'(?<=\\)\n', Comment.Preproc),
-            (r'\n', Comment.Preproc, '#pop'),
+            (r'\n', Whitespace, '#pop'),
         ],
         'import': [
             (r'[\w:]+\*?', Name.Namespace, '#pop')
@@ -386,9 +384,8 @@ class VhdlLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'\n', Text),
-            (r'\s+', Text),
-            (r'\\\n', Text),  # line continuation
+            (r'\s+', Whitespace),
+            (r'(\\)(\n)', bygroups(String.Escape, Whitespace)),  # line continuation
             (r'--.*?$', Comment.Single),
             (r"'(U|X|0|1|Z|W|L|H|-)'", String.Char),
             (r'[~!%^&*+=|?:<>/-]', Operator),
@@ -397,25 +394,25 @@ class VhdlLexer(RegexLexer):
             (r'"[^\n\\"]*"', String),
 
             (r'(library)(\s+)([a-z_]\w*)',
-             bygroups(Keyword, Text, Name.Namespace)),
-            (r'(use)(\s+)(entity)', bygroups(Keyword, Text, Keyword)),
+             bygroups(Keyword, Whitespace, Name.Namespace)),
+            (r'(use)(\s+)(entity)', bygroups(Keyword, Whitespace, Keyword)),
             (r'(use)(\s+)([a-z_][\w.]*\.)(all)',
-             bygroups(Keyword, Text, Name.Namespace, Keyword)),
+             bygroups(Keyword, Whitespace, Name.Namespace, Keyword)),
             (r'(use)(\s+)([a-z_][\w.]*)',
-             bygroups(Keyword, Text, Name.Namespace)),
+             bygroups(Keyword, Whitespace, 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)),
+             bygroups(Keyword, Whitespace, 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)),
+             bygroups(Keyword, Whitespace, Name.Class, Whitespace, Keyword, Whitespace,
+                      Name.Class, Whitespace, Keyword)),
             (r'([a-z_]\w*)(:)(\s+)(process|for)',
-             bygroups(Name.Class, Operator, Text, Keyword)),
-            (r'(end)(\s+)', bygroups(using(this), Text), 'endblock'),
+             bygroups(Name.Class, Operator, Whitespace, Keyword)),
+            (r'(end)(\s+)', bygroups(using(this), Whitespace), 'endblock'),
 
             include('types'),
             include('keywords'),
@@ -426,7 +423,7 @@ class VhdlLexer(RegexLexer):
         'endblock': [
             include('keywords'),
             (r'[a-z_]\w*', Name.Class),
-            (r'(\s+)', Text),
+            (r'\s+', Whitespace),
             (r';', Punctuation, '#pop'),
         ],
         'types': [