pygments.rb 1.1.1 → 2.0.0.rc3

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

@@ -5,7 +5,7 @@
 
     Lexers for "business-oriented" languages.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -256,6 +256,7 @@ class ABAPLexer(RegexLexer):
             (r'\s+', Text),
             (r'^\*.*$', Comment.Single),
             (r'\".*?\n', Comment.Single),
+            (r'##\w+', Comment.Special),
         ],
         'variable-names': [
             (r'<\S+>', Name.Variable),
@@ -264,8 +265,8 @@ class ABAPLexer(RegexLexer):
         'root': [
             include('common'),
             # function calls
-            (r'(CALL\s+(?:BADI|CUSTOMER-FUNCTION|FUNCTION))(\s+)(\'?\S+\'?)',
-             bygroups(Keyword, Text, Name.Function)),
+            (r'CALL\s+(?:BADI|CUSTOMER-FUNCTION|FUNCTION)',
+             Keyword),
             (r'(CALL\s+(?:DIALOG|SCREEN|SUBSCREEN|SELECTION-SCREEN|'
              r'TRANSACTION|TRANSFORMATION))\b',
              Keyword),
@@ -285,6 +286,12 @@ class ABAPLexer(RegexLexer):
             # call methodnames returning style
             (r'(?<=(=|-)>)([\w\-~]+)(?=\()', Name.Function),
 
+            # text elements
+            (r'(TEXT)(-)(\d{3})',
+             bygroups(Keyword, Punctuation, Number.Integer)),
+            (r'(TEXT)(-)(\w{3})',
+             bygroups(Keyword, Punctuation, Name.Variable)),
+
             # keywords with dashes in them.
             # these need to be first, because for instance the -ID part
             # of MESSAGE-ID wouldn't get highlighted if MESSAGE was
@@ -301,13 +308,13 @@ class ABAPLexer(RegexLexer):
              r'OUTPUT-LENGTH|PRINT-CONTROL|'
              r'SELECT-OPTIONS|START-OF-SELECTION|SUBTRACT-CORRESPONDING|'
              r'SYNTAX-CHECK|SYSTEM-EXCEPTIONS|'
-             r'TYPE-POOL|TYPE-POOLS'
+             r'TYPE-POOL|TYPE-POOLS|NO-DISPLAY'
              r')\b', Keyword),
 
             # keyword kombinations
-            (r'CREATE\s+(PUBLIC|PRIVATE|DATA|OBJECT)|'
-             r'((PUBLIC|PRIVATE|PROTECTED)\s+SECTION|'
-             r'(TYPE|LIKE)(\s+(LINE\s+OF|REF\s+TO|'
+            (r'(?<![-\>])(CREATE\s+(PUBLIC|PRIVATE|DATA|OBJECT)|'
+             r'(PUBLIC|PRIVATE|PROTECTED)\s+SECTION|'
+             r'(TYPE|LIKE)\s+((LINE\s+OF|REF\s+TO|'
              r'(SORTED|STANDARD|HASHED)\s+TABLE\s+OF))?|'
              r'FROM\s+(DATABASE|MEMORY)|CALL\s+METHOD|'
              r'(GROUP|ORDER) BY|HAVING|SEPARATED BY|'
@@ -343,10 +350,16 @@ class ABAPLexer(RegexLexer):
              r'(BEGIN|END)\s+OF|'
              r'DELETE(\s+ADJACENT\s+DUPLICATES\sFROM)?|'
              r'COMPARING(\s+ALL\s+FIELDS)?|'
-             r'INSERT(\s+INITIAL\s+LINE\s+INTO|\s+LINES\s+OF)?|'
+             r'(INSERT|APPEND)(\s+INITIAL\s+LINE\s+(IN)?TO|\s+LINES\s+OF)?|'
              r'IN\s+((BYTE|CHARACTER)\s+MODE|PROGRAM)|'
              r'END-OF-(DEFINITION|PAGE|SELECTION)|'
              r'WITH\s+FRAME(\s+TITLE)|'
+             r'(REPLACE|FIND)\s+((FIRST|ALL)\s+OCCURRENCES?\s+OF\s+)?(SUBSTRING|REGEX)?|'
+             r'MATCH\s+(LENGTH|COUNT|LINE|OFFSET)|'
+             r'(RESPECTING|IGNORING)\s+CASE|'
+             r'IN\s+UPDATE\s+TASK|'
+             r'(SOURCE|RESULT)\s+(XML)?|'
+             r'REFERENCE\s+INTO|'
 
              # simple kombinations
              r'AND\s+(MARK|RETURN)|CLIENT\s+SPECIFIED|CORRESPONDING\s+FIELDS\s+OF|'
@@ -355,39 +368,41 @@ class ABAPLexer(RegexLexer):
              r'MODIFY\s+SCREEN|NESTING\s+LEVEL|NO\s+INTERVALS|OF\s+STRUCTURE|'
              r'RADIOBUTTON\s+GROUP|RANGE\s+OF|REF\s+TO|SUPPRESS DIALOG|'
              r'TABLE\s+OF|UPPER\s+CASE|TRANSPORTING\s+NO\s+FIELDS|'
-             r'VALUE\s+CHECK|VISIBLE\s+LENGTH|HEADER\s+LINE)\b', Keyword),
+             r'VALUE\s+CHECK|VISIBLE\s+LENGTH|HEADER\s+LINE|COMMON\s+PART)\b', Keyword),
 
             # single word keywords.
-            (r'(^|(?<=(\s|\.)))(ABBREVIATED|ADD|ALIASES|APPEND|ASSERT|'
-             r'ASSIGN(ING)?|AT(\s+FIRST)?|'
+            (r'(^|(?<=(\s|\.)))(ABBREVIATED|ABSTRACT|ADD|ALIASES|ALIGN|ALPHA|'
+             r'ASSERT|AS|ASSIGN(ING)?|AT(\s+FIRST)?|'
              r'BACK|BLOCK|BREAK-POINT|'
              r'CASE|CATCH|CHANGING|CHECK|CLASS|CLEAR|COLLECT|COLOR|COMMIT|'
              r'CREATE|COMMUNICATION|COMPONENTS?|COMPUTE|CONCATENATE|CONDENSE|'
-             r'CONSTANTS|CONTEXTS|CONTINUE|CONTROLS|'
-             r'DATA|DECIMALS|DEFAULT|DEFINE|DEFINITION|DEFERRED|DEMAND|'
-             r'DETAIL|DIRECTORY|DIVIDE|DO|'
-             r'ELSE(IF)?|ENDAT|ENDCASE|ENDCLASS|ENDDO|ENDFORM|ENDFUNCTION|'
-             r'ENDIF|ENDLOOP|ENDMETHOD|ENDMODULE|ENDSELECT|ENDTRY|'
-             r'ENHANCEMENT|EVENTS|EXCEPTIONS|EXIT|EXPORT|EXPORTING|EXTRACT|'
-             r'FETCH|FIELDS?|FIND|FOR|FORM|FORMAT|FREE|FROM|'
+             r'CONSTANTS|CONTEXTS|CONTINUE|CONTROLS|COUNTRY|CURRENCY|'
+             r'DATA|DATE|DECIMALS|DEFAULT|DEFINE|DEFINITION|DEFERRED|DEMAND|'
+             r'DETAIL|DIRECTORY|DIVIDE|DO|DUMMY|'
+             r'ELSE(IF)?|ENDAT|ENDCASE|ENDCATCH|ENDCLASS|ENDDO|ENDFORM|ENDFUNCTION|'
+             r'ENDIF|ENDINTERFACE|ENDLOOP|ENDMETHOD|ENDMODULE|ENDSELECT|ENDTRY|ENDWHILE|'
+             r'ENHANCEMENT|EVENTS|EXACT|EXCEPTIONS?|EXIT|EXPONENT|EXPORT|EXPORTING|EXTRACT|'
+             r'FETCH|FIELDS?|FOR|FORM|FORMAT|FREE|FROM|FUNCTION|'
              r'HIDE|'
              r'ID|IF|IMPORT|IMPLEMENTATION|IMPORTING|IN|INCLUDE|INCLUDING|'
              r'INDEX|INFOTYPES|INITIALIZATION|INTERFACE|INTERFACES|INTO|'
-             r'LENGTH|LINES|LOAD|LOCAL|'
+             r'LANGUAGE|LEAVE|LENGTH|LINES|LOAD|LOCAL|'
              r'JOIN|'
              r'KEY|'
-             r'MAXIMUM|MESSAGE|METHOD[S]?|MINIMUM|MODULE|MODIFY|MOVE|MULTIPLY|'
-             r'NODES|'
-             r'OBLIGATORY|OF|OFF|ON|OVERLAY|'
-             r'PACK|PARAMETERS|PERCENTAGE|POSITION|PROGRAM|PROVIDE|PUBLIC|PUT|'
-             r'RAISE|RAISING|RANGES|READ|RECEIVE|REFRESH|REJECT|REPORT|RESERVE|'
-             r'RESUME|RETRY|RETURN|RETURNING|RIGHT|ROLLBACK|'
-             r'SCROLL|SEARCH|SELECT|SHIFT|SINGLE|SKIP|SORT|SPLIT|STATICS|STOP|'
-             r'SUBMIT|SUBTRACT|SUM|SUMMARY|SUMMING|SUPPLY|'
-             r'TABLE|TABLES|TIMES|TITLE|TO|TOP-OF-PAGE|TRANSFER|TRANSLATE|TRY|TYPES|'
+             r'NEXT|'
+             r'MAXIMUM|MESSAGE|METHOD[S]?|MINIMUM|MODULE|MODIFIER|MODIFY|MOVE|MULTIPLY|'
+             r'NODES|NUMBER|'
+             r'OBLIGATORY|OBJECT|OF|OFF|ON|OTHERS|OVERLAY|'
+             r'PACK|PAD|PARAMETERS|PERCENTAGE|POSITION|PROGRAM|PROVIDE|PUBLIC|PUT|PF\d\d|'
+             r'RAISE|RAISING|RANGES?|READ|RECEIVE|REDEFINITION|REFRESH|REJECT|REPORT|RESERVE|'
+             r'RESUME|RETRY|RETURN|RETURNING|RIGHT|ROLLBACK|REPLACE|'
+             r'SCROLL|SEARCH|SELECT|SHIFT|SIGN|SINGLE|SIZE|SKIP|SORT|SPLIT|STATICS|STOP|'
+             r'STYLE|SUBMATCHES|SUBMIT|SUBTRACT|SUM(?!\()|SUMMARY|SUMMING|SUPPLY|'
+             r'TABLE|TABLES|TIMESTAMP|TIMES?|TIMEZONE|TITLE|\??TO|'
+             r'TOP-OF-PAGE|TRANSFER|TRANSLATE|TRY|TYPES|'
              r'ULINE|UNDER|UNPACK|UPDATE|USING|'
-             r'VALUE|VALUES|VIA|'
-             r'WAIT|WHEN|WHERE|WHILE|WITH|WINDOW|WRITE)\b', Keyword),
+             r'VALUE|VALUES|VIA|VARYING|VARY|'
+             r'WAIT|WHEN|WHERE|WIDTH|WHILE|WITH|WINDOW|WRITE|XSD|ZERO)\b', Keyword),
 
             # builtins
             (r'(abs|acos|asin|atan|'
@@ -413,18 +428,21 @@ class ABAPLexer(RegexLexer):
 
             # operators which look like variable names before
             # parsing variable names.
-            (r'(?<=(\s|.))(AND|EQ|NE|GT|LT|GE|LE|CO|CN|CA|NA|CS|NOT|NS|CP|NP|'
+            (r'(?<=(\s|.))(AND|OR|EQ|NE|GT|LT|GE|LE|CO|CN|CA|NA|CS|NOT|NS|CP|NP|'
              r'BYTE-CO|BYTE-CN|BYTE-CA|BYTE-NA|BYTE-CS|BYTE-NS|'
-             r'IS\s+(NOT\s+)?(INITIAL|ASSIGNED|REQUESTED|BOUND))\b', Operator),
+             r'IS\s+(NOT\s+)?(INITIAL|ASSIGNED|REQUESTED|BOUND))\b', Operator.Word),
 
             include('variable-names'),
 
-            # standard oparators after variable names,
+            # standard operators after variable names,
             # because < and > are part of field symbols.
-            (r'[?*<>=\-+]', Operator),
+            (r'[?*<>=\-+&]', Operator),
             (r"'(''|[^'])*'", String.Single),
             (r"`([^`])*`", String.Single),
-            (r'[/;:()\[\],.]', Punctuation)
+            (r"([|}])([^{}|]*?)([|{])",
+             bygroups(Punctuation, String.Single, Punctuation)),
+            (r'[/;:()\[\],.]', Punctuation),
+            (r'(!)(\w+)', bygroups(Operator, Name)),
         ],
     }
 
@@ -482,11 +500,26 @@ class OpenEdgeLexer(RegexLexer):
         ],
     }
 
+    def analyse_text(text):
+        """Try to identify OpenEdge ABL based on a few common constructs."""
+        result = 0
+
+        if 'END.' in text:
+            result += 0.05
+
+        if 'END PROCEDURE.' in text:
+            result += 0.05
+
+        if 'ELSE DO:' in text:
+            result += 0.05
+
+        return result
+
 
 class GoodDataCLLexer(RegexLexer):
     """
     Lexer for `GoodData-CL
-    <http://github.com/gooddata/GoodData-CL/raw/master/cli/src/main/resources/\
+    <https://github.com/gooddata/GoodData-CL/raw/master/cli/src/main/resources/\
 com/gooddata/processor/COMMANDS.txt>`_
     script files.
 

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

@@ -5,7 +5,7 @@
 
     Lexers for C/C++ languages.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -33,10 +33,22 @@ class CFamilyLexer(RegexLexer):
     #: only one /* */ style comment
     _ws1 = r'\s*(?:/[*].*?[*]/\s*)?'
 
+    # Hexadecimal part in an hexadecimal integer/floating-point literal.
+    # This includes decimal separators matching.
+    _hexpart = r'[0-9a-fA-F](\'?[0-9a-fA-F])*'
+    # Decimal part in an decimal integer/floating-point literal.
+    # This includes decimal separators matching.
+    _decpart = r'\d(\'?\d)*'
+    # Integer literal suffix (e.g. 'ull' or 'll').
+    _intsuffix = r'(([uU][lL]{0,2})|[lL]{1,2}[uU]?)?'
+
+    # 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})*'
+
     tokens = {
         'whitespace': [
             # preprocessor directives: without whitespace
-            ('^#if\s+0', Comment.Preproc, 'if0'),
+            (r'^#if\s+0', Comment.Preproc, 'if0'),
             ('^#', Comment.Preproc, 'macro'),
             # or with whitespace
             ('^(' + _ws1 + r')(#if\s+0)',
@@ -52,27 +64,33 @@ class CFamilyLexer(RegexLexer):
             (r'/(\\\n)?[*][\w\W]*', Comment.Multiline),
         ],
         'statements': [
-            (r'(L?)(")', bygroups(String.Affix, String), 'string'),
-            (r"(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')",
+            (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)),
-            (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*', Number.Float),
-            (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
-            (r'0x[0-9a-fA-F]+[LlUu]*', Number.Hex),
-            (r'0[0-7]+[LlUu]*', Number.Oct),
-            (r'\d+[LlUu]*', Number.Integer),
+
+             # Hexadecimal floating-point literals (C11, C++17)
+            (r'0[xX](' + _hexpart + r'\.' + _hexpart + r'|\.' + _hexpart + r'|' + _hexpart + r')[pP][+-]?' + _hexpart + r'[lL]?', Number.Float),
+
+            (r'(-)?(' + _decpart + r'\.' + _decpart + r'|\.' + _decpart + r'|' + _decpart + r')[eE][+-]?' + _decpart + r'[fFlL]?', Number.Float),
+            (r'(-)?((' + _decpart + r'\.(' + _decpart + r')?|\.' + _decpart + r')[fFlL]?)|(' + _decpart + r'[fFlL])', Number.Float),
+            (r'(-)?0[xX]' + _hexpart + _intsuffix, Number.Hex),
+            (r'(-)?0[bB][01](\'?[01])*' + _intsuffix, Number.Bin),
+            (r'(-)?0(\'?[0-7])+' + _intsuffix, Number.Oct),
+            (r'(-)?' + _decpart + _intsuffix, Number.Integer),
             (r'\*/', Error),
             (r'[~!%^&*+=|?:<>/-]', Operator),
             (r'[()\[\],.]', Punctuation),
+            (r'(struct|union)(\s+)', bygroups(Keyword, Text), 'classname'),
             (words(('asm', 'auto', 'break', 'case', 'const', 'continue',
                     'default', 'do', 'else', 'enum', 'extern', 'for', 'goto',
-                    'if', 'register', 'restricted', 'return', 'sizeof',
-                    'static', 'struct', 'switch', 'typedef', 'union',
-                    'volatile', 'while'),
+                    'if', 'register', 'restricted', 'return', 'sizeof', 'struct',
+                    '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', 'typename'), suffix=r'\b'), Keyword.Reserved),
+                    'thread'), suffix=r'\b'), Keyword.Reserved),
             # Vector intrinsics
             (r'(__m(128i|128d|128|64))\b', Keyword.Reserved),
             # Microsoft-isms
@@ -83,22 +101,22 @@ class CFamilyLexer(RegexLexer):
                 'identifier', 'forceinline', 'assume'),
                 prefix=r'__', suffix=r'\b'), Keyword.Reserved),
             (r'(true|false|NULL)\b', Name.Builtin),
-            (r'([a-zA-Z_]\w*)(\s*)(:)(?!:)', bygroups(Name.Label, Text, Punctuation)),
-            ('[a-zA-Z_]\w*', Name),
+            (r'(' + _ident + r')(\s*)(:)(?!:)', bygroups(Name.Label, Text, Punctuation)),
+            (_ident, Name)
         ],
         'root': [
             include('whitespace'),
             # functions
-            (r'((?:[\w*\s])+?(?:\s|[*]))'  # return arguments
-             r'([a-zA-Z_]\w*)'             # method name
+            (r'((?:' + _ident + r'(?:[&*\s])+))'  # return arguments
+             r'(' + _ident + r')'             # method name
              r'(\s*\([^;]*?\))'            # signature
              r'([^;{]*)(\{)',
              bygroups(using(this), Name.Function, using(this), using(this),
                       Punctuation),
              'function'),
             # function declarations
-            (r'((?:[\w*\s])+?(?:\s|[*]))'  # return arguments
-             r'([a-zA-Z_]\w*)'             # method name
+            (r'((?:' + _ident + r'(?:[&*\s])+))'  # return arguments
+             r'(' + _ident + r')'             # method name
              r'(\s*\([^;]*?\))'            # signature
              r'([^;]*)(;)',
              bygroups(using(this), Name.Function, using(this), using(this),
@@ -108,8 +126,8 @@ class CFamilyLexer(RegexLexer):
         'statement': [
             include('whitespace'),
             include('statements'),
-            ('[{}]', Punctuation),
-            (';', Punctuation, '#pop'),
+            (r'\}', Punctuation),
+            (r'[{;]', Punctuation, '#pop'),
         ],
         'function': [
             include('whitespace'),
@@ -127,8 +145,8 @@ class CFamilyLexer(RegexLexer):
             (r'\\', String),  # stray backslash
         ],
         'macro': [
-            (r'(include)(' + _ws1 + r')([^\n]+)',
-             bygroups(Comment.Preproc, Text, Comment.PreprocFile)),
+            (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'[^/\n]+', Comment.Preproc),
             (r'/[*](.|\n)*?[*]/', Comment.Multiline),
             (r'//.*?\n', Comment.Single, '#pop'),
@@ -141,28 +159,46 @@ class CFamilyLexer(RegexLexer):
             (r'^\s*#el(?:se|if).*\n', Comment.Preproc, '#pop'),
             (r'^\s*#endif.*?(?<!\\)\n', Comment.Preproc, '#pop'),
             (r'.*?\n', Comment),
+        ],
+        'classname': [
+            (_ident, Name.Class, '#pop'),
+            # template specification
+            (r'\s*(?=>)', Text, '#pop'),
+            default('#pop')
         ]
     }
 
-    stdlib_types = set((
+    stdlib_types = {
         'size_t', 'ssize_t', 'off_t', 'wchar_t', 'ptrdiff_t', 'sig_atomic_t', 'fpos_t',
         'clock_t', 'time_t', 'va_list', 'jmp_buf', 'FILE', 'DIR', 'div_t', 'ldiv_t',
-        'mbstate_t', 'wctrans_t', 'wint_t', 'wctype_t'))
-    c99_types = set((
-        '_Bool', '_Complex', 'int8_t', 'int16_t', 'int32_t', 'int64_t', 'uint8_t',
+        'mbstate_t', 'wctrans_t', 'wint_t', 'wctype_t'}
+    c99_types = {
+        'int8_t', 'int16_t', 'int32_t', 'int64_t', 'uint8_t',
         'uint16_t', 'uint32_t', 'uint64_t', 'int_least8_t', 'int_least16_t',
         'int_least32_t', 'int_least64_t', 'uint_least8_t', 'uint_least16_t',
         'uint_least32_t', 'uint_least64_t', 'int_fast8_t', 'int_fast16_t', 'int_fast32_t',
         'int_fast64_t', 'uint_fast8_t', 'uint_fast16_t', 'uint_fast32_t', 'uint_fast64_t',
-        'intptr_t', 'uintptr_t', 'intmax_t', 'uintmax_t'))
-    linux_types = set((
+        'intptr_t', 'uintptr_t', 'intmax_t', 'uintmax_t'}
+    linux_types = {
         'clockid_t', 'cpu_set_t', 'cpumask_t', 'dev_t', 'gid_t', 'id_t', 'ino_t', 'key_t',
         'mode_t', 'nfds_t', 'pid_t', 'rlim_t', 'sig_t', 'sighandler_t', 'siginfo_t',
-        'sigset_t', 'sigval_t', 'socklen_t', 'timer_t', 'uid_t'))
+        'sigset_t', 'sigval_t', 'socklen_t', 'timer_t', 'uid_t'}
+    c11_atomic_types = {
+        'atomic_bool', 'atomic_char', 'atomic_schar', 'atomic_uchar', 'atomic_short', 
+        'atomic_ushort', 'atomic_int', 'atomic_uint', 'atomic_long', 'atomic_ulong',
+        'atomic_llong', 'atomic_ullong', 'atomic_char16_t', 'atomic_char32_t', 'atomic_wchar_t', 
+        'atomic_int_least8_t', 'atomic_uint_least8_t', 'atomic_int_least16_t', 
+        'atomic_uint_least16_t', 'atomic_int_least32_t', 'atomic_uint_least32_t',
+        'atomic_int_least64_t', 'atomic_uint_least64_t', 'atomic_int_fast8_t', 
+        'atomic_uint_fast8_t', 'atomic_int_fast16_t', 'atomic_uint_fast16_t',
+        'atomic_int_fast32_t', 'atomic_uint_fast32_t', 'atomic_int_fast64_t',
+        'atomic_uint_fast64_t', 'atomic_intptr_t', 'atomic_uintptr_t', 'atomic_size_t',
+        'atomic_ptrdiff_t', 'atomic_intmax_t', 'atomic_uintmax_t'}
 
     def __init__(self, **options):
         self.stdlibhighlighting = get_bool_opt(options, 'stdlibhighlighting', True)
         self.c99highlighting = get_bool_opt(options, 'c99highlighting', True)
+        self.c11highlighting = get_bool_opt(options, 'c11highlighting', True)
         self.platformhighlighting = get_bool_opt(options, 'platformhighlighting', True)
         RegexLexer.__init__(self, **options)
 
@@ -174,6 +210,8 @@ class CFamilyLexer(RegexLexer):
                     token = Keyword.Type
                 elif self.c99highlighting and value in self.c99_types:
                     token = Keyword.Type
+                elif self.c11highlighting and value in self.c11_atomic_types:
+                    token = Keyword.Type
                 elif self.platformhighlighting and value in self.linux_types:
                     token = Keyword.Type
             yield index, token, value
@@ -182,6 +220,25 @@ class CFamilyLexer(RegexLexer):
 class CLexer(CFamilyLexer):
     """
     For C source code with preprocessor directives.
+
+    Additional options accepted:
+
+    `stdlibhighlighting`
+        Highlight common types found in the C/C++ standard library (e.g. `size_t`).
+        (default: ``True``).
+
+    `c99highlighting`
+        Highlight common types found in the C99 standard library (e.g. `int8_t`).
+        Actually, this includes all fixed-width integer types.
+        (default: ``True``).
+
+    `c11highlighting`
+        Highlight atomic types found in the C11 standard library (e.g. `atomic_bool`).
+        (default: ``True``).
+
+    `platformhighlighting`
+        Highlight common types found in the platform SDK headers (e.g. `clockid_t` on Linux).
+        (default: ``True``).
     """
     name = 'C'
     aliases = ['c']
@@ -189,16 +246,46 @@ class CLexer(CFamilyLexer):
     mimetypes = ['text/x-chdr', 'text/x-csrc']
     priority = 0.1
 
+    tokens = {
+        'statements': [
+            (words((
+                '_Alignas', '_Alignof', '_Noreturn', '_Generic', '_Thread_local', 
+                '_Static_assert', '_Imaginary', 'noreturn', 'imaginary', 'complex'),
+                suffix=r'\b'), Keyword),
+            (words(('_Bool', '_Complex', '_Atomic'), suffix=r'\b'), Keyword.Type),
+            inherit
+        ]
+    }
+
     def analyse_text(text):
-        if re.search('^\s*#include [<"]', text, re.MULTILINE):
+        if re.search(r'^\s*#include [<"]', text, re.MULTILINE):
             return 0.1
-        if re.search('^\s*#ifn?def ', text, re.MULTILINE):
+        if re.search(r'^\s*#ifn?def ', text, re.MULTILINE):
             return 0.1
 
 
 class CppLexer(CFamilyLexer):
     """
     For C++ source code with preprocessor directives.
+
+    Additional options accepted:
+
+    `stdlibhighlighting`
+        Highlight common types found in the C/C++ standard library (e.g. `size_t`).
+        (default: ``True``).
+
+    `c99highlighting`
+        Highlight common types found in the C99 standard library (e.g. `int8_t`).
+        Actually, this includes all fixed-width integer types.
+        (default: ``True``).
+
+    `c11highlighting`
+        Highlight atomic types found in the C11 standard library (e.g. `atomic_bool`).
+        (default: ``True``).
+
+    `platformhighlighting`
+        Highlight common types found in the platform SDK headers (e.g. `clockid_t` on Linux).
+        (default: ``True``).
     """
     name = 'C++'
     aliases = ['cpp', 'c++']
@@ -210,23 +297,24 @@ 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',
+                'private', 'protected', 'public', 'reinterpret_cast', 'class',
                 'restrict', 'static_cast', 'template', 'this', 'throw', 'throws',
-                'try', 'typeid', 'typename', 'using', 'virtual',
-                'constexpr', 'nullptr', 'decltype', 'thread_local',
-                'alignas', 'alignof', 'static_assert', 'noexcept', 'override',
-                'final'), suffix=r'\b'), Keyword),
-            (r'char(16_t|32_t)\b', Keyword.Type),
-            (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
+                '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'(R)(")([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(")',
+            (r'((?:[LuU]|u8)?R)(")([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(")',
              bygroups(String.Affix, String, String.Delimiter, String.Delimiter,
                       String, String.Delimiter, String)),
-            # C++11 UTF-8/16/32 strings
-            (r'(u8|u|U)(")', bygroups(String.Affix, String), 'string'),
             inherit,
         ],
         'root': [
@@ -238,11 +326,15 @@ class CppLexer(CFamilyLexer):
             # Offload C++ extensions, http://offload.codeplay.com/
             (r'__(offload|blockingoffload|outer)\b', Keyword.Pseudo),
         ],
-        'classname': [
-            (r'[a-zA-Z_]\w*', Name.Class, '#pop'),
+        'enumname': [
+            include('whitespace'),
+            # 'enum class' and 'enum struct' C++11 support
+            (words(('class', 'struct'), suffix=r'\b'), Keyword),
+            (CFamilyLexer._ident, Name.Class, '#pop'),
             # template specification
             (r'\s*(?=>)', Text, '#pop'),
-        ],
+            default('#pop')
+        ]
     }
 
     def analyse_text(text):