Merge commit '2abfcd02f1868bc12b5b0934101d2845c41e3cf5' into dev

external/fmt/support/Vagrantfile

@@ -3,10 +3,9 @@
 
 # A vagrant config for testing against gcc-4.8.
 Vagrant.configure("2") do |config|
-  config.vm.box = "ubuntu/xenial64"
-  config.disksize.size = '15GB'
+  config.vm.box = "bento/ubuntu-22.04-arm64"
 
-  config.vm.provider "virtualbox" do |vb|
+  config.vm.provider "vmware_desktop" do |vb|
     vb.memory = "4096"
   end
 

external/fmt/support/bazel/.bazelversion

@@ -1 +1 @@
-7.0.0
+7.1.2

external/fmt/support/bazel/BUILD.bazel

@@ -8,6 +8,10 @@ cc_library(
     hdrs = glob([
         "include/fmt/*.h",
     ]),
+    copts = select({
+        "@platforms//os:windows": ["-utf-8"],
+        "//conditions:default": [],
+    }),
     includes = [
         "include",
     ],

external/fmt/support/bazel/MODULE.bazel

@@ -2,3 +2,5 @@ module(
    name = "fmt",
    compatibility_level = 10,
 )
+
+bazel_dep(name = "platforms", version = "0.0.10")

external/fmt/support/bazel/README.md

@@ -16,6 +16,8 @@ For instance, to use {fmt} add to your `MODULE.bazel` file:
 bazel_dep(name = "fmt", version = "10.2.1")
 ```
 
+### Live at head
+
 For a live-at-head approach, you can copy the contents of this repository and move the Bazel-related build files to the root folder of this project as described above and make use of `local_path_override`, e.g.:
 
 ```
@@ -24,72 +26,3 @@ local_path_override(
     path = "../third_party/fmt",
 )
 ```
-
-### WORKSPACE system
-
-The following minimal example shows how to use {fmt} as a dependency within a Bazel project,
-that uses the traditional, repository-focused WORKSPACE system.
-Note that in the long term Bazel will only support Bzlmod.
-
-The following file structure is assumed:
-
-```
-example
-├── BUILD.bazel
-├── main.cpp
-└── WORKSPACE.bazel
-```
-
-*main.cpp*:
-
-```c++
-#include "fmt/core.h"
-
-int main() {
-  fmt::print("The answer is {}\n", 42);
-}
-```
-
-The expected output of this example is `The answer is 42`.
-
-*WORKSPACE.bazel*:
-
-```python
-load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
-
-git_repository(
-    name = "fmt",
-    branch = "master",
-    remote = "https://github.com/fmtlib/fmt",
-    patch_cmds = [
-        "mv support/bazel/.bazelversion .bazelversion",
-        "mv support/bazel/BUILD.bazel BUILD.bazel",
-        "mv support/bazel/WORKSPACE.bazel WORKSPACE.bazel",
-    ],
-    # Windows-related patch commands are only needed in the case MSYS2 is not installed.
-    # More details about the installation process of MSYS2 on Windows systems can be found here:
-    # https://docs.bazel.build/versions/main/install-windows.html#installing-compilers-and-language-runtimes
-    # Even if MSYS2 is installed the Windows related patch commands can still be used.
-    patch_cmds_win = [
-        "Move-Item -Path support/bazel/.bazelversion -Destination .bazelversion",
-        "Move-Item -Path support/bazel/BUILD.bazel -Destination BUILD.bazel",
-        "Move-Item -Path support/bazel/WORKSPACE.bazel -Destination WORKSPACE.bazel",
-    ],
-)
-```
-
-In the *WORKSPACE* file, the {fmt} GitHub repository is fetched. Using the attribute `patch_cmds` the  files `BUILD.bazel`, `WORKSPACE.bazel`, and `.bazelversion` are moved to the root of the {fmt} repository. This way the {fmt} repository is recognized as a bazelized workspace. 
-
-*BUILD.bazel*:
-
-```python
-cc_binary(
-    name = "Demo",
-    srcs = ["main.cpp"],
-    deps = ["@fmt"],
-)
-```
-
-The *BUILD* file defines a binary named `Demo` that has a dependency to {fmt}.
-
-To execute the binary you can run `bazel run //:Demo`.

external/fmt/support/bazel/WORKSPACE.bazel

@@ -1 +1,2 @@
-workspace(name = "fmt")
+# WORKSPACE marker file needed by Bazel
+

external/fmt/support/build-docs.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python
-# Build the documentation in CI.
-
-from __future__ import print_function
-import errno, os, shutil, subprocess, sys, urllib
-from subprocess import call, check_call, Popen, PIPE, STDOUT
-
-def rmtree_if_exists(dir):
-    try:
-        shutil.rmtree(dir)
-    except OSError as e:
-        if e.errno == errno.ENOENT:
-            pass
-
-# Build the docs.
-fmt_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-sys.path.insert(0, os.path.join(fmt_dir, 'doc'))
-import build
-build.create_build_env()
-html_dir = build.build_docs()
-
-repo = 'fmtlib.github.io'
-branch = os.environ['GITHUB_REF']
-is_ci = 'CI' in os.environ
-if is_ci and branch != 'refs/heads/master':
-    print('Branch: ' + branch)
-    exit(0) # Ignore non-master branches
-if is_ci and 'KEY' not in os.environ:
-    # Don't update the repo if building in CI from an account that doesn't have
-    # push access.
-    print('Skipping update of ' + repo)
-    exit(0)
-
-# Clone the fmtlib.github.io repo.
-rmtree_if_exists(repo)
-git_url = 'https://github.com/' if is_ci else 'git@github.com:'
-check_call(['git', 'clone', git_url + 'fmtlib/{}.git'.format(repo)])
-
-# Copy docs to the repo.
-target_dir = os.path.join(repo, 'dev')
-rmtree_if_exists(target_dir)
-shutil.copytree(html_dir, target_dir, ignore=shutil.ignore_patterns('.*'))
-if is_ci:
-    check_call(['git', 'config', '--global', 'user.name', 'fmtbot'])
-    check_call(['git', 'config', '--global', 'user.email', 'viz@fmt.dev'])
-
-# Push docs to GitHub pages.
-check_call(['git', 'add', '--all'], cwd=repo)
-if call(['git', 'diff-index', '--quiet', 'HEAD'], cwd=repo):
-    check_call(['git', 'commit', '-m', 'Update documentation'], cwd=repo)
-    cmd = 'git push'
-    if is_ci:
-        cmd += ' https://$KEY@github.com/fmtlib/fmtlib.github.io.git master'
-    p = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT, cwd=repo)
-    # Print the output without the key.
-    print(p.communicate()[0].decode('utf-8').replace(os.environ['KEY'], '$KEY'))
-    if p.returncode != 0:
-        raise subprocess.CalledProcessError(p.returncode, cmd)

external/fmt/support/check-commits

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+
+"""Compile source on a range of commits
+
+Usage:
+  check-commits <start> <source>
+"""
+
+import docopt, os, sys, tempfile
+from subprocess import check_call, check_output, run
+
+args = docopt.docopt(__doc__)
+start = args.get('<start>')
+source = args.get('<source>')
+
+cwd = os.getcwd()
+
+with tempfile.TemporaryDirectory() as work_dir:
+  check_call(['git', 'clone', 'https://github.com/fmtlib/fmt.git'],
+             cwd=work_dir)
+  repo_dir = os.path.join(work_dir, 'fmt')
+  commits = check_output(
+    ['git', 'rev-list', f'{start}..HEAD', '--abbrev-commit',
+     '--', 'include', 'src'],
+    text=True, cwd=repo_dir).rstrip().split('\n')
+  commits.reverse()
+  print('Time\tCommit')
+  for commit in commits:
+    check_call(['git', '-c', 'advice.detachedHead=false', 'checkout', commit],
+               cwd=repo_dir)
+    returncode = run(
+      ['c++', '-std=c++11', '-O3', '-DNDEBUG', '-I', 'include',
+       'src/format.cc', os.path.join(cwd, source)], cwd=repo_dir).returncode
+    if returncode != 0:
+      continue
+    times = []
+    for i in range(5):
+      output = check_output([os.path.join(repo_dir, 'a.out')], text=True)
+      times.append(float(output))
+    message = check_output(['git', 'log', '-1', '--pretty=format:%s', commit],
+                           cwd=repo_dir, text=True)
+    print(f'{min(times)}\t{commit} {message[:40]}')
+    sys.stdout.flush()

external/fmt/support/compute-powers.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python
-# Compute 10 ** exp with exp in the range [min_exponent, max_exponent] and print
-# normalized (with most-significant bit equal to 1) significands in hexadecimal.
-
-from __future__ import print_function
-
-min_exponent = -348
-max_exponent = 340
-step = 8
-significand_size = 64
-exp_offset = 2000
-
-class fp:
-    pass
-
-powers = []
-for i, exp in enumerate(range(min_exponent, max_exponent + 1, step)):
-    result = fp()
-    n = 10 ** exp if exp >= 0 else 2 ** exp_offset / 10 ** -exp
-    k = significand_size + 1
-    # Convert to binary and round.
-    binary = '{:b}'.format(n)
-    result.f = (int('{:0<{}}'.format(binary[:k], k), 2) + 1) / 2
-    result.e = len(binary) - (exp_offset if exp < 0 else 0) - significand_size
-    powers.append(result)
-    # Sanity check.
-    exp_offset10 = 400
-    actual = result.f * 10 ** exp_offset10
-    if result.e > 0:
-        actual *= 2 ** result.e
-    else:
-        for j in range(-result.e):
-            actual /= 2
-    expected = 10 ** (exp_offset10 + exp)
-    precision = len('{}'.format(expected)) - len('{}'.format(actual - expected))
-    if precision < 19:
-        print('low precision:', precision)
-        exit(1)
-
-print('Significands:', end='')
-for i, fp in enumerate(powers):
-    if i % 3 == 0:
-        print(end='\n ')
-    print(' {:0<#16x}'.format(fp.f, ), end=',')
-
-print('\n\nExponents:', end='')
-for i, fp in enumerate(powers):
-    if i % 11 == 0:
-        print(end='\n ')
-    print(' {:5}'.format(fp.e), end=',')
-
-print('\n\nMax exponent difference:',
-      max([x.e - powers[i - 1].e for i, x in enumerate(powers)][1:]))

external/fmt/support/manage.py

@@ -14,7 +14,6 @@ from __future__ import print_function
 import datetime, docopt, errno, fileinput, json, os
 import re, requests, shutil, sys
 from contextlib import contextmanager
-from distutils.version import LooseVersion
 from subprocess import check_call
 
 
@@ -76,147 +75,42 @@ def create_build_env():
     class Env:
         pass
     env = Env()
-
-    # Import the documentation build module.
     env.fmt_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    sys.path.insert(0, os.path.join(env.fmt_dir, 'doc'))
-    import build
-
     env.build_dir = 'build'
-    env.versions = build.versions
-
-    # Virtualenv and repos are cached to speed up builds.
-    build.create_build_env(os.path.join(env.build_dir, 'virtualenv'))
-
     env.fmt_repo = Git(os.path.join(env.build_dir, 'fmt'))
     return env
 
 
-@contextmanager
-def rewrite(filename):
-    class Buffer:
-        pass
-    buffer = Buffer()
-    if not os.path.exists(filename):
-        buffer.data = ''
-        yield buffer
-        return
-    with open(filename) as f:
-        buffer.data = f.read()
-    yield buffer
-    with open(filename, 'w') as f:
-        f.write(buffer.data)
-
-
 fmt_repo_url = 'git@github.com:fmtlib/fmt'
 
 
 def update_site(env):
     env.fmt_repo.update(fmt_repo_url)
 
-    doc_repo = Git(os.path.join(env.build_dir, 'fmtlib.github.io'))
-    doc_repo.update('git@github.com:fmtlib/fmtlib.github.io')
+    doc_repo = Git(os.path.join(env.build_dir, 'fmt.dev'))
+    doc_repo.update('git@github.com:fmtlib/fmt.dev')
 
-    for version in env.versions:
-        clean_checkout(env.fmt_repo, version)
-        target_doc_dir = os.path.join(env.fmt_repo.dir, 'doc')
-        # Remove the old theme.
-        for entry in os.listdir(target_doc_dir):
-            path = os.path.join(target_doc_dir, entry)
-            if os.path.isdir(path):
-                shutil.rmtree(path)
-        # Copy the new theme.
-        for entry in ['_static', '_templates', 'basic-bootstrap', 'bootstrap',
-                      'conf.py', 'fmt.less']:
-            src = os.path.join(env.fmt_dir, 'doc', entry)
-            dst = os.path.join(target_doc_dir, entry)
-            copy = shutil.copytree if os.path.isdir(src) else shutil.copyfile
-            copy(src, dst)
-        # Rename index to contents.
-        contents = os.path.join(target_doc_dir, 'contents.rst')
-        if not os.path.exists(contents):
-            os.rename(os.path.join(target_doc_dir, 'index.rst'), contents)
-        # Fix issues in reference.rst/api.rst.
-        for filename in ['reference.rst', 'api.rst', 'index.rst']:
-            pattern = re.compile('doxygenfunction.. (bin|oct|hexu|hex)$', re.M)
-            with rewrite(os.path.join(target_doc_dir, filename)) as b:
-                b.data = b.data.replace('std::ostream &', 'std::ostream&')
-                b.data = re.sub(pattern, r'doxygenfunction:: \1(int)', b.data)
-                b.data = b.data.replace('std::FILE*', 'std::FILE *')
-                b.data = b.data.replace('unsigned int', 'unsigned')
-                #b.data = b.data.replace('operator""_', 'operator"" _')
-                b.data = b.data.replace(
-                    'format_to_n(OutputIt, size_t, string_view, Args&&',
-                    'format_to_n(OutputIt, size_t, const S&, const Args&')
-                b.data = b.data.replace(
-                    'format_to_n(OutputIt, std::size_t, string_view, Args&&',
-                    'format_to_n(OutputIt, std::size_t, const S&, const Args&')
-                if version == ('3.0.2'):
-                    b.data = b.data.replace(
-                        'fprintf(std::ostream&', 'fprintf(std::ostream &')
-                if version == ('5.3.0'):
-                    b.data = b.data.replace(
-                        'format_to(OutputIt, const S&, const Args&...)',
-                        'format_to(OutputIt, const S &, const Args &...)')
-                if version.startswith('5.') or version.startswith('6.'):
-                    b.data = b.data.replace(', size_t', ', std::size_t')
-                if version.startswith('7.'):
-                    b.data = b.data.replace(', std::size_t', ', size_t')
-                    b.data = b.data.replace('join(It, It', 'join(It, Sentinel')
-                if version.startswith('7.1.'):
-                    b.data = b.data.replace(', std::size_t', ', size_t')
-                    b.data = b.data.replace('join(It, It', 'join(It, Sentinel')
-                    b.data = b.data.replace(
-                        'fmt::format_to(OutputIt, const S&, Args&&...)',
-                        'fmt::format_to(OutputIt, const S&, Args&&...) -> ' +
-                        'typename std::enable_if<enable, OutputIt>::type')
-                b.data = b.data.replace('aa long', 'a long')
-                b.data = b.data.replace('serveral', 'several')
-                if version.startswith('6.2.'):
-                    b.data = b.data.replace(
-                        'vformat(const S&, basic_format_args<' +
-                        'buffer_context<Char>>)',
-                        'vformat(const S&, basic_format_args<' +
-                        'buffer_context<type_identity_t<Char>>>)')
-        # Fix a broken link in index.rst.
-        index = os.path.join(target_doc_dir, 'index.rst')
-        with rewrite(index) as b:
-            b.data = b.data.replace(
-                'doc/latest/index.html#format-string-syntax', 'syntax.html')
-        # Fix issues in syntax.rst.
-        index = os.path.join(target_doc_dir, 'syntax.rst')
-        with rewrite(index) as b:
-            b.data = b.data.replace(
-                '..productionlist:: sf\n', '.. productionlist:: sf\n ')
-            b.data = b.data.replace('Examples:\n', 'Examples::\n')
-        # Build the docs.
-        html_dir = os.path.join(env.build_dir, 'html')
-        if os.path.exists(html_dir):
-            shutil.rmtree(html_dir)
-        include_dir = env.fmt_repo.dir
-        if LooseVersion(version) >= LooseVersion('5.0.0'):
-            include_dir = os.path.join(include_dir, 'include', 'fmt')
-        elif LooseVersion(version) >= LooseVersion('3.0.0'):
-            include_dir = os.path.join(include_dir, 'fmt')
-        import build
-        build.build_docs(version, doc_dir=target_doc_dir,
-                         include_dir=include_dir, work_dir=env.build_dir)
-        shutil.rmtree(os.path.join(html_dir, '.doctrees'))
-        # Create symlinks for older versions.
-        for link, target in {'index': 'contents', 'api': 'reference'}.items():
-            link = os.path.join(html_dir, link) + '.html'
-            target += '.html'
-            if os.path.exists(os.path.join(html_dir, target)) and \
-               not os.path.exists(link):
-                os.symlink(target, link)
-        # Copy docs to the website.
-        version_doc_dir = os.path.join(doc_repo.dir, version)
-        try:
-            shutil.rmtree(version_doc_dir)
-        except OSError as e:
-            if e.errno != errno.ENOENT:
-                raise
-        shutil.move(html_dir, version_doc_dir)
+    version = '11.0.0'
+    clean_checkout(env.fmt_repo, version)
+    target_doc_dir = os.path.join(env.fmt_repo.dir, 'doc')
+
+    # Build the docs.
+    html_dir = os.path.join(env.build_dir, 'html')
+    if os.path.exists(html_dir):
+        shutil.rmtree(html_dir)
+    include_dir = env.fmt_repo.dir
+    import build
+    build.build_docs(version, doc_dir=target_doc_dir,
+                        include_dir=include_dir, work_dir=env.build_dir)
+    shutil.rmtree(os.path.join(html_dir, '.doctrees'))
+    # Copy docs to the website.
+    version_doc_dir = os.path.join(doc_repo.dir, version)
+    try:
+        shutil.rmtree(version_doc_dir)
+    except OSError as e:
+        if e.errno != errno.ENOENT:
+            raise
+    shutil.move(html_dir, version_doc_dir)
 
 
 def release(args):
@@ -250,6 +144,18 @@ def release(args):
     if first_section[0] == '\n':
         first_section.pop(0)
 
+    ns_version = None
+    base_h_path = os.path.join(fmt_repo.dir, 'include', 'fmt', 'base.h')
+    for line in fileinput.input(base_h_path):
+        m = re.match(r'\s*inline namespace v(.*) .*', line)
+        if m:
+            ns_version = m.group(1)
+            break
+    major_version = version.split('.')[0]
+    if not ns_version or ns_version != major_version:
+        raise Exception(f'Version mismatch {ns_version} != {major_version}')
+
+    # Workaround GitHub-flavored Markdown treating newlines as <br>.
     changes = ''
     code_block = False
     stripped = False
@@ -262,36 +168,19 @@ def release(args):
         if code_block:
             changes += line
             continue
-        if line == '\n':
-            changes += line
+        if line == '\n' or re.match(r'^\s*\|.*', line):
             if stripped:
-                changes += line
+                changes += '\n'
                 stripped = False
+            changes += line
             continue
         if stripped:
             line = ' ' + line.lstrip()
         changes += line.rstrip()
         stripped = True
 
-    cmakelists = 'CMakeLists.txt'
-    for line in fileinput.input(os.path.join(fmt_repo.dir, cmakelists),
-                                inplace=True):
-        prefix = 'set(FMT_VERSION '
-        if line.startswith(prefix):
-            line = prefix + version + ')\n'
-        sys.stdout.write(line)
-
-    # Add the version to the build script.
-    script = os.path.join('doc', 'build.py')
-    script_path = os.path.join(fmt_repo.dir, script)
-    for line in fileinput.input(script_path, inplace=True):
-      m = re.match(r'( *versions \+= )\[(.+)\]', line)
-      if m:
-        line = '{}[{}, \'{}\']\n'.format(m.group(1), m.group(2), version)
-      sys.stdout.write(line)
-
     fmt_repo.checkout('-B', 'release')
-    fmt_repo.add(changelog, cmakelists, script)
+    fmt_repo.add(changelog)
     fmt_repo.commit('-m', 'Update version')
 
     # Build the docs and package.

external/fmt/support/mkdocs

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# A script to invoke mkdocs with the correct environment.
+# Additionally supports deploying via mike:
+#   ./mkdocs deploy [mike-deploy-options]
+
+import errno, os, shutil, sys
+from subprocess import call
+
+support_dir = os.path.dirname(os.path.normpath(__file__))
+build_dir = os.path.join(os.path.dirname(support_dir), 'build')
+
+# Set PYTHONPATH for the mkdocstrings handler.
+env = os.environ.copy()
+path = env.get('PYTHONPATH')
+env['PYTHONPATH'] = \
+  (path + ':' if path else '') + os.path.join(support_dir, 'python')
+
+redirect_page = \
+'''<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Redirecting</title>
+  <noscript>
+    <meta http-equiv="refresh" content="1; url=11.0/" />
+  </noscript>
+  <script>
+    window.location.replace(
+      "api/" + window.location.search + window.location.hash
+    );
+  </script>
+</head>
+<body>
+  Redirecting to <a href="api/">api</a>...
+</body>
+</html>
+'''
+
+config_path = os.path.join(support_dir, 'mkdocs.yml')
+args = sys.argv[1:]
+if len(args) > 0:
+  command = args[0]
+  if command == 'deploy':
+    git_url = 'https://github.com/' if 'CI' in os.environ else 'git@github.com:'
+    site_repo = git_url + 'fmtlib/fmt.dev.git'
+
+    site_dir = os.path.join(build_dir, 'fmt.dev')
+    try:
+      shutil.rmtree(site_dir)
+    except OSError as e:
+      if e.errno == errno.ENOENT:
+        pass
+    ret = call(['git', 'clone', '--depth=1', site_repo, site_dir])
+    if ret != 0:
+      sys.exit(ret)
+
+    # Copy the config to the build dir because the site is built relative to it.
+    config_build_path = os.path.join(build_dir, 'mkdocs.yml')
+    shutil.copyfile(config_path, config_build_path)
+
+    version = args[1]
+    ret = call(['mike'] + args + ['--config-file', config_build_path,
+               '--branch', 'master'], cwd=site_dir, env=env)
+    if ret != 0 or version == 'dev':
+      sys.exit(ret)
+    redirect_page_path = os.path.join(site_dir, version, 'api.html')
+    with open(redirect_page_path, "w") as file:
+      file.write(redirect_page)
+    ret = call(['git', 'add', redirect_page_path], cwd=site_dir)
+    if ret != 0:
+      sys.exit(ret)
+    ret = call(['git', 'commit', '--amend', '--no-edit'], cwd=site_dir)
+    sys.exit(ret)
+  elif not command.startswith('-'):
+    args += ['-f', config_path]
+sys.exit(call(['mkdocs'] + args, env=env))

external/fmt/support/mkdocs.yml

@@ -0,0 +1,48 @@
+site_name: '{fmt}'
+
+docs_dir: ../doc
+
+repo_url: https://github.com/fmtlib/fmt
+
+theme:
+  name: material
+  features:
+    - navigation.tabs
+    - navigation.top
+    - toc.integrate
+
+extra_javascript:
+  - https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.7.2/highlight.min.js
+  - fmt.js
+
+extra_css:
+  - https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.7.2/styles/default.min.css
+  - fmt.css
+
+markdown_extensions:
+  - pymdownx.highlight:
+      # Use JavaScript syntax highlighter instead of Pygments because it
+      # automatically applies to code blocks extracted through Doxygen.
+      use_pygments: false
+      anchor_linenums: true
+      line_spans: __span
+      pygments_lang_class: true
+  - pymdownx.inlinehilite
+  - pymdownx.snippets
+
+plugins:
+  - search
+  - mkdocstrings:
+      default_handler: cxx
+nav:
+  - Home: index.md
+  - Get Started: get-started.md
+  - API: api.md
+  - Syntax: syntax.md
+
+exclude_docs: ChangeLog-old.md
+
+extra:
+  version:
+    provider: mike
+  generator: false

external/fmt/support/python/mkdocstrings_handlers/cxx/__init__.py

@@ -0,0 +1,338 @@
+# A basic mkdocstrings handler for {fmt}.
+# Copyright (c) 2012 - present, Victor Zverovich
+# https://github.com/fmtlib/fmt/blob/master/LICENSE
+
+import os
+import xml.etree.ElementTree as ElementTree
+from pathlib import Path
+from subprocess import PIPE, STDOUT, CalledProcessError, Popen
+from typing import Any, List, Mapping, Optional
+
+from mkdocstrings.handlers.base import BaseHandler
+
+
+class Definition:
+    """A definition extracted by Doxygen."""
+
+    def __init__(self, name: str, kind: Optional[str] = None,
+                 node: Optional[ElementTree.Element] = None,
+                 is_member: bool = False):
+        self.name = name
+        self.kind = kind if kind is not None else node.get('kind')
+        self.desc = None
+        self.id = name if not is_member else None
+        self.members = None
+        self.params = None
+        self.template_params = None
+        self.trailing_return_type = None
+        self.type = None
+
+
+# A map from Doxygen to HTML tags.
+tag_map = {
+    'bold': 'b',
+    'emphasis': 'em',
+    'computeroutput': 'code',
+    'para': 'p',
+    'programlisting': 'pre',
+    'verbatim': 'pre'
+}
+
+# A map from Doxygen tags to text.
+tag_text_map = {
+    'codeline': '',
+    'highlight': '',
+    'sp': ' '
+}
+
+
+def escape_html(s: str) -> str:
+    return s.replace("<", "&lt;")
+
+
+def doxyxml2html(nodes: List[ElementTree.Element]):
+    out = ''
+    for n in nodes:
+        tag = tag_map.get(n.tag)
+        if not tag:
+            out += tag_text_map[n.tag]
+        out += '<' + tag + '>' if tag else ''
+        out += '<code class="language-cpp">' if tag == 'pre' else ''
+        if n.text:
+            out += escape_html(n.text)
+        out += doxyxml2html(list(n))
+        out += '</code>' if tag == 'pre' else ''
+        out += '</' + tag + '>' if tag else ''
+        if n.tail:
+            out += n.tail
+    return out
+
+
+def convert_template_params(node: ElementTree.Element) -> Optional[List[Definition]]:
+    template_param_list = node.find('templateparamlist')
+    if template_param_list is None:
+        return None
+    params = []
+    for param_node in template_param_list.findall('param'):
+        name = param_node.find('declname')
+        param = Definition(name.text if name is not None else '', 'param')
+        param.type = param_node.find('type').text
+        params.append(param)
+    return params
+
+
+def get_description(node: ElementTree.Element) -> List[ElementTree.Element]:
+    return node.findall('briefdescription/para') + \
+        node.findall('detaileddescription/para')
+
+
+def normalize_type(type_: str) -> str:
+    type_ = type_.replace('< ', '<').replace(' >', '>')
+    return type_.replace(' &', '&').replace(' *', '*')
+
+
+def convert_type(type_: ElementTree.Element) -> Optional[str]:
+    if type_ is None:
+        return None
+    result = type_.text if type_.text else ''
+    for ref in type_:
+        result += ref.text
+        if ref.tail:
+            result += ref.tail
+    result += type_.tail.strip()
+    return normalize_type(result)
+
+
+def convert_params(func: ElementTree.Element) -> List[Definition]:
+    params = []
+    for p in func.findall('param'):
+        d = Definition(p.find('declname').text, 'param')
+        d.type = convert_type(p.find('type'))
+        params.append(d)
+    return params
+
+
+def convert_return_type(d: Definition, node: ElementTree.Element) -> None:
+    d.trailing_return_type = None
+    if d.type == 'auto' or d.type == 'constexpr auto':
+        parts = node.find('argsstring').text.split(' -> ')
+        if len(parts) > 1:
+            d.trailing_return_type = normalize_type(parts[1])
+
+
+def render_param(param: Definition) -> str:
+    return param.type + (f'&nbsp;{param.name}' if len(param.name) > 0 else '')
+
+
+def render_decl(d: Definition) -> str:
+    text = ''
+    if d.id is not None:
+        text += f'<a id="{d.id}">\n'
+    text += '<pre><code class="language-cpp decl">'
+
+    text += '<div>'
+    if d.template_params is not None:
+        text += 'template &lt;'
+        text += ', '.join([render_param(p) for p in d.template_params])
+        text += '&gt;\n'
+    text += '</div>'
+
+    text += '<div>'
+    end = ';'
+    if d.kind == 'function' or d.kind == 'variable':
+        text += d.type + ' ' if len(d.type) > 0 else ''
+    elif d.kind == 'typedef':
+        text += 'using '
+    elif d.kind == 'define':
+        end = ''
+    else:
+        text += d.kind + ' '
+    text += d.name
+
+    if d.params is not None:
+        params = ', '.join([
+            (p.type + ' ' if p.type else '') + p.name for p in d.params])
+        text += '(' + escape_html(params) + ')'
+        if d.trailing_return_type:
+            text += ' -&NoBreak;>&nbsp;' + escape_html(d.trailing_return_type)
+    elif d.kind == 'typedef':
+        text += ' = ' + escape_html(d.type)
+
+    text += end
+    text += '</div>'
+    text += '</code></pre>\n'
+    if d.id is not None:
+        text += f'</a>\n'
+    return text
+
+
+class CxxHandler(BaseHandler):
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(handler='cxx', **kwargs)
+
+        headers = [
+            'args.h', 'base.h', 'chrono.h', 'color.h', 'compile.h', 'format.h',
+            'os.h', 'ostream.h', 'printf.h', 'ranges.h', 'std.h', 'xchar.h'
+        ]
+
+        # Run doxygen.
+        cmd = ['doxygen', '-']
+        support_dir = Path(__file__).parents[3]
+        top_dir = os.path.dirname(support_dir)
+        include_dir = os.path.join(top_dir, 'include', 'fmt')
+        self._ns2doxyxml = {}
+        build_dir = os.path.join(top_dir, 'build')
+        os.makedirs(build_dir, exist_ok=True)
+        self._doxyxml_dir = os.path.join(build_dir, 'doxyxml')
+        p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=STDOUT)
+        _, _ = p.communicate(input=r'''
+            PROJECT_NAME     = fmt
+            GENERATE_XML     = YES
+            GENERATE_LATEX   = NO
+            GENERATE_HTML    = NO
+            INPUT            = {0}
+            XML_OUTPUT       = {1}
+            QUIET            = YES
+            AUTOLINK_SUPPORT = NO
+            MACRO_EXPANSION  = YES
+            PREDEFINED       = _WIN32=1 \
+                               __linux__=1 \
+                               FMT_ENABLE_IF(...)= \
+                               FMT_USE_USER_LITERALS=1 \
+                               FMT_USE_ALIAS_TEMPLATES=1 \
+                               FMT_USE_NONTYPE_TEMPLATE_ARGS=1 \
+                               FMT_API= \
+                               "FMT_BEGIN_NAMESPACE=namespace fmt {{" \
+                               "FMT_END_NAMESPACE=}}" \
+                               "FMT_DOC=1"
+            '''.format(
+                ' '.join([os.path.join(include_dir, h) for h in headers]),
+                self._doxyxml_dir).encode('utf-8'))
+        if p.returncode != 0:
+            raise CalledProcessError(p.returncode, cmd)
+
+        # Merge all file-level XMLs into one to simplify search.
+        self._file_doxyxml = None
+        for h in headers:
+            filename = h.replace(".h", "_8h.xml")
+            with open(os.path.join(self._doxyxml_dir, filename)) as f:
+                doxyxml = ElementTree.parse(f)
+                if self._file_doxyxml is None:
+                    self._file_doxyxml = doxyxml
+                    continue
+                root = self._file_doxyxml.getroot()
+                for node in doxyxml.getroot():
+                    root.append(node)
+
+    def collect_compound(self, identifier: str,
+                         cls: List[ElementTree.Element]) -> Definition:
+        """Collect a compound definition such as a struct."""
+        path = os.path.join(self._doxyxml_dir, cls[0].get('refid') + '.xml')
+        with open(path) as f:
+            xml = ElementTree.parse(f)
+            node = xml.find('compounddef')
+            d = Definition(identifier, node=node)
+            d.template_params = convert_template_params(node)
+            d.desc = get_description(node)
+            d.members = []
+            for m in \
+                    node.findall('sectiondef[@kind="public-attrib"]/memberdef') + \
+                    node.findall('sectiondef[@kind="public-func"]/memberdef'):
+                name = m.find('name').text
+                # Doxygen incorrectly classifies members of private unnamed unions as
+                # public members of the containing class.
+                if name.endswith('_'):
+                    continue
+                desc = get_description(m)
+                if len(desc) == 0:
+                    continue
+                kind = m.get('kind')
+                member = Definition(name if name else '', kind=kind, is_member=True)
+                type_text = m.find('type').text
+                member.type = type_text if type_text else ''
+                if kind == 'function':
+                    member.params = convert_params(m)
+                    convert_return_type(member, m)
+                member.template_params = None
+                member.desc = desc
+                d.members.append(member)
+            return d
+
+    def collect(self, identifier: str, _config: Mapping[str, Any]) -> Definition:
+        qual_name = 'fmt::' + identifier
+
+        param_str = None
+        paren = qual_name.find('(')
+        if paren > 0:
+            qual_name, param_str = qual_name[:paren], qual_name[paren + 1:-1]
+
+        colons = qual_name.rfind('::')
+        namespace, name = qual_name[:colons], qual_name[colons + 2:]
+
+        # Load XML.
+        doxyxml = self._ns2doxyxml.get(namespace)
+        if doxyxml is None:
+            path = f'namespace{namespace.replace("::", "_1_1")}.xml'
+            with open(os.path.join(self._doxyxml_dir, path)) as f:
+                doxyxml = ElementTree.parse(f)
+                self._ns2doxyxml[namespace] = doxyxml
+
+        nodes = doxyxml.findall(
+            f"compounddef/sectiondef/memberdef/name[.='{name}']/..")
+        if len(nodes) == 0:
+            nodes = self._file_doxyxml.findall(
+                f"compounddef/sectiondef/memberdef/name[.='{name}']/..")
+        candidates = []
+        for node in nodes:
+            # Process a function or a typedef.
+            params = None
+            d = Definition(name, node=node)
+            if d.kind == 'function':
+                params = convert_params(node)
+                node_param_str = ', '.join([p.type for p in params])
+                if param_str and param_str != node_param_str:
+                    candidates.append(f'{name}({node_param_str})')
+                    continue
+            elif d.kind == 'define':
+                params = []
+                for p in node.findall('param'):
+                    param = Definition(p.find('defname').text, kind='param')
+                    param.type = None
+                    params.append(param)
+            d.type = convert_type(node.find('type'))
+            d.template_params = convert_template_params(node)
+            d.params = params
+            convert_return_type(d, node)
+            d.desc = get_description(node)
+            return d
+
+        cls = doxyxml.findall(f"compounddef/innerclass[.='{qual_name}']")
+        if not cls:
+            raise Exception(f'Cannot find {identifier}. Candidates: {candidates}')
+        return self.collect_compound(identifier, cls)
+
+    def render(self, d: Definition, config: dict) -> str:
+        if d.id is not None:
+            self.do_heading('', 0, id=d.id)
+        text = '<div class="docblock">\n'
+        text += render_decl(d)
+        text += '<div class="docblock-desc">\n'
+        text += doxyxml2html(d.desc)
+        if d.members is not None:
+            for m in d.members:
+                text += self.render(m, config)
+        text += '</div>\n'
+        text += '</div>\n'
+        return text
+
+
+def get_handler(theme: str, custom_templates: Optional[str] = None,
+                **_config: Any) -> CxxHandler:
+    """Return an instance of `CxxHandler`.
+
+    Arguments:
+        theme: The theme to use when rendering contents.
+        custom_templates: Directory containing custom templates.
+        **_config: Configuration passed to the handler.
+    """
+    return CxxHandler(theme=theme, custom_templates=custom_templates)

external/fmt/support/python/mkdocstrings_handlers/cxx/templates/README

@@ -0,0 +1 @@
+mkdocsstrings requires a handler to have a templates directory.

external/fmt/support/rtd/conf.py

@@ -1,7 +0,0 @@
-# Sphinx configuration for readthedocs.
-
-import os, sys
-
-master_doc = 'index'
-html_theme = 'theme'
-html_theme_path = ["."]

external/fmt/support/rtd/index.rst

@@ -1,2 +0,0 @@
-If you are not redirected automatically, follow the
-`link to the fmt documentation <https://fmt.dev/latest/>`_.

external/fmt/support/rtd/theme/layout.html

@@ -1,17 +0,0 @@
-{% extends "basic/layout.html" %}
-
-{% block extrahead %}
-<meta charset="UTF-8">
-<meta http-equiv="refresh" content="1;url=https://fmt.dev/latest/">
-<script type="text/javascript">
-    window.location.href = "https://fmt.dev/latest/"
-</script>
-<title>Page Redirection</title>
-{% endblock %}
-
-{% block document %}
-If you are not redirected automatically, follow the <a href='https://fmt.dev/latest/'>link to the fmt documentation</a>.
-{% endblock %}
-
-{% block footer %}
-{% endblock %}

external/fmt/support/rtd/theme/theme.conf

@@ -1,2 +0,0 @@
-[theme]
-inherit = basic