mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-08-02 11:54:27 +02:00
Code Issues Packages Projects Releases Wiki Activity

apply python format

Browse Source
This commit is contained in:
Markus Hofbauer
2022-05-12 13:58:32 +02:00
parent 08ceb4c8db
commit 42072cc7c5
3 changed files with 468 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
build.py
View File

@@ -33,12 +33,10 @@ if __name__ == "__main__":
# package id # package id
channel="testing", channel="testing",
stable_branch_pattern=r"v\d+\.\d+\.\d+.*", stable_branch_pattern=r"v\d+\.\d+\.\d+.*",
# dependencies # dependencies
build_policy=["mp-units", "outdated"], build_policy=["mp-units", "outdated"],
upload_dependencies="all", upload_dependencies="all",
pip_install=["sphinx", "recommonmark", "breathe"], pip_install=["sphinx", "recommonmark", "breathe"],
# build configurations # build configurations
archs=["x86_64"], # limit to 64-bit only archs=["x86_64"], # limit to 64-bit only
) )

53
conanfile.py
View File

@@ -24,7 +24,10 @@ from conan import ConanFile
from conan.tools.cmake import CMakeToolchain, CMakeDeps, CMake from conan.tools.cmake import CMakeToolchain, CMakeDeps, CMake
from conan.tools.files import copy, load, rmdir from conan.tools.files import copy, load, rmdir
from conan.tools.scm import Version from conan.tools.scm import Version
from conans.tools import get_env, check_min_cppstd # TODO replace with new tools for Conan 2.0 from conans.tools import (
get_env,
check_min_cppstd,
) # TODO replace with new tools for Conan 2.0
import os, re import os, re
required_conan_version = ">=1.48.0" required_conan_version = ">=1.48.0"
@@ -50,19 +53,18 @@ class MPUnitsConan(ConanFile):
license = "MIT" license = "MIT"
url = "https://github.com/mpusz/units" url = "https://github.com/mpusz/units"
settings = "os", "compiler", "build_type", "arch" settings = "os", "compiler", "build_type", "arch"
requires = ( requires = "gsl-lite/0.40.0"
"gsl-lite/0.40.0" options = {"downcast_mode": ["off", "on", "auto"], "build_docs": [True, False]}
) default_options = {"downcast_mode": "on", "build_docs": True}
options = {
"downcast_mode": ["off", "on", "auto"],
"build_docs": [True, False]
}
default_options = {
"downcast_mode": "on",
"build_docs": True
}
exports = ["LICENSE.md"] exports = ["LICENSE.md"]
exports_sources = ["docs/*", "src/*", "test/*", "cmake/*", "example/*", "CMakeLists.txt"] exports_sources = [
"docs/*",
"src/*",
"test/*",
"cmake/*",
"example/*",
"CMakeLists.txt",
]
no_copy_source = True no_copy_source = True
generators = "cmake_paths" generators = "cmake_paths"
@@ -74,9 +76,9 @@ class MPUnitsConan(ConanFile):
def _use_libfmt(self): def _use_libfmt(self):
compiler = self.settings.compiler compiler = self.settings.compiler
version = Version(self.settings.compiler.version) version = Version(self.settings.compiler.version)
std_support = \ std_support = (
(compiler == "Visual Studio" and version >= 17 and compiler.cppstd == 23) or \ compiler == "Visual Studio" and version >= 17 and compiler.cppstd == 23
(compiler == "msvc" and version >= 193 and compiler.cppstd == 23) ) or (compiler == "msvc" and version >= 193 and compiler.cppstd == 23)
return not std_support return not std_support
@property @property
@@ -95,7 +97,9 @@ class MPUnitsConan(ConanFile):
def set_version(self): def set_version(self):
content = load(self, os.path.join(self.recipe_folder, "src/CMakeLists.txt")) content = load(self, os.path.join(self.recipe_folder, "src/CMakeLists.txt"))
version = re.search(r"project\([^\)]+VERSION (\d+\.\d+\.\d+)[^\)]*\)", content).group(1) version = re.search(
r"project\([^\)]+VERSION (\d+\.\d+\.\d+)[^\)]*\)", content
).group(1)
self.version = version.strip() self.version = version.strip()
def requirements(self): def requirements(self):
@@ -124,10 +128,14 @@ class MPUnitsConan(ConanFile):
raise ConanInvalidConfiguration("mp-units requires at least clang++-12") raise ConanInvalidConfiguration("mp-units requires at least clang++-12")
elif compiler == "apple-clang": elif compiler == "apple-clang":
if version < 13: if version < 13:
raise ConanInvalidConfiguration("mp-units requires at least AppleClang 13") raise ConanInvalidConfiguration(
"mp-units requires at least AppleClang 13"
)
elif compiler == "Visual Studio": elif compiler == "Visual Studio":
if version < 16: if version < 16:
raise ConanInvalidConfiguration("mp-units requires at least Visual Studio 16.9") raise ConanInvalidConfiguration(
"mp-units requires at least Visual Studio 16.9"
)
elif compiler == "msvc": elif compiler == "msvc":
if self._msvc_version < 1928: if self._msvc_version < 1928:
raise ConanInvalidConfiguration("mp-units requires at least MSVC 19.28") raise ConanInvalidConfiguration("mp-units requires at least MSVC 19.28")
@@ -162,7 +170,12 @@ class MPUnitsConan(ConanFile):
self.info.header_only() self.info.header_only()
def package(self): def package(self):
copy(self, "LICENSE.md", self.source_folder, os.path.join(self.package_folder, "licenses")) copy(
self,
"LICENSE.md",
self.source_folder,
os.path.join(self.package_folder, "licenses"),
)
cmake = CMake(self) cmake = CMake(self)
cmake.install() cmake.install()
rmdir(self, os.path.join(self.package_folder, "lib", "cmake")) rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))

612
docs/conf.py
View File

@@ -12,152 +12,311 @@
import re import re
import sphinx_rtd_theme import sphinx_rtd_theme
from pygments.lexer import RegexLexer, include, bygroups, using, \ from pygments.lexer import (
this, inherit, default, words RegexLexer,
include,
bygroups,
using,
this,
inherit,
default,
words,
)
from pygments.util import get_bool_opt from pygments.util import get_bool_opt
from pygments.token import Text, Comment, Operator, Keyword, Name, String, \ from pygments.token import (
Number, Punctuation, Error Text,
Comment,
Operator,
Keyword,
Name,
String,
Number,
Punctuation,
Error,
)
from sphinx.highlighting import lexers from sphinx.highlighting import lexers
class MyCFamilyLexer(RegexLexer): class MyCFamilyLexer(RegexLexer):
#: optional Comment or Whitespace #: optional Comment or Whitespace
_ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+' _ws = r"(?:\s|//.*?\n|/[*].*?[*]/)+"
# The trailing ?, rather than *, avoids a geometric performance drop here. # The trailing ?, rather than *, avoids a geometric performance drop here.
#: only one /* */ style comment #: only one /* */ style comment
_ws1 = r'\s*(?:/[*].*?[*]/\s*)?' _ws1 = r"\s*(?:/[*].*?[*]/\s*)?"
tokens = { tokens = {
'whitespace': [ "whitespace": [
# preprocessor directives: without whitespace # preprocessor directives: without whitespace
(r'^#if\s+0', Comment.Preproc, 'if0'), (r"^#if\s+0", Comment.Preproc, "if0"),
('^#', Comment.Preproc, 'macro'), ("^#", Comment.Preproc, "macro"),
# or with whitespace # or with whitespace
('^(' + _ws1 + r')(#if\s+0)', (
bygroups(using(this), Comment.Preproc), 'if0'), "^(" + _ws1 + r")(#if\s+0)",
('^(' + _ws1 + ')(#)', bygroups(using(this), Comment.Preproc),
bygroups(using(this), Comment.Preproc), 'macro'), "if0",
(r'\n', Text), ),
(r'\s+', Text), ("^(" + _ws1 + ")(#)", bygroups(using(this), Comment.Preproc), "macro"),
(r'\\\n', Text), # line continuation (r"\n", Text),
(r'//(\n|[\w\W]*?[^\\]\n)', Comment.Single), (r"\s+", Text),
(r'/(\\\n)?[*][\w\W]*?[*](\\\n)?/', Comment.Multiline), (r"\\\n", Text), # line continuation
(r"//(\n|[\w\W]*?[^\\]\n)", Comment.Single),
(r"/(\\\n)?[*][\w\W]*?[*](\\\n)?/", Comment.Multiline),
# Open until EOF, so no ending delimeter # Open until EOF, so no ending delimeter
(r'/(\\\n)?[*][\w\W]*', Comment.Multiline), (r"/(\\\n)?[*][\w\W]*", Comment.Multiline),
], ],
'statements': [ "statements": [
(r'(L?)(")', bygroups(String.Affix, String), 'string'), (r'(L?)(")', bygroups(String.Affix, String), "string"),
(r"(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')", (
bygroups(String.Affix, String.Char, String.Char, String.Char)), r"(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')",
(r'\*/', Error), bygroups(String.Affix, String.Char, String.Char, String.Char),
(r'[~!%^&*+=|?:<>/-]', Operator), ),
(r'[()\[\],.]', Punctuation), (r"\*/", Error),
(words(('asm', 'auto', 'break', 'case', 'const', 'continue', (r"[~!%^&*+=|?:<>/-]", Operator),
'default', 'do', 'else', 'enum', 'extern', 'for', 'goto', (r"[()\[\],.]", Punctuation),
'if', 'register', 'restricted', 'return', 'sizeof', (
'static', 'struct', 'switch', 'typedef', 'union', words(
'volatile', 'while'), (
suffix=r'\b'), Keyword), "asm",
(r'(bool|int|long|float|short|double|char|unsigned|signed|void)\b', "auto",
Keyword.Type), "break",
(words(('inline', '_inline', '__inline', 'naked', 'restrict', "case",
'thread', 'typename'), suffix=r'\b'), Keyword.Reserved), "const",
"continue",
"default",
"do",
"else",
"enum",
"extern",
"for",
"goto",
"if",
"register",
"restricted",
"return",
"sizeof",
"static",
"struct",
"switch",
"typedef",
"union",
"volatile",
"while",
),
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,
),
# Vector intrinsics # Vector intrinsics
(r'(__m(128i|128d|128|64))\b', Keyword.Reserved), (r"(__m(128i|128d|128|64))\b", Keyword.Reserved),
# Microsoft-isms # Microsoft-isms
(words(( (
'asm', 'int8', 'based', 'except', 'int16', 'stdcall', 'cdecl', words(
'fastcall', 'int32', 'declspec', 'finally', 'int64', 'try', (
'leave', 'wchar_t', 'w64', 'unaligned', 'raise', 'noop', "asm",
'identifier', 'forceinline', 'assume'), "int8",
prefix=r'__', suffix=r'\b'), Keyword.Reserved), "based",
(r'(true|false|NULL)\b', Name.Builtin), "except",
(r'([a-zA-Z_]\w*)(\s*)(:)(?!:)', bygroups(Name.Label, Text, Punctuation)), "int16",
(r'[a-zA-Z_]\w*', Name), "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"[a-zA-Z_]\w*", Name),
], ],
'root': [ "root": [
include('whitespace'), include("whitespace"),
# functions # functions
(r'((?:[\w*\s])+?(?:\s|[*]))' # return arguments (
r'([a-zA-Z_]\w*)' # method name r"((?:[\w*\s])+?(?:\s|[*]))" # return arguments
r'(\s*\([^;]*?\))' # signature r"([a-zA-Z_]\w*)" # method name
r'([^;{]*)(\{)', r"(\s*\([^;]*?\))" # signature
bygroups(using(this), Name.Function, using(this), using(this), r"([^;{]*)(\{)",
Punctuation), bygroups(
'function'), using(this), Name.Function, using(this), using(this), Punctuation
),
"function",
),
# function declarations # function declarations
(r'((?:[\w*\s])+?(?:\s|[*]))' # return arguments (
r'([a-zA-Z_]\w*)' # method name r"((?:[\w*\s])+?(?:\s|[*]))" # return arguments
r'(\s*\([^;]*?\))' # signature r"([a-zA-Z_]\w*)" # method name
r'([^;]*)(;)', r"(\s*\([^;]*?\))" # signature
bygroups(using(this), Name.Function, using(this), using(this), r"([^;]*)(;)",
Punctuation)), bygroups(
default('statement'), using(this), Name.Function, using(this), using(this), Punctuation
),
),
default("statement"),
], ],
'statement': [ "statement": [
include('whitespace'), include("whitespace"),
include('statements'), include("statements"),
('[{}]', Punctuation), ("[{}]", Punctuation),
(';', Punctuation, '#pop'), (";", Punctuation, "#pop"),
], ],
'function': [ "function": [
include('whitespace'), include("whitespace"),
include('statements'), include("statements"),
(';', Punctuation), (";", Punctuation),
(r'\{', Punctuation, '#push'), (r"\{", Punctuation, "#push"),
(r'\}', Punctuation, '#pop'), (r"\}", Punctuation, "#pop"),
], ],
'string': [ "string": [
(r'"', String, '#pop'), (r'"', String, "#pop"),
(r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|' (
r'u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})', String.Escape), r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|'
r"u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})",
String.Escape,
),
(r'[^\\"\n]+', String), # all other characters (r'[^\\"\n]+', String), # all other characters
(r'\\\n', String), # line continuation (r"\\\n", String), # line continuation
(r'\\', String), # stray backslash (r"\\", String), # stray backslash
], ],
'macro': [ "macro": [
(r'(include)(' + _ws1 + r')([^\n]+)', (
bygroups(Comment.Preproc, Text, Comment.PreprocFile)), r"(include)(" + _ws1 + r")([^\n]+)",
(r'[^/\n]+', Comment.Preproc), bygroups(Comment.Preproc, Text, Comment.PreprocFile),
(r'/[*](.|\n)*?[*]/', Comment.Multiline), ),
(r'//.*?\n', Comment.Single, '#pop'), (r"[^/\n]+", Comment.Preproc),
(r'/', Comment.Preproc), (r"/[*](.|\n)*?[*]/", Comment.Multiline),
(r'(?<=\\)\n', Comment.Preproc), (r"//.*?\n", Comment.Single, "#pop"),
(r'\n', Comment.Preproc, '#pop'), (r"/", Comment.Preproc),
(r"(?<=\\)\n", Comment.Preproc),
(r"\n", Comment.Preproc, "#pop"),
],
"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),
], ],
'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),
]
} }
stdlib_types = { stdlib_types = {
'size_t', 'ssize_t', 'off_t', 'wchar_t', 'ptrdiff_t', 'sig_atomic_t', 'fpos_t', "size_t",
'clock_t', 'time_t', 'va_list', 'jmp_buf', 'FILE', 'DIR', 'div_t', 'ldiv_t', "ssize_t",
'mbstate_t', 'wctrans_t', 'wint_t', 'wctype_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 = { c99_types = {
'_Bool', '_Complex', 'int8_t', 'int16_t', 'int32_t', 'int64_t', 'uint8_t', "_Bool",
'uint16_t', 'uint32_t', 'uint64_t', 'int_least8_t', 'int_least16_t', "_Complex",
'int_least32_t', 'int_least64_t', 'uint_least8_t', 'uint_least16_t', "int8_t",
'uint_least32_t', 'uint_least64_t', 'int_fast8_t', 'int_fast16_t', 'int_fast32_t', "int16_t",
'int_fast64_t', 'uint_fast8_t', 'uint_fast16_t', 'uint_fast32_t', 'uint_fast64_t', "int32_t",
'intptr_t', 'uintptr_t', 'intmax_t', 'uintmax_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 = { linux_types = {
'clockid_t', 'cpu_set_t', 'cpumask_t', 'dev_t', 'gid_t', 'id_t', 'ino_t', 'key_t', "clockid_t",
'mode_t', 'nfds_t', 'pid_t', 'rlim_t', 'sig_t', 'sighandler_t', 'siginfo_t', "cpu_set_t",
'sigset_t', 'sigval_t', 'socklen_t', 'timer_t', 'uid_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",
}
def __init__(self, **options): def __init__(self, **options):
self.stdlibhighlighting = get_bool_opt(options, 'stdlibhighlighting', True) self.stdlibhighlighting = get_bool_opt(options, "stdlibhighlighting", True)
self.c99highlighting = get_bool_opt(options, 'c99highlighting', True) self.c99highlighting = get_bool_opt(options, "c99highlighting", True)
self.platformhighlighting = get_bool_opt(options, 'platformhighlighting', True) self.platformhighlighting = get_bool_opt(options, "platformhighlighting", True)
RegexLexer.__init__(self, **options) RegexLexer.__init__(self, **options)
def get_tokens_unprocessed(self, text): def get_tokens_unprocessed(self, text):
for index, token, value in \ for index, token, value in RegexLexer.get_tokens_unprocessed(self, text):
RegexLexer.get_tokens_unprocessed(self, text):
if token is Name: if token is Name:
if self.stdlibhighlighting and value in self.stdlib_types: if self.stdlibhighlighting and value in self.stdlib_types:
token = Keyword.Type token = Keyword.Type
@@ -172,65 +331,147 @@ class MyCppLexer(MyCFamilyLexer):
""" """
For C++ source code with preprocessor directives. For C++ source code with preprocessor directives.
""" """
name = 'My C++'
aliases = ['cpp', 'c++'] name = "My C++"
filenames = ['*.cpp', '*.hpp', '*.c++', '*.h++', aliases = ["cpp", "c++"]
'*.cc', '*.hh', '*.cxx', '*.hxx', filenames = [
'*.C', '*.H', '*.cp', '*.CPP'] "*.cpp",
mimetypes = ['text/x-c++hdr', 'text/x-c++src'] "*.hpp",
"*.c++",
"*.h++",
"*.cc",
"*.hh",
"*.cxx",
"*.hxx",
"*.C",
"*.H",
"*.cp",
"*.CPP",
]
mimetypes = ["text/x-c++hdr", "text/x-c++src"]
priority = 0.1 priority = 0.1
tokens = { tokens = {
'statements': [ "statements": [
(words(( (
'catch', 'const_cast', 'delete', 'dynamic_cast', 'explicit', words(
'export', 'friend', 'mutable', 'namespace', 'new', 'operator', (
'private', 'protected', 'public', 'reinterpret_cast', "catch",
'restrict', 'static_cast', 'template', 'this', 'throw', 'throws', "const_cast",
'try', 'typeid', 'typename', 'using', 'virtual', "delete",
'constexpr', 'nullptr', 'decltype', 'thread_local', "dynamic_cast",
'alignas', 'alignof', 'static_assert', 'noexcept', 'override', "explicit",
'final', 'constinit', 'consteval', 'constinit', 'concept', 'co_await', "export",
'co_return', 'co_yield', 'requires', 'import', 'module'), suffix=r'\b'), Keyword), "friend",
(r'char(16_t|32_t|8_t)\b', Keyword.Type), "mutable",
(r'(class)(\s+)', bygroups(Keyword, Text), 'classname'), "namespace",
"new",
"operator",
"private",
"protected",
"public",
"reinterpret_cast",
"restrict",
"static_cast",
"template",
"this",
"throw",
"throws",
"try",
"typeid",
"typename",
"using",
"virtual",
"constexpr",
"nullptr",
"decltype",
"thread_local",
"alignas",
"alignof",
"static_assert",
"noexcept",
"override",
"final",
"constinit",
"consteval",
"constinit",
"concept",
"co_await",
"co_return",
"co_yield",
"requires",
"import",
"module",
),
suffix=r"\b",
),
Keyword,
),
(r"char(16_t|32_t|8_t)\b", Keyword.Type),
(r"(class)(\s+)", bygroups(Keyword, Text), "classname"),
# C++11 raw strings # C++11 raw strings
(r'(R)(")([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(")', (
bygroups(String.Affix, String, String.Delimiter, String.Delimiter, r'(R)(")([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(")',
String, String.Delimiter, String)), bygroups(
String.Affix,
String,
String.Delimiter,
String.Delimiter,
String,
String.Delimiter,
String,
),
),
# C++11 UTF-8/16/32 strings # C++11 UTF-8/16/32 strings
(r'(u8|u|U)(")', bygroups(String.Affix, String), 'string'), (r'(u8|u|U)(")', bygroups(String.Affix, String), "string"),
# C++14 number separators # C++14 number separators
(r'(\d[\d\']*\.[\d\']*|\.\d[\d\']*|\d[\d\']*)[eE][+-]?\d[\d\']*[LlUu]*', Number.Float), (
(r'(\d[\d\']*\.[\d\']*|\.\d[\d\']*|\d[\d\']*[fF])[fF]?', Number.Float), r"(\d[\d\']*\.[\d\']*|\.\d[\d\']*|\d[\d\']*)[eE][+-]?\d[\d\']*[LlUu]*",
(r'0x[0-9a-fA-F\']+[LlUu]*', Number.Hex), Number.Float,
(r'0[0-7\']+[LlUu]*', Number.Oct), ),
(r'\d[\d\']*[LlUu]*', Number.Integer), (r"(\d[\d\']*\.[\d\']*|\.\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[\d\']*[LlUu]*", Number.Integer),
inherit, inherit,
], ],
'root': [ "root": [
inherit, inherit,
# C++ Microsoft-isms # C++ Microsoft-isms
(words(('virtual_inheritance', 'uuidof', 'super', 'single_inheritance', (
'multiple_inheritance', 'interface', 'event'), words(
prefix=r'__', suffix=r'\b'), Keyword.Reserved), (
"virtual_inheritance",
"uuidof",
"super",
"single_inheritance",
"multiple_inheritance",
"interface",
"event",
),
prefix=r"__",
suffix=r"\b",
),
Keyword.Reserved,
),
# Offload C++ extensions, http://offload.codeplay.com/ # Offload C++ extensions, http://offload.codeplay.com/
(r'__(offload|blockingoffload|outer)\b', Keyword.Pseudo), (r"__(offload|blockingoffload|outer)\b", Keyword.Pseudo),
], ],
'classname': [ "classname": [
(r'[a-zA-Z_]\w*', Name.Class, '#pop'), (r"[a-zA-Z_]\w*", Name.Class, "#pop"),
# template specification # template specification
(r'\s*(?=>)', Text, '#pop'), (r"\s*(?=>)", Text, "#pop"),
], ],
} }
def analyse_text(text): def analyse_text(text):
if re.search('#include <[a-z_]+>', text): if re.search("#include <[a-z_]+>", text):
return 0.2 return 0.2
if re.search('using namespace ', text): if re.search("using namespace ", text):
return 0.4 return 0.4
lexers['cpp'] = MyCppLexer(startinline=True)
lexers["cpp"] = MyCppLexer(startinline=True)
# TODO Remove the above when Pygments release with fixes is available # TODO Remove the above when Pygments release with fixes is available
@@ -243,11 +484,14 @@ lexers['cpp'] = MyCppLexer(startinline=True)
import subprocess, os, re import subprocess, os, re
def get_version(): def get_version():
try: try:
with open('../src/CMakeLists.txt', 'r') as file: with open("../src/CMakeLists.txt", "r") as file:
content = file.read() content = file.read()
version = re.search(r"project\([^\)]+VERSION (\d+\.\d+\.\d+)[^\)]*\)", content).group(1) version = re.search(
r"project\([^\)]+VERSION (\d+\.\d+\.\d+)[^\)]*\)", content
).group(1)
return version.strip() return version.strip()
except Exception: except Exception:
return None return None
@@ -255,9 +499,9 @@ def get_version():
# -- Project information ----------------------------------------------------- # -- Project information -----------------------------------------------------
project = 'mp-units' project = "mp-units"
copyright = '2018-present, Mateusz Pusz' copyright = "2018-present, Mateusz Pusz"
author = 'Mateusz Pusz' author = "Mateusz Pusz"
# The major project version, used as the replacement for |version|. # The major project version, used as the replacement for |version|.
version = get_version() version = get_version()
@@ -270,21 +514,21 @@ release = get_version()
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones. # ones.
extensions = [ extensions = [
'sphinx.ext.autosectionlabel', "sphinx.ext.autosectionlabel",
'sphinx.ext.githubpages', "sphinx.ext.githubpages",
'sphinx.ext.graphviz', "sphinx.ext.graphviz",
'sphinx_rtd_theme', "sphinx_rtd_theme",
'recommonmark', "recommonmark",
'breathe' "breathe",
] ]
# Add any paths that contain templates here, relative to this directory. # Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates'] templates_path = ["_templates"]
# List of patterns, relative to source directory, that match files and # List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files. # directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path. # This pattern also affects html_static_path and html_extra_path.
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
# If true, Sphinx will warn about all references where the target cannot # If true, Sphinx will warn about all references where the target cannot
# be found. Default is False. # be found. Default is False.
@@ -305,29 +549,29 @@ autosectionlabel_prefix_document = True
# The name of the default domain. Can also be None to disable a default # The name of the default domain. Can also be None to disable a default
# domain. The default is 'py'. # domain. The default is 'py'.
primary_domain = 'cpp' primary_domain = "cpp"
# The reST default role (used for this markup: `text`) to use for all documents. # The reST default role (used for this markup: `text`) to use for all documents.
default_role = 'cpp:any' default_role = "cpp:any"
# The default language to highlight source code in. The default is 'python3'. # The default language to highlight source code in. The default is 'python3'.
# The value should be a valid Pygments lexer name (https://pygments.org/docs/lexers). # The value should be a valid Pygments lexer name (https://pygments.org/docs/lexers).
highlight_language = 'cpp' highlight_language = "cpp"
# The style name to use for Pygments highlighting of source code. If not set, # The style name to use for Pygments highlighting of source code. If not set,
# either the theme’s default style or 'sphinx' is selected for HTML output. # either the theme’s default style or 'sphinx' is selected for HTML output.
pygments_style = 'default' pygments_style = "default"
# A list of prefixes that will be ignored when sorting C++ objects in the global # A list of prefixes that will be ignored when sorting C++ objects in the global
# index. For example ['awesome_lib::']. # index. For example ['awesome_lib::'].
cpp_index_common_prefix = ['units::'] cpp_index_common_prefix = ["units::"]
# -- Options for HTML output ------------------------------------------------- # -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for # The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes. # a list of builtin themes.
html_theme = 'sphinx_rtd_theme' html_theme = "sphinx_rtd_theme"
# A dictionary of options that influence the look and feel of the selected theme. # A dictionary of options that influence the look and feel of the selected theme.
# These are theme-specific. # These are theme-specific.
@@ -339,7 +583,7 @@ html_theme_options = {
# Add any paths that contain custom static files (such as style sheets) here, # Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files, # relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css". # so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static'] html_static_path = ["_static"]
# If given, this must be the name of an image file (path relative to the # If given, this must be the name of an image file (path relative to the
# configuration directory) that is the logo of the docs. It is placed at the # configuration directory) that is the logo of the docs. It is placed at the
@@ -349,40 +593,40 @@ html_static_path = ['_static']
# These paths are either relative to html_static_path or fully qualified # These paths are either relative to html_static_path or fully qualified
# paths (eg. https://...) # paths (eg. https://...)
html_css_files = [ html_css_files = ["css/custom.css"]
'css/custom.css'
]
# -- Breathe configuration --------------------------------------------------- # -- Breathe configuration ---------------------------------------------------
def configureDoxyfile(input_dir, output_dir): def configureDoxyfile(input_dir, output_dir):
with open('Doxyfile.in', 'r') as file: with open("Doxyfile.in", "r") as file:
filedata = file.read() filedata = file.read()
filedata = filedata.replace('@DOXYGEN_INPUT_DIR@', input_dir) filedata = filedata.replace("@DOXYGEN_INPUT_DIR@", input_dir)
filedata = filedata.replace('@DOXYGEN_OUTPUT_DIR@', output_dir) filedata = filedata.replace("@DOXYGEN_OUTPUT_DIR@", output_dir)
with open('Doxyfile', 'w') as file: with open("Doxyfile", "w") as file:
file.write(filedata) file.write(filedata)
# Check if we're running on Read the Docs' servers # Check if we're running on Read the Docs' servers
read_the_docs_build = os.environ.get('READTHEDOCS', None) == 'True' read_the_docs_build = os.environ.get("READTHEDOCS", None) == "True"
# This should be a dictionary in which the keys are project names and the values # This should be a dictionary in which the keys are project names and the values
# are paths to the folder containing the doxygen output for that project. # are paths to the folder containing the doxygen output for that project.
breathe_projects = {} breathe_projects = {}
if read_the_docs_build: if read_the_docs_build:
input_dir = '../src' input_dir = "../src"
output_dir = 'build' output_dir = "build"
configureDoxyfile(input_dir, output_dir) configureDoxyfile(input_dir, output_dir)
subprocess.call('doxygen', shell=True) subprocess.call("doxygen", shell=True)
breathe_projects['mp-units'] = output_dir + '/xml' breathe_projects["mp-units"] = output_dir + "/xml"
# This should match one of the keys in the breathe_projects dictionary and # This should match one of the keys in the breathe_projects dictionary and
# indicates which project should be used when the project is not specified on # indicates which project should be used when the project is not specified on
# the directive. # the directive.
breathe_default_project = 'mp-units' breathe_default_project = "mp-units"
# Allows you to specify domains for particular files according to their extension. # Allows you to specify domains for particular files according to their extension.
breathe_domain_by_extension = {"h": "cpp"} breathe_domain_by_extension = {"h": "cpp"}
@@ -390,4 +634,4 @@ breathe_domain_by_extension = {"h" : "cpp"}
# Provides the directive flags that should be applied to all directives which # Provides the directive flags that should be applied to all directives which
# take :members:, :private-members: and :undoc-members: options. By default, # take :members:, :private-members: and :undoc-members: options. By default,
# this is set to an empty list, which means no members are displayed. # this is set to an empty list, which means no members are displayed.
breathe_default_members = ('members', ) breathe_default_members = ("members",)