#!/usr/bin/env python3

# Copyright (c) 2017-2026 Jean-Louis Leroy

# Distributed under the Boost Software License, Version 1.0.

# See accompanying file LICENSE_1_0.txt

# or copy at http://www.boost.org/LICENSE_1_0.txt)

"""Generate flattened copies of the public headers, for Compiler Explorer.

CE can include a header from a URL, but only one file at a time: it does not

resolve the includes inside the file it fetches. Each public header thus becomes

a self-sufficient file, so that a CE example includes exactly what a local

example includes, one line per header:

#include <https://.../boost/openmethod.hpp>

#include <https://.../boost/openmethod/initialize.hpp>

`boost/openmethod.hpp` is the root: it carries its entire closure. Every other

header carries only what the root does not already provide - its `detail/`

headers, `interop/virtual_any.hpp` - and replaces the rest with a check on the

include guard, so that including it without the root fails with a diagnostic

instead of a wall of undeclared identifiers.

"""

import argparse

import re

import subprocess

from pathlib import Path

ROOT = "boost/openmethod.hpp"

DETAIL = "boost/openmethod/detail/"

INCLUDE = re.compile(r"#include <(boost/openmethod(?:/[^>]+)?\.hpp)>")

GUARD = re.compile(r"#ifndef (\w+)$")

class Flattener:

def __init__(self, include_dir, base_url, revision):

self.include_dir = include_dir

self.base_url = base_url.rstrip("/")

self.revision = revision

# What the root already brings in, minus the `detail/` headers, which

# are small and are copied into every header that needs them.

self.provided = {

header

for header in self.dependencies(ROOT)

if not header.startswith(DETAIL)

}

def read(self, header):

return (self.include_dir / header).read_text()

def guard_of(self, header):

lines = self.read(header).splitlines()

for line, next_line in zip(lines, lines[1:]):

if (m := GUARD.match(line)) and next_line == f"#define {m[1]}":

return m[1]

raise SystemExit(f"{header}: no include guard")

def dependencies(self, header, found=None):

found = set() if found is None else found

for dep in INCLUDE.findall(self.read(header)):

if dep not in found:

found.add(dep)

self.dependencies(dep, found)

return found

def headers(self):

return [ROOT] + sorted(

header

for path in (self.include_dir / "boost/openmethod").rglob("*.hpp")

if not (

header := path.relative_to(self.include_dir).as_posix()

).startswith(DETAIL)

)

def write(self, header, output):

if header == ROOT:

note = "// This file is self-contained.\n"

else:

note = f"// #include <{self.base_url}/{ROOT}> first.\n"

output.write(

f"// <{header}>, flattened for Compiler Explorer.\n"

f"{note}"

"//\n"

"// Generated by dev/flatten.py from Boost.OpenMethod"

f" {self.revision}. Do not edit.\n"

"// See https://github.com/boostorg/openmethod\n\n"

)

# The root carries everything; the others require what it provides.

provided = set() if header == ROOT else self.provided

self.copy(header, output, provided, header, set())

def copy(self, header, output, provided, top, done):

if header in done:

return

done.add(header)

for line in self.read(header).splitlines(keepends=True):

if m := INCLUDE.match(line):

dep = m[1]

if dep in provided:

output.write(

f"#ifndef {self.guard_of(dep)}\n"

f'#error "<{top}>:'

f" #include <{self.base_url}/{ROOT}> first\"\n"

"#endif\n"

)

else:

output.write("\n")

self.copy(dep, output, provided, top, done)

output.write("\n")

continue

output.write(line)

def revision():

try:

return subprocess.run(

["git", "describe", "--always", "--dirty"],

capture_output=True,

check=True,

text=True,

).stdout.strip()

except (OSError, subprocess.CalledProcessError):

return "(unknown revision)"

def main():

parser = argparse.ArgumentParser(description=__doc__)

parser.add_argument("--include-dir", type=Path, default=Path("include"))

parser.add_argument("--output-dir", type=Path, default=Path("flat"))

parser.add_argument(

"--base-url", default="https://boostorg.github.io/openmethod"

)

args = parser.parse_args()

flattener = Flattener(args.include_dir, args.base_url, revision())

for header in flattener.headers():

path = args.output_dir / header

path.parent.mkdir(parents=True, exist_ok=True)

with path.open("w") as output:

flattener.write(header, output)

print(path)

main()