eric: comparison eric6/ThirdParty/Pygments/pygments/lexers/c

-:a3cf077a8db3
+:25f42e208e08
 pygments.lexers.c_cpp
 ~~~~~~~~~~~~~~~~~~~~~
 Lexers for C/C++ languages.
-:copyright: Copyright 2006-2019 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
 import re
 _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
 # The trailing ?, rather than *, avoids a geometric performance drop here.
 #: 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
 (r'^#if\s+0', Comment.Preproc, 'if0'),
 (r'/(\\\n)?[*][\w\W]*?[*](\\\n)?/', Comment.Multiline),
 # Open until EOF, so no ending delimeter
 (r'/(\\\n)?[*][\w\W]*', Comment.Multiline),
 ],
 'statements': [
-(r'(L?)(")', bygroups(String.Affix, String), 'string'),
+(r'([LuU]|u8)?(")', bygroups(String.Affix, String), 'string'),
-(r"(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')",
+(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),
+# Hexadecimal floating-point literals (C11, C++17)
-(r'0x[0-9a-fA-F]+[LlUu]*', Number.Hex),
+(r'0[xX](' + _hexpart + r'\.' + _hexpart + r'|\.' + _hexpart + r'|' + _hexpart + r')[pP][+-]?' + _hexpart + r'[lL]?', Number.Float),
-(r'0[0-7]+[LlUu]*', Number.Oct),
-(r'\d+[LlUu]*', Number.Integer),
+(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',
+'if', 'register', 'restricted', 'return', 'sizeof', 'struct',
-'static', 'struct', 'switch', 'typedef', 'union',
+'static', 'switch', 'typedef', 'volatile', 'while', 'union',
-'volatile', 'while'),
+'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
 (words((
 'asm', 'int8', 'based', 'except', 'int16', 'stdcall', 'cdecl',
 'fastcall', 'int32', 'declspec', 'finally', 'int64', 'try',
 'leave', 'wchar_t', 'w64', 'unaligned', 'raise', 'noop',
 '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)),
+(r'(' + _ident + r')(\s*)(:)(?!:)', bygroups(Name.Label, Text, Punctuation)),
-(r'[a-zA-Z_]\w*', Name),
+(_ident, Name)
 ],
 'root': [
 include('whitespace'),
 # functions
-(r'((?:[\w*\s])+?(?:\s|[*]))'  # return arguments
+(r'((?:' + _ident + r'(?:[&*\s])+))'  # return arguments
-r'([a-zA-Z_]\w*)'             # method name
+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'((?:' + _ident + r'(?:[&*\s])+))'  # return arguments
-r'([a-zA-Z_]\w*)'             # method name
+r'(' + _ident + r')'             # method name
 r'(\s*\([^;]*?\))'            # signature
 r'([^;]*)(;)',
 bygroups(using(this), Name.Function, using(this), using(this),
 Punctuation)),
 default('statement'),
 ],
 'statement': [
 include('whitespace'),
 include('statements'),
-('[{}]', Punctuation),
+(r'\}', Punctuation),
-(';', Punctuation, '#pop'),
+(r'[{;]', Punctuation, '#pop'),
 ],
 'function': [
 include('whitespace'),
 include('statements'),
 (';', Punctuation),
 (r'[^\\"\n]+', String),  # all other characters
 (r'\\\n', String),  # line continuation
 (r'\\', String),  # stray backslash
 ],
 'macro': [
-(r'(include)(' + _ws1 + r')([^\n]+)',
+(r'(include)('+_ws1+r')("[^"]+")([^\n]*)', bygroups(Comment.Preproc, using(this), Comment.PreprocFile, Comment.Single)),
-bygroups(Comment.Preproc, Text, Comment.PreprocFile)),
+(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'),
 (r'/', Comment.Preproc),
 (r'(?<=\\)\n', Comment.Preproc),
 'if0': [
 (r'^\s*#if.*?(?<!\\)\n', Comment.Preproc, '#push'),
 (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 = {
 '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 = {
-'_Bool', '_Complex', 'int8_t', 'int16_t', 'int32_t', 'int64_t', 'uint8_t',
+'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 = {
 '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'}
+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)
 def get_tokens_unprocessed(self, text):
 for index, token, value in \
 if token is Name:
 if self.stdlibhighlighting and value in self.stdlib_types:
 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
 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']
 filenames = ['*.c', '*.h', '*.idc']
 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(r'^\s*#include [<"]', text, re.MULTILINE):
 return 0.1
 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++']
 filenames = ['*.cpp', '*.hpp', '*.c++', '*.h++',
 '*.cc', '*.hh', '*.cxx', '*.hxx',
 mimetypes = ['text/x-c++hdr', 'text/x-c++src']
 priority = 0.1
 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',
+'try', 'typeid', 'using', 'virtual', 'constexpr', 'nullptr', 'concept',
-'constexpr', 'nullptr', 'decltype', 'thread_local',
+'decltype', 'noexcept', 'override', 'final', 'constinit', 'consteval',
-'alignas', 'alignof', 'static_assert', 'noexcept', 'override',
+'co_await', 'co_return', 'co_yield', 'requires', 'import', 'module',
-'final', 'constinit', 'consteval', 'concept', 'co_await',
+'typename'),
-'co_return', 'co_yield', 'requires', 'import', 'module'), suffix=r'\b'), Keyword),
+suffix=r'\b'), Keyword),
 (r'char(16_t|32_t|8_t)\b', Keyword.Type),
-(r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
+(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': [
 inherit,
 # C++ Microsoft-isms
 'multiple_inheritance', 'interface', 'event'),
 prefix=r'__', suffix=r'\b'), Keyword.Reserved),
 # Offload C++ extensions, http://offload.codeplay.com/
 (r'__(offload|blockingoffload|outer)\b', Keyword.Pseudo),
 ],
-'classname': [
+'enumname': [
-(r'[a-zA-Z_]\w*', Name.Class, '#pop'),
+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):
 if re.search('#include <[a-z_]+>', text):
 return 0.2

Mercurial Repositories > eric / file comparison

comparison: eric6/ThirdParty/Pygments/pygments/lexers/c_cpp.py

eric6/ThirdParty/Pygments/pygments/lexers/c_cpp.py