pygments.rb 2.3.1 → 2.4.0

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

@@ -4,7 +4,7 @@
 
     Lexers for assembly 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.
 """
 
@@ -15,7 +15,7 @@ from pygments.lexer import RegexLexer, include, bygroups, using, words, \
 from pygments.lexers.c_cpp import CppLexer, CLexer
 from pygments.lexers.d import DLexer
 from pygments.token import Text, Name, Number, String, Comment, Punctuation, \
-    Other, Keyword, Operator, Literal
+    Other, Keyword, Operator, Whitespace
 
 __all__ = ['GasLexer', 'ObjdumpLexer', 'DObjdumpLexer', 'CppObjdumpLexer',
            'CObjdumpLexer', 'HsailLexer', 'LlvmLexer', 'LlvmMirBodyLexer',
@@ -37,7 +37,7 @@ class GasLexer(RegexLexer):
     char = r'[\w$.@-]'
     identifier = r'(?:[a-zA-Z$_]' + char + r'*|\.' + char + '+)'
     number = r'(?:0[xX][a-fA-F0-9]+|#?-?\d+)'
-    register = '%' + identifier
+    register = '%' + identifier + r'\b'
 
     tokens = {
         'root': [
@@ -54,7 +54,7 @@ class GasLexer(RegexLexer):
             ('@' + identifier, Name.Attribute),
             (number, Number.Integer),
             (register, Name.Variable),
-            (r'[\r\n]+', Text, '#pop'),
+            (r'[\r\n]+', Whitespace, '#pop'),
             (r'([;#]|//).*?\n', Comment.Single, '#pop'),
             (r'/[*].*?[*]/', Comment.Multiline),
             (r'/[*].*?\n[\w\W]*?[*]/', Comment.Multiline, '#pop'),
@@ -80,7 +80,7 @@ class GasLexer(RegexLexer):
             # Numeric constants
             ('$'+number, Number.Integer),
             (r"$'(.|\\')'", String.Char),
-            (r'[\r\n]+', Text, '#pop'),
+            (r'[\r\n]+', Whitespace, '#pop'),
             (r'([;#]|//).*?\n', Comment.Single, '#pop'),
             (r'/[*].*?[*]/', Comment.Multiline),
             (r'/[*].*?\n[\w\W]*?[*]/', Comment.Multiline, '#pop'),
@@ -89,13 +89,13 @@ class GasLexer(RegexLexer):
             include('whitespace')
         ],
         'whitespace': [
-            (r'\n', Text),
-            (r'\s+', Text),
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
             (r'([;#]|//).*?\n', Comment.Single),
             (r'/[*][\w\W]*?[*]/', Comment.Multiline)
         ],
         'punctuation': [
-            (r'[-*,.()\[\]!:]+', Punctuation)
+            (r'[-*,.()\[\]!:{}]+', Punctuation)
         ]
     }
 
@@ -122,33 +122,37 @@ def _objdump_lexer_tokens(asm_lexer):
             # Function labels
             # (With offset)
             ('('+hex_re+'+)( )(<)(.*?)([-+])(0[xX][A-Za-z0-9]+)(>:)$',
-                bygroups(Number.Hex, Text, Punctuation, Name.Function,
+                bygroups(Number.Hex, Whitespace, Punctuation, Name.Function,
                          Punctuation, Number.Hex, Punctuation)),
             # (Without offset)
             ('('+hex_re+'+)( )(<)(.*?)(>:)$',
-                bygroups(Number.Hex, Text, Punctuation, Name.Function,
+                bygroups(Number.Hex, Whitespace, Punctuation, Name.Function,
                          Punctuation)),
             # Code line with disassembled instructions
             ('( *)('+hex_re+r'+:)(\t)((?:'+hex_re+hex_re+' )+)( *\t)([a-zA-Z].*?)$',
-                bygroups(Text, Name.Label, Text, Number.Hex, Text,
+                bygroups(Whitespace, Name.Label, Whitespace, Number.Hex, Whitespace,
+                         using(asm_lexer))),
+            # Code line without raw instructions (objdump --no-show-raw-insn)
+            ('( *)('+hex_re+r'+:)( *\t)([a-zA-Z].*?)$',
+                bygroups(Whitespace, Name.Label, Whitespace,
                          using(asm_lexer))),
             # Code line with ascii
             ('( *)('+hex_re+r'+:)(\t)((?:'+hex_re+hex_re+' )+)( *)(.*?)$',
-                bygroups(Text, Name.Label, Text, Number.Hex, Text, String)),
+                bygroups(Whitespace, Name.Label, Whitespace, Number.Hex, Whitespace, String)),
             # Continued code line, only raw opcodes without disassembled
             # instruction
             ('( *)('+hex_re+r'+:)(\t)((?:'+hex_re+hex_re+' )+)$',
-                bygroups(Text, Name.Label, Text, Number.Hex)),
+                bygroups(Whitespace, Name.Label, Whitespace, Number.Hex)),
             # Skipped a few bytes
             (r'\t\.\.\.$', Text),
             # Relocation line
             # (With offset)
             (r'(\t\t\t)('+hex_re+r'+:)( )([^\t]+)(\t)(.*?)([-+])(0x'+hex_re+'+)$',
-                bygroups(Text, Name.Label, Text, Name.Property, Text,
+                bygroups(Whitespace, Name.Label, Whitespace, Name.Property, Whitespace,
                          Name.Constant, Punctuation, Number.Hex)),
             # (Without offset)
             (r'(\t\t\t)('+hex_re+r'+:)( )([^\t]+)(\t)(.*?)$',
-                bygroups(Text, Name.Label, Text, Name.Property, Text,
+                bygroups(Whitespace, Name.Label, Whitespace, Name.Property, Whitespace,
                          Name.Constant)),
             (r'[^\n]+\n', Other)
         ]
@@ -221,7 +225,7 @@ class HsailLexer(RegexLexer):
     identifier = r'[a-zA-Z_][\w.]*'
     # Registers
     register_number = r'[0-9]+'
-    register = r'(\$(c|s|d|q)' + register_number + ')'
+    register = r'(\$(c|s|d|q)' + register_number + r')\b'
     # Qualifiers
     alignQual = r'(align\(\d+\))'
     widthQual = r'(width\((\d+|all)\))'
@@ -270,7 +274,7 @@ class HsailLexer(RegexLexer):
             (r'[=<>{}\[\]()*.,:;!]|x\b', Punctuation)
         ],
         'whitespace': [
-            (r'(\n|\s)+', Text),
+            (r'(\n|\s)+', Whitespace),
         ],
         'comments': [
             (r'/\*.*?\*/', Comment.Multiline),
@@ -346,6 +350,7 @@ class LlvmLexer(RegexLexer):
     For LLVM assembly code.
     """
     name = 'LLVM'
+    url = 'https://llvm.org/docs/LangRef.html'
     aliases = ['llvm']
     filenames = ['*.ll']
     mimetypes = ['text/x-llvm']
@@ -379,7 +384,7 @@ class LlvmLexer(RegexLexer):
             (r'[=<>{}\[\]()*.,!]|x\b', Punctuation)
         ],
         'whitespace': [
-            (r'(\n|\s)+', Text),
+            (r'(\n|\s+)+', Whitespace),
             (r';.*?\n', Comment)
         ],
         'keyword': [
@@ -473,7 +478,7 @@ class LlvmLexer(RegexLexer):
             # Types
             (words(('void', 'half', 'bfloat', 'float', 'double', 'fp128',
                     'x86_fp80', 'ppc_fp128', 'label', 'metadata', 'x86_mmx',
-                    'x86_amx', 'token')),
+                    'x86_amx', 'token', 'ptr')),
                    Keyword.Type),
 
             # Integer types
@@ -486,11 +491,10 @@ class LlvmMirBodyLexer(RegexLexer):
     """
     For LLVM MIR examples without the YAML wrapper.
 
-    For more information on LLVM MIR see https://llvm.org/docs/MIRLangRef.html.
-
     .. versionadded:: 2.6
     """
     name = 'LLVM-MIR Body'
+    url = 'https://llvm.org/docs/MIRLangRef.html'
     aliases = ['llvm-mir-body']
     filenames = []
     mimetypes = []
@@ -555,13 +559,13 @@ class LlvmMirBodyLexer(RegexLexer):
             # Flags
             (words(('killed', 'implicit')), Keyword),
             # ConstantInt values
-            (r'i[0-9]+ +', Keyword.Type, 'constantint'),
+            (r'(i[0-9]+)( +)', bygroups(Keyword.Type, Whitespace), 'constantint'),
             # ConstantFloat values
             (r'(half|float|double) +', Keyword.Type, 'constantfloat'),
             # Bare immediates
             include('integer'),
             # MMO's
-            (r':: *', Operator, 'mmo'),
+            (r'(::)( *)', bygroups(Operator, Whitespace), 'mmo'),
             # MIR Comments
             (r';.*', Comment),
             # If we get here, assume it's a target instruction
@@ -581,29 +585,29 @@ class LlvmMirBodyLexer(RegexLexer):
         ],
         'vreg': [
             # The bank or class if there is one
-            (r' *:(?!:)', Keyword, ('#pop', 'vreg_bank_or_class')),
+            (r'( *)(:(?!:))', bygroups(Whitespace, Keyword), ('#pop', 'vreg_bank_or_class')),
             # The LLT if there is one
-            (r' *\(', Text, 'vreg_type'),
+            (r'( *)(\()', bygroups(Whitespace, Text), 'vreg_type'),
             (r'(?=.)', Text, '#pop'),
         ],
         'vreg_bank_or_class': [
             # The unassigned bank/class
-            (r' *_', Name.Variable.Magic),
-            (r' *[a-zA-Z0-9_]+', Name.Variable),
+            (r'( *)(_)', bygroups(Whitespace, Name.Variable.Magic)),
+            (r'( *)([a-zA-Z0-9_]+)', bygroups(Whitespace, Name.Variable)),
             # The LLT if there is one
-            (r' *\(', Text, 'vreg_type'),
+            (r'( *)(\()', bygroups(Whitespace, Text), 'vreg_type'),
             (r'(?=.)', Text, '#pop'),
         ],
         'vreg_type': [
             # Scalar and pointer types
-            (r' *[sp][0-9]+', Keyword.Type),
-            (r' *<[0-9]+ *x *[sp][0-9]+>', Keyword.Type),
+            (r'( *)([sp][0-9]+)', bygroups(Whitespace, Keyword.Type)),
+            (r'( *)(<[0-9]+ *x *[sp][0-9]+>)', bygroups(Whitespace, Keyword.Type)),
             (r'\)', Text, '#pop'),
             (r'(?=.)', Text, '#pop'),
         ],
         'mmo': [
             (r'\(', Text),
-            (r' +', Text),
+            (r' +', Whitespace),
             (words(('load', 'store', 'on', 'into', 'from', 'align', 'monotonic',
                     'acquire', 'release', 'acq_rel', 'seq_cst')),
              Keyword),
@@ -632,11 +636,10 @@ class LlvmMirLexer(RegexLexer):
     see the state of the compilation process at various points, as well as test
     individual pieces of the compiler.
 
-    For more information on LLVM MIR see https://llvm.org/docs/MIRLangRef.html.
-
     .. versionadded:: 2.6
     """
     name = 'LLVM-MIR'
+    url = 'https://llvm.org/docs/MIRLangRef.html'
     aliases = ['llvm-mir']
     filenames = ['*.mir']
 
@@ -677,7 +680,7 @@ class LlvmMirLexer(RegexLexer):
             (r'body: *\|', Keyword, 'llvm_mir_body'),
             # Consume everything else
             (r'.+', Text),
-            (r'\n', Text),
+            (r'\n', Whitespace),
         ],
         'name': [
             (r'[^\n]+', Name),
@@ -710,7 +713,7 @@ class NasmLexer(RegexLexer):
     """
     name = 'NASM'
     aliases = ['nasm']
-    filenames = ['*.asm', '*.ASM']
+    filenames = ['*.asm', '*.ASM', '*.nasm']
     mimetypes = ['text/x-nasm']
 
     # Tasm uses the same file endings, but TASM is not as common as NASM, so
@@ -725,16 +728,17 @@ class NasmLexer(RegexLexer):
     floatn = decn + r'\.e?' + decn
     string = r'"(\\"|[^"\n])*"|' + r"'(\\'|[^'\n])*'|" + r"`(\\`|[^`\n])*`"
     declkw = r'(?:res|d)[bwdqt]|times'
-    register = (r'r[0-9][0-5]?[bwd]?|'
+    register = (r'(r[0-9][0-5]?[bwd]?|'
                 r'[a-d][lh]|[er]?[a-d]x|[er]?[sb]p|[er]?[sd]i|[c-gs]s|st[0-7]|'
-                r'mm[0-7]|cr[0-4]|dr[0-367]|tr[3-7]')
-    wordop = r'seg|wrt|strict'
+                r'mm[0-7]|cr[0-4]|dr[0-367]|tr[3-7]|k[0-7]|'
+                r'[xyz]mm(?:[12][0-9]?|3[01]?|[04-9]))\b')
+    wordop = r'seg|wrt|strict|rel|abs'
     type = r'byte|[dq]?word'
     # Directives must be followed by whitespace, otherwise CPU will match
     # cpuid for instance.
     directives = (r'(?:BITS|USE16|USE32|SECTION|SEGMENT|ABSOLUTE|EXTERN|GLOBAL|'
                   r'ORG|ALIGN|STRUC|ENDSTRUC|COMMON|CPU|GROUP|UPPERCASE|IMPORT|'
-                  r'EXPORT|LIBRARY|MODULE)\s+')
+                  r'EXPORT|LIBRARY|MODULE)(?=\s)')
 
     flags = re.IGNORECASE | re.MULTILINE
     tokens = {
@@ -743,12 +747,12 @@ class NasmLexer(RegexLexer):
             include('whitespace'),
             (identifier + ':', Name.Label),
             (r'(%s)(\s+)(equ)' % identifier,
-                bygroups(Name.Constant, Keyword.Declaration, Keyword.Declaration),
+                bygroups(Name.Constant, Whitespace, Keyword.Declaration),
                 'instruction-args'),
             (directives, Keyword, 'instruction-args'),
             (declkw, Keyword.Declaration, 'instruction-args'),
             (identifier, Name.Function, 'instruction-args'),
-            (r'[\r\n]+', Text)
+            (r'[\r\n]+', Whitespace)
         ],
         'instruction-args': [
             (string, String),
@@ -760,7 +764,7 @@ class NasmLexer(RegexLexer):
             include('punctuation'),
             (register, Name.Builtin),
             (identifier, Name.Variable),
-            (r'[\r\n]+', Text, '#pop'),
+            (r'[\r\n]+', Whitespace, '#pop'),
             include('whitespace')
         ],
         'preproc': [
@@ -769,12 +773,13 @@ class NasmLexer(RegexLexer):
             (r'\n', Comment.Preproc, '#pop'),
         ],
         'whitespace': [
-            (r'\n', Text),
-            (r'[ \t]+', Text),
-            (r';.*', Comment.Single)
+            (r'\n', Whitespace),
+            (r'[ \t]+', Whitespace),
+            (r';.*', Comment.Single),
+            (r'#.*', Comment.Single)
         ],
         'punctuation': [
-            (r'[,():\[\]]+', Punctuation),
+            (r'[,{}():\[\]]+', Punctuation),
             (r'[&|^<>+*/%~-]+', Operator),
             (r'[$]+', Keyword.Constant),
             (wordop, Operator.Word),
@@ -819,9 +824,9 @@ class TasmLexer(RegexLexer):
     floatn = decn + r'\.e?' + decn
     string = r'"(\\"|[^"\n])*"|' + r"'(\\'|[^'\n])*'|" + r"`(\\`|[^`\n])*`"
     declkw = r'(?:res|d)[bwdqt]|times'
-    register = (r'r[0-9][0-5]?[bwd]|'
+    register = (r'(r[0-9][0-5]?[bwd]|'
                 r'[a-d][lh]|[er]?[a-d]x|[er]?[sb]p|[er]?[sd]i|[c-gs]s|st[0-7]|'
-                r'mm[0-7]|cr[0-4]|dr[0-367]|tr[3-7]')
+                r'mm[0-7]|cr[0-4]|dr[0-367]|tr[3-7])\b')
     wordop = r'seg|wrt|strict'
     type = r'byte|[dq]?word'
     directives = (r'BITS|USE16|USE32|SECTION|SEGMENT|ABSOLUTE|EXTERN|GLOBAL|'
@@ -840,11 +845,11 @@ class TasmLexer(RegexLexer):
             (identifier + ':', Name.Label),
             (directives, Keyword, 'instruction-args'),
             (r'(%s)(\s+)(%s)' % (identifier, datatype),
-                bygroups(Name.Constant, Keyword.Declaration, Keyword.Declaration),
+                bygroups(Name.Constant, Whitespace, Keyword.Declaration),
                 'instruction-args'),
             (declkw, Keyword.Declaration, 'instruction-args'),
             (identifier, Name.Function, 'instruction-args'),
-            (r'[\r\n]+', Text)
+            (r'[\r\n]+', Whitespace)
         ],
         'instruction-args': [
             (string, String),
@@ -856,9 +861,10 @@ class TasmLexer(RegexLexer):
             include('punctuation'),
             (register, Name.Builtin),
             (identifier, Name.Variable),
-            # Do not match newline when it's preceeded by a backslash
-            (r'(\\\s*)(;.*)([\r\n])', bygroups(Text, Comment.Single, Text)),
-            (r'[\r\n]+', Text, '#pop'),
+            # Do not match newline when it's preceded by a backslash
+            (r'(\\)(\s*)(;.*)([\r\n])',
+             bygroups(Text, Whitespace, Comment.Single, Whitespace)),
+            (r'[\r\n]+', Whitespace, '#pop'),
             include('whitespace')
         ],
         'preproc': [
@@ -867,9 +873,9 @@ class TasmLexer(RegexLexer):
             (r'\n', Comment.Preproc, '#pop'),
         ],
         'whitespace': [
-            (r'[\n\r]', Text),
-            (r'\\[\n\r]', Text),
-            (r'[ \t]+', Text),
+            (r'[\n\r]', Whitespace),
+            (r'(\\)([\n\r])', bygroups(Text, Whitespace)),
+            (r'[ \t]+', Whitespace),
             (r';.*', Comment.Single)
         ],
         'punctuation': [
@@ -902,7 +908,7 @@ class Ca65Lexer(RegexLexer):
     tokens = {
         'root': [
             (r';.*', Comment.Single),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'[a-z_.@$][\w.@$]*:', Name.Label),
             (r'((ld|st)[axy]|(in|de)[cxy]|asl|lsr|ro[lr]|adc|sbc|cmp|cp[xy]'
              r'|cl[cvdi]|se[cdi]|jmp|jsr|bne|beq|bpl|bmi|bvc|bvs|bcc|bcs'
@@ -930,11 +936,10 @@ class Dasm16Lexer(RegexLexer):
     """
     For DCPU-16 Assembly.
 
-    Check http://0x10c.com/doc/dcpu-16.txt
-
     .. versionadded:: 2.4
     """
     name = 'DASM16'
+    url = 'http://0x10c.com/doc/dcpu-16.txt'
     aliases = ['dasm16']
     filenames = ['*.dasm16', '*.dasm']
     mimetypes = ['text/x-dasm16']
@@ -983,7 +988,7 @@ class Dasm16Lexer(RegexLexer):
             (identifier + ':', Name.Label),
             (instruction, Name.Function, 'instruction-args'),
             (r'\.' + identifier, Name.Function, 'data-args'),
-            (r'[\r\n]+', Text)
+            (r'[\r\n]+', Whitespace)
         ],
 
         'numeric' : [
@@ -1005,7 +1010,7 @@ class Dasm16Lexer(RegexLexer):
         ],
 
         'instruction-line' : [
-            (r'[\r\n]+', Text, '#pop'),
+            (r'[\r\n]+', Whitespace, '#pop'),
             (r';.*?$', Comment, '#pop'),
             include('whitespace')
         ],
@@ -1025,8 +1030,8 @@ class Dasm16Lexer(RegexLexer):
         ],
 
         'whitespace': [
-            (r'\n', Text),
-            (r'\s+', Text),
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
             (r';.*?\n', Comment)
         ],
     }

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

@@ -4,7 +4,7 @@
 
     Lexers for automation scripting 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.
 """
 
@@ -17,11 +17,12 @@ __all__ = ['AutohotkeyLexer', 'AutoItLexer']
 
 class AutohotkeyLexer(RegexLexer):
     """
-    For `autohotkey <http://www.autohotkey.com/>`_ source code.
+    For autohotkey source code.
 
     .. versionadded:: 1.4
     """
     name = 'autohotkey'
+    url = 'http://www.autohotkey.com/'
     aliases = ['autohotkey', 'ahk']
     filenames = ['*.ahk', '*.ahkl']
     mimetypes = ['text/x-autohotkey']
@@ -49,8 +50,8 @@ class AutohotkeyLexer(RegexLexer):
         ],
         'incomment': [
             (r'^\s*\*/', Comment.Multiline, '#pop'),
-            (r'[^*/]', Comment.Multiline),
-            (r'[*/]', Comment.Multiline)
+            (r'[^*]+', Comment.Multiline),
+            (r'\*', Comment.Multiline)
         ],
         'incontinuation': [
             (r'^\s*\)', Generic, '#pop'),
@@ -194,7 +195,7 @@ class AutohotkeyLexer(RegexLexer):
 
 class AutoItLexer(RegexLexer):
     """
-    For `AutoIt <http://www.autoitscript.com/site/autoit/>`_ files.
+    For AutoIt files.
 
     AutoIt is a freeware BASIC-like scripting language
     designed for automating the Windows GUI and general scripting
@@ -202,6 +203,7 @@ class AutoItLexer(RegexLexer):
     .. versionadded:: 1.6
     """
     name = 'AutoIt'
+    url = 'http://www.autoitscript.com/site/autoit/'
     aliases = ['autoit']
     filenames = ['*.au3']
     mimetypes = ['text/x-autoit']

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

@@ -4,30 +4,27 @@
 
     Lexer for the BARE schema.
 
-    :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 RegexLexer, words, bygroups
-from pygments.token import Text, Comment, Keyword, Name, Literal
+from pygments.token import Text, Comment, Keyword, Name, Literal, Whitespace
 
 __all__ = ['BareLexer']
 
 
 class BareLexer(RegexLexer):
     """
-    For `BARE schema <https://baremessages.org>`_ schema source.
+    For BARE schema source.
 
     .. versionadded:: 2.7
     """
     name = 'BARE'
+    url = 'https://baremessages.org'
     filenames = ['*.bare']
     aliases = ['bare']
 
-    flags = re.MULTILINE | re.UNICODE
-
     keywords = [
         'type',
         'enum',
@@ -53,29 +50,30 @@ class BareLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'(type)(\s+)([A-Z][a-zA-Z0-9]+)(\s+\{)',
-             bygroups(Keyword, Text, Name.Class, Text), 'struct'),
-            (r'(type)(\s+)([A-Z][a-zA-Z0-9]+)(\s+\()',
-             bygroups(Keyword, Text, Name.Class, Text), 'union'),
+            (r'(type)(\s+)([A-Z][a-zA-Z0-9]+)(\s+)(\{)',
+             bygroups(Keyword, Whitespace, Name.Class, Whitespace, Text), 'struct'),
+            (r'(type)(\s+)([A-Z][a-zA-Z0-9]+)(\s+)(\()',
+             bygroups(Keyword, Whitespace, Name.Class, Whitespace, Text), 'union'),
             (r'(type)(\s+)([A-Z][a-zA-Z0-9]+)(\s+)',
-             bygroups(Keyword, Text, Name, Text), 'typedef'),
+             bygroups(Keyword, Whitespace, Name, Whitespace), 'typedef'),
             (r'(enum)(\s+)([A-Z][a-zA-Z0-9]+)(\s+\{)',
-             bygroups(Keyword, Text, Name.Class, Text), 'enum'),
+             bygroups(Keyword, Whitespace, Name.Class, Whitespace), 'enum'),
             (r'#.*?$', Comment),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
         ],
         'struct': [
             (r'\{', Text, '#push'),
             (r'\}', Text, '#pop'),
-            (r'([a-zA-Z0-9]+)(:\s*)', bygroups(Name.Attribute, Text), 'typedef'),
-            (r'\s+', Text),
+            (r'([a-zA-Z0-9]+)(:)(\s*)',
+             bygroups(Name.Attribute, Text, Whitespace), 'typedef'),
+            (r'\s+', Whitespace),
         ],
         'union': [
             (r'\)', Text, '#pop'),
-            (r'\s*\|\s*', Text),
+            (r'(\s*)(\|)(\s*)', bygroups(Whitespace, Text, Whitespace)),
             (r'[A-Z][a-zA-Z0-9]+', Name.Class),
             (words(keywords), Keyword),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
         ],
         'typedef': [
             (r'\[\]', Text),
@@ -89,15 +87,16 @@ class BareLexer(RegexLexer):
             (words(keywords), Keyword),
             (r'\n', Text, '#pop'),
             (r'\{', Text, 'struct'),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'\d+', Literal),
         ],
         'enum': [
             (r'\{', Text, '#push'),
             (r'\}', Text, '#pop'),
-            (r'([A-Z][A-Z0-9_]*)(\s*=\s*)(\d+)', bygroups(Name.Attribute, Text, Literal)),
+            (r'([A-Z][A-Z0-9_]*)(\s*=\s*)(\d+)',
+             bygroups(Name.Attribute, Text, Literal)),
             (r'([A-Z][A-Z0-9_]*)', bygroups(Name.Attribute)),
             (r'#.*?$', Comment),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
         ],
     }