pygments.rb 2.2.0 → 2.3.0

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

@@ -353,13 +353,14 @@ class LlvmLexer(RegexLexer):
     #: optional Comment or Whitespace
     string = r'"[^"]*?"'
     identifier = r'([-a-zA-Z$._][\w\-$.]*|' + string + ')'
+    block_label = r'(' + identifier + r'|(\d+))'
 
     tokens = {
         'root': [
             include('whitespace'),
 
             # Before keywords, because keywords are valid label names :(...
-            (identifier + r'\s*:', Name.Label),
+            (block_label + r'\s*:', Name.Label),
 
             include('keyword'),
 
@@ -384,68 +385,95 @@ class LlvmLexer(RegexLexer):
         'keyword': [
             # Regular keywords
             (words((
-                'acq_rel', 'acquire', 'add', 'addrspace', 'addrspacecast', 'afn', 'alias',
-                'aliasee', 'align', 'alignLog2', 'alignstack', 'alloca', 'allocsize', 'allOnes',
-                'alwaysinline', 'amdgpu_cs', 'amdgpu_es', 'amdgpu_gs', 'amdgpu_hs',
-                'amdgpu_kernel', 'amdgpu_ls', 'amdgpu_ps', 'amdgpu_vs', 'and', 'any',
-                'anyregcc', 'appending', 'arcp', 'argmemonly', 'args', 'arm_aapcs_vfpcc',
-                'arm_aapcscc', 'arm_apcscc', 'ashr', 'asm', 'atomic', 'atomicrmw', 'attributes',
-                'available_externally', 'avr_intrcc', 'avr_signalcc', 'bit', 'bitcast',
-                'bitMask', 'blockaddress', 'br', 'branchFunnel', 'builtin', 'byArg', 'byte',
-                'byteArray', 'byval', 'c', 'call', 'callee', 'caller', 'calls', 'catch',
-                'catchpad', 'catchret', 'catchswitch', 'cc', 'ccc', 'cleanup', 'cleanuppad',
-                'cleanupret', 'cmpxchg', 'cold', 'coldcc', 'comdat', 'common', 'constant',
-                'contract', 'convergent', 'critical', 'cxx_fast_tlscc', 'datalayout', 'declare',
-                'default', 'define', 'deplibs', 'dereferenceable', 'dereferenceable_or_null',
-                'distinct', 'dllexport', 'dllimport', 'dso_local', 'dso_preemptable',
-                'dsoLocal', 'eq', 'exact', 'exactmatch', 'extern_weak', 'external',
-                'externally_initialized', 'extractelement', 'extractvalue', 'fadd', 'false',
-                'fast', 'fastcc', 'fcmp', 'fdiv', 'fence', 'filter', 'flags', 'fmul',
-                'fpext', 'fptosi', 'fptoui', 'fptrunc', 'freeze', 'frem', 'from', 'fsub',
-                'funcFlags', 'function', 'gc', 'getelementptr', 'ghccc', 'global', 'guid', 'gv',
-                'hash', 'hhvm_ccc', 'hhvmcc', 'hidden', 'hot', 'hotness', 'icmp',
-                'ifunc', 'inaccessiblemem_or_argmemonly', 'inaccessiblememonly', 'inalloca',
-                'inbounds', 'indir', 'indirectbr', 'info', 'initialexec', 'inline',
-                'inlineBits', 'inlinehint', 'inrange', 'inreg', 'insertelement', 'insertvalue',
-                'insts', 'intel_ocl_bicc', 'inteldialect', 'internal', 'inttoptr', 'invoke',
-                'jumptable', 'kind', 'landingpad', 'largest', 'linkage', 'linkonce',
-                'linkonce_odr', 'live', 'load', 'local_unnamed_addr', 'localdynamic',
-                'localexec', 'lshr', 'max', 'metadata', 'min', 'minsize', 'module', 'monotonic',
-                'msp430_intrcc', 'mul', 'musttail', 'naked', 'name', 'nand', 'ne', 'nest',
-                'ninf', 'nnan', 'noalias', 'nobuiltin', 'nocapture', 'nocf_check',
-                'noduplicate', 'noduplicates', 'noimplicitfloat', 'noinline', 'none',
-                'nonlazybind', 'nonnull', 'norecurse', 'noRecurse', 'noredzone', 'noreturn',
-                'notail', 'notEligibleToImport', 'nounwind', 'nsw', 'nsz', 'null', 'nuw', 'oeq',
-                'offset', 'oge', 'ogt', 'ole', 'olt', 'one', 'opaque', 'optforfuzzing',
-                'optnone', 'optsize', 'or', 'ord', 'path', 'personality', 'phi', 'poison',
-                'prefix', 'preserve_allcc', 'preserve_mostcc', 'private', 'prologue',
-                'protected', 'ptrtoint', 'ptx_device', 'ptx_kernel', 'readnone', 'readNone',
-                'readonly', 'readOnly', 'reassoc', 'refs', 'relbf', 'release', 'resByArg',
-                'resume', 'ret', 'returnDoesNotAlias', 'returned', 'returns_twice', 'safestack',
-                'samesize', 'sanitize_address', 'sanitize_hwaddress', 'sanitize_memory',
-                'sanitize_thread', 'sdiv', 'section', 'select', 'seq_cst', 'sext', 'sge', 'sgt',
-                'shadowcallstack', 'shl', 'shufflevector', 'sideeffect', 'signext', 'single',
-                'singleImpl', 'singleImplName', 'sitofp', 'sizeM1', 'sizeM1BitWidth', 'sle',
-                'slt', 'source_filename', 'speculatable', 'spir_func', 'spir_kernel', 'srem',
-                'sret', 'ssp', 'sspreq', 'sspstrong', 'store', 'strictfp', 'sub', 'summaries',
-                'summary', 'swiftcc', 'swifterror', 'swiftself', 'switch', 'syncscope', 'tail',
-                'target', 'thread_local', 'to', 'token', 'triple', 'true', 'trunc', 'type',
-                'typeCheckedLoadConstVCalls', 'typeCheckedLoadVCalls', 'typeid', 'typeIdInfo',
-                'typeTestAssumeConstVCalls', 'typeTestAssumeVCalls', 'typeTestRes', 'typeTests',
-                'udiv', 'ueq', 'uge', 'ugt', 'uitofp', 'ule', 'ult', 'umax', 'umin', 'undef',
-                'une', 'uniformRetVal', 'uniqueRetVal', 'unknown', 'unnamed_addr', 'uno',
-                'unordered', 'unreachable', 'unsat', 'unwind', 'urem', 'uselistorder',
-                'uselistorder_bb', 'uwtable', 'va_arg', 'variable', 'vFuncId',
-                'virtualConstProp', 'void', 'volatile', 'weak', 'weak_odr', 'webkit_jscc',
+                'aarch64_sve_vector_pcs', 'aarch64_vector_pcs', 'acq_rel',
+                'acquire', 'add', 'addrspace', 'addrspacecast', 'afn', 'alias',
+                'aliasee', 'align', 'alignLog2', 'alignstack', 'alloca',
+                'allocsize', 'allOnes', 'alwaysinline', 'alwaysInline',
+                'amdgpu_cs', 'amdgpu_es', 'amdgpu_gfx', 'amdgpu_gs',
+                'amdgpu_hs', 'amdgpu_kernel', 'amdgpu_ls', 'amdgpu_ps',
+                'amdgpu_vs', 'and', 'any', 'anyregcc', 'appending', 'arcp',
+                'argmemonly', 'args', 'arm_aapcs_vfpcc', 'arm_aapcscc',
+                'arm_apcscc', 'ashr', 'asm', 'atomic', 'atomicrmw',
+                'attributes', 'available_externally', 'avr_intrcc',
+                'avr_signalcc', 'bit', 'bitcast', 'bitMask', 'blockaddress',
+                'blockcount', 'br', 'branchFunnel', 'builtin', 'byArg',
+                'byref', 'byte', 'byteArray', 'byval', 'c', 'call', 'callbr',
+                'callee', 'caller', 'calls', 'canAutoHide', 'catch',
+                'catchpad', 'catchret', 'catchswitch', 'cc', 'ccc',
+                'cfguard_checkcc', 'cleanup', 'cleanuppad', 'cleanupret',
+                'cmpxchg', 'cold', 'coldcc', 'comdat', 'common', 'constant',
+                'contract', 'convergent', 'critical', 'cxx_fast_tlscc',
+                'datalayout', 'declare', 'default', 'define', 'deplibs',
+                'dereferenceable', 'dereferenceable_or_null', 'distinct',
+                'dllexport', 'dllimport', 'dso_local', 'dso_local_equivalent',
+                'dso_preemptable', 'dsoLocal', 'eq', 'exact', 'exactmatch',
+                'extern_weak', 'external', 'externally_initialized',
+                'extractelement', 'extractvalue', 'fadd', 'false', 'fast',
+                'fastcc', 'fcmp', 'fdiv', 'fence', 'filter', 'flags', 'fmul',
+                'fneg', 'fpext', 'fptosi', 'fptoui', 'fptrunc', 'freeze',
+                'frem', 'from', 'fsub', 'funcFlags', 'function', 'gc',
+                'getelementptr', 'ghccc', 'global', 'guid', 'gv', 'hash',
+                'hhvm_ccc', 'hhvmcc', 'hidden', 'hot', 'hotness', 'icmp',
+                'ifunc', 'inaccessiblemem_or_argmemonly',
+                'inaccessiblememonly', 'inalloca', 'inbounds', 'indir',
+                'indirectbr', 'info', 'initialexec', 'inline', 'inlineBits',
+                'inlinehint', 'inrange', 'inreg', 'insertelement',
+                'insertvalue', 'insts', 'intel_ocl_bicc', 'inteldialect',
+                'internal', 'inttoptr', 'invoke', 'jumptable', 'kind',
+                'landingpad', 'largest', 'linkage', 'linkonce', 'linkonce_odr',
+                'live', 'load', 'local_unnamed_addr', 'localdynamic',
+                'localexec', 'lshr', 'max', 'metadata', 'min', 'minsize',
+                'module', 'monotonic', 'msp430_intrcc', 'mul', 'mustprogress',
+                'musttail', 'naked', 'name', 'nand', 'ne', 'nest', 'ninf',
+                'nnan', 'noalias', 'nobuiltin', 'nocallback', 'nocapture',
+                'nocf_check', 'noduplicate', 'noduplicates', 'nofree',
+                'noimplicitfloat', 'noinline', 'noInline', 'nomerge', 'none',
+                'nonlazybind', 'nonnull', 'noprofile', 'norecurse',
+                'noRecurse', 'noredzone', 'noreturn', 'nosync', 'notail',
+                'notEligibleToImport', 'noundef', 'nounwind', 'nsw',
+                'nsz', 'null', 'null_pointer_is_valid', 'nuw', 'oeq', 'offset',
+                'oge', 'ogt', 'ole', 'olt', 'one', 'opaque', 'optforfuzzing',
+                'optnone', 'optsize', 'or', 'ord', 'param', 'params',
+                'partition', 'path', 'personality', 'phi', 'poison',
+                'preallocated', 'prefix', 'preserve_allcc', 'preserve_mostcc',
+                'private', 'prologue', 'protected', 'ptrtoint', 'ptx_device',
+                'ptx_kernel', 'readnone', 'readNone', 'readonly', 'readOnly',
+                'reassoc', 'refs', 'relbf', 'release', 'resByArg', 'resume',
+                'ret', 'returnDoesNotAlias', 'returned', 'returns_twice',
+                'safestack', 'samesize', 'sanitize_address',
+                'sanitize_hwaddress', 'sanitize_memory', 'sanitize_memtag',
+                'sanitize_thread', 'sdiv', 'section', 'select', 'seq_cst',
+                'sext', 'sge', 'sgt', 'shadowcallstack', 'shl',
+                'shufflevector', 'sideeffect', 'signext', 'single',
+                'singleImpl', 'singleImplName', 'sitofp', 'sizeM1',
+                'sizeM1BitWidth', 'sle', 'slt', 'source_filename',
+                'speculatable', 'speculative_load_hardening', 'spir_func',
+                'spir_kernel', 'srem', 'sret', 'ssp', 'sspreq', 'sspstrong',
+                'store', 'strictfp', 'sub', 'summaries', 'summary', 'swiftcc',
+                'swifterror', 'swiftself', 'switch', 'syncscope', 'tail',
+                'tailcc', 'target', 'thread_local', 'to', 'token', 'triple',
+                'true', 'trunc', 'type', 'typeCheckedLoadConstVCalls',
+                'typeCheckedLoadVCalls', 'typeid', 'typeidCompatibleVTable',
+                'typeIdInfo', 'typeTestAssumeConstVCalls',
+                'typeTestAssumeVCalls', 'typeTestRes', 'typeTests', 'udiv',
+                'ueq', 'uge', 'ugt', 'uitofp', 'ule', 'ult', 'umax', 'umin',
+                'undef', 'une', 'uniformRetVal', 'uniqueRetVal', 'unknown',
+                'unnamed_addr', 'uno', 'unordered', 'unreachable', 'unsat',
+                'unwind', 'urem', 'uselistorder', 'uselistorder_bb', 'uwtable',
+                'va_arg', 'varFlags', 'variable', 'vcall_visibility',
+                'vFuncId', 'virtFunc', 'virtualConstProp', 'void', 'volatile',
+                'vscale', 'vTableFuncs', 'weak', 'weak_odr', 'webkit_jscc',
                 'win64cc', 'within', 'wpdRes', 'wpdResolutions', 'writeonly',
-                'x86_64_sysvcc', 'x86_fastcallcc', 'x86_intrcc', 'x86_mmx',
-                'x86_regcallcc', 'x86_stdcallcc', 'x86_thiscallcc', 'x86_vectorcallcc', 'xchg',
-                'xor', 'zeroext', 'zeroinitializer', 'zext', 'immarg', 'willreturn'),
+                'x', 'x86_64_sysvcc', 'x86_fastcallcc', 'x86_intrcc',
+                'x86_mmx', 'x86_regcallcc', 'x86_stdcallcc', 'x86_thiscallcc',
+                'x86_vectorcallcc', 'xchg', 'xor', 'zeroext',
+                'zeroinitializer', 'zext', 'immarg', 'willreturn'),
                 suffix=r'\b'), Keyword),
 
             # Types
             (words(('void', 'half', 'bfloat', 'float', 'double', 'fp128',
-                    'x86_fp80', 'ppc_fp128', 'label', 'metadata', 'token')),
+                    'x86_fp80', 'ppc_fp128', 'label', 'metadata', 'x86_mmx',
+                    'x86_amx', 'token')),
                    Keyword.Type),
 
             # Integer types

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

@@ -22,7 +22,7 @@ class AutohotkeyLexer(RegexLexer):
     .. versionadded:: 1.4
     """
     name = 'autohotkey'
-    aliases = ['ahk', 'autohotkey']
+    aliases = ['autohotkey', 'ahk']
     filenames = ['*.ahk', '*.ahkl']
     mimetypes = ['text/x-autohotkey']
 

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

@@ -26,7 +26,7 @@ class BibTeXLexer(ExtendedRegexLexer):
     """
 
     name = 'BibTeX'
-    aliases = ['bib', 'bibtex']
+    aliases = ['bibtex', 'bib']
     filenames = ['*.bib']
     mimetypes = ["text/x-bibtex"]
     flags = re.IGNORECASE
@@ -154,6 +154,6 @@ class BSTLexer(RegexLexer):
         ],
         'whitespace': [
             (r'\s+', Text),
-            ('%.*?$', Comment.SingleLine),
+            ('%.*?$', Comment.Single),
         ],
     }

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

@@ -14,7 +14,7 @@ from pygments.lexer import RegexLexer, include, bygroups, using, \
     this, inherit, default, words
 from pygments.util import get_bool_opt
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+    Number, Punctuation, Whitespace
 
 __all__ = ['CLexer', 'CppLexer']
 
@@ -43,6 +43,7 @@ class CFamilyLexer(RegexLexer):
 
     # Identifier regex with C and C++ Universal Character Name (UCN) support.
     _ident = r'(?:[a-zA-Z_$]|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8})(?:[\w$]|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8})*'
+    _namespaced_ident = r'(?:[a-zA-Z_$]|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8})(?:[\w$]|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|::)*'
 
     tokens = {
         'whitespace': [
@@ -54,8 +55,8 @@ class CFamilyLexer(RegexLexer):
              bygroups(using(this), Comment.Preproc), 'if0'),
             ('^(' + _ws1 + ')(#)',
              bygroups(using(this), Comment.Preproc), 'macro'),
-            (r'\n', Text),
-            (r'\s+', Text),
+            (r'\n', Whitespace),
+            (r'[^\S\n]+', Whitespace),
             (r'\\\n', Text),  # line continuation
             (r'//(\n|[\w\W]*?[^\\]\n)', Comment.Single),
             (r'/(\\\n)?[*][\w\W]*?[*](\\\n)?/', Comment.Multiline),
@@ -63,6 +64,8 @@ class CFamilyLexer(RegexLexer):
             (r'/(\\\n)?[*][\w\W]*', Comment.Multiline),
         ],
         'statements': [
+            include('keywords'),
+            include('types'),
             (r'([LuU]|u8)?(")', bygroups(String.Affix, String), 'string'),
             (r"([LuU]|u8)?(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')",
              bygroups(String.Affix, String.Char, String.Char, String.Char)),
@@ -78,6 +81,17 @@ class CFamilyLexer(RegexLexer):
             (r'(-)?' + _decpart + _intsuffix, Number.Integer),
             (r'[~!%^&*+=|?:<>/-]', Operator),
             (r'[()\[\],.]', Punctuation),
+            (r'(true|false|NULL)\b', Name.Builtin),
+            (r'(' + _ident + r')(\s*)(:)(?!:)', bygroups(Name.Label, Text, Punctuation)),
+            (_ident, Name)
+        ],
+        'types': [
+            (words(('int8', 'int16', 'int32', 'int64', 'wchar_t'), prefix=r'__',
+                    suffix=r'\b'), Keyword.Reserved),
+            (words(('bool', 'int', 'long', 'float', 'short', 'double', 'char',
+                    'unsigned', 'signed', 'void'), suffix=r'\b'), Keyword.Type)
+        ],
+        'keywords': [
             (r'(struct|union)(\s+)', bygroups(Keyword, Text), 'classname'),
             (words(('asm', 'auto', 'break', 'case', 'const', 'continue',
                     'default', 'do', 'else', 'enum', 'extern', 'for', 'goto',
@@ -85,36 +99,32 @@ class CFamilyLexer(RegexLexer):
                     'static', 'switch', 'typedef', 'volatile', 'while', 'union',
                     'thread_local', 'alignas', 'alignof', 'static_assert', '_Pragma'),
                    suffix=r'\b'), Keyword),
-            (r'(bool|int|long|float|short|double|char|unsigned|signed|void)\b',
-             Keyword.Type),
             (words(('inline', '_inline', '__inline', 'naked', 'restrict',
                     'thread'), suffix=r'\b'), Keyword.Reserved),
             # Vector intrinsics
             (r'(__m(128i|128d|128|64))\b', Keyword.Reserved),
             # Microsoft-isms
             (words((
-                'asm', 'int8', 'based', 'except', 'int16', 'stdcall', 'cdecl',
-                'fastcall', 'int32', 'declspec', 'finally', 'int64', 'try',
-                'leave', 'wchar_t', 'w64', 'unaligned', 'raise', 'noop',
+                'asm', 'based', 'except', 'stdcall', 'cdecl',
+                'fastcall', 'declspec', 'finally', 'try',
+                'leave', 'w64', 'unaligned', 'raise', 'noop',
                 'identifier', 'forceinline', 'assume'),
-                prefix=r'__', suffix=r'\b'), Keyword.Reserved),
-            (r'(true|false|NULL)\b', Name.Builtin),
-            (r'(' + _ident + r')(\s*)(:)(?!:)', bygroups(Name.Label, Text, Punctuation)),
-            (_ident, Name)
+                prefix=r'__', suffix=r'\b'), Keyword.Reserved)
         ],
         'root': [
             include('whitespace'),
+            include('keywords'),
             # functions
-            (r'((?:' + _ident + r'(?:[&*\s])+))'  # return arguments
-             r'(' + _ident + r')'             # method name
+            (r'(' + _namespaced_ident + r'(?:[&*\s])+)'  # return arguments
+             r'(' + _namespaced_ident + r')'             # method name
              r'(\s*\([^;]*?\))'            # signature
              r'([^;{]*)(\{)',
              bygroups(using(this), Name.Function, using(this), using(this),
                       Punctuation),
              'function'),
             # function declarations
-            (r'((?:' + _ident + r'(?:[&*\s])+))'  # return arguments
-             r'(' + _ident + r')'             # method name
+            (r'(' + _namespaced_ident + r'(?:[&*\s])+)'  # return arguments
+             r'(' + _namespaced_ident + r')'             # method name
              r'(\s*\([^;]*?\))'            # signature
              r'([^;]*)(;)',
              bygroups(using(this), Name.Function, using(this), using(this),
@@ -143,8 +153,10 @@ class CFamilyLexer(RegexLexer):
             (r'\\', String),  # stray backslash
         ],
         'macro': [
-            (r'(include)('+_ws1+r')("[^"]+")([^\n]*)', bygroups(Comment.Preproc, using(this), Comment.PreprocFile, Comment.Single)),
-            (r'(include)('+_ws1+r')(<[^>]+>)([^\n]*)', bygroups(Comment.Preproc, using(this), Comment.PreprocFile, Comment.Single)),
+            (r'('+_ws1+r')(include)('+_ws1+r')("[^"]+")([^\n]*)',
+                bygroups(using(this), Comment.Preproc, using(this), Comment.PreprocFile, Comment.Single)),
+            (r'('+_ws1+r')(include)('+_ws1+r')(<[^>]+>)([^\n]*)',
+                bygroups(using(this), Comment.Preproc, using(this), Comment.PreprocFile, Comment.Single)),
             (r'[^/\n]+', Comment.Preproc),
             (r'/[*](.|\n)*?[*]/', Comment.Multiline),
             (r'//.*?\n', Comment.Single, '#pop'),
@@ -245,11 +257,14 @@ class CLexer(CFamilyLexer):
     priority = 0.1
 
     tokens = {
-        'statements': [
+        'keywords': [
             (words((
                 '_Alignas', '_Alignof', '_Noreturn', '_Generic', '_Thread_local', 
                 '_Static_assert', '_Imaginary', 'noreturn', 'imaginary', 'complex'),
                 suffix=r'\b'), Keyword),
+            inherit
+        ],
+        'types': [
             (words(('_Bool', '_Complex', '_Atomic'), suffix=r'\b'), Keyword.Type),
             inherit
         ]
@@ -295,20 +310,6 @@ class CppLexer(CFamilyLexer):
 
     tokens = {
         'statements': [
-            (r'(class|concept|typename)(\s+)', bygroups(Keyword, Text), 'classname'),
-            (words((
-                'catch', 'const_cast', 'delete', 'dynamic_cast', 'explicit',
-                'export', 'friend', 'mutable', 'namespace', 'new', 'operator',
-                'private', 'protected', 'public', 'reinterpret_cast', 'class',
-                'restrict', 'static_cast', 'template', 'this', 'throw', 'throws',
-                'try', 'typeid', 'using', 'virtual', 'constexpr', 'nullptr', 'concept',
-                'decltype', 'noexcept', 'override', 'final', 'constinit', 'consteval', 
-                'co_await', 'co_return', 'co_yield', 'requires', 'import', 'module',
-                'typename'),
-               suffix=r'\b'), Keyword),
-            (r'char(16_t|32_t|8_t)\b', Keyword.Type),
-            (r'(enum)(\s+)', bygroups(Keyword, Text), 'enumname'),
-
             # C++11 raw strings
             (r'((?:[LuU]|u8)?R)(")([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(")',
              bygroups(String.Affix, String, String.Delimiter, String.Delimiter,
@@ -332,6 +333,32 @@ class CppLexer(CFamilyLexer):
             # template specification
             (r'\s*(?=>)', Text, '#pop'),
             default('#pop')
+        ],
+        'keywords': [
+            (r'(class|concept|typename)(\s+)', bygroups(Keyword, Text), 'classname'),
+            (words((
+                'catch', 'const_cast', 'delete', 'dynamic_cast', 'explicit',
+                'export', 'friend', 'mutable', 'new', 'operator',
+                'private', 'protected', 'public', 'reinterpret_cast', 'class',
+                'restrict', 'static_cast', 'template', 'this', 'throw', 'throws',
+                'try', 'typeid', 'using', 'virtual', 'constexpr', 'nullptr', 'concept',
+                'decltype', 'noexcept', 'override', 'final', 'constinit', 'consteval', 
+                'co_await', 'co_return', 'co_yield', 'requires', 'import', 'module',
+                'typename'),
+               suffix=r'\b'), Keyword),
+            (r'namespace\b', Keyword, 'namespace'),
+            (r'(enum)(\s+)', bygroups(Keyword, Text), 'enumname'),
+            inherit
+        ],
+        'types': [
+            (r'char(16_t|32_t|8_t)\b', Keyword.Type),
+            inherit
+        ],
+        'namespace': [
+            (r'[;{]', Punctuation, ('#pop', 'root')),
+            (r'inline\b', Keyword.Reserved),
+            (CFamilyLexer._ident, Name.Namespace),
+            include('statement')
         ]
     }
 

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

@@ -13,13 +13,14 @@ import re
 from pygments.lexer import RegexLexer, include, bygroups, inherit, words, \
     default
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+    Number, Punctuation, Whitespace
 
 from pygments.lexers.c_cpp import CLexer, CppLexer
 from pygments.lexers import _mql_builtins
 
 __all__ = ['PikeLexer', 'NesCLexer', 'ClayLexer', 'ECLexer', 'ValaLexer',
-           'CudaLexer', 'SwigLexer', 'MqlLexer', 'ArduinoLexer', 'CharmciLexer']
+           'CudaLexer', 'SwigLexer', 'MqlLexer', 'ArduinoLexer', 'CharmciLexer',
+           'OmgIdlLexer']
 
 
 class PikeLexer(CppLexer):
@@ -334,6 +335,11 @@ class SwigLexer(CppLexer):
     priority = 0.04  # Lower than C/C++ and Objective C/C++
 
     tokens = {
+        'root': [
+            # Match it here so it won't be matched as a function in the rest of root
+            (r'\$\**\&?\w+', Name),
+            inherit
+        ],
         'statements': [
             # SWIG directives
             (r'(%[a-z_][a-z0-9_]*)', Name.Function),
@@ -549,7 +555,7 @@ class CharmciLexer(CppLexer):
     mimetypes = []
 
     tokens = {
-        'statements': [
+        'keywords': [
             (r'(module)(\s+)', bygroups(Keyword, Text), 'classname'),
             (words(('mainmodule', 'mainchare', 'chare', 'array', 'group',
                     'nodegroup', 'message', 'conditional')), Keyword),
@@ -563,3 +569,96 @@ class CharmciLexer(CppLexer):
             inherit,
         ],
     }
+
+
+class OmgIdlLexer(CLexer):
+    """
+    Lexer for `Object Management Group Interface Definition Language <https://www.omg.org/spec/IDL/About-IDL/>`_.
+
+    .. versionadded:: 2.9
+    """
+
+    name = 'OMG Interface Definition Language'
+    aliases = ['omg-idl']
+    filenames = ['*.idl', '*.pidl']
+    mimetypes = []
+
+    scoped_name = r'((::)?\w+)+'
+
+    tokens = {
+        'values': [
+            (words(('true', 'false'), prefix=r'(?i)', suffix=r'\b'), Number),
+            (r'([Ll]?)(")', bygroups(String.Affix, String.Double), 'string'),
+            (r'([Ll]?)(\')(\\[^\']+)(\')',
+                bygroups(String.Affix, String.Char, String.Escape, String.Char)),
+            (r'([Ll]?)(\')(\\\')(\')',
+                bygroups(String.Affix, String.Char, String.Escape, String.Char)),
+            (r'([Ll]?)(\'.\')', bygroups(String.Affix, String.Char)),
+            (r'[+-]?\d+(\.\d*)?[Ee][+-]?\d+', Number.Float),
+            (r'[+-]?(\d+\.\d*)|(\d*\.\d+)([Ee][+-]?\d+)?', Number.Float),
+            (r'(?i)[+-]?0x[0-9a-f]+', Number.Hex),
+            (r'[+-]?[1-9]\d*', Number.Integer),
+            (r'[+-]?0[0-7]*', Number.Oct),
+            (r'[\+\-\*\/%^&\|~]', Operator),
+            (words(('<<', '>>')), Operator),
+            (scoped_name, Name),
+            (r'[{};:,<>\[\]]', Punctuation),
+        ],
+        'annotation_params': [
+            include('whitespace'),
+            (r'\(', Punctuation, '#push'),
+            include('values'),
+            (r'=', Punctuation),
+            (r'\)', Punctuation, '#pop'),
+        ],
+        'annotation_params_maybe': [
+            (r'\(', Punctuation, 'annotation_params'),
+            include('whitespace'),
+            default('#pop'),
+        ],
+        'annotation_appl': [
+            (r'@' + scoped_name, Name.Decorator, 'annotation_params_maybe'),
+        ],
+        'enum': [
+            include('whitespace'),
+            (r'[{,]', Punctuation),
+            (r'\w+', Name.Constant),
+            include('annotation_appl'),
+            (r'\}', Punctuation, '#pop'),
+        ],
+        'root': [
+            include('whitespace'),
+            (words((
+                'typedef', 'const',
+                'in', 'out', 'inout', 'local',
+            ), prefix=r'(?i)', suffix=r'\b'), Keyword.Declaration),
+            (words((
+                'void', 'any', 'native', 'bitfield',
+                'unsigned', 'boolean', 'char', 'wchar', 'octet', 'short', 'long',
+                'int8', 'uint8', 'int16', 'int32', 'int64', 'uint16', 'uint32', 'uint64',
+                'float', 'double', 'fixed',
+                'sequence', 'string', 'wstring', 'map',
+            ), prefix=r'(?i)', suffix=r'\b'), Keyword.Type),
+            (words((
+                '@annotation', 'struct', 'union', 'bitset', 'interface',
+                'exception', 'valuetype', 'eventtype', 'component',
+            ), prefix=r'(?i)', suffix=r'(\s+)(\w+)'), bygroups(Keyword, Whitespace, Name.Class)),
+            (words((
+                'abstract', 'alias', 'attribute', 'case', 'connector',
+                'consumes', 'context', 'custom', 'default', 'emits', 'factory',
+                'finder', 'getraises', 'home', 'import', 'manages', 'mirrorport',
+                'multiple', 'Object', 'oneway', 'primarykey', 'private', 'port',
+                'porttype', 'provides', 'public', 'publishes', 'raises',
+                'readonly', 'setraises', 'supports', 'switch', 'truncatable',
+                'typeid', 'typename', 'typeprefix', 'uses', 'ValueBase',
+            ), prefix=r'(?i)', suffix=r'\b'), Keyword),
+            (r'(?i)(enum|bitmask)(\s+)(\w+)',
+                bygroups(Keyword, Whitespace, Name.Class), 'enum'),
+            (r'(?i)(module)(\s+)(\w+)',
+                bygroups(Keyword.Namespace, Whitespace, Name.Namespace)),
+            (r'(\w+)(\s*)(=)', bygroups(Name.Constant, Whitespace, Operator)),
+            (r'[\(\)]', Punctuation),
+            include('values'),
+            include('annotation_appl'),
+        ],
+    }

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

@@ -119,7 +119,7 @@ class CddlLexer(RegexLexer):
         "root": [
             include("commentsandwhitespace"),
             # tag types
-            (r"#(\d\.{uint})?".format(uint=_re_uint), Keyword.Type), # type or any
+            (r"#(\d\.{uint})?".format(uint=_re_uint), Keyword.Type),  # type or any
             # occurence
             (
                 r"({uint})?(\*)({uint})?".format(uint=_re_uint),
@@ -164,7 +164,7 @@ class CddlLexer(RegexLexer):
                 Number.Float,
             ),
             # Int
-            (_re_int, Number.Int),
+            (_re_int, Number.Integer),
             (r'"(\\\\|\\"|[^"])*"', String.Double),
         ],
         "bstrb64url": [