# -*- coding: utf-8 -*- """ pygments.lexers.c_cpp ~~~~~~~~~~~~~~~~~~~~~ Lexers for C/C++ languages. :copyright: Copyright 2006-2019 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ import re import sphinx_rtd_theme 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, Error, ) from sphinx.highlighting import lexers class MyCFamilyLexer(RegexLexer): #: optional Comment or Whitespace _ws = r"(?:\s|//.*?\n|/[*].*?[*]/)+" # The trailing ?, rather than *, avoids a geometric performance drop here. #: only one /* */ style comment _ws1 = r"\s*(?:/[*].*?[*]/\s*)?" tokens = { "whitespace": [ # preprocessor directives: without whitespace (r"^#if\s+0", Comment.Preproc, "if0"), ("^#", Comment.Preproc, "macro"), # or with whitespace ( "^(" + _ws1 + r")(#if\s+0)", bygroups(using(this), Comment.Preproc), "if0", ), ("^(" + _ws1 + ")(#)", bygroups(using(this), Comment.Preproc), "macro"), (r"\n", Text), (r"\s+", Text), (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 (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])(')", bygroups(String.Affix, String.Char, String.Char, String.Char), ), (r"\*/", Error), (r"[~!%^&*+=|?:<>/-]", Operator), (r"[()\[\],.]", Punctuation), ( 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", ), 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 (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"[a-zA-Z_]\w*", Name), ], "root": [ include("whitespace"), # functions ( r"((?:[\w*\s])+?(?:\s|[*]))" # return arguments r"([a-zA-Z_]\w*)" # 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"(\s*\([^;]*?\))" # signature r"([^;]*)(;)", bygroups( using(this), Name.Function, using(this), using(this), Punctuation ), ), default("statement"), ], "statement": [ include("whitespace"), include("statements"), ("[{}]", Punctuation), (";", Punctuation, "#pop"), ], "function": [ include("whitespace"), include("statements"), (";", Punctuation), (r"\{", Punctuation, "#push"), (r"\}", Punctuation, "#pop"), ], "string": [ (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'[^\\"\n]+', String), # all other characters (r"\\\n", String), # line continuation (r"\\", String), # stray backslash ], "macro": [ ( r"(include)(" + _ws1 + r")([^\n]+)", bygroups(Comment.Preproc, Text, Comment.PreprocFile), ), (r"[^/\n]+", Comment.Preproc), (r"/[*](.|\n)*?[*]/", Comment.Multiline), (r"//.*?\n", Comment.Single, "#pop"), (r"/", Comment.Preproc), (r"(?<=\\)\n", Comment.Preproc), (r"\n", Comment.Preproc, "#pop"), ], "if0": [ (r"^\s*#if.*?(?)", Text, "#pop"), ], } def analyse_text(text): if re.search("#include <[a-z_]+>", text): return 0.2 if re.search("using namespace ", text): return 0.4 lexers["cpp"] = MyCppLexer(startinline=True) # TODO Remove the above when Pygments release with fixes is available # Configuration file for the Sphinx documentation builder. # # This file only contains a selection of the most common options. # For a full list see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html import subprocess, os, re def get_version(): try: with open("../src/CMakeLists.txt", "r") as file: content = file.read() version = re.search( r"project\([^\)]+VERSION (\d+\.\d+\.\d+)[^\)]*\)", content ).group(1) return version.strip() except Exception: return None # -- Project information ----------------------------------------------------- project = "mp-units" copyright = "2018-present, Mateusz Pusz" author = "Mateusz Pusz" # The major project version, used as the replacement for |version|. version = get_version() # The full project version, used as the replacement for |release| and # e.g. in the HTML templates. release = get_version() # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ "sphinx.ext.autosectionlabel", "sphinx.ext.githubpages", "sphinx.ext.graphviz", "sphinx_rtd_theme", "recommonmark", "breathe", ] # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] # If true, Sphinx will warn about all references where the target cannot # be found. Default is False. nitpicky = True # A list of (type, target) tuples (by default empty) that should be ignored # when generating warnings in “nitpicky mode”. Note that type should include # the domain name if present. Example entries would be ('py:func', 'int') # or ('envvar', 'LD_LIBRARY_PATH'). nitpick_ignore = [] # True to prefix each section label with the name of the document it is in, # followed by a colon. Useful for avoiding ambiguity when the same section # heading appears in different documents. autosectionlabel_prefix_document = True # -- C++ configuration --------------------------------------------------- # The name of the default domain. Can also be None to disable a default # domain. The default is 'py'. primary_domain = "cpp" # The reST default role (used for this markup: `text`) to use for all documents. default_role = "cpp:any" # 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). highlight_language = "cpp" # 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. pygments_style = "default" # A list of prefixes that will be ignored when sorting C++ objects in the global # index. For example ['awesome_lib::']. cpp_index_common_prefix = ["units::"] # -- Options for HTML output ------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = "sphinx_rtd_theme" # A dictionary of options that influence the look and feel of the selected theme. # These are theme-specific. html_theme_options = { # WARNING: unsupported theme option 'github_url' given # 'github_url': 'https://github.com/mpusz/units' } # 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, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ["_static"] # 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 # top of the sidebar; its width should therefore not exceed 200 pixels. # Default: None. # html_logo = # These paths are either relative to html_static_path or fully qualified # paths (eg. https://...) html_css_files = ["css/custom.css"] # -- Breathe configuration --------------------------------------------------- def configureDoxyfile(input_dir, output_dir): with open("Doxyfile.in", "r") as file: filedata = file.read() filedata = filedata.replace("@DOXYGEN_INPUT_DIR@", input_dir) filedata = filedata.replace("@DOXYGEN_OUTPUT_DIR@", output_dir) with open("Doxyfile", "w") as file: file.write(filedata) # Check if we're running on Read the Docs' servers 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 # are paths to the folder containing the doxygen output for that project. breathe_projects = {} if read_the_docs_build: input_dir = "../src" output_dir = "build" configureDoxyfile(input_dir, output_dir) subprocess.call("doxygen", shell=True) breathe_projects["mp-units"] = output_dir + "/xml" # 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 # the directive. breathe_default_project = "mp-units" # Allows you to specify domains for particular files according to their extension. breathe_domain_by_extension = {"h": "cpp"} # Provides the directive flags that should be applied to all directives which # take :members:, :private-members: and :undoc-members: options. By default, # this is set to an empty list, which means no members are displayed. breathe_default_members = ("members",)