diff --git a/.agents/docs/2026-10-28-mwrap-module-wrapper-generation.md b/.agents/docs/2026-10-28-mwrap-module-wrapper-generation.md new file mode 100644 index 000000000..4264d3bfa --- /dev/null +++ b/.agents/docs/2026-10-28-mwrap-module-wrapper-generation.md @@ -0,0 +1,1399 @@ +# mcpplibs `mwrap` 模块封装层生成原理技术报告 + +> 对象：GitHub 组织 [`mcpplibs`](https://github.com/mcpplibs) 下的 +> [`llama.cpp-m`](https://github.com/mcpplibs/llama.cpp-m) 与 +> [`onnxruntime-m`](https://github.com/mcpplibs/onnxruntime-m) +> +> 日期：2026-10-28 +> +> 基线：`llama.cpp-m@c8b41c67cc6a7767797ccb05d637a7936c3d22ea`、 +> `onnxruntime-m@baf37fe63375021e937fb6e80ecc0214242a24e2`、 +> `mcpp-index@e4ee62e06db008b3cbf37744b13fe3c86264e5f9` +> +> 目标：说明“用脚本生成 C++23 模块封装层”的完整流程、背后的语言机制、 +> 两个仓库各自的具体实现，以及复制这套做法时必须注意的坑。 + +--- + +## 0. 一句话结论 + +这两个仓库的“模块封装层生成器”**不是绑定生成器（binding generator），也不是转译器**。 +它不生成任何代理函数、不复制上游实现、不改变类型和命名空间，而只做三件事： + +1. **用编译器读上游公开头文件**，得到“有哪些公开名字、属于哪个作用域、值是多少”的确定清单； +2. 把清单写成**纯 `using` 声明**（`export using ::name;` 或 + `export namespace N { using ::N::name; }`），由手写的 `.cppm` 门面文本包含； +3. 对**模块机制覆盖不到的东西**（预处理宏、内部链接变量、构建期产物） + 用有限的、显式的替代物补齐：`inline constexpr` 常量、兼容头文件、 + `build.mcpp` 声明的构建图动作。 + +因此封装层本身几乎没有“代码”，只有**声明搬运 + 等价替换 + 构建编排**。 +上游头文件始终是唯一事实来源（single source of truth）；生成物的价值在于 +**规模、确定性、可审计和可重复**，而不是“把 C API 翻译成 C++”。 + +| 维度 | `onnxruntime-m` | `llama.cpp-m` | +|---|---|---| +| 上游形态 | 官方预编译 CPU SDK | 源码 vendored（随包编译） | +| 生成输入 | SDK 头文件 + 少量补充头 | vendored `llama.h`/`ggml*.h` + 源码 | +| 生成器 | `tools/generate_exports.py` | `tools/gen_exports.py` | +| 主要产物 | `src/exports.inc`(411 条 using)、`src/config_exports.inc`(69 个常量)、`upstream/api-surface.json` | `src/gen_exports/llama.inc`(388)、`required_ggml.inc`(99)、`typed_constants.inc`(13)、`llama.skipped.txt`、`snapshots/.json` | +| 宏策略 | `.macros` 模块 + `port/include/mwrap/onnxruntime/macros.hpp` | `.macros` 模块 + `#undef` + 跳过清单 | +| 构建脚本 | 无（声明式 `mcpp.toml` + `compat` 提供方） | `build.mcpp`（Metal 内嵌、Vulkan 着色器图） | +| 额外审计 | Clang AST `--check`、SDK 头哈希 | 导入锁、AST `--check`、源码/ABI 快照审计 | +| 版本 | `1.25.1`（上游版本） | `b10069`（上游 build 号，可加 `.1` 修订） | + +--- + +## 1. 背景：为什么需要“生成的封装层” + +### 1.1 目标形态 + +`mcpp` 生态要求消费者写： + +```cpp +import mcpplibs.mwrap.onnxruntime; // 而不是 #include +import mcpplibs.mwrap.llamacpp; + +Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "example"); +llama_backend_init(); +``` + +但上游是传统头文件库，公开 API 动辄几百个名字、几十个头文件、 +大量平台条件编译和预处理宏。手写一个模块门面会遇到四个问题： + +1. **规模**：ONNX Runtime 公开面有 287 个 C 声明/枚举项、107 个 `Ort::` 声明， + 另有 `Ort::Custom` 14 个、`onnxruntime` 3 个（合计 411 条 `using`）； + llama.cpp 有 388 个 `llama_*`/`LLAMA_*` 名字 + 99 个所需 ggml 名字。 + 手抄必然漏、必然拼错。 +2. **漂移**：上游升级后，新增/删除/改签名必须能被发现，而不是靠人眼 diff。 +3. **一致性**：封装层绝不能“顺手改 API”。类型、重载、默认参数、ABI 都必须 + 与上游逐字一致，否则消费者代码不能无缝迁移。 +4. **可复现**：生成结果必须能 `--check`，在 CI 中证明“提交的封装层就是 + 当前上游头文件生成的”，且不同机器生成结果字节一致。 + +### 1.2 `mwrap` 的组织约束 + +`mcpp-index/docs/mwrap.md` 定义了这个类别的硬约束，两个仓库都遵守： + +- 仓库名 `-m`，包命名空间固定 `mcpplibs.mwrap`； +- 根模块是完整包标识：`mcpplibs.mwrap.llamacpp`； +- **公开 API 保留上游原始拼写与命名空间**，不搬家、不加 `-m` 后缀； +- 优先用 `export using` 导出上游实体，每个实体只有一个导出属主； +- 版本跟上游走，最多追加一个数字修订（`5.0.0`、`5.0.0.1`）； +- 必须有可运行的默认模板、双语 README、许可证部署、CI 证据。 + +这解释了为什么生成器输出的是“using 清单”而不是“包装类”： +**策略上不允许发明新 API，技术上 `using` 恰好是零成本地引用同一实体。** + +--- + +## 2. 语言机制：这样生成的模块为什么成立 + +理解生成器之前必须先理解四个 C++20/23 模块事实。两个仓库的所有设计都由此推导。 + +### 2.1 全局模块片段（global module fragment） + +两个根模块都是这个形状： + +```cpp +module; // 全局模块片段开始 +#include // 上游头文件在这里展开 +#include +#undef LLAMA_DEFAULT_SEED // 清掉会干扰模块体的对象宏 +... + +export module mcpplibs.mwrap.llamacpp; // 具名模块开始 +export import mcpplibs.mwrap.llamacpp.macros; +#include "gen_exports/required_ggml.inc" +#include "gen_exports/llama.inc" +``` + +关键点：`module;` 与 `export module` 之间的声明属于**全局模块**， +而不是这个具名模块。于是： + +- 上游头文件里的类、函数、模板仍然属于全局模块，消费者**同时** `#include` + 同一个头文件不会产生“同一实体属于两个模块”的 ODR 冲突； +- 模块体里的 `export using ::llama_model_load_from_file;` + 只是把全局模块中的实体**引入并导出**，不产生新实体、不产生新符号； +- 头文件里的 `inline` 函数、模板、默认参数、`constexpr` 定义都在编译该模块时 + 已完成语义分析，消费者导入后可以直接使用。 + +如果把 `#include` 放进模块体（`export module` 之后），声明的模块归属就会改变， +头文件/模块混用会变得非常脆弱。两个仓库都刻意把 include 放在全局模块片段， +这是“头文件与模块可共存”的基础。 + +### 2.2 `export using` 保留实体同一性 + +```cpp +export using ::llama_model_load_from_file; // 自由函数（含全部重载） +export namespace Ort { using ::Ort::Session; } // 类（含全部成员、重载、默认参数） +``` + +`using` 声明引用的是**同一个实体**，因此： + +- `&llama_model_load_from_file` 得到的就是上游函数地址； +- `Ort::Session` 的类型身份、布局、ABI、异常规格完全不变； +- 重载集、模板参数、默认实参原样保留； +- 不引入调用开销、不引入生命周期包装、不做异常翻译。 + +这正是“封装层”可以只有几百行 `using` 的原因：**编译器已经把语义做完了， +生成器只负责把名字列出来。** + +### 2.3 具名模块不能导出预处理宏 + +`#define` 在预处理阶段消失，模块导出的是声明，不是宏。所以： + +- 对象式宏（`LLAMA_DEFAULT_SEED`、`ORT_API_VERSION`）→ 映射成 + `inline constexpr` 常量，放在 `.macros` 子模块； +- 函数式/控制流/字符串化宏（`ORT_TSTR`、`LLAMA_API`）→ 无法等值映射， + 保留在兼容头 `/macros.hpp>`，要求在 `import` **之前**包含； +- 宏在限定名里也会展开（例如 `LLAMA_DEFAULT_SEED` 作为标识符出现时）， + 所以模块体里必须先 `#undef`，再用自己的常量名。 + +### 2.4 内部链接实体不能直接导出 + +ONNX Runtime 的配置键头文件里是： + +```cpp +static const char* const kOrtSessionOptionsConfigDisablePrepacking = ...; +``` + +`static`（内部链接）变量在 GCC 下不能被模块导出（导出后消费者无法链接到它）。 +`onnxruntime-m` 的处理是：在全局模块片段里把这些头文件塞进一个**私有命名空间** +`mwrap_onnxruntime_config_detail`，然后在模块体里定义**同名、同类型的 +`export inline constexpr` 指针**，值来自上游常量。 + +```cpp +// src/config.cppm +module; +namespace mwrap_onnxruntime_config_detail { +#include +... +} +export module mcpplibs.mwrap.onnxruntime.config; +#include "config_exports.inc" + +// config_exports.inc（生成） +export inline const char* const kOrtSessionOptionsConfigDisablePrepacking = + mwrap_onnxruntime_config_detail::kOrtSessionOptionsConfigDisablePrepacking; +``` + +代价是：**`.config` 模块与同名原始配置头不能在同一 TU 混用**，否则会出现两个 +同名实体。文档明确写出了这个限制，并用测试覆盖“只用模块”和“原始头 + 根模块” +两种组合。 + +--- + +## 3. 总体流水线 + +两个仓库共享同一条主流水线，只是“上游从哪来”和“额外生成什么”不同。 + +```text +┌──────────────────────┐ +│ 上游：SDK 头文件 │ onnxruntime: 官方预编译 SDK（compat 提供方下载） +│ 或 vendored 源码 │ llama.cpp: 按 upstream.lock 导入的官方 tag 归档 +└──────────┬───────────┘ + │ 1. 锁定版本/哈希（lock / sources.lock / upstream.lock） + ▼ +┌──────────────────────┐ +│ 探针翻译单元 probe.cpp│ 只写 #include，不写业务代码 +└──────────┬───────────┘ + │ 2. clang -Xclang -ast-dump=json -fsyntax-only + │ （llama 另跑 clang -dM -E 取宏） + ▼ +┌──────────────────────┐ +│ 语义清单 │ namespaces / kinds / 签名 / 枚举值 / 宏 / 布局指纹 +└──────────┬───────────┘ + │ 3. 过滤、归属判定、排序、去重 + ▼ +┌──────────────────────┐ +│ 生成物（.inc/.json） │ export using ... / inline constexpr ... / 快照 +└──────────┬───────────┘ + │ 4. 手写 .cppm 文本包含（不是单独编译） + ▼ +┌──────────────────────┐ +│ 模块 BMI │ mcpp 用消费者工具链编译一次 +└──────────┬───────────┘ + │ 5. import + ▼ + 消费者代码 +``` + +三条“生成线”要分开看： + +1. **声明导出线**：头文件 → AST → `using` 清单（两个仓库都有）。 +2. **宏/常量线**：`-dM` 宏 dump → 类型化常量 + 兼容头 + 跳过清单（两个仓库都有， + llama 更细）。 +3. **构建动作线**：只有 llama.cpp-m 需要。`build.mcpp` 不生成声明，而是把 + “Metal shader 内嵌”“Vulkan 134 组 shader 生成”声明成构建图边。 + +--- + +## 4. 原理一：AST 驱动的声明导出 + +### 4.1 为什么用编译器而不是正则/头文件解析器 + +C++ 头文件不是上下文无关文本：宏、模板、`extern "C"`、条件编译、命名空间别名、 +typedef 重定向都会让正则失效。两个仓库都选择**让编译器把答案算出来**： + +```bash +clang++ -std=c++23 -I -I<补充头> \ + -Xclang -ast-dump=json -fsyntax-only probe.cpp > ast.json +``` + +得到的是完整语义 AST：每个节点有 `kind`、`name`、`type.qualType`、 +`loc`、`isImplicit`、`parentDeclContextId`、`completeDefinition`、`inner` 等。 +生成器只做**遍历和筛选**，不重新解析 C++。 + +这也带来一个必须正视的事实：**AST JSON 是编译器实现细节**，不同 Clang 版本 +的字段可能变化（例如 `desugaredQualType` 的出现），所以快照要记录生成它的 +编译器，比较时要能识别“换编译器”而不是“API 变了”（见 7.4）。 + +### 4.2 探针 TU + +ONNX 的探针（`tools/generate_exports.py`）： + +```cpp +#include +#include +#include +#include +#include +#include + +namespace mwrap_onnxruntime_config_detail { +#include +#include +#include +#include +} +``` + +这个探针**就是公开面的定义**：想导出的头必须出现在这里；配置头必须放进私有 +命名空间，才能把内部链接变量“困”在一个可引用的作用域里。 + +llama 的探针更简单： + +```cpp +#include "llama.h" +#include "ggml.h" +#include "ggml-backend.h" +#include "ggml-alloc.h" +``` + +因为它只导出 `llama_*` 和一份**显式白名单**里的 ggml 名字，不需要把整个 +ggml 公开面都列进来。 + +### 4.3 遍历与过滤（ONNX 版） + +`generate(ast)` 的核心规则： + +```python +namespaces = {name: [] for name in ("Ort", "Ort::Custom", "onnxruntime", + "mwrap_onnxruntime_config_detail")} +# 递归收集目标命名空间节点（可能多次出现：namespace 可以重开） +find_namespaces(ast["inner"]) + +kinds = {"CXXRecordDecl", "RecordDecl", "ClassTemplateDecl", + "FunctionTemplateDecl", "FunctionDecl", "TypeAliasDecl", + "TypeAliasTemplateDecl", "TypedefDecl", "EnumDecl", "VarDecl"} + +for namespace in extensions: + namespace_ids = {node["id"] for node in extensions} + for node in namespace["inner"]: + if node["kind"] not in kinds: continue + if not node["name"].isidentifier(): continue # 跳过匿名/运算符等 + if node.get("isImplicit"): continue # 跳过编译器合成 + owner = node.get("parentDeclContextId") + if owner and owner not in namespace_ids: continue # 跳过类外定义 + if node["kind"] == "FunctionTemplateDecl" and any( + x["kind"] == "CXXMethodDecl" for x in node["inner"]): + continue # 跳过成员函数模板 + names.add(node["name"]) +``` + +这几条过滤都对应真实坑： + +| 过滤 | 不做的后果 | +|---|---| +| `isidentifier()` | 生成 `using ::operator<<;` 之类的非法行 | +| `isImplicit` | 把编译器生成的拷贝构造、`__va_list_tag` 等当公开 API | +| `parentDeclContextId` | 把类外定义的成员、私有命名空间里的重载误当顶层名字 | +| 成员函数模板 | 在命名空间作用域导出类成员模板，语义错误/编译失败 | + +C API 走另一条路：遍历 `LinkageSpecDecl`（`extern "C"`），按名字前缀 +`Ort`/`ONNX` 或固定白名单收集，并为收集到的枚举补上枚举项： + +```python +public_name = name.startswith(("Ort", "ONNX")) or name in { + "GraphOptimizationLevel", "ExecutionMode", "ExecutionOrder", + "RunAsyncCallbackFn", "CreateEpApiFactoriesFn", "ReleaseEpApiFactoryFn", + "CustomOpContext", "ResourceOffset"} +``` + +C API 的枚举项（`ONNX_TENSOR_ELEMENT_DATA_TYPE_*`、`ORT_*`）必须单独收集， +因为它们在 AST 里是 `EnumConstantDecl`，不是类型。 + +### 4.4 遍历与过滤（llama 版） + +llama 的判定更“按上游意图”： + +- 函数：名字以 `llama_` 开头，**且声明所在源码行包含 `LLAMA_API`**。 + 这条“源码行检查”用于区分公开导出函数与头文件里的 `static inline` 辅助函数； + 上游用 `LLAMA_API` 标记可见性，生成器复用同一标记，不另造白名单。 +- 类型：`llama_*` 直接导出；ggml 只导出 `REQUIRED_GGML_TYPES` 白名单 + （`ggml_context`、`ggml_tensor`、`ggml_backend_t`、`ggml_cgraph` 等）。 +- ggml 函数：只导出后端生命周期/图执行/分配所需的 + `REQUIRED_GGML_FUNCTIONS`（`ggml_init`、`ggml_backend_graph_compute` 等）； + 这是“够 llama 消费者用”的最小面，不是整个 ggml。 +- 枚举：只对 `GGML_ENUM_TYPES` 里的枚举导出全部枚举项。 +- 生成完必须自检：**白名单里任何一个名字在 AST 中缺失，直接报错退出**， + 防止上游改名后静默少导出。 + +llama 代码里有一段很重要的注释：Clang JSON AST 的 `loc.file` 不可靠， +可能指向探针 `.cpp` 而不是真实头文件，所以**用命名前缀做归属判断**， +不要依赖 `loc.file`。这是一个很容易踩的坑。 + +### 4.5 代码生成 + +ONNX 的输出是三个文本块： + +```cpp +// src/exports.inc +export { +using ::OrtGetApiBase; +using ::ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT; +... +} +export namespace Ort { +using ::Ort::Session; +... +} +export namespace Ort::Custom { ... } +export namespace onnxruntime { ... } +``` + +llama 的输出是一行一个： + +```cpp +export using ::llama_model_load_from_file; +export using ::ggml_backend_t; +``` + +排序规则都是**按名字排序后输出**（llama 用 `x.rsplit("::", 1)[-1]` 作为键）， +保证同一输入永远得到同一字节序列——这是 `--check` 能工作的前提。 + +### 4.6 `using` 清单为什么能覆盖模板和内联实现 + +因为头文件在**全局模块片段**里被完整包含，模板定义、`inline` 函数体、 +`constexpr` 变量都在编译模块时存在；`using` 只是把名字导出。消费者导入模块后： + +- 实例化模板时，定义已经在 BMI 中； +- 内联函数不会产生新的外部符号； +- 默认参数在声明里，原样可见； +- `dllimport`/`visibility` 属性来自上游声明，不会被 `using` 抹掉。 + +反过来说，**如果上游把实现放在 `.cpp` 里，`using` 不会把它带进来**； +消费者仍然要链接上游库。模块只改变“如何声明/导入”，不改变“如何链接”。 + +### 4.7 和 Header Unit、手写门面的对比 + +| 方案 | 问题 | +|---|---| +| 手写 `using` | 规模大、易漏、升级不可审计 | +| Header Unit（`import
`） | 消费者要知道每个头名；宏仍不可导出；无法统一成稳定模块名；BMI 数量多 | +| 生成代理函数 | 破坏重载/默认参数/ABI，增加调用层，等于重写 API | +| 生成 `using` 清单（本方案） | 零运行时成本、保留同一性、可用 `--check` 锁死 | + +--- + +## 5. 原理二：宏与常量的模块化 + +### 5.1 三类宏，三种处理 + +| 宏类型 | 例子 | 处理 | +|---|---|---| +| 对象式数值常量 | `LLAMA_DEFAULT_SEED`、`LLAMA_TOKEN_NULL`、`ORT_API_VERSION` | 生成带类型的 `export inline constexpr` | +| 对象式但类型敏感 | `LLAMA_STATE_SEQ_FLAGS_*`（枚举标志） | `static_cast(...)` | +| 函数式/控制流/字符串化 | `ORT_TSTR`、`LLAMA_API`、`LLAMA_H` | 留在兼容头或跳过清单，要求 `#include` 在 `import` 前 | + +### 5.2 llama：先 `#undef`，再定义 + +`src/macros.cppm`： + +```cpp +module; +#include +#undef LLAMA_DEFAULT_SEED +#undef LLAMA_TOKEN_NULL +... +export module mcpplibs.mwrap.llamacpp.macros; + +namespace mcpplibs::mwrap::llamacpp::macros { +#include "gen_exports/typed_constants.inc" +} +``` + +生成的 `typed_constants.inc`： + +```cpp +export inline constexpr uint32_t LLAMA_DEFAULT_SEED = 0xFFFFFFFF; +export inline constexpr llama_token LLAMA_TOKEN_NULL = -1; +export inline constexpr llama_state_seq_flags LLAMA_STATE_SEQ_FLAGS_SWA_ONLY = + static_cast(1); +``` + +`#undef` 不是洁癖：宏名在模块体里出现时会被预处理展开，若不 `#undef`， +`LLAMA_DEFAULT_SEED` 这一行会先被替换成 `0xFFFFFFFF`，定义就变成语法错误。 + +生成器 `_expand_macro()` 会递归展开宏依赖，并检测循环引用； +`TYPED_LLAMA_CONSTANTS` 是显式表，只有表里的宏才会被转成常量， +其余宏进入 `llama.skipped.txt`（含 `LLAMA_API`、`LLAMA_H` 这类非 API 宏）， +形成“为什么没导出”的可审计记录。 + +### 5.3 ONNX：`ORT_API_VERSION` 的类型化映射 + +```cpp +module; +#include +namespace mwrap_onnxruntime_detail { +inline constexpr unsigned api_version = ORT_API_VERSION; +} +#undef ORT_API_VERSION + +export module mcpplibs.mwrap.onnxruntime.macros; + +export namespace mcpplibs::mwrap::onnxruntime::macros { +inline constexpr unsigned ORT_API_VERSION = mwrap_onnxruntime_detail::api_version; +} +``` + +消费者用 `mcpplibs::mwrap::onnxruntime::macros::ORT_API_VERSION`。 +原始 `ORT_TSTR` 等仍通过： + +```cpp +#include // 必须在 import 之前 +import mcpplibs.mwrap.onnxruntime; +``` + +因为宏是预处理概念，模块无法“导出”它；任何声称模块能导出宏的方案都是错的。 + +### 5.4 配置键：内部链接的等价替换 + +见 2.4。这里补三个注意点： + +1. 类型必须逐字保留：测试用 + `static_assert(std::is_same_v)` 锁死； +2. 值必须逐字保留：测试比较 `std::string_view(k...) == "session.disable_prepacking"`； +3. **不能和原始配置头混用**，否则同名实体冲突；根模块也刻意不 `export import` + `.config`，让消费者显式选择。 + +### 5.5 宏的“展开环境”是模块构建环境 + +模块 BMI 是在**构建模块时**的环境下生成的：平台宏、`ORT_API_VERSION`、 +特性宏、`NDEBUG` 等都固定了。消费者之后 `#define` 什么，都不会改变模块里 +已经展开的声明。ONNX 文档因此明确说：默认模块使用 SDK 的正常 API 初始化模式， +不响应调用方后来的预处理改动。这是所有“头文件 → 模块”方案的固有限制， +必须在文档和测试里写清楚。 + +--- + +## 6. `onnxruntime-m` 完整流程 + +### 6.1 仓库定位 + +```text +onnxruntime-m/ + mcpp.toml # 包身份 + 模块源 + compat 依赖 + 运行时部署 + src/onnxruntime.cppm # 根模块：include 头 + 包含 exports.inc + src/config.cppm # 配置键模块 + src/macros.cppm # 版本宏映射 + src/exports.inc # 生成：C/C++ using 清单 + src/config_exports.inc # 生成：69 个配置常量 + port/include/mwrap/onnxruntime/macros.hpp # 宏兼容头 + upstream/ + api-surface.json # 生成：API 清单（287 C + 107 Ort + 14 Custom + 3 onnxruntime + 69 config） + api-coverage.md # 头文件 → 模块面覆盖说明 + sources.lock.toml # SDK/补充头的 URL 与 SHA256 + include/core/providers/ # Windows SDK 缺失的两个头（逐字副本） + tools/ + generate_exports.py # AST 生成器 + generate_model.py # 生成测试用 Identity ONNX 模型 + check_mwrap_release.py # mwrap 身份/README/许可证/哈希检查 + test_candidate.py # 候选 SDK 索引下的真实构建/运行/审计 + tests/ + inference.cpp # 真实 CPU 推理 + public_surface.cpp # 类型/常量/工厂 API 的 static_assert + headers_mix.cpp # 模块与原始头共存 + templates/inference/ # mcpp 模板（内嵌模型，无需下载） +``` + +包声明： + +```toml +[package] +namespace = "mcpplibs.mwrap" +name = "onnxruntime" +version = "1.25.1" + +[build] +sources = ["src/onnxruntime.cppm", "src/macros.cppm", "src/config.cppm"] +include_dirs = ["port/include", "upstream/include"] + +[dependencies.compat] +onnxruntime = "1.25.1" + +[target.x86_64-linux-gnu] +cxx_runtime = "toolchain-coupled" +``` + +### 6.2 上游从哪来：`compat` 提供方，而不是 vendored 源码 + +ONNX 不在仓库里保存实现，而是依赖索引里的 +`compat.onnxruntime`（`mcpp-index/pkgs/c/compat.onnxruntime.lua`）。这个提供方： + +- 下载官方 CPU SDK（Linux `.tgz`、macOS `.tar.gz`、Windows `.zip`），带 SHA256； +- 声明平台运行时闭包（Linux：`onnxruntime` + `stdc++` + `gcc-runtime`/`glibc` 兼容桩）； +- 用 `generated_files` 生成一个 `sdk.cpp`，其中 `static_assert(ORT_API_VERSION == 25)` + 并检查平台 ABI（macOS arm64 / Linux-Windows x86_64 / glibc / MSVC ABI）； +- 部署 SDK 的 `LICENSE` 与 `ThirdPartyNotices.txt`。 + +**职责边界很清晰**：`compat` 拥有头文件和 `libonnxruntime.so`； +`mcpplibs.mwrap.onnxruntime` 拥有模块接口。二者版本必须一一对应（`1.25.1`）。 + +这样做的好处是：模块仓库极小（约 62KB 的树，不含 SDK）， +不需要在仓库里放几百 MB 的二进制；代价是构建/发布必须同时保证提供方可用， +并且 SDK 的平台限制就是模块的平台限制（CPU only、glibc、MSVC ABI、macOS arm64）。 + +### 6.3 生成器逐步拆解 + +`tools/generate_exports.py` 的入口： + +```bash +python3 tools/generate_exports.py [--clang clang++] [--check] +``` + +**第 1 步：校验补充头** + +```python +lock = tomllib.loads((root / "upstream/sources.lock.toml").read_text()) +for header in lock["onnxruntime"]["supplemental-headers"].values(): + digest = sha256((root / header["path"]).read_bytes()) + if digest != header["sha256"]: + raise SystemExit(...) +``` + +Windows 官方 SDK 缺少 `core/providers/custom_op_context.h` 与 `resource.h`， +仓库在 `upstream/include` 放了官方 v1.25.1 源码的逐字副本，并把哈希锁死。 +这属于“平台头文件补齐”，不是发明 API。 + +**第 2 步：构造探针并跑 Clang** + +```python +probe.write_text("\n".join(f"#include <{h}>" for h in ( + "onnxruntime_cxx_api.h", "cpu_provider_factory.h", "provider_options.h", + "onnxruntime_lite_custom_op.h", "core/providers/custom_op_context.h", + "core/providers/resource.h")) + + "\nnamespace mwrap_onnxruntime_config_detail {\n" + + "\n".join(f"#include <{h}>" for h in config_headers) + "\n}\n") + +subprocess.run([clang, "-std=c++23", "-I", sdk_include, "-I", upstream_include, + "-Xclang", "-ast-dump=json", "-fsyntax-only", probe], + stdout=out, check=True) +``` + +**第 3 步：`generate(ast)`** + +- 收集 `Ort`、`Ort::Custom`、`onnxruntime`、`mwrap_onnxruntime_config_detail` + 四个命名空间的所有重开节点； +- 按 4.3 的规则过滤； +- C API 走 `LinkageSpecDecl` + 前缀/白名单； +- 返回 `(sorted(capi), cpp_dict)`。 + +**第 4 步：写文件（或校验）** + +```python +outputs = { + "src/exports.inc": text, + "src/config_exports.inc": config_text, + "upstream/api-surface.json": json.dumps({ + "version": "1.25.1", + "c": capi, + "cpp": cpp["Ort"], + "config-keys": sorted(config_keys), + "cpp-namespaces": {...}}, indent=2) + "\n", +} +``` + +`--check` 模式下逐字节比较，任何差异都以非零退出；不写文件。 +生成物没有时间戳、没有绝对路径、没有随机顺序，因此可复现。 + +**第 5 步：人工评审** + +生成器只保证“名字来自 AST”，不保证“这个面是对的”。所以仓库还有 +`upstream/api-coverage.md`：逐个头文件说明它对应模块的哪一部分、 +哪些是内部实现、哪些平台缺失、哪些不能导出。这是生成器无法替代的 +**人工边界声明**。 + +### 6.4 三个模块的编译关系 + +```text +src/onnxruntime.cppm + module; #include 6 个 SDK 头 + export module mcpplibs.mwrap.onnxruntime; + export import mcpplibs.mwrap.onnxruntime.macros; + #include "exports.inc" // using 清单进入模块体 + +src/config.cppm + module; namespace detail { #include 4 个配置头 } + export module ...config; + #include "config_exports.inc" // inline constexpr 常量 + +src/macros.cppm + module; #include onnxruntime_c_api.h; 捕获 ORT_API_VERSION; #undef + export module ...macros; + export namespace ...::macros { inline constexpr ... } +``` + +注意 `exports.inc`、`config_exports.inc` **不是独立编译单元**，也不在 +`[build].sources` 里；它们被文本包含，实体属于所在模块。把它们误列为源文件 +会导致重复定义。 + +### 6.5 平台与运行时适配 + +- **Linux**：官方 SDK 是共享库，自身依赖 libstdc++；GCC 消费者若嵌入另一份 + 静态 libstdc++，会出现“SDK 抛出的异常无法被消费者捕获”的跨运行时问题。 + 因此 `[target.x86_64-linux-gnu] cxx_runtime = "toolchain-coupled"`， + 让可执行文件共享同一份 C++ 运行时。提供方还把声明的 `gcc-runtime` + 中的 `libstdc++.so.6`、`libgcc_s.so.1` 软链到 SDK 的 `lib/`，不扫描宿主库。 +- **macOS**：SDK 安装名是 `@rpath/libonnxruntime.1.25.1.dylib`，消费者需要 + `-Wl,-rpath,@loader_path`，让部署到可执行文件旁的 dylib 能被找到。 +- **Windows**：MSVC ABI；官方 SDK 缺两个 helper 头，用逐字副本补齐。 +- **不支持**：GPU EP、musl、MinGW。CPU SDK 里有 EP API 的声明，但**没有 GPU + 提供方二进制**；文档明确说“API 可用 ≠ 能执行该 EP”，避免过度承诺。 + +### 6.6 验证链 + +- `tests/public_surface.cpp`：`sizeof(OrtEpApi)`、`CreateEpApiFactoriesFn` 是指针、 + `Ort::Custom::Tensor` 是类、配置键类型是 `const char* const`、 + `cpu_resource_offset == 0`、`ProviderOptions` 行为、CPU provider 注册； +- `tests/inference.cpp`：真实 Identity 模型推理，校验输出形状和值； +- `tests/headers_mix.cpp`：模块与原始头共存； +- `tools/generate_model.py`：可复现地生成测试模型（不下载外部数据）； +- `tools/test_candidate.py`：在临时副本里追加候选索引，真实 `mcpp test`， + LLVM job 还会从 `compile_commands.json` 里找到**实际解析到的 SDK include + 路径和 clang**，再跑 `generate_exports.py --check`；可选 `--cold-sdk` + 在空 `MCPP_HOME` 中验证 SDK 能安装； +- CI 矩阵：Linux LLVM、Linux GCC、macOS arm64、Windows MSVC ABI； +- `check_mwrap_release.py`：命名空间、版本规则、Apache-2.0、NOTICE、 + README 双语/长度/互链、`upstream/documents.json` 哈希、 + `runtime.deploy` 必须包含 LICENSE/NOTICE 与上游文档。 + +--- + +## 7. `llama.cpp-m` 完整流程 + +### 7.1 仓库定位 + +```text +llama.cpp-m/ + mcpp.toml # 16KB 清单：源文件、按架构/OS 的 flags、feature、生成文件 + build.mcpp # 构建程序：Metal 内嵌 + Vulkan shader 图 + src/llamacpp.cppm # 根模块 + src/macros.cppm # 类型化常量模块 + src/gen_exports/ + llama.inc # 生成：388 条 llama 导出 + required_ggml.inc # 生成：99 条 ggml 导出 + typed_constants.inc # 生成：13 个常量 + llama.skipped.txt # 生成：宏跳过清单 + generated/ # 清单内联生成的稳定构建输入（shim + build_info.h） + snapshots/b10069.json # 生成：源码/注册表/ABI/API 全量快照 + third_party/llama.cpp/ # 官方 tag 归档，逐字 vendored + upstream.lock # tag/commit/archive URL/SHA256 + tools/ + import_upstream.py # 确定性导入 + gen_exports.py # AST + 宏导出生成 + audit_snapshot.py # 源码/API/布局审计 + generate_build_files.py # 把 [generated_files] 落盘并 --check + check_upstream.py # 每周上游检查 + check_release.py # 发布门禁 + test_template.py # 真实模板渲染/构建/运行 + tests/unit/ # 生成器、清单契约、审计、导入的单元测试 + tests/cpu_decode.cpp ... # 真实推理/后端测试 +``` + +### 7.2 确定性导入：`import_upstream.py` + `upstream.lock` + +`upstream.lock`（b10069）： + +```toml +[upstream] +repository = "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/ggml-org/llama.cpp" +tag = "b10069" +commit = "178a6c44937154dc4c4eff0d166f4a044c4fceba" +archive_url = "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/ggml-org/llama.cpp/archive/refs/tags/b10069.tar.gz" +archive_sha256 = "293a7c65..." +imported_at_utc = "2026-07-29T00:00:00Z" +``` + +导入器强制： + +- 仓库必须是官方 `ggml-org/llama.cpp`； +- archive URL 必须是**官方 tag 归档**的规范形式，不能是任意镜像； +- commit 40 位、SHA256 64 位的格式校验； +- 下载有大小上限、临时文件 + 原子替换、对 408/429/5xx 和网络错误做 + **有界指数退避**（最多 3 次），对稳定 4xx、摘要不匹配、源码漂移立即失败； +- tar 解包前校验成员路径（防目录穿越），只接受预期前缀； +- `--check` 模式只比对，不写；`--verify-tag` 额外核对 tag 与 commit。 + +原则：**消费者构建时不联网、不拉 submodule**；发布归档里已经包含 +`third_party/llama.cpp`。vendored 源码默认零补丁；不可避免的补丁要单独存放、 +在发布说明中记录、并有回归测试。 + +### 7.3 导出生成：`gen_exports.py` + +#### 输入与命令 + +```bash +python3 tools/gen_exports.py [--upstream ] [--output-dir src/gen_exports] [--check] +``` + +默认对 `third_party/llama.cpp` 的 `include/llama.h`、`ggml/include/ggml.h`、 +`ggml-backend.h`、`ggml-alloc.h` 做两次 Clang 调用： + +```python +# 1) 语义 AST（注意：这里用 C++20 语法模式即可，模块本身仍是 C++23） +clang -std=c++20 -fsyntax-only -Xclang -ast-dump=json -I... probe.cpp + +# 2) 宏定义（-dM -E） +clang -dM -E -I... - <<< '#include "llama.h"' +``` + +#### 导出判定 + +| 对象 | 条件 | 输出 | +|---|---|---| +| `llama_*` 函数 | 名字前缀 + 源码行含 `LLAMA_API` | `export using ::...;` | +| `llama_*` 记录/typedef/类模板/枚举 | 名字前缀 | `export using ::...;` | +| ggml 类型 | 在 `REQUIRED_GGML_TYPES` 白名单 | 同上 | +| ggml 函数 | 在 `REQUIRED_GGML_FUNCTIONS` 白名单 | 同上 | +| ggml 枚举项 | 属于 `GGML_ENUM_TYPES` 或显式成员白名单 | 同上 | +| `LLAMA_*` 枚举项 | 前缀 | 同上 | +| 对象式 `LLAMA_*` 宏 | 在 `TYPED_LLAMA_CONSTANTS` 表 | `inline constexpr`（见 5.2） | +| 其他 `LLAMA_*` 宏 | 一律 | `llama.skipped.txt` | +| 非白名单 ggml | 一律 | 不导出 | + +#### 必须通过的内部一致性检查 + +```python +missing_ggml = sorted((REQUIRED_GGML_TYPES | REQUIRED_GGML_ENUM_MEMBERS | + REQUIRED_GGML_FUNCTIONS) - exported_ggml) +if missing_ggml: + raise RuntimeError("required GGML API missing from Clang AST: " + ...) +``` + +这防止“白名单写了但上游删了/改名了”导致静默缺失。同理，typed constants +的宏依赖必须存在，缺失或循环引用直接失败。 + +#### 输出 + +- `llama.inc`：388 条 `export using`（含 deprecated API，测试明确断言保留）； +- `required_ggml.inc`：99 条； +- `typed_constants.inc`：13 条带类型常量； +- `llama.skipped.txt`：13 个宏 + `LLAMA_API`/`LLAMA_H`，每条都有分类前缀 + （`macro ...`），便于人审。 + +所有输出排序、无时间戳；`--check` 逐字节比较，不写文件。 + +### 7.4 API 快照与审计：为什么不止“导出清单” + +`export using` 清单能发现**名字**的增删，但发现不了： + +- 函数签名/参数类型变化（同名不同型）； +- 结构体字段增删、顺序、位宽、对齐属性变化（ABI 破坏）； +- 枚举值变化； +- 宏值变化； +- typedef 背后真实类型变化（如 `int64_t` 在 macOS 是 `long long`、 + Linux 是 `long`）。 + +所以 `collect_api_snapshot()` 为每个声明记录“指纹”： + +```python +"llama_model": "CXXRecordDecl:{...fields, bit_width, attributes, bases...}" +"llama_token": "TypedefDecl:int32_t" +"LLAMA_DEFAULT_SEED": "EnumConstantDecl:..." +``` + +记录布局时： + +- `_type_fingerprint()` 规范化匿名结构体地址 + `(anonymous struct at file:line:col)` → `(anonymous struct)`； +- 对 `int8_t/uint64_t` 等定宽整数，把 `desugaredQualType` 统一成 + `signed 64-bit integer`，消除平台 typedef 差异； +- `_record_layout()` 记录字段名、类型、位域宽度、属性、嵌套记录、基类； +- `_resolved_enum_values()` 手动补全 Clang JSON 省略的隐式枚举值（+1 递增）。 + +`snapshots/b10069.json` 还记录： + +- `upstream`：tag/commit/URL/SHA256； +- `sources`：按 `ggml_base`、`ggml_registry`、`ggml_cpu_common`、 + `ggml_cpu_x86`、`ggml_cpu_arm`、`llama_core`、`models`、`ggml_metal` 分组； +- `registry`：`GGML_USE_*` → 注册函数名； +- `metal`、`dialect_exceptions`（哪些模型文件强制 C++20）、 + `platform_links`（Windows `advapi32`）、 + `public_header_sha256`； +- `api`：declarations/macros/manual_decisions/typed_constants。 + +`audit_snapshot.py` 负责： + +- 从上游 CMakeLists 解析源文件选择，与 `mcpp.toml` 的 source 列表比对 + （确保“清单选的文件 = 上游 CMake 在这种配置下会选的文件”）； +- 校验公开头 SHA256； +- 比对 API 快照，输出 `added/removed/changed/breaking` 分类； +- 对 breaking 变更要求显式 `--accept-breaking-api `， + 且接受文件必须与报告完全相同，不能“一键刷新”掩盖破坏； +- 当快照记录的 Clang 与当前 Clang 不同，报告会提示“这可能是 AST 表示差异， + 不是 API 变化”，避免误导排查方向。 + +这是两个仓库里 llama 独有的深度：**它不仅锁“导出什么”，还锁“源码选择、 +头文件字节、结构体布局、枚举值、宏值”。** + +### 7.5 构建层生成：`build.mcpp` + +`onnxruntime-m` 是声明式清单就够了；`llama.cpp-m` 有两个后端需要“构建期 +生成”，所以有 `build.mcpp`（`import std; import mcpp;` 的 C++ 程序）。 + +#### Metal（macOS arm64，`backend-metal`） + +1. 校验 `target_os=macos`、`target_arch=aarch64`； +2. 读 `ggml-common.h`、`ggml-metal.metal`、`ggml-metal-impl.h`； +3. 用 `replace_once()` 把 `__embed_ggml-common.h__` 和 + `#include "ggml-metal-impl.h"` 替换成实际内容（必须恰好出现一次， + 否则报错，防止上游改结构后静默生成错误文件）； +4. 生成 `ggml-metal-embed.metal`； +5. 生成汇编： + + ```asm + .section __DATA,__ggml_metallib + .globl _ggml_metallib_start + _ggml_metallib_start: + .incbin ".../ggml-metal-embed.metal" + .globl _ggml_metallib_end + _ggml_metallib_end: + ``` + +6. `mcpp::generated(assembly)` 把它加入构建；`mcpp::define("GGML_METAL_EMBED_LIBRARY")`； +7. `mcpp::rerun_if_changed()` 声明三个输入。 + +结果：Metal shader 库被**静态内嵌**进产物，运行时不需要外部 `.metallib`。 +测试要求看到 “using embedded metal library”、正的 offload 层数、正的 Metal +buffer 大小，编译成功不算覆盖。 + +#### Vulkan（Linux，`backend-vulkan`） + +这里体现了“**声明构建图，而不是自己跑循环**”的原则： + +- 先用 `glslc` 做 7 个扩展能力探针（cooperative matrix、bfloat16、e2m1/e4m3 等）。 + 探针**以编译退出码为准**，不是解析错误消息；编译失败但没有明确说 + “extension not supported” 时，按“不支持”处理并告警，避免把“工具没跑起来” + 误判为“支持”。 +- 探针结果同时用于生成器的 `-D` 和 `ggml-vulkan.cpp` 的 `-D`： + **一次探测，两个读者**，防止两份判断漂移。 +- 构造 `mcpp::action`： + - `vulkan:shaders-gen`：用工具链编译器编译 vendored 的 + `vulkan-shaders-gen.cpp`，产出生成器； + - `vulkan:shaders-hpp`：生成共享头 `ggml-vulkan-shaders.hpp`； + - 每个 `.comp` 一条 action：输入生成器 + 自身 + 所有 `.glsl` 片段， + 输出 `.comp.cpp`。 +- 这样每个 shader 都是**独立、可增量、可并行、失败可归因**的图边； + 测试断言 action 数 = shader 数 + 2，且程序自己**不写任何生成源文件**。 +- 拒绝的组合都显式报错，而不是让编译在一个很远的地方失败： + - 非 Linux（macOS 用 Metal；Windows loader 不同）； + - libc++ 工具链（上游 `ggml-vulkan.cpp` 对不完整类型 + `std::unique_ptr` 的析构触发 libc++ 静态断言； + libstdc++ 接受。这是上游源码问题，仓库不打补丁，只拒绝）； + - 交叉编译（生成器必须在构建机运行）； + - 缺少 `xim:shaderc` / `glslc`。 +- 第二个编译器必须被告知 `--sysroot` 和 `-B`（`mcpp::toolchain_sysroot()`、 + `mcpp::toolchain_binutils_dir()`），否则会读宿主 `/usr/include`， + 在干净 CI 上暴露 `features.h: No such file or directory`。 +- `vulkan-shaders-gen` 链接成自包含产物：g++ 用 `-static`， + clang++ 用 `-static-libstdc++ -lc++abi`（实测 `-static` 在 libc++ 下 + 链接失败或启动段错误）。 + +#### `[generated_files]` 与小 shim + +清单里内联了四个稳定生成文件： + +```toml +[generated_files] +"generated/ggml_cpp.cpp" = "#include \"ggml.cpp\"\n" +"generated/ggml-cpu_cpp.cpp" = "#include \"ggml-cpu.cpp\"\n" +"generated/ggml_metal_device_m.m" = "#include \"ggml-metal-device.m\"\n" +"generated/ggml_build_info.h" = """ +#pragma once +#define GGML_VERSION "b10069" +#define GGML_COMMIT "178a6c..." +""" +``` + +`tools/generate_build_files.py --check` 负责把这些内联内容与磁盘文件逐字比对。 +`tests/unit/test_build_contract.py` 里有一张 `GENERATED_SOURCE_MAP`，把 +`generated/ggml_cpp.cpp` 映射回 `ggml/src/ggml.cpp`，从而让“源码选择审计” +仍能按上游文件集合比对。 + +> 说明：这层 shim 的直接效果是给构建系统一个**稳定、可寻址的翻译单元名**， +> 并让 `[build.flags]` 能按 glob 精确附加 flags（如 `GGML_USE_LLAMAFILE`）。 +> 具体动机应以 mcpp 引擎的对象命名规则为准；阅读时应把它理解为 +> “构建输入适配”，而不是模块导出的一部分。 + +### 7.6 清单里的源码选择 + +`mcpp.toml` 不是 `sources = glob("**/*.cpp")`，而是**逐文件列表**： + +- ggml 基础、registry、CPU common、llama core、137 个 `src/models/*.cpp`； +- `[target.'cfg(arch = "x86_64")'.build]` 加 x86 quants/repack； +- `[target.'cfg(arch = "aarch64")'.build]` 加 ARM 版本； +- 每个平台单独的 `cflags/cxxflags/ldflags`（Linux `-ldl -lpthread -lm`， + macOS Metal/Foundation frameworks，Windows `advapi32`）； +- third-party 代码统一 `-w -include ggml_build_info.h`，不把上游警告 + 变成消费者警告； +- 少数模型文件强制 `-std=c++20`（`dialect_exceptions`，快照里有记录）。 + +**为什么不用 glob**：上游源码树里有很多不参与该配置的文件（其他后端、 +测试、工具），glob 会把它们拉进来；逐文件列表才能和上游 CMake 的选择 +做审计比对，也才能让“这个文件为什么在/不在”可回答。 + +### 7.7 特性与运行时 + +```toml +[features] +default = { implies = ["backend-cpu"] } +backend-cpu = {} +[features.backend-metal] ... # macOS arm64 +[features.backend-vulkan] ... # Linux + libstdc++ + 134 shaders +[feature-deps.backend-vulkan] +compat.vulkan = "1.4.357.0" +compat.spirv-headers = "1.4.357.0" +compat.vulkan-runtime = "2026.09.11" +[feature-xlings.backend-vulkan] +"xim:shaderc" = "2026.3" +"xim:mesa-lavapipe" = { version = "26.2.1", when = "dev" } +``` + +要点： + +- 未启用的 backend 不引入任何依赖（CPU-only 消费者不装 Vulkan loader）； +- `GGML_USE_VULKAN` 必须同时定义在 `ggml-backend-reg.cpp` 上，否则库能编能链， + 但运行时不注册 Vulkan 设备——**一个没有报错的失败**； +- `mesa-lavapipe` 是 `when = "dev"`，只给本仓库测试用，不进消费者安装； +- `runtime.deploy` 部署 wrapper 与上游的 LICENSE/NOTICE/README。 + +### 7.8 验证链 + +CI（`.github/workflows/ci.yml`）的 `unit-and-import` 顺序是有意的： + +```text +check_mwrap_release.py +→ 安装 pinned mcpp +→ generate_build_files.py --check +→ mcpp build --strict --no-cache # 先构建，产出 build.mcpp 二进制 +→ unittest discover tests/unit # 其中会运行 build.mcpp 做契约测试 +→ test_template.py # 真实模板渲染/构建/运行 +→ import_upstream.py --check --verify-tag +→ gen_exports.py --check +→ audit_snapshot.py --check snapshots/b10069.json +``` + +为什么先 `mcpp build`：`build.mcpp` 是模块程序，普通 `c++` 编不了； +单元测试要运行 mcpp 编出来的二进制。`LLAMACPP_REQUIRE_BUILD_HELPER=1` +把“二进制缺失”从 skip 变成 fail，防止某个 job 什么都没测却绿。 + +另外： + +- 多平台 CPU 构建/推理（Linux x86_64/ARM64、Windows、macOS）； +- Metal：注册、分配、offload、decode、sample 都要有正证据； +- Vulkan：同一 prompt 分别全 CPU/全 offload，贪心采样必须得到同一 token； + 且先从 llama.cpp 日志确认真的 offload，否则“设备没跑但 token 合法”会骗过测试； +- 模板测试走真实 `mcpp new`，不是手写 manifest； +- 发布前 `check_release.py --tag mwrap-` 校验 tag/版本/lock/ + vendored 源码/exports/snapshot 一致。 + +--- + +## 8. 两个仓库的对比与分工 + +| 问题 | onnxruntime-m | llama.cpp-m | +|---|---|---| +| 上游交付形式 | 预编译 SDK（共享库） | 源码（随包编译成静态库） | +| 谁拥有实现 | `compat.onnxruntime` 提供方 | 本仓库 `third_party/llama.cpp` | +| 模块面 | C API + `Ort::` C++ API + `Ort::Custom` + `onnxruntime::ProviderOptions` | llama C API + 最小 ggml 面 | +| 生成器复杂度 | 中（命名空间/白名单/AST） | 高（AST + 宏 + 布局指纹 + CMake 源选择审计） | +| 宏处理 | `.macros` + 兼容头 + 69 个 config 常量 | `.macros` + `#undef` + typed constants + skipped 清单 | +| ABI 审计 | 依赖 SDK 版本固定 + 类型 static_assert | 结构体布局/枚举值/头哈希快照 | +| 构建脚本 | 无 | `build.mcpp`（Metal/Vulkan） | +| 平台策略 | 官方 SDK 支持什么就支持什么 | 自己选源文件、自己控 flags/后端 | +| 版本语义 | 上游语义版本 `1.25.1` | 上游 build 号 `b10069`（非 semver，精确 pin） | +| 主要风险 | C++ 运行时耦合、SDK 平台限制、内部链接变量 | 上游源码/ABI 漂移、shader/工具链、源选择偏差 | + +共同点： + +- 都是 `mcpplibs.mwrap` 身份，保留上游命名； +- 都用 Clang AST 生成 `using`，都用 `--check` 锁死； +- 都把“不能导出的东西”显式记录（config 常量 / skipped 宏）； +- 都有真实消费者测试、模板、双语 README、许可证部署、CI 门禁； +- 都拒绝“静默降级”：不可用平台/后端/工具链直接报错。 + +--- + +## 9. 注意事项与常见坑 + +下面按“会出什么问题 → 为什么 → 对策”组织。这些不是理论风险，多数在两个 +仓库的代码注释/测试里有对应记录。 + +### 9.1 AST 与生成器 + +1. **不要依赖 `loc.file` 判断声明来自哪个头。** + Clang JSON AST 可能把位置指向探针 `.cpp`；用命名前缀/命名空间/白名单。 + llama 的代码里明确写了这一点。 + +2. **必须过滤隐式声明和类外定义。** + `isImplicit`、`parentDeclContextId not in namespace_ids` 两条缺一不可； + 否则会把编译器合成成员、私有实现细节导出成公开 API。 + +3. **不要导出成员函数模板到命名空间作用域。** + 对 `FunctionTemplateDecl` 里含 `CXXMethodDecl` 的节点要跳过； + 类的成员模板会随类一起导出。 + +4. **AST JSON 随 Clang 版本漂移。** + 同一份头文件，不同 Clang 可能写出 `desugaredQualType` 与否、匿名类型地址不同。 + 对策：规范化指纹（匿名结构体、定宽整数）、记录 `generator` 身份、 + 审计报告区分“换编译器”与“API 变化”。 + +5. **平台 typedef 差异会制造假 diff。** + `int64_t` 的 desugared 类型在 macOS/Linux 不同；不规范化就会出现 + “什么都没改但快照变了”。llama 用 `signed N-bit integer` 规则解决。 + +6. **隐式枚举值不能假设 AST 一定给出。** + `enum { A = 1, B, C }` 中 B/C 可能没有 `value` 字段；要按前值 +1 补全， + 否则快照里的值会缺失/错误。 + +7. **生成顺序必须稳定。** + 所有输出排序、JSON 固定缩进、不写时间戳/绝对路径/随机 ID； + 否则 `--check` 永远失败，或 CI 因机器不同而红。 + +8. **`--check` 必须逐字节比较且不写文件。** + 只比较“名字集合”会漏掉类型/值变化；只“重新生成后 git diff”会让 + 失败信息不可读，还可能意外改写工作区。 + +9. **生成器不是正确性证明。** + AST 只能说明“头文件里有这个名字”，不能说明“这个 API 在目标平台可用”。 + 需要 `api-coverage.md` 这类人工边界文档 + 真实运行测试。 + +10. **条件编译只覆盖探针环境。** + 模块 BMI 里只有探针那次预处理的结果；平台/宏条件分支的其他声明不会 + 自动出现。跨平台导出集要么分别审计，要么保持头文件平台中立并测试。 + +### 9.2 宏 + +11. **不要承诺“模块导出宏”。** + 具名模块没有宏导出机制；对象式宏只能映射成常量，函数式宏只能留在头文件。 + 文档必须写清“先 `#include` 再 `import`”的顺序要求。 + +12. **映射宏前必须 `#undef`。** + 否则宏名在模块体里被展开，`inline constexpr` 定义直接语法错误。 + +13. **类型要跟着宏走。** + `LLAMA_TOKEN_NULL` 应该是 `llama_token` 而不是 `int`； + 枚举标志要 `static_cast` 到枚举类型；否则重载解析/比较会出现细微差异。 + +14. **宏展开可能改变调用点语义。** + `ORT_TSTR` 涉及 `L""`/`u""` 前缀；函数式宏可能有参数多次求值、 + `do { } while(0)`、`#`/`##`。这些**不能**用普通函数等价替换， + 必须保留原始头文件。 + +15. **内部链接变量不能直接导出。** + GCC 会拒绝；用“私有命名空间 + 同名同类型 inline 常量”替换， + 并明确“不能与原始头混用”。 + +16. **宏名冲突是双向的。** + 消费者若同时包含原始配置头和 `.config` 模块，会出现两个同名实体； + 根模块刻意不 re-export `.config`，把选择权交给消费者。 + +### 9.3 链接、ABI 与运行时 + +17. **模块不改变链接方式。** + `import` 只带来声明和 BMI；消费者仍要链接 `onnxruntime`/`llama`。 + 忘记链接会出现“编译通过、链接失败”。 + +18. **C++ 运行时必须只有一份。** + ONNX SDK 是共享库且自身依赖 libstdc++；消费者若静态嵌入另一份， + 跨边界抛出的 `Ort::Exception` 可能无法被捕获。 + 对策：`cxx_runtime = "toolchain-coupled"`，并在模板里固化。 + +19. **共享库的运行时搜索路径要显式声明。** + macOS 的 `@rpath`、Linux 的 `RUNPATH=$ORIGIN`、Windows 的 DLL 同目录， + 都需要 `runtime.deploy`/`ldflags` 配合；只把 `.so` 放在旁边不够。 + +20. **不要同时链接 vendored 实现和 compat 实现。** + 同一个库在一个程序里只能有一个属主；重复实现会导致符号/ABI 冲突。 + `mwrap.md` 明确写了这一点。 + +21. **导出 `using` 不会改变可见性属性。** + 上游的 `LLAMA_API`/`ORT_API2_STATUS` 已经展开成 `visibility`/`dllimport`； + 如果上游漏了标记，模块也救不了。这是上游问题，不要用 wrapper 补。 + +22. **deprecated API 也要导出。** + llama 的测试明确断言保留 deprecated C API；删除它们会破坏“无缝迁移”， + 应通过 release notes 而不是静默裁剪来处理。 + +23. **异常/错误码语义不能包装掉。** + ONNX 的 `Ort::Exception`、llama 的返回码/NULL 都要原样保留； + 生成器不生成 try/catch，也不做返回值转换。 + +### 9.4 构建图与增量 + +24. **构建脚本不要自己循环生成几百个文件。** + 那会串行、不可增量、失败只能报“build.mcpp exited 1”； + 应该像 llama 一样为每个产物 `submit()` 一条 action，声明 input/output。 + +25. **生成器自身也要是图里的一条边。** + `vulkan-shaders-gen` 编译、共享头生成、每个 shader 生成，三者分开； + 否则改一个 shader 会重跑全部，或改了生成器不重跑。 + +26. **第二个编译器要显式给 sysroot/binutils。** + 构建程序启动的子编译器不知道 mcpp 的 sysroot，默认会读宿主 `/usr/include`； + 本地可能“碰巧能编”，干净 CI 立刻失败。 + +27. **能力探测以编译结果为准。** + 解析 glslc 的错误文本会把“工具没启动/磁盘满/测试 shader 改名”误判为 + “扩展支持”；必须以退出码为准，异常情况按不支持处理并告警。 + +28. **一次探测，多处使用。** + 生成器和 `ggml-vulkan.cpp` 必须用同一组 `-D`；探测两次必然漂移。 + +29. **不要跨平台“试试看”。** + Vulkan 在 macOS 需要 MoltenVK、Windows loader 语义不同； + 显式拒绝比在深处报一个无关错误好。 + +30. **生成文件要保持时间戳稳定。** + `mwrap.md` 明确要求：内容未变时不要 touch，否则一个公共头会让整棵 + vendored 源码重编。CI 要同时验证“字节幂等”和“增量行为”。 + +31. **构建期不要写源码树。** + 生成物写到 `MCPP_OUT_DIR`，不要在 `build.mcpp` 里改 `third_party/` 或 + `src/`；否则并发配置互相覆盖，且工作区变脏。 + +### 9.5 供应链与可重复性 + +32. **锁定一切。** + `.xlings.json` 锁 mcpp 版本；`upstream.lock`/`sources.lock.toml` 锁上游 + tag/commit/归档 SHA256；补充头单独锁哈希；CI 用 pinned 工具链。 + +33. **归档 URL 要规范化。** + 只接受官方 tag 归档形式，防止镜像/分支内容漂移； + 下载做大小上限、原子替换、有界重试。 + +34. **vendored 源码默认零补丁。** + 必须打补丁时单独存放、记录理由、加回归测试；不要“顺手改一下”。 + +35. **许可证要随产物部署。** + 共享 SDK 的 `LICENSE`/`ThirdPartyNotices.txt` 不会被自动发现； + 用 `runtime.deploy` 显式声明目标路径，并在重定位后的消费者包里验证字节。 + +### 9.6 版本与发布 + +36. **版本就是上游版本，不另造 0.x。** + `llama.cpp-m` 用 `b10069`，修订用 `b10069.1`； + `onnxruntime-m` 用 `1.25.1`，修订只能是 `1.25.1.N`（N≥1）。 + 不要同时发布 `5.0.0` 和 `5.0.0.0`（比较相等）。 + +37. **非 semver 版本只能精确 pin。** + `b10069` 不能表达范围；消费者要用新 feature 必须改版本号。 + 这是已知代价，发布说明要写清。 + +38. **发布不可变。** + tag、归档、索引条目一旦发布不改；修复发新修订。 + 首次发布前的替换是显式授权的例外。 + +39. **breaking 变更不能靠“重新生成快照”通过。** + llama 的审计要求 `--accept-breaking-api` 且接受内容与报告完全一致； + 删除/改签名必须在 release notes 里解释。 + +### 9.7 测试与资源 + +40. **编译成功不等于后端可用。** + Metal 要证明注册/分配/offload；Vulkan 要证明真的 offload 且结果与 CPU 一致； + ONNX 要跑真实推理，不是只 `sizeof`。 + +41. **模板要走真实渲染器。** + 手写一个等价 manifest 测试不到 `{{self.name}}`、feature 转发、模板归档等 + 真实路径；两个仓库都有 `test_template.py`。 + +42. **cold consumer 测试。** + 在空 `MCPP_HOME`/隔离索引里真正下载、安装、构建、运行； + 否则“本机已装好”会掩盖依赖缺失。 + +43. **本地测试资源有预算。** + `mwrap.md` 要求本地测试总量不超过机器可用 CPU/内存的 80%； + AST 子进程、代码生成、编译都要计入，必要时用 cgroup 限制。 + +44. **skip 要能变成 fail。** + CI 专用 job 用 `LLAMACPP_REQUIRE_*` 把“工具缺失导致 skip”变成失败， + 防止关键 job 什么都没测却绿。 + +--- + +## 10. 复刻清单：新增一个 `xxx-m` 的最小步骤 + +1. **确认上游形态** + - 有稳定公开头 + 预编译 SDK → 走 onnx 模式（`compat` 提供方 + AST 导出）； + - 只有源码/需要自己选源文件 → 走 llama 模式（vendored + lock + 快照）。 + +2. **建立身份** + - 仓库 `xxx-m`，`namespace = "mcpplibs.mwrap"`，`name = "xxx"`； + - 根模块 `mcpplibs.mwrap.xxx`； + - `[package.metadata.mwrap]` 记录 upstream-version/repo。 + +3. **锁定上游** + - 源码：`upstream.lock`（repo/tag/commit/archive_url/sha256）； + - SDK：`sources.lock.toml` + 头文件哈希； + - `.xlings.json` 锁 mcpp。 + +4. **写探针** + - 列出所有公开头；需要特殊作用域的（内部链接变量）放进私有命名空间； + - 确保探针在目标平台能编译。 + +5. **写生成器** + - `clang -Xclang -ast-dump=json -fsyntax-only`； + - 明确命名空间/前缀/白名单/排除规则； + - 排序输出、无时间戳； + - 生成 `--check` 模式； + - 生成一份人类可读的 `api-surface.json`/`skipped.txt`。 + +6. **写门面** + - `src/xxx.cppm`：`module;` + include + `export module` + `#include "exports.inc"`； + - `src/macros.cppm`：对象宏 → typed constexpr； + - 必要时 `src/config.cppm`：内部链接变量 → inline 常量； + - 兼容头 `port/include/mwrap/xxx/macros.hpp`。 + +7. **写清单** + - `[build].sources` 精确列出； + - `include_dirs`、`cflags/cxxflags/ldflags` 按平台； + - `[features]` 与 `[feature-deps]`； + - `[[runtime.deploy]]` 部署许可证。 + +8. **写测试** + - 模块-only 编译； + - 原始头与模块混用； + - API 表面 `static_assert`； + - 真实功能/推理； + - 模板真实渲染 + 构建 + 运行。 + +9. **写 CI** + - `--check` 生成物； + - 上游导入/哈希校验； + - 多平台构建/运行； + - 发布 tag 审计。 + +10. **写文档** + - README（英文）+ README.zh.md； + - `docs/usage.md` 写清支持边界、不能混用的组合、宏包含顺序； + - `upstream-update-policy` 写清触发条件、版本映射、失败归属。 + +--- + +## 11. 局限与可改进点 + +1. **单一大模块的编译成本。** + 所有头进一个模块 TU，消费者侧导入很快，但模块本身编译内存/时间高； + 上游头越多越明显。可按上游子模块拆分（`mwrap.xxx.core` 等）， + 但会增加 BMI 管理和交叉依赖。 + +2. **AST 只覆盖“声明”，不覆盖“语义契约”。** + 线程安全、所有权、异常保证、生命周期、回调线程模型都不在 AST 里； + 必须靠文档和真实测试。生成器不能替代 API 评审。 + +3. **平台条件声明的清单偏差。** + 单平台生成的 `exports.inc` 不包含其他平台独有名字； + 要么分别生成并合并（需保证各平台 using 在别的平台也能编译）， + 要么在 CI 里做“头文件声明集合 ⊆ 导出集合”的检查。 + +4. **宏覆盖天然不完整。** + 函数式宏、`#if` 控制流、`#`/`##` 宏只能留在头文件； + `.macros` 模块永远只是“常用对象常量”的子集，文档必须诚实。 + +5. **快照对编译器敏感。** + llama 已用规范化 + 记录生成器缓解，但换 Clang 仍可能需要重新生成； + 这不是 API 变化，CI 报错信息要能区分。 + +6. **版本硬编码。** + ONNX 生成器里 `1.25.1`、llama 的 `GGML_VERSION` 都写在脚本/清单里； + 升级时要同步改多处，最好从 lock/清单读取，减少漏改。 + +7. **构建脚本的可移植性。** + Vulkan 分支依赖 `std::system`、shell 重定向、`glslc` 名字、工具链布局； + 换平台/换 shell 就可能失效。llama 通过“显式拒绝 + CI 覆盖”控制风险， + 但仍是维护成本最高的部分。 + +8. **工具链耦合。** + ONNX 的 `toolchain-coupled` 是正确修复，但意味着消费者不能用任意 + 静态 C++ 运行时组合；这是 SDK 共享库模型的固有限制。 + +--- + +## 12. 参考文件（基线 commit 永久链接） + +### `llama.cpp-m` + +- 导出生成器： +- 源码/ABI 审计： +- 上游导入： +- 构建程序： +- 模块门面： +- 宏模块： +- 清单： +- 更新策略： +- 生成器单元测试： +- 清单/构建契约测试： + +### `onnxruntime-m` + +- 导出生成器： +- 根模块： +- 配置模块： +- 宏模块： +- 覆盖说明： +- API 清单： +- 清单： +- 使用说明： +- 发布检查： + +### 生态政策 + +- `mwrap` 规范： +- 许可证策略： +- README 模板： +- ONNX SDK 提供方： + +--- + +## 13. 最终总结 + +`llama.cpp-m` 与 `onnxruntime-m` 的封装层生成，本质上是把 +**“上游公开声明”这一事实**从编译器里取出来，转成两种确定的形式： + +- 对声明：`export using`，零成本、保身份、可 `--check`； +- 对宏/内部链接/构建产物：显式的、有限范围的等价替换与构建图声明。 + +真正困难的不是写 `export using`，而是： + +1. 定义**什么算公开面**（命名空间、前缀、白名单、人工覆盖文档）； +2. 定义**什么不能直接导出**（宏、内部链接变量、平台条件声明）； +3. 用**快照/哈希/审计**把“上游变了”与“生成器换了”区分开； +4. 用**真实运行测试**证明模块不是“能编译但不可用”； +5. 用**版本/锁/不可变发布**保证消费者拿到的是可复现的字节。 + +这套方法可以复制到任何“公开头文件 + 稳定 ABI”的 C/C++ 库上； +代价是必须接受“生成器只搬运、不翻译”的边界，并把边界之外的东西 +（宏、运行时、平台、构建）逐个显式处理，而不是假装它们不存在。 diff --git a/.agents/docs/2026-10-28-upstream-compat.md b/.agents/docs/2026-10-28-upstream-compat.md new file mode 100644 index 000000000..60181b1ee --- /dev/null +++ b/.agents/docs/2026-10-28-upstream-compat.md @@ -0,0 +1,546 @@ +# 与 Boost 上游兼容 + +> 同一个仓库如何今天作为 `mwrap` 包发布，日后又能把模块层贡献进 Boost 上游， +> 而不维护两份模块层。 +> +> 相关：[architecture.md](../../docs/architecture.md) · +> [mwrap 规范](https://github.com/mcpplibs/mcpp-index/blob/main/docs/mwrap.md) · +> [Boost 库要求与准则](https://www.boost.org/development/requirements.html) + +## 1. 结论 + +两套规范在**代码**上并不冲突。双方要的是同一件事：上游头文件、上游名字、上游 +命名空间、上游类型身份一律不动，模块层只负责"重新公布"它们。 + +冲突集中在四件**打包**上的事： + +| | mwrap | Boost | +|---|---|---| +| 身份 | `mcpplibs.mwrap.boost.` | `boost.` | +| 版本与 tag | 上游版本 + 至多一个数字修订，`mwrap-1.93.0` | 发布列车 `1.93.0`，每个库的 tag `boost-1.93.0` | +| 许可证 | 封装层贡献用 Apache-2.0 | BSL-1.0 | +| 构建与测试 | mcpp、`tests/`、模板、索引 | b2 + CMake、`test/`、禁止外部依赖 | + +因此办法是**单向拆分，而不是合并**： + +1. **可以贡献出去的模块接口按上游形状编写**，并且自包含：纯 C++20、 + `export module boost.;`、BSL-1.0、只靠 CMake 就能构建、零非 Boost 依赖。 + 这棵子树（`bridge/`）可以逐字节搬进 `boostorg/`。若某个库暂时接不了， + 封装层就保留一份清单门面——那份门面永远不往上提。 +2. **mwrap 专有的东西全部是薄薄的生成别名**：`export module + mcpplibs.mwrap.boost.; export import boost.;`，外加清单、版本、tag、 + 索引描述、模板、测试与 README。 +3. **一条字节级不变量决定什么能过界**：上游子树里任何文件都不许出现 `mcpp`、 + `mcpplibs`、`mwrap` 或 mwrap 模块名。正是这条规则让拆分长期成立。 + +因为别名只有三行，而上游单元里的模块名始终不变，所以从"只有封装层"到"上游自己 +发模块"的整个迁移过程中，mwrap 的 import 名字保持稳定。 + +## 2. Boost 上游到底要求什么 + +依据顺序：[requirements](https://www.boost.org/development/requirements.html) · +[submissions](https://www.boost.org/development/submissions.html) · +[boost-ci](https://github.com/boostorg/boost-ci) · +[CMake 指南](https://github.com/boostorg/boost-ci/blob/master/CMake.md)。 + +### 2.1 硬性要求（不满足直接拒收） + +- **许可证**：允许免费复制/使用/修改；要求在源码副本上保留许可证；不得要求二进制 + 附带许可证；不得要求为二进制使用提供源码。首选 BSL-1.0；GPL/LGPL 不可接受。 +- **版权**：归属清晰，所有重要文件带版权声明。 +- **通用性**：对足够广泛的用户有用。 +- **可移植**：接口可移植；至少两个实现当前 ISO 标准的 C++ 编译器能构建并运行， + 实践中即两个操作系统。`boost/config.hpp` 是官方认可的条件编译机制。没有义务支持 + 不符合标准的编译器。 +- **禁止外部依赖**："不要使用 C++ 标准库与 Boost 之外的库。" 包管理器、生成器 + 运行时、vendored 第三方库都不能成为 Boost 库的构建前提。 +- **作者愿意参与邮件列表讨论并维护**。 + +### 2.2 组织（接收后强制） + +`build/`（Jamfile）、`config/`、`doc/` + `doc/html/`、`index.html` 重定向、 +`example/`、`include/boost//`、`meta/libraries.json`、`src/`、`test/`、 +`tools/`。 + +`test/` 是**自动化测试唯一被考虑的位置**，其他地方必须由它引用 +（`build-project`）。`meta/libraries.json` 包含 `key`、`name`、`authors`、 +`maintainers`、`description`、`category`、`cxxstd`、`documentation`、`sublibs`。 + +### 2.3 集成（接收后强制） + +- **b2**：`build/Jamfile` 里 `project boost/ ;`、库目标与 `boost-install`； + 在 Boost 根目录执行 `b2 libs//test` 必须可用。 +- **CMake**：`CMakeLists.txt` 用 `boost_install`，产出 `Boost::` 目标，并有 + `test/cmake_test` / `test/cmake_subdir_test` 覆盖安装与子目录消费。 +- **文档**：`doc/` 必须能用 Boost Build 构建，提供 `boostdoc` 别名，默认构建独立 + 文档；库根目录的 `index.html` 重定向到 `doc/html/index.html`。 +- **CI**：使用 boost-ci 的 `.github/workflows/ci.yml`；覆盖率/Coverity 可选。 + +### 2.4 模块层会撞上的准则 + +- **向后兼容**：非破坏性改动自由；小破坏性改动要提前几个版本通知；大改动需要并行 + 的目录/命名空间与弃用路径。删除库需要更长周期。模块单元是增量改动，属于非破坏性 + ——但它不得改变头文件路径的含义。 +- **命名**：小写加下划线，缩写当普通单词；宏全大写且带 `BOOST_` 前缀；模板参数 + 首字母大写。 +- **文件名**：小写字母、数字、`_`、`-`、`.`；目录名不含点；每段 ≤31 字符； + 全路径 ≤207 字符；C++ 翻译单元用三个字母、以 `pp` 结尾的扩展名。 +- **源码卫生**：空格不用 Tab；80 列；每个文件以描述行、版权/许可证块，以及 + `// See https://www.boost.org/libs/ for library home page.` 开头。 +- **头文件要做好邻居**：自包含、不依赖包含顺序；用 `BOOST_ASSERT` 而非 `assert`； + 防范 `min`/`max` 宏。 + +### 2.5 要求文档里没写的那部分：模块 + +Boost 已经有一个被接收的 in-tree C++20 模块模式，而且是唯一应当照抄的模式。 +`boostorg/any` 与 `boostorg/type_index` 已经这么做了： + +```text +modules/boost_any.cppm +``` + +```cpp +module; +#include // 全局模块片段 +#ifdef BOOST_ANY_USE_STD_MODULE +import std; +#else +#include // ... +#endif +#define BOOST_ANY_INTERFACE_UNIT +export module boost.any; +#ifdef __clang__ +# pragma clang diagnostic ignored "-Winclude-angled-in-module-purview" +#endif +#include // 在模块体内 +``` + +`CMakeLists.txt` 中： + +```cmake +if(BOOST_USE_MODULES) + add_library(boost_any STATIC) + target_sources(boost_any PUBLIC FILE_SET CXX_MODULES + BASE_DIRS modules FILES modules/boost_any.cppm) + target_compile_features(boost_any PUBLIC cxx_std_20) + target_compile_definitions(boost_any PUBLIC BOOST_USE_MODULES) + ... +endif() +``` + +公开头文件里则加一道守卫，使模块提供实体时头文件变成空操作： + +```cpp +#if !defined(BOOST_USE_MODULES) || defined(BOOST_ANY_INTERFACE_UNIT) +... +#endif +``` + +由此得到五条支配下文的结论： + +1. **模块单元是 opt-in**（`BOOST_USE_MODULES`，默认关闭）。b2 永不构建它；其他人 + 的头文件路径完全不变。 +2. **`meta/libraries.json` 不动**——`any` 至今仍写 `"cxxstd": "11"`。模块单元 + 不抬高库的语言基线。 +3. **钩子放在库自己的头文件里**（`BOOST__INTERFACE_UNIT`、 + `BOOST__BEGIN/END_MODULE_EXPORT`），因为单元是在**模块体**里包含头文件的： + 声明归属 `boost.`，所以所有头文件消费者必须被 `BOOST_USE_MODULES` 中和。 +4. **`import std` 可选**，单独开关（`BOOST__USE_STD_MODULE`、`cxx_std_23`）。 +5. **上游化一个模块单元是"每个库的改动"，不是新库**：只需要该库维护者同意，不需要 + 正式评审。只有**新的** Boost 库（例如假想的 "Boost.Modules"）才走评审流程—— + 联署、评审经理、正式评审，周期以年计。 + +同时要正视：模块化在上游并不是已解决问题。Rubén Pérez 2025 年的原型 +（[anarthal.github.io/cppblog/modules](https://anarthal.github.io/cppblog/modules)） +在与维护者讨论后被搁置，主因是 MSVC 与 `import std` 工具链成熟度。所以贡献必须是 +严格增量、不得成为任何东西的前置条件。 + +## 3. mwrap 要求了什么 + +只列约束上游交付的部分： + +| 方面 | 规则 | +|---|---| +| 仓库 | `-m` | +| 包 | 命名空间 `mcpplibs.mwrap`，短名 = 上游库名，单一原子段 | +| 模块 | 根模块 = 完整包标识；子模块 = 上游模块分组 | +| 公开 API | 原始上游拼写、命名空间、类型身份、重载；优先 `export using`；每个实体只有一个导出属主 | +| 版本 | 跟上游版本，最多一个数字修订；tag 系列 `mwrap-${version}` | +| 布局 | `mcpp.toml`、`.xlings.json`、`upstream/`、`patches/`、`port/`、`src/`、`generated/`、`templates/`、`tests/`、`tools/` | +| 宏 | `.macros` 模块映射对象常量，外加 `/macros.hpp>` 在 import 前包含 | +| 特性 | 小写 kebab-case、可叠加、`implies`、不可用目标显式报错 | +| README | 英文 `README.md` + `README.zh.md`，固定导航行，Modules 在 Getting started 之前 | +| 模板 | 至少一个可运行的默认 `templates//template.toml` | +| 测试 | API、行为、头文件/模块、已安装消费者，都在 `tests/` | +| 索引 | `pkgs/mwrap/.lua`，`namespace = "mcpplibs.mwrap"` | +| 许可证 | 封装层 Apache-2.0，`mcpp-community` 署名，保留上游文档 | + +其中两条对拆分至关重要：*"保留上游拼写与命名空间"* 恰好就是 Boost 要的；*"每个 +实体只有一个导出属主"* 正是别名合法的原因——实体属于上游单元，绝不被导出两次。 + +## 4. 冲突矩阵 + +| # | 维度 | mwrap | Boost | 处理 | +|---|---|---|---|---| +| 1 | 仓库 | `boost-m` | `boostorg/` | 封装层仓库持有 `bridge/`；PR 的载荷只有 `bridge/`，绝不是整个仓库 | +| 2 | 许可证 | Apache-2.0 | BSL-1.0 | 按目录**单**许可：`bridge/` BSL-1.0，胶水 Apache-2.0；根 `LICENSE` + `NOTICE` 说明范围；`upstream/` 保留上游原字节；不接受二选一表达式（§5.8） | +| 3 | 命名空间 | 上游 `boost::` | 上游 `boost::` | **一致** | +| 4 | 模块名 | `mcpplibs.mwrap.boost.` | `boost.` | 生成别名：`export import boost.;` | +| 5 | 版本 | `1.93.0[.N]`，tag `mwrap-1.93.0` | `1.93.0`，tag `boost-1.93.0` | 映射表 + `[package.metadata.mwrap]`；Boost 的 `-N` 重发映射为封装修订并逐字记录 | +| 6 | 布局 | `src/`、`tests/`、`upstream/`、`port/`、`templates/`、`tools/` | `include/`、`meta/`、`doc/`、`test/`、`build/`、`example/`、`src/` | 除 `src/` 外基本不相交；bridge 用 `modules/`；测试只留一个 `test/` 入口 | +| 7 | 构建 | mcpp | b2 + CMake | `bridge/` 对 b2 不可见，由 `BOOST_USE_MODULES` 在 CMake 中开关 | +| 8 | 语言基线 | 包默认 C++23 | 每个库各自，常见 C++11/14/17 | 模块单元需要 C++20 且保持 opt-in；不抬高 `meta/libraries.json` 的 `cxxstd` | +| 9 | 宏 | `.macros` 模块 + 兼容头 | 宏仍是宏，外加 `BOOST_USE_MODULES` 守卫 | 宏映射是 mwrap 专有；上游只拿守卫，不拿映射 | +| 10 | 依赖 | `compat.boost` 提供方 | 除 std 与 Boost 外无库 | bridge 零依赖；提供方只存在于封装层 | +| 11 | 测试 | `tests/` | `test/`（唯一自动化位置） | 源码留在 `tests/`；`test/Jamfile` 与 `test/CMakeLists.txt` 引用它 | +| 12 | 文档 | 根 README 布局，中英双语，100–150 行 | `doc/` HTML + `doc/html` + 重定向 | 根 README 走 mwrap 形状；`doc/` 走 Boost 形状；PR 只带 `doc/` | +| 13 | CI | 三个 mcpp 作业 + 模板 + 已安装消费者 | boost-ci 矩阵，2 编译器 × 2 OS | 两者都保留；新增 `bridge-ci` 作业把 `bridge/` 覆盖进临时 Boost 根 | +| 14 | 评审 | 索引 PR | 每库维护者同意；只有新库才正式评审 | 先做每库 PR；只有确实需要元层时才提新库 | +| 15 | 署名 | `mcpp-community` 标签 | 逐文件版权 + `meta/libraries.json` 维护者 | 逐文件版权；标签留在 `mcpp.toml` 与 NOTICE | +| 16 | 配置/ABI | 记录 ABI、运行时、CPU、SDK 约束 | 向后兼容政策 | 每次模块构建固定一套宏，写进文档并测试 | + +## 5. 设计 + +### 5.1 三层，一个事实来源 + +```text + 上游头文件（Boost，按发布版本 pin） + │ + ┌─────────────────────┴─────────────────────┐ + ▼ ▼ + bridge/modules/boost_.cppm generated/-exports.inc + export module boost.; export namespace boost { ... } + （上游形状，BSL，无 mcpp） （由 AST 生成的名字清单） + │ │ + ▼ ▼ + src/.cppm ── export import ──► src/.cppm + mcpplibs.mwrap.boost. mcpplibs.mwrap.boost. + （B 档：上游已有单元） （A 档：只有封装层） +``` + +**A 档 —— 清单门面**（今天对所有 Boost 库都成立，且不需要任何上游改动）。上游 +头文件在**全局模块片段**里包含，实体仍属于全局模块；模块体重新打开每个上游命名 +空间，为每个审计过的实体加一条 `using` 声明。这正是 `onnxruntime-m` 与 +`llama.cpp-m` 已验证的设计，也是唯一能让头文件与模块在同一翻译单元里共存的设计。 + +**B 档 —— 上游单元**（Boost.Any 形状）。头文件在模块体内包含，头文件里有 +`BOOST_USE_MODULES` / `BOOST__INTERFACE_UNIT` 守卫，声明被 +`BOOST__BEGIN/END_MODULE_EXPORT` 包住。构造上就是完全保真的，但它禁止原始 +头文件与模块混用，所以只有在守卫已经进入该库之后才是正确的。 + +两档最终落到同一个公开名字。封装层默认 A 档；一旦某个库在上游发布了 B 档单元， +封装层就翻成三行别名： + +```cpp +// src/asio.cppm —— 上游发布 modules/boost_asio.cppm 之后 +export module mcpplibs.mwrap.boost.asio; +export import boost.asio; +``` + +消费者零改动、清单无需重新审计，实体依旧只有一个导出属主。 + +### 5.2 仓库布局 + +```text +boost-m/ + mcpp.toml # 包身份、特性、提供方依赖 + .xlings.json # 精确的 mcpp pin + LICENSE NOTICE # 封装层 Apache-2.0 + 范围声明 + bridge/ # ← 唯一允许搬去上游的子树 + LICENSE_1_0.txt # BSL-1.0 + modules/boost_asio.cppm # B 档单元，`export module boost.asio;` + modules/boost_json.cppm + test/ # 模块测试，纯 C++，不用 mcpp + doc/ # 给该库 PR 用的 AsciiDoc/Quickbook 片段 + upstream.meta.toml # 目标库、维护者、每库 PR 状态 + src/boost.cppm # mwrap 根模块：export import 已启用闭包 + src/asio.cppm # A 档门面，或 B 档别名 + src/macros.cppm # mcpplibs.mwrap.boost.macros + generated/asio.inc # 清单（仅 A 档），字节稳定 + port/include/mwrap/boost/macros.hpp + tests/ # API、行为、头文件/模块混用、已安装消费者 + tools/gen_exports.py # AST → 清单，支持 --check + tools/gen_alias.py # 清单 → src/.cppm 门面，支持 --check + tools/bridge_into_boost.py # 把 bridge/ 覆盖到临时 Boost 根 + templates/ # 必需的默认可运行模板 + upstream/ # pin 住的 Boost 文档、校验和、许可证 +``` + +`bridge/` 按库可选，它的缺失就是这个库诚实的现状："封装层有了，上游单元还没有"。 + +### 5.3 清单 + +沿用现有 AST 流水线生成，每个上游命名空间一块，排序、无时间戳、可 `--check`： + +```cpp +// generated/asio.inc +export namespace boost { namespace asio { +using ::boost::asio::io_context; +using ::boost::asio::steady_timer; +} } +export namespace boost { namespace system { +using ::boost::system::error_code; +} } +``` + +生成器必须强制的三条规则，每条背后都有真实故障： + +- **必须重新打开命名空间，不要在全局作用域导出。** 裸写 + `export using ::boost::system::error_code;` 只导出**非限定**名字， + 消费者写 `boost::system::error_code` 仍然不可见。 +- **命名空间作用域的函数与运算符必须显式列出。** 类内的 hidden friend 由 ADL + 找到，无需列出；而 `operator==(optional const&, none_t)` 这类自由运算符 + 不会被找到，漏掉就会让消费者在 `opt != boost::none` 上报 + "no match for operator!=" ——而对着头文件编译是好的。 +- **被跳过的名字必须计数。** 每个未导出的公开名字（内部链接、成员模板、无法映射 + 的宏）都进入机器校验的跳过清单，让"缺失"永远是一个决定，而不是意外。 + +### 5.4 上游单元 + +```cpp +// bridge/modules/boost_optional.cppm +module; +#include +#ifdef BOOST_OPTIONAL_USE_STD_MODULE +import std; +#else +#include +#endif +#define BOOST_OPTIONAL_INTERFACE_UNIT +export module boost.optional; +#include // 模块体，在守卫之后 +``` + +头文件一侧： + +```cpp +#if !defined(BOOST_USE_MODULES) || defined(BOOST_OPTIONAL_INTERFACE_UNIT) +#define BOOST_OPTIONAL_BEGIN_MODULE_EXPORT export { +#define BOOST_OPTIONAL_END_MODULE_EXPORT } +... +#endif +``` + +CMake 一侧照抄 `boostorg/any`： + +```cmake +option(BOOST_USE_MODULES "Build and use C++20 modules" OFF) +if(BOOST_USE_MODULES) + add_library(boost_optional STATIC) + target_sources(boost_optional PUBLIC FILE_SET CXX_MODULES + BASE_DIRS modules FILES modules/boost_optional.cppm) + target_compile_features(boost_optional PUBLIC cxx_std_20) + target_compile_definitions(boost_optional PUBLIC BOOST_USE_MODULES) +endif() +``` + +每库一个 `.cppm` 加一段头文件钩子补丁，**就是**那个 PR。它小、可评审、贴合已被 +接收的先例，并且对从不设置 `BOOST_USE_MODULES` 的用户零影响。 + +### 5.5 版本、tag、元数据 + +```toml +[package] +namespace = "mcpplibs.mwrap" +name = "boost" +version = "1.93.0" + +[package.metadata.mwrap] +upstream = "boost" +upstream_release = "1.93.0" # Boost 自己的写法，逐字记录 +upstream_tag = "boost-1.93.0" # boostorg/ 里每个库的 tag +libs = { asio = "", optional = "" } # 发布版本内的 pin +``` + +映射规则必须写下来，因为 Boost 的编号有一个 mwrap 没有的情形： + +| Boost | mwrap | 说明 | +|---|---|---| +| `1.93.0` | `1.93.0`，tag `mwrap-1.93.0` | 该身份的首发，不带修订 | +| `1.93.0` + 封装层修复 | `1.93.0.1` | 封装修订 | +| `1.91.0-1`（重发） | `1.91.0.1`，`upstream_release = "1.91.0-1"` | 连字符形式不可排序，逐字记录且绝不当作版本号；上游重发占用第一个修订槽 | + +封装层 tag 系列是 `mwrap-${version}`；自动更新必须跟随 `boostorg/boost` 的发布 +tag 以及各库的 `boost-1.93.0` tag，绝不能跟 GitHub "latest"。 + +### 5.6 构建、测试、CI + +`test/` 只作为入口存在，让两套工具链都在它们期望的位置找到测试： + +```make +# test/Jamfile —— Boost 看到 libs//test，源码只有一份 +build-project ../tests ; +``` + +```cmake +# test/CMakeLists.txt +add_subdirectory(../tests tests) +``` + +- **Boost 侧**：`bridge-ci` 用 `tools/bridge_into_boost.py` 把 `bridge/` 覆盖进 + 临时 Boost 根，然后跑 `b2 libs//test`，以及 + `cmake -DBOOST_USE_MODULES=ON`（clang ≥ 19），并额外跑一次不带 `import std` + 的构建。这与 boost-ci 做的事一致，且能在 PR 存在之前就证明载荷可用。 +- **mwrap 侧**：三个平台作业（`xlings`、`mcpp build/test`、模板 smoke、已安装 + 消费者）加上 `gen_exports.py --check` 与 `gen_alias.py --check`。 +- **共享一致性套件**（`tests/`）：清单里每个名字在 mwrap 导入**和**上游导入之后 + 都断言可见；另有一个 TU 混用头文件与模块。B 档库还要断言：在 + `BOOST_USE_MODULES` 下包含该头文件是空操作。 + +### 5.7 文档与索引 + +- 根 `README.md` / `README.zh.md` 遵循 mwrap README 布局（导航行、Modules 在 + Getting started 之前、100–150 行、特性表）。 +- `doc/` 是 Boost 形状，也是 PR 唯一携带的文档。 +- `pkgs/mwrap/boost.lua` 声明 `namespace = "mcpplibs.mwrap"`、`name = "boost"`、 + `licenses = {"Apache-2.0"}`，指向封装层发布物。`bridge/` 与 `upstream/` 的 + BSL 写在 `NOTICE` 里，不混进封装层的 SPDX 字段。 + +### 5.8 许可证：按路径单许可，而不是"二选一" + +"封装层能不能写成 Apache-2.0 OR BSL-1.0"有一个法律答案和一个工程答案，两者不同。 + +mwrap 到底怎么规定的（它是政策文档，不是许可证校验器）： + +- 封装层**默认** Apache-2.0；根 `LICENSE` 放 Apache 正文，根 `NOTICE` 写明 + `mcpp-community` 并*说明封装层贡献的范围*； +- `mcpp.toml` 与描述符声明 Apache-2.0； +- 上游 `LICENSE`/`NOTICE` 要保留在 `upstream/` 下——也就是说，"一个仓库里存在 + 多种许可证"本来就是常态； +- `onnxruntime-m` / `llama.cpp-m` 里的发布检查器硬断言 + `package['license'] == 'Apache-2.0'`；索引里所有 mwrap 描述符都是 + `licenses = { "Apache-2.0" }`；索引 CI 不校验许可证*取值*。 + +Boost 真正需要的是 BSL-1.0。原因不是"Apache 不自由"，而是其准则拒绝任何"必须随 +二进制一起出现"的许可证，而 Apache-2.0 §4(d) 要求二进制分发中包含 `NOTICE` 内容。 +BSL 没有这一条。这就是为什么 Boost 每个库都是 BSL-1.0，也是为什么双许可头会让评审 +者先去读许可证正文、而不是代码。 + +而描述符能表达什么：`licenses` 是 SPDX id 的**列表**，所以 +`{ "Apache-2.0", "BSL-1.0" }` 读作"两者都存在"，而不是"任选其一"；`OR` 表达式在 +清单里无处安放。 + +三个选项，如实比较： + +| 选项 | `bridge/` | 胶水（`src/`、`tools/`、`tests/`） | 根 `LICENSE` | 描述符 | 结论 | +|---|---|---|---|---|---| +| **A. 按路径单许可** | BSL-1.0 | Apache-2.0 | Apache + `NOTICE` 范围声明 | `{ "Apache-2.0" }` | **推荐**：每个产物只有一个许可证，两套规范都按字面满足，不给评审留问题 | +| B. 全仓 Apache，贡献时改 BSL | Apache-2.0 | Apache-2.0 | Apache | `{ "Apache-2.0" }` | 合法（权利人把要贡献的那份副本改为 BSL），最好管；上游副本与仓库副本只差一行文件头 | +| C. 双许可 "Apache OR BSL" | `BSL-1.0 OR Apache-2.0` | 同左 | 两份正文 | 无法表达 `OR` | 合法，但描述符退化为 AND，标准发布检查器直接失败，Boost 仍需裁定"哪一份适用于树里的副本" | + +C 比 A 多做功，实际却没多给任何许可：Boost 收下文件的那一刻，"选择"就坍缩成 +BSL。它换来的好处——文件搬去上游时不用改头——是每个库改一次、一次一行。 + +应当这样做： + +```text +LICENSE Apache License 2.0（封装层贡献） +NOTICE mcpp-community；范围：src/、tools/、tests/、templates/、mcpp.toml； + bridge/ 为 Boost Software License 1.0；upstream/ 保留上游条款 +bridge/LICENSE_1_0.txt BSL-1.0 正文 +bridge/modules/*.cppm // Copyright + // Distributed under the Boost Software License, Version 1.0. + // See accompanying file LICENSE_1_0.txt or copy at + // https://www.boost.org/LICENSE_1_0.txt +``` + +每个文件只写一个 `SPDX-License-Identifier`，绝不写两个。如果项目日后确实要求整个 +仓库只有一个表达式，请选 B 而不是 C：产物边界已经存在，让许可证跟着去向走即可。 + +**既有材料保留原许可证。** mwrap 要求保留继承来的封装层声明，并要求把遗留材料与 +上游材料分别标注。因此，早期代码是 BSL-1.0 的仓库在采用封装层政策时不必整体重新 +授权：新的胶水是 Apache-2.0，继承代码保持 BSL-1.0，`NOTICE` 写清哪块是哪块。这是 +把选项 A 用到时间轴上——仍然是一个产物一个许可证，而不是 `OR`。 + +## 6. 不变量 + +按此顺序在 CI 中可检查。每一条都对应一个"不报错就出事"的错误。 + +1. `grep -rniE 'mcpp|mwrap|mcpplibs' bridge/` 无输出。 +2. `bridge/modules/*.cppm` 每个只声明一个 `export module boost.;`，没有别的 + 模块名。 +3. `bridge/` 下每个源文件带 BSL 头与 + `// See https://www.boost.org/libs/ ...`（许可证文本除外）。 +4. `bridge/` 只用 `clang++ -std=c++20 --precompile` 加 include 路径就能构建—— + 不需要 mcpp、不需要生成器、不需要包装脚本——且 + `cmake -DBOOST_USE_MODULES=ON` 能构建。 +5. 无论 `bridge/` 在不在，`b2` 构建结果不变。 +6. `bridge/` 加入前后 `meta/libraries.json` 字节相同。 +7. `mcpp.toml` 不引用 `bridge/` 下任何文件；`bridge/` 里不出现任何 mwrap 模块名。 +8. `generated/.inc` 的每个名字都能通过封装层导入在编译测试中解析；每个被跳过 + 的名字都出现在跳过清单里。 +9. 同时包含上游头文件并导入封装层模块的 TU 能编译链接（A 档），或被一个有文档、 + 有测试的诊断明确拒绝（B 档）。 +10. `gen_exports.py --check` 与 `gen_alias.py --check` 字节幂等，且重新生成不会 + 触碰未变化的文件。 + +## 7. 贡献顺序 + +| 阶段 | 工作 | 门禁 | +|---|---|---| +| 0 | 只做封装层：对一个纯头文件子集（`asio`、`optional`、`mp11`、`describe`、`static_string` 等）实现 A 档，依赖索引里已经存在的逐库 `compat.boost-` 提供方（BSL-1.0，`1.92.0`） | mwrap 各门禁、索引发布、真实用户 | +| 1 | 选一个有活跃维护者的库；在 `bridge/` 写 B 档单元与钩子补丁；跑 `bridge-ci` | 维护者同意；`b2` + CMake 在 2 编译器 × 2 OS 上绿 | +| 2 | 提该库的 PR（载荷：`modules/`、头文件守卫、`test/cmake_subdir_test`、`doc/` 片段） | 该库维护者评审；进入下一发布列车（1.94 起；1.93 已于 2026-10-21 对新库关闭） | +| 3 | 该库发布后，把封装层门面翻成 `export import boost.;`，删掉那份清单 | 封装层测试不变，import 名不变 | +| 4 | 只有确实还需要元层时：贡献生成器/工具，或提新 Boost 库——后者才需要正式评审 | 联署、评审经理、正式评审 | + +明确不进入上游的部分：`mcpplibs.mwrap.boost` 根聚合模块（它为满足 mwrap 根模块 +规则而存在，而一个 import 全部 Boost 库的 `boost` 模块恰好是 Boost 最不想要的）、 +`.macros` 映射（具名模块无法导出宏，上游让宏保持为宏）、模板、索引描述。 + +## 8. 风险 + +- **宏配置在模块构建时被冻结。** 一套 `BOOST_*` / 特性开关下编译出的模块单元， + 消费者无法重新配置，混用不同配置就是 ODR 违规。对策：每次模块构建固定一套有 + 文档的宏集，映射到包特性，并用头文件/模块一致性测试覆盖。这与 + `onnxruntime-m` 已记录的固有限制相同。 +- **编译器成熟度。** 本机实测：A 档机制在 Clang 23 + Boost 1.92 下编译运行通过， + 包括一个混用原始头文件与模块的 TU；GCC 14 在命名空间作用域运算符被导出后能通过 + 轻量库，但在 Asio 的模板体上失败于 + "must `#include ` before using `typeid`"——这是消费者可见性缺口，不是 + 设计缺陷。因此按库给出编译器矩阵，而不是给一个全局承诺。 +- **一个程序里两种身份。** `boost.asio` 与 `mcpplibs.mwrap.boost.asio` 是同一批 + 实体，可以同时导入（已实测）。真正的"唯一属主"规则针对的是**实现**，不是模块名： + 绝不同时链接 vendored 副本与 `compat.boost`。 +- **上游意愿。** 模块支持是 opt-in，且已被搁置过一次。预算要按"逐库采纳"来算， + 而不是一次性全量接受；封装层永远不能依赖某个上游改动先落地。 +- **版本漂移。** Boost 大约一年三次发布，偶尔用连字符重发。两者都由 §5.5 的映射表 + 吸收；执行者必须是更新机器人，而不是人。 + +## 9. 实测证据 + +2026-10-28 在本机以 `clang 23.1.4` + Boost 1.92 头文件，以及 `g++ 14.2` 验证： + +```cpp +// 一份清单，两个模块名，一个程序 +// src/asio.cppm +module; +#include +export module mcpplibs.mwrap.boost.asio; +#include "../include/boost/asio/module/exports.inc" + +// upstream/asio.cppm +module; +#include +export module boost.asio; +#include "../include/boost/asio/module/exports.inc" +``` + +- 两个模块单元都能预编译，两个消费者都能构建并运行； +- 消费者可以用上游拼写写 `boost::asio::io_context`、`boost::system::error_code`； +- 一个同时 `#include ` 并 `import boost.asio` 的 TU + 能构建运行（全局模块片段正是它安全的原因）； +- 同一 TU 同时导入 `boost.asio` 与 `mcpplibs.mwrap.boost.asio` 能构建运行； +- 只导出 `boost::optional` 而不导出 `boost::operator==` / `operator!=`，消费者写 + `opt != boost::none` 会失败；补上两条 using 声明即恢复——§5.3 的审计规则不是 + 纸上风险。 + +## 10. 参考 + +- Boost 库要求与准则 — https://www.boost.org/development/requirements.html +- Boost 库提交流程 — https://www.boost.org/development/submissions.html +- Boost.CI 及其 CMake 指南 — https://github.com/boostorg/boost-ci +- 已被接收的模块先例 — https://github.com/boostorg/any（`modules/boost_any.cppm`）、https://github.com/boostorg/type_index +- 模块原型与分析 — https://anarthal.github.io/cppblog/modules +- mwrap 规范 — https://github.com/mcpplibs/mcpp-index/blob/main/docs/mwrap.md +- mwrap 许可、README 布局、包形状 — 同仓库 `docs/mwrap-licensing.md`、`docs/mwrap-readme.md`、`docs/package-types.md` diff --git a/.agents/docs/2026-11-05-json-ast-generation.md b/.agents/docs/2026-11-05-json-ast-generation.md new file mode 100644 index 000000000..026950a97 --- /dev/null +++ b/.agents/docs/2026-11-05-json-ast-generation.md @@ -0,0 +1,123 @@ +# 封装层生成原理改造：clang JSON AST + 声明式策略 + `--check` + +> 日期：2026-11-05 +> +> 依据：[2026-10-28 mwrap 模块封装层生成原理技术报告](2026-10-28-mwrap-module-wrapper-generation.md) +> （`llama.cpp-m` / `onnxruntime-m`） +> +> 相关：[architecture.md §5](../../docs/architecture.md) · +> [patches/README.md](../../patches/README.md) · +> [tools/export_policy.toml](../../tools/export_policy.toml) + +## 1. 改造前的问题 + +报告总结的原则是"编译器算出公开面，生成器只搬运，生成物可 `--check`"。改造前的 +boost-m 在三处偏离了它： + +| 报告的原则 | 改造前 | +|---|---| +| `clang++ -Xclang -ast-dump=json -fsyntax-only` 由编译器给出 AST | libclang Python 绑定；xlings 的 LLVM 不带 `libclang.so`，CI 每次下载约 1 GB 的完整 LLVM；libclang 与 clang++ gate 是两套解析，曾互相不一致 | +| 生成物只由生成器写出，`--check` 逐字节比对（报告 §9.1 第 8 条：不要只靠"重新生成后 git diff"） | 35 个模块侧 `patches/*.patch` + `reapply_hand_edits.py` 中的程序化 guard + `patches/final/` 整文件回放，事后改写 `generated/exports/*.inc` 与 `src/*.cppm`；CI 以 `git diff` 为判据 | +| 手写门面 `.cppm` 文本包含生成的 using 清单 | `--emit-cppm` 覆盖 `src/*.cppm`，再由补丁/最终形态恢复 | +| 不能导出的东西显式记录（`skipped.txt`、`api-surface.json`） | 分散在补丁 hunk、Python 列表与注释里 | +| 版本从 lock/清单读取 | 生成器里硬编码 `boost=1.92.0` | + +## 2. 改造后的原理 + +```text +upstream/boost (import_boost.py + apply_patches.py：只改 vendored 树) + │ + ▼ 每库一个 bundle TU = 门面 GMF 的 include 集合 +clang++ -fsyntax-only -Xclang -ast-dump=json -Xclang -ast-dump-filter=boost + │ （同一次编译就是语法门禁；失败时剔除诊断点名的 GMF 头并重编） + ▼ tools/ast_json.py：流式读取 → 扁平声明表 +gen_exports.py：候选 / using 注入 / 签名闭包 / first-wins 归属 / 函数体边 + │ + tools/export_policy.toml（guard / drop / extra / add / gmf ...，每条带理由） + ▼ +generated/exports/.inc|.deps generated/meta/api-surface.json|skipped.txt + │ + ▼ 文本包含 +src/.cppm（人工维护的门面；--check 校验 GMF == bundle） +``` + +### 2.1 JSON AST 的读取 + +- `-ast-dump-filter=boost` 只输出 `namespace boost` 子树；但 std 侧名字里含 `boost` + 的声明（`std::__are_same` 的成员）也会作为无上下文的顶层对象出现，读取器 + 只接受顶层 `NamespaceDecl`。 +- 体量：geometry 过滤后仍有 6.8 GB（600 万个隐式 `ClassTemplateSpecializationDecl`）， + 单个块 1.8 GB，不能 `json.loads`。clang 的 JSON 是一键一行、两空格缩进，读取器按行 + 解析，峰值内存约 300 MB，geometry 约 45 s。 +- `loc.file` / `loc.line` 是增量编码（与上一个**打印出的**位置相同则省略）， + `includedFrom.file` 不计入状态；状态必须跨所有位置延续，包括被丢弃的 range、 + 实例化与 `UsingShadowDecl` 副本。这正是报告 §4.4 "不要信 `loc.file`" 的根因。 +- 丢弃：`*TemplateDecl` 中模式之后的所有声明（隐式实例化）、`UsingShadowDecl` 的 + inner 副本、`FullComment`、`range`、`definitionData`、空子节点 `{}`。被丢弃实例化内 + 每个节点 id 记入别名表，引用 `foo` 及其成员时解析回模板 `foo`。 +- 非模板声明带 Itanium `mangledName`：既是跨 TU 的稳定身份（替代 libclang USR）， + `L` 标记又直接给出内部链接。 + +### 2.2 与 libclang 语义对齐的规则 + +逐库与旧输出（把模块侧补丁与 guard 反向剥离后的原始生成物）比对，确定了这些规则： + +- 词法父为类的声明不是候选；仅以 friend 出现的声明不入索引。 +- 语义父优先取 `parentDeclContextId`，经别名表解析；无法解析时视为未知作用域， + 绝不退回词法命名空间（否则 `call_stack<…>::top_` 的类外定义会变成 + `boost::asio::detail::top_`）。 +- `typedef enum { … } mode_t;`：typedef 名即枚举的链接名，枚举项拼写为 + `mode_t::read_only`。 +- 任一重声明位于 `extern "C"` 中的函数是 C 语言链接，不作为命名空间 API。 +- `using namespace X;` 只在 X 嵌套于该指令所在作用域时注入（ADL 屏障形态）； + 引入兄弟 `detail` 命名空间只是实现便利。 +- 跨 TU 的身份取重声明链的首个声明，避免同一实体在不同 TU 得到不同键。 +- 导出块内首段被遮蔽的名字（`boost::hana::ext::{boost,std}`）写成 `::boost::…` + （原先由 `hana.patch` 手改）。 + +### 2.3 有意的行为变化 + +相对旧生成物，以下差异是 JSON AST 更准确的结果，保留： + +- 宏拼写的 using 声明现在可见：`using BOOST_FILESYSTEM_VERSION_NAMESPACE::absolute;` + 使 `boost::filesystem::{absolute,canonical,equivalent,weakly_canonical}` 以文档拼写 + 导出（此前缺失）；`BOOST_MPL_AUX_ADL_BARRIER_DECL` 生成的 `mpl_::*` 同理。 +- 首个声明是类内 elaborated 前置声明的类型（`cobalt::as_tuple_tag` 等）不再被误判为 + 类成员。 +- 签名闭包改为基于类型字符串的名字解析（JSON 不输出 TypeLoc），不再把已被其他库 + 认领的实体以"特化 USR"的形式在非属主模块重复导出；`.deps` 随之变化， + `gen_features.py` 推导的 implies 跟着变（默认闭包增加 `bind`、`function`）。 + 门面的 `export import` 块保持原样：人工定稿的门面本来就少于 `.deps` + （range 不导入 regex，gcc abi tag 不匹配），曾尝试强制 imports ⊇ `.deps`， + gcc 构建即失败，故不作为检查项。 +- `flyweight.inc`、`algorithm.inc|.deps` 不再是手工最终形态，分别由 `drop.namespaces` + 与 `gmf` 策略生成；`version.deps` 由策略 `[version.deps]` 生成。 + +### 2.4 策略文件 + +`tools/export_policy.toml` 吸收了原 `tools/curated/*.txt`、`GMF_OVERRIDE`、 +`EXTRA_DEFINES`、全部 `.inc` 补丁与程序化 guard。guard 的理由来自原补丁注释与 +`reapply_hand_edits.py` 注释；`generated/meta/skipped.txt` 逐名列出受策略影响的 +导出，`api-surface.json` 记录生成器身份（clang 版本、目标、宏）与每库 GMF/导出数/边。 + +## 3. 验证 + +- 旧原始生成物对照：全局只丢失 15 个名字（均为 typedef 命名的匿名枚举项，已修复）。 +- `gen_exports.py --check`：连续两次生成逐字节一致，门面检查通过。 +- 工具单元测试 19 项通过（新增 `test_ast_json.py` 覆盖增量位置、实例化别名、 + 空子节点、顶层过滤、using/shadow 细节）。 +- 冷生成约 12 分钟（geometry 单库约 1.5 分钟），全命中缓存的热生成约 50 秒。 +- 本地构建（x86_64 Linux）：gcc 16.1 `mcpp build --features all-modules` 全部模块接口 + 通过，`mcpp test --features all-modules` 144/144；LLVM 23.1.3 按 CI 的 A/B 分组 + `mcpp test` 各 144/144（clang 整个 all-modules 闭包会触及已知的 source-location 上限）。 + 构建中发现 process 新引用到的 `boost::asio::windows::basic_object_handle` 需要 + `_WIN32` guard，已加入策略。macOS、Windows 未在本地验证，依赖 CI。 + +## 4. 已知限制 + +- 快照仍是单一平台风味（MinGW x86_64、libstdc++），平台条件仍需在策略中人工声明 + （报告 §9.1 第 10 条、§11 第 3 条）；可以改为多风味生成后求差自动推导 guard， + 但 macOS libc++ 与 MSVC 头文件目前无法在生成环境中提供。 +- `extern "C"` 块内的 `namespace boost` 在过滤后的 dump 中无法识别为链接说明作用域， + 个别名字（winapi `winsdk_*`）以策略 drop 处理。 +- 签名闭包与函数体边的类型名解析是文本级的近似（JSON 不输出类型位置）， + `.deps` 边与旧值有差异（608 → 633 条，丢 32 增 57），已确认合并后无 import 环。 diff --git a/.gitattributes b/.gitattributes index 0909fe737..0080fb461 100644 --- a/.gitattributes +++ b/.gitattributes @@ -6,11 +6,13 @@ *.mpp linguist-detectable=true *.mpp linguist-documentation=false -# Patch replay and stored final forms must match the generator's LF bytes even -# when the checkout uses core.autocrlf=true (the Windows runners' default). +# Generated files, their inputs and the vendored patches keep LF bytes even +# when the checkout uses core.autocrlf=true (the Windows runners' default), so +# gen_exports.py --check and the patch replay agree on every host. *.cppm text eol=lf patches/** text eol=lf generated/** text eol=lf +tools/export_policy.toml text eol=lf # Vendored upstream bytes are fixed: no end-of-line or encoding conversion, so a # Linux and a Windows checkout hash identically (upstream/documents.json and the diff --git a/.github/actions/setup-generator/action.yml b/.github/actions/setup-generator/action.yml new file mode 100644 index 000000000..8c1d319b5 --- /dev/null +++ b/.github/actions/setup-generator/action.yml @@ -0,0 +1,65 @@ +# Toolchain of the generation chain, shared by the jobs of verify-scripts.yml: +# Python + uv, xlings and the tools pinned in .xlings.json (mcpp, the +# generator's clang++), the cached MinGW sysroot archive and the tool +# dependencies. Expects a checkout; sets CLANG_NO_DEFAULT_CONFIG and +# LLVM_VERSION for the following steps. +name: Set up the generation toolchain +description: Python, uv, xlings, the pinned clang++ and the MinGW sysroot archive cache + +runs: + using: composite + steps: + - name: Set up Python + uses: actions/setup-python@v7 + with: + python-version: "3.x" + + - name: Set up uv + uses: astral-sh/setup-uv@07a047e608db84b3d8c06cd9a7c7dcc9c355c18e + with: + enable-cache: true + cache-dependency-glob: tools/uv.lock + + - name: Install xlings + if: runner.os != 'Windows' + shell: bash + run: | + set -euo pipefail + curl -fsSL --retry 3 --retry-all-errors \ + https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh \ + | bash -s "$XLINGS_VERSION" + echo "$HOME/.xlings/subos/current/bin" >> "$GITHUB_PATH" + + - name: Install xlings + if: runner.os == 'Windows' + shell: pwsh + run: | + irm https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.ps1 | iex + "$env:USERPROFILE\.xlings\subos\current\bin" | + Out-File -Append -FilePath $env:GITHUB_PATH -Encoding utf8 + + # .xlings.json pins the generator's clang++ next to mcpp. The xlings + # package installs a host config file for native builds; the generator + # parses for an explicit MinGW target and sysroot, so it is ignored. + - name: Install project tools (.xlings.json -> mcpp, llvm) + shell: bash + run: | + set -euo pipefail + xlings update + xlings install -y + echo "CLANG_NO_DEFAULT_CONFIG=1" >> "$GITHUB_ENV" + LLVM_VERSION="$(python -c "import json; print(json.load(open('.xlings.json'))['workspace']['llvm'])")" + echo "LLVM_VERSION=$LLVM_VERSION" >> "$GITHUB_ENV" + clang++ --version + + - name: Cache MinGW sysroot archive + uses: actions/cache@v6 + with: + path: tools/_deps/_archives + key: mingw-sysroot-archive-${{ runner.os }}-${{ hashFiles('tools/fetch_mingw_sysroot.py') }} + restore-keys: | + mingw-sysroot-archive-${{ runner.os }}- + + - name: Install tool dependencies + shell: bash + run: uv sync --project tools --locked diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index c6499a1e6..863d89366 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -32,10 +32,11 @@ # `examples` job, which `needs: [test]`: they start only after both groups have # passed on all five hosts. # -# mcpp comes from the repository's own pin: xlings installs `mcpp 2026.10.26.1` -# from `.xlings.json`, and the job asserts that CI's MCPP_VERSION and the -# manifest pin are the same build. Toolchains are then installed by mcpp into its -# sandbox (`~/.mcpp`), which actions/cache keeps warm per host and toolchain. +# mcpp comes from the repository's own pin: xlings installs `mcpp 2026.11.5.1` +# (only that entry of `.xlings.json`; its `llvm` pin is the generator's), and +# the job asserts that CI's MCPP_VERSION and the manifest pin are the same +# build. Toolchains are then installed by mcpp into its sandbox (`~/.mcpp`), +# which actions/cache keeps warm per host and toolchain. name: Build and Tests @@ -84,7 +85,7 @@ env: XLINGS_VERSION: v2026.10.26.1 XLINGS_NON_INTERACTIVE: '1' # Must match [workspace].mcpp in .xlings.json — checked on every leg. - MCPP_VERSION: "2026.10.26.1" + MCPP_VERSION: "2026.11.5.1" # Leave the runners room: the vendored tree is large and every leg compiles # Boost from the same checkout. MCPP_JOBS: '4' @@ -147,15 +148,16 @@ jobs: "$env:USERPROFILE\.xlings\subos\current\bin" | Out-File -Append -FilePath $env:GITHUB_PATH -Encoding utf8 + # Only mcpp: the manifest's llvm pin is the generator's clang++, which + # the build legs never use (their toolchain comes from mcpp below). - name: Install project tools (.xlings.json → mcpp) shell: bash run: | set -euo pipefail - xlings update - xlings install -y - mcpp --version # The CI pin and the repository pin must name the same tool build. grep -Fq "\"mcpp\": \"$MCPP_VERSION\"" .xlings.json + xlings update + xlings install -y "mcpp@$MCPP_VERSION" mcpp --version | grep -Fq "$MCPP_VERSION" - name: Install toolchain (${{ matrix.target.toolchain }}) @@ -282,14 +284,16 @@ jobs: "$env:USERPROFILE\.xlings\subos\current\bin" | Out-File -Append -FilePath $env:GITHUB_PATH -Encoding utf8 + # Only mcpp: the manifest's llvm pin is the generator's clang++, which + # the build legs never use (their toolchain comes from mcpp below). - name: Install project tools (.xlings.json → mcpp) shell: bash run: | set -euo pipefail - xlings update - xlings install -y - mcpp --version + # The CI pin and the repository pin must name the same tool build. grep -Fq "\"mcpp\": \"$MCPP_VERSION\"" .xlings.json + xlings update + xlings install -y "mcpp@$MCPP_VERSION" mcpp --version | grep -Fq "$MCPP_VERSION" - name: Install toolchain (${{ matrix.toolchain }}) diff --git a/.github/workflows/verify-scripts.yml b/.github/workflows/verify-scripts.yml index 7609d230d..6653d68e7 100644 --- a/.github/workflows/verify-scripts.yml +++ b/.github/workflows/verify-scripts.yml @@ -1,27 +1,38 @@ # Verify the committed outputs of the repository's generation chain. # # The generated export lists, the feature blocks and the committed metadata are -# build inputs, so "regenerate and diff" is the only honest check that they still -# describe the sources. LLVM is pinned because the AST snapshot must come from -# the same parser family the committed files were generated with; the MinGW -# sysroot under tools/_deps is provisioned by fetch_mingw_sysroot.py. +# build inputs, so every generator runs in --check mode (regenerate into a +# scratch copy, compare byte for byte) on all three host platforms. The AST +# comes from clang++ itself (-ast-dump=json): the generator needs only the +# compiler driver pinned in .xlings.json (`llvm`), installed by xlings like the +# build toolchains, plus the MinGW sysroot under tools/_deps provisioned by +# fetch_mingw_sysroot.py. No libclang, no LLVM release archive. # -# LLVM itself is installed from the pinned upstream archive on every run: caching -# the ~1 GiB dist tree was measured to save no meaningful time. The generator -# cache under target/gen/exports-cache (bundle TUs, clang++ gate verdicts and -# incremental-skip keys) is worth caching because it removes the libclang parse -# and the gate loop entirely on a hit. +# The generator cache under target/gen/exports-cache (bundle TUs, pruned-GMF +# verdicts, incremental-skip keys and gen_audit.py's linkage reports) is worth +# caching because a hit skips the AST dump of an unchanged library entirely. +# +# Nightly (and on demand), the cache-drift job proves that cache sound: it +# regenerates and audits once with the restored CI cache and once from an +# empty cache, and compares both with each other and the generated files with +# the committed ones (tools/ci/check_cache_drift.py). On +# drift the job fails, uploads the evidence, saves the cold cache over the +# stale one, and the report job opens or updates the `cache-drift` issue. name: Verify Generation Scripts env: - LLVM_VERSION: "23.1.3" - LLVM_MAJOR: "23" + XLINGS_VERSION: v2026.10.26.1 + XLINGS_NON_INTERACTIVE: '1' on: + schedule: + - cron: "17 3 * * *" + workflow_dispatch: push: branches: [main] paths: - ".github/workflows/verify-scripts.yml" + - ".github/actions/setup-generator/**" - "tools/**" - "src/**" - "patches/**" @@ -35,6 +46,7 @@ on: branches: [main] paths: - ".github/workflows/verify-scripts.yml" + - ".github/actions/setup-generator/**" - "tools/**" - "src/**" - "patches/**" @@ -45,13 +57,16 @@ on: - ".gitignore" - ".gitattributes" +# The event is part of the group: a push to main must not cancel the nightly +# run on main (or the reverse). concurrency: - group: generated-${{ github.workflow }}-${{ github.ref }} + group: generated-${{ github.workflow }}-${{ github.ref }}-${{ github.event_name }} cancel-in-progress: true jobs: verify: name: ${{ matrix.os }} + if: github.event_name == 'push' || github.event_name == 'pull_request' runs-on: ${{ matrix.os }} timeout-minutes: 240 env: @@ -64,16 +79,10 @@ jobs: # leg, so an update does not trigger three large downloads. - os: ubuntu-latest check_import_boost: true - llvm_archive: LLVM-23.1.3-Linux-X64.tar.xz - llvm_sha256: ca9fe385a5d9e2d88132dc0e23a00e9f87f38fa75f67207b5e457d208e71d013 - os: windows-latest check_import_boost: false - llvm_archive: clang+llvm-23.1.3-x86_64-pc-windows-msvc.tar.xz - llvm_sha256: 9ee6a2192fbb30c776415af529927f76ca6b5d1d55699bb1315f9878e610b5b8 - os: macos-latest check_import_boost: false - llvm_archive: LLVM-23.1.3-macOS-ARM64.tar.xz - llvm_sha256: 3dcfd88aec10be204a24037bcb0dc0ad777882e9dbe8ac60e2639060d8a794b1 steps: - name: Checkout full history @@ -81,120 +90,31 @@ jobs: with: fetch-depth: 0 - - name: Set up Python - uses: actions/setup-python@v7 - with: - python-version: "3.x" - - - name: Set up uv - uses: astral-sh/setup-uv@07a047e608db84b3d8c06cd9a7c7dcc9c355c18e - with: - enable-cache: true - cache-dependency-glob: tools/uv.lock - - # The slim xlings compiler package omits libclang. Using its headers with - # pip's older libclang corrupts the AST even though clang++ passes, so the - # full upstream release is installed and the driver, C API and builtin - # headers all come from the pinned LLVM version. - - name: Install LLVM ${{ env.LLVM_VERSION }} - shell: bash - env: - LLVM_ARCHIVE: ${{ matrix.llvm_archive }} - LLVM_SHA256: ${{ matrix.llvm_sha256 }} - run: | - set -euo pipefail - LLVM_PREFIX="$HOME/llvm/dist" - ARCHIVE="$RUNNER_TEMP/$LLVM_ARCHIVE" - mkdir -p "$LLVM_PREFIX" "$RUNNER_TEMP" - - curl --fail --location --retry 3 \ - "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/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION/$LLVM_ARCHIVE" \ - --output "$ARCHIVE.part" - - LLVM_ARCHIVE_FILE="$ARCHIVE.part" - if [[ "${RUNNER_OS:-}" == Windows ]]; then - LLVM_ARCHIVE_FILE="$(cygpath -w "$LLVM_ARCHIVE_FILE")" - fi - export LLVM_ARCHIVE_FILE - - python - <<'PY' - import hashlib - import os - from pathlib import Path - with Path(os.environ["LLVM_ARCHIVE_FILE"]).open("rb") as f: - digest = hashlib.file_digest(f, "sha256").hexdigest() - if digest != os.environ["LLVM_SHA256"]: - raise SystemExit("LLVM archive SHA-256 mismatch: " + digest) - PY - - mv "$ARCHIVE.part" "$ARCHIVE" - # Read the archive through stdin: GNU tar on the Windows runner treats - # a drive letter in `-f D:/...` as a remote host. - tar -xJf - -C "$LLVM_PREFIX" --strip-components=1 < "$ARCHIVE" - rm -f "$ARCHIVE" - - - name: Configure LLVM generator environment (Unix) - if: runner.os != 'Windows' - shell: bash - run: | - set -euo pipefail - LLVM_PREFIX="$HOME/llvm/dist" - test -x "$LLVM_PREFIX/bin/clang++" - test -f "$LLVM_PREFIX/lib/clang/$LLVM_MAJOR/include/mm_malloc.h" - echo "$LLVM_PREFIX/bin" >> "$GITHUB_PATH" - echo "LLVM_PATH=$LLVM_PREFIX" >> "$GITHUB_ENV" - echo "CXX=$LLVM_PREFIX/bin/clang++" >> "$GITHUB_ENV" - echo "CLANG_RESOURCE_DIR=$LLVM_PREFIX/lib/clang/$LLVM_MAJOR/include" >> "$GITHUB_ENV" - echo "CLANG_NO_DEFAULT_CONFIG=1" >> "$GITHUB_ENV" - if [[ "$RUNNER_OS" == Linux ]]; then - echo "LD_LIBRARY_PATH=$LLVM_PREFIX/lib:$LLVM_PREFIX/lib/x86_64-unknown-linux-gnu:${LD_LIBRARY_PATH:-}" >> "$GITHUB_ENV" - fi - - - name: Configure LLVM generator environment (Windows) - if: runner.os == 'Windows' - shell: pwsh - run: | - $llvmPrefix = Join-Path $env:USERPROFILE "llvm\dist" - $clangxx = Join-Path $llvmPrefix "bin\clang++.exe" - $resource = Join-Path $llvmPrefix "lib\clang\$env:LLVM_MAJOR\include" - if (-not (Test-Path $clangxx)) { throw "missing $clangxx" } - if (-not (Test-Path (Join-Path $resource "mm_malloc.h"))) { throw "missing mm_malloc.h under $resource" } - "$llvmPrefix\bin" >> $env:GITHUB_PATH - "LLVM_PATH=$llvmPrefix" >> $env:GITHUB_ENV - "CXX=$clangxx" >> $env:GITHUB_ENV - "CLANG_RESOURCE_DIR=$resource" >> $env:GITHUB_ENV - "CLANG_NO_DEFAULT_CONFIG=1" >> $env:GITHUB_ENV - - - name: Cache MinGW sysroot archive - uses: actions/cache@v6 - with: - path: tools/_deps/_archives - key: mingw-sysroot-archive-${{ runner.os }}-${{ hashFiles('tools/fetch_mingw_sysroot.py') }} - restore-keys: | - mingw-sysroot-archive-${{ runner.os }}- - - # gen_exports.py caches bundle TUs, clang++ gate verdicts and - # incremental-skip keys under target/gen/exports-cache. Every entry is - # self-validating (keyed on the content hash of the closure it describes - # plus the generator/libclang/clang versions), so restoring an older - # commit's cache yields misses rather than wrong output. The salt in the - # key only bounds rollover: a generator or sysroot-pin change drops the - # restore prefix instead of mixing verdicts across engine changes. + - name: Set up the generation toolchain + uses: ./.github/actions/setup-generator + + # gen_exports.py caches bundle TUs, pruned-GMF verdicts and + # incremental-skip keys under target/gen/exports-cache, gen_audit.py + # its linkage reports. Every entry is self-validating (keyed on the + # generator, clang and flags, and valid only while every file clang + # read for it and the first-wins ownership it was computed under still + # hold), so restoring an older commit's + # cache yields misses rather than wrong output; the nightly cache-drift + # job checks exactly that. The salt in the key only bounds rollover: a + # generator or sysroot-pin change drops the restore prefix instead of + # mixing verdicts across engine changes. - name: Cache generator export intermediates uses: actions/cache@v6 with: path: target/gen/exports-cache - key: exports-cache-v1-${{ runner.os }}-${{ runner.arch }}-llvm-${{ env.LLVM_VERSION }}-${{ hashFiles('tools/gen_exports.py', 'tools/boost_common.py', 'tools/curated/**', 'tools/fetch_mingw_sysroot.py', 'tools/uv.lock') }}-${{ github.sha }} + key: exports-cache-v2-${{ runner.os }}-${{ runner.arch }}-llvm-${{ env.LLVM_VERSION }}-${{ hashFiles('tools/gen_exports.py', 'tools/ast_json.py', 'tools/boost_common.py', 'tools/export_policy.toml', 'tools/fetch_mingw_sysroot.py') }}-${{ github.sha }} restore-keys: | - exports-cache-v1-${{ runner.os }}-${{ runner.arch }}-llvm-${{ env.LLVM_VERSION }}-${{ hashFiles('tools/gen_exports.py', 'tools/boost_common.py', 'tools/curated/**', 'tools/fetch_mingw_sysroot.py', 'tools/uv.lock') }}- + exports-cache-v2-${{ runner.os }}-${{ runner.arch }}-llvm-${{ env.LLVM_VERSION }}-${{ hashFiles('tools/gen_exports.py', 'tools/ast_json.py', 'tools/boost_common.py', 'tools/export_policy.toml', 'tools/fetch_mingw_sysroot.py') }}- - - name: Install tool dependencies - run: uv sync --project tools --locked - - - name: Check AST parser and tool regressions + - name: Check the AST compiler and tool regressions working-directory: tools run: | - uv run --locked python -c "import boost_common as bc; v = bc.libclang_version(); print('AST parser:', v); assert '${{ env.LLVM_VERSION }}' in v, v" + uv run --locked python -c "import ast_json as aj; v = aj.clang_release(); print('AST compiler: clang', v); assert v == '${{ env.LLVM_VERSION }}', v" uv run --locked python -m unittest discover -s tests - name: Verify generated outputs (including import_boost when changed) @@ -204,3 +124,105 @@ jobs: - name: Verify generated outputs if: ${{ !matrix.check_import_boost }} run: uv run --project tools --locked python tools/ci/verify_generated.py + + cache-drift: + name: cache drift (${{ matrix.os }}) + if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' + runs-on: ${{ matrix.os }} + timeout-minutes: 360 + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, windows-latest, macos-latest] + + steps: + - name: Checkout + uses: actions/checkout@v7 + + - name: Set up the generation toolchain + uses: ./.github/actions/setup-generator + + # The cache verify restores: the newest entry under the current salt. + - name: Restore generator export intermediates + uses: actions/cache/restore@v6 + with: + path: target/gen/exports-cache + key: exports-cache-v2-${{ runner.os }}-${{ runner.arch }}-llvm-${{ env.LLVM_VERSION }}-${{ hashFiles('tools/gen_exports.py', 'tools/ast_json.py', 'tools/boost_common.py', 'tools/export_policy.toml', 'tools/fetch_mingw_sysroot.py') }}-${{ github.sha }} + restore-keys: | + exports-cache-v2-${{ runner.os }}-${{ runner.arch }}-llvm-${{ env.LLVM_VERSION }}-${{ hashFiles('tools/gen_exports.py', 'tools/ast_json.py', 'tools/boost_common.py', 'tools/export_policy.toml', 'tools/fetch_mingw_sysroot.py') }}- + + - name: Compare cached, cold and committed generation + id: drift + run: uv run --project tools --locked python tools/ci/check_cache_drift.py --out target/cache-drift + + # Upload before anything replaces the stale entries: the restored + # versions are the evidence of what the cache key missed. + - name: Upload drift evidence + if: ${{ !cancelled() && steps.drift.outcome != 'skipped' }} + uses: actions/upload-artifact@v7 + with: + name: cache-drift-${{ runner.os }} + path: target/cache-drift + if-no-files-found: ignore + retention-days: 30 + + # The cold run rewrote target/gen/exports-cache from scratch. Saved + # under the restore prefix, it is the newest entry, so the next verify + # run restores it instead of the stale one. + - name: Save the cold cache over the stale one + if: ${{ !cancelled() && steps.drift.outputs.cache_drift == 'true' }} + uses: actions/cache/save@v6 + with: + path: target/gen/exports-cache + key: exports-cache-v2-${{ runner.os }}-${{ runner.arch }}-llvm-${{ env.LLVM_VERSION }}-${{ hashFiles('tools/gen_exports.py', 'tools/ast_json.py', 'tools/boost_common.py', 'tools/export_policy.toml', 'tools/fetch_mingw_sysroot.py') }}-${{ github.sha }}-cold-${{ github.run_id }} + + report: + name: report cache drift + needs: cache-drift + if: ${{ !cancelled() && needs.cache-drift.result != 'skipped' }} + runs-on: ubuntu-latest + permissions: + contents: read + issues: write + env: + GH_TOKEN: ${{ github.token }} + GH_REPO: ${{ github.repository }} + steps: + - name: Checkout + uses: actions/checkout@v7 + with: + sparse-checkout: tools + + # Absent when no platform got as far as the comparison. + - name: Download drift results + continue-on-error: true + uses: actions/download-artifact@v8 + with: + pattern: cache-drift-* + path: drift + + # One open issue tracks drift: later runs comment on it instead of + # opening duplicates. + - name: Open or update the cache-drift issue + shell: bash + run: | + set -euo pipefail + mkdir -p drift + python3 tools/ci/check_cache_drift.py --summarize drift \ + --run-url "$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID" \ + > issue.md + if [ ! -s issue.md ]; then + echo "no drift reported" + exit 0 + fi + gh label create cache-drift --color B60205 \ + --description "Generator cache replayed output a cold run does not produce" \ + --force + number="$(gh issue list --label cache-drift --state open \ + --json number --jq '.[0].number // empty')" + if [ -n "$number" ]; then + gh issue comment "$number" --body-file issue.md + else + gh issue create --title "Generator cache drift detected" \ + --label cache-drift --body-file issue.md + fi diff --git a/.xlings.json b/.xlings.json index ecb66c067..9aae499ce 100644 --- a/.xlings.json +++ b/.xlings.json @@ -1,5 +1,6 @@ { "workspace": { - "mcpp": "2026.10.26.1" + "mcpp": "2026.11.5.1", + "llvm": "23.1.3" } } diff --git a/docs/architecture.md b/docs/architecture.md index 8293f8834..d65ad2cb8 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -23,16 +23,16 @@ boost-m/ ├── build.mcpp root-closure partition generator ├── upstream/boost/ pinned official Boost tree (pruned) + SOURCE.md ├── upstream/boost-module/ retained pre-mwrap wrapper licence/README/history -├── patches/ replayable adaptations; final/ = stored forms +├── patches/ vendored adaptations of upstream/boost (apply_patches.py) ├── port/ wrapper TUs (system/thread/leaf extras) ├── port/include/mwrap/boost/ include entry -├── src/ module interfaces, root module, macros module -├── generated/exports/ committed export lists (.inc) and edges (.deps) -├── generated/meta/ committed lists/maps the generators and build.mcpp read +├── src/ hand-maintained module facades, root module, macros module +├── generated/exports/ export lists (.inc) and edges (.deps) — generator output only +├── generated/meta/ api-surface.json, skipped.txt, lists/maps build.mcpp reads ├── templates/ basic (default) and lib templates ├── tests/ one standalone program per file ├── examples/ basic, git-dep, profiles consumers -├── tools/ import, generation, audit, packaging, CI helpers +├── tools/ import, generation (+ export_policy.toml), audit, packaging, CI └── docs/ ``` @@ -56,10 +56,17 @@ export import mcpplibs.mwrap.boost.type_traits; #include "../generated/exports/optional.inc" // export namespace boost { using ...; } ``` -- The GMF include set comes from the library's public include DAG, minus headers - that are not standalone-parseable; the `.inc` file carries the - `export namespace boost { using ...; }` list generated from a libclang AST - snapshot. +- The facade is hand-maintained; the generator never writes it. Its GMF include + set is exactly the bundle translation unit the export list was computed from + (the library's public include DAG, minus headers that do not compile on the + snapshot platform), and the `.inc` file carries the generated + `export namespace boost { using ...; }` list. `gen_exports.py --check` + verifies both halves agree: the GMF equals the bundle (plus any + `facade-includes` the policy declares), and the `export import` block + covers every `.deps` edge, because the `.inc` leaves out what an earlier + module owns. An edge the facade cannot take (range does not import regex: + abi-tag mismatch under gcc) is declared in the policy's `[.facade]` + `omit-imports` with a reason. - One entity has one export owner. A dependency that another target library owns becomes an `export import` edge in the primary module, recorded in `.deps` as the complete module name. @@ -101,31 +108,113 @@ a clang build of the whole closure can hit the source-location limit. ## 5. Generation chain +The principle: **the compiler computes the public surface, the generator only +lists it, and nothing edits the result.** The upstream headers are the single +source of truth; the generated files are reproducible from them byte for byte. + ```sh python3 tools/import_boost.py --tarball boost_1_92_0.tar.gz # repopulates upstream/boost/ -python3 tools/reapply_hand_edits.py # vendored adaptations -python3 tools/gen_exports.py --emit-cppm # generated/exports/*.inc|*.deps + draft .cppm -python3 tools/reapply_hand_edits.py # module-side adaptations, final forms -python3 tools/gen_features.py # mcpp.toml blocks + generated/meta/* +python3 tools/apply_patches.py # vendored adaptations (patches/*.patch) +python3 tools/gen_exports.py # generated/exports/*, api-surface.json, skipped.txt +python3 tools/gen_features.py # mcpp.toml blocks + generated/meta/*.lst +python3 tools/gen_exports.py --check # byte-compare, writes nothing python3 tools/gen_features.py --check -python3 tools/gen_audit.py # export completeness (AST) +python3 tools/gen_audit.py # linkage audit (AST, target/gen/audit) python3 tools/gen_audit.py --macros # macro-surface inventory -git diff --exit-code && git status --short ``` +### 5.1 The AST comes from clang++ + +For each library one bundle TU includes the facade's GMF headers and is compiled +once: + +```sh +clang++ -std=c++23 --target=x86_64-w64-mingw32 --sysroot= \ + -fsyntax-only -Xclang -ast-dump=json -Xclang -ast-dump-filter=boost bundle.cpp +``` + +The same invocation is the syntax gate: when it fails, the GMF headers named by +the diagnostics (platform-exclusive alternatives such as the pthread/win32 thread +backends) are pruned and the bundle is recompiled; the pruned set is recorded in +`api-surface.json`. `-ast-dump-filter=boost` keeps the `namespace boost` +subtrees only. The dump of an instantiation-heavy library is still several GB, +so `tools/ast_json.py` reads it as a stream into a flat declaration table: + +- clang prints a location's file only when it differs from the previously + printed location, so the reader carries that state across every location in + output order — including the ones it drops — and never trusts a single + `loc.file` in isolation; +- implicit template instantiations (every declaration of a `*TemplateDecl` + after its pattern), `UsingShadowDecl` copies, comments, source ranges and + record definition data are dropped while streaming; references to a dropped + instantiation resolve to its template; +- references found in a declaration's subtree (declaration references, + lookups, type-node declarations, written types) are attributed to the + namespace-scope entity that owns it. + +Only the clang++ driver pinned in `.xlings.json` (`llvm`) is needed — no +libclang, no Python bindings, no LLVM release archive. + +### 5.2 What is exported + +- **Candidates**: namespace-scope `boost::` entities with external linkage whose + definition lives in a header the library owns (`boost//**`, + `boost/.hpp`) or in no target library's headers ("shared"). Linkage is + read from the AST: anonymous namespaces, `static`, non-inline const variables + and Itanium `L`-marked manglings are internal; typedef names are exportable + members. Compiler-implicit declarations, friend-only declarations, explicit + and partial specializations (reachable through the primary template), + deduction guides and class members are not candidates. +- **Using-injections**: namespace-scope `using X::y;` / `using namespace X;` + that give entities their public spelling (ADL barriers, `detail` re-exports). +- **Signature closure**: entities named by the candidates' signatures + (parameters, results, bases, fields, typedef targets — with typedefs looked + through), so the API's own types are exported with it. +- **Ownership**: libraries are processed dependencies-first; the first library + to claim an entity owns it, later ones get an `export import` edge to the + owner in `.deps`. Pass 2 walks the bodies of every exported entity and + adds the edges a consumer instantiating them needs (cycle-closing and + transitive edges skipped). +- Output is sorted, carries no paths or timestamps, and uses LF; a name + shadowed inside the export block (`boost::hana::ext::boost`) is spelled with a + leading `::`. + +### 5.3 What the AST cannot decide: `tools/export_policy.toml` + +The snapshot is one platform flavor (MinGW x86_64, libstdc++). Every human +decision about the surface is declared in `tools/export_policy.toml` with a +written reason and applied by the generator, never patched into its output: + +| Rule | Effect | +|---|---| +| `[[.guard]]` | wrap the matching exports in the upstream header's own condition (`#if defined(_WIN32)` ...), optional `#else` lines | +| `[[.drop]]` | never export the matching names / namespaces | +| `[[.extra]]` | verbatim declarations (the gcc `extern template` vtable workarounds) | +| `add` | names no collector reaches (body-only or ADL-only references) | +| `gmf`, `defines`, `facade-includes` | the bundle's include set and macros; facade-only includes | +| `inline-namespaces` | export a macro-selected inline namespace through its parent | +| `[.deps]` | module edge corrections; edges of the hand-written special modules | + +`generated/meta/skipped.txt` lists every name a rule guards, drops or adds, so +the boundary is reviewable in one file, and `generated/meta/api-surface.json` +records the generator identity (clang release, target, defines) and per-library +GMF, export count and edges. A diff after a compiler update therefore shows as a +generator change, not as an unexplained API change. + +### 5.4 Checks + +- `gen_exports.py --check` regenerates into a scratch copy and compares every + generated file byte for byte, then verifies each facade's GMF against the + bundle; it never writes the tree. CI runs it on Linux, macOS and Windows. - `import_boost.py` is the single upstream import: URL, archive SHA-256, kept entries, pruned directories/files and the CRLF-normalized files are recorded in `upstream/boost/SOURCE.md`. The release `README.md` and `LICENSE_1_0.txt` are copied byte-for-byte; `.gitattributes` disables text conversion under `upstream/**`. -- `reapply_hand_edits.py` never reads Git history. It applies `patches/*.patch` - (forward/reverse idempotent, with a `patch -p1` fallback when Git is absent) - and replays hand-maintained final forms from `patches/final/`. A patch - whose anchor is missing is an error unless listed in `TOLERANT` with a written - reason. -- `gen_exports.py` keeps its two passes: the libclang AST snapshot produces the - export lists, and a body-reference pass completes the `.deps` edges. Caches and - bundle TUs live under the gitignored `target/gen/`. +- `apply_patches.py` replays `patches/*.patch` onto `upstream/boost/` only + (forward/reverse idempotent, `patch -p1` fallback without Git); see + [patches/README.md](../patches/README.md). It never touches generated files or + facades. - `gen_features.py` splices two marked blocks in `mcpp.toml` and writes `generated/meta/{libs.json,features.lst,modules.lst,profiles.lst}`. It is byte- and mtime-idempotent. Feature names are kebab-case; `implies` lists @@ -133,12 +222,14 @@ git diff --exit-code && git status --short `export import` lines plus the generated body edges. `modules.lst` is the feature → module map `build.mcpp` reads; `all-modules` expands to the 117 module entries. -- `gen_audit.py` is the migration gate for export completeness; its report is - reviewed with the committed tree, not treated as "not public API" on failure. +- `gen_audit.py` reports internal-linkage functions, anonymous-namespace + entities and explicit specializations per library from the same AST; its + report is reviewed with the committed tree, not treated as "not public API". -Generation needs LLVM 23.1.3 with matching libclang and the pinned MinGW sysroot -(`tools/fetch_mingw_sysroot.py`, `tools/uv.lock`). Consumers do not: they use the -committed output. +Generation needs the clang++ pinned in `.xlings.json` and the pinned MinGW +sysroot (`tools/fetch_mingw_sysroot.py`); set `CLANG_NO_DEFAULT_CONFIG=1` when +the xlings LLVM package installs a host config file. Consumers need neither: +they use the committed output. ## 6. Features @@ -169,8 +260,8 @@ The module TUs, the library TUs and raw-header consumers share one configuration - the profile's `NDEBUG` state reaches the headers, so release-only declaration differences follow upstream: Boost.uBLAS's tensor `BOOST_UBLAS_INLINE` ordering is corrected by `patches/numeric.patch` (it is ill-formed when the macro expands - to `inline`), and the checked-build-only `same_impl_ex` export is guarded in - `generated/exports/numeric.inc` by the replay tool. + to `inline`), and the checked-build-only `same_impl_ex` export is guarded by + the `numeric` rule of `tools/export_policy.toml`. The same `upstream/boost` tree feeds the interfaces, the library TUs and raw header consumption. One Boost implementation per program: there is no @@ -193,9 +284,10 @@ keeps byte-identical notices. - Native build + `mcpp test` on Linux x86_64 (GCC 16.1, LLVM), Linux arm64 (GCC), macOS arm64 (LLVM), Windows x86_64 (clang-msvc). -- `tools/ci/verify_generated.py`: import/replay, generation, feature splice and - audit on a clean tree, with `git diff`/`git status` as the oracle; a second - build on the same configuration records the incremental TU count and mtimes. +- `tools/ci/verify_generated.py`: patch replay, `gen_exports.py --check`, + `gen_features.py --check` and the audits on a clean tree on all three host + platforms, then `git status` must be clean; a second build on the same + configuration records the incremental TU count and mtimes. - `tools/check_mwrap_release.py`: identity, version scheme, tag, licence split and retained-document bytes. - `tools/test_template.py`: installs an isolated `MCPP_HOME` fixture, runs a real diff --git a/docs/architecture.zh.md b/docs/architecture.zh.md index b6f0b6eb8..7ded98250 100644 --- a/docs/architecture.zh.md +++ b/docs/architecture.zh.md @@ -22,16 +22,16 @@ boost-m/ ├── build.mcpp root-closure partition generator ├── upstream/boost/ pinned official Boost tree (pruned) + SOURCE.md ├── upstream/boost-module/ retained pre-mwrap wrapper licence/README/history -├── patches/ replayable adaptations; final/ = stored forms +├── patches/ vendored adaptations of upstream/boost (apply_patches.py) ├── port/ wrapper TUs (system/thread/leaf extras) ├── port/include/mwrap/boost/ include entry -├── src/ module interfaces, root module, macros module -├── generated/exports/ committed export lists (.inc) and edges (.deps) -├── generated/meta/ committed lists/maps the generators and build.mcpp read +├── src/ hand-maintained module facades, root module, macros module +├── generated/exports/ export lists (.inc) and edges (.deps) — generator output only +├── generated/meta/ api-surface.json, skipped.txt, lists/maps build.mcpp reads ├── templates/ basic (default) and lib templates ├── tests/ one standalone program per file ├── examples/ basic, git-dep, profiles consumers -├── tools/ import, generation, audit, packaging, CI helpers +├── tools/ import, generation (+ export_policy.toml), audit, packaging, CI └── docs/ ``` @@ -54,9 +54,13 @@ export import mcpplibs.mwrap.boost.type_traits; #include "../generated/exports/optional.inc" // export namespace boost { using ...; } ``` -- GMF 的 include 集合取自该库的公共 include DAG，并去掉无法独立解析的头文件； - `.inc` 文件承载由 libclang AST 快照生成的 - `export namespace boost { using ...; }` 列表。 +- 门面文件由人工维护，生成器从不改写它。它的 GMF include 集合恰好就是计算导出 + 列表时所用的 bundle 翻译单元（该库的公共 include DAG，去掉在快照平台上无法编译 + 的头文件）；`.inc` 文件承载生成的 `export namespace boost { using ...; }` 列表。 + `gen_exports.py --check` 校验两半一致：GMF 等于 bundle（外加策略声明的 + `facade-includes`），且 `export import` 块覆盖 `.deps` 中的每条边，因为 `.inc` + 不再导出更早模块拥有的实体。门面无法接受的边（range 不导入 regex：gcc 下 abi + tag 不匹配）须在策略的 `[.facade]` `omit-imports` 中声明并写明原因。 - 一个实体只有一个导出归属。由另一个目标库拥有的依赖，在主模块中成为一条 `export import` 边，并以完整模块名记录在 `.deps` 中。 - 跨库类型引用、友元运算符、ADL 辅助函数，以及补丁赋予外部链接的常量，都在 @@ -94,41 +98,110 @@ clang 构建整个闭包则可能触及 source-location 限制。 ## 5. 生成链 +原则：**由编译器计算公开面，生成器只负责列出，结果不再被任何东西改写。**上游 +头文件是唯一事实来源；生成文件可以从它们逐字节复现。 + ```sh python3 tools/import_boost.py --tarball boost_1_92_0.tar.gz # repopulates upstream/boost/ -python3 tools/reapply_hand_edits.py # vendored adaptations -python3 tools/gen_exports.py --emit-cppm # generated/exports/*.inc|*.deps + draft .cppm -python3 tools/reapply_hand_edits.py # module-side adaptations, final forms -python3 tools/gen_features.py # mcpp.toml blocks + generated/meta/* +python3 tools/apply_patches.py # vendored adaptations (patches/*.patch) +python3 tools/gen_exports.py # generated/exports/*, api-surface.json, skipped.txt +python3 tools/gen_features.py # mcpp.toml blocks + generated/meta/*.lst +python3 tools/gen_exports.py --check # byte-compare, writes nothing python3 tools/gen_features.py --check -python3 tools/gen_audit.py # export completeness (AST) +python3 tools/gen_audit.py # linkage audit (AST, target/gen/audit) python3 tools/gen_audit.py --macros # macro-surface inventory -git diff --exit-code && git status --short ``` +### 5.1 AST 来自 clang++ + +每个库有一个 bundle TU，包含门面 GMF 的全部头文件，只编译一次： + +```sh +clang++ -std=c++23 --target=x86_64-w64-mingw32 --sysroot= \ + -fsyntax-only -Xclang -ast-dump=json -Xclang -ast-dump-filter=boost bundle.cpp +``` + +同一次调用就是语法门禁：失败时，诊断里点名的 GMF 头文件（平台互斥的备选实现， +如 pthread/win32 两套线程后端）会被剔除并重新编译；剔除后的集合记录在 +`api-surface.json` 中。`-ast-dump-filter=boost` 只保留 `namespace boost` 子树。 +实例化密集的库输出仍有数 GB，因此 `tools/ast_json.py` 以流的方式把它读成一张 +扁平的声明表： + +- clang 只在文件与上一次打印的位置不同时才打印 `file`，所以读取器按输出顺序在 + 所有位置（包括被丢弃的位置）之间延续这一状态，从不孤立地相信某一个 `loc.file`； +- 隐式模板实例化（`*TemplateDecl` 中模式之后的所有声明）、`UsingShadowDecl` 副本、 + 注释、源码范围和记录的 definition data 在流式读取时丢弃；指向被丢弃实例化的 + 引用解析到其模板； +- 声明子树中找到的引用（声明引用、lookup、类型节点声明、书写出的类型）归属到 + 拥有该子树的命名空间作用域实体。 + +只需要 `.xlings.json` 中固定的 clang++ 驱动（`llvm`）——不需要 libclang、Python +绑定或 LLVM 发行包。 + +### 5.2 导出什么 + +- **候选**：定义位于该库拥有的头文件（`boost//**`、`boost/.hpp`）或不属于 + 任何目标库的头文件（"shared"）中、具有外部链接的命名空间作用域 `boost::` 实体。 + 链接性从 AST 读取：匿名命名空间、`static`、非 inline 的 const 变量以及带 Itanium + `L` 标记的修饰名为内部链接；typedef 名是可导出的成员。编译器隐式声明、仅以 + friend 形式出现的声明、显式与偏特化（经由主模板可达）、推导指引以及类成员都 + 不是候选。 +- **using 注入**：赋予实体公开拼写的命名空间作用域 `using X::y;` / + `using namespace X;`（ADL 屏障、`detail` 再导出）。 +- **签名闭包**：候选签名中点名的实体（形参、返回值、基类、字段、typedef 目标—— + typedef 会被看穿），使 API 自身的类型随之导出。 +- **归属**：按依赖优先的顺序处理各库；第一个认领实体的库拥有它，之后的库在 + `.deps` 中得到一条指向拥有者的 `export import` 边。第二遍扫描每个导出实体的 + 函数体，补上实例化这些函数体的消费者所需的边（跳过成环和可传递的边）。 +- 输出有序、不含路径或时间戳、使用 LF；在导出块内被遮蔽的名字 + （`boost::hana::ext::boost`）以前导 `::` 拼写。 + +### 5.3 AST 决定不了的部分：`tools/export_policy.toml` + +快照只是一种平台风味（MinGW x86_64、libstdc++）。关于公开面的所有人工决策都在 +`tools/export_policy.toml` 中声明并写明原因，由生成器应用，绝不以补丁形式改写其 +输出： + +| 规则 | 作用 | +|---|---| +| `[[.guard]]` | 用上游头文件自身的条件包裹匹配的导出（`#if defined(_WIN32)` ...），可选 `#else` 行 | +| `[[.drop]]` | 永不导出匹配的名字 / 命名空间 | +| `[[.extra]]` | 原样声明（gcc `extern template` 虚表变通） | +| `add` | 没有收集器能到达的名字（只在函数体或 ADL 中出现的引用） | +| `gmf`、`defines`、`facade-includes` | bundle 的 include 集合与宏；仅门面使用的 include | +| `inline-namespaces` | 经由父命名空间导出由宏选择的 inline 命名空间 | +| `[.deps]` | 模块边修正；手写特殊模块的边 | + +`generated/meta/skipped.txt` 列出每条规则守卫、丢弃或添加的名字，边界可以在一个 +文件里审阅；`generated/meta/api-surface.json` 记录生成器身份（clang 版本、目标、 +宏定义）以及每个库的 GMF、导出数和边。因此编译器升级后的差异会显示为生成器 +变化，而不是无法解释的 API 变化。 + +### 5.4 检查 + +- `gen_exports.py --check` 在临时副本中重新生成，逐字节比较每个生成文件，再对照 + bundle 校验每个门面的 GMF；它从不写代码树。CI 在 Linux、macOS、Windows 上 + 运行它。 - `import_boost.py` 是唯一的上游导入入口：URL、压缩包 SHA-256、保留的条目、 裁剪掉的目录/文件以及做过 CRLF 规范化的文件，全部记录在 `upstream/boost/SOURCE.md` 中。发行版自带的 `README.md` 和 `LICENSE_1_0.txt` 按字节原样复制；`.gitattributes` 在 `upstream/**` 下禁用 文本转换。 -- `reapply_hand_edits.py` 从不读取 Git 历史。它应用 `patches/*.patch` - （正向/反向幂等，Git 不可用时回退到 `patch -p1`），并从 - `patches/final/` 重放手工维护的最终形态。锚点缺失的补丁会被视为错误， - 除非它已在 `TOLERANT` 中登记并写明原因。 -- `gen_exports.py` 保留两遍处理：libclang AST 快照生成导出列表，函数体引用 - 扫描补齐 `.deps` 边。缓存和 bundle TU 位于被 gitignore 的 `target/gen/` 下。 +- `apply_patches.py` 只把 `patches/*.patch` 重放到 `upstream/boost/`（正向/反向 + 幂等，没有 Git 时回退到 `patch -p1`），见 [patches/README.md](../patches/README.md)； + 它从不触碰生成文件或门面。 - `gen_features.py` 拼接 `mcpp.toml` 中两个带标记的块，并写出 `generated/meta/{libs.json,features.lst,modules.lst,profiles.lst}`。它在字节和 mtime 上都是幂等的。feature 名使用 kebab-case；`implies` 列出的是 feature 名（绝不是内部键），由各接口的 `export import` 行加上生成的函数体边推导而来。 `modules.lst` 是 `build.mcpp` 读取的 feature → 模块映射；`all-modules` 展开为 117 个模块条目。 -- `gen_audit.py` 是导出完整性的迁移门禁；它的报告要结合已提交的代码树一起 - 审阅，失败时不能简单当成“不属于公共 API”处理。 +- `gen_audit.py` 从同一份 AST 报告每个库的内部链接函数、匿名命名空间实体和显式 + 特化；其报告要结合已提交的代码树审阅，不能当成“不属于公共 API”。 -生成过程需要 LLVM 23.1.3、匹配的 libclang 以及固定版本的 MinGW sysroot -（`tools/fetch_mingw_sysroot.py`、`tools/uv.lock`）。消费者不需要这些：他们使用 -已提交的产物。 +生成需要 `.xlings.json` 中固定的 clang++ 和固定版本的 MinGW sysroot +（`tools/fetch_mingw_sysroot.py`）；当 xlings 的 LLVM 包安装了宿主配置文件时设置 +`CLANG_NO_DEFAULT_CONFIG=1`。消费者两者都不需要：他们使用已提交的产物。 ## 6. Feature @@ -161,8 +234,8 @@ feature（两种 Boost.Test 形态绝不能链接在一起）。 - profile 的 `NDEBUG` 状态会到达头文件，因此仅 release 生效的声明差异跟随上游条件： Boost.uBLAS tensor 的 `BOOST_UBLAS_INLINE` 顺序由 `patches/numeric.patch` 修正 - （宏展开为 `inline` 时该写法非法），仅在检查构建中存在的 `same_impl_ex` 导出也由 - 重放工具在 `generated/exports/numeric.inc` 中加上同样的条件。 + （宏展开为 `inline` 时该写法非法），仅在检查构建中存在的 `same_impl_ex` 导出则由 + `tools/export_policy.toml` 的 `numeric` 规则加上同样的条件。 ## 8. 许可 @@ -180,9 +253,9 @@ feature（两种 Boost.Test 形态绝不能链接在一起）。 - 在 Linux x86_64（GCC 16.1、LLVM）、Linux arm64（GCC）、macOS arm64（LLVM）、 Windows x86_64（clang-msvc）上执行原生构建 + `mcpp test`。 -- `tools/ci/verify_generated.py`：在干净代码树上跑导入/重放、生成、feature 拼接 - 和审计，以 `git diff`/`git status` 作为判定依据；在同一配置上再做一次构建， - 记录增量 TU 数量和 mtime。 +- `tools/ci/verify_generated.py`：在三种宿主平台的干净代码树上跑补丁重放、 + `gen_exports.py --check`、`gen_features.py --check` 和审计，最后 `git status` + 必须干净；在同一配置上再做一次构建，记录增量 TU 数量和 mtime。 - `tools/check_mwrap_release.py`：校验标识、版本方案、tag、许可证拆分以及保留 文档的字节。 - `tools/test_template.py`：安装隔离的 `MCPP_HOME` 测试环境，执行真实的 diff --git a/docs/usage.md b/docs/usage.md index 62ba361e3..d0bbc60ff 100644 --- a/docs/usage.md +++ b/docs/usage.md @@ -247,10 +247,10 @@ immutable; this is a new identity, not a rename. ## 8. Toolchain pin and tests -The tested build tool is pinned in `.xlings.json` (`mcpp 2026.10.26.1`); CI runs +The tested build tool is pinned in `.xlings.json` (`mcpp 2026.11.5.1`); CI runs the same pin on every leg. Generation (regenerating export lists or auditing -headers) additionally needs LLVM 23.1.3 with matching libclang and the pinned -MinGW sysroot under `tools/`; ordinary consumers only use the committed +headers) additionally needs the clang++ 23.1.3 pinned in `.xlings.json` and the +pinned MinGW sysroot under `tools/`; ordinary consumers only use the committed generated files. ```sh diff --git a/docs/usage.zh.md b/docs/usage.zh.md index 9e7b9b6ac..06464f114 100644 --- a/docs/usage.zh.md +++ b/docs/usage.zh.md @@ -188,7 +188,7 @@ serialization numeric version macros`。 ## 8. 工具链固定与测试 -受测的构建工具固定在 `.xlings.json` 中（`mcpp 2026.10.26.1`）；CI 在每条组合上运行同一固定版本。生成（重新生成导出列表或审计头文件）还需要 LLVM 23.1.3 及匹配的 libclang，以及 `tools/` 下固定的 MinGW sysroot；普通消费者只使用已提交的生成文件。 +受测的构建工具固定在 `.xlings.json` 中（`mcpp 2026.11.5.1`）；CI 在每条组合上运行同一固定版本。生成（重新生成导出列表或审计头文件）还需要 `.xlings.json` 中固定的 clang++ 23.1.3，以及 `tools/` 下固定的 MinGW sysroot；普通消费者只使用已提交的生成文件。 ```sh mcpp build # default feature closure diff --git a/generated/exports/accumulators.deps b/generated/exports/accumulators.deps index d72473aaa..a669a82fa 100644 --- a/generated/exports/accumulators.deps +++ b/generated/exports/accumulators.deps @@ -1,7 +1,11 @@ +mcpplibs.mwrap.boost.array mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.circular_buffer +mcpplibs.mwrap.boost.concept_check mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core +mcpplibs.mwrap.boost.iterator +mcpplibs.mwrap.boost.mp11 mcpplibs.mwrap.boost.numeric mcpplibs.mwrap.boost.type_traits mcpplibs.mwrap.boost.utility diff --git a/generated/exports/accumulators.inc b/generated/exports/accumulators.inc index b82a42989..ada6c3f95 100644 --- a/generated/exports/accumulators.inc +++ b/generated/exports/accumulators.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=accumulators boost=1.92.0 target=x86_64-w64-mingw32 entities=717 +// lib=accumulators boost=1.92.0 target=x86_64-w64-mingw32 entities=711 export namespace boost { namespace accumulators { using boost::accumulators::absolute; @@ -572,15 +572,8 @@ export namespace boost { namespace detail { using boost::detail::pod_singleton; }} -export namespace boost { namespace iterators { - using boost::iterators::counting_iterator; - using boost::iterators::transform_iterator; -}} - export namespace boost { namespace mpl { using boost::mpl::empty_sequence; - using boost::mpl::insert; - using boost::mpl::lambda; using boost::mpl::partition; using boost::mpl::reverse_partition; using boost::mpl::reverse_sort; @@ -600,7 +593,6 @@ export namespace boost { namespace mpl { namespace aux { using boost::mpl::aux::reverse_stable_partition_impl; using boost::mpl::aux::sort_impl; using boost::mpl::aux::stable_partition_impl; - using boost::mpl::aux::template_arity; }}} export namespace boost { namespace numeric { @@ -762,10 +754,6 @@ export namespace boost { namespace numeric { namespace op { using boost::numeric::op::unary_plus; }}} -export namespace boost { namespace parameter { - using boost::parameter::keyword; -}} - export namespace boost { namespace serialization { using boost::serialization::load; using boost::serialization::save; diff --git a/generated/exports/algorithm.deps b/generated/exports/algorithm.deps index 4204b5fc6..974b92bdb 100644 --- a/generated/exports/algorithm.deps +++ b/generated/exports/algorithm.deps @@ -1,5 +1,11 @@ +mcpplibs.mwrap.boost.assert +mcpplibs.mwrap.boost.bind +mcpplibs.mwrap.boost.concept_check +mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core -mcpplibs.mwrap.boost.iterator +mcpplibs.mwrap.boost.function mcpplibs.mwrap.boost.range +mcpplibs.mwrap.boost.smart_ptr +mcpplibs.mwrap.boost.throw_exception mcpplibs.mwrap.boost.tuple mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/algorithm.inc b/generated/exports/algorithm.inc index 74afb3364..ce91e99ea 100644 --- a/generated/exports/algorithm.inc +++ b/generated/exports/algorithm.inc @@ -1,29 +1,12 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=algorithm boost=1.92.0 target=x86_64-w64-mingw32 entities=630 +// lib=algorithm boost=1.92.0 target=x86_64-w64-mingw32 entities=477 export namespace boost { - using boost::_arg_eq; using boost::all; - using boost::arg; - using boost::atomic_compare_exchange; - using boost::atomic_compare_exchange_explicit; - using boost::atomic_exchange; - using boost::atomic_exchange_explicit; - using boost::atomic_is_lock_free; - using boost::atomic_load; - using boost::atomic_load_explicit; - using boost::atomic_store; - using boost::atomic_store_explicit; - using boost::bad_weak_ptr; - using boost::bind; using boost::const_formatter; - using boost::const_pointer_cast; using boost::contains; using boost::dissect_formatter; - using boost::dynamic_pointer_cast; using boost::empty_formatter; - using boost::enable_shared_from_raw; - using boost::enable_shared_from_this; using boost::ends_with; using boost::equals; using boost::erase_all; @@ -40,8 +23,8 @@ export namespace boost { using boost::erase_range_copy; using boost::erase_tail; using boost::erase_tail_copy; - using boost::error_info; using boost::error_info_name; + using boost::find; using boost::find_all; using boost::find_first; using boost::find_format; @@ -59,10 +42,8 @@ export namespace boost { using boost::first_min_element; using boost::first_min_first_max_element; using boost::first_min_last_max_element; - using boost::get_deleter; - using boost::get_pointer; + using boost::function_n; using boost::has_to_string; - using boost::hash_value; using boost::head_finder; using boost::icontains; using boost::identity_formatter; @@ -92,7 +73,6 @@ export namespace boost { using boost::is_alnum; using boost::is_alpha; using boost::is_any_of; - using boost::is_bind_expression; using boost::is_blank; using boost::is_classified; using boost::is_cntrl; @@ -107,7 +87,6 @@ export namespace boost { using boost::is_not_greater; using boost::is_not_igreater; using boost::is_output_streamable; - using boost::is_placeholder; using boost::is_print; using boost::is_punct; using boost::is_space; @@ -123,17 +102,14 @@ export namespace boost { using boost::last_min_element; using boost::last_min_first_max_element; using boost::last_min_last_max_element; + using boost::lexicographical_compare; using boost::make_find_iterator; using boost::make_split_iterator; using boost::minmax; using boost::minmax_element; using boost::nth_finder; - using boost::operator!=; - using boost::operator<; using boost::operator<<; - using boost::operator==; using boost::range_finder; - using boost::reinterpret_pointer_cast; using boost::replace_all; using boost::replace_all_copy; using boost::replace_first; @@ -148,12 +124,9 @@ export namespace boost { using boost::replace_range_copy; using boost::replace_tail; using boost::replace_tail_copy; - using boost::shared_ptr; using boost::split; using boost::split_iterator; using boost::starts_with; - using boost::static_pointer_cast; - using boost::swap; using boost::tag_type_name; using boost::tail_finder; using boost::to_lower; @@ -185,58 +158,9 @@ export namespace boost { using boost::trim_right_copy; using boost::trim_right_copy_if; using boost::trim_right_if; - using boost::type; using boost::type_name; - using boost::visit_each; - using boost::weak_ptr; } -export namespace boost { namespace _bi { - using boost::_bi::accept_lambda; - using boost::_bi::add_cref; - using boost::_bi::add_value; - using boost::_bi::add_value_2; - using boost::_bi::dm_result; - using boost::_bi::equal; - using boost::_bi::equal_lambda; - using boost::_bi::function_equal; - using boost::_bi::greater; - using boost::_bi::greater_equal; - using boost::_bi::index_sequence; - using boost::_bi::index_sequence_for; - using boost::_bi::integer_sequence; - using boost::_bi::isref; - using boost::_bi::less; - using boost::_bi::less_equal; - using boost::_bi::list; - using boost::_bi::list_av; - using boost::_bi::logical_and; - using boost::_bi::logical_not; - using boost::_bi::logical_or; - using boost::_bi::make_index_sequence; - using boost::_bi::make_integer_sequence; - using boost::_bi::not_equal; - using boost::_bi::operator!; - using boost::_bi::operator!=; - using boost::_bi::operator&&; - using boost::_bi::operator<; - using boost::_bi::operator<=; - using boost::_bi::operator==; - using boost::_bi::operator>; - using boost::_bi::operator>=; - using boost::_bi::operator||; - using boost::_bi::ref_compare; - using boost::_bi::result_traits; - using boost::_bi::rrlist; - using boost::_bi::tuple_for_each; - using boost::_bi::tuple_for_each_impl; - using boost::_bi::type; - using boost::_bi::unspecified; - using boost::_bi::unwrapper; - using boost::_bi::value; - using boost::_bi::visit_each; -}} - export namespace boost { namespace algorithm { using boost::algorithm::FinderConcept; using boost::algorithm::FormatterConcept; @@ -529,56 +453,16 @@ export namespace boost { namespace algorithm { namespace detail { }}} export namespace boost { namespace detail { - using boost::detail::atomic_conditional_increment; - using boost::detail::atomic_decrement; - using boost::detail::atomic_increment; using boost::detail::basic_first_max_element; using boost::detail::basic_first_min_element; using boost::detail::basic_first_min_last_max_element; - using boost::detail::basic_get_deleter; - using boost::detail::basic_get_local_deleter; using boost::detail::basic_last_max_element; using boost::detail::basic_last_min_element; using boost::detail::basic_last_min_first_max_element; using boost::detail::basic_last_min_last_max_element; using boost::detail::basic_minmax_element; using boost::detail::binary_pred_over_iter; - using boost::detail::esft2_deleter_wrapper; - using boost::detail::get_local_deleter; using boost::detail::less_over_iter; - using boost::detail::local_counted_base; - using boost::detail::local_counted_impl; - using boost::detail::local_counted_impl_em; - using boost::detail::local_sp_deleter; - using boost::detail::shared_count; - using boost::detail::sp_array_access; - using boost::detail::sp_assert_convertible; - using boost::detail::sp_convert_reference; - using boost::detail::sp_convertible; - using boost::detail::sp_counted_base; - using boost::detail::sp_counted_impl_p; - using boost::detail::sp_counted_impl_pd; - using boost::detail::sp_counted_impl_pda; - using boost::detail::sp_deleter_construct; - using boost::detail::sp_dereference; - using boost::detail::sp_element; - using boost::detail::sp_empty; - using boost::detail::sp_enable_if_convertible; - using boost::detail::sp_enable_if_convertible_impl; - using boost::detail::sp_enable_shared_from_this; - using boost::detail::sp_extent; - using boost::detail::sp_hash_pointer; - using boost::detail::sp_inplace_tag; - using boost::detail::sp_internal_constructor_tag; - using boost::detail::sp_member_access; - using boost::detail::sp_nothrow_tag; - using boost::detail::sp_pointer_construct; - using boost::detail::sp_reference_wrapper; - using boost::detail::sp_typeinfo_; - using boost::detail::spinlock; - using boost::detail::spinlock_pool; - using boost::detail::weak_count; - using boost::detail::yield; }} export namespace boost { namespace exception_detail { @@ -594,7 +478,6 @@ export namespace boost { namespace exception_detail { using boost::exception_detail::object_hex_dump; using boost::exception_detail::pretty_type_name; using boost::exception_detail::set_info; - using boost::exception_detail::set_info_rv; using boost::exception_detail::string_stub_dump; using boost::exception_detail::to_string_dispatcher; }} @@ -608,27 +491,11 @@ export namespace boost { namespace exception_serialization { using boost::exception_serialization::serialize; }} -export namespace boost { namespace movelib { - using boost::movelib::unique_ptr; -}} - export namespace boost { namespace n { using boost::n::p; using boost::n::r; }} -export namespace boost { namespace placeholders { - using boost::placeholders::_1; - using boost::placeholders::_2; - using boost::placeholders::_3; - using boost::placeholders::_4; - using boost::placeholders::_5; - using boost::placeholders::_6; - using boost::placeholders::_7; - using boost::placeholders::_8; - using boost::placeholders::_9; -}} - export namespace boost { namespace to_string_detail { using boost::to_string_detail::has_to_string_impl; using boost::to_string_detail::is_output_streamable_impl; diff --git a/generated/exports/align.deps b/generated/exports/align.deps index 58bc5e3ef..378c00b02 100644 --- a/generated/exports/align.deps +++ b/generated/exports/align.deps @@ -1,3 +1 @@ -mcpplibs.mwrap.boost.assert -mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core diff --git a/generated/exports/align.inc b/generated/exports/align.inc index ce7bdacdf..fc3ba7486 100644 --- a/generated/exports/align.inc +++ b/generated/exports/align.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=align boost=1.92.0 target=x86_64-w64-mingw32 entities=29 +// lib=align boost=1.92.0 target=x86_64-w64-mingw32 entities=28 export namespace boost { namespace alignment { using boost::alignment::align; diff --git a/generated/exports/asio.deps b/generated/exports/asio.deps index 5a7050dd9..281d1c1a4 100644 --- a/generated/exports/asio.deps +++ b/generated/exports/asio.deps @@ -1,4 +1,6 @@ mcpplibs.mwrap.boost.align mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.date_time +mcpplibs.mwrap.boost.smart_ptr mcpplibs.mwrap.boost.system +mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/asio.inc b/generated/exports/asio.inc index d375f6164..bcb825e82 100644 --- a/generated/exports/asio.inc +++ b/generated/exports/asio.inc @@ -1,12 +1,11 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=asio boost=1.92.0 target=x86_64-w64-mingw32 entities=1425 +// lib=asio boost=1.92.0 target=x86_64-w64-mingw32 entities=1426 export namespace boost { using boost::array; using boost::basic_regex; using boost::match_results; using boost::sub_match; - using boost::throw_exception; } export namespace boost { namespace asio { @@ -53,11 +52,15 @@ export namespace boost { namespace asio { using boost::asio::basic_datagram_socket; using boost::asio::basic_deadline_timer; #if defined(BOOST_ASIO_HAS_FILE) + // Asio's file support (basic_file and friends) is declared only where + // BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. using boost::asio::basic_file; #endif using boost::asio::basic_inline_executor; using boost::asio::basic_io_object; #if defined(BOOST_ASIO_HAS_FILE) + // Asio's file support (basic_file and friends) is declared only where + // BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. using boost::asio::basic_random_access_file; #endif using boost::asio::basic_raw_socket; @@ -70,6 +73,8 @@ export namespace boost { namespace asio { using boost::asio::basic_socket_iostream; using boost::asio::basic_socket_streambuf; #if defined(BOOST_ASIO_HAS_FILE) + // Asio's file support (basic_file and friends) is declared only where + // BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. using boost::asio::basic_stream_file; #endif using boost::asio::basic_stream_socket; @@ -176,6 +181,8 @@ export namespace boost { namespace asio { using boost::asio::executor_binder; using boost::asio::executor_work_guard; #if defined(BOOST_ASIO_HAS_FILE) + // Asio's file support (basic_file and friends) is declared only where + // BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. using boost::asio::file_base; #endif using boost::asio::get_associated_allocator; @@ -225,6 +232,7 @@ export namespace boost { namespace asio { using boost::asio::mutable_registered_buffer; using boost::asio::no_error; using boost::asio::no_error_t; + using boost::asio::noncopyable; using boost::asio::null_buffers; using boost::asio::operator!; using boost::asio::operator&; @@ -258,6 +266,8 @@ export namespace boost { namespace asio { using boost::asio::query_result_t; using boost::asio::query_t; #if defined(BOOST_ASIO_HAS_FILE) + // Asio's file support (basic_file and friends) is declared only where + // BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. using boost::asio::random_access_file; #endif using boost::asio::read; @@ -297,6 +307,8 @@ export namespace boost { namespace asio { using boost::asio::steady_timer; using boost::asio::strand; #if defined(BOOST_ASIO_HAS_FILE) + // Asio's file support (basic_file and friends) is declared only where + // BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. using boost::asio::stream_file; #endif using boost::asio::streambuf; @@ -439,6 +451,8 @@ export namespace boost { namespace asio { namespace detail { using boost::asio::detail::any_completion_handler_impl; using boost::asio::detail::any_completion_handler_impl_base; #if defined(_WIN32) + // Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); + // POSIX builds the epoll/kqueue backends instead. using boost::asio::detail::apc_function; #endif using boost::asio::detail::append_handler; @@ -512,6 +526,8 @@ export namespace boost { namespace asio { namespace detail { using boost::asio::detail::buffers_iterator_types; using boost::asio::detail::buffers_iterator_types_helper; #if defined(_WIN32) + // Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); + // POSIX builds the epoll/kqueue backends instead. using boost::asio::detail::calculate_hash_value; #endif using boost::asio::detail::call_connect_condition; @@ -616,6 +632,8 @@ export namespace boost { namespace asio { namespace detail { using boost::asio::detail::executor_memfns_derived; using boost::asio::detail::executor_op; #if defined(_WIN32) + // Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); + // POSIX builds the epoll/kqueue backends instead. using boost::asio::detail::fd_set_adapter; #endif using boost::asio::detail::fenced_block; @@ -635,6 +653,8 @@ export namespace boost { namespace asio { namespace detail { using boost::asio::detail::has_result_type; using boost::asio::detail::has_result_type_helper; #if defined(_WIN32) + // Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); + // POSIX builds the epoll/kqueue backends instead. using boost::asio::detail::hash_map; #endif using boost::asio::detail::immediate_executor_binder_argument_type; @@ -756,9 +776,9 @@ export namespace boost { namespace asio { namespace detail { using boost::asio::detail::null_event; using boost::asio::detail::null_mutex; #if defined(_WIN32) + // Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); + // POSIX builds the epoll/kqueue backends instead. using boost::asio::detail::null_reactor; -#endif -#if defined(_WIN32) using boost::asio::detail::null_signal_blocker; #endif using boost::asio::detail::on_work_finished_memfn_helper; @@ -801,6 +821,8 @@ export namespace boost { namespace asio { namespace detail { using boost::asio::detail::reactor; using boost::asio::detail::reactor_op; #if defined(_WIN32) + // Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); + // POSIX builds the epoll/kqueue backends instead. using boost::asio::detail::reactor_op_queue; #endif using boost::asio::detail::read_at_buffer_sequence; @@ -848,6 +870,8 @@ export namespace boost { namespace asio { namespace detail { using boost::asio::detail::scoped_ptr; using boost::asio::detail::select_interrupter; #if defined(_WIN32) + // Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); + // POSIX builds the epoll/kqueue backends instead. using boost::asio::detail::select_reactor; #endif using boost::asio::detail::service_base; @@ -873,6 +897,8 @@ export namespace boost { namespace asio { namespace detail { using boost::asio::detail::socket_holder; using boost::asio::detail::socket_iostream_base; #if defined(_WIN32) + // Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); + // POSIX builds the epoll/kqueue backends instead. using boost::asio::detail::socket_select_interrupter; #endif using boost::asio::detail::socket_streambuf_buffers; @@ -906,6 +932,7 @@ export namespace boost { namespace asio { namespace detail { using boost::asio::detail::thread_info_base; using boost::asio::detail::thread_pool_bits; using boost::asio::detail::throw_error; + using boost::asio::detail::throw_exception; using boost::asio::detail::timed_cancel_op; using boost::asio::detail::timed_cancel_op_handler; using boost::asio::detail::timed_cancel_timer_handler; @@ -925,105 +952,41 @@ export namespace boost { namespace asio { namespace detail { using boost::asio::detail::wait_handler; using boost::asio::detail::wait_op; #if defined(_WIN32) + // Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); + // POSIX builds the epoll/kqueue backends instead. using boost::asio::detail::win_event; -#endif -#if defined(_WIN32) using boost::asio::detail::win_fd_set_adapter; -#endif -#if defined(_WIN32) using boost::asio::detail::win_global; -#endif -#if defined(_WIN32) using boost::asio::detail::win_global_impl; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_file_service; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_handle_read_op; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_handle_service; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_handle_write_op; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_io_context; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_null_buffers_op; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_operation; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_overlapped_op; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_overlapped_ptr; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_serial_port_service; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_socket_accept_op; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_socket_connect_op; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_socket_connect_op_base; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_socket_move_accept_op; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_socket_recv_op; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_socket_recvfrom_op; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_socket_recvmsg_op; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_socket_send_op; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_socket_service; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_socket_service_base; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_thread_info; -#endif -#if defined(_WIN32) using boost::asio::detail::win_iocp_wait_op; -#endif -#if defined(_WIN32) using boost::asio::detail::win_mutex; -#endif -#if defined(_WIN32) using boost::asio::detail::win_object_handle_service; -#endif -#if defined(_WIN32) using boost::asio::detail::win_static_mutex; -#endif -#if defined(_WIN32) using boost::asio::detail::win_thread; -#endif -#if defined(_WIN32) using boost::asio::detail::win_thread_base; -#endif -#if defined(_WIN32) using boost::asio::detail::win_thread_function; -#endif -#if defined(_WIN32) using boost::asio::detail::winsock_init; -#endif -#if defined(_WIN32) using boost::asio::detail::winsock_init_base; #endif using boost::asio::detail::work_dispatcher; @@ -1080,21 +1043,13 @@ export namespace boost { namespace asio { namespace detail { namespace socket_op using boost::asio::detail::socket_ops::clear_last_error; using boost::asio::detail::socket_ops::close; #if defined(_WIN32) + // Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); + // POSIX builds the epoll/kqueue backends instead. using boost::asio::detail::socket_ops::complete_iocp_accept; -#endif -#if defined(_WIN32) using boost::asio::detail::socket_ops::complete_iocp_connect; -#endif -#if defined(_WIN32) using boost::asio::detail::socket_ops::complete_iocp_recv; -#endif -#if defined(_WIN32) using boost::asio::detail::socket_ops::complete_iocp_recvfrom; -#endif -#if defined(_WIN32) using boost::asio::detail::socket_ops::complete_iocp_recvmsg; -#endif -#if defined(_WIN32) using boost::asio::detail::socket_ops::complete_iocp_send; #endif using boost::asio::detail::socket_ops::connect; @@ -1116,6 +1071,8 @@ export namespace boost { namespace asio { namespace detail { namespace socket_op using boost::asio::detail::socket_ops::ioctl; using boost::asio::detail::socket_ops::listen; #if defined(_WIN32) + // Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); + // POSIX builds the epoll/kqueue backends instead. using boost::asio::detail::socket_ops::msghdr; #endif using boost::asio::detail::socket_ops::network_to_host_long; @@ -1333,6 +1290,7 @@ export namespace boost { namespace asio { namespace experimental { using boost::asio::experimental::basic_concurrent_channel; using boost::asio::experimental::channel; using boost::asio::experimental::channel_traits; + using boost::asio::experimental::co_composed; using boost::asio::experimental::co_spawn; using boost::asio::experimental::concurrent_channel; using boost::asio::experimental::coro; @@ -1614,30 +1572,16 @@ export namespace boost { namespace asio { namespace traits { export namespace boost { namespace asio { namespace windows { #if defined(_WIN32) + // Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); + // POSIX builds the epoll/kqueue backends instead. using boost::asio::windows::basic_object_handle; -#endif -#if defined(_WIN32) using boost::asio::windows::basic_overlapped_handle; -#endif -#if defined(_WIN32) using boost::asio::windows::basic_random_access_handle; -#endif -#if defined(_WIN32) using boost::asio::windows::basic_stream_handle; -#endif -#if defined(_WIN32) using boost::asio::windows::object_handle; -#endif -#if defined(_WIN32) using boost::asio::windows::overlapped_handle; -#endif -#if defined(_WIN32) using boost::asio::windows::overlapped_ptr; -#endif -#if defined(_WIN32) using boost::asio::windows::random_access_handle; -#endif -#if defined(_WIN32) using boost::asio::windows::stream_handle; #endif }}} @@ -1680,7 +1624,3 @@ export namespace boost { namespace context { namespace detail { using boost::context::detail::tuple_head; using boost::context::detail::tuple_tail; }}} - -export namespace boost { namespace posix_time { - using boost::posix_time::ptime; -}} diff --git a/generated/exports/assign.deps b/generated/exports/assign.deps index 26620a28f..d165749cf 100644 --- a/generated/exports/assign.deps +++ b/generated/exports/assign.deps @@ -1,7 +1,5 @@ mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.config -mcpplibs.mwrap.boost.core -mcpplibs.mwrap.boost.iterator mcpplibs.mwrap.boost.move mcpplibs.mwrap.boost.ptr_container mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/atomic.deps b/generated/exports/atomic.deps index 122674e80..d3dd41f2a 100644 --- a/generated/exports/atomic.deps +++ b/generated/exports/atomic.deps @@ -1,3 +1,2 @@ mcpplibs.mwrap.boost.config -mcpplibs.mwrap.boost.type_traits mcpplibs.mwrap.boost.winapi diff --git a/generated/exports/atomic.inc b/generated/exports/atomic.inc index 56d0ccab0..8cc8c4f2b 100644 --- a/generated/exports/atomic.inc +++ b/generated/exports/atomic.inc @@ -62,20 +62,8 @@ export namespace boost { using boost::ipc_atomic; using boost::ipc_atomic_flag; using boost::ipc_atomic_ref; -#if defined(BOOST_HAS_INT128) - // M11 platform guard: atomic/detail/type_traits/is_integral.hpp (and - // is_signed) pull the boost:: trait only under BOOST_HAS_INT128 (libstdc++ - // __int128 workaround); the MSVC ABI takes the std:: trait instead. - using boost::is_integral; - using boost::is_signed; -#endif using boost::make_atomic_ref; using boost::make_ipc_atomic_ref; -#if defined(BOOST_HAS_INT128) - // M11 platform guard: atomic/detail/type_traits/make_signed.hpp — as above. - using boost::make_signed; - using boost::make_unsigned; -#endif using boost::memory_order; using boost::memory_order_acq_rel; using boost::memory_order_acquire; @@ -171,23 +159,23 @@ export namespace boost { namespace atomics { namespace detail { using boost::atomics::detail::classify_pointer; using boost::atomics::detail::clear_tail_padding_bits; #if defined(__GNUC__) - // M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw flavor). + // M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw + // flavor). using boost::atomics::detail::convert_memory_order_to_gcc; #endif using boost::atomics::detail::core_arch_operations; #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) - // M11 platform guard: gcc_x86 backend of boost/atomic (platform.hpp); x86 only. + // M11 platform guard: gcc_x86 backend of boost/atomic (platform.hpp); x86 + // only. using boost::atomics::detail::core_arch_operations_gcc_x86; -#endif -#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) - // M11 platform guard: gcc_x86 backend of boost/atomic (platform.hpp); x86 only. using boost::atomics::detail::core_arch_operations_gcc_x86_base; #endif using boost::atomics::detail::core_operations; using boost::atomics::detail::core_operations_emulated; using boost::atomics::detail::core_operations_emulated_base; #if defined(__GNUC__) - // M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw flavor). + // M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw + // flavor). using boost::atomics::detail::core_operations_gcc_atomic; #endif using boost::atomics::detail::deduce_failure_order; @@ -200,12 +188,14 @@ export namespace boost { namespace atomics { namespace detail { using boost::atomics::detail::extra_operations_generic; using boost::atomics::detail::fence_arch_operations; #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) - // M11 platform guard: gcc_x86 backend of boost/atomic (platform.hpp); x86 only. + // M11 platform guard: gcc_x86 backend of boost/atomic (platform.hpp); x86 + // only. using boost::atomics::detail::fence_arch_operations_gcc_x86; #endif using boost::atomics::detail::fence_operations; #if defined(__GNUC__) - // M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw flavor). + // M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw + // flavor). using boost::atomics::detail::fence_operations_gcc_atomic; #endif using boost::atomics::detail::fp_operations; @@ -215,6 +205,10 @@ export namespace boost { namespace atomics { namespace detail { using boost::atomics::detail::integral_truncate; using boost::atomics::detail::is_atomic_ref_lock_free; using boost::atomics::detail::is_iec559; + using boost::atomics::detail::is_integral; + using boost::atomics::detail::is_signed; + using boost::atomics::detail::make_signed; + using boost::atomics::detail::make_unsigned; using boost::atomics::detail::non_atomic_load; using boost::atomics::detail::sign_extend; using boost::atomics::detail::sign_extend_impl; diff --git a/generated/exports/beast.deps b/generated/exports/beast.deps index 1682054e7..5333b3bae 100644 --- a/generated/exports/beast.deps +++ b/generated/exports/beast.deps @@ -1,13 +1,17 @@ mcpplibs.mwrap.boost.asio mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.config +mcpplibs.mwrap.boost.container_hash mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.endian +mcpplibs.mwrap.boost.intrusive mcpplibs.mwrap.boost.logic +mcpplibs.mwrap.boost.mp11 mcpplibs.mwrap.boost.optional mcpplibs.mwrap.boost.smart_ptr mcpplibs.mwrap.boost.static_string mcpplibs.mwrap.boost.system mcpplibs.mwrap.boost.throw_exception mcpplibs.mwrap.boost.type_index +mcpplibs.mwrap.boost.utility mcpplibs.mwrap.boost.winapi diff --git a/generated/exports/beast.inc b/generated/exports/beast.inc index 30e5e438f..6020b65c1 100644 --- a/generated/exports/beast.inc +++ b/generated/exports/beast.inc @@ -1,26 +1,10 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=beast boost=1.92.0 target=x86_64-w64-mingw32 entities=505 - -export namespace boost { - using boost::hash; - using boost::optional; - using boost::shared_ptr; -} - -export namespace boost { namespace asio { - using boost::asio::associator; - using boost::asio::strand; -}} +// lib=beast boost=1.92.0 target=x86_64-w64-mingw32 entities=499 export namespace boost { namespace asio { namespace ssl { using boost::asio::ssl::stream; }}} -export namespace boost { namespace asio { namespace traits { - using boost::asio::traits::execute_member; - using boost::asio::traits::query_static_constexpr_member; -}}} - export namespace boost { namespace beast { using boost::beast::allocate_stable; using boost::beast::asio_handler_is_continuation; @@ -63,12 +47,15 @@ export namespace boost { namespace beast { using boost::beast::file_mode; using boost::beast::file_stdio; #if defined(_WIN32) + // Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream + // dstream) are Windows-only. using boost::beast::file_win32; #endif using boost::beast::flat_buffer; using boost::beast::flat_static_buffer; using boost::beast::flat_static_buffer_base; using boost::beast::flat_stream; + using boost::beast::generic_category; using boost::beast::get_lowest_layer; using boost::beast::has_get_executor; using boost::beast::iequal; @@ -104,6 +91,7 @@ export namespace boost { namespace beast { using boost::beast::static_string; using boost::beast::string_view; using boost::beast::swap; + using boost::beast::system_category; using boost::beast::system_error; using boost::beast::tcp_stream; using boost::beast::teardown; @@ -186,6 +174,8 @@ export namespace boost { namespace beast { namespace detail { using boost::beast::detail::run_detect_ssl_op; using boost::beast::detail::service_base; #if defined(_WIN32) + // Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream + // dstream) are Windows-only. using boost::beast::detail::set_file_pointer_ex; #endif using boost::beast::detail::sha1_context; @@ -205,6 +195,8 @@ export namespace boost { namespace beast { namespace detail { using boost::beast::detail::varint_write; using boost::beast::detail::void_t; #if defined(_WIN32) + // Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream + // dstream) are Windows-only. using boost::beast::detail::win32_unicode_path; #endif using boost::beast::detail::with_immediate_executor_type; @@ -328,6 +320,8 @@ export namespace boost { namespace beast { namespace http { namespace detail { using boost::beast::http::detail::get_field_table; using boost::beast::http::detail::has_value_type; #if defined(_WIN32) + // Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream + // dstream) are Windows-only. using boost::beast::http::detail::highPart; #endif using boost::beast::http::detail::http_error_category; @@ -347,12 +341,10 @@ export namespace boost { namespace beast { namespace http { namespace detail { using boost::beast::http::detail::is_token_char; using boost::beast::http::detail::keep_alive_impl; #if defined(_WIN32) + // Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream + // dstream) are Windows-only. using boost::beast::http::detail::lowPart; -#endif -#if defined(_WIN32) using boost::beast::http::detail::make_win32_error; -#endif -#if defined(_WIN32) using boost::beast::http::detail::null_lambda; #endif using boost::beast::http::detail::opt_token_list_policy; @@ -368,6 +360,8 @@ export namespace boost { namespace beast { namespace http { namespace detail { using boost::beast::http::detail::run_write_op; using boost::beast::http::detail::run_write_some_op; #if defined(_WIN32) + // Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream + // dstream) are Windows-only. using boost::beast::http::detail::run_write_some_win32_op; #endif using boost::beast::http::detail::serializer_is_done; @@ -387,6 +381,8 @@ export namespace boost { namespace beast { namespace http { namespace detail { using boost::beast::http::detail::write_some_lambda; using boost::beast::http::detail::write_some_op; #if defined(_WIN32) + // Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream + // dstream) are Windows-only. using boost::beast::http::detail::write_some_win32_op; #endif }}}} @@ -426,6 +422,8 @@ export namespace boost { namespace beast { namespace unit_test { using boost::beast::unit_test::abort_t::no_abort_on_fail; using boost::beast::unit_test::amount; #if defined(_WIN32) + // Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream + // dstream) are Windows-only. using boost::beast::unit_test::basic_dstream; #endif using boost::beast::unit_test::case_results; @@ -453,6 +451,8 @@ export namespace boost { namespace beast { namespace unit_test { export namespace boost { namespace beast { namespace unit_test { namespace detail { using boost::beast::unit_test::detail::const_container; #if defined(_WIN32) + // Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream + // dstream) are Windows-only. using boost::beast::unit_test::detail::dstream_buf; #endif using boost::beast::unit_test::detail::global_suites; @@ -583,7 +583,3 @@ export namespace boost { namespace beast { namespace zlib { namespace detail { using boost::beast::zlib::detail::ranges; using boost::beast::zlib::detail::window; }}}} - -export namespace boost { namespace static_strings { - using boost::static_strings::basic_static_string; -}} diff --git a/generated/exports/bimap.deps b/generated/exports/bimap.deps index b7519d010..32d91aa59 100644 --- a/generated/exports/bimap.deps +++ b/generated/exports/bimap.deps @@ -3,7 +3,6 @@ mcpplibs.mwrap.boost.concept_check mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.functional -mcpplibs.mwrap.boost.iterator mcpplibs.mwrap.boost.lambda mcpplibs.mwrap.boost.multi_index mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/bimap.inc b/generated/exports/bimap.inc index 6036e7b8c..6bdeab843 100644 --- a/generated/exports/bimap.inc +++ b/generated/exports/bimap.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=bimap boost=1.92.0 target=x86_64-w64-mingw32 entities=193 +// lib=bimap boost=1.92.0 target=x86_64-w64-mingw32 entities=190 export namespace boost { using boost::bimap; @@ -246,10 +246,4 @@ export namespace boost { namespace mpl { using boost::mpl::contains_impl; using boost::mpl::find; using boost::mpl::inherit_linearly; - using boost::mpl::lambda; - using boost::mpl::vector; }} - -export namespace boost { namespace mpl { namespace aux { - using boost::mpl::aux::template_arity; -}}} diff --git a/generated/exports/bloom.deps b/generated/exports/bloom.deps index 3e5225112..b6d84cfa6 100644 --- a/generated/exports/bloom.deps +++ b/generated/exports/bloom.deps @@ -1,4 +1,3 @@ mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.container_hash mcpplibs.mwrap.boost.core -mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/bloom.inc b/generated/exports/bloom.inc index bfb942c62..891d82cea 100644 --- a/generated/exports/bloom.inc +++ b/generated/exports/bloom.inc @@ -1,9 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=bloom boost=1.92.0 target=x86_64-w64-mingw32 entities=46 - -export namespace boost { - using boost::span; -} +// lib=bloom boost=1.92.0 target=x86_64-w64-mingw32 entities=45 export namespace boost { namespace bloom { using boost::bloom::block; diff --git a/generated/exports/charconv.inc b/generated/exports/charconv.inc index 7ae95be6a..4af9ecba0 100644 --- a/generated/exports/charconv.inc +++ b/generated/exports/charconv.inc @@ -31,8 +31,8 @@ export namespace boost { namespace charconv { namespace detail { using boost::charconv::detail::ieee754_binary32; using boost::charconv::detail::ieee754_binary64; #if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 - // M11 platform guard: bit_layouts.hpp defines ieee754_binary80 only for - // 80-bit long double (x86-64 gcc/mingw); MSVC long double is 53-bit. + // M11 platform guard: bit_layouts.hpp defines ieee754_binary80 only for 80-bit + // long double (x86-64 gcc/mingw); MSVC long double is 53-bit. using boost::charconv::detail::ieee754_binary80; #endif using boost::charconv::detail::is_int128; diff --git a/generated/exports/chrono.inc b/generated/exports/chrono.inc index ed6b5fa65..41823e557 100644 --- a/generated/exports/chrono.inc +++ b/generated/exports/chrono.inc @@ -2,7 +2,6 @@ // lib=chrono boost=1.92.0 target=x86_64-w64-mingw32 entities=71 export namespace boost { - using boost::common_type; using boost::unique_ptr; } @@ -85,4 +84,5 @@ export namespace boost { namespace chrono { namespace detail { export namespace boost { namespace ratio_detail { using boost::ratio_detail::is_evenly_divisible_by; + using boost::ratio_detail::is_evenly_divisible_by_; }} diff --git a/generated/exports/circular_buffer.deps b/generated/exports/circular_buffer.deps index b4baaa952..563c05350 100644 --- a/generated/exports/circular_buffer.deps +++ b/generated/exports/circular_buffer.deps @@ -1,4 +1,6 @@ mcpplibs.mwrap.boost.assert +mcpplibs.mwrap.boost.concept_check mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core +mcpplibs.mwrap.boost.move mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/cobalt.deps b/generated/exports/cobalt.deps index 1f7c896a7..26f80de6a 100644 --- a/generated/exports/cobalt.deps +++ b/generated/exports/cobalt.deps @@ -8,6 +8,6 @@ mcpplibs.mwrap.boost.endian mcpplibs.mwrap.boost.intrusive mcpplibs.mwrap.boost.mp11 mcpplibs.mwrap.boost.smart_ptr -mcpplibs.mwrap.boost.static_string mcpplibs.mwrap.boost.system +mcpplibs.mwrap.boost.utility mcpplibs.mwrap.boost.variant2 diff --git a/generated/exports/cobalt.inc b/generated/exports/cobalt.inc index cac64e62f..7e2d68f26 100644 --- a/generated/exports/cobalt.inc +++ b/generated/exports/cobalt.inc @@ -1,34 +1,14 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=cobalt boost=1.92.0 target=x86_64-w64-mingw32 entities=220 - -export namespace boost { namespace asio { - using boost::asio::associator; - using boost::asio::async_result; - using boost::asio::basic_datagram_socket; -#if defined(BOOST_ASIO_HAS_FILE) - using boost::asio::basic_file; -#endif - using boost::asio::basic_seq_packet_socket; - using boost::asio::basic_socket; - using boost::asio::basic_socket_acceptor; -}} - -export namespace boost { namespace asio { namespace detail { -#if defined(_WIN32) - using boost::asio::detail::win_iocp_socket_service; -#endif -}}} - -export namespace boost { namespace asio { namespace ip { - using boost::asio::ip::basic_resolver; -}}} +// lib=cobalt boost=1.92.0 target=x86_64-w64-mingw32 entities=211 export namespace boost { namespace cobalt { using boost::cobalt::allocate_coroutine; using boost::cobalt::as_result; using boost::cobalt::as_result_t; + using boost::cobalt::as_result_tag; using boost::cobalt::as_tuple; using boost::cobalt::as_tuple_t; + using boost::cobalt::as_tuple_tag; using boost::cobalt::awaitable; using boost::cobalt::awaitable_type; using boost::cobalt::channel; @@ -253,19 +233,11 @@ export namespace boost { namespace cobalt { namespace this_thread { using boost::cobalt::this_thread::set_executor; }}} -export namespace boost { namespace intrusive { - using boost::intrusive::constant_time_size; -}} +export namespace boost { namespace concepts { namespace detail { + using boost::concepts::detail::has_constraints_; +}}} export namespace boost { namespace process { using boost::process::is_readable_pipe; using boost::process::is_writable_pipe; }} - -export namespace boost { namespace static_strings { - using boost::static_strings::basic_static_string; -}} - -export namespace boost { namespace system { - using boost::system::result; -}} diff --git a/generated/exports/config.inc b/generated/exports/config.inc index d230ea625..939b605d3 100644 --- a/generated/exports/config.inc +++ b/generated/exports/config.inc @@ -3,12 +3,14 @@ export namespace boost { #if defined(BOOST_HAS_INT128) - // M3 hand-guard (M9: moved to config.inc): suffix.hpp defines int128_type only where BOOST_HAS_INT128. + // M3 hand-guard (M9: moved to config.inc): suffix.hpp defines int128_type only + // where BOOST_HAS_INT128. using boost::int128_type; #endif using boost::long_long_type; #if defined(BOOST_HAS_INT128) - // M3 hand-guard (M9: moved to config.inc): suffix.hpp defines uint128_type only where BOOST_HAS_INT128. + // M3 hand-guard (M9: moved to config.inc): suffix.hpp defines uint128_type + // only where BOOST_HAS_INT128. using boost::uint128_type; #endif using boost::ulong_long_type; diff --git a/generated/exports/container.inc b/generated/exports/container.inc index 2826d4ccd..0eeda546f 100644 --- a/generated/exports/container.inc +++ b/generated/exports/container.inc @@ -1,13 +1,11 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=container boost=1.92.0 target=x86_64-w64-mingw32 entities=970 - -export namespace boost { - using boost::has_trivial_destructor_after_move; -} +// lib=container boost=1.92.0 target=x86_64-w64-mingw32 entities=976 export namespace boost { namespace container { using boost::container::DeepSwapAllocNMaxStorage; using boost::container::adaptive_pool; + using boost::container::algo_equal; + using boost::container::algo_lexicographical_compare; using boost::container::allocate_new; using boost::container::allocation_type; using boost::container::allocation_type_v; @@ -544,6 +542,7 @@ export namespace boost { namespace container { namespace dtl { using boost::container::dtl::add_const; using boost::container::dtl::add_const_reference; using boost::container::dtl::add_reference; + using boost::container::dtl::addressof; using boost::container::dtl::aligned_allocate; using boost::container::dtl::aligned_deallocate; using boost::container::dtl::aligned_storage; @@ -553,12 +552,14 @@ export namespace boost { namespace container { namespace dtl { using boost::container::dtl::allocator_node_destroyer_and_chain_builder; using boost::container::dtl::allocator_traits_dummy; using boost::container::dtl::allocator_version_traits; + using boost::container::dtl::and_; using boost::container::dtl::are_contiguous_and_same; using boost::container::dtl::are_elements_contiguous; using boost::container::dtl::assign_alloc; using boost::container::dtl::basic_multiallocation_chain; using boost::container::dtl::basic_string_base; using boost::container::dtl::block_container_traits; + using boost::container::dtl::bool_; using boost::container::dtl::boost_intrusive_default_type_bucket_traits; using boost::container::dtl::boost_intrusive_default_type_bucket_type; using boost::container::dtl::boost_intrusive_default_type_const_reference; @@ -606,20 +607,32 @@ export namespace boost { namespace container { namespace dtl { using boost::container::dtl::construct_type; using boost::container::dtl::ctad_declval; using boost::container::dtl::default_mutex; + using boost::container::dtl::disable_if; + using boost::container::dtl::disable_if_and; + using boost::container::dtl::disable_if_c; + using boost::container::dtl::disable_if_convertible; using boost::container::dtl::disable_if_memtransfer_copy_assignable; using boost::container::dtl::disable_if_memtransfer_copy_constructible; using boost::container::dtl::disable_if_memzero_initializable; + using boost::container::dtl::disable_if_or; using boost::container::dtl::disable_if_single_value_proxy; using boost::container::dtl::disable_if_trivially_destructible; using boost::container::dtl::dispatch_uses_allocator; using boost::container::dtl::dispatch_uses_allocator_index; + using boost::container::dtl::enable_if; + using boost::container::dtl::enable_if_and; + using boost::container::dtl::enable_if_c; + using boost::container::dtl::enable_if_convertible; using boost::container::dtl::enable_if_memtransfer_copy_assignable; using boost::container::dtl::enable_if_memtransfer_copy_constructible; using boost::container::dtl::enable_if_memzero_initializable; + using boost::container::dtl::enable_if_or; using boost::container::dtl::enable_if_single_value_proxy; using boost::container::dtl::enable_if_transparent; using boost::container::dtl::enable_if_trivially_destructible; using boost::container::dtl::fake_segment_manager; + using boost::container::dtl::false_; + using boost::container::dtl::false_type; using boost::container::dtl::flat_tree; using boost::container::dtl::flat_tree_adopt_sequence_equal; using boost::container::dtl::flat_tree_adopt_sequence_unique; @@ -652,6 +665,9 @@ export namespace boost { namespace container { namespace dtl { using boost::container::dtl::has_iterator_category; using boost::container::dtl::has_single_value; using boost::container::dtl::hdr_offset_holder_t; + using boost::container::dtl::identity; + using boost::container::dtl::if_; + using boost::container::dtl::if_c; using boost::container::dtl::iiterator_node_value_type; using boost::container::dtl::iiterator_types; using boost::container::dtl::index_tuple; @@ -664,6 +680,7 @@ export namespace boost { namespace container { namespace dtl { using boost::container::dtl::insert_nonmovable_emplace_proxy; using boost::container::dtl::insert_range_proxy; using boost::container::dtl::insert_value_initialized_n_proxy; + using boost::container::dtl::integral_constant; using boost::container::dtl::intrusive_list_type; using boost::container::dtl::intrusive_slist_type; using boost::container::dtl::intrusive_tree_dispatch; @@ -676,6 +693,7 @@ export namespace boost { namespace container { namespace dtl { using boost::container::dtl::is_constructible_with_allocator_suffix; using boost::container::dtl::is_container; using boost::container::dtl::is_contiguous_container; + using boost::container::dtl::is_convertible; using boost::container::dtl::is_different; using boost::container::dtl::is_empty; using boost::container::dtl::is_enum; @@ -744,9 +762,11 @@ export namespace boost { namespace container { namespace dtl { using boost::container::dtl::nat2; using boost::container::dtl::nat3; using boost::container::dtl::natN; + using boost::container::dtl::no_type; using boost::container::dtl::node_alloc_holder; using boost::container::dtl::node_slist; using boost::container::dtl::node_slist_helper; + using boost::container::dtl::not_; using boost::container::dtl::null_scoped_array_deallocator; using boost::container::dtl::null_scoped_deallocator; using boost::container::dtl::null_scoped_destructor; @@ -763,6 +783,7 @@ export namespace boost { namespace container { namespace dtl { using boost::container::dtl::operator_new_allocate; using boost::container::dtl::operator_new_raw_allocate; using boost::container::dtl::operator_new_raw_overaligned; + using boost::container::dtl::or_; using boost::container::dtl::outermost_allocator_imp; using boost::container::dtl::outermost_allocator_type_impl; using boost::container::dtl::packed_3n_bits_ref; @@ -778,6 +799,7 @@ export namespace boost { namespace container { namespace dtl { using boost::container::dtl::private_adaptive_node_pool_impl_rt_data; using boost::container::dtl::private_node_pool_impl; using boost::container::dtl::push_back_functor; + using boost::container::dtl::remove_const; using boost::container::dtl::remove_cvref; using boost::container::dtl::remove_reference; using boost::container::dtl::require_allocator_t; @@ -806,6 +828,9 @@ export namespace boost { namespace container { namespace dtl { using boost::container::dtl::tree; using boost::container::dtl::tree_internal_data_type; using boost::container::dtl::tree_key_of_value; + using boost::container::dtl::tree_value_compare; + using boost::container::dtl::true_; + using boost::container::dtl::true_type; using boost::container::dtl::tuple; using boost::container::dtl::tuple_element; using boost::container::dtl::type_identity; @@ -814,6 +839,7 @@ export namespace boost { namespace container { namespace dtl { using boost::container::dtl::unchecked_countr_one; using boost::container::dtl::unchecked_countr_zero; using boost::container::dtl::unused_storage; + using boost::container::dtl::unvoid_ref; using boost::container::dtl::upper_power_of_2; using boost::container::dtl::upper_power_of_2_ct; using boost::container::dtl::upper_power_of_2_loop_ct; @@ -827,10 +853,11 @@ export namespace boost { namespace container { namespace dtl { using boost::container::dtl::version_type; using boost::container::dtl::void_t; #if defined(_WIN32) - // M11 platform guard: win_critical_section is the non-pthread branch - // of container/detail/thread_mutex.hpp; POSIX uses pthread_mutex. + // M11 platform guard: win_critical_section is the non-pthread branch of + // container/detail/thread_mutex.hpp; POSIX uses pthread_mutex. using boost::container::dtl::win_critical_section; #endif + using boost::container::dtl::yes_type; }}} export namespace boost { namespace container { namespace dtl { namespace adl_range { @@ -874,6 +901,7 @@ export namespace boost { namespace container { namespace hub_detail { using boost::container::hub_detail::pocma_t; using boost::container::hub_detail::pocs_t; using boost::container::hub_detail::pointer_rebind_t; + using boost::container::hub_detail::pointer_traits; using boost::container::hub_detail::range_iterator_t; using boost::container::hub_detail::range_reference_t; using boost::container::hub_detail::range_value_t; @@ -992,51 +1020,20 @@ export namespace boost { namespace container { namespace stable_vector_detail { using boost::container::stable_vector_detail::node_base; }}} -#if defined(_WIN32) export namespace boost { namespace container_winapi { - // M11 platform guard: container_winapi DWORD_/BOOL_/SleepEx are - // declared only in the _WIN32 branch of container/detail/mutex.hpp. +#if defined(_WIN32) + // M11 platform guard: container_winapi DWORD_/BOOL_/SleepEx are declared only + // in the _WIN32 branch of container/detail/mutex.hpp. using ::SleepEx; using boost::container_winapi::BOOL_; using boost::container_winapi::DWORD_; -}} #endif +}} export namespace boost { namespace interprocess { using boost::interprocess::offset_ptr; }} -export namespace boost { namespace intrusive { - using boost::intrusive::algo_equal; - using boost::intrusive::algo_lexicographical_compare; - using boost::intrusive::cache_last; - using boost::intrusive::circular_list_algorithms; - using boost::intrusive::linear; - using boost::intrusive::linear_slist_algorithms; - using boost::intrusive::link_mode; - using boost::intrusive::pointer_traits; - using boost::intrusive::tree_value_compare; -}} - -export namespace boost { namespace move_detail { - using boost::move_detail::and_; - using boost::move_detail::disable_if_and; - using boost::move_detail::disable_if_or; - using boost::move_detail::enable_if_and; - using boost::move_detail::enable_if_or; - using boost::move_detail::integral_constant; - using boost::move_detail::is_class; - using boost::move_detail::is_class_or_union; - using boost::move_detail::is_trivially_copy_assignable; - using boost::move_detail::is_trivially_copy_constructible; - using boost::move_detail::is_trivially_destructible; - using boost::move_detail::is_trivially_move_assignable; - using boost::move_detail::is_trivially_move_constructible; - using boost::move_detail::is_union; - using boost::move_detail::not_; - using boost::move_detail::or_; -}} - export namespace boost { namespace tuples { using boost::tuples::null_type; using boost::tuples::tuple; diff --git a/generated/exports/container_hash.deps b/generated/exports/container_hash.deps index 7bc604bf3..e7b142002 100644 --- a/generated/exports/container_hash.deps +++ b/generated/exports/container_hash.deps @@ -1,2 +1 @@ -mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.mp11 diff --git a/generated/exports/contract.inc b/generated/exports/contract.inc index 1a3050eea..6295bf41d 100644 --- a/generated/exports/contract.inc +++ b/generated/exports/contract.inc @@ -1,9 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=contract boost=1.92.0 target=x86_64-w64-mingw32 entities=176 - -export namespace boost { - using boost::function; -} +// lib=contract boost=1.92.0 target=x86_64-w64-mingw32 entities=173 export namespace boost { namespace contract { using boost::contract::access; @@ -196,7 +192,6 @@ export namespace boost { namespace function_types { export namespace boost { namespace mpl { using boost::mpl::copy_if; - using boost::mpl::lambda; using boost::mpl::reverse_copy_if; }} @@ -204,5 +199,4 @@ export namespace boost { namespace mpl { namespace aux { using boost::mpl::aux::copy_if_impl; using boost::mpl::aux::copy_if_op; using boost::mpl::aux::reverse_copy_if_impl; - using boost::mpl::aux::template_arity; }}} diff --git a/generated/exports/core.inc b/generated/exports/core.inc index 887ab8123..c5fb9e251 100644 --- a/generated/exports/core.inc +++ b/generated/exports/core.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=core boost=1.92.0 target=x86_64-w64-mingw32 entities=267 +// lib=core boost=1.92.0 target=x86_64-w64-mingw32 entities=270 export namespace boost { using boost::addressof; @@ -122,6 +122,7 @@ export namespace boost { namespace core { using boost::core::functor; using boost::core::has_single_bit; using boost::core::invoke_swap; + using boost::core::is_same; using boost::core::launder; using boost::core::load_construct_data_adl; using boost::core::lwt_init; @@ -136,6 +137,8 @@ export namespace boost { namespace core { using boost::core::scoped_demangled_name; using boost::core::snprintf; using boost::core::sp_thread_pause; + using boost::core::sp_thread_sleep; + using boost::core::sp_thread_yield; using boost::core::split_free; using boost::core::split_member; using boost::core::swprintf; @@ -161,7 +164,8 @@ export namespace boost { namespace core { namespace detail { using boost::core::detail::byteswap_impl; using boost::core::detail::class_template_name; #if defined(__GNUC__) - // M3 hand-guard: boost/core/cmath.hpp defines copysign_impl only on gcc-like compilers. + // M3 hand-guard: boost/core/cmath.hpp defines copysign_impl only on gcc-like + // compilers. using boost::core::detail::copysign_impl; #endif using boost::core::detail::countl_impl; @@ -178,8 +182,9 @@ export namespace boost { namespace core { namespace detail { using boost::core::detail::sequence_template_name; using boost::core::detail::set_template_name; #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) - // M6 platform guard: sp_thread_sleep/yield live in boost::core::detail only on Windows; - // on POSIX (nanosleep/sched_yield branch of the header) they are declared in boost::core. + // M6 platform guard: sp_thread_sleep/yield live in boost::core::detail only on + // Windows; on POSIX (nanosleep/sched_yield branch of the header) they are + // declared in boost::core. using boost::core::detail::sp_thread_sleep; using boost::core::detail::sp_thread_yield; #else diff --git a/generated/exports/date_time.deps b/generated/exports/date_time.deps index d73c75e16..039eca064 100644 --- a/generated/exports/date_time.deps +++ b/generated/exports/date_time.deps @@ -4,6 +4,7 @@ mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.io mcpplibs.mwrap.boost.iterator mcpplibs.mwrap.boost.numeric +mcpplibs.mwrap.boost.smart_ptr mcpplibs.mwrap.boost.throw_exception mcpplibs.mwrap.boost.tokenizer mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/date_time.inc b/generated/exports/date_time.inc index 0163b436d..ecb177570 100644 --- a/generated/exports/date_time.inc +++ b/generated/exports/date_time.inc @@ -1,9 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=date_time boost=1.92.0 target=x86_64-w64-mingw32 entities=392 - -export namespace boost { - using boost::shared_ptr; -} +// lib=date_time boost=1.92.0 target=x86_64-w64-mingw32 entities=391 export namespace boost { namespace CV { using boost::CV::constrained_value; @@ -154,6 +150,8 @@ export namespace boost { namespace date_time { using boost::date_time::time_facet; using boost::date_time::time_formats; #if defined(_WIN32) + // The FILETIME conversions of date_time/filetime_functions.hpp exist only on + // Windows. using boost::date_time::time_from_ftime; #endif using boost::date_time::time_input_facet; @@ -358,6 +356,8 @@ export namespace boost { namespace local_time { export namespace boost { namespace posix_time { using boost::posix_time::duration_from_string; #if defined(_WIN32) + // The FILETIME conversions of date_time/filetime_functions.hpp exist only on + // Windows. using boost::posix_time::from_ftime; #endif using boost::posix_time::from_iso_extended_string; diff --git a/generated/exports/decimal.inc b/generated/exports/decimal.inc index 82aa61238..bd3b42aa7 100644 --- a/generated/exports/decimal.inc +++ b/generated/exports/decimal.inc @@ -580,6 +580,7 @@ export namespace boost { namespace decimal { namespace detail { using boost::decimal::detail::trailing_significand_field_width_v; using boost::decimal::detail::u256; #if defined(__GNUC__) + // The builtin carry helpers are declared only in the __GNUC__ branch. using boost::decimal::detail::u256_add; #endif using boost::decimal::detail::uchar_values; @@ -690,6 +691,7 @@ export namespace boost { namespace decimal { namespace detail { namespace fast_f export namespace boost { namespace decimal { namespace detail { namespace impl { using boost::decimal::detail::impl::BOOST_DECIMAL_DETAIL_INT128_pow10; #if defined(__GNUC__) + // The builtin carry helpers are declared only in the __GNUC__ branch. using boost::decimal::detail::impl::add_carry_u64; #endif using boost::decimal::detail::impl::basic_add_impl; @@ -740,6 +742,8 @@ export namespace boost { namespace decimal { namespace detail { namespace impl { using boost::decimal::detail::impl::memmove_impl; using boost::decimal::detail::impl::memset_impl; #if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) + // The 128-bit division intrinsics are declared only where + // BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). using boost::decimal::detail::impl::mg32_u256_by_u128; #endif using boost::decimal::detail::impl::mul_default_rounding; @@ -1001,27 +1005,25 @@ export namespace boost { namespace int128 { namespace detail { namespace impl { using boost::int128::detail::impl::countr_impl; using boost::int128::detail::impl::digit_from_char; #if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) + // The 128-bit division intrinsics are declared only where + // BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). using boost::int128::detail::impl::div_mod_intrinsic; #endif using boost::int128::detail::impl::from_chars_integer_impl; using boost::int128::detail::impl::from_words; #if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) + // The 128-bit division intrinsics are declared only where + // BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). using boost::int128::detail::impl::int128_addcarry_u64; -#endif -#if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) using boost::int128::detail::impl::int128_subborrow_u64; -#endif -#if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) using boost::int128::detail::impl::int128_udiv128_intrinsic; -#endif -#if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) using boost::int128::detail::impl::int128_umul128_intrinsic; #endif using boost::int128::detail::impl::knuth_divide; #if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) + // The 128-bit division intrinsics are declared only where + // BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). using boost::int128::detail::impl::mg32_div_3by2; -#endif -#if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) using boost::int128::detail::impl::mg32_reciprocal_2by1; #endif using boost::int128::detail::impl::to_words; diff --git a/generated/exports/dll.deps b/generated/exports/dll.deps index a800879ec..f1e7cbb56 100644 --- a/generated/exports/dll.deps +++ b/generated/exports/dll.deps @@ -1,5 +1,6 @@ mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.filesystem +mcpplibs.mwrap.boost.io mcpplibs.mwrap.boost.type_index mcpplibs.mwrap.boost.winapi diff --git a/generated/exports/dll.inc b/generated/exports/dll.inc index b2e80405c..3c72b47b7 100644 --- a/generated/exports/dll.inc +++ b/generated/exports/dll.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=dll boost=1.92.0 target=x86_64-w64-mingw32 entities=224 +// lib=dll boost=1.92.0 target=x86_64-w64-mingw32 entities=150 export namespace boost { namespace dll { using boost::dll::import_alias; @@ -99,8 +99,8 @@ export namespace boost { namespace dll { namespace detail { export namespace boost { namespace dll { namespace detail { namespace parser { #if !defined(_MSC_VER) - // M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) - // is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). + // M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is + // selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). using boost::dll::detail::parser::arg_list; using boost::dll::detail::parser::const_rule; using boost::dll::detail::parser::const_rule_impl; @@ -117,10 +117,12 @@ export namespace boost { namespace dll { namespace detail { namespace parser { }}}} export namespace boost { namespace dll { namespace experimental { + using boost::dll::experimental::constructor; #if !defined(_MSC_VER) // M9 platform guard: demangle_symbol comes from demangling/itanium.hpp. using boost::dll::experimental::demangle_symbol; #endif + using boost::dll::experimental::destructor; using boost::dll::experimental::get; using boost::dll::experimental::import_class; using boost::dll::experimental::import_mangled; @@ -153,81 +155,8 @@ export namespace boost { namespace dll { namespace experimental { namespace deta }}}} export namespace boost { namespace dll { namespace fs { - using boost::dll::fs::bitmask_set; - using boost::dll::fs::codecvt_error_category; - using boost::dll::fs::copy; - using boost::dll::fs::copy_file; - using boost::dll::fs::copy_options; - using boost::dll::fs::copy_symlink; - using boost::dll::fs::create_directories; - using boost::dll::fs::create_directory; - using boost::dll::fs::create_directory_symlink; - using boost::dll::fs::create_hard_link; - using boost::dll::fs::create_symlink; - using boost::dll::fs::creation_time; - using boost::dll::fs::current_path; - using boost::dll::fs::directory_entry; - using boost::dll::fs::exists; - using boost::dll::fs::file_size; - using boost::dll::fs::file_status; - using boost::dll::fs::file_type; - using boost::dll::fs::hard_link_count; - using boost::dll::fs::hash_value; - using boost::dll::fs::initial_path; - using boost::dll::fs::is_block_file; - using boost::dll::fs::is_character_file; - using boost::dll::fs::is_directory; - using boost::dll::fs::is_empty; - using boost::dll::fs::is_fifo; - using boost::dll::fs::is_other; - using boost::dll::fs::is_regular_file; - using boost::dll::fs::is_reparse_file; - using boost::dll::fs::is_socket; - using boost::dll::fs::is_symlink; - using boost::dll::fs::last_write_time; - using boost::dll::fs::native; - using boost::dll::fs::operator!; - using boost::dll::fs::operator!=; - using boost::dll::fs::operator&; - using boost::dll::fs::operator&=; - using boost::dll::fs::operator/; - using boost::dll::fs::operator<; - using boost::dll::fs::operator<<; - using boost::dll::fs::operator<=; - using boost::dll::fs::operator==; - using boost::dll::fs::operator>; - using boost::dll::fs::operator>=; - using boost::dll::fs::operator>>; - using boost::dll::fs::operator^; - using boost::dll::fs::operator^=; - using boost::dll::fs::operator|; - using boost::dll::fs::operator|=; - using boost::dll::fs::operator~; - using boost::dll::fs::path; - using boost::dll::fs::permissions; - using boost::dll::fs::permissions_present; - using boost::dll::fs::perms; - using boost::dll::fs::portable_directory_name; - using boost::dll::fs::portable_file_name; - using boost::dll::fs::portable_name; - using boost::dll::fs::portable_posix_name; - using boost::dll::fs::read_symlink; - using boost::dll::fs::relative; - using boost::dll::fs::remove; - using boost::dll::fs::remove_all; - using boost::dll::fs::rename; - using boost::dll::fs::resize_file; - using boost::dll::fs::space; - using boost::dll::fs::space_info; - using boost::dll::fs::status; - using boost::dll::fs::status_known; - using boost::dll::fs::swap; - using boost::dll::fs::symlink_status; - using boost::dll::fs::system_complete; - using boost::dll::fs::temp_directory_path; - using boost::dll::fs::type_present; - using boost::dll::fs::unique_path; - using boost::dll::fs::windows_name; + using boost::dll::fs::error_code; + using boost::dll::fs::system_error; }}} export namespace boost { namespace dll { namespace load_mode { @@ -252,14 +181,8 @@ export namespace boost { namespace dll { namespace load_mode { using boost::dll::load_mode::type::search_system_folders; }}} -export namespace boost { namespace system { - using boost::system::error_code; - using boost::system::system_error; -}} - export namespace boost { namespace typeindex { using boost::typeindex::ctti_type_index; - using boost::typeindex::type_index_facade; }} export namespace boost { namespace typeindex { namespace detail { diff --git a/generated/exports/dynamic_bitset.deps b/generated/exports/dynamic_bitset.deps index 0b2dffa43..b6d84cfa6 100644 --- a/generated/exports/dynamic_bitset.deps +++ b/generated/exports/dynamic_bitset.deps @@ -1,2 +1,3 @@ mcpplibs.mwrap.boost.assert +mcpplibs.mwrap.boost.container_hash mcpplibs.mwrap.boost.core diff --git a/generated/exports/endian.deps b/generated/exports/endian.deps deleted file mode 100644 index c63a6b32b..000000000 --- a/generated/exports/endian.deps +++ /dev/null @@ -1 +0,0 @@ -mcpplibs.mwrap.boost.config diff --git a/generated/exports/filesystem.deps b/generated/exports/filesystem.deps index d66ac624b..dd6c2a10e 100644 --- a/generated/exports/filesystem.deps +++ b/generated/exports/filesystem.deps @@ -1,3 +1,4 @@ +mcpplibs.mwrap.boost.container_hash mcpplibs.mwrap.boost.io mcpplibs.mwrap.boost.iterator mcpplibs.mwrap.boost.smart_ptr diff --git a/generated/exports/filesystem.inc b/generated/exports/filesystem.inc index 8f32d7813..fd2869cf1 100644 --- a/generated/exports/filesystem.inc +++ b/generated/exports/filesystem.inc @@ -1,9 +1,8 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=filesystem boost=1.92.0 target=x86_64-w64-mingw32 entities=242 +// lib=filesystem boost=1.92.0 target=x86_64-w64-mingw32 entities=244 export namespace boost { using boost::basic_string_view; - using boost::intrusive_ptr; using boost::range_const_iterator; using boost::range_mutable_iterator; } @@ -17,12 +16,14 @@ export namespace boost { namespace detail { namespace bitmask { }}} export namespace boost { namespace filesystem { + using boost::filesystem::absolute; using boost::filesystem::basic_filebuf; using boost::filesystem::basic_fstream; using boost::filesystem::basic_ifstream; using boost::filesystem::basic_ofstream; using boost::filesystem::begin; using boost::filesystem::bitmask_set; + using boost::filesystem::canonical; using boost::filesystem::cbegin; using boost::filesystem::cend; using boost::filesystem::codecvt_error_category; @@ -41,6 +42,7 @@ export namespace boost { namespace filesystem { using boost::filesystem::directory_iterator; using boost::filesystem::directory_options; using boost::filesystem::end; + using boost::filesystem::equivalent; using boost::filesystem::exists; using boost::filesystem::file_size; using boost::filesystem::file_status; @@ -146,6 +148,7 @@ export namespace boost { namespace filesystem { using boost::filesystem::temp_directory_path; using boost::filesystem::type_present; using boost::filesystem::unique_path; + using boost::filesystem::weakly_canonical; using boost::filesystem::wfilebuf; using boost::filesystem::wfstream; using boost::filesystem::wifstream; @@ -271,7 +274,3 @@ export namespace boost { namespace iterators { using boost::iterators::operator>; using boost::iterators::operator>=; }} - -export namespace boost { namespace sp_adl_block { - using boost::sp_adl_block::intrusive_ref_counter; -}} diff --git a/generated/exports/flyweight.deps b/generated/exports/flyweight.deps index 5d7802c5d..fb2b7db51 100644 --- a/generated/exports/flyweight.deps +++ b/generated/exports/flyweight.deps @@ -1,5 +1,6 @@ mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.config +mcpplibs.mwrap.boost.container_hash mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.interprocess mcpplibs.mwrap.boost.mp11 diff --git a/generated/exports/flyweight.inc b/generated/exports/flyweight.inc index 7f19975c6..7e302db3e 100644 --- a/generated/exports/flyweight.inc +++ b/generated/exports/flyweight.inc @@ -1,15 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=flyweight boost=1.92.0 target=x86_64-w64-mingw32 entities=932 -// -// M9 hand-trim: the generator leaked the entire transitive surface of -// boost.container / boost.interprocess / boost.intrusive / boost.move_detail / -// boost.mpl / boost.parameter / boost.multi_index / boost.interprocess.winapi -// into flyweight.inc (932 entities). Those namespaces are internal dependencies -// whose availability is platform-dependent (the interprocess winapi block is -// Windows-only; the container option types are macro-generated and only -// declared on the include path of the mingw snapshot). Trimmed to flyweight's -// own public surface (boost::flyweight + boost::flyweights::*). Mirrors the -// algorithm.inc restore_from_git convention in reapply_hand_edits.py. +// lib=flyweight boost=1.92.0 target=x86_64-w64-mingw32 entities=81 export namespace boost { using boost::flyweight; diff --git a/generated/exports/function.deps b/generated/exports/function.deps index 0b2dffa43..2404bc42d 100644 --- a/generated/exports/function.deps +++ b/generated/exports/function.deps @@ -1,2 +1,3 @@ mcpplibs.mwrap.boost.assert +mcpplibs.mwrap.boost.bind mcpplibs.mwrap.boost.core diff --git a/generated/exports/functional.inc b/generated/exports/functional.inc index df363476a..a21894d86 100644 --- a/generated/exports/functional.inc +++ b/generated/exports/functional.inc @@ -1,8 +1,7 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=functional boost=1.92.0 target=x86_64-w64-mingw32 entities=399 +// lib=functional boost=1.92.0 target=x86_64-w64-mingw32 entities=389 export namespace boost { - using boost::add_reference; using boost::binary_negate; using boost::binary_traits; using boost::bind1st; @@ -18,7 +17,6 @@ export namespace boost { using boost::factory_alloc_propagation::factory_alloc_for_pointee_and_deleter; using boost::factory_alloc_propagation::factory_passes_alloc_to_smart_pointer; using boost::forward_adapter; - using boost::function; using boost::function_equal; using boost::function_equal_impl; using boost::lightweight_forward_adapter; @@ -35,7 +33,6 @@ export namespace boost { using boost::pointer_to_binary_function; using boost::pointer_to_unary_function; using boost::ptr_fun; - using boost::result_of; using boost::unary_negate; using boost::unary_traits; using boost::value_factory; @@ -352,17 +349,12 @@ export namespace boost { namespace functional { namespace detail { }}} export namespace boost { namespace mpl { - using boost::mpl::advance; using boost::mpl::bitand_; using boost::mpl::bitand_impl; using boost::mpl::bitand_tag; using boost::mpl::bitxor_; using boost::mpl::bitxor_impl; using boost::mpl::bitxor_tag; - using boost::mpl::distance; - using boost::mpl::lambda; - using boost::mpl::next; - using boost::mpl::prior; using boost::mpl::remove; using boost::mpl::remove_if; using boost::mpl::reverse_remove; @@ -375,6 +367,7 @@ export namespace boost { namespace mpl { #endif using boost::mpl::v_iter; #if defined(__GNUC__) + // M9 platform guard: gcc-preprocessed mpl vector headers only. using boost::mpl::v_mask; #endif using boost::mpl::vector0; @@ -416,8 +409,6 @@ export namespace boost { namespace mpl { namespace aux { using boost::mpl::aux::remove_impl; using boost::mpl::aux::reverse_remove_if_impl; using boost::mpl::aux::reverse_remove_impl; - using boost::mpl::aux::template_arity; - using boost::mpl::aux::type_wrapper; using boost::mpl::aux::v_iter_tag; using boost::mpl::aux::vector_tag; }}} diff --git a/generated/exports/geometry.deps b/generated/exports/geometry.deps index 95ef9c3b5..4360a8551 100644 --- a/generated/exports/geometry.deps +++ b/generated/exports/geometry.deps @@ -3,10 +3,8 @@ mcpplibs.mwrap.boost.array mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.concept_check mcpplibs.mwrap.boost.config -mcpplibs.mwrap.boost.container mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.graph -mcpplibs.mwrap.boost.integer mcpplibs.mwrap.boost.iterator mcpplibs.mwrap.boost.math mcpplibs.mwrap.boost.mp11 @@ -14,11 +12,12 @@ mcpplibs.mwrap.boost.polygon mcpplibs.mwrap.boost.qvm mcpplibs.mwrap.boost.range mcpplibs.mwrap.boost.rational +mcpplibs.mwrap.boost.smart_ptr mcpplibs.mwrap.boost.thread mcpplibs.mwrap.boost.throw_exception +mcpplibs.mwrap.boost.tokenizer mcpplibs.mwrap.boost.tuple mcpplibs.mwrap.boost.type_traits -mcpplibs.mwrap.boost.unordered mcpplibs.mwrap.boost.utility mcpplibs.mwrap.boost.variant mcpplibs.mwrap.boost.variant2 diff --git a/generated/exports/geometry.inc b/generated/exports/geometry.inc index 65ac32d86..75a8713d8 100644 --- a/generated/exports/geometry.inc +++ b/generated/exports/geometry.inc @@ -1,13 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=geometry boost=1.92.0 target=x86_64-w64-mingw32 entities=4683 - -export namespace boost { - using boost::char_separator; - using boost::range_const_iterator; - using boost::range_mutable_iterator; - using boost::range_size; - using boost::tokenizer; -} +// lib=geometry boost=1.92.0 target=x86_64-w64-mingw32 entities=4675 export namespace boost { namespace geometry { using boost::geometry::add_const_if_c; @@ -5734,13 +5726,10 @@ export namespace boost { namespace geometry { namespace util { namespace detail export namespace boost { namespace mpl { using boost::mpl::count_if; - using boost::mpl::lambda; - using boost::mpl::push_back; }} export namespace boost { namespace mpl { namespace aux { using boost::mpl::aux::next_if; - using boost::mpl::aux::template_arity; }}} export namespace boost { namespace polygon { diff --git a/generated/exports/gil.deps b/generated/exports/gil.deps index 9e40df713..be0101ef4 100644 --- a/generated/exports/gil.deps +++ b/generated/exports/gil.deps @@ -1,7 +1,8 @@ mcpplibs.mwrap.boost.assert +mcpplibs.mwrap.boost.concept_check mcpplibs.mwrap.boost.config +mcpplibs.mwrap.boost.container_hash mcpplibs.mwrap.boost.core -mcpplibs.mwrap.boost.integer -mcpplibs.mwrap.boost.iterator mcpplibs.mwrap.boost.mp11 +mcpplibs.mwrap.boost.type_traits mcpplibs.mwrap.boost.variant2 diff --git a/generated/exports/gil.inc b/generated/exports/gil.inc index 06dfa8b3f..d7f493f1d 100644 --- a/generated/exports/gil.inc +++ b/generated/exports/gil.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=gil boost=1.92.0 target=x86_64-w64-mingw32 entities=3881 +// lib=gil boost=1.92.0 target=x86_64-w64-mingw32 entities=3880 export namespace boost { namespace gil { using boost::gil::Assignable; @@ -3922,7 +3922,3 @@ export namespace boost { namespace gil { namespace ycbcr_709_color_space { using boost::gil::ycbcr_709_color_space::cr_t; using boost::gil::ycbcr_709_color_space::y_t; }}} - -export namespace boost { namespace mp11 { - using boost::mp11::mp_list; -}} diff --git a/generated/exports/graph.inc b/generated/exports/graph.inc index c8a9a84b2..70791db0b 100644 --- a/generated/exports/graph.inc +++ b/generated/exports/graph.inc @@ -1,19 +1,31 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=graph boost=1.92.0 target=x86_64-w64-mingw32 entities=3081 +// lib=graph boost=1.92.0 target=x86_64-w64-mingw32 entities=3072 export namespace boost { using boost::AStarHeuristicConcept; using boost::AStarVisitorConcept; + using boost::AdjacencyGraphConcept; + using boost::AdjacencyMatrixConcept; using boost::BFSVisitorConcept; + using boost::BasicMatrixConcept; using boost::BellmanFordVisitorConcept; + using boost::BidirectionalGraphConcept; using boost::Buffer; using boost::BufferConcept; using boost::CliqueVisitorConcept; + using boost::ColorValueConcept; using boost::CoreNumbersVisitorConcept; using boost::CycleVisitorConcept; using boost::DFSVisitorConcept; + using boost::DegreeMeasureConcept; using boost::DijkstraVisitorConcept; + using boost::DistanceMeasureConcept; + using boost::EdgeIndexGraphConcept; + using boost::EdgeListGraphConcept; + using boost::EdgeMutableGraphConcept; + using boost::EdgeMutablePropertyGraphConcept; using boost::EdgePrinter; + using boost::GraphConcept; using boost::GraphParser; using boost::GraphParserState; using boost::GraphParserState::PARSE_EDGE; @@ -22,16 +34,31 @@ export namespace boost { using boost::GraphPartitionQualityFunctionConcept; using boost::GraphPartitionQualityFunctionIncrementalConcept; using boost::GraphPrinter; + using boost::IncidenceGraphConcept; using boost::KeyedUpdatableQueue; using boost::KeyedUpdatableQueueConcept; + using boost::LvaluePropertyGraphConcept; using boost::MASVisitorConcept; + using boost::MultiPassInputIteratorConcept; + using boost::MutableBidirectionalGraphConcept; + using boost::MutableEdgeListGraphConcept; + using boost::MutableGraphConcept; + using boost::MutableIncidenceGraphConcept; using boost::NeighborBFSVisitorConcept; + using boost::NumericValueConcept; using boost::PreorderTraverser; + using boost::PropertyGraphConcept; using boost::PropertyPrinter; + using boost::ReadablePropertyGraphConcept; using boost::Requires_; using boost::TSPVertexVisitorConcept; using boost::UpdatableQueue; using boost::UpdatableQueueConcept; + using boost::VertexAndEdgeListGraphConcept; + using boost::VertexIndexGraphConcept; + using boost::VertexListGraphConcept; + using boost::VertexMutableGraphConcept; + using boost::VertexMutablePropertyGraphConcept; using boost::_requires_; using boost::add_edge; using boost::add_edge_by_label; @@ -451,7 +478,6 @@ export namespace boost { using boost::has_graph_property; using boost::has_property; using boost::has_vertex_property; - using boost::hash; using boost::hash_mapS; using boost::hash_multimapS; using boost::hash_multisetS; @@ -783,7 +809,6 @@ export namespace boost { using boost::property_map_tuple_adaptor; using boost::property_map_value; using boost::property_put; - using boost::property_traits; using boost::property_value; using boost::property_writer; using boost::pseudo_peripheral_pair; @@ -801,8 +826,6 @@ export namespace boost { using boost::random_spanning_tree; using boost::random_vertex; using boost::randomize_property; - using boost::range_const_iterator; - using boost::range_mutable_iterator; using boost::rank_comparison; using boost::rank_map; using boost::read; @@ -837,7 +860,6 @@ export namespace boost { using boost::repulsive_force_t; using boost::requires_; using boost::residual_capacity_map; - using boost::result_of; using boost::reverse_edge_map; using boost::reverse_graph; using boost::reverse_graph_tag; @@ -865,8 +887,6 @@ export namespace boost { using boost::set_remove; using boost::set_subset; using boost::set_union; - using boost::shared_array; - using boost::shared_ptr; using boost::side_length; using boost::simple_point; using boost::single_side; @@ -884,7 +904,6 @@ export namespace boost { using boost::square_topology; using boost::ssca_iterator; using boost::stamp_times; - using boost::static_property_map; using boost::stoer_wagner_min_cut; using boost::strong_components; using boost::subgraph; @@ -901,7 +920,6 @@ export namespace boost { using boost::time_stamper; using boost::topo_sort_visitor; using boost::topological_sort; - using boost::tr1_result_of; using boost::transitive_closure; using boost::transitive_reduction; using boost::transpose_graph; @@ -1061,10 +1079,6 @@ export namespace boost { using boost::write_property; } -export namespace boost { namespace bimaps { - using boost::bimaps::set_of; -}} - export namespace boost { namespace boyer_myrvold_params { using boost::boyer_myrvold_params::boyer_myrvold_params_t; }} @@ -1634,31 +1648,6 @@ export namespace boost { namespace foreach_detail_ { using boost::foreach_detail_::wrap_cstr; }} -export namespace boost { namespace fusion { namespace extension { - using boost::fusion::extension::advance_impl; - using boost::fusion::extension::at_impl; - using boost::fusion::extension::begin_impl; - using boost::fusion::extension::category_of_impl; - using boost::fusion::extension::convert_impl; - using boost::fusion::extension::deref_impl; - using boost::fusion::extension::distance_impl; - using boost::fusion::extension::end_impl; - using boost::fusion::extension::is_segmented_impl; - using boost::fusion::extension::is_sequence_impl; - using boost::fusion::extension::is_view_impl; - using boost::fusion::extension::next_impl; - using boost::fusion::extension::prior_impl; - using boost::fusion::extension::segments_impl; - using boost::fusion::extension::size_impl; - using boost::fusion::extension::value_at_impl; - using boost::fusion::extension::value_of_impl; -}}} - -export namespace boost { namespace fusion { namespace traits { - using boost::fusion::traits::enable_comparison; - using boost::fusion::traits::enable_equality; -}}} - export namespace boost { namespace graph { using boost::graph::add_edge; using boost::graph::add_removed_edge_capacity; @@ -1939,7 +1928,6 @@ export namespace boost { namespace hawick_circuits_detail { export namespace boost { namespace iterators { using boost::iterators::int_iterator; - using boost::iterators::iterator_facade; using boost::iterators::operator+; }} @@ -1953,22 +1941,10 @@ export namespace boost { namespace louvain_detail { using boost::louvain_detail::unfold; }} -export namespace boost { namespace mpl { - using boost::mpl::identity; - using boost::mpl::sequence_tag; -}} - -export namespace boost { namespace multi_index { - using boost::multi_index::tag; -}} - export namespace boost { namespace parameter { using boost::parameter::are_tagged_arguments; using boost::parameter::compose; using boost::parameter::is_argument_pack; - using boost::parameter::keyword; - using boost::parameter::parameters; - using boost::parameter::required; }} export namespace boost { namespace parameter { namespace aux { @@ -2377,18 +2353,23 @@ export namespace boost { namespace proto { namespace detail { using boost::proto::detail::sized_type; using boost::proto::detail::static_const; #if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) - // M11 platform guard: proto/detail/template_arity.hpp declares template_arity only under - // BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template matching). + // M11 platform guard: proto/detail/template_arity.hpp declares template_arity + // only under BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc + // extended-template matching). using boost::proto::detail::template_arity; #endif #if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) - // M11 platform guard: proto/detail/template_arity.hpp declares template_arity_helper only under - // BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template matching). + // M11 platform guard: proto/detail/template_arity.hpp declares + // template_arity_helper only under + // BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template + // matching). using boost::proto::detail::template_arity_helper; #endif #if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) - // M11 platform guard: proto/detail/template_arity.hpp declares template_arity_impl2 only under - // BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template matching). + // M11 platform guard: proto/detail/template_arity.hpp declares + // template_arity_impl2 only under + // BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template + // matching). using boost::proto::detail::template_arity_impl2; #endif using boost::proto::detail::term_traits; @@ -2644,7 +2625,6 @@ export namespace boost { namespace serialization { using boost::serialization::load; using boost::serialization::save; using boost::serialization::serialize; - using boost::serialization::tracking_level; }} export namespace boost { namespace sparse { @@ -2921,6 +2901,7 @@ export namespace boost { namespace xpressive { namespace detail { using boost::xpressive::detail::hash_peek_bitset; using boost::xpressive::detail::hash_peek_finder; using boost::xpressive::detail::icase_modifier; + using boost::xpressive::detail::ignore_unused; using boost::xpressive::detail::ignore_unused_icase; using boost::xpressive::detail::ignore_unused_regex_primitives; using boost::xpressive::detail::independent_end_matcher; diff --git a/generated/exports/hana.deps b/generated/exports/hana.deps index 1314b2c0c..1bf099d3c 100644 --- a/generated/exports/hana.deps +++ b/generated/exports/hana.deps @@ -1,3 +1,2 @@ mcpplibs.mwrap.boost.core -mcpplibs.mwrap.boost.tuple mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/hana.inc b/generated/exports/hana.inc index b6dd9f4c3..3e0afe023 100644 --- a/generated/exports/hana.inc +++ b/generated/exports/hana.inc @@ -1,10 +1,9 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=hana boost=1.92.0 target=x86_64-w64-mingw32 entities=1047 +// lib=hana boost=1.92.0 target=x86_64-w64-mingw32 entities=1046 export namespace boost { namespace fusion { using boost::fusion::as_deque; using boost::fusion::as_list; - using boost::fusion::deque; using boost::fusion::deque_iterator; using boost::fusion::front_extended_deque; using boost::fusion::make_deque; diff --git a/generated/exports/heap.inc b/generated/exports/heap.inc index 146df1eb8..fabba87de 100644 --- a/generated/exports/heap.inc +++ b/generated/exports/heap.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=heap boost=1.92.0 target=x86_64-w64-mingw32 entities=97 +// lib=heap boost=1.92.0 target=x86_64-w64-mingw32 entities=92 export namespace boost { namespace heap { using boost::heap::MergablePriorityQueue; @@ -99,20 +99,6 @@ export namespace boost { namespace heap { namespace tag { using boost::heap::tag::store_parent_pointer; }}} -export namespace boost { namespace intrusive { - using boost::intrusive::list; -}} - -export namespace boost { namespace mpl { - using boost::mpl::lambda; -}} - -export namespace boost { namespace parameter { - using boost::parameter::optional; - using boost::parameter::parameters; - using boost::parameter::required; -}} - export namespace boost { namespace parameter { namespace aux { using boost::parameter::aux::is_name_tag; using boost::parameter::aux::name_tag; diff --git a/generated/exports/histogram.inc b/generated/exports/histogram.inc index 0847788cb..bf93d8030 100644 --- a/generated/exports/histogram.inc +++ b/generated/exports/histogram.inc @@ -1,9 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=histogram boost=1.92.0 target=x86_64-w64-mingw32 entities=383 - -export namespace boost { - using boost::span; -} +// lib=histogram boost=1.92.0 target=x86_64-w64-mingw32 entities=382 export namespace boost { namespace accumulators { using boost::accumulators::accumulator_set; @@ -33,6 +29,7 @@ export namespace boost { namespace histogram { using boost::histogram::storage_adaptor; using boost::histogram::unlimited_storage; using boost::histogram::unsafe_access; + using boost::histogram::use_default; using boost::histogram::weight; using boost::histogram::weight_storage; using boost::histogram::weight_type; @@ -421,7 +418,3 @@ export namespace boost { namespace histogram { namespace utility { using boost::histogram::utility::wald_interval; using boost::histogram::utility::wilson_interval; }}} - -export namespace boost { namespace serialization { - using boost::serialization::version; -}} diff --git a/generated/exports/hof.inc b/generated/exports/hof.inc index 2736aa6a7..c59bce814 100644 --- a/generated/exports/hof.inc +++ b/generated/exports/hof.inc @@ -148,28 +148,28 @@ export namespace boost { namespace hof { namespace detail { using boost::hof::detail::basic_first_of_adaptor; using boost::hof::detail::bind_transformer; #if !defined(_MSC_VER) - // C2 platform guard: bool_seq is the non-_MSC_VER branch of - // detail/and.hpp (the MSVC branch declares struct and_ instead). + // C2 platform guard: bool_seq is the non-_MSC_VER branch of detail/and.hpp + // (the MSVC branch declares struct and_ instead). using boost::hof::detail::bool_seq; #endif using boost::hof::detail::by_eval; using boost::hof::detail::by_void_eval; #if !BOOST_HOF_NO_EXPRESSION_SFINAE - // C2 platform guard: callable_args is the !NO_EXPRESSION_SFINAE branch - // of detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). + // C2 platform guard: callable_args is the !NO_EXPRESSION_SFINAE branch of + // detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). using boost::hof::detail::callable_args; #endif using boost::hof::detail::callable_base; using boost::hof::detail::callable_base_type; #if !BOOST_HOF_NO_EXPRESSION_SFINAE - // C2 platform guard: called_val is the !NO_EXPRESSION_SFINAE branch - // of detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). + // C2 platform guard: called_val is the !NO_EXPRESSION_SFINAE branch of + // detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). using boost::hof::detail::called_val; #endif using boost::hof::detail::can_be_called; #if !BOOST_HOF_NO_EXPRESSION_SFINAE - // C2 platform guard: can_be_called_impl is the !NO_EXPRESSION_SFINAE branch - // of detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). + // C2 platform guard: can_be_called_impl is the !NO_EXPRESSION_SFINAE branch of + // detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). using boost::hof::detail::can_be_called_impl; #endif using boost::hof::detail::capture_f; @@ -195,8 +195,8 @@ export namespace boost { namespace hof { namespace detail { using boost::hof::detail::decorator_invoke; using boost::hof::detail::enable_if_constructible; #if !BOOST_HOF_NO_ORDERED_BRACE_INIT - // C2 platform guard: eval_helper is the !NO_ORDERED_BRACE_INIT branch - // of apply_eval.hpp (config.hpp: _MSC_VER → 1). + // C2 platform guard: eval_helper is the !NO_ORDERED_BRACE_INIT branch of + // apply_eval.hpp (config.hpp: _MSC_VER → 1). using boost::hof::detail::eval_helper; #endif using boost::hof::detail::fix_adaptor_base; @@ -362,8 +362,8 @@ export namespace boost { namespace hof { namespace operators { using boost::hof::operators::call; using boost::hof::operators::compl_; #if !defined(_MSC_VER) - // C2 platform guard: operators::decrement is the #ifndef _MSC_VER - // branch of placeholders.hpp (MSVC 2017 ICE on ++/-- constexpr). + // C2 platform guard: operators::decrement is the #ifndef _MSC_VER branch of + // placeholders.hpp (MSVC 2017 ICE on ++/-- constexpr). using boost::hof::operators::decrement; #endif using boost::hof::operators::dereference; @@ -372,8 +372,8 @@ export namespace boost { namespace hof { namespace operators { using boost::hof::operators::greater_than; using boost::hof::operators::greater_than_equal; #if !defined(_MSC_VER) - // C2 platform guard: operators::increment is the #ifndef _MSC_VER - // branch of placeholders.hpp (MSVC 2017 ICE on ++/-- constexpr). + // C2 platform guard: operators::increment is the #ifndef _MSC_VER branch of + // placeholders.hpp (MSVC 2017 ICE on ++/-- constexpr). using boost::hof::operators::increment; #endif using boost::hof::operators::less_than; diff --git a/generated/exports/icl.deps b/generated/exports/icl.deps index e19ec91ec..67821ec79 100644 --- a/generated/exports/icl.deps +++ b/generated/exports/icl.deps @@ -4,5 +4,6 @@ mcpplibs.mwrap.boost.date_time mcpplibs.mwrap.boost.io mcpplibs.mwrap.boost.iterator mcpplibs.mwrap.boost.rational +mcpplibs.mwrap.boost.smart_ptr mcpplibs.mwrap.boost.type_traits mcpplibs.mwrap.boost.utility diff --git a/generated/exports/interprocess.inc b/generated/exports/interprocess.inc index 37e9b8ef0..2a0f289c2 100644 --- a/generated/exports/interprocess.inc +++ b/generated/exports/interprocess.inc @@ -1,49 +1,17 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=interprocess boost=1.92.0 target=x86_64-w64-mingw32 entities=718 +// lib=interprocess boost=1.92.0 target=x86_64-w64-mingw32 entities=716 export namespace boost { using boost::has_trivial_destructor; using boost::pointer_to_other; } -export namespace boost { namespace container { - using boost::container::allocation_type; - using boost::container::basic_string; - using boost::container::deque; - using boost::container::flat_map; - using boost::container::flat_multimap; - using boost::container::flat_multiset; - using boost::container::flat_set; - using boost::container::list; - using boost::container::make_transform_iterator; - using boost::container::map; - using boost::container::multimap; - using boost::container::multiset; - using boost::container::ordered_range; - using boost::container::ordered_unique_range; - using boost::container::set; - using boost::container::slist; - using boost::container::stable_vector; - using boost::container::string; - using boost::container::transform_iterator; - using boost::container::vector; -}} - -export namespace boost { namespace container { namespace dtl { - using boost::container::dtl::build_number_seq; - using boost::container::dtl::get; - using boost::container::dtl::index_tuple; - using boost::container::dtl::pair; - using boost::container::dtl::tuple; - using boost::container::dtl::version; - using boost::container::dtl::version_type; -}}} - export namespace boost { namespace interprocess { using boost::interprocess::accept_ownership_type; using boost::interprocess::adaptive_pool; using boost::interprocess::addressof; using boost::interprocess::alignof_value; + using boost::interprocess::allocation_type; using boost::interprocess::allocator; using boost::interprocess::anonymous_shared_memory; using boost::interprocess::bad_alloc; @@ -57,10 +25,13 @@ export namespace boost { namespace interprocess { using boost::interprocess::basic_managed_mapped_file; using boost::interprocess::basic_managed_shared_memory; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::basic_managed_windows_shared_memory; #endif using boost::interprocess::basic_obufferstream; using boost::interprocess::basic_ovectorstream; + using boost::interprocess::basic_string; using boost::interprocess::basic_vectorbuf; using boost::interprocess::basic_vectorstream; using boost::interprocess::bufferbuf; @@ -73,6 +44,7 @@ export namespace boost { namespace interprocess { using boost::interprocess::cv_status; using boost::interprocess::defer_lock_type; using boost::interprocess::deleter; + using boost::interprocess::deque; using boost::interprocess::dynamic_pointer_cast; using boost::interprocess::ec_xlate; using boost::interprocess::enable_shared_from_this; @@ -113,8 +85,12 @@ export namespace boost { namespace interprocess { using boost::interprocess::file_pos_t::file_end; using boost::interprocess::fill_system_message; using boost::interprocess::fixed_managed_shared_memory; + using boost::interprocess::flat_map; using boost::interprocess::flat_map_index; using boost::interprocess::flat_map_index_aux; + using boost::interprocess::flat_multimap; + using boost::interprocess::flat_multiset; + using boost::interprocess::flat_set; using boost::interprocess::ibufferstream; using boost::interprocess::ignore; using boost::interprocess::instance_type; @@ -137,11 +113,13 @@ export namespace boost { namespace interprocess { using boost::interprocess::iset_index_aux; using boost::interprocess::iunordered_set_index; using boost::interprocess::iunordered_set_index_aux; + using boost::interprocess::list; using boost::interprocess::lock_exception; using boost::interprocess::lookup_error; using boost::interprocess::make_managed_shared_ptr; using boost::interprocess::make_managed_unique_ptr; using boost::interprocess::make_managed_weak_ptr; + using boost::interprocess::make_transform_iterator; using boost::interprocess::managed_external_buffer; using boost::interprocess::managed_heap_memory; using boost::interprocess::managed_mapped_file; @@ -150,8 +128,11 @@ export namespace boost { namespace interprocess { using boost::interprocess::managed_unique_ptr; using boost::interprocess::managed_weak_ptr; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::managed_windows_shared_memory; #endif + using boost::interprocess::map; using boost::interprocess::map_index; using boost::interprocess::map_options_t; using boost::interprocess::mapped_region; @@ -171,7 +152,9 @@ export namespace boost { namespace interprocess { using boost::interprocess::mqblock_types::blocking; using boost::interprocess::mqblock_types::non_blocking; using boost::interprocess::mqblock_types::timed; + using boost::interprocess::multimap; using boost::interprocess::multiplication_overflows; + using boost::interprocess::multiset; using boost::interprocess::mutex_family; using boost::interprocess::named_condition; using boost::interprocess::named_condition_any; @@ -200,6 +183,9 @@ export namespace boost { namespace interprocess { using boost::interprocess::operator<<; using boost::interprocess::operator==; using boost::interprocess::operator>>; + using boost::interprocess::ordered_range; + using boost::interprocess::ordered_unique_range; + using boost::interprocess::pair; using boost::interprocess::permissions; using boost::interprocess::pointer_offset_caster; using boost::interprocess::private_adaptive_pool; @@ -212,6 +198,7 @@ export namespace boost { namespace interprocess { using boost::interprocess::scoped_ptr; using boost::interprocess::segment_manager; using boost::interprocess::segment_manager_base; + using boost::interprocess::set; using boost::interprocess::sharable_lock; using boost::interprocess::shared_memory_object; using boost::interprocess::shared_ptr; @@ -219,13 +206,17 @@ export namespace boost { namespace interprocess { using boost::interprocess::simple_swap; using boost::interprocess::size_overflows; using boost::interprocess::sizeof_value; + using boost::interprocess::slist; using boost::interprocess::spin_wait; using boost::interprocess::sqrt_size_type_max; + using boost::interprocess::stable_vector; using boost::interprocess::static_pointer_cast; + using boost::interprocess::string; using boost::interprocess::sum_overflows; using boost::interprocess::swap; using boost::interprocess::system_error_code; using boost::interprocess::to_raw_pointer; + using boost::interprocess::transform_iterator; using boost::interprocess::try_to_lock_type; using boost::interprocess::unique_ptr; using boost::interprocess::unordered_map_index; @@ -237,12 +228,17 @@ export namespace boost { namespace interprocess { using boost::interprocess::ustime; using boost::interprocess::ustime_delay_milliseconds; using boost::interprocess::value_eraser; + using boost::interprocess::vector; + using boost::interprocess::version; + using boost::interprocess::version_type; using boost::interprocess::wbufferbuf; using boost::interprocess::wbufferstream; using boost::interprocess::weak_ptr; using boost::interprocess::wfixed_managed_shared_memory; using boost::interprocess::wibufferstream; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::windows_shared_memory; #endif using boost::interprocess::wmanaged_external_buffer; @@ -250,6 +246,8 @@ export namespace boost { namespace interprocess { using boost::interprocess::wmanaged_mapped_file; using boost::interprocess::wmanaged_shared_memory; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::wmanaged_windows_shared_memory; #endif using boost::interprocess::wobufferstream; @@ -290,6 +288,7 @@ export namespace boost { namespace interprocess { namespace ipcdetail { using boost::interprocess::ipcdetail::boost_intrusive_has_type_rep; using boost::interprocess::ipcdetail::boost_intrusive_has_type_rep_type; using boost::interprocess::ipcdetail::boost_intrusive_has_type_time_duration_type; + using boost::interprocess::ipcdetail::build_number_seq; using boost::interprocess::ipcdetail::cache_impl; using boost::interprocess::ipcdetail::cached_adaptive_pool_v1; using boost::interprocess::ipcdetail::cached_allocator_impl; @@ -320,6 +319,8 @@ export namespace boost { namespace interprocess { namespace ipcdetail { using boost::interprocess::ipcdetail::disable_if; using boost::interprocess::ipcdetail::disable_if_ptime; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::do_winapi_wait; #endif using boost::interprocess::ipcdetail::duration_to_milliseconds; @@ -341,13 +342,18 @@ export namespace boost { namespace interprocess { namespace ipcdetail { using boost::interprocess::ipcdetail::false_type; using boost::interprocess::ipcdetail::file_handle_from_mapping_handle; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::file_time_to_microseconds; #endif using boost::interprocess::ipcdetail::file_wrapper; using boost::interprocess::ipcdetail::floor_log2; using boost::interprocess::ipcdetail::for_each_file_in_dir; using boost::interprocess::ipcdetail::gcd; + using boost::interprocess::ipcdetail::get; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::get_bootstamp; #endif using boost::interprocess::ipcdetail::get_current_process_creation_time; @@ -374,6 +380,8 @@ export namespace boost { namespace interprocess { namespace ipcdetail { using boost::interprocess::ipcdetail::get_system_tick_us; using boost::interprocess::ipcdetail::get_temporary_path; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::get_temporary_wpath; #endif using boost::interprocess::ipcdetail::get_truncated_size; @@ -384,12 +392,13 @@ export namespace boost { namespace interprocess { namespace ipcdetail { using boost::interprocess::ipcdetail::index_config; using boost::interprocess::ipcdetail::index_data; using boost::interprocess::ipcdetail::index_key; + using boost::interprocess::ipcdetail::index_tuple; using boost::interprocess::ipcdetail::instance_t; using boost::interprocess::ipcdetail::integral_constant; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::intermodule_singleton_common; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::intermodule_singleton_impl; #endif using boost::interprocess::ipcdetail::internal_mutex_lock; @@ -418,6 +427,8 @@ export namespace boost { namespace interprocess { namespace ipcdetail { using boost::interprocess::ipcdetail::map_index_aux; using boost::interprocess::ipcdetail::mapping_handle_from_file_handle; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::mapping_handle_from_shm_handle; #endif using boost::interprocess::ipcdetail::mem_algo_deallocator; @@ -455,6 +466,8 @@ export namespace boost { namespace interprocess { namespace ipcdetail { using boost::interprocess::ipcdetail::operator<; using boost::interprocess::ipcdetail::operator==; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::os_file_traits; #endif using boost::interprocess::ipcdetail::os_thread_func_ptr_deleter; @@ -470,6 +483,8 @@ export namespace boost { namespace interprocess { namespace ipcdetail { using boost::interprocess::ipcdetail::private_node_pool; using boost::interprocess::ipcdetail::raw_mapped_region_creator; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::ref_count_ptr; #endif using boost::interprocess::ipcdetail::reinterpret_cast_tag; @@ -497,10 +512,14 @@ export namespace boost { namespace interprocess { namespace ipcdetail { using boost::interprocess::ipcdetail::shm_named_condition; using boost::interprocess::ipcdetail::shm_named_condition_any; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::shm_named_mutex; #endif using boost::interprocess::ipcdetail::shm_named_recursive_mutex; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::shm_named_semaphore; #endif using boost::interprocess::ipcdetail::shmem_open_or_create; @@ -510,15 +529,11 @@ export namespace boost { namespace interprocess { namespace ipcdetail { using boost::interprocess::ipcdetail::sp_counted_impl_pd; using boost::interprocess::ipcdetail::sp_enable_shared_from_this; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::spin_condition; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::spin_mutex; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::spin_recursive_mutex; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::spin_semaphore; #endif using boost::interprocess::ipcdetail::static_cast_tag; @@ -540,43 +555,34 @@ export namespace boost { namespace interprocess { namespace ipcdetail { using boost::interprocess::ipcdetail::try_acquire_file_lock_sharable; using boost::interprocess::ipcdetail::try_based_lock; using boost::interprocess::ipcdetail::try_based_timed_lock; + using boost::interprocess::ipcdetail::tuple; using boost::interprocess::ipcdetail::two; using boost::interprocess::ipcdetail::unique_instance_t; using boost::interprocess::ipcdetail::universal_time_u64_us; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::unrestricted_permissions_holder; #endif using boost::interprocess::ipcdetail::upper_power_of_2; using boost::interprocess::ipcdetail::weak_count; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::winapi_mutex_functions; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::winapi_mutex_wrapper; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::winapi_semaphore_functions; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::winapi_semaphore_wrapper; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::winapi_wrapper_timed_wait_for_single_object; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::winapi_wrapper_try_wait_for_single_object; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::winapi_wrapper_wait_for_single_object; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::windows_bootstamp; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::windows_intermodule_singleton; #endif using boost::interprocess::ipcdetail::write_file; #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::wshmem_open_or_create; #endif using boost::interprocess::ipcdetail::yes_type; @@ -585,21 +591,13 @@ export namespace boost { namespace interprocess { namespace ipcdetail { export namespace boost { namespace interprocess { namespace ipcdetail { namespace intermodule_singleton_helpers { #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::intermodule_singleton_helpers::get_map_base_name; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::intermodule_singleton_helpers::get_map_name; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::intermodule_singleton_helpers::get_map_size; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::intermodule_singleton_helpers::get_pid_creation_time_str; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::intermodule_singleton_helpers::thread_safe_global_map_dependant; -#endif -#if defined(_WIN32) using boost::interprocess::ipcdetail::intermodule_singleton_helpers::windows_semaphore_based_map; #endif }}}} @@ -610,6 +608,8 @@ export namespace boost { namespace interprocess { namespace ipcdetail { namespac export namespace boost { namespace interprocess { namespace ipcdetail { namespace robust_emulation_helpers { #if defined(_WIN32) + // The Windows shared-memory and synchronization surface (detail/win32_api.hpp + // chain); POSIX interprocess never declares it. using boost::interprocess::ipcdetail::robust_emulation_helpers::mutex_traits; #endif }}}} @@ -618,8 +618,8 @@ export namespace boost { namespace interprocess { namespace ipcdetail_really_dee using boost::interprocess::ipcdetail_really_deep_namespace::dummy; }}} -#if defined(_WIN32) export namespace boost { namespace interprocess { namespace winapi { +#if defined(_WIN32) // M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) // is Windows-only; POSIX interprocess never declares it. using boost::interprocess::winapi::NtClose_t; @@ -805,16 +805,15 @@ export namespace boost { namespace interprocess { namespace winapi { using boost::interprocess::winapi::win32_find_data_w; using boost::interprocess::winapi::winapi_traits; using boost::interprocess::winapi::write_file; -}}} #endif +}}} export namespace boost { namespace intrusive { - using boost::intrusive::max_pointer_plus_bits; using boost::intrusive::pointer_plus_bits; }} -#if defined(_WIN32) export namespace boost { namespace ipwinapiext { +#if defined(_WIN32) // M12 platform guard: registry / virtual-memory extension surface — // Windows-only (win32_api.hpp chain). using boost::ipwinapiext::CreateThread; @@ -833,9 +832,5 @@ export namespace boost { namespace ipwinapiext { using boost::ipwinapiext::VirtualLock; using boost::ipwinapiext::VirtualProtect; using boost::ipwinapiext::VirtualUnlock; -}} #endif - -export namespace boost { namespace move_detail { - using boost::move_detail::is_trivially_destructible; }} diff --git a/generated/exports/intrusive.inc b/generated/exports/intrusive.inc index 8fb4713fe..700a1c7e4 100644 --- a/generated/exports/intrusive.inc +++ b/generated/exports/intrusive.inc @@ -175,6 +175,10 @@ export namespace boost { namespace intrusive { using boost::intrusive::inverted_typelist; using boost::intrusive::is_default_hook_tag; using boost::intrusive::is_safe_autounlink; + using boost::intrusive::iter_category; + using boost::intrusive::iter_difference; + using boost::intrusive::iter_size; + using boost::intrusive::iter_value; using boost::intrusive::iterator; using boost::intrusive::iterator_advance; using boost::intrusive::iterator_arrow_result; @@ -226,6 +230,7 @@ export namespace boost { namespace intrusive { using boost::intrusive::make_list_member_hook; using boost::intrusive::make_multiset; using boost::intrusive::make_rbtree; + using boost::intrusive::make_reverse_iterator; using boost::intrusive::make_set; using boost::intrusive::make_set_base_hook; using boost::intrusive::make_set_member_hook; @@ -284,6 +289,7 @@ export namespace boost { namespace intrusive { using boost::intrusive::rbtree_node_traits; using boost::intrusive::rbtree_node_traits_dispatch; using boost::intrusive::reduced_slist_node_traits; + using boost::intrusive::reverse_iterator; using boost::intrusive::set; using boost::intrusive::set_base_hook; using boost::intrusive::set_impl; @@ -364,14 +370,22 @@ export namespace boost { namespace intrusive { namespace adldft { }}} export namespace boost { namespace intrusive { namespace detail { + using boost::intrusive::detail::add_const; + using boost::intrusive::detail::add_const_if_c; + using boost::intrusive::detail::add_pointer; + using boost::intrusive::detail::add_reference; + using boost::intrusive::detail::addressof; + using boost::intrusive::detail::alignment_of; using boost::intrusive::detail::alpha_0_75_by_max_size_t; using boost::intrusive::detail::alpha_by_max_size_t; using boost::intrusive::detail::alpha_holder; using boost::intrusive::detail::any_hook_base_value_traits; using boost::intrusive::detail::any_or_concrete_value_traits; using boost::intrusive::detail::any_to_some_hook; + using boost::intrusive::detail::apply; using boost::intrusive::detail::array_initializer; using boost::intrusive::detail::avltree_node_checker; + using boost::intrusive::detail::bool_; using boost::intrusive::detail::boost_intrusive_default_type_difference_type; using boost::intrusive::detail::boost_intrusive_default_type_reference; using boost::intrusive::detail::boost_intrusive_default_type_size_type; @@ -395,11 +409,21 @@ export namespace boost { namespace intrusive { namespace detail { using boost::intrusive::detail::constptr; using boost::intrusive::detail::default_header_holder; using boost::intrusive::detail::destructor_impl; + using boost::intrusive::detail::disable_if; + using boost::intrusive::detail::disable_if_c; + using boost::intrusive::detail::disable_if_convertible; using boost::intrusive::detail::dummy_constptr; using boost::intrusive::detail::ebo_functor_holder; using boost::intrusive::detail::empty_node_checker; + using boost::intrusive::detail::enable_if; + using boost::intrusive::detail::enable_if_c; + using boost::intrusive::detail::enable_if_convertible; using boost::intrusive::detail::equal_to_value; + using boost::intrusive::detail::eval_if; + using boost::intrusive::detail::eval_if_c; using boost::intrusive::detail::exception_disposer; + using boost::intrusive::detail::false_; + using boost::intrusive::detail::false_type; using boost::intrusive::detail::fast_log2; using boost::intrusive::detail::floor_log2; using boost::intrusive::detail::get_base_value_traits; @@ -420,20 +444,35 @@ export namespace boost { namespace intrusive { namespace detail { using boost::intrusive::detail::hash_mix_impl; using boost::intrusive::detail::hash_value; using boost::intrusive::detail::hash_value_dispatch; + using boost::intrusive::detail::identity; + using boost::intrusive::detail::if_; + using boost::intrusive::detail::if_c; using boost::intrusive::detail::init_disposer; + using boost::intrusive::detail::integral_constant; using boost::intrusive::detail::internal_any_hook_bool; using boost::intrusive::detail::internal_any_hook_bool_is_true; using boost::intrusive::detail::internal_base_hook_bool; using boost::intrusive::detail::internal_base_hook_bool_is_true; using boost::intrusive::detail::internal_hash_functor; using boost::intrusive::detail::internal_member_value_traits; + using boost::intrusive::detail::is_const; + using boost::intrusive::detail::is_convertible; + using boost::intrusive::detail::is_empty; + using boost::intrusive::detail::is_enum; + using boost::intrusive::detail::is_floating_point; + using boost::intrusive::detail::is_integral; using boost::intrusive::detail::is_pow2; + using boost::intrusive::detail::is_same; + using boost::intrusive::detail::is_scalar; using boost::intrusive::detail::is_stateful_value_traits; + using boost::intrusive::detail::is_unsigned; using boost::intrusive::detail::key_nodeptr_comp; using boost::intrusive::detail::key_nodeptr_comp_types; using boost::intrusive::detail::link_dispatch; using boost::intrusive::detail::ls_zeros; + using boost::intrusive::detail::make_unsigned; using boost::intrusive::detail::max_align; + using boost::intrusive::detail::no_type; using boost::intrusive::detail::node_cloner; using boost::intrusive::detail::node_disposer; using boost::intrusive::detail::node_to_value; @@ -446,6 +485,10 @@ export namespace boost { namespace intrusive { namespace detail { using boost::intrusive::detail::parent_from_member; using boost::intrusive::detail::previous_or_equal_pow2; using boost::intrusive::detail::rbtree_node_checker; + using boost::intrusive::detail::remove_const; + using boost::intrusive::detail::remove_cv; + using boost::intrusive::detail::remove_pointer; + using boost::intrusive::detail::remove_reference; using boost::intrusive::detail::select_constptr; using boost::intrusive::detail::size_holder; using boost::intrusive::detail::splaydown_assemble_and_fix_header; @@ -457,7 +500,12 @@ export namespace boost { namespace intrusive { namespace detail { using boost::intrusive::detail::supposed_value_traits; using boost::intrusive::detail::transform_iterator; using boost::intrusive::detail::treap_node_extra_checker; + using boost::intrusive::detail::true_; + using boost::intrusive::detail::true_type; using boost::intrusive::detail::uncast_types; + using boost::intrusive::detail::unvoid_ref; + using boost::intrusive::detail::voider; + using boost::intrusive::detail::yes_type; }}} export namespace boost { namespace intrusive { namespace function_detector { @@ -479,57 +527,3 @@ export namespace boost { namespace iterators { export namespace boost { namespace iterators { namespace detail { using boost::iterators::detail::iterator_category_with_traversal; }}} - -export namespace boost { namespace move_detail { - using boost::move_detail::add_const; - using boost::move_detail::add_const_if_c; - using boost::move_detail::add_pointer; - using boost::move_detail::add_reference; - using boost::move_detail::addressof; - using boost::move_detail::alignment_of; - using boost::move_detail::apply; - using boost::move_detail::bool_; - using boost::move_detail::disable_if; - using boost::move_detail::disable_if_c; - using boost::move_detail::disable_if_convertible; - using boost::move_detail::enable_if; - using boost::move_detail::enable_if_c; - using boost::move_detail::enable_if_convertible; - using boost::move_detail::eval_if; - using boost::move_detail::eval_if_c; - using boost::move_detail::false_; - using boost::move_detail::false_type; - using boost::move_detail::identity; - using boost::move_detail::if_; - using boost::move_detail::if_c; - using boost::move_detail::integral_constant; - using boost::move_detail::is_const; - using boost::move_detail::is_convertible; - using boost::move_detail::is_empty; - using boost::move_detail::is_enum; - using boost::move_detail::is_floating_point; - using boost::move_detail::is_integral; - using boost::move_detail::is_same; - using boost::move_detail::is_scalar; - using boost::move_detail::is_unsigned; - using boost::move_detail::make_unsigned; - using boost::move_detail::no_type; - using boost::move_detail::remove_const; - using boost::move_detail::remove_cv; - using boost::move_detail::remove_pointer; - using boost::move_detail::remove_reference; - using boost::move_detail::true_; - using boost::move_detail::true_type; - using boost::move_detail::unvoid_ref; - using boost::move_detail::voider; - using boost::move_detail::yes_type; -}} - -export namespace boost { namespace movelib { - using boost::movelib::iter_category; - using boost::movelib::iter_difference; - using boost::movelib::iter_size; - using boost::movelib::iter_value; - using boost::movelib::make_reverse_iterator; - using boost::movelib::reverse_iterator; -}} diff --git a/generated/exports/iostreams.deps b/generated/exports/iostreams.deps index 472391dc3..c2cb4fb83 100644 --- a/generated/exports/iostreams.deps +++ b/generated/exports/iostreams.deps @@ -1,7 +1,7 @@ mcpplibs.mwrap.boost.assert +mcpplibs.mwrap.boost.concept_check mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core -mcpplibs.mwrap.boost.iterator mcpplibs.mwrap.boost.random mcpplibs.mwrap.boost.range mcpplibs.mwrap.boost.smart_ptr diff --git a/generated/exports/iostreams.inc b/generated/exports/iostreams.inc index 7acc504f0..4969dbb04 100644 --- a/generated/exports/iostreams.inc +++ b/generated/exports/iostreams.inc @@ -1,10 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=iostreams boost=1.92.0 target=x86_64-w64-mingw32 entities=439 - -export namespace boost { - using boost::iterator_range; - using boost::shared_ptr; -} +// lib=iostreams boost=1.92.0 target=x86_64-w64-mingw32 entities=437 export namespace boost { namespace iostreams { using boost::iostreams::access_control; @@ -272,9 +267,9 @@ export namespace boost { namespace iostreams { namespace detail { #if defined(BOOST_IOSTREAMS_NO_PRIMARY_CODECVT_DEFINITION) || \ defined(BOOST_IOSTREAMS_EMPTY_PRIMARY_CODECVT_DEFINITION) || \ defined(BOOST_IOSTREAMS_NO_LOCALE) - // M11 platform guard: detail/codecvt_helper.hpp declares codecvt_impl only - // on these std::codecvt workaround paths (libstdc++ mingw snapshot); the - // MSVC STL takes none of them. + // M11 platform guard: detail/codecvt_helper.hpp declares codecvt_impl only on + // these std::codecvt workaround paths (libstdc++ mingw snapshot); the MSVC STL + // takes none of them. using boost::iostreams::detail::codecvt_impl; #endif using boost::iostreams::detail::codecvt_intern; diff --git a/generated/exports/iterator.inc b/generated/exports/iterator.inc index 678f0b488..67f3376f1 100644 --- a/generated/exports/iterator.inc +++ b/generated/exports/iterator.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=iterator boost=1.92.0 target=x86_64-w64-mingw32 entities=979 +// lib=iterator boost=1.92.0 target=x86_64-w64-mingw32 entities=968 export namespace boost { using boost::access_archetype; @@ -264,7 +264,6 @@ export namespace boost { using boost::unary_predicate_archetype; using boost::undefined; using boost::unit_steppable; - using boost::use_default; using boost::void_generator_archetype; using boost::writable_iterator_test; using boost::writable_iterator_traversal_test; @@ -768,6 +767,7 @@ export namespace boost { namespace iterators { using boost::iterators::traversal_archetype_base; using boost::iterators::trivial_iterator_test; using boost::iterators::undefined; + using boost::iterators::use_default; using boost::iterators::zip_iterator; }} @@ -890,13 +890,9 @@ export namespace boost { namespace iterators { namespace distance_adl_barrier { }}} export namespace boost { namespace mpl { - using boost::mpl::advance; using boost::mpl::at; using boost::mpl::at_c; - using boost::mpl::at_impl; using boost::mpl::back; - using boost::mpl::back_impl; - using boost::mpl::distance; using boost::mpl::empty_base; using boost::mpl::equal_to; using boost::mpl::equal_to_impl; @@ -914,23 +910,13 @@ export namespace boost { namespace mpl { using boost::mpl::inherit4; using boost::mpl::inherit5; using boost::mpl::is_empty_base; - using boost::mpl::lambda; using boost::mpl::minus; using boost::mpl::minus_impl; using boost::mpl::minus_tag; - using boost::mpl::next; using boost::mpl::pop_back; using boost::mpl::pop_back_impl; - using boost::mpl::pop_front; - using boost::mpl::pop_front_impl; - using boost::mpl::prior; - using boost::mpl::sequence_tag; }} -export namespace boost { namespace mpl { namespace aux { - using boost::mpl::aux::template_arity; -}}} - export namespace boost { namespace operators_impl { using boost::operators_impl::addable; using boost::operators_impl::addable1; diff --git a/generated/exports/json.inc b/generated/exports/json.inc index 4f8de60ab..88084674d 100644 --- a/generated/exports/json.inc +++ b/generated/exports/json.inc @@ -1,9 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=json boost=1.92.0 target=x86_64-w64-mingw32 entities=309 - -export namespace boost { namespace container { namespace pmr { - using boost::container::pmr::polymorphic_allocator; -}}} +// lib=json boost=1.92.0 target=x86_64-w64-mingw32 entities=306 export namespace boost { namespace container_hash { using boost::container_hash::is_unordered_range; @@ -337,11 +333,3 @@ export namespace boost { namespace json { namespace detail { namespace charconv export namespace boost { namespace json { namespace detail_pilfer { using boost::json::detail_pilfer::not_pilfered; }}} - -export namespace boost { namespace system { - using boost::system::result; -}} - -export namespace boost { namespace variant2 { - using boost::variant2::variant; -}} diff --git a/generated/exports/lambda.inc b/generated/exports/lambda.inc index cdbd33f85..9762954ff 100644 --- a/generated/exports/lambda.inc +++ b/generated/exports/lambda.inc @@ -1,9 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=lambda boost=1.92.0 target=x86_64-w64-mingw32 entities=361 - -export namespace boost { - using boost::tr1_result_of; -} +// lib=lambda boost=1.92.0 target=x86_64-w64-mingw32 entities=360 export namespace boost { namespace lambda { using boost::lambda::_1; @@ -345,9 +341,8 @@ export namespace boost { namespace lambda { namespace ll { using boost::lambda::ll::prev_permutation; using boost::lambda::ll::push_heap; #if !defined(BOOST_NO_CXX98_RANDOM_SHUFFLE) - // C4 flavor guard: random_shuffle is the - // !BOOST_NO_CXX98_RANDOM_SHUFFLE branch of algorithm.hpp - // (MSVC STL/libc++ under C++17 removed std::random_shuffle). + // C4 flavor guard: random_shuffle is the !BOOST_NO_CXX98_RANDOM_SHUFFLE branch + // of algorithm.hpp (MSVC STL/libc++ under C++17 removed std::random_shuffle). using boost::lambda::ll::random_shuffle; #endif using boost::lambda::ll::remove; diff --git a/generated/exports/leaf.inc b/generated/exports/leaf.inc index 3dbe91ddf..7eb49d82f 100644 --- a/generated/exports/leaf.inc +++ b/generated/exports/leaf.inc @@ -57,6 +57,13 @@ export namespace boost { namespace leaf { }} export namespace boost { namespace leaf { namespace detail { + // M9: gcc 16.1.0 module consumers emit a partial vtable for + // exception (multi-base exception_base/error_id) whose non-virtual + // thunks stay undefined — gcc never emits them in a module consumer TU. This + // extern template suppresses the consumer's implicit instantiation; the + // complete vtable + thunks come from the explicit instantiation in + // port/leaf_extras.cpp (same pattern as thread's clone_impl, cf. M7c). + extern template class boost::leaf::detail::exception; using boost::leaf::detail::accumulating_item; using boost::leaf::detail::at_least_one_derives_from_std_exception; using boost::leaf::detail::atomic_unsigned_int; @@ -97,14 +104,6 @@ export namespace boost { namespace leaf { namespace detail { using boost::leaf::detail::encoder_adaptor; using boost::leaf::detail::enforce_std_exception; using boost::leaf::detail::exception; - // M9: gcc 16.1.0 module consumers emit a partial vtable for - // exception (multi-base exception_base/error_id) whose - // non-virtual thunks stay undefined — gcc never emits them in a module - // consumer TU. This extern template suppresses the consumer's implicit - // instantiation; the complete vtable + thunks come from the explicit - // instantiation in port/leaf_extras.cpp (same pattern as thread's - // clone_impl, cf. M7c). - extern template class boost::leaf::detail::exception; using boost::leaf::detail::exception_base; using boost::leaf::detail::find_in_tuple; using boost::leaf::detail::fn_arg_type; diff --git a/generated/exports/lockfree.inc b/generated/exports/lockfree.inc index 314531e40..52f1e7c47 100644 --- a/generated/exports/lockfree.inc +++ b/generated/exports/lockfree.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=lockfree boost=1.92.0 target=x86_64-w64-mingw32 entities=67 +// lib=lockfree boost=1.92.0 target=x86_64-w64-mingw32 entities=65 export namespace boost { namespace lockfree { using boost::lockfree::allocator; @@ -74,8 +74,3 @@ export namespace boost { namespace lockfree { namespace tag { using boost::lockfree::tag::single_consumer; using boost::lockfree::tag::single_producer; }}} - -export namespace boost { namespace parameter { - using boost::parameter::optional; - using boost::parameter::parameters; -}} diff --git a/generated/exports/math.inc b/generated/exports/math.inc index e57c4599a..1190b6c16 100644 --- a/generated/exports/math.inc +++ b/generated/exports/math.inc @@ -6,21 +6,24 @@ export namespace boost { using boost::float64_t; #if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 // M11 platform guard: cstdfloat_types.hpp declares the 80-bit long-double - // typedefs only where long double really is 80-bit; MSVC long double is 53-bit. + // typedefs only where long double really is 80-bit; MSVC long double is + // 53-bit. using boost::float80_t; #endif using boost::float_fast32_t; using boost::float_fast64_t; #if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 // M11 platform guard: cstdfloat_types.hpp declares the 80-bit long-double - // typedefs only where long double really is 80-bit; MSVC long double is 53-bit. + // typedefs only where long double really is 80-bit; MSVC long double is + // 53-bit. using boost::float_fast80_t; #endif using boost::float_least32_t; using boost::float_least64_t; #if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 // M11 platform guard: cstdfloat_types.hpp declares the 80-bit long-double - // typedefs only where long double really is 80-bit; MSVC long double is 53-bit. + // typedefs only where long double really is 80-bit; MSVC long double is + // 53-bit. using boost::float_least80_t; #endif using boost::floatmax_t; @@ -28,20 +31,8 @@ export namespace boost { export namespace boost { namespace integer { using boost::integer::gcd; - using boost::integer::gcd_evaluator; - using boost::integer::gcd_range; - using boost::integer::lcm; - using boost::integer::lcm_evaluator; - using boost::integer::lcm_range; - using boost::integer::static_gcd; - using boost::integer::static_gcd_type; - using boost::integer::static_lcm; }} -export namespace boost { namespace integer { namespace gcd_detail { - using boost::integer::gcd_detail::gcd_traits; -}}} - export namespace boost { namespace math { using boost::math::_IMAGINARY_jacobi_theta1tau; using boost::math::_IMAGINARY_jacobi_theta2tau; @@ -178,6 +169,9 @@ export namespace boost { namespace math { using boost::math::gamma_q; using boost::math::gamma_q_inv; using boost::math::gamma_q_inva; + using boost::math::gcd; + using boost::math::gcd_evaluator; + using boost::math::gcd_range; using boost::math::gegenbauer; using boost::math::gegenbauer_derivative; using boost::math::gegenbauer_prime; @@ -343,6 +337,9 @@ export namespace boost { namespace math { using boost::math::landau_distribution; using boost::math::laplace; using boost::math::laplace_distribution; + using boost::math::lcm; + using boost::math::lcm_evaluator; + using boost::math::lcm_range; using boost::math::lconvert; using boost::math::legendre_next; using boost::math::legendre_p; @@ -461,6 +458,9 @@ export namespace boost { namespace math { using boost::math::spherical_harmonic_r; using boost::math::sqrt1pm1; using boost::math::standard_deviation; + using boost::math::static_gcd; + using boost::math::static_gcd_type; + using boost::math::static_lcm; using boost::math::students_t; using boost::math::students_t_distribution; using boost::math::sup; @@ -2362,16 +2362,16 @@ export namespace boost { namespace math { namespace statistics { export namespace boost { namespace math { namespace statistics { namespace detail { #if defined(BOOST_MATH_EXEC_COMPATIBLE) - // M11 CI platform guard: statistics chatterjee_correlation_par_impl is defined only under - // BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / + // M11 CI platform guard: statistics chatterjee_correlation_par_impl is defined + // only under BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / // bivariate_statistics.hpp); libc++ lacks __cpp_lib_execution. using boost::math::statistics::detail::chatterjee_correlation_par_impl; #endif using boost::math::statistics::detail::chatterjee_correlation_seq_impl; using boost::math::statistics::detail::chatterjee_transform; #if defined(BOOST_MATH_EXEC_COMPATIBLE) - // M11 CI platform guard: statistics correlation_coefficient_parallel_impl is defined only under - // BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / + // M11 CI platform guard: statistics correlation_coefficient_parallel_impl is + // defined only under BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / // bivariate_statistics.hpp); libc++ lacks __cpp_lib_execution. using boost::math::statistics::detail::correlation_coefficient_parallel_impl; #endif @@ -2383,8 +2383,8 @@ export namespace boost { namespace math { namespace statistics { namespace detai using boost::math::statistics::detail::gini_range_fraction; using boost::math::statistics::detail::mean_sequential_impl; #if defined(BOOST_MATH_EXEC_COMPATIBLE) - // M11 CI platform guard: statistics means_and_covariance_parallel_impl is defined only under - // BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / + // M11 CI platform guard: statistics means_and_covariance_parallel_impl is + // defined only under BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / // bivariate_statistics.hpp); libc++ lacks __cpp_lib_execution. using boost::math::statistics::detail::means_and_covariance_parallel_impl; #endif diff --git a/generated/exports/mp11.inc b/generated/exports/mp11.inc index 530fee2d1..271fac939 100644 --- a/generated/exports/mp11.inc +++ b/generated/exports/mp11.inc @@ -452,7 +452,8 @@ export namespace boost { namespace mp11 { namespace detail { using boost::mp11::detail::mp_void_impl; using boost::mp11::detail::mp_with_index_impl_; #if !defined(__GNUC__) - // M3 hand-guard: mp_map_find.hpp (gcc bug 120161 workaround) defines mpmf_* only outside gcc. + // M3 hand-guard: mp_map_find.hpp (gcc bug 120161 workaround) defines mpmf_* + // only outside gcc. using boost::mp11::detail::mpmf_unwrap; using boost::mp11::detail::mpmf_wrap; #endif diff --git a/generated/exports/mqtt5.deps b/generated/exports/mqtt5.deps index 7ba2781f7..955c06a18 100644 --- a/generated/exports/mqtt5.deps +++ b/generated/exports/mqtt5.deps @@ -7,3 +7,5 @@ mcpplibs.mwrap.boost.random mcpplibs.mwrap.boost.smart_ptr mcpplibs.mwrap.boost.static_string mcpplibs.mwrap.boost.system +mcpplibs.mwrap.boost.type_traits +mcpplibs.mwrap.boost.utility diff --git a/generated/exports/mqtt5.inc b/generated/exports/mqtt5.inc index e4e08f256..fbb0f26c4 100644 --- a/generated/exports/mqtt5.inc +++ b/generated/exports/mqtt5.inc @@ -1,29 +1,10 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=mqtt5 boost=1.92.0 target=x86_64-w64-mingw32 entities=335 - -export namespace boost { namespace asio { - using boost::asio::any_completion_handler; - using boost::asio::any_completion_handler_allocator; - using boost::asio::recycling_allocator; -}} - -export namespace boost { namespace asio { namespace ip { - using boost::asio::ip::basic_resolver; - using boost::asio::ip::basic_resolver_results; -}}} +// lib=mqtt5 boost=1.92.0 target=x86_64-w64-mingw32 entities=327 export namespace boost { namespace asio { namespace ssl { using boost::asio::ssl::stream; }}} -export namespace boost { namespace beast { namespace websocket { - using boost::beast::websocket::stream; -}}} - -export namespace boost { namespace container { - using boost::container::small_vector; -}} - export namespace boost { namespace mqtt5 { using boost::mqtt5::assign_tls_sni; using boost::mqtt5::at_connack_sig; @@ -388,7 +369,3 @@ export namespace boost { namespace mqtt5 { namespace reason_codes { export namespace boost { namespace mqtt5 { namespace reason_codes { namespace detail { using boost::mqtt5::reason_codes::detail::valid_codes; }}}} - -export namespace boost { namespace random { - using boost::random::uniform_smallint; -}} diff --git a/generated/exports/multi_array.inc b/generated/exports/multi_array.inc index 5934077c7..bc0568086 100644 --- a/generated/exports/multi_array.inc +++ b/generated/exports/multi_array.inc @@ -1,8 +1,7 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=multi_array boost=1.92.0 target=x86_64-w64-mingw32 entities=53 +// lib=multi_array boost=1.92.0 target=x86_64-w64-mingw32 entities=55 export namespace boost { - using boost::CollectionConcept; using boost::array_view_gen; using boost::c_storage_order; using boost::const_array_view_gen; @@ -18,6 +17,9 @@ export namespace boost { } export namespace boost { namespace detail { namespace multi_array { + using boost::detail::multi_array::CollectionConcept; + using boost::detail::multi_array::ConstMultiArrayConcept; + using boost::detail::multi_array::MutableMultiArrayConcept; using boost::detail::multi_array::array_iterator; using boost::detail::multi_array::associated_types; using boost::detail::multi_array::choose_range_list_n; diff --git a/generated/exports/multi_index.inc b/generated/exports/multi_index.inc index 6015d0dab..752c1bed7 100644 --- a/generated/exports/multi_index.inc +++ b/generated/exports/multi_index.inc @@ -1,8 +1,8 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=multi_index boost=1.92.0 target=x86_64-w64-mingw32 entities=275 +// lib=multi_index boost=1.92.0 target=x86_64-w64-mingw32 entities=274 export namespace boost { - using boost::hash; + using boost::get; using boost::multi_index_container; using boost::project; } @@ -292,7 +292,3 @@ export namespace boost { namespace multi_index { namespace safe_mode { using boost::multi_index::safe_mode::error_code::same_container; using boost::multi_index::safe_mode::error_code::unequal_allocators; }}} - -export namespace boost { namespace serialization { - using boost::serialization::version; -}} diff --git a/generated/exports/multiprecision.deps b/generated/exports/multiprecision.deps index 0cebdf8fe..12d7b8746 100644 --- a/generated/exports/multiprecision.deps +++ b/generated/exports/multiprecision.deps @@ -1,3 +1,4 @@ mcpplibs.mwrap.boost.assert +mcpplibs.mwrap.boost.io mcpplibs.mwrap.boost.math mcpplibs.mwrap.boost.random diff --git a/generated/exports/multiprecision.inc b/generated/exports/multiprecision.inc index 10d1c3e67..21e61bada 100644 --- a/generated/exports/multiprecision.inc +++ b/generated/exports/multiprecision.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=multiprecision boost=1.92.0 target=x86_64-w64-mingw32 entities=1239 +// lib=multiprecision boost=1.92.0 target=x86_64-w64-mingw32 entities=890 export namespace boost { using boost::denominator; @@ -14,7 +14,23 @@ export namespace boost { namespace archive { using boost::archive::binary_oarchive; }} +export namespace boost { namespace integer { + using boost::integer::gcd; + using boost::integer::lcm; +}} + export namespace boost { namespace math { + using boost::math::changesign; + using boost::math::copysign; + using boost::math::fpclassify; + using boost::math::gcd; + using boost::math::isfinite; + using boost::math::isinf; + using boost::math::isnan; + using boost::math::isnormal; + using boost::math::lcm; + using boost::math::sign; + using boost::math::signbit; using boost::math::sinc_pi; using boost::math::sinhc_pi; }} @@ -28,14 +44,7 @@ export namespace boost { namespace math { namespace detail { using boost::math::detail::sinhc_pi_imp; }}} -export namespace boost { namespace math { namespace policies { - using boost::math::policies::policy; - using boost::math::policies::precision; -}}} - export namespace boost { namespace math { namespace tools { - using boost::math::tools::is_complex_type; - using boost::math::tools::promote_arg; using boost::math::tools::real_cast; }}} @@ -71,6 +80,7 @@ export namespace boost { namespace multiprecision { using boost::multiprecision::checked_uint256_t; using boost::multiprecision::checked_uint512_t; using boost::multiprecision::complex128; + using boost::multiprecision::complex_adaptor; using boost::multiprecision::complex_result_from_scalar; using boost::multiprecision::component_type; using boost::multiprecision::conj; @@ -94,6 +104,7 @@ export namespace boost { namespace multiprecision { using boost::multiprecision::cpp_complex_oct; using boost::multiprecision::cpp_complex_quad; using boost::multiprecision::cpp_complex_single; + using boost::multiprecision::cpp_dec_float; using boost::multiprecision::cpp_dec_float_100; using boost::multiprecision::cpp_dec_float_50; using boost::multiprecision::cpp_double_double; @@ -101,6 +112,7 @@ export namespace boost { namespace multiprecision { using boost::multiprecision::cpp_double_fp_backend; using boost::multiprecision::cpp_double_long_double; using boost::multiprecision::cpp_int; + using boost::multiprecision::cpp_int_backend; using boost::multiprecision::cpp_int_check_type; using boost::multiprecision::cpp_int_check_type::checked; using boost::multiprecision::cpp_int_check_type::unchecked; @@ -111,8 +123,11 @@ export namespace boost { namespace multiprecision { using boost::multiprecision::cpp_integer_type::unsigned_packed; using boost::multiprecision::cpp_rational; using boost::multiprecision::cpp_rational_backend; + using boost::multiprecision::debug_adaptor; using boost::multiprecision::debug_adaptor_t; using boost::multiprecision::denominator; + using boost::multiprecision::digit_base_10; + using boost::multiprecision::digit_base_2; using boost::multiprecision::divide_qr; using boost::multiprecision::double_limb_type; using boost::multiprecision::erf; @@ -128,6 +143,7 @@ export namespace boost { namespace multiprecision { using boost::multiprecision::fabs; using boost::multiprecision::fdim; using boost::multiprecision::float128; + using boost::multiprecision::float128_backend; using boost::multiprecision::floor; using boost::multiprecision::fma; using boost::multiprecision::fmax; @@ -136,6 +152,9 @@ export namespace boost { namespace multiprecision { using boost::multiprecision::fpclassify; using boost::multiprecision::frexp; using boost::multiprecision::gcd; + using boost::multiprecision::gmp_float; + using boost::multiprecision::gmp_int; + using boost::multiprecision::gmp_rational; using boost::multiprecision::hash_value; using boost::multiprecision::hypot; using boost::multiprecision::ilogb; @@ -186,6 +205,7 @@ export namespace boost { namespace multiprecision { using boost::multiprecision::log_postfix_event; using boost::multiprecision::log_prefix_event; using boost::multiprecision::logb; + using boost::multiprecision::logged_adaptor; using boost::multiprecision::logged_adaptor_t; using boost::multiprecision::lrint; using boost::multiprecision::lround; @@ -201,6 +221,7 @@ export namespace boost { namespace multiprecision { using boost::multiprecision::mpc_complex_1000; using boost::multiprecision::mpc_complex_50; using boost::multiprecision::mpc_complex_500; + using boost::multiprecision::mpc_complex_backend; using boost::multiprecision::mpf_float; using boost::multiprecision::mpf_float_100; using boost::multiprecision::mpf_float_1000; @@ -211,6 +232,7 @@ export namespace boost { namespace multiprecision { using boost::multiprecision::mpfi_float_1000; using boost::multiprecision::mpfi_float_50; using boost::multiprecision::mpfi_float_500; + using boost::multiprecision::mpfi_float_backend; using boost::multiprecision::mpfr_allocation_type; using boost::multiprecision::mpfr_allocation_type::allocate_dynamic; using boost::multiprecision::mpfr_allocation_type::allocate_stack; @@ -219,6 +241,7 @@ export namespace boost { namespace multiprecision { using boost::multiprecision::mpfr_float_1000; using boost::multiprecision::mpfr_float_50; using boost::multiprecision::mpfr_float_500; + using boost::multiprecision::mpfr_float_backend; using boost::multiprecision::mpq_rational; using boost::multiprecision::mpz_int; using boost::multiprecision::msb; @@ -259,6 +282,7 @@ export namespace boost { namespace multiprecision { using boost::multiprecision::pow; using boost::multiprecision::powm; using boost::multiprecision::proj; + using boost::multiprecision::rational_adaptor; using boost::multiprecision::real; using boost::multiprecision::remainder; using boost::multiprecision::remquo; @@ -284,6 +308,7 @@ export namespace boost { namespace multiprecision { using boost::multiprecision::to_string; using boost::multiprecision::tom_int; using boost::multiprecision::tom_rational; + using boost::multiprecision::tommath_int; using boost::multiprecision::tommath_rational; using boost::multiprecision::trunc; using boost::multiprecision::uint1024_t; @@ -704,10 +729,10 @@ export namespace boost { namespace multiprecision { namespace detail { using boost::multiprecision::detail::abs_funct; using boost::multiprecision::detail::add_immediates; #if defined(BOOST_MP_HAS_IMMINTRIN_H) - // M11 platform guard: cpp_int/intel_intrinsics.hpp declares addcarry_limb - // only under BOOST_MP_HAS_IMMINTRIN_H (the adc intrinsics dispatch — clang on - // macOS arm64 unsets the macro because __builtin_ia32_addcarryx_u64 is a - // gcc-only builtin and BOOST_GCC is not defined). + // M11 platform guard: cpp_int/intel_intrinsics.hpp declares addcarry_limb only + // under BOOST_MP_HAS_IMMINTRIN_H (the adc intrinsics dispatch — clang on macOS + // arm64 unsets the macro because __builtin_ia32_addcarryx_u64 is a gcc-only + // builtin and BOOST_GCC is not defined). using boost::multiprecision::detail::addcarry_limb; #endif using boost::multiprecision::detail::arg_type; @@ -914,10 +939,6 @@ export namespace boost { namespace multiprecision { namespace detail { using boost::multiprecision::detail::terminal; using boost::multiprecision::detail::transcendental_reduction_type; using boost::multiprecision::detail::uint_t; - // M12: unmentionable dropped — no external linkage (multiprecision detail - // placeholder); gcc refuses the export. - // M12: unmentionable_type dropped — no external linkage (multiprecision detail - // placeholder); gcc refuses the export. using boost::multiprecision::detail::unsigned_abs; using boost::multiprecision::detail::use_empty_value_base; }}} @@ -977,393 +998,6 @@ export namespace boost { namespace serialization { }} export namespace boost { namespace serialization { namespace cpp_int_detail { - using boost::serialization::cpp_int_detail::abs; - using boost::serialization::cpp_int_detail::acos; - using boost::serialization::cpp_int_detail::acosh; - using boost::serialization::cpp_int_detail::add; - using boost::serialization::cpp_int_detail::add_unsigned; - using boost::serialization::cpp_int_detail::add_unsigned_constexpr; - using boost::serialization::cpp_int_detail::arg; - using boost::serialization::cpp_int_detail::asin; - using boost::serialization::cpp_int_detail::asinh; - using boost::serialization::cpp_int_detail::assign_components; - using boost::serialization::cpp_int_detail::atan; - using boost::serialization::cpp_int_detail::atan2; - using boost::serialization::cpp_int_detail::atanh; - using boost::serialization::cpp_int_detail::bit_and; - using boost::serialization::cpp_int_detail::bit_flip; - using boost::serialization::cpp_int_detail::bit_or; - using boost::serialization::cpp_int_detail::bit_set; - using boost::serialization::cpp_int_detail::bit_test; - using boost::serialization::cpp_int_detail::bit_unset; - using boost::serialization::cpp_int_detail::bit_xor; - using boost::serialization::cpp_int_detail::bitwise_op; - using boost::serialization::cpp_int_detail::block_multiplier; - using boost::serialization::cpp_int_detail::c99_error_policy; - using boost::serialization::cpp_int_detail::cbrt; - using boost::serialization::cpp_int_detail::ceil; - using boost::serialization::cpp_int_detail::changesign; - using boost::serialization::cpp_int_detail::check_in_range; - using boost::serialization::cpp_int_detail::check_is_negative; - using boost::serialization::cpp_int_detail::checked_cpp_int; - using boost::serialization::cpp_int_detail::checked_cpp_rational; - using boost::serialization::cpp_int_detail::checked_cpp_rational_backend; - using boost::serialization::cpp_int_detail::checked_int1024_t; - using boost::serialization::cpp_int_detail::checked_int128_t; - using boost::serialization::cpp_int_detail::checked_int256_t; - using boost::serialization::cpp_int_detail::checked_int512_t; - using boost::serialization::cpp_int_detail::checked_uint1024_t; - using boost::serialization::cpp_int_detail::checked_uint128_t; - using boost::serialization::cpp_int_detail::checked_uint256_t; - using boost::serialization::cpp_int_detail::checked_uint512_t; - using boost::serialization::cpp_int_detail::complex128; - using boost::serialization::cpp_int_detail::complex_adaptor; - using boost::serialization::cpp_int_detail::complex_result_from_scalar; - using boost::serialization::cpp_int_detail::component_type; - using boost::serialization::cpp_int_detail::conj; - using boost::serialization::cpp_int_detail::conversion_overflow; - using boost::serialization::cpp_int_detail::convert_to_signed_int; - using boost::serialization::cpp_int_detail::convert_to_unsigned_int; - using boost::serialization::cpp_int_detail::copy_and_round; - using boost::serialization::cpp_int_detail::copysign; - using boost::serialization::cpp_int_detail::cos; - using boost::serialization::cpp_int_detail::cosh; - using boost::serialization::cpp_int_detail::cpp_bin_float; - using boost::serialization::cpp_int_detail::cpp_bin_float_100; - using boost::serialization::cpp_int_detail::cpp_bin_float_50; - using boost::serialization::cpp_int_detail::cpp_bin_float_double; - using boost::serialization::cpp_int_detail::cpp_bin_float_double_extended; - using boost::serialization::cpp_int_detail::cpp_bin_float_oct; - using boost::serialization::cpp_int_detail::cpp_bin_float_quad; - using boost::serialization::cpp_int_detail::cpp_bin_float_single; - using boost::serialization::cpp_int_detail::cpp_complex; - using boost::serialization::cpp_int_detail::cpp_complex_100; - using boost::serialization::cpp_int_detail::cpp_complex_50; - using boost::serialization::cpp_int_detail::cpp_complex_backend; - using boost::serialization::cpp_int_detail::cpp_complex_double; - using boost::serialization::cpp_int_detail::cpp_complex_extended; - using boost::serialization::cpp_int_detail::cpp_complex_oct; - using boost::serialization::cpp_int_detail::cpp_complex_quad; - using boost::serialization::cpp_int_detail::cpp_complex_single; - using boost::serialization::cpp_int_detail::cpp_dec_float; - using boost::serialization::cpp_int_detail::cpp_dec_float_100; - using boost::serialization::cpp_int_detail::cpp_dec_float_50; - using boost::serialization::cpp_int_detail::cpp_double_double; - using boost::serialization::cpp_int_detail::cpp_double_float; - using boost::serialization::cpp_int_detail::cpp_double_fp_backend; - using boost::serialization::cpp_int_detail::cpp_double_long_double; - using boost::serialization::cpp_int_detail::cpp_int; - using boost::serialization::cpp_int_detail::cpp_int_backend; - using boost::serialization::cpp_int_detail::cpp_int_base; - using boost::serialization::cpp_int_detail::cpp_int_check_type; - using boost::serialization::cpp_int_detail::cpp_integer_type; - using boost::serialization::cpp_int_detail::cpp_rational; - using boost::serialization::cpp_int_detail::cpp_rational_backend; - using boost::serialization::cpp_int_detail::debug_adaptor; - using boost::serialization::cpp_int_detail::debug_adaptor_t; - using boost::serialization::cpp_int_detail::denominator; - using boost::serialization::cpp_int_detail::digit_base_type; - using boost::serialization::cpp_int_detail::divide_qr; -#if defined(BOOST_HAS_INT128) - // M12 platform guard: serialize.hpp's `using namespace - // boost::multiprecision(::backends)` exposes the divide_subtract entity into - // cpp_int_detail — present only under BOOST_HAS_INT128. - using boost::serialization::cpp_int_detail::divide_subtract; -#endif - using boost::serialization::cpp_int_detail::divide_unsigned_helper; - using boost::serialization::cpp_int_detail::do_eval_add; - using boost::serialization::cpp_int_detail::do_eval_subtract; using boost::serialization::cpp_int_detail::do_serialize; - using boost::serialization::cpp_int_detail::double_limb_type; - using boost::serialization::cpp_int_detail::erf; - using boost::serialization::cpp_int_detail::erfc; - using boost::serialization::cpp_int_detail::eval_abs; - using boost::serialization::cpp_int_detail::eval_acos; - using boost::serialization::cpp_int_detail::eval_acosh; - using boost::serialization::cpp_int_detail::eval_add; - using boost::serialization::cpp_int_detail::eval_add_subtract_imp; - using boost::serialization::cpp_int_detail::eval_asin; - using boost::serialization::cpp_int_detail::eval_asinh; - using boost::serialization::cpp_int_detail::eval_atan; - using boost::serialization::cpp_int_detail::eval_atan2; - using boost::serialization::cpp_int_detail::eval_atanh; - using boost::serialization::cpp_int_detail::eval_bit_flip; - using boost::serialization::cpp_int_detail::eval_bit_set; - using boost::serialization::cpp_int_detail::eval_bit_test; - using boost::serialization::cpp_int_detail::eval_bit_unset; - using boost::serialization::cpp_int_detail::eval_bitwise_and; - using boost::serialization::cpp_int_detail::eval_bitwise_or; - using boost::serialization::cpp_int_detail::eval_bitwise_xor; - using boost::serialization::cpp_int_detail::eval_ceil; - using boost::serialization::cpp_int_detail::eval_complement; - using boost::serialization::cpp_int_detail::eval_conj; - using boost::serialization::cpp_int_detail::eval_convert_to; - using boost::serialization::cpp_int_detail::eval_cos; - using boost::serialization::cpp_int_detail::eval_cosh; - using boost::serialization::cpp_int_detail::eval_decrement; - using boost::serialization::cpp_int_detail::eval_divide; - using boost::serialization::cpp_int_detail::eval_eq; - using boost::serialization::cpp_int_detail::eval_exp; - using boost::serialization::cpp_int_detail::eval_exp_taylor; - using boost::serialization::cpp_int_detail::eval_fabs; - using boost::serialization::cpp_int_detail::eval_floor; - using boost::serialization::cpp_int_detail::eval_fmod; - using boost::serialization::cpp_int_detail::eval_fpclassify; - using boost::serialization::cpp_int_detail::eval_frexp; - using boost::serialization::cpp_int_detail::eval_gcd; - using boost::serialization::cpp_int_detail::eval_gcd_lehmer; - using boost::serialization::cpp_int_detail::eval_get_sign; - using boost::serialization::cpp_int_detail::eval_gt; - using boost::serialization::cpp_int_detail::eval_ilogb; - using boost::serialization::cpp_int_detail::eval_imag; - using boost::serialization::cpp_int_detail::eval_increment; - using boost::serialization::cpp_int_detail::eval_integer_modulus; - using boost::serialization::cpp_int_detail::eval_is_zero; - using boost::serialization::cpp_int_detail::eval_lcm; - using boost::serialization::cpp_int_detail::eval_ldexp; - using boost::serialization::cpp_int_detail::eval_left_shift; - using boost::serialization::cpp_int_detail::eval_log; - using boost::serialization::cpp_int_detail::eval_log10; - using boost::serialization::cpp_int_detail::eval_logb; - using boost::serialization::cpp_int_detail::eval_lsb; - using boost::serialization::cpp_int_detail::eval_lsb_imp; - using boost::serialization::cpp_int_detail::eval_lt; - using boost::serialization::cpp_int_detail::eval_modulus; - using boost::serialization::cpp_int_detail::eval_msb; - using boost::serialization::cpp_int_detail::eval_msb_imp; - using boost::serialization::cpp_int_detail::eval_multiply; - using boost::serialization::cpp_int_detail::eval_multiply_add; - using boost::serialization::cpp_int_detail::eval_multiply_comba; - using boost::serialization::cpp_int_detail::eval_multiply_imp; - using boost::serialization::cpp_int_detail::eval_multiply_subtract; - using boost::serialization::cpp_int_detail::eval_pow; - using boost::serialization::cpp_int_detail::eval_powm; - using boost::serialization::cpp_int_detail::eval_proj; - using boost::serialization::cpp_int_detail::eval_qr; - using boost::serialization::cpp_int_detail::eval_real; - using boost::serialization::cpp_int_detail::eval_right_shift; - using boost::serialization::cpp_int_detail::eval_round; - using boost::serialization::cpp_int_detail::eval_scalbn; - using boost::serialization::cpp_int_detail::eval_set_imag; - using boost::serialization::cpp_int_detail::eval_set_real; - using boost::serialization::cpp_int_detail::eval_signbit; - using boost::serialization::cpp_int_detail::eval_sin; - using boost::serialization::cpp_int_detail::eval_sinh; - using boost::serialization::cpp_int_detail::eval_sqrt; - using boost::serialization::cpp_int_detail::eval_subtract; - using boost::serialization::cpp_int_detail::eval_tan; - using boost::serialization::cpp_int_detail::eval_tanh; - using boost::serialization::cpp_int_detail::eval_trunc; - using boost::serialization::cpp_int_detail::exp; - using boost::serialization::cpp_int_detail::exp2; - using boost::serialization::cpp_int_detail::expm1; - using boost::serialization::cpp_int_detail::export_bits; - using boost::serialization::cpp_int_detail::expression_template_default; - using boost::serialization::cpp_int_detail::expression_template_option; - using boost::serialization::cpp_int_detail::extract_exponent_type; - using boost::serialization::cpp_int_detail::fabs; - using boost::serialization::cpp_int_detail::fdim; - using boost::serialization::cpp_int_detail::float128; - using boost::serialization::cpp_int_detail::float128_backend; - using boost::serialization::cpp_int_detail::floor; - using boost::serialization::cpp_int_detail::fma; - using boost::serialization::cpp_int_detail::fmax; - using boost::serialization::cpp_int_detail::fmin; - using boost::serialization::cpp_int_detail::fmod; - using boost::serialization::cpp_int_detail::fpclassify; - using boost::serialization::cpp_int_detail::frexp; - using boost::serialization::cpp_int_detail::gcd; - using boost::serialization::cpp_int_detail::gmp_float; - using boost::serialization::cpp_int_detail::gmp_int; - using boost::serialization::cpp_int_detail::gmp_rational; - using boost::serialization::cpp_int_detail::hash_value; - using boost::serialization::cpp_int_detail::hypot; - using boost::serialization::cpp_int_detail::ilogb; - using boost::serialization::cpp_int_detail::imag; - using boost::serialization::cpp_int_detail::import_bits; - using boost::serialization::cpp_int_detail::int1024_t; - using boost::serialization::cpp_int_detail::int128_t; -#if defined(BOOST_HAS_INT128) - // M12 platform guard: serialize.hpp's `using namespace - // boost::multiprecision(::backends)` exposes the int128_type entity into - // cpp_int_detail — present only under BOOST_HAS_INT128. - using boost::serialization::cpp_int_detail::int128_type; -#endif - using boost::serialization::cpp_int_detail::int256_t; - using boost::serialization::cpp_int_detail::int512_t; - using boost::serialization::cpp_int_detail::integer_modulus; - using boost::serialization::cpp_int_detail::iround; - using boost::serialization::cpp_int_detail::is_allowed_cpp_int_base_conversion; using boost::serialization::cpp_int_detail::is_binary_archive; - using boost::serialization::cpp_int_detail::is_compatible_arithmetic_type; - using boost::serialization::cpp_int_detail::is_equivalent_number_type; - using boost::serialization::cpp_int_detail::is_et_number; - using boost::serialization::cpp_int_detail::is_fixed_precision; - using boost::serialization::cpp_int_detail::is_implicit_cpp_int_conversion; - using boost::serialization::cpp_int_detail::is_interval_number; - using boost::serialization::cpp_int_detail::is_minus_one; - using boost::serialization::cpp_int_detail::is_no_et_number; - using boost::serialization::cpp_int_detail::is_non_throwing_cpp_int; - using boost::serialization::cpp_int_detail::is_number; - using boost::serialization::cpp_int_detail::is_number_expression; - using boost::serialization::cpp_int_detail::is_signed_number; - using boost::serialization::cpp_int_detail::is_trivial_cpp_int; - using boost::serialization::cpp_int_detail::is_unsigned_number; - using boost::serialization::cpp_int_detail::is_valid_bitwise_op; - using boost::serialization::cpp_int_detail::isfinite; - using boost::serialization::cpp_int_detail::isgreater; - using boost::serialization::cpp_int_detail::isgreaterequal; - using boost::serialization::cpp_int_detail::isinf; - using boost::serialization::cpp_int_detail::isless; - using boost::serialization::cpp_int_detail::islessequal; - using boost::serialization::cpp_int_detail::islessgreater; - using boost::serialization::cpp_int_detail::isnan; - using boost::serialization::cpp_int_detail::isnormal; - using boost::serialization::cpp_int_detail::isunordered; - using boost::serialization::cpp_int_detail::itrunc; - using boost::serialization::cpp_int_detail::karatsuba_storage_size; - using boost::serialization::cpp_int_detail::lcm; - using boost::serialization::cpp_int_detail::ldexp; - using boost::serialization::cpp_int_detail::left_shift_byte; - using boost::serialization::cpp_int_detail::left_shift_generic; - using boost::serialization::cpp_int_detail::left_shift_limb; - using boost::serialization::cpp_int_detail::lgamma; - using boost::serialization::cpp_int_detail::limb_type; - using boost::serialization::cpp_int_detail::llrint; - using boost::serialization::cpp_int_detail::llround; - using boost::serialization::cpp_int_detail::lltrunc; - using boost::serialization::cpp_int_detail::log; - using boost::serialization::cpp_int_detail::log10; - using boost::serialization::cpp_int_detail::log1p; - using boost::serialization::cpp_int_detail::log2; - using boost::serialization::cpp_int_detail::log_postfix_event; - using boost::serialization::cpp_int_detail::log_prefix_event; - using boost::serialization::cpp_int_detail::logb; - using boost::serialization::cpp_int_detail::logged_adaptor; - using boost::serialization::cpp_int_detail::logged_adaptor_t; - using boost::serialization::cpp_int_detail::lrint; - using boost::serialization::cpp_int_detail::lround; - using boost::serialization::cpp_int_detail::lsb; - using boost::serialization::cpp_int_detail::ltrunc; - using boost::serialization::cpp_int_detail::max; - using boost::serialization::cpp_int_detail::max_precision; - using boost::serialization::cpp_int_detail::miller_rabin_test; - using boost::serialization::cpp_int_detail::min; - using boost::serialization::cpp_int_detail::min_precision; - using boost::serialization::cpp_int_detail::minmax; - using boost::serialization::cpp_int_detail::modf; - using boost::serialization::cpp_int_detail::mpc_complex; - using boost::serialization::cpp_int_detail::mpc_complex_100; - using boost::serialization::cpp_int_detail::mpc_complex_1000; - using boost::serialization::cpp_int_detail::mpc_complex_50; - using boost::serialization::cpp_int_detail::mpc_complex_500; - using boost::serialization::cpp_int_detail::mpc_complex_backend; - using boost::serialization::cpp_int_detail::mpf_float; - using boost::serialization::cpp_int_detail::mpf_float_100; - using boost::serialization::cpp_int_detail::mpf_float_1000; - using boost::serialization::cpp_int_detail::mpf_float_50; - using boost::serialization::cpp_int_detail::mpf_float_500; - using boost::serialization::cpp_int_detail::mpfi_float; - using boost::serialization::cpp_int_detail::mpfi_float_100; - using boost::serialization::cpp_int_detail::mpfi_float_1000; - using boost::serialization::cpp_int_detail::mpfi_float_50; - using boost::serialization::cpp_int_detail::mpfi_float_500; - using boost::serialization::cpp_int_detail::mpfi_float_backend; - using boost::serialization::cpp_int_detail::mpfr_allocation_type; - using boost::serialization::cpp_int_detail::mpfr_float; - using boost::serialization::cpp_int_detail::mpfr_float_100; - using boost::serialization::cpp_int_detail::mpfr_float_1000; - using boost::serialization::cpp_int_detail::mpfr_float_50; - using boost::serialization::cpp_int_detail::mpfr_float_500; - using boost::serialization::cpp_int_detail::mpfr_float_backend; - using boost::serialization::cpp_int_detail::mpq_rational; - using boost::serialization::cpp_int_detail::mpz_int; - using boost::serialization::cpp_int_detail::msb; - using boost::serialization::cpp_int_detail::multiply; - using boost::serialization::cpp_int_detail::multiply_karatsuba; - using boost::serialization::cpp_int_detail::nearbyint; - using boost::serialization::cpp_int_detail::negate_integer; - using boost::serialization::cpp_int_detail::nextafter; - using boost::serialization::cpp_int_detail::nexttoward; - using boost::serialization::cpp_int_detail::norm; - using boost::serialization::cpp_int_detail::number; - using boost::serialization::cpp_int_detail::number_category; - using boost::serialization::cpp_int_detail::number_category_base; - using boost::serialization::cpp_int_detail::number_category_type; - using boost::serialization::cpp_int_detail::numerator; - using boost::serialization::cpp_int_detail::numeric_limits_workaround; - using boost::serialization::cpp_int_detail::operator!=; - using boost::serialization::cpp_int_detail::operator%; - using boost::serialization::cpp_int_detail::operator&; - using boost::serialization::cpp_int_detail::operator*; - using boost::serialization::cpp_int_detail::operator+; - using boost::serialization::cpp_int_detail::operator-; - using boost::serialization::cpp_int_detail::operator/; - using boost::serialization::cpp_int_detail::operator<; - using boost::serialization::cpp_int_detail::operator<<; - using boost::serialization::cpp_int_detail::operator<=; - using boost::serialization::cpp_int_detail::operator==; - using boost::serialization::cpp_int_detail::operator>; - using boost::serialization::cpp_int_detail::operator>=; - using boost::serialization::cpp_int_detail::operator>>; - using boost::serialization::cpp_int_detail::operator^; - using boost::serialization::cpp_int_detail::operator|; - using boost::serialization::cpp_int_detail::operator~; - using boost::serialization::cpp_int_detail::polar; - using boost::serialization::cpp_int_detail::pow; - using boost::serialization::cpp_int_detail::powm; - using boost::serialization::cpp_int_detail::proj; - using boost::serialization::cpp_int_detail::rational_adaptor; - using boost::serialization::cpp_int_detail::real; - using boost::serialization::cpp_int_detail::remainder; - using boost::serialization::cpp_int_detail::remquo; - using boost::serialization::cpp_int_detail::resize_for_carry; - using boost::serialization::cpp_int_detail::right_shift_byte; - using boost::serialization::cpp_int_detail::right_shift_generic; - using boost::serialization::cpp_int_detail::right_shift_limb; - using boost::serialization::cpp_int_detail::rint; - using boost::serialization::cpp_int_detail::round; - using boost::serialization::cpp_int_detail::scalar_result_from_possible_complex; - using boost::serialization::cpp_int_detail::scalbln; - using boost::serialization::cpp_int_detail::scalbn; - using boost::serialization::cpp_int_detail::setup_karatsuba; - using boost::serialization::cpp_int_detail::sign; - using boost::serialization::cpp_int_detail::signbit; - using boost::serialization::cpp_int_detail::signed_double_limb_type; - using boost::serialization::cpp_int_detail::signed_limb_type; - using boost::serialization::cpp_int_detail::sin; - using boost::serialization::cpp_int_detail::sinh; - using boost::serialization::cpp_int_detail::sqrt; - using boost::serialization::cpp_int_detail::static_mpfr_float_100; - using boost::serialization::cpp_int_detail::static_mpfr_float_50; - using boost::serialization::cpp_int_detail::subtract; - using boost::serialization::cpp_int_detail::subtract_unsigned; - using boost::serialization::cpp_int_detail::subtract_unsigned_constexpr; - using boost::serialization::cpp_int_detail::swap; - using boost::serialization::cpp_int_detail::tan; - using boost::serialization::cpp_int_detail::tanh; - using boost::serialization::cpp_int_detail::tanh_imp; - using boost::serialization::cpp_int_detail::tgamma; - using boost::serialization::cpp_int_detail::to_string; - using boost::serialization::cpp_int_detail::tom_int; - using boost::serialization::cpp_int_detail::tom_rational; - using boost::serialization::cpp_int_detail::tommath_int; - using boost::serialization::cpp_int_detail::tommath_rational; - using boost::serialization::cpp_int_detail::trivial_limb_type; - using boost::serialization::cpp_int_detail::trivial_limb_type_imp; - using boost::serialization::cpp_int_detail::trunc; - using boost::serialization::cpp_int_detail::uint1024_t; - using boost::serialization::cpp_int_detail::uint128_t; -#if defined(BOOST_HAS_INT128) - // M12 platform guard: serialize.hpp's `using namespace - // boost::multiprecision(::backends)` exposes the uint128_type entity into - // cpp_int_detail — present only under BOOST_HAS_INT128. - using boost::serialization::cpp_int_detail::uint128_type; -#endif - using boost::serialization::cpp_int_detail::uint256_t; - using boost::serialization::cpp_int_detail::uint512_t; - using boost::serialization::cpp_int_detail::uniform_int_distribution; - using boost::serialization::cpp_int_detail::unwrap_debug_type; - using boost::serialization::cpp_int_detail::unwrap_logged_type; - using boost::serialization::cpp_int_detail::variable_precision_options; }}} diff --git a/generated/exports/nowide.deps b/generated/exports/nowide.deps index 827765049..b78b6b17a 100644 --- a/generated/exports/nowide.deps +++ b/generated/exports/nowide.deps @@ -1,2 +1,3 @@ mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.filesystem +mcpplibs.mwrap.boost.io diff --git a/generated/exports/nowide.inc b/generated/exports/nowide.inc index 57c9ff3a6..6980f25ad 100644 --- a/generated/exports/nowide.inc +++ b/generated/exports/nowide.inc @@ -46,11 +46,13 @@ export namespace boost { namespace nowide { namespace detail { using boost::nowide::detail::StreamTypeOut; using boost::nowide::detail::buf_holder; #if defined(_WIN32) - // M11 platform guard: console_input_buffer is the windows console machinery (detail/console_buffer.hpp); POSIX nowide uses std:: streams directly. + // M11 platform guard: console_input_buffer is the windows console machinery + // (detail/console_buffer.hpp); POSIX nowide uses std:: streams directly. using boost::nowide::detail::console_input_buffer; #endif #if defined(_WIN32) - // M11 platform guard: console_output_buffer is the windows console machinery (detail/console_buffer.hpp); POSIX nowide uses std:: streams directly. + // M11 platform guard: console_output_buffer is the windows console machinery + // (detail/console_buffer.hpp); POSIX nowide uses std:: streams directly. using boost::nowide::detail::console_output_buffer; #endif using boost::nowide::detail::const_data_result; @@ -77,18 +79,20 @@ export namespace boost { namespace nowide { namespace detail { using boost::nowide::detail::requires_wide_string_container; using boost::nowide::detail::size_result; #if defined(_WIN32) - // M11 platform guard: detail::stat is the BOOST_WINDOWS branch of - // stat.hpp; POSIX exposes ::stat via a using-declaration instead. + // M11 platform guard: detail::stat is the BOOST_WINDOWS branch of stat.hpp; + // POSIX exposes ::stat via a using-declaration instead. using boost::nowide::detail::stat; #endif using boost::nowide::detail::void_t; using boost::nowide::detail::wfopen; #if defined(_WIN32) - // M11 platform guard: winconsole_istream is the windows console stream branch of iostream.hpp; POSIX takes std:: streams directly. + // M11 platform guard: winconsole_istream is the windows console stream branch + // of iostream.hpp; POSIX takes std:: streams directly. using boost::nowide::detail::winconsole_istream; #endif #if defined(_WIN32) - // M11 platform guard: winconsole_ostream is the windows console stream branch of iostream.hpp; POSIX takes std:: streams directly. + // M11 platform guard: winconsole_ostream is the windows console stream branch + // of iostream.hpp; POSIX takes std:: streams directly. using boost::nowide::detail::winconsole_ostream; #endif using boost::nowide::detail::write_state; diff --git a/generated/exports/numeric.deps b/generated/exports/numeric.deps index 5c3d160d0..51396d491 100644 --- a/generated/exports/numeric.deps +++ b/generated/exports/numeric.deps @@ -1,12 +1,10 @@ mcpplibs.mwrap.boost.assert +mcpplibs.mwrap.boost.concept_check mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.iterator -mcpplibs.mwrap.boost.lexical_cast mcpplibs.mwrap.boost.math -mcpplibs.mwrap.boost.multi_array mcpplibs.mwrap.boost.range mcpplibs.mwrap.boost.serialization mcpplibs.mwrap.boost.type_traits -mcpplibs.mwrap.boost.units mcpplibs.mwrap.boost.utility diff --git a/generated/exports/numeric.inc b/generated/exports/numeric.inc index 03aa897d3..4c84d1aea 100644 --- a/generated/exports/numeric.inc +++ b/generated/exports/numeric.inc @@ -1,10 +1,8 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=numeric boost=1.92.0 target=x86_64-w64-mingw32 entities=1485 +// lib=numeric boost=1.92.0 target=x86_64-w64-mingw32 entities=1115 export namespace boost { using boost::bad_numeric_cast; - using boost::get_pointer; - using boost::integral_constant; using boost::numeric_cast; } @@ -45,6 +43,7 @@ export namespace boost { namespace fusion { using boost::fusion::make_vector; using boost::fusion::none; using boost::fusion::not_equal_to; + using boost::fusion::operator!=; using boost::fusion::operator<; using boost::fusion::operator<<; using boost::fusion::operator<=; @@ -222,13 +221,8 @@ export namespace boost { namespace fusion { namespace result_of { }}} export namespace boost { namespace mpl { - using boost::mpl::advance; using boost::mpl::copy; - using boost::mpl::distance; using boost::mpl::for_each; - using boost::mpl::lambda; - using boost::mpl::next; - using boost::mpl::prior; using boost::mpl::r_iter; using boost::mpl::range_c; using boost::mpl::reverse_copy; @@ -247,7 +241,6 @@ export namespace boost { namespace mpl { namespace aux { using boost::mpl::aux::r_iter_tag; using boost::mpl::aux::reverse_copy_impl; using boost::mpl::aux::sel_iter; - using boost::mpl::aux::template_arity; using boost::mpl::aux::transform_iter; using boost::mpl::aux::unpack_args_impl; using boost::mpl::aux::unwrap; @@ -939,6 +932,8 @@ export namespace boost { namespace numeric { namespace ublas { using boost::numeric::ublas::row_major_tag; using boost::numeric::ublas::safe; #if !defined(NDEBUG) && !defined(BOOST_UBLAS_NDEBUG) + // Boost.uBLAS declares same_impl_ex only when size checks are on; a release + // build (NDEBUG) takes BOOST_UBLAS_USE_FAST_SAME and never declares it. using boost::numeric::ublas::same_impl_ex; #endif using boost::numeric::ublas::scalar_abs; @@ -1104,416 +1099,51 @@ export namespace boost { namespace numeric { namespace ublas { namespace blas_3 }}}} export namespace boost { namespace numeric { namespace ublas { namespace detail { - using boost::numeric::ublas::detail::DEFAULT_TRAVERSE_POLICY; - using boost::numeric::ublas::detail::DEFAULT_WRAP_POLICY; - using boost::numeric::ublas::detail::abs; using boost::numeric::ublas::detail::access; - using boost::numeric::ublas::detail::accumulate; using boost::numeric::ublas::detail::all_extents_equal; - using boost::numeric::ublas::detail::array_adaptor; - using boost::numeric::ublas::detail::array_to_vector; using boost::numeric::ublas::detail::array_to_vector_impl; - using boost::numeric::ublas::detail::assign_tag; - using boost::numeric::ublas::detail::axpy_lu_factorize; - using boost::numeric::ublas::detail::axpy_prod; - using boost::numeric::ublas::detail::bad_argument; - using boost::numeric::ublas::detail::bad_index; - using boost::numeric::ublas::detail::bad_size; - using boost::numeric::ublas::detail::banded_adaptor; - using boost::numeric::ublas::detail::banded_matrix; - using boost::numeric::ublas::detail::basic_column_major; - using boost::numeric::ublas::detail::basic_extents; - using boost::numeric::ublas::detail::basic_full; - using boost::numeric::ublas::detail::basic_lower; - using boost::numeric::ublas::detail::basic_range; - using boost::numeric::ublas::detail::basic_row_major; - using boost::numeric::ublas::detail::basic_slice; - using boost::numeric::ublas::detail::basic_strict_lower; - using boost::numeric::ublas::detail::basic_strict_upper; - using boost::numeric::ublas::detail::basic_strides; - using boost::numeric::ublas::detail::basic_unit_lower; - using boost::numeric::ublas::detail::basic_unit_upper; - using boost::numeric::ublas::detail::basic_upper; - using boost::numeric::ublas::detail::begin; - using boost::numeric::ublas::detail::begin1; - using boost::numeric::ublas::detail::begin1_manip; - using boost::numeric::ublas::detail::begin2; - using boost::numeric::ublas::detail::begin2_manip; using boost::numeric::ublas::detail::begin_impl; - using boost::numeric::ublas::detail::bidirectional_iterator_base; using boost::numeric::ublas::detail::binary_tensor_expression; - using boost::numeric::ublas::detail::block_prod; - using boost::numeric::ublas::detail::bounded_array; - using boost::numeric::ublas::detail::bounded_matrix; - using boost::numeric::ublas::detail::bounded_vector; - using boost::numeric::ublas::detail::c_array_view; - using boost::numeric::ublas::detail::c_matrix; - using boost::numeric::ublas::detail::c_vector; - using boost::numeric::ublas::detail::column; - using boost::numeric::ublas::detail::column_major; - using boost::numeric::ublas::detail::column_major_tag; using boost::numeric::ublas::detail::compare; - using boost::numeric::ublas::detail::complex_traits; - using boost::numeric::ublas::detail::compressed_matrix; - using boost::numeric::ublas::detail::compressed_matrix_view; - using boost::numeric::ublas::detail::compressed_vector; - using boost::numeric::ublas::detail::computed_assign_tag; - using boost::numeric::ublas::detail::conj; - using boost::numeric::ublas::detail::const_iterator_type; using boost::numeric::ublas::detail::const_iterator_type_impl; - using boost::numeric::ublas::detail::container_const_reference; - using boost::numeric::ublas::detail::container_reference; - using boost::numeric::ublas::detail::container_traits; - using boost::numeric::ublas::detail::container_view_traits; - using boost::numeric::ublas::detail::coordinate_matrix; - using boost::numeric::ublas::detail::coordinate_vector; - using boost::numeric::ublas::detail::copy; - using boost::numeric::ublas::detail::dense_proxy_tag; - using boost::numeric::ublas::detail::dense_random_access_iterator_tag; - using boost::numeric::ublas::detail::dense_tag; - using boost::numeric::ublas::detail::diagonal_adaptor; - using boost::numeric::ublas::detail::diagonal_matrix; - using boost::numeric::ublas::detail::divide_by_zero; - using boost::numeric::ublas::detail::element_div; - using boost::numeric::ublas::detail::element_prod; using boost::numeric::ublas::detail::element_reference; - using boost::numeric::ublas::detail::end; using boost::numeric::ublas::detail::end_impl; using boost::numeric::ublas::detail::equals; - using boost::numeric::ublas::detail::error_cant_deduce_type; using boost::numeric::ublas::detail::eval; using boost::numeric::ublas::detail::expression_type_check; - using boost::numeric::ublas::detail::external_logic; - using boost::numeric::ublas::detail::fill_policy_wrapper; - using boost::numeric::ublas::detail::first_order; - using boost::numeric::ublas::detail::fixed_matrix; - using boost::numeric::ublas::detail::fixed_vector; - using boost::numeric::ublas::detail::forward_iterator_base; - using boost::numeric::ublas::detail::full; - using boost::numeric::ublas::detail::generalized_vector_of_vector; - using boost::numeric::ublas::detail::has_index; using boost::numeric::ublas::detail::has_index_impl; using boost::numeric::ublas::detail::has_size_type; using boost::numeric::ublas::detail::has_tensor_types; using boost::numeric::ublas::detail::has_trivial_constructor; using boost::numeric::ublas::detail::has_trivial_destructor; - using boost::numeric::ublas::detail::herm; - using boost::numeric::ublas::detail::hermitian_adaptor; - using boost::numeric::ublas::detail::hermitian_matrix; - using boost::numeric::ublas::detail::hermitian_matrix_element; - using boost::numeric::ublas::detail::identity_matrix; using boost::numeric::ublas::detail::ignore_unused_variable_warning; - using boost::numeric::ublas::detail::imag; - using boost::numeric::ublas::detail::increment; - using boost::numeric::ublas::detail::index_manipulator; - using boost::numeric::ublas::detail::index_norm_inf; - using boost::numeric::ublas::detail::index_pair; - using boost::numeric::ublas::detail::index_pair_array; - using boost::numeric::ublas::detail::index_position; using boost::numeric::ublas::detail::index_position_impl; - using boost::numeric::ublas::detail::index_position_pairs; using boost::numeric::ublas::detail::index_position_pairs_impl; - using boost::numeric::ublas::detail::index_triple; - using boost::numeric::ublas::detail::index_triple_array; - using boost::numeric::ublas::detail::indexed_const_iterator; - using boost::numeric::ublas::detail::indexed_const_iterator1; - using boost::numeric::ublas::detail::indexed_const_iterator2; - using boost::numeric::ublas::detail::indexed_iterator; - using boost::numeric::ublas::detail::indexed_iterator1; - using boost::numeric::ublas::detail::indexed_iterator2; - using boost::numeric::ublas::detail::indexing_matrix_assign; - using boost::numeric::ublas::detail::indexing_matrix_assign_scalar; - using boost::numeric::ublas::detail::indexing_vector_assign; - using boost::numeric::ublas::detail::indexing_vector_assign_scalar; - using boost::numeric::ublas::detail::indirect_array; - using boost::numeric::ublas::detail::inner; - using boost::numeric::ublas::detail::inner_prod; - using boost::numeric::ublas::detail::inplace_solve; - using boost::numeric::ublas::detail::internal_logic; - using boost::numeric::ublas::detail::is_hermitian; - using boost::numeric::ublas::detail::is_symmetric; - using boost::numeric::ublas::detail::iterating_matrix_assign; - using boost::numeric::ublas::detail::iterating_matrix_assign_scalar; - using boost::numeric::ublas::detail::iterating_vector_assign; - using boost::numeric::ublas::detail::iterating_vector_assign_scalar; - using boost::numeric::ublas::detail::iterator_base_traits; - using boost::numeric::ublas::detail::iterator_restrict_traits; - using boost::numeric::ublas::detail::iterator_type; using boost::numeric::ublas::detail::iterator_type_impl; - using boost::numeric::ublas::detail::last_order; using boost::numeric::ublas::detail::less_pair; using boost::numeric::ublas::detail::less_triple; - using boost::numeric::ublas::detail::lower; using boost::numeric::ublas::detail::lower_bound; - using boost::numeric::ublas::detail::lower_tag; - using boost::numeric::ublas::detail::lu_factorize; - using boost::numeric::ublas::detail::lu_substitute; using boost::numeric::ublas::detail::make_binary_tensor_expression; - using boost::numeric::ublas::detail::make_column_vector; - using boost::numeric::ublas::detail::make_compressed_matrix_view; using boost::numeric::ublas::detail::make_conformant; - using boost::numeric::ublas::detail::make_row_vector; using boost::numeric::ublas::detail::make_unary_tensor_expression; - using boost::numeric::ublas::detail::map_array; using boost::numeric::ublas::detail::map_capacity; using boost::numeric::ublas::detail::map_capacity_traits; using boost::numeric::ublas::detail::map_reserve; - using boost::numeric::ublas::detail::map_std; using boost::numeric::ublas::detail::map_traits; - using boost::numeric::ublas::detail::mapped_matrix; - using boost::numeric::ublas::detail::mapped_vector; - using boost::numeric::ublas::detail::mapped_vector_of_mapped_vector; - using boost::numeric::ublas::detail::matrix; - using boost::numeric::ublas::detail::matrix_assign; - using boost::numeric::ublas::detail::matrix_assign_scalar; - using boost::numeric::ublas::detail::matrix_assign_traits; - using boost::numeric::ublas::detail::matrix_binary; - using boost::numeric::ublas::detail::matrix_binary_scalar1; - using boost::numeric::ublas::detail::matrix_binary_scalar1_traits; - using boost::numeric::ublas::detail::matrix_binary_scalar2; - using boost::numeric::ublas::detail::matrix_binary_scalar2_traits; - using boost::numeric::ublas::detail::matrix_binary_traits; - using boost::numeric::ublas::detail::matrix_column; - using boost::numeric::ublas::detail::matrix_column_vector; - using boost::numeric::ublas::detail::matrix_container; - using boost::numeric::ublas::detail::matrix_expression; - using boost::numeric::ublas::detail::matrix_expression_assigner; - using boost::numeric::ublas::detail::matrix_indirect; - using boost::numeric::ublas::detail::matrix_matrix_binary; - using boost::numeric::ublas::detail::matrix_matrix_binary_functor; - using boost::numeric::ublas::detail::matrix_matrix_binary_traits; - using boost::numeric::ublas::detail::matrix_matrix_prod; - using boost::numeric::ublas::detail::matrix_matrix_solve_traits; - using boost::numeric::ublas::detail::matrix_move_manip; - using boost::numeric::ublas::detail::matrix_move_to_manip; - using boost::numeric::ublas::detail::matrix_norm_1; - using boost::numeric::ublas::detail::matrix_norm_frobenius; - using boost::numeric::ublas::detail::matrix_norm_inf; - using boost::numeric::ublas::detail::matrix_range; - using boost::numeric::ublas::detail::matrix_reference; using boost::numeric::ublas::detail::matrix_resize_preserve; - using boost::numeric::ublas::detail::matrix_row; - using boost::numeric::ublas::detail::matrix_row_vector; - using boost::numeric::ublas::detail::matrix_scalar_real_unary_functor; - using boost::numeric::ublas::detail::matrix_scalar_unary; - using boost::numeric::ublas::detail::matrix_scalar_unary_traits; using boost::numeric::ublas::detail::matrix_size_type; - using boost::numeric::ublas::detail::matrix_slice; - using boost::numeric::ublas::detail::matrix_swap; - using boost::numeric::ublas::detail::matrix_swap_traits; - using boost::numeric::ublas::detail::matrix_tag; - using boost::numeric::ublas::detail::matrix_temporary_traits; - using boost::numeric::ublas::detail::matrix_traits; - using boost::numeric::ublas::detail::matrix_unary1; - using boost::numeric::ublas::detail::matrix_unary1_traits; - using boost::numeric::ublas::detail::matrix_unary2; - using boost::numeric::ublas::detail::matrix_unary2_traits; - using boost::numeric::ublas::detail::matrix_vector_binary1; - using boost::numeric::ublas::detail::matrix_vector_binary1_traits; - using boost::numeric::ublas::detail::matrix_vector_binary2; - using boost::numeric::ublas::detail::matrix_vector_binary2_traits; - using boost::numeric::ublas::detail::matrix_vector_binary_functor; - using boost::numeric::ublas::detail::matrix_vector_indirect; using boost::numeric::ublas::detail::matrix_vector_iterator; - using boost::numeric::ublas::detail::matrix_vector_prod1; - using boost::numeric::ublas::detail::matrix_vector_prod2; - using boost::numeric::ublas::detail::matrix_vector_range; - using boost::numeric::ublas::detail::matrix_vector_slice; - using boost::numeric::ublas::detail::matrix_vector_solve_traits; - using boost::numeric::ublas::detail::matrix_view_traits; - using boost::numeric::ublas::detail::move; - using boost::numeric::ublas::detail::move_to; - using boost::numeric::ublas::detail::mutable_container_traits; - using boost::numeric::ublas::detail::mutable_matrix_traits; - using boost::numeric::ublas::detail::mutable_vector_traits; - using boost::numeric::ublas::detail::next_column; - using boost::numeric::ublas::detail::next_column_manip; - using boost::numeric::ublas::detail::next_row; - using boost::numeric::ublas::detail::next_row_manip; - using boost::numeric::ublas::detail::noalias; - using boost::numeric::ublas::detail::noalias_proxy; - using boost::numeric::ublas::detail::non_real; - using boost::numeric::ublas::detail::nonassignable; - using boost::numeric::ublas::detail::norm; - using boost::numeric::ublas::detail::norm_1; - using boost::numeric::ublas::detail::norm_2; - using boost::numeric::ublas::detail::norm_2_square; - using boost::numeric::ublas::detail::norm_frobenius; - using boost::numeric::ublas::detail::norm_inf; - using boost::numeric::ublas::detail::num_columns; - using boost::numeric::ublas::detail::num_rows; - using boost::numeric::ublas::detail::number_equal_indexes; using boost::numeric::ublas::detail::number_equal_indexes_impl; - using boost::numeric::ublas::detail::opb_prod; - using boost::numeric::ublas::detail::operator*; - using boost::numeric::ublas::detail::operator+; - using boost::numeric::ublas::detail::operator-; - using boost::numeric::ublas::detail::operator/; - using boost::numeric::ublas::detail::operator<<; - using boost::numeric::ublas::detail::operator<<=; - using boost::numeric::ublas::detail::operator>>; - using boost::numeric::ublas::detail::outer; - using boost::numeric::ublas::detail::outer_prod; - using boost::numeric::ublas::detail::packed_proxy_tag; - using boost::numeric::ublas::detail::packed_random_access_iterator_tag; - using boost::numeric::ublas::detail::packed_tag; - using boost::numeric::ublas::detail::permutation_matrix; - using boost::numeric::ublas::detail::prec_inner_prod; - using boost::numeric::ublas::detail::prec_prod; using boost::numeric::ublas::detail::print; - using boost::numeric::ublas::detail::prod; - using boost::numeric::ublas::detail::project; - using boost::numeric::ublas::detail::promote_traits; - using boost::numeric::ublas::detail::random_access_iterator_base; - using boost::numeric::ublas::detail::range; - using boost::numeric::ublas::detail::real; - using boost::numeric::ublas::detail::ref; using boost::numeric::ublas::detail::retrieve_extents; - using boost::numeric::ublas::detail::reverse_iterator_base; - using boost::numeric::ublas::detail::reverse_iterator_base1; - using boost::numeric::ublas::detail::reverse_iterator_base2; - using boost::numeric::ublas::detail::row; - using boost::numeric::ublas::detail::row_major; - using boost::numeric::ublas::detail::row_major_tag; - using boost::numeric::ublas::detail::safe; -#if !defined(NDEBUG) && !defined(BOOST_UBLAS_NDEBUG) - using boost::numeric::ublas::detail::same_impl_ex; -#endif - using boost::numeric::ublas::detail::scalar_abs; - using boost::numeric::ublas::detail::scalar_assign; - using boost::numeric::ublas::detail::scalar_binary_assign_functor; - using boost::numeric::ublas::detail::scalar_binary_functor; - using boost::numeric::ublas::detail::scalar_binary_swap_functor; - using boost::numeric::ublas::detail::scalar_conj; - using boost::numeric::ublas::detail::scalar_divides; - using boost::numeric::ublas::detail::scalar_divides_assign; - using boost::numeric::ublas::detail::scalar_expression; - using boost::numeric::ublas::detail::scalar_identity; - using boost::numeric::ublas::detail::scalar_imag; - using boost::numeric::ublas::detail::scalar_matrix; - using boost::numeric::ublas::detail::scalar_minus; - using boost::numeric::ublas::detail::scalar_minus_assign; - using boost::numeric::ublas::detail::scalar_multiplies; - using boost::numeric::ublas::detail::scalar_multiplies_assign; - using boost::numeric::ublas::detail::scalar_negate; - using boost::numeric::ublas::detail::scalar_plus; - using boost::numeric::ublas::detail::scalar_plus_assign; - using boost::numeric::ublas::detail::scalar_real; - using boost::numeric::ublas::detail::scalar_real_unary_functor; - using boost::numeric::ublas::detail::scalar_reference; - using boost::numeric::ublas::detail::scalar_swap; - using boost::numeric::ublas::detail::scalar_tag; - using boost::numeric::ublas::detail::scalar_traits; - using boost::numeric::ublas::detail::scalar_unary_functor; - using boost::numeric::ublas::detail::scalar_value; - using boost::numeric::ublas::detail::scalar_vector; - using boost::numeric::ublas::detail::shape; - using boost::numeric::ublas::detail::singular; - using boost::numeric::ublas::detail::size; using boost::numeric::ublas::detail::size_by_dim_impl; using boost::numeric::ublas::detail::size_by_tag_impl; - using boost::numeric::ublas::detail::slice; - using boost::numeric::ublas::detail::solve; - using boost::numeric::ublas::detail::sparse_bidirectional_iterator_tag; - using boost::numeric::ublas::detail::sparse_matrix_element; - using boost::numeric::ublas::detail::sparse_prod; - using boost::numeric::ublas::detail::sparse_proxy_tag; - using boost::numeric::ublas::detail::sparse_tag; - using boost::numeric::ublas::detail::sparse_vector_element; - using boost::numeric::ublas::detail::static_matrix_move_manip; - using boost::numeric::ublas::detail::static_matrix_move_to_manip; - using boost::numeric::ublas::detail::static_vector_move_manip; - using boost::numeric::ublas::detail::static_vector_move_to_manip; - using boost::numeric::ublas::detail::storage_array; - using boost::numeric::ublas::detail::storage_restrict_traits; - using boost::numeric::ublas::detail::storage_traits; - using boost::numeric::ublas::detail::strict_lower; - using boost::numeric::ublas::detail::strict_lower_tag; - using boost::numeric::ublas::detail::strict_upper; - using boost::numeric::ublas::detail::strict_upper_tag; - using boost::numeric::ublas::detail::strides; - using boost::numeric::ublas::detail::subrange; - using boost::numeric::ublas::detail::subslice; - using boost::numeric::ublas::detail::sum; - using boost::numeric::ublas::detail::swap_rows; - using boost::numeric::ublas::detail::symmetric_adaptor; - using boost::numeric::ublas::detail::symmetric_matrix; - using boost::numeric::ublas::detail::tensor; using boost::numeric::ublas::detail::tensor_expression; - using boost::numeric::ublas::detail::tensor_tag; - using boost::numeric::ublas::detail::trans; - using boost::numeric::ublas::detail::transform; using boost::numeric::ublas::detail::transposed_structure; - using boost::numeric::ublas::detail::traverse_policy_wrapper; - using boost::numeric::ublas::detail::triangular_adaptor; - using boost::numeric::ublas::detail::triangular_matrix; - using boost::numeric::ublas::detail::ttm; - using boost::numeric::ublas::detail::ttt; - using boost::numeric::ublas::detail::ttv; - using boost::numeric::ublas::detail::type_traits; - using boost::numeric::ublas::detail::ublas_expression; using boost::numeric::ublas::detail::unary_tensor_expression; - using boost::numeric::ublas::detail::unbounded_array; - using boost::numeric::ublas::detail::unit_lower; - using boost::numeric::ublas::detail::unit_lower_tag; - using boost::numeric::ublas::detail::unit_upper; - using boost::numeric::ublas::detail::unit_upper_tag; - using boost::numeric::ublas::detail::unit_vector; - using boost::numeric::ublas::detail::unknown_orientation_tag; - using boost::numeric::ublas::detail::unknown_storage_tag; - using boost::numeric::ublas::detail::upper; using boost::numeric::ublas::detail::upper_bound; - using boost::numeric::ublas::detail::upper_tag; - using boost::numeric::ublas::detail::valid_multi_index; using boost::numeric::ublas::detail::valid_multi_index_impl; - using boost::numeric::ublas::detail::vector; - using boost::numeric::ublas::detail::vector_assign; - using boost::numeric::ublas::detail::vector_assign_scalar; - using boost::numeric::ublas::detail::vector_assign_traits; - using boost::numeric::ublas::detail::vector_binary; - using boost::numeric::ublas::detail::vector_binary_scalar1; - using boost::numeric::ublas::detail::vector_binary_scalar1_traits; - using boost::numeric::ublas::detail::vector_binary_scalar2; - using boost::numeric::ublas::detail::vector_binary_scalar2_traits; - using boost::numeric::ublas::detail::vector_binary_traits; - using boost::numeric::ublas::detail::vector_container; - using boost::numeric::ublas::detail::vector_expression; - using boost::numeric::ublas::detail::vector_expression_assigner; - using boost::numeric::ublas::detail::vector_index_norm_inf; - using boost::numeric::ublas::detail::vector_indirect; - using boost::numeric::ublas::detail::vector_inner_prod; - using boost::numeric::ublas::detail::vector_matrix_binary; - using boost::numeric::ublas::detail::vector_matrix_binary_traits; - using boost::numeric::ublas::detail::vector_move_manip; - using boost::numeric::ublas::detail::vector_move_to_manip; - using boost::numeric::ublas::detail::vector_norm_1; - using boost::numeric::ublas::detail::vector_norm_2; - using boost::numeric::ublas::detail::vector_norm_2_square; - using boost::numeric::ublas::detail::vector_norm_inf; - using boost::numeric::ublas::detail::vector_of_vector; - using boost::numeric::ublas::detail::vector_range; - using boost::numeric::ublas::detail::vector_reference; - using boost::numeric::ublas::detail::vector_scalar_binary; - using boost::numeric::ublas::detail::vector_scalar_binary_functor; - using boost::numeric::ublas::detail::vector_scalar_binary_traits; - using boost::numeric::ublas::detail::vector_scalar_index_unary_functor; - using boost::numeric::ublas::detail::vector_scalar_real_unary_functor; - using boost::numeric::ublas::detail::vector_scalar_unary; - using boost::numeric::ublas::detail::vector_scalar_unary_functor; - using boost::numeric::ublas::detail::vector_scalar_unary_traits; using boost::numeric::ublas::detail::vector_size_type; - using boost::numeric::ublas::detail::vector_slice; - using boost::numeric::ublas::detail::vector_sum; - using boost::numeric::ublas::detail::vector_swap; - using boost::numeric::ublas::detail::vector_swap_traits; - using boost::numeric::ublas::detail::vector_tag; - using boost::numeric::ublas::detail::vector_temporary_traits; - using boost::numeric::ublas::detail::vector_traits; - using boost::numeric::ublas::detail::vector_unary; - using boost::numeric::ublas::detail::vector_unary_traits; - using boost::numeric::ublas::detail::vector_view_traits; - using boost::numeric::ublas::detail::zero_matrix; - using boost::numeric::ublas::detail::zero_vector; }}}} export namespace boost { namespace numeric { namespace ublas { namespace detail { namespace recursive { diff --git a/generated/exports/outcome.inc b/generated/exports/outcome.inc index 4df62b731..1ffa9b525 100644 --- a/generated/exports/outcome.inc +++ b/generated/exports/outcome.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=outcome boost=1.92.0 target=x86_64-w64-mingw32 entities=191 +// lib=outcome boost=1.92.0 target=x86_64-w64-mingw32 entities=192 export namespace boost { namespace outcome_v2 { using boost::outcome_v2::bad_outcome_access; @@ -204,6 +204,7 @@ export namespace boost { namespace outcome_v2 { namespace policy { namespace det using boost::outcome_v2::policy::detail::exception_ptr; using boost::outcome_v2::policy::detail::make_error_code; using boost::outcome_v2::policy::detail::make_exception_ptr; + using boost::outcome_v2::policy::detail::make_ub; using boost::outcome_v2::policy::detail::std_enum_overload_tag; }}}} diff --git a/generated/exports/parser.inc b/generated/exports/parser.inc index a13d03e41..0a55ac915 100644 --- a/generated/exports/parser.inc +++ b/generated/exports/parser.inc @@ -510,13 +510,10 @@ export namespace boost { namespace parser { namespace detail { namespace hl { export namespace boost { namespace parser { namespace detail { namespace numeric { using boost::parser::detail::numeric::common_range; - using boost::parser::detail::numeric::unpacked_iter; - using boost::parser::detail::numeric::unpacks_to_chars; -}}}} - -export namespace boost { namespace parser { namespace detail { namespace numeric { using boost::parser::detail::numeric::parse_int; using boost::parser::detail::numeric::parse_real; + using boost::parser::detail::numeric::unpacked_iter; + using boost::parser::detail::numeric::unpacks_to_chars; using boost::parser::detail::numeric::use_charconv_int; using boost::parser::detail::numeric::use_charconv_real; }}}} diff --git a/generated/exports/pfr.inc b/generated/exports/pfr.inc index cbb47e0b6..01eb4b033 100644 --- a/generated/exports/pfr.inc +++ b/generated/exports/pfr.inc @@ -95,8 +95,8 @@ export namespace boost { namespace pfr { namespace detail { using boost::pfr::detail::fields_count; using boost::pfr::detail::fields_count_dispatch; #if BOOST_PFR_USE_CPP26_REFLECTION || BOOST_PFR_USE_CPP26 - // M9 platform guard: fields_count_dispatch_impl exists only under the - // C++26 reflection / structured-bindings branches (fields_count.hpp). + // M9 platform guard: fields_count_dispatch_impl exists only under the C++26 + // reflection / structured-bindings branches (fields_count.hpp). using boost::pfr::detail::fields_count_dispatch_impl; #endif using boost::pfr::detail::for_each_field; diff --git a/generated/exports/poly_collection.deps b/generated/exports/poly_collection.deps index 0ad421c5b..fcace4973 100644 --- a/generated/exports/poly_collection.deps +++ b/generated/exports/poly_collection.deps @@ -1,7 +1,6 @@ mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.config -mcpplibs.mwrap.boost.core -mcpplibs.mwrap.boost.iterator mcpplibs.mwrap.boost.mp11 +mcpplibs.mwrap.boost.smart_ptr mcpplibs.mwrap.boost.type_erasure mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/poly_collection.inc b/generated/exports/poly_collection.inc index 49d3cc0c0..2d043eb96 100644 --- a/generated/exports/poly_collection.inc +++ b/generated/exports/poly_collection.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=poly_collection boost=1.92.0 target=x86_64-w64-mingw32 entities=319 +// lib=poly_collection boost=1.92.0 target=x86_64-w64-mingw32 entities=324 export namespace boost { using boost::any_collection; @@ -11,14 +11,11 @@ export namespace boost { export namespace boost { namespace mpl { using boost::mpl::base; - using boost::mpl::contains_impl; - using boost::mpl::has_key_impl; using boost::mpl::item_by_order; #if defined(__GNUC__) // M9 platform guard: gcc-preprocessed mpl map headers only. using boost::mpl::item_by_order_impl; #endif - using boost::mpl::lambda; using boost::mpl::m_at; using boost::mpl::m_item; using boost::mpl::m_iter; @@ -45,9 +42,7 @@ export namespace boost { namespace mpl { using boost::mpl::map7; using boost::mpl::map8; using boost::mpl::map9; - using boost::mpl::next; using boost::mpl::next_order; - using boost::mpl::order_impl; using boost::mpl::s_item; using boost::mpl::s_iter; using boost::mpl::s_iter_get; @@ -85,7 +80,6 @@ export namespace boost { namespace mpl { namespace aux { using boost::mpl::aux::ptr_to_ref; using boost::mpl::aux::set_insert_impl; using boost::mpl::aux::set_tag; - using boost::mpl::aux::template_arity; }}} export namespace boost { namespace poly_collection { @@ -95,6 +89,7 @@ export namespace boost { namespace poly_collection { using boost::poly_collection::any_collection; using boost::poly_collection::any_collection_value_type; using boost::poly_collection::any_of; + using boost::poly_collection::bad_variant_access; using boost::poly_collection::base_collection; using boost::poly_collection::copy; using boost::poly_collection::copy_if; @@ -111,6 +106,9 @@ export namespace boost { namespace poly_collection { using boost::poly_collection::for_each_n; using boost::poly_collection::function_collection; using boost::poly_collection::function_collection_value_type; + using boost::poly_collection::get; + using boost::poly_collection::get_if; + using boost::poly_collection::holds_alternative; using boost::poly_collection::is_partitioned; using boost::poly_collection::is_permutation; using boost::poly_collection::mismatch; @@ -134,9 +132,16 @@ export namespace boost { namespace poly_collection { using boost::poly_collection::transform; using boost::poly_collection::unique_copy; using boost::poly_collection::unregistered_type; + using boost::poly_collection::unsafe_get; + using boost::poly_collection::variant_alternative; + using boost::poly_collection::variant_alternative_t; using boost::poly_collection::variant_collection; using boost::poly_collection::variant_collection_of; using boost::poly_collection::variant_collection_value_type; + using boost::poly_collection::variant_size; + using boost::poly_collection::variant_size_v; + using boost::poly_collection::visit; + using boost::poly_collection::visit_by_index; }} export namespace boost { namespace poly_collection { namespace common_impl { diff --git a/generated/exports/pool.deps b/generated/exports/pool.deps index a5ef752dc..7a79874ff 100644 --- a/generated/exports/pool.deps +++ b/generated/exports/pool.deps @@ -1,4 +1,4 @@ mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.config -mcpplibs.mwrap.boost.integer mcpplibs.mwrap.boost.throw_exception +mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/process.deps b/generated/exports/process.deps index 2f443316c..b76d7846d 100644 --- a/generated/exports/process.deps +++ b/generated/exports/process.deps @@ -1,9 +1,10 @@ mcpplibs.mwrap.boost.asio mcpplibs.mwrap.boost.assert +mcpplibs.mwrap.boost.concept_check mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.filesystem -mcpplibs.mwrap.boost.iterator +mcpplibs.mwrap.boost.io mcpplibs.mwrap.boost.system mcpplibs.mwrap.boost.type_traits mcpplibs.mwrap.boost.utility diff --git a/generated/exports/process.inc b/generated/exports/process.inc index dfe2ff322..5efdcb2ff 100644 --- a/generated/exports/process.inc +++ b/generated/exports/process.inc @@ -1,14 +1,6 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT // lib=process boost=1.92.0 target=x86_64-w64-mingw32 entities=471 -export namespace boost { - using boost::basic_string_view; - using boost::optional; - using boost::result_of; - using boost::string_view; - using boost::wstring_view; -} - export namespace boost { namespace asio { using boost::asio::basic_yield_context; using boost::asio::const_buffers_1; @@ -17,6 +9,9 @@ export namespace boost { namespace asio { export namespace boost { namespace asio { namespace windows { #if defined(_WIN32) + // The boost::asio::windows handles that process's Windows launcher reaches + // (stream_handle, basic_object_handle) exist only on Windows. + using boost::asio::windows::basic_object_handle; using boost::asio::windows::stream_handle; #endif }}} @@ -36,7 +31,6 @@ export namespace boost { namespace fusion { using boost::fusion::make_pair; using boost::fusion::make_set; using boost::fusion::make_tuple; - using boost::fusion::map; using boost::fusion::map_iterator; using boost::fusion::map_tie; using boost::fusion::nview; @@ -95,18 +89,6 @@ export namespace boost { namespace fusion { namespace result_of { using boost::fusion::result_of::vector_tie; }}} -export namespace boost { namespace fusion { namespace traits { - using boost::fusion::traits::tag_of; -}}} - -export namespace boost { namespace io { - using boost::io::quoted; -}} - -export namespace boost { namespace mpl { - using boost::mpl::sequence_tag; -}} - export namespace boost { namespace process { namespace v1 { using boost::process::v1::async_pipe; using boost::process::v1::async_system; @@ -250,10 +232,10 @@ export namespace boost { namespace process { namespace v1 { namespace detail { using boost::process::v1::detail::valid_argument_list; }}}} -#if defined(_WIN32) export namespace boost { namespace process { namespace v1 { namespace detail { namespace windows { - // M11 platform guard: v1 detail windows impls (incl. the NT workaround - // block below) are declared only by the windows GMF branches. +#if defined(_WIN32) + // M11 platform guard: v1 detail windows impls (incl. the NT workaround block + // below) are declared only by the windows GMF branches. using boost::process::v1::detail::windows::apply_out_handles; using boost::process::v1::detail::windows::associate_completion_port; using boost::process::v1::detail::windows::async_handler; @@ -324,9 +306,13 @@ export namespace boost { namespace process { namespace v1 { namespace detail { n using boost::process::v1::detail::windows::wait_impl; using boost::process::v1::detail::windows::wait_until; using boost::process::v1::detail::windows::windows_file_codecvt; +#endif }}}}} export namespace boost { namespace process { namespace v1 { namespace detail { namespace windows { namespace workaround { +#if defined(_WIN32) + // M11 platform guard: v1 detail windows impls (incl. the NT workaround block + // below) are declared only by the windows GMF branches. using boost::process::v1::detail::windows::workaround::GENERIC_MAPPING_; using boost::process::v1::detail::windows::workaround::OBJECT_BASIC_INFORMATION_; using boost::process::v1::detail::windows::workaround::OBJECT_INFORMATION_CLASS_; @@ -356,8 +342,8 @@ export namespace boost { namespace process { namespace v1 { namespace detail { n using boost::process::v1::detail::windows::workaround::nt_query_object; using boost::process::v1::detail::windows::workaround::nt_system_query_information; using boost::process::v1::detail::windows::workaround::set_information_job_object; -}}}}}} #endif +}}}}}} export namespace boost { namespace process { namespace v1 { namespace extend { using boost::process::v1::extend::foreach_used_handle; @@ -373,8 +359,8 @@ export namespace boost { namespace process { namespace v1 { namespace extend { export namespace boost { namespace process { namespace v2 { #if defined(__MINGW32__) - // M11 platform guard: _popen is the MinGW spelling of popen - // (mingw stdio.h #defines popen to _popen); MSVC/POSIX expose popen. + // M11 platform guard: _popen is the MinGW spelling of popen (mingw stdio.h + // #defines popen to _popen); MSVC/POSIX expose popen. using boost::process::v2::_popen; #endif using boost::process::v2::all_pids; @@ -383,6 +369,7 @@ export namespace boost { namespace process { namespace v2 { using boost::process::v2::basic_popen; using boost::process::v2::basic_process; using boost::process::v2::basic_process_handle; + using boost::process::v2::basic_string_view; using boost::process::v2::bind_default_launcher; using boost::process::v2::bind_launcher; using boost::process::v2::bound_launcher; @@ -391,6 +378,8 @@ export namespace boost { namespace process { namespace v2 { using boost::process::v2::cstring_ref; using boost::process::v2::current_pid; using boost::process::v2::default_process_launcher; + using boost::process::v2::error_category; + using boost::process::v2::error_code; using boost::process::v2::evaluate_exit_code; using boost::process::v2::execute; using boost::process::v2::get_shell_category; @@ -399,6 +388,7 @@ export namespace boost { namespace process { namespace v2 { using boost::process::v2::is_writable_pipe; using boost::process::v2::native_exit_code_type; using boost::process::v2::operator<<; + using boost::process::v2::optional; using boost::process::v2::parent_pid; using boost::process::v2::pid_type; using boost::process::v2::process; @@ -407,19 +397,27 @@ export namespace boost { namespace process { namespace v2 { using boost::process::v2::process_is_running; using boost::process::v2::process_start_dir; using boost::process::v2::process_stdio; + using boost::process::v2::quoted; using boost::process::v2::shell; + using boost::process::v2::string_view; + using boost::process::v2::system_category; + using boost::process::v2::system_error; using boost::process::v2::u16cstring_ref; using boost::process::v2::u32cstring_ref; using boost::process::v2::wcstring_ref; + using boost::process::v2::wstring_view; }}} export namespace boost { namespace process { namespace v2 { namespace detail { #if defined(_WIN32) - // M11 platform guard: all_are_initializers is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: all_are_initializers is the windows generic-launcher + // machinery (flat v2::detail); POSIX nests a different set under + // v2::posix::detail. using boost::process::v2::detail::all_are_initializers; #endif #if defined(_WIN32) - // M11 platform guard: base is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: base is the windows generic-launcher machinery (flat + // v2::detail); POSIX nests a different set under v2::posix::detail. using boost::process::v2::detail::base; #endif #if defined(_WIN32) @@ -428,98 +426,122 @@ export namespace boost { namespace process { namespace v2 { namespace detail { using boost::process::v2::detail::basic_process_handle_win; #endif #if defined(_WIN32) - // M11 platform guard: check_handle_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). + // M11 platform guard: check_handle_ lives in detail/process_handle_windows.hpp + // (no fd-variant counterpart). using boost::process::v2::detail::check_handle_; #endif #if defined(_WIN32) - // M11 platform guard: check_pid_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). + // M11 platform guard: check_pid_ lives in detail/process_handle_windows.hpp + // (no fd-variant counterpart). using boost::process::v2::detail::check_pid_; #endif #if defined(_WIN32) - // M11 platform guard: check_running_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). + // M11 platform guard: check_running_ lives in + // detail/process_handle_windows.hpp (no fd-variant counterpart). using boost::process::v2::detail::check_running_; #endif using boost::process::v2::detail::conv_string; using boost::process::v2::detail::convert_to_utf8; using boost::process::v2::detail::convert_to_wide; #if defined(_WIN32) - // M11 platform guard: derived is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: derived is the windows generic-launcher machinery (flat + // v2::detail); POSIX nests a different set under v2::posix::detail. using boost::process::v2::detail::derived; #endif using boost::process::v2::detail::do_throw_error; using boost::process::v2::detail::execute_op; #if defined(_WIN32) - // M11 platform guard: get_exit_code_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). + // M11 platform guard: get_exit_code_ lives in + // detail/process_handle_windows.hpp (no fd-variant counterpart). using boost::process::v2::detail::get_exit_code_; #endif using boost::process::v2::detail::get_last_error; #if defined(_WIN32) - // M11 platform guard: handle_closer is the Windows stdio handle - // wrapper (DWORD/GetStdHandle); POSIX stdio does not declare it. + // M11 platform guard: handle_closer is the Windows stdio handle wrapper + // (DWORD/GetStdHandle); POSIX stdio does not declare it. using boost::process::v2::detail::handle_closer; #endif #if defined(_WIN32) - // M11 platform guard: has_on_error is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: has_on_error is the windows generic-launcher machinery + // (flat v2::detail); POSIX nests a different set under v2::posix::detail. using boost::process::v2::detail::has_on_error; #endif #if defined(_WIN32) - // M11 platform guard: has_on_setup is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: has_on_setup is the windows generic-launcher machinery + // (flat v2::detail); POSIX nests a different set under v2::posix::detail. using boost::process::v2::detail::has_on_setup; #endif #if defined(_WIN32) - // M11 platform guard: has_on_success is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: has_on_success is the windows generic-launcher machinery + // (flat v2::detail); POSIX nests a different set under v2::posix::detail. using boost::process::v2::detail::has_on_success; #endif using boost::process::v2::detail::index_sequence; #if defined(_WIN32) - // M11 platform guard: interrupt_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). + // M11 platform guard: interrupt_ lives in detail/process_handle_windows.hpp + // (no fd-variant counterpart). using boost::process::v2::detail::interrupt_; #endif #if defined(_WIN32) - // M11 platform guard: invoke_on_error is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: invoke_on_error is the windows generic-launcher + // machinery (flat v2::detail); POSIX nests a different set under + // v2::posix::detail. using boost::process::v2::detail::invoke_on_error; #endif #if defined(_WIN32) - // M11 platform guard: invoke_on_setup is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: invoke_on_setup is the windows generic-launcher + // machinery (flat v2::detail); POSIX nests a different set under + // v2::posix::detail. using boost::process::v2::detail::invoke_on_setup; #endif #if defined(_WIN32) - // M11 platform guard: invoke_on_success is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: invoke_on_success is the windows generic-launcher + // machinery (flat v2::detail); POSIX nests a different set under + // v2::posix::detail. using boost::process::v2::detail::invoke_on_success; #endif #if defined(_WIN32) - // M11 platform guard: is_initializer is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: is_initializer is the windows generic-launcher machinery + // (flat v2::detail); POSIX nests a different set under v2::posix::detail. using boost::process::v2::detail::is_initializer; #endif using boost::process::v2::detail::make_index_sequence; using boost::process::v2::detail::make_index_sequence_impl; using boost::process::v2::detail::make_index_sequence_t; #if defined(_WIN32) - // M11 platform guard: on_error is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: on_error is the windows generic-launcher machinery (flat + // v2::detail); POSIX nests a different set under v2::posix::detail. using boost::process::v2::detail::on_error; #endif #if defined(_WIN32) - // M11 platform guard: on_setup is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: on_setup is the windows generic-launcher machinery (flat + // v2::detail); POSIX nests a different set under v2::posix::detail. using boost::process::v2::detail::on_setup; #endif #if defined(_WIN32) - // M11 platform guard: on_success is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: on_success is the windows generic-launcher machinery + // (flat v2::detail); POSIX nests a different set under v2::posix::detail. using boost::process::v2::detail::on_success; #endif #if defined(_WIN32) - // M11 platform guard: open_process_ lives in detail/process_handle_windows.hpp. + // M11 platform guard: open_process_ lives in + // detail/process_handle_windows.hpp. using boost::process::v2::detail::open_process_; #endif #if defined(_WIN32) - // M11 platform guard: probe_on_error is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: probe_on_error is the windows generic-launcher machinery + // (flat v2::detail); POSIX nests a different set under v2::posix::detail. using boost::process::v2::detail::probe_on_error; #endif #if defined(_WIN32) - // M11 platform guard: probe_on_setup is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: probe_on_setup is the windows generic-launcher machinery + // (flat v2::detail); POSIX nests a different set under v2::posix::detail. using boost::process::v2::detail::probe_on_setup; #endif #if defined(_WIN32) - // M11 platform guard: probe_on_success is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. + // M11 platform guard: probe_on_success is the windows generic-launcher + // machinery (flat v2::detail); POSIX nests a different set under + // v2::posix::detail. using boost::process::v2::detail::probe_on_success; #endif using boost::process::v2::detail::process_error_binding; @@ -527,25 +549,30 @@ export namespace boost { namespace process { namespace v2 { namespace detail { using boost::process::v2::detail::process_io_binding; using boost::process::v2::detail::process_output_binding; #if defined(_WIN32) - // M11 platform guard: request_exit_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). + // M11 platform guard: request_exit_ lives in detail/process_handle_windows.hpp + // (no fd-variant counterpart). using boost::process::v2::detail::request_exit_; #endif #if defined(_WIN32) - // M11 platform guard: resume_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). + // M11 platform guard: resume_ lives in detail/process_handle_windows.hpp (no + // fd-variant counterpart). using boost::process::v2::detail::resume_; #endif using boost::process::v2::detail::size_as_utf8; using boost::process::v2::detail::size_as_wide; #if defined(_WIN32) - // M11 platform guard: suspend_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). + // M11 platform guard: suspend_ lives in detail/process_handle_windows.hpp (no + // fd-variant counterpart). using boost::process::v2::detail::suspend_; #endif #if defined(_WIN32) - // M11 platform guard: terminate_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). + // M11 platform guard: terminate_ lives in detail/process_handle_windows.hpp + // (no fd-variant counterpart). using boost::process::v2::detail::terminate_; #endif #if defined(_WIN32) - // M11 platform guard: terminate_if_running_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). + // M11 platform guard: terminate_if_running_ lives in + // detail/process_handle_windows.hpp (no fd-variant counterpart). using boost::process::v2::detail::terminate_if_running_; #endif using boost::process::v2::detail::throw_error; @@ -596,8 +623,8 @@ export namespace boost { namespace process { namespace v2 { namespace environmen using boost::process::v2::environment::detail::get; using boost::process::v2::environment::detail::hash_step; #if defined(_WIN32) - // M11 platform guard: is_exec_type lives in detail/environment_win.hpp; - // POSIX environment detail does not declare it. + // M11 platform guard: is_exec_type lives in detail/environment_win.hpp; POSIX + // environment detail does not declare it. using boost::process::v2::environment::detail::is_exec_type; #endif using boost::process::v2::environment::detail::is_executable; @@ -624,8 +651,8 @@ export namespace boost { namespace process { namespace v2 { namespace ext { using boost::process::v2::ext::exe; }}}} -#if defined(_WIN32) export namespace boost { namespace process { namespace v2 { namespace windows { +#if defined(_WIN32) // M11 platform guard: v2 windows launchers are Windows-only headers. using boost::process::v2::windows::as_user_launcher; using boost::process::v2::windows::default_launcher; @@ -633,12 +660,8 @@ export namespace boost { namespace process { namespace v2 { namespace windows { using boost::process::v2::windows::process_show_window; using boost::process::v2::windows::with_logon_launcher; using boost::process::v2::windows::with_token_launcher; -}}}} #endif - -export namespace boost { namespace system { - using boost::system::error_category; -}} +}}}} export namespace boost { namespace this_process { using boost::this_process::environment; diff --git a/generated/exports/program_options.inc b/generated/exports/program_options.inc index 8d23ad497..40ef08aef 100644 --- a/generated/exports/program_options.inc +++ b/generated/exports/program_options.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=program_options boost=1.92.0 target=x86_64-w64-mingw32 entities=92 +// lib=program_options boost=1.92.0 target=x86_64-w64-mingw32 entities=90 export namespace boost { using boost::environment_iterator; @@ -7,9 +7,7 @@ export namespace boost { using boost::from_8_bit; using boost::from_local_8_bit; using boost::from_utf8; - using boost::function_n; using boost::optional; - using boost::shared_ptr; using boost::to_8_bit; using boost::to_local_8_bit; using boost::to_utf8; diff --git a/generated/exports/property_map.inc b/generated/exports/property_map.inc index c9323ee90..95436f10e 100644 --- a/generated/exports/property_map.inc +++ b/generated/exports/property_map.inc @@ -1,7 +1,8 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=property_map boost=1.92.0 target=x86_64-w64-mingw32 entities=109 +// lib=property_map boost=1.92.0 target=x86_64-w64-mingw32 entities=116 export namespace boost { + using ::get; using ::put; using boost::LvaluePropertyMapConcept; using boost::Mutable_LvaluePropertyMapConcept; @@ -18,7 +19,6 @@ export namespace boost { using boost::dynamic_properties; using boost::dynamic_property_exception; using boost::dynamic_property_map; - using boost::function_n; using boost::function_property_map; using boost::get; using boost::has_category; @@ -59,7 +59,6 @@ export namespace boost { using boost::ref_property_map; using boost::safe_iterator_property_map; using boost::shared_array_property_map; - using boost::shared_ptr; using boost::static_property_map; using boost::transform_value_property_map; using boost::typed_identity_property_map; @@ -85,6 +84,20 @@ export namespace boost { namespace detail { using boost::detail::readable_pmap_iter; }} +export namespace boost { namespace graph { namespace distributed { + using boost::graph::distributed::attach_distributed_object; + using boost::graph::distributed::trc_early_receive; + using boost::graph::distributed::trc_in_synchronization; + using boost::graph::distributed::trc_irecv_out_of_band; + using boost::graph::distributed::trc_none; + using boost::graph::distributed::trc_out_of_band; + using boost::graph::distributed::trigger_receive_context; +}}} + +export namespace boost { namespace graph { namespace parallel { + using boost::graph::parallel::simple_trigger; +}}} + export namespace boost { namespace parallel { using boost::parallel::attach_distributed_object; using boost::parallel::batch_process_group_tag; diff --git a/generated/exports/property_tree.deps b/generated/exports/property_tree.deps index e74d5cbac..b39e7164e 100644 --- a/generated/exports/property_tree.deps +++ b/generated/exports/property_tree.deps @@ -1,6 +1,7 @@ mcpplibs.mwrap.boost.any mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.bind +mcpplibs.mwrap.boost.concept_check mcpplibs.mwrap.boost.optional mcpplibs.mwrap.boost.range mcpplibs.mwrap.boost.serialization diff --git a/generated/exports/ptr_container.deps b/generated/exports/ptr_container.deps index 6133399ce..4f503cdc6 100644 --- a/generated/exports/ptr_container.deps +++ b/generated/exports/ptr_container.deps @@ -3,8 +3,6 @@ mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.circular_buffer mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core -mcpplibs.mwrap.boost.iterator mcpplibs.mwrap.boost.range mcpplibs.mwrap.boost.smart_ptr mcpplibs.mwrap.boost.type_traits -mcpplibs.mwrap.boost.unordered diff --git a/generated/exports/qvm.inc b/generated/exports/qvm.inc index af9a3641f..983b57f27 100644 --- a/generated/exports/qvm.inc +++ b/generated/exports/qvm.inc @@ -2008,8 +2008,8 @@ export namespace boost { namespace qvm { namespace qvm_detail { using boost::qvm::qvm_detail::vec_register_read; using boost::qvm::qvm_detail::vec_register_write; #if defined(__GNUC__) && defined(__SSE2__) - // M12 platform guard: vec_traits_gnuc.hpp declares vec_traits_gnuc_impl - // only under __GNUC__ && __SSE2__ (gcc vector_size ext_vector_traits). + // M12 platform guard: vec_traits_gnuc.hpp declares vec_traits_gnuc_impl only + // under __GNUC__ && __SSE2__ (gcc vector_size ext_vector_traits). using boost::qvm::qvm_detail::vec_traits_gnuc_impl; #endif using boost::qvm::qvm_detail::vector_scalar_cast_; diff --git a/generated/exports/range.deps b/generated/exports/range.deps index 34018ea16..f3cdfcb6e 100644 --- a/generated/exports/range.deps +++ b/generated/exports/range.deps @@ -9,4 +9,3 @@ mcpplibs.mwrap.boost.optional mcpplibs.mwrap.boost.regex mcpplibs.mwrap.boost.tuple mcpplibs.mwrap.boost.type_traits -mcpplibs.mwrap.boost.utility diff --git a/generated/exports/range.inc b/generated/exports/range.inc index a2cf6f59d..4b4eb9cab 100644 --- a/generated/exports/range.inc +++ b/generated/exports/range.inc @@ -36,6 +36,7 @@ export namespace boost { using boost::count; using boost::count_if; using boost::counting_range; + using boost::distance; using boost::empty; using boost::end; using boost::equal; @@ -245,11 +246,6 @@ export namespace boost { namespace iterator_range_detail { using boost::iterator_range_detail::test_traversal_tag; }} -export namespace boost { namespace iterators { namespace detail { - using boost::iterators::detail::postfix_increment_proxy; - using boost::iterators::detail::writable_postfix_increment_proxy; -}}} - export namespace boost { namespace next_prior_detail { using boost::next_prior_detail::next_advance_impl; using boost::next_prior_detail::next_plus_assign_impl; @@ -279,6 +275,7 @@ export namespace boost { namespace range { using boost::range::find_first_of; using boost::range::find_if; using boost::range::for_each; + using boost::range::formatted_range; using boost::range::generate; using boost::range::includes; using boost::range::index_value; @@ -344,8 +341,8 @@ export namespace boost { namespace range { namespace detail { using boost::range::detail::max_element; using boost::range::detail::min_element; #if defined(__GLIBCXX__) - // M9 platform guard: std::random_shuffle was removed in C++17; only - // libstdc++ (mingw/linux-gcc) still provides it. + // M9 platform guard: std::random_shuffle was removed in C++17; only libstdc++ + // (mingw/linux-gcc) still provides it. using std::random_shuffle; #endif }}} diff --git a/generated/exports/rational.inc b/generated/exports/rational.inc index 53405fef7..0dfbe4628 100644 --- a/generated/exports/rational.inc +++ b/generated/exports/rational.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=rational boost=1.92.0 target=x86_64-w64-mingw32 entities=23 +// lib=rational boost=1.92.0 target=x86_64-w64-mingw32 entities=21 export namespace boost { using boost::abs; @@ -26,11 +26,6 @@ export namespace boost { namespace detail { using boost::detail::resetter; }} -export namespace boost { namespace integer { - using boost::integer::gcd_evaluator; - using boost::integer::lcm_evaluator; -}} - export namespace boost { namespace rational_detail { using boost::rational_detail::is_backward_compatible_integer; using boost::rational_detail::is_compatible_integer; diff --git a/generated/exports/regex.inc b/generated/exports/regex.inc index e2a35f94c..ef1d9177f 100644 --- a/generated/exports/regex.inc +++ b/generated/exports/regex.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=regex boost=1.92.0 target=x86_64-w64-mingw32 entities=381 +// lib=regex boost=1.92.0 target=x86_64-w64-mingw32 entities=404 export namespace boost { using boost::BaseRegexConcept; @@ -7,7 +7,6 @@ export namespace boost { using boost::BoostRegexConcept; using boost::RegexConcept; using boost::RegexTraitsConcept; - using boost::assignable_archetype; using boost::bad_expression; using boost::bad_pattern; using boost::basic_regex; @@ -15,11 +14,16 @@ export namespace boost { using boost::c_regex_traits; using boost::char_architype; using boost::cmatch; - using boost::copy_constructible_archetype; using boost::cpp_regex_traits; using boost::cregex_iterator; using boost::cregex_token_iterator; using boost::csub_match; + using boost::format_all; + using boost::format_default; + using boost::format_first_only; + using boost::format_no_copy; + using boost::format_perl; + using boost::format_sed; using boost::functor1; using boost::functor1b; using boost::functor2; @@ -28,9 +32,28 @@ export namespace boost { using boost::is_random_access_iterator; using boost::make_regex_iterator; using boost::make_regex_token_iterator; + using boost::match_all; + using boost::match_any; + using boost::match_continuous; + using boost::match_default; + using boost::match_extra; using boost::match_flag_type; + using boost::match_nosubs; + using boost::match_not_bob; + using boost::match_not_bol; + using boost::match_not_bow; + using boost::match_not_dot_newline; + using boost::match_not_dot_null; + using boost::match_not_eob; + using boost::match_not_eol; + using boost::match_not_eow; + using boost::match_not_null; + using boost::match_partial; + using boost::match_perl; + using boost::match_posix; + using boost::match_prev_avail; using boost::match_results; - using boost::null_archetype; + using boost::match_single_line; using boost::object_cache; using boost::operator!=; using boost::operator+; diff --git a/generated/exports/serialization.inc b/generated/exports/serialization.inc index 41578d6af..acf33da7b 100644 --- a/generated/exports/serialization.inc +++ b/generated/exports/serialization.inc @@ -1,10 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=serialization boost=1.92.0 target=x86_64-w64-mingw32 entities=410 - -export namespace boost { - using boost::scoped_ptr; - using boost::shared_ptr; -} +// lib=serialization boost=1.92.0 target=x86_64-w64-mingw32 entities=401 export namespace boost { namespace archive { using boost::archive::BOOST_ARCHIVE_SIGNATURE; @@ -176,14 +171,12 @@ export namespace boost { namespace archive { namespace iterators { namespace det }}}} export namespace boost { namespace mpl { - using boost::mpl::always; using boost::mpl::greater; using boost::mpl::greater_equal; using boost::mpl::greater_equal_impl; using boost::mpl::greater_equal_tag; using boost::mpl::greater_impl; using boost::mpl::greater_tag; - using boost::mpl::lambda; using boost::mpl::less_equal; using boost::mpl::less_equal_impl; using boost::mpl::less_equal_tag; @@ -193,19 +186,6 @@ export namespace boost { namespace mpl { using boost::mpl::print; }} -export namespace boost { namespace mpl { namespace aux { - using boost::mpl::aux::template_arity; -}}} - -export namespace boost { namespace operators_impl { - using boost::operators_impl::totally_ordered1; - using boost::operators_impl::totally_ordered2; -}} - -export namespace boost { namespace operators_impl { namespace operators_detail { - using boost::operators_impl::operators_detail::empty_base; -}}} - export namespace boost { namespace serialization { using boost::serialization::BOOST_SERIALIZATION_SS; using boost::serialization::BOOST_SERIALIZATION_STATIC_WARNING_LINE; @@ -246,7 +226,6 @@ export namespace boost { namespace serialization { using boost::serialization::make_array; using boost::serialization::make_binary_object; using boost::serialization::null_deleter; - using boost::serialization::nvp; using boost::serialization::operator>=; using boost::serialization::save; using boost::serialization::save_construct_data; diff --git a/generated/exports/signals2.deps b/generated/exports/signals2.deps index a98909713..ae1e3bd68 100644 --- a/generated/exports/signals2.deps +++ b/generated/exports/signals2.deps @@ -1,7 +1,9 @@ mcpplibs.mwrap.boost.assert +mcpplibs.mwrap.boost.bind mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.function mcpplibs.mwrap.boost.iterator +mcpplibs.mwrap.boost.move mcpplibs.mwrap.boost.mp11 mcpplibs.mwrap.boost.optional mcpplibs.mwrap.boost.smart_ptr diff --git a/generated/exports/signals2.inc b/generated/exports/signals2.inc index 1c42f9862..5c8121a35 100644 --- a/generated/exports/signals2.inc +++ b/generated/exports/signals2.inc @@ -1,17 +1,11 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=signals2 boost=1.92.0 target=x86_64-w64-mingw32 entities=127 +// lib=signals2 boost=1.92.0 target=x86_64-w64-mingw32 entities=124 export namespace boost { - using boost::scoped_ptr; + using boost::enable_shared_from_this; using boost::shared_ptr; - using boost::variant; - using boost::weak_ptr; } -export namespace boost { namespace iterators { - using boost::iterators::function_output_iterator; -}} - export namespace boost { namespace signals2 { using boost::signals2::connect_position; using boost::signals2::connect_position::at_back; @@ -54,9 +48,9 @@ export namespace boost { namespace signals2 { namespace detail { using boost::signals2::detail::connection_body; using boost::signals2::detail::connection_body_base; #if defined(BOOST_HAS_WINTHREADS) + // The critical-section mutex is the Windows-threads branch of signals2's + // lightweight mutex; POSIX uses pthread. using boost::signals2::detail::critical_section; -#endif -#if defined(BOOST_HAS_WINTHREADS) using boost::signals2::detail::critical_section_debug; #endif using boost::signals2::detail::deconstruct_deleter; @@ -95,6 +89,8 @@ export namespace boost { namespace signals2 { namespace detail { using boost::signals2::detail::replace_slot_function; using boost::signals2::detail::result_type_wrapper; #if defined(BOOST_HAS_WINTHREADS) + // The critical-section mutex is the Windows-threads branch of signals2's + // lightweight mutex; POSIX uses pthread. using boost::signals2::detail::rtl_critical_section; #endif using boost::signals2::detail::scope_guard; diff --git a/generated/exports/sort.deps b/generated/exports/sort.deps index 1bf099d3c..e733338f0 100644 --- a/generated/exports/sort.deps +++ b/generated/exports/sort.deps @@ -1,2 +1,3 @@ mcpplibs.mwrap.boost.core +mcpplibs.mwrap.boost.range mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/sort.inc b/generated/exports/sort.inc index 4cffa3eb3..589d5bb5c 100644 --- a/generated/exports/sort.inc +++ b/generated/exports/sort.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=sort boost=1.92.0 target=x86_64-w64-mingw32 entities=214 +// lib=sort boost=1.92.0 target=x86_64-w64-mingw32 entities=160 export namespace boost { namespace sort { using boost::sort::block_indirect_sort; @@ -17,8 +17,6 @@ export namespace boost { namespace sort { }} export namespace boost { namespace sort { namespace blk_detail { - using boost::sort::blk_detail::H_comp; - using boost::sort::blk_detail::L_comp; using boost::sort::blk_detail::backbone; using boost::sort::blk_detail::block; using boost::sort::blk_detail::block_indirect_sort; @@ -27,63 +25,10 @@ export namespace boost { namespace sort { namespace blk_detail { using boost::sort::blk_detail::block_size; using boost::sort::blk_detail::compare_block; using boost::sort::blk_detail::compare_block_pos; - using boost::sort::blk_detail::concat; - using boost::sort::blk_detail::create_index; - using boost::sort::blk_detail::deque_cnc; - using boost::sort::blk_detail::destroy; - using boost::sort::blk_detail::fill_vector_string; - using boost::sort::blk_detail::fill_vector_uint64; - using boost::sort::blk_detail::filter_iterator; - using boost::sort::blk_detail::filter_pos; - using boost::sort::blk_detail::full_merge4; - using boost::sort::blk_detail::generate_file; - using boost::sort::blk_detail::indirect_sort; - using boost::sort::blk_detail::initialize; - using boost::sort::blk_detail::int_array; - using boost::sort::blk_detail::internal_sort; - using boost::sort::blk_detail::is_mergeable; - using boost::sort::blk_detail::is_mergeable_stable; - using boost::sort::blk_detail::is_reverse_stable_sorted_backward; - using boost::sort::blk_detail::is_reverse_stable_sorted_forward; - using boost::sort::blk_detail::is_stable_sorted_backward; - using boost::sort::blk_detail::is_stable_sorted_forward; - using boost::sort::blk_detail::less_ptr_no_null; - using boost::sort::blk_detail::less_range; - using boost::sort::blk_detail::merge; - using boost::sort::blk_detail::merge_block; using boost::sort::blk_detail::merge_blocks; - using boost::sort::blk_detail::merge_construct; - using boost::sort::blk_detail::merge_contiguous; - using boost::sort::blk_detail::merge_half; - using boost::sort::blk_detail::merge_level4; - using boost::sort::blk_detail::merge_uncontiguous; - using boost::sort::blk_detail::merge_vector4; - using boost::sort::blk_detail::mid3; - using boost::sort::blk_detail::mid9; - using boost::sort::blk_detail::move_backward; using boost::sort::blk_detail::move_blocks; - using boost::sort::blk_detail::move_construct; - using boost::sort::blk_detail::move_forward; - using boost::sort::blk_detail::now; - using boost::sort::blk_detail::number_stable_sorted_backward; - using boost::sort::blk_detail::number_stable_sorted_forward; - using boost::sort::blk_detail::operator<<; using boost::sort::blk_detail::parallel_sort; - using boost::sort::blk_detail::pivot3; - using boost::sort::blk_detail::pivot9; - using boost::sort::blk_detail::range; - using boost::sort::blk_detail::rearrange; - using boost::sort::blk_detail::scheduler; - using boost::sort::blk_detail::sort_index; - using boost::sort::blk_detail::spinlock_t; - using boost::sort::blk_detail::stack_cnc; - using boost::sort::blk_detail::subtract_time; - using boost::sort::blk_detail::time_point; - using boost::sort::blk_detail::uint64_file_generator; - using boost::sort::blk_detail::uninit_full_merge4; - using boost::sort::blk_detail::uninit_merge_level4; - using boost::sort::blk_detail::write_file_string; - using boost::sort::blk_detail::write_file_uint64; + using boost::sort::blk_detail::pdqsort; }}} export namespace boost { namespace sort { namespace common { @@ -246,4 +191,5 @@ export namespace boost { namespace sort { namespace spreadsort { namespace detai export namespace boost { namespace sort { namespace stable_detail { using boost::sort::stable_detail::parallel_stable_sort; + using boost::sort::stable_detail::sample_sort; }}} diff --git a/generated/exports/stacktrace.deps b/generated/exports/stacktrace.deps index c63a6b32b..3519ed810 100644 --- a/generated/exports/stacktrace.deps +++ b/generated/exports/stacktrace.deps @@ -1 +1 @@ -mcpplibs.mwrap.boost.config +mcpplibs.mwrap.boost.container_hash diff --git a/generated/exports/statechart.deps b/generated/exports/statechart.deps index 458364b8f..25a839676 100644 --- a/generated/exports/statechart.deps +++ b/generated/exports/statechart.deps @@ -1,6 +1,7 @@ mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core +mcpplibs.mwrap.boost.function mcpplibs.mwrap.boost.smart_ptr mcpplibs.mwrap.boost.thread mcpplibs.mwrap.boost.throw_exception diff --git a/generated/exports/statechart.inc b/generated/exports/statechart.inc index b3d3524ef..de8780782 100644 --- a/generated/exports/statechart.inc +++ b/generated/exports/statechart.inc @@ -1,20 +1,10 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=statechart boost=1.92.0 target=x86_64-w64-mingw32 entities=77 - -export namespace boost { - using boost::function_n; - using boost::intrusive_ptr; -} +// lib=statechart boost=1.92.0 target=x86_64-w64-mingw32 entities=73 export namespace boost { namespace mpl { - using boost::mpl::lambda; using boost::mpl::reverse; }} -export namespace boost { namespace mpl { namespace aux { - using boost::mpl::aux::template_arity; -}}} - export namespace boost { namespace statechart { using boost::statechart::asynchronous_state_machine; using boost::statechart::custom_reaction; diff --git a/generated/exports/static_string.deps b/generated/exports/static_string.deps index 0b2dffa43..2d787224c 100644 --- a/generated/exports/static_string.deps +++ b/generated/exports/static_string.deps @@ -1,2 +1,4 @@ mcpplibs.mwrap.boost.assert +mcpplibs.mwrap.boost.container_hash mcpplibs.mwrap.boost.core +mcpplibs.mwrap.boost.utility diff --git a/generated/exports/system.inc b/generated/exports/system.inc index 6b9d3d59d..32ac1eeb3 100644 --- a/generated/exports/system.inc +++ b/generated/exports/system.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=system boost=1.92.0 target=x86_64-w64-mingw32 entities=199 +// lib=system boost=1.92.0 target=x86_64-w64-mingw32 entities=198 export namespace boost { using boost::throws; @@ -58,12 +58,18 @@ export namespace boost { namespace system { namespace detail { using boost::system::detail::is_result; using boost::system::detail::is_value_convertible_to; #if defined(BOOST_WINDOWS_API) - // M6 platform guard: snapshot = mingw flavor; these boost/system/detail entities - // exist only under BOOST_WINDOWS_API (system_category_message_win32.hpp / condition). + // M6 platform guard: snapshot = mingw flavor; these boost/system/detail + // entities exist only under BOOST_WINDOWS_API + // (system_category_message_win32.hpp / condition). using boost::system::detail::local_free; - using boost::system::detail::message_cp_win32; #endif using boost::system::detail::lock_guard; +#if defined(BOOST_WINDOWS_API) + // M6 platform guard: snapshot = mingw flavor; these boost/system/detail + // entities exist only under BOOST_WINDOWS_API + // (system_category_message_win32.hpp / condition). + using boost::system::detail::message_cp_win32; +#endif using boost::system::detail::reference_to_temporary; using boost::system::detail::remove_cvref; using boost::system::detail::std_category; @@ -170,8 +176,9 @@ export namespace boost { namespace system { namespace errc { using boost::system::errc::make_error_condition; }}} -#if defined(BOOST_WINDOWS_API) export namespace boost { namespace system { namespace windows_error { +#if defined(BOOST_WINDOWS_API) + // M6 platform guard: as above. using boost::system::windows_error::make_error_code; using boost::system::windows_error::windows_error_code; using boost::system::windows_error::windows_error_code::access_denied; @@ -226,9 +233,5 @@ export namespace boost { namespace system { namespace windows_error { using boost::system::windows_error::windows_error_code::write_fault; using boost::system::windows_error::windows_error_code::write_protect; using boost::system::windows_error::windows_error_code::wrong_disk; -}}} #endif - -export namespace boost { namespace variant2 { - using boost::variant2::in_place_index_t; -}} +}}} diff --git a/generated/exports/thread.deps b/generated/exports/thread.deps index a5a40b72c..fc166c1f6 100644 --- a/generated/exports/thread.deps +++ b/generated/exports/thread.deps @@ -1,6 +1,7 @@ mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.atomic mcpplibs.mwrap.boost.chrono +mcpplibs.mwrap.boost.concept_check mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.date_time @@ -11,4 +12,3 @@ mcpplibs.mwrap.boost.system mcpplibs.mwrap.boost.throw_exception mcpplibs.mwrap.boost.type_traits mcpplibs.mwrap.boost.utility -mcpplibs.mwrap.boost.winapi diff --git a/generated/exports/thread.inc b/generated/exports/thread.inc index 13345b8fb..bf29c9bf2 100644 --- a/generated/exports/thread.inc +++ b/generated/exports/thread.inc @@ -1,7 +1,16 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=thread boost=1.92.0 target=x86_64-w64-mingw32 entities=452 +// lib=thread boost=1.92.0 target=x86_64-w64-mingw32 entities=446 export namespace boost { + // M7c: gcc 16.1.0 module consumers emit a partial vtable for clone_impl + // (virtual base clone_base) whose thunk slots stay undefined — gcc never emits + // the thunks in a module consumer TU. These extern-template declarations + // suppress the consumer's implicit instantiation; the complete vtable + thunks + // come from the explicit instantiation in port/thread_extras.cpp (same pattern + // as boost_system_extras.cpp). + extern template class boost::exception_detail::clone_impl; + extern template class boost::exception_detail::clone_impl; + extern template class boost::exception_detail::clone_impl; using boost::BasicLock; using boost::BasicLockable; using boost::Lock; @@ -20,15 +29,6 @@ export namespace boost { using boost::basic_lockable_adapter; using boost::basic_poly_lockable; using boost::broken_promise; - // M7c: gcc 16.1.0 module consumers emit a partial vtable for clone_impl - // (virtual base clone_base) whose thunk slots stay undefined — gcc never - // emits the thunks in a module consumer TU. These extern-template - // declarations suppress the consumer's implicit instantiation; the complete - // vtable + thunks come from the explicit instantiation in - // port/thread_extras.cpp (same pattern as boost_system_extras.cpp). - extern template class boost::exception_detail::clone_impl; - extern template class boost::exception_detail::clone_impl; - extern template class boost::exception_detail::clone_impl; using boost::call_once; using boost::caller_context_t; using boost::completion_latch; @@ -54,7 +54,6 @@ export namespace boost { using boost::detach_if_joinable; using boost::diagnostic_information; using boost::diagnostic_information_what; - using boost::error_info; using boost::exception_ptr; using boost::exceptional_ptr; using boost::executor; @@ -71,9 +70,6 @@ export namespace boost { using boost::get_system_time; using boost::get_xtime; using boost::interrupt_and_join_if_joinable; -#if defined(_WIN32) - using boost::intrusive_ptr; -#endif using boost::invalid_thread_argument; using boost::is_future_type; using boost::is_mutex_type; @@ -147,7 +143,6 @@ export namespace boost { using boost::shared_lockable_adapter; using boost::shared_mutex; using boost::shared_poly_lockable; - using boost::shared_ptr; using boost::shared_timed_mutex; using boost::static_shared_from_this; using boost::stream_guard; @@ -206,15 +201,6 @@ export namespace boost { using boost::xtime_get; } -export namespace boost { namespace atomics { - using boost::atomics::atomic; -}} - -export namespace boost { namespace chrono { - using boost::chrono::duration; - using boost::chrono::time_point; -}} - export namespace boost { namespace concurrent { using boost::concurrent::deque_adaptor; using boost::concurrent::deque_back; @@ -285,35 +271,33 @@ export namespace boost { namespace csbl { export namespace boost { namespace detail { using boost::detail::add_thread_exit_function; #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::allocate_raw_heap_memory; #endif using boost::detail::base_future; #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::basic_condition_variable; -#endif -#if defined(_WIN32) using boost::detail::basic_cv_list_entry; #endif using boost::detail::basic_future; #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::basic_recursive_mutex; -#endif -#if defined(_WIN32) using boost::detail::basic_recursive_mutex_impl; -#endif -#if defined(_WIN32) using boost::detail::basic_recursive_timed_mutex; -#endif -#if defined(_WIN32) using boost::detail::basic_timed_mutex; -#endif -#if defined(_WIN32) using boost::detail::commit_once_region; #endif using boost::detail::counter; using boost::detail::counter_is_not_zero; using boost::detail::counter_is_zero; #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::create_once_event; #endif using boost::detail::deduced_type; @@ -321,9 +305,9 @@ export namespace boost { namespace detail { using boost::detail::do_heap_delete; using boost::detail::enable_move_utility_emulation_dummy_specialization; #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::enter_once_region; -#endif -#if defined(_WIN32) using boost::detail::free_raw_heap_memory; #endif using boost::detail::future_async_shared_state; @@ -337,21 +321,19 @@ export namespace boost { namespace detail { using boost::detail::heap_delete; using boost::detail::heap_new; #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::int_to_string; -#endif -#if defined(_WIN32) using boost::detail::interlocked_read_acquire; -#endif -#if defined(_WIN32) using boost::detail::interlocked_write_release; #endif using boost::detail::internal_chrono_clock; using boost::detail::internal_platform_clock; using boost::detail::internal_platform_timepoint; #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::intrusive_ptr_add_ref; -#endif -#if defined(_WIN32) using boost::detail::intrusive_ptr_release; #endif using boost::detail::invoke; @@ -369,29 +351,21 @@ export namespace boost { namespace detail { using boost::detail::mono_platform_clock; using boost::detail::mono_platform_timepoint; #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::name_once_mutex; #endif using boost::detail::not_equal; using boost::detail::nullary_function; #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::once_action; -#endif -#if defined(_WIN32) using boost::detail::once_action::break_; -#endif -#if defined(_WIN32) using boost::detail::once_action::continue_; -#endif -#if defined(_WIN32) using boost::detail::once_action::try_; -#endif -#if defined(_WIN32) using boost::detail::once_char_type; -#endif -#if defined(_WIN32) using boost::detail::once_context; -#endif -#if defined(_WIN32) using boost::detail::open_once_event; #endif using boost::detail::operator!=; @@ -409,6 +383,8 @@ export namespace boost { namespace detail { using boost::detail::real_platform_timepoint; using boost::detail::relocker; #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::rollback_once_region; #endif using boost::detail::set_tss_data; @@ -432,6 +408,8 @@ export namespace boost { namespace detail { using boost::detail::tss_data_node; using boost::detail::tuple_indices; #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::underlying_mutex; #endif using boost::detail::waiter_for_any_in_seq; @@ -442,8 +420,10 @@ export namespace boost { namespace detail { namespace thread { using boost::detail::thread::cleanup_func_t; }}} -#if defined(_WIN32) export namespace boost { namespace detail { namespace win32 { +#if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::win32::create_anonymous_event; using boost::detail::win32::create_anonymous_semaphore; using boost::detail::win32::create_anonymous_semaphore_nothrow; @@ -465,11 +445,13 @@ export namespace boost { namespace detail { namespace win32 { using boost::detail::win32::sleep; using boost::detail::win32::system_info; using boost::detail::win32::ticks_type; -}}} #endif +}}} export namespace boost { namespace detail { namespace win32 { namespace detail { #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::detail::win32::detail::gettickcount64_t; #endif }}}} @@ -552,6 +534,8 @@ export namespace boost { namespace this_thread { using boost::this_thread::disable_interruption; using boost::this_thread::get_id; #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::this_thread::interruptible_wait; #endif using boost::this_thread::interruption_enabled; @@ -566,6 +550,8 @@ export namespace boost { namespace this_thread { export namespace boost { namespace this_thread { namespace no_interruption_point { #if defined(_WIN32) + // The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX + // builds the pthread backend. using boost::this_thread::no_interruption_point::non_interruptible_wait; #endif using boost::this_thread::no_interruption_point::sleep; diff --git a/generated/exports/throw_exception.inc b/generated/exports/throw_exception.inc index b5004db25..844629e81 100644 --- a/generated/exports/throw_exception.inc +++ b/generated/exports/throw_exception.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=throw_exception boost=1.92.0 target=x86_64-w64-mingw32 entities=44 +// lib=throw_exception boost=1.92.0 target=x86_64-w64-mingw32 entities=45 export namespace boost { using boost::enable_current_exception; @@ -50,6 +50,7 @@ export namespace boost { namespace exception_detail { using boost::exception_detail::serialize_diagnostic_information_to_impl_; using boost::exception_detail::set_info; using boost::exception_detail::set_info_rv; + using boost::exception_detail::shared_ptr; using boost::exception_detail::small_size; using boost::exception_detail::type_info_; }} diff --git a/generated/exports/tuple.deps b/generated/exports/tuple.deps index eaaebb70a..1bf099d3c 100644 --- a/generated/exports/tuple.deps +++ b/generated/exports/tuple.deps @@ -1,3 +1,2 @@ -mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/tuple.inc b/generated/exports/tuple.inc index da09c5102..ddbadc43b 100644 --- a/generated/exports/tuple.inc +++ b/generated/exports/tuple.inc @@ -47,7 +47,8 @@ export namespace boost { namespace tuples { namespace detail { using boost::tuples::detail::gte; using boost::tuples::detail::handle_width; #if !defined(__GNUC__) - // M3 hand-guard: ignore_t is a member-pointer typedef; gcc treats it as internal linkage. + // M3 hand-guard: ignore_t is a member-pointer typedef; gcc treats it as + // internal linkage. using boost::tuples::detail::ignore_t; #endif using boost::tuples::detail::lt; diff --git a/generated/exports/type_erasure.deps b/generated/exports/type_erasure.deps index ac5e473b8..2c2b7d0ad 100644 --- a/generated/exports/type_erasure.deps +++ b/generated/exports/type_erasure.deps @@ -2,6 +2,7 @@ mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.iterator +mcpplibs.mwrap.boost.mp11 mcpplibs.mwrap.boost.smart_ptr mcpplibs.mwrap.boost.throw_exception mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/type_erasure.inc b/generated/exports/type_erasure.inc index 8f3d92b32..ce35104fe 100644 --- a/generated/exports/type_erasure.inc +++ b/generated/exports/type_erasure.inc @@ -1,16 +1,11 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=type_erasure boost=1.92.0 target=x86_64-w64-mingw32 entities=302 +// lib=type_erasure boost=1.92.0 target=x86_64-w64-mingw32 entities=300 export namespace boost { namespace mpl { using boost::mpl::index_if; using boost::mpl::index_of; - using boost::mpl::lambda; }} -export namespace boost { namespace mpl { namespace aux { - using boost::mpl::aux::template_arity; -}}} - export namespace boost { namespace type_erasure { using boost::type_erasure::_a; using boost::type_erasure::_b; diff --git a/generated/exports/units.deps b/generated/exports/units.deps index 860493595..35d9ff261 100644 --- a/generated/exports/units.deps +++ b/generated/exports/units.deps @@ -1,5 +1,6 @@ mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.config +mcpplibs.mwrap.boost.io mcpplibs.mwrap.boost.lambda mcpplibs.mwrap.boost.math mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/units.inc b/generated/exports/units.inc index 44872d711..e516ae192 100644 --- a/generated/exports/units.inc +++ b/generated/exports/units.inc @@ -1,18 +1,10 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=units boost=1.92.0 target=x86_64-w64-mingw32 entities=1162 - -export namespace boost { namespace lambda { - using boost::lambda::plain_return_type_1; - using boost::lambda::plain_return_type_2; -}} +// lib=units boost=1.92.0 target=x86_64-w64-mingw32 entities=1156 export namespace boost { namespace mpl { - using boost::mpl::deref; using boost::mpl::divides; using boost::mpl::divides_impl; using boost::mpl::divides_tag; - using boost::mpl::lambda; - using boost::mpl::less_impl; using boost::mpl::modulus; using boost::mpl::modulus_impl; using boost::mpl::modulus_tag; @@ -22,10 +14,6 @@ export namespace boost { namespace mpl { using boost::mpl::times_tag; }} -export namespace boost { namespace mpl { namespace aux { - using boost::mpl::aux::template_arity; -}}} - export namespace boost { namespace serialization { using boost::serialization::serialize; }} diff --git a/generated/exports/unordered.inc b/generated/exports/unordered.inc index c4f40a869..c519e3626 100644 --- a/generated/exports/unordered.inc +++ b/generated/exports/unordered.inc @@ -1,14 +1,21 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=unordered boost=1.92.0 target=x86_64-w64-mingw32 entities=234 +// lib=unordered boost=1.92.0 target=x86_64-w64-mingw32 entities=245 export namespace boost { - using boost::hash_is_avalanching; + using boost::concurrent_flat_map; + using boost::concurrent_flat_set; + using boost::concurrent_node_map; + using boost::concurrent_node_set; + using boost::unordered_flat_map; + using boost::unordered_flat_set; + using boost::unordered_map; + using boost::unordered_multimap; + using boost::unordered_multiset; + using boost::unordered_node_map; + using boost::unordered_node_set; + using boost::unordered_set; } -export namespace boost { namespace serialization { - using boost::serialization::version; -}} - export namespace boost { namespace tuples { using boost::tuples::null_type; }} @@ -21,6 +28,7 @@ export namespace boost { namespace unordered { using boost::unordered::erase_if; using boost::unordered::from_range; using boost::unordered::from_range_t; + using boost::unordered::hash_is_avalanching; using boost::unordered::insert_return_type_map; using boost::unordered::insert_return_type_set; using boost::unordered::node_handle_map; diff --git a/generated/exports/url.deps b/generated/exports/url.deps index 3cc5c4cb2..6af58f254 100644 --- a/generated/exports/url.deps +++ b/generated/exports/url.deps @@ -1,5 +1,6 @@ mcpplibs.mwrap.boost.assert mcpplibs.mwrap.boost.core +mcpplibs.mwrap.boost.mp11 mcpplibs.mwrap.boost.optional mcpplibs.mwrap.boost.system mcpplibs.mwrap.boost.type_traits diff --git a/generated/exports/url.inc b/generated/exports/url.inc index 4fe454f51..4f2188caa 100644 --- a/generated/exports/url.inc +++ b/generated/exports/url.inc @@ -1,17 +1,11 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=url boost=1.92.0 target=x86_64-w64-mingw32 entities=319 +// lib=url boost=1.92.0 target=x86_64-w64-mingw32 entities=318 export namespace boost { using boost::url; using boost::url_view; } -export namespace boost { namespace system { - using boost::system::generic_category; - using boost::system::result; - using boost::system::system_category; -}} - export namespace boost { namespace urls { using boost::urls::absolute_uri_rule; using boost::urls::arg; @@ -207,7 +201,9 @@ export namespace boost { namespace urls { namespace error_types { using boost::urls::error_types::error_category; using boost::urls::error_types::error_code; using boost::urls::error_types::error_condition; + using boost::urls::error_types::generic_category; using boost::urls::error_types::result; + using boost::urls::error_types::system_category; using boost::urls::error_types::system_error; }}} diff --git a/generated/exports/utility.inc b/generated/exports/utility.inc index 60c467231..2345a4043 100644 --- a/generated/exports/utility.inc +++ b/generated/exports/utility.inc @@ -1,13 +1,10 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=utility boost=1.92.0 target=x86_64-w64-mingw32 entities=81 +// lib=utility boost=1.92.0 target=x86_64-w64-mingw32 entities=75 export namespace boost { using boost::base_from_member; - // M11: basic_string_ref dropped — declared only via string_ref.hpp (curated out of - // the module GMF; gcc 16.1 buffer_fill enum mismatch). using boost::basic_string_view; using boost::compressed_pair; - using boost::enable_if_c; using boost::equal_pointees; using boost::equal_pointees_t; using boost::get; @@ -38,8 +35,6 @@ export namespace boost { using boost::operator>; using boost::operator>=; using boost::result_of; - // M11: string_ref dropped — declared only via string_ref.hpp (curated out of - // the module GMF; gcc 16.1 buffer_fill enum mismatch). using boost::string_view; using boost::swap; using boost::tr1_result_of; @@ -55,15 +50,9 @@ export namespace boost { using boost::typed_in_place_factory8; using boost::typed_in_place_factory9; using boost::typed_in_place_factory_base; - // M11: u16string_ref dropped — declared only via string_ref.hpp (curated out of - // the module GMF; gcc 16.1 buffer_fill enum mismatch). using boost::u16string_view; - // M11: u32string_ref dropped — declared only via string_ref.hpp (curated out of - // the module GMF; gcc 16.1 buffer_fill enum mismatch). using boost::u32string_view; using boost::value_initialized; - // M11: wstring_ref dropped — declared only via string_ref.hpp (curated out of - // the module GMF; gcc 16.1 buffer_fill enum mismatch). using boost::wstring_view; } diff --git a/generated/exports/uuid.inc b/generated/exports/uuid.inc index c4e744496..28887d1e4 100644 --- a/generated/exports/uuid.inc +++ b/generated/exports/uuid.inc @@ -50,9 +50,9 @@ export namespace boost { namespace uuids { namespace detail { using boost::uuids::detail::byteswap; using boost::uuids::detail::chacha20_12; #if defined(BOOST_UUID_USE_SSE2) + // The SIMD to_chars/from_chars helpers are declared only under + // BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. using boost::uuids::detail::compare; -#endif -#if defined(BOOST_UUID_USE_SSE2) using boost::uuids::detail::countr_zero_nz; #endif using boost::uuids::detail::fc_error_to_string; @@ -63,18 +63,12 @@ export namespace boost { namespace uuids { namespace detail { using boost::uuids::detail::from_chars_is_dash; using boost::uuids::detail::from_chars_is_opening_brace; #if defined(BOOST_UUID_USE_SSE2) + // The SIMD to_chars/from_chars helpers are declared only under + // BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. using boost::uuids::detail::from_chars_simd; -#endif -#if defined(BOOST_UUID_USE_SSE2) using boost::uuids::detail::from_chars_simd_char_constants; -#endif -#if defined(BOOST_UUID_USE_SSE2) using boost::uuids::detail::from_chars_simd_constants; -#endif -#if defined(BOOST_UUID_USE_SSE2) using boost::uuids::detail::from_chars_simd_core; -#endif -#if defined(BOOST_UUID_USE_SSE2) using boost::uuids::detail::from_chars_simd_load_traits; #endif using boost::uuids::detail::hash_mix_fmx; @@ -106,15 +100,11 @@ export namespace boost { namespace uuids { namespace detail { using boost::uuids::detail::random_provider; using boost::uuids::detail::sha1; #if defined(BOOST_UUID_USE_SSE2) + // The SIMD to_chars/from_chars helpers are declared only under + // BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. using boost::uuids::detail::simd_vector; -#endif -#if defined(BOOST_UUID_USE_SSE2) using boost::uuids::detail::simd_vector128; -#endif -#if defined(BOOST_UUID_USE_SSE2) using boost::uuids::detail::simd_vector256; -#endif -#if defined(BOOST_UUID_USE_SSE2) using boost::uuids::detail::simd_vector512; #endif using boost::uuids::detail::store_big_u128; @@ -135,15 +125,11 @@ export namespace boost { namespace uuids { namespace detail { using boost::uuids::detail::to_chars_digits; using boost::uuids::detail::to_chars_generic; #if defined(BOOST_UUID_USE_SSE2) + // The SIMD to_chars/from_chars helpers are declared only under + // BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. using boost::uuids::detail::to_chars_simd; -#endif -#if defined(BOOST_UUID_USE_SSE2) using boost::uuids::detail::to_chars_simd_char_constants; -#endif -#if defined(BOOST_UUID_USE_SSE2) using boost::uuids::detail::to_chars_simd_constants; -#endif -#if defined(BOOST_UUID_USE_SSE2) using boost::uuids::detail::to_chars_simd_core; #endif using boost::uuids::detail::uuid_from_string; diff --git a/generated/exports/variant.inc b/generated/exports/variant.inc index 99a0c7cf5..d11e2808b 100644 --- a/generated/exports/variant.inc +++ b/generated/exports/variant.inc @@ -1,5 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=variant boost=1.92.0 target=x86_64-w64-mingw32 entities=341 +// lib=variant boost=1.92.0 target=x86_64-w64-mingw32 entities=347 export namespace boost { using boost::apply_visitor; @@ -11,10 +11,7 @@ export namespace boost { using boost::blank; using boost::call_traits; using boost::get; - using boost::has_nothrow_copy; using boost::hash_value; - using boost::is_constructible; - using boost::is_nothrow_move_constructible; using boost::is_recursive_wrapper; using boost::is_static_visitor; using boost::make_recursive_variant; @@ -134,6 +131,21 @@ export namespace boost { namespace detail { namespace variant { }}} export namespace boost { namespace mpl { + using ::mpl_::_; + using ::mpl_::_1; + using ::mpl_::_2; + using ::mpl_::_3; + using ::mpl_::_4; + using ::mpl_::_5; + using ::mpl_::_6; + using ::mpl_::arg; + using ::mpl_::false_; + using ::mpl_::int_; + using ::mpl_::long_; + using ::mpl_::na; + using ::mpl_::size_t; + using ::mpl_::true_; + using ::mpl_::void_; using boost::mpl::O1_size; using boost::mpl::O1_size_impl; using boost::mpl::advance; @@ -165,7 +177,6 @@ export namespace boost { namespace mpl { using boost::mpl::bind4; using boost::mpl::bind5; using boost::mpl::clear; - using boost::mpl::clear_impl; using boost::mpl::deref; using boost::mpl::distance; using boost::mpl::distance_impl; @@ -179,7 +190,6 @@ export namespace boost { namespace mpl { using boost::mpl::first; using boost::mpl::fold; using boost::mpl::front; - using boost::mpl::front_impl; using boost::mpl::front_inserter; using boost::mpl::has_push_back; using boost::mpl::has_push_back_arg; @@ -262,9 +272,7 @@ export namespace boost { namespace mpl { using boost::mpl::prior; using boost::mpl::protect; using boost::mpl::push_back; - using boost::mpl::push_back_impl; using boost::mpl::push_front; - using boost::mpl::push_front_impl; using boost::mpl::quote1; using boost::mpl::quote2; using boost::mpl::quote3; @@ -278,9 +286,7 @@ export namespace boost { namespace mpl { using boost::mpl::reverse_transform2; using boost::mpl::same_as; using boost::mpl::second; - using boost::mpl::sequence_tag; using boost::mpl::size; - using boost::mpl::size_impl; using boost::mpl::sizeof_; using boost::mpl::tag; using boost::mpl::transform; @@ -294,7 +300,8 @@ export namespace boost { namespace mpl { namespace aux { using boost::mpl::aux::advance_forward; using boost::mpl::aux::and_impl; #if defined(__GNUC__) - // M3 hand-guard: gcc-preprocessed mpl headers only (BOOST_MPL_CFG_COMPILER_DIR=gcc). + // M3 hand-guard: gcc-preprocessed mpl headers only + // (BOOST_MPL_CFG_COMPILER_DIR=gcc). using boost::mpl::aux::arity_helper; using boost::mpl::aux::arity_tag; #endif diff --git a/generated/exports/version.deps b/generated/exports/version.deps index dcd0ad9dd..bd37a576a 100644 --- a/generated/exports/version.deps +++ b/generated/exports/version.deps @@ -1,4 +1 @@ -# SPECIAL module: hand-written, no gen_exports bundle TU. `version` is the thin -# entry that re-exports the macro mapping module, so its only import edge is -# `.macros`; the constants themselves live there (one export owner). mcpplibs.mwrap.boost.macros diff --git a/generated/exports/wave.deps b/generated/exports/wave.deps index d2284861b..d897c6bca 100644 --- a/generated/exports/wave.deps +++ b/generated/exports/wave.deps @@ -4,7 +4,9 @@ mcpplibs.mwrap.boost.config mcpplibs.mwrap.boost.core mcpplibs.mwrap.boost.filesystem mcpplibs.mwrap.boost.format +mcpplibs.mwrap.boost.io mcpplibs.mwrap.boost.iterator +mcpplibs.mwrap.boost.mp11 mcpplibs.mwrap.boost.multi_index mcpplibs.mwrap.boost.optional mcpplibs.mwrap.boost.pool diff --git a/generated/exports/wave.inc b/generated/exports/wave.inc index 30f07ce24..0239a3622 100644 --- a/generated/exports/wave.inc +++ b/generated/exports/wave.inc @@ -1,19 +1,5 @@ // GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=wave boost=1.92.0 target=x86_64-w64-mingw32 entities=890 - -export namespace boost { - using boost::call_traits; - using boost::remove_reference; -} - -export namespace boost { namespace multi_index { - using boost::multi_index::indexed_by; - using boost::multi_index::member; - using boost::multi_index::multi_index_container; - using boost::multi_index::ordered_non_unique; - using boost::multi_index::ordered_unique; - using boost::multi_index::tag; -}} +// lib=wave boost=1.92.0 target=x86_64-w64-mingw32 entities=878 export namespace boost { namespace spirit { using boost::spirit::make_default_multi_pass; @@ -43,7 +29,6 @@ export namespace boost { namespace spirit { namespace classic { using boost::spirit::classic::binary_right_subject; using boost::spirit::classic::bounded; using boost::spirit::classic::bounded_gen; - using boost::spirit::classic::chlit; using boost::spirit::classic::closure; using boost::spirit::classic::closure_context; using boost::spirit::classic::closure_context_linker; @@ -170,8 +155,6 @@ export namespace boost { namespace spirit { namespace classic { using boost::spirit::classic::operator~; using boost::spirit::classic::optional; using boost::spirit::classic::optional_parser_gen; - using boost::spirit::classic::parser; - using boost::spirit::classic::parser_context; using boost::spirit::classic::position_iterator; using boost::spirit::classic::position_iterator2; using boost::spirit::classic::position_policy; @@ -202,7 +185,6 @@ export namespace boost { namespace spirit { namespace classic { using boost::spirit::classic::static_; using boost::spirit::classic::strict_real_parser_policies; using boost::spirit::classic::strict_ureal_parser_policies; - using boost::spirit::classic::strlit; using boost::spirit::classic::subrule; using boost::spirit::classic::subrule_list; using boost::spirit::classic::subrule_parser; diff --git a/generated/exports/winapi.deps b/generated/exports/winapi.deps deleted file mode 100644 index c63a6b32b..000000000 --- a/generated/exports/winapi.deps +++ /dev/null @@ -1 +0,0 @@ -mcpplibs.mwrap.boost.config diff --git a/generated/meta/api-surface.json b/generated/meta/api-surface.json new file mode 100644 index 000000000..5e0765261 --- /dev/null +++ b/generated/meta/api-surface.json @@ -0,0 +1,2804 @@ +{ + "boost": "1.92.0", + "generator": { + "ast": "clang++ -ast-dump=json", + "clang": "23.1.3", + "defines": [ + "_WIN32_WINNT=0x0A00", + "WIN32_LEAN_AND_MEAN" + ], + "target": "x86_64-w64-mingw32", + "tool": "tools/gen_exports.py" + }, + "libraries": { + "accumulators": { + "deps": [ + "array", + "assert", + "circular_buffer", + "concept_check", + "config", + "core", + "iterator", + "mp11", + "numeric", + "type_traits", + "utility" + ], + "exported": 711, + "gmf": [ + "boost/accumulators/statistics.hpp", + "boost/accumulators/statistics/p_square_cumulative_distribution.hpp", + "boost/accumulators/statistics/rolling_variance.hpp", + "boost/accumulators/statistics/weighted_p_square_cumulative_distribution.hpp" + ] + }, + "algorithm": { + "deps": [ + "assert", + "bind", + "concept_check", + "config", + "core", + "function", + "range", + "smart_ptr", + "throw_exception", + "tuple", + "type_traits" + ], + "exported": 477, + "gmf": [ + "boost/algorithm/algorithm.hpp", + "boost/algorithm/apply_permutation.hpp", + "boost/algorithm/clamp.hpp", + "boost/algorithm/cxx11/all_of.hpp", + "boost/algorithm/cxx11/any_of.hpp", + "boost/algorithm/cxx11/copy_if.hpp", + "boost/algorithm/cxx11/copy_n.hpp", + "boost/algorithm/cxx11/find_if_not.hpp", + "boost/algorithm/cxx11/iota.hpp", + "boost/algorithm/cxx11/is_partitioned.hpp", + "boost/algorithm/cxx11/is_sorted.hpp", + "boost/algorithm/cxx11/one_of.hpp", + "boost/algorithm/cxx11/partition_copy.hpp", + "boost/algorithm/cxx11/partition_point.hpp", + "boost/algorithm/cxx14/equal.hpp", + "boost/algorithm/cxx14/is_permutation.hpp", + "boost/algorithm/cxx17/exclusive_scan.hpp", + "boost/algorithm/cxx17/for_each_n.hpp", + "boost/algorithm/cxx17/inclusive_scan.hpp", + "boost/algorithm/cxx17/reduce.hpp", + "boost/algorithm/cxx17/transform_exclusive_scan.hpp", + "boost/algorithm/cxx17/transform_inclusive_scan.hpp", + "boost/algorithm/cxx17/transform_reduce.hpp", + "boost/algorithm/find_backward.hpp", + "boost/algorithm/find_not.hpp", + "boost/algorithm/gather.hpp", + "boost/algorithm/hex.hpp", + "boost/algorithm/is_clamped.hpp", + "boost/algorithm/is_palindrome.hpp", + "boost/algorithm/is_partitioned_until.hpp", + "boost/algorithm/minmax.hpp", + "boost/algorithm/minmax_element.hpp", + "boost/algorithm/searching/boyer_moore.hpp", + "boost/algorithm/searching/boyer_moore_horspool.hpp", + "boost/algorithm/searching/knuth_morris_pratt.hpp", + "boost/algorithm/sort_subrange.hpp", + "boost/algorithm/string.hpp", + "boost/algorithm/string/trim_all.hpp" + ] + }, + "align": { + "deps": [ + "core" + ], + "exported": 28, + "gmf": [ + "boost/align.hpp" + ] + }, + "any": { + "deps": [ + "assert", + "config", + "throw_exception", + "type_index" + ], + "exported": 28, + "gmf": [ + "boost/any.hpp", + "boost/any/basic_any.hpp", + "boost/any/unique_any.hpp" + ] + }, + "array": { + "deps": [ + "assert", + "config", + "throw_exception" + ], + "exported": 12, + "gmf": [ + "boost/array.hpp" + ] + }, + "asio": { + "deps": [ + "align", + "assert", + "date_time", + "smart_ptr", + "system", + "type_traits" + ], + "exported": 1426, + "gmf": [ + "boost/asio.hpp", + "boost/asio/deadline_timer.hpp", + "boost/asio/experimental/as_single.hpp", + "boost/asio/experimental/awaitable_operators.hpp", + "boost/asio/experimental/channel.hpp", + "boost/asio/experimental/co_composed.hpp", + "boost/asio/experimental/co_spawn.hpp", + "boost/asio/experimental/concurrent_channel.hpp", + "boost/asio/experimental/promise.hpp", + "boost/asio/experimental/use_coro.hpp", + "boost/asio/fwd.hpp", + "boost/asio/spawn.hpp", + "boost/asio/ssl/stream_base.hpp", + "boost/asio/ts/net.hpp", + "boost/asio/unyield.hpp", + "boost/asio/yield.hpp" + ] + }, + "assert": { + "deps": [ + "config" + ], + "exported": 32, + "gmf": [ + "boost/assert.hpp", + "boost/assert/source_location.hpp" + ] + }, + "assign": { + "deps": [ + "assert", + "config", + "move", + "ptr_container", + "type_traits" + ], + "exported": 56, + "gmf": [ + "boost/assign.hpp", + "boost/assign/ptr_list_inserter.hpp", + "boost/assign/ptr_list_of.hpp", + "boost/assign/ptr_map_inserter.hpp" + ] + }, + "atomic": { + "deps": [ + "config", + "winapi" + ], + "exported": 216, + "gmf": [ + "boost/atomic.hpp" + ] + }, + "beast": { + "deps": [ + "asio", + "assert", + "config", + "container_hash", + "core", + "endian", + "intrusive", + "logic", + "mp11", + "optional", + "smart_ptr", + "static_string", + "system", + "throw_exception", + "type_index", + "utility", + "winapi" + ], + "exported": 499, + "gmf": [ + "boost/beast.hpp", + "boost/beast/_experimental/http/icy_stream.hpp", + "boost/beast/_experimental/test/immediate_executor.hpp", + "boost/beast/_experimental/test/stream.hpp", + "boost/beast/_experimental/test/tcp.hpp", + "boost/beast/_experimental/unit_test/dstream.hpp", + "boost/beast/_experimental/unit_test/match.hpp", + "boost/beast/_experimental/unit_test/reporter.hpp", + "boost/beast/core/buffer_ref.hpp", + "boost/beast/core/string_param.hpp" + ] + }, + "bimap": { + "deps": [ + "assert", + "concept_check", + "config", + "core", + "functional", + "lambda", + "multi_index", + "type_traits" + ], + "exported": 190, + "gmf": [ + "boost/bimap.hpp", + "boost/bimap/container_adaptor/support/iterator_facade_converters.hpp", + "boost/bimap/list_of.hpp", + "boost/bimap/multiset_of.hpp", + "boost/bimap/property_map/set_support.hpp", + "boost/bimap/property_map/unordered_set_support.hpp", + "boost/bimap/relation/mutant_relation.hpp", + "boost/bimap/relation/support/get_pair_functor.hpp", + "boost/bimap/relation/support/is_tag_of_member_at.hpp", + "boost/bimap/relation/support/opposite_tag.hpp", + "boost/bimap/support/lambda.hpp", + "boost/bimap/support/value_type_by.hpp", + "boost/bimap/tags/support/apply_to_value_type.hpp", + "boost/bimap/tags/support/is_tagged.hpp", + "boost/bimap/tags/support/overwrite_tagged.hpp", + "boost/bimap/unconstrained_set_of.hpp", + "boost/bimap/unordered_multiset_of.hpp", + "boost/bimap/vector_of.hpp" + ] + }, + "bind": { + "deps": [ + "config", + "core" + ], + "exported": 78, + "gmf": [ + "boost/bind.hpp", + "boost/bind/apply.hpp", + "boost/bind/make_adaptable.hpp", + "boost/bind/protect.hpp" + ] + }, + "bloom": { + "deps": [ + "assert", + "container_hash", + "core" + ], + "exported": 45, + "gmf": [ + "boost/bloom.hpp" + ] + }, + "callable_traits": { + "deps": [], + "exported": 203, + "gmf": [ + "boost/callable_traits.hpp", + "boost/callable_traits/is_cv_member.hpp" + ] + }, + "charconv": { + "deps": [ + "assert", + "core" + ], + "exported": 61, + "gmf": [ + "boost/charconv.hpp" + ] + }, + "chrono": { + "deps": [ + "assert", + "config", + "core", + "integer", + "move", + "ratio", + "system", + "type_traits" + ], + "exported": 71, + "gmf": [ + "boost/chrono.hpp", + "boost/chrono/typeof/boost/chrono/chrono.hpp", + "boost/chrono/typeof/boost/ratio.hpp" + ] + }, + "circular_buffer": { + "deps": [ + "assert", + "concept_check", + "config", + "core", + "move", + "type_traits" + ], + "exported": 23, + "gmf": [ + "boost/circular_buffer.hpp" + ] + }, + "cobalt": { + "deps": [ + "asio", + "assert", + "callable_traits", + "circular_buffer", + "config", + "core", + "endian", + "intrusive", + "mp11", + "smart_ptr", + "system", + "utility", + "variant2" + ], + "exported": 211, + "gmf": [ + "boost/cobalt.hpp", + "boost/cobalt/composition.hpp", + "boost/cobalt/experimental/context.hpp", + "boost/cobalt/experimental/yield_context.hpp", + "boost/cobalt/io.hpp" + ] + }, + "compat": { + "deps": [ + "assert", + "config", + "throw_exception" + ], + "exported": 76, + "gmf": [ + "boost/compat/bind_back.hpp", + "boost/compat/bind_front.hpp", + "boost/compat/function_ref.hpp", + "boost/compat/latch.hpp", + "boost/compat/move_only_function.hpp", + "boost/compat/shared_lock.hpp", + "boost/compat/to_array.hpp", + "boost/compat/to_underlying.hpp" + ] + }, + "concept_check": { + "deps": [ + "config", + "type_traits" + ], + "exported": 143, + "gmf": [ + "boost/concept_check.hpp", + "boost/concept_check/borland.hpp", + "boost/concept_check/general.hpp" + ] + }, + "config": { + "deps": [], + "exported": 4, + "gmf": [ + "boost/config.hpp" + ] + }, + "container": { + "deps": [ + "assert", + "config", + "intrusive", + "move" + ], + "exported": 976, + "gmf": [ + "boost/container/adaptive_pool.hpp", + "boost/container/allocator.hpp", + "boost/container/experimental/pmr/nest.hpp", + "boost/container/experimental/segmented_all_of.hpp", + "boost/container/experimental/segmented_any_of.hpp", + "boost/container/experimental/segmented_copy_if.hpp", + "boost/container/experimental/segmented_copy_n.hpp", + "boost/container/experimental/segmented_count.hpp", + "boost/container/experimental/segmented_count_if.hpp", + "boost/container/experimental/segmented_equal.hpp", + "boost/container/experimental/segmented_fill.hpp", + "boost/container/experimental/segmented_find_last.hpp", + "boost/container/experimental/segmented_find_last_if_not.hpp", + "boost/container/experimental/segmented_for_each.hpp", + "boost/container/experimental/segmented_generate.hpp", + "boost/container/experimental/segmented_generate_n.hpp", + "boost/container/experimental/segmented_is_partitioned.hpp", + "boost/container/experimental/segmented_is_sorted.hpp", + "boost/container/experimental/segmented_merge.hpp", + "boost/container/experimental/segmented_partition.hpp", + "boost/container/experimental/segmented_partition_copy.hpp", + "boost/container/experimental/segmented_partition_point.hpp", + "boost/container/experimental/segmented_remove.hpp", + "boost/container/experimental/segmented_remove_if.hpp", + "boost/container/experimental/segmented_replace.hpp", + "boost/container/experimental/segmented_replace_if.hpp", + "boost/container/experimental/segmented_reverse.hpp", + "boost/container/experimental/segmented_reverse_copy.hpp", + "boost/container/experimental/segmented_search.hpp", + "boost/container/experimental/segmented_search_n.hpp", + "boost/container/experimental/segmented_set_difference.hpp", + "boost/container/experimental/segmented_set_intersection.hpp", + "boost/container/experimental/segmented_set_symmetric_difference.hpp", + "boost/container/experimental/segmented_set_union.hpp", + "boost/container/experimental/segmented_stable_partition.hpp", + "boost/container/experimental/segmented_swap_ranges.hpp", + "boost/container/experimental/segmented_transform.hpp", + "boost/container/experimental/wrapped_iterator.hpp", + "boost/container/node_handle.hpp", + "boost/container/pmr/deque.hpp", + "boost/container/pmr/devector.hpp", + "boost/container/pmr/flat_map.hpp", + "boost/container/pmr/flat_set.hpp", + "boost/container/pmr/hub.hpp", + "boost/container/pmr/list.hpp", + "boost/container/pmr/map.hpp", + "boost/container/pmr/monotonic_buffer_resource.hpp", + "boost/container/pmr/pool_options.hpp", + "boost/container/pmr/resource_adaptor.hpp", + "boost/container/pmr/segtor.hpp", + "boost/container/pmr/set.hpp", + "boost/container/pmr/slist.hpp", + "boost/container/pmr/small_vector.hpp", + "boost/container/pmr/stable_vector.hpp", + "boost/container/pmr/string.hpp", + "boost/container/pmr/synchronized_pool_resource.hpp", + "boost/container/pmr/unsynchronized_pool_resource.hpp", + "boost/container/pmr/vector.hpp", + "boost/container/scoped_allocator.hpp", + "boost/container/static_vector.hpp", + "boost/container/uses_allocator.hpp", + "boost/container/uses_allocator_construction.hpp" + ] + }, + "container_hash": { + "deps": [ + "mp11" + ], + "exported": 76, + "gmf": [ + "boost/container_hash/extensions.hpp", + "boost/container_hash/is_tuple_like.hpp" + ] + }, + "contract": { + "deps": [ + "any", + "assert", + "config", + "core", + "function", + "optional", + "smart_ptr", + "thread", + "type_traits", + "utility" + ], + "exported": 173, + "gmf": [ + "boost/contract/assert.hpp", + "boost/contract/base_types.hpp", + "boost/contract/call_if.hpp", + "boost/contract/check.hpp", + "boost/contract/constructor.hpp", + "boost/contract/core/access.hpp", + "boost/contract/core/check_macro.hpp", + "boost/contract/core/config.hpp", + "boost/contract/core/constructor_precondition.hpp", + "boost/contract/core/exception.hpp", + "boost/contract/core/specify.hpp", + "boost/contract/core/virtual.hpp", + "boost/contract/destructor.hpp", + "boost/contract/function.hpp", + "boost/contract/old.hpp", + "boost/contract/override.hpp", + "boost/contract/public_function.hpp", + "boost/contract.hpp" + ] + }, + "convert": { + "deps": [ + "assert", + "core", + "optional", + "type_traits" + ], + "exported": 12, + "gmf": [ + "boost/convert.hpp" + ] + }, + "core": { + "deps": [ + "assert", + "config", + "throw_exception" + ], + "exported": 270, + "gmf": [ + "boost/core/alloc_construct.hpp", + "boost/core/allocator_traits.hpp", + "boost/core/bit.hpp", + "boost/core/checked_delete.hpp", + "boost/core/cmath.hpp", + "boost/core/default_allocator.hpp", + "boost/core/empty_value.hpp", + "boost/core/exchange.hpp", + "boost/core/explicit_operator_bool.hpp", + "boost/core/fclose_deleter.hpp", + "boost/core/first_scalar.hpp", + "boost/core/functor.hpp", + "boost/core/identity.hpp", + "boost/core/ignore_unused.hpp", + "boost/core/is_same.hpp", + "boost/core/launder.hpp", + "boost/core/lightweight_test_trait.hpp", + "boost/core/make_span.hpp", + "boost/core/memory_resource.hpp", + "boost/core/no_exceptions_support.hpp", + "boost/core/noncopyable.hpp", + "boost/core/null_deleter.hpp", + "boost/core/pointer_in_range.hpp", + "boost/core/quick_exit.hpp", + "boost/core/ref.hpp", + "boost/core/scoped_enum.hpp", + "boost/core/serialization.hpp", + "boost/core/size.hpp", + "boost/core/snprintf.hpp", + "boost/core/swap.hpp", + "boost/core/typeinfo.hpp", + "boost/core/uncaught_exceptions.hpp", + "boost/core/underlying_type.hpp", + "boost/core/use_default.hpp", + "boost/core/verbose_terminate_handler.hpp", + "boost/core/yield_primitives.hpp" + ] + }, + "crc": { + "deps": [], + "exported": 44, + "gmf": [ + "boost/crc.hpp" + ] + }, + "date_time": { + "deps": [ + "algorithm", + "assert", + "core", + "io", + "iterator", + "numeric", + "smart_ptr", + "throw_exception", + "tokenizer", + "type_traits" + ], + "exported": 391, + "gmf": [ + "boost/date_time.hpp", + "boost/date_time/c_local_time_adjustor.hpp", + "boost/date_time/local_time_adjustor.hpp", + "boost/date_time/local_timezone_defs.hpp", + "boost/date_time/posix_time/time_serialize.hpp" + ] + }, + "decimal": { + "deps": [], + "exported": 914, + "gmf": [ + "boost/decimal.hpp", + "boost/decimal/fmt_format.hpp" + ] + }, + "dll": { + "deps": [ + "assert", + "core", + "filesystem", + "io", + "type_index", + "winapi" + ], + "exported": 150, + "gmf": [ + "boost/dll.hpp", + "boost/dll/import_class.hpp", + "boost/dll/shared_library_load_mode.hpp" + ] + }, + "dynamic_bitset": { + "deps": [ + "assert", + "container_hash", + "core" + ], + "exported": 34, + "gmf": [ + "boost/dynamic_bitset.hpp", + "boost/dynamic_bitset/serialization.hpp" + ] + }, + "endian": { + "deps": [], + "exported": 236, + "gmf": [ + "boost/endian.hpp" + ] + }, + "filesystem": { + "deps": [ + "container_hash", + "io", + "iterator", + "smart_ptr", + "system" + ], + "exported": 244, + "gmf": [ + "boost/filesystem.hpp", + "boost/filesystem/cstdio.hpp", + "boost/filesystem/fstream.hpp" + ] + }, + "flyweight": { + "deps": [ + "assert", + "config", + "container_hash", + "core", + "interprocess", + "mp11", + "multi_index", + "smart_ptr", + "throw_exception", + "type_traits", + "unordered" + ], + "exported": 81, + "gmf": [ + "boost/flyweight.hpp", + "boost/flyweight/concurrent_factory.hpp", + "boost/flyweight/intermodule_holder.hpp", + "boost/flyweight/key_value.hpp", + "boost/flyweight/no_locking.hpp", + "boost/flyweight/no_tracking.hpp", + "boost/flyweight/serialize.hpp", + "boost/flyweight/set_factory.hpp" + ] + }, + "format": { + "deps": [ + "assert", + "config", + "optional", + "smart_ptr", + "utility" + ], + "exported": 62, + "gmf": [ + "boost/format.hpp" + ] + }, + "function": { + "deps": [ + "assert", + "bind", + "core" + ], + "exported": 78, + "gmf": [ + "boost/function.hpp", + "boost/function/function0.hpp", + "boost/function/function1.hpp", + "boost/function/function10.hpp", + "boost/function/function2.hpp", + "boost/function/function3.hpp", + "boost/function/function4.hpp", + "boost/function/function5.hpp", + "boost/function/function6.hpp", + "boost/function/function7.hpp", + "boost/function/function8.hpp", + "boost/function/function9.hpp", + "boost/function/function_typeof.hpp" + ] + }, + "functional": { + "deps": [ + "assert", + "config", + "container_hash", + "core", + "type_traits", + "utility" + ], + "exported": 389, + "gmf": [ + "boost/functional.hpp", + "boost/functional/factory.hpp", + "boost/functional/forward_adapter.hpp", + "boost/functional/hash.hpp", + "boost/functional/hash/extensions.hpp", + "boost/functional/hash/hash.hpp", + "boost/functional/hash/hash_fwd.hpp", + "boost/functional/hash_fwd.hpp", + "boost/functional/identity.hpp", + "boost/functional/lightweight_forward_adapter.hpp", + "boost/functional/overloaded_function.hpp", + "boost/functional/value_factory.hpp" + ] + }, + "geometry": { + "deps": [ + "any", + "array", + "assert", + "concept_check", + "config", + "core", + "graph", + "iterator", + "math", + "mp11", + "polygon", + "qvm", + "range", + "rational", + "smart_ptr", + "thread", + "throw_exception", + "tokenizer", + "tuple", + "type_traits", + "utility", + "variant", + "variant2" + ], + "exported": 4675, + "gmf": [ + "boost/geometry.hpp", + "boost/geometry/algorithms/dispatch/closest_points.hpp", + "boost/geometry/algorithms/dispatch/distance.hpp", + "boost/geometry/algorithms/dispatch/expand.hpp", + "boost/geometry/algorithms/dispatch/is_simple.hpp", + "boost/geometry/algorithms/dispatch/is_valid.hpp", + "boost/geometry/algorithms/merge_elements.hpp", + "boost/geometry/core/is_areal.hpp", + "boost/geometry/formulas/gnomonic_intersection.hpp", + "boost/geometry/formulas/meridian_direct.hpp", + "boost/geometry/formulas/vertex_longitude.hpp", + "boost/geometry/geometries/adapted/boost_any.hpp", + "boost/geometry/geometries/adapted/boost_array.hpp", + "boost/geometry/geometries/adapted/boost_fusion.hpp", + "boost/geometry/geometries/adapted/boost_polygon.hpp", + "boost/geometry/geometries/adapted/boost_range/adjacent_filtered.hpp", + "boost/geometry/geometries/adapted/boost_range/filtered.hpp", + "boost/geometry/geometries/adapted/boost_range/reversed.hpp", + "boost/geometry/geometries/adapted/boost_range/sliced.hpp", + "boost/geometry/geometries/adapted/boost_range/strided.hpp", + "boost/geometry/geometries/adapted/boost_range/uniqued.hpp", + "boost/geometry/geometries/adapted/boost_tuple.hpp", + "boost/geometry/geometries/adapted/boost_variant2.hpp", + "boost/geometry/geometries/adapted/c_array.hpp", + "boost/geometry/geometries/adapted/std_any.hpp", + "boost/geometry/geometries/adapted/std_array.hpp", + "boost/geometry/geometries/adapted/std_pair_as_segment.hpp", + "boost/geometry/geometries/adapted/std_variant.hpp", + "boost/geometry/geometries/pointing_segment.hpp", + "boost/geometry/geometries/register/box.hpp", + "boost/geometry/geometries/register/linestring.hpp", + "boost/geometry/geometries/register/multi_linestring.hpp", + "boost/geometry/geometries/register/multi_point.hpp", + "boost/geometry/geometries/register/multi_polygon.hpp", + "boost/geometry/geometries/register/point.hpp", + "boost/geometry/geometries/register/ring.hpp", + "boost/geometry/geometries/register/segment.hpp", + "boost/geometry/index/adaptors/query.hpp", + "boost/geometry/index/parameters.hpp", + "boost/geometry/io/svg/write_svg.hpp", + "boost/geometry/io/svg/write_svg_multi.hpp", + "boost/geometry/io/wkt/stream.hpp", + "boost/geometry/iterators/concatenate_iterator.hpp", + "boost/geometry/iterators/flatten_iterator.hpp", + "boost/geometry/iterators/point_reverse_iterator.hpp", + "boost/geometry/policies/disjoint_interrupt_policy.hpp", + "boost/geometry/policies/is_valid/default_policy.hpp", + "boost/geometry/policies/is_valid/failing_reason_policy.hpp", + "boost/geometry/policies/is_valid/failure_type_policy.hpp", + "boost/geometry/policies/predicate_based_interrupt_policy.hpp", + "boost/geometry/policies/relate/intersection_ratios.hpp", + "boost/geometry/srs/epsg.hpp", + "boost/geometry/srs/esri.hpp", + "boost/geometry/srs/iau2000.hpp", + "boost/geometry/srs/shared_grids.hpp", + "boost/geometry/srs/shared_grids_std.hpp", + "boost/geometry/srs/transformation.hpp", + "boost/geometry/strategies/agnostic/point_in_poly_oriented_winding.hpp", + "boost/geometry/strategies/cartesian/distance_projected_point_ax.hpp", + "boost/geometry/strategies/cartesian/turn_in_ring_winding.hpp", + "boost/geometry/strategies/concepts/convex_hull_concept.hpp", + "boost/geometry/strategies/concepts/segment_intersect_concept.hpp", + "boost/geometry/strategies/concepts/simplify_concept.hpp", + "boost/geometry/strategies/concepts/within_concept.hpp", + "boost/geometry/strategies/default_comparable_distance_result.hpp", + "boost/geometry/strategies/distance/backward_compatibility.hpp", + "boost/geometry/strategies/geographic/intersection_elliptic.hpp", + "boost/geometry/strategies/geographic/mapping_ssf.hpp", + "boost/geometry/strategies/relate3/cartesian.hpp", + "boost/geometry/strategies/spherical/side_by_cross_track.hpp", + "boost/geometry/strategies/transform/srs_transformer.hpp", + "boost/geometry/strategy/cartesian/in_circle_robust.hpp", + "boost/geometry/strategy/cartesian/precise_area.hpp", + "boost/geometry/util/add_const_if_c.hpp", + "boost/geometry/util/bare_type.hpp", + "boost/geometry/util/closure_as_bool.hpp", + "boost/geometry/util/combine_if.hpp", + "boost/geometry/util/compress_variant.hpp", + "boost/geometry/util/has_infinite_coordinate.hpp", + "boost/geometry/util/has_non_finite_coordinate.hpp", + "boost/geometry/util/promote_floating_point.hpp", + "boost/geometry/util/rational.hpp", + "boost/geometry/util/transform_variant.hpp", + "boost/geometry/views/enumerate_view.hpp" + ] + }, + "gil": { + "deps": [ + "assert", + "concept_check", + "config", + "container_hash", + "core", + "mp11", + "type_traits", + "variant2" + ], + "exported": 3880, + "gmf": [ + "boost/gil/extension/dynamic_image/dynamic_at_c.hpp", + "boost/gil/extension/histogram/std.hpp", + "boost/gil/extension/io/bmp/old.hpp", + "boost/gil/extension/io/pnm/old.hpp", + "boost/gil/extension/io/targa/old.hpp", + "boost/gil/extension/numeric/algorithm.hpp", + "boost/gil/extension/numeric/channel_numeric_operations.hpp", + "boost/gil/extension/numeric/convolve.hpp", + "boost/gil/extension/numeric/kernel.hpp", + "boost/gil/extension/numeric/pixel_numeric_operations.hpp", + "boost/gil/extension/numeric/resample.hpp", + "boost/gil/extension/numeric/sampler.hpp", + "boost/gil/extension/toolbox/color_spaces/ycbcr.hpp", + "boost/gil/extension/toolbox/image_types/subchroma_image.hpp", + "boost/gil/io/bit_operations.hpp", + "boost/gil/io/io.hpp", + "boost/gil/io/reader_base.hpp", + "boost/gil/io/row_buffer_helper.hpp" + ] + }, + "graph": { + "deps": [ + "algorithm", + "any", + "array", + "assert", + "bimap", + "concept_check", + "config", + "container_hash", + "core", + "function", + "integer", + "iterator", + "lexical_cast", + "math", + "move", + "mp11", + "multi_index", + "multiprecision", + "numeric", + "optional", + "property_map", + "property_tree", + "random", + "range", + "serialization", + "smart_ptr", + "throw_exception", + "tuple", + "type_traits", + "unordered", + "utility", + "version" + ], + "exported": 3072, + "gmf": [ + "boost/graph/adj_list_serialize.hpp", + "boost/graph/adjacency_list_io.hpp", + "boost/graph/adjacency_matrix.hpp", + "boost/graph/astar_search.hpp", + "boost/graph/bc_clustering.hpp", + "boost/graph/bipartite.hpp", + "boost/graph/boyer_myrvold_planar_test.hpp", + "boost/graph/boykov_kolmogorov_max_flow.hpp", + "boost/graph/bron_kerbosch_all_cliques.hpp", + "boost/graph/chrobak_payne_drawing.hpp", + "boost/graph/circle_layout.hpp", + "boost/graph/closeness_centrality.hpp", + "boost/graph/clustering_coefficient.hpp", + "boost/graph/core_numbers.hpp", + "boost/graph/create_condensation_graph.hpp", + "boost/graph/cycle_canceling.hpp", + "boost/graph/dag_shortest_paths.hpp", + "boost/graph/degree_centrality.hpp", + "boost/graph/dijkstra_shortest_paths_no_color_map.hpp", + "boost/graph/dimacs.hpp", + "boost/graph/directed_graph.hpp", + "boost/graph/dominator_tree.hpp", + "boost/graph/eccentricity.hpp", + "boost/graph/edge_coloring.hpp", + "boost/graph/edge_connectivity.hpp", + "boost/graph/edge_list.hpp", + "boost/graph/edmunds_karp_max_flow.hpp", + "boost/graph/erdos_renyi_generator.hpp", + "boost/graph/floyd_warshall_shortest.hpp", + "boost/graph/fruchterman_reingold.hpp", + "boost/graph/geodesic_distance.hpp", + "boost/graph/graph_archetypes.hpp", + "boost/graph/graph_stats.hpp", + "boost/graph/graphml.hpp", + "boost/graph/graphviz.hpp", + "boost/graph/grid_graph.hpp", + "boost/graph/gursoy_atun_layout.hpp", + "boost/graph/hawick_circuits.hpp", + "boost/graph/howard_cycle_ratio.hpp", + "boost/graph/incremental_components.hpp", + "boost/graph/is_kuratowski_subgraph.hpp", + "boost/graph/is_straight_line_drawing.hpp", + "boost/graph/kamada_kawai_spring_layout.hpp", + "boost/graph/king_ordering.hpp", + "boost/graph/kruskal_min_spanning_tree.hpp", + "boost/graph/labeled_graph.hpp", + "boost/graph/louvain_clustering.hpp", + "boost/graph/make_biconnected_planar.hpp", + "boost/graph/make_connected.hpp", + "boost/graph/make_maximal_planar.hpp", + "boost/graph/matrix_as_graph.hpp", + "boost/graph/maximum_weighted_matching.hpp", + "boost/graph/mesh_graph_generator.hpp", + "boost/graph/metis.hpp", + "boost/graph/metric_tsp_approx.hpp", + "boost/graph/minimum_degree_ordering.hpp", + "boost/graph/neighbor_bfs.hpp", + "boost/graph/page_rank.hpp", + "boost/graph/parallel/process_group.hpp", + "boost/graph/parallel/simple_trigger.hpp", + "boost/graph/planar_canonical_ordering.hpp", + "boost/graph/plod_generator.hpp", + "boost/graph/point_traits.hpp", + "boost/graph/profile.hpp", + "boost/graph/property_iter_range.hpp", + "boost/graph/push_relabel_max_flow.hpp", + "boost/graph/r_c_shortest_paths.hpp", + "boost/graph/random_layout.hpp", + "boost/graph/random_spanning_tree.hpp", + "boost/graph/read_dimacs.hpp", + "boost/graph/rmat_graph_generator.hpp", + "boost/graph/sequential_vertex_coloring.hpp", + "boost/graph/simple_point.hpp", + "boost/graph/small_world_generator.hpp", + "boost/graph/smallest_last_ordering.hpp", + "boost/graph/ssca_graph_generator.hpp", + "boost/graph/st_connected.hpp", + "boost/graph/stoer_wagner_min_cut.hpp", + "boost/graph/successive_shortest_path_nonnegative_weights.hpp", + "boost/graph/tiernan_all_cycles.hpp", + "boost/graph/transitive_closure.hpp", + "boost/graph/transitive_reduction.hpp", + "boost/graph/two_graphs_common_spanning_trees.hpp", + "boost/graph/undirected_graph.hpp", + "boost/graph/use_mpi.hpp", + "boost/graph/vector_as_graph.hpp", + "boost/graph/vertex_and_edge_range.hpp", + "boost/graph/vf2_sub_graph_iso.hpp", + "boost/graph/wavefront.hpp", + "boost/graph/write_dimacs.hpp" + ] + }, + "hana": { + "deps": [ + "core", + "type_traits" + ], + "exported": 1046, + "gmf": [ + "boost/hana.hpp", + "boost/hana/experimental/printable.hpp", + "boost/hana/experimental/type_name.hpp", + "boost/hana/experimental/types.hpp", + "boost/hana/experimental/view.hpp", + "boost/hana/ext/boost.hpp", + "boost/hana/ext/std.hpp", + "boost/hana/fwd/core.hpp" + ] + }, + "hash2": { + "deps": [ + "assert", + "config", + "container_hash", + "mp11" + ], + "exported": 119, + "gmf": [ + "boost/hash2/blake2.hpp", + "boost/hash2/fnv1a.hpp", + "boost/hash2/hash_append.hpp", + "boost/hash2/legacy/murmur3.hpp", + "boost/hash2/legacy/spooky2.hpp", + "boost/hash2/md5.hpp", + "boost/hash2/ripemd.hpp", + "boost/hash2/sha1.hpp", + "boost/hash2/sha2.hpp", + "boost/hash2/sha3.hpp", + "boost/hash2/siphash.hpp", + "boost/hash2/xxh3.hpp", + "boost/hash2/xxhash.hpp" + ] + }, + "heap": { + "deps": [ + "assert", + "concept_check", + "config", + "core", + "intrusive", + "iterator", + "mp11", + "type_traits" + ], + "exported": 92, + "gmf": [ + "boost/heap/binomial_heap.hpp", + "boost/heap/d_ary_heap.hpp", + "boost/heap/fibonacci_heap.hpp", + "boost/heap/heap_merge.hpp", + "boost/heap/pairing_heap.hpp", + "boost/heap/priority_queue.hpp", + "boost/heap/skew_heap.hpp" + ] + }, + "histogram": { + "deps": [ + "assert", + "core", + "math", + "mp11", + "serialization" + ], + "exported": 382, + "gmf": [ + "boost/histogram.hpp", + "boost/histogram/ostream.hpp", + "boost/histogram/serialization.hpp", + "boost/histogram/utility/clopper_pearson_interval.hpp", + "boost/histogram/utility/jeffreys_interval.hpp", + "boost/histogram/utility/wald_interval.hpp" + ] + }, + "hof": { + "deps": [], + "exported": 355, + "gmf": [ + "boost/hof.hpp", + "boost/hof/version.hpp" + ] + }, + "icl": { + "deps": [ + "assert", + "config", + "date_time", + "io", + "iterator", + "rational", + "smart_ptr", + "type_traits", + "utility" + ], + "exported": 414, + "gmf": [ + "boost/icl/concept/interval_set_value.hpp", + "boost/icl/gregorian.hpp", + "boost/icl/map.hpp", + "boost/icl/predicates/distinct_equal.hpp", + "boost/icl/predicates/element_equal.hpp", + "boost/icl/predicates/std_equal.hpp", + "boost/icl/predicates/sub_super_set.hpp", + "boost/icl/ptime.hpp", + "boost/icl/rational.hpp", + "boost/icl/separate_interval_set.hpp", + "boost/icl/set.hpp", + "boost/icl/split_interval_map.hpp", + "boost/icl/type_traits/adds_inversely.hpp", + "boost/icl/type_traits/difference.hpp" + ] + }, + "integer": { + "deps": [ + "assert", + "config", + "core", + "throw_exception", + "type_traits" + ], + "exported": 63, + "gmf": [ + "boost/integer/common_factor.hpp", + "boost/integer/integer_log2.hpp", + "boost/integer/integer_mask.hpp", + "boost/integer/mod_inverse.hpp", + "boost/integer/static_log2.hpp", + "boost/integer/static_min_max.hpp" + ] + }, + "interprocess": { + "deps": [ + "assert", + "config", + "container", + "intrusive", + "move", + "winapi" + ], + "exported": 716, + "gmf": [ + "boost/interprocess/allocators/adaptive_pool.hpp", + "boost/interprocess/allocators/cached_adaptive_pool.hpp", + "boost/interprocess/allocators/cached_node_allocator.hpp", + "boost/interprocess/allocators/node_allocator.hpp", + "boost/interprocess/allocators/private_node_allocator.hpp", + "boost/interprocess/anonymous_shared_memory.hpp", + "boost/interprocess/containers/deque.hpp", + "boost/interprocess/containers/flat_map.hpp", + "boost/interprocess/containers/flat_set.hpp", + "boost/interprocess/containers/list.hpp", + "boost/interprocess/containers/map.hpp", + "boost/interprocess/containers/pair.hpp", + "boost/interprocess/containers/set.hpp", + "boost/interprocess/containers/slist.hpp", + "boost/interprocess/containers/stable_vector.hpp", + "boost/interprocess/containers/string.hpp", + "boost/interprocess/containers/vector.hpp", + "boost/interprocess/indexes/flat_map_index.hpp", + "boost/interprocess/indexes/iunordered_set_index.hpp", + "boost/interprocess/indexes/map_index.hpp", + "boost/interprocess/indexes/null_index.hpp", + "boost/interprocess/ipc/message_queue.hpp", + "boost/interprocess/managed_external_buffer.hpp", + "boost/interprocess/managed_heap_memory.hpp", + "boost/interprocess/managed_mapped_file.hpp", + "boost/interprocess/managed_shared_memory.hpp", + "boost/interprocess/managed_windows_shared_memory.hpp", + "boost/interprocess/mem_algo/simple_seq_fit.hpp", + "boost/interprocess/segment_manager.hpp", + "boost/interprocess/smart_ptr/enable_shared_from_this.hpp", + "boost/interprocess/smart_ptr/intrusive_ptr.hpp", + "boost/interprocess/smart_ptr/scoped_ptr.hpp", + "boost/interprocess/smart_ptr/unique_ptr.hpp", + "boost/interprocess/streams/bufferstream.hpp", + "boost/interprocess/streams/vectorstream.hpp", + "boost/interprocess/sync/file_lock.hpp", + "boost/interprocess/sync/interprocess_condition_any.hpp", + "boost/interprocess/sync/named_condition.hpp", + "boost/interprocess/sync/named_condition_any.hpp", + "boost/interprocess/sync/named_recursive_mutex.hpp", + "boost/interprocess/sync/named_semaphore.hpp", + "boost/interprocess/sync/named_sharable_mutex.hpp", + "boost/interprocess/sync/sharable_lock.hpp", + "boost/interprocess/sync/upgradable_lock.hpp" + ] + }, + "intrusive": { + "deps": [ + "move" + ], + "exported": 502, + "gmf": [ + "boost/intrusive/any_hook.hpp", + "boost/intrusive/avl_set.hpp", + "boost/intrusive/bs_set.hpp", + "boost/intrusive/derivation_value_traits.hpp", + "boost/intrusive/list.hpp", + "boost/intrusive/member_value_traits.hpp", + "boost/intrusive/pointer_plus_bits.hpp", + "boost/intrusive/set.hpp", + "boost/intrusive/sg_set.hpp", + "boost/intrusive/slist.hpp", + "boost/intrusive/splay_set.hpp", + "boost/intrusive/treap_set.hpp", + "boost/intrusive/trivial_value_traits.hpp", + "boost/intrusive/unordered_set.hpp" + ] + }, + "io": { + "deps": [ + "config" + ], + "exported": 46, + "gmf": [ + "boost/io/nullstream.hpp", + "boost/io/ostream_joiner.hpp", + "boost/io/quoted.hpp" + ] + }, + "iostreams": { + "deps": [ + "assert", + "concept_check", + "config", + "core", + "random", + "range", + "smart_ptr", + "throw_exception", + "type_traits", + "utility" + ], + "exported": 437, + "gmf": [ + "boost/iostreams/code_converter.hpp", + "boost/iostreams/combine.hpp", + "boost/iostreams/device/file.hpp", + "boost/iostreams/device/file_descriptor.hpp", + "boost/iostreams/device/mapped_file.hpp", + "boost/iostreams/filter/counter.hpp", + "boost/iostreams/filter/line.hpp", + "boost/iostreams/filter/newline.hpp", + "boost/iostreams/filter/stdio.hpp", + "boost/iostreams/filter/symmetric.hpp", + "boost/iostreams/filter/test.hpp", + "boost/iostreams/filtering_stream.hpp", + "boost/iostreams/invert.hpp", + "boost/iostreams/restrict.hpp", + "boost/iostreams/skip.hpp", + "boost/iostreams/slice.hpp", + "boost/iostreams/stream.hpp", + "boost/iostreams/tee.hpp" + ] + }, + "iterator": { + "deps": [ + "assert", + "concept_check", + "config", + "core", + "mp11", + "optional", + "tuple", + "type_traits", + "utility" + ], + "exported": 968, + "gmf": [ + "boost/iterator.hpp", + "boost/iterator/advance.hpp", + "boost/iterator/counting_iterator.hpp", + "boost/iterator/distance.hpp", + "boost/iterator/filter_iterator.hpp", + "boost/iterator/function_input_iterator.hpp", + "boost/iterator/function_output_iterator.hpp", + "boost/iterator/generator_iterator.hpp", + "boost/iterator/indirect_iterator.hpp", + "boost/iterator/iterator_archetypes.hpp", + "boost/iterator/iterator_concepts.hpp", + "boost/iterator/minimum_category.hpp", + "boost/iterator/new_iterator_tests.hpp", + "boost/iterator/permutation_iterator.hpp", + "boost/iterator/reverse_iterator.hpp", + "boost/iterator/shared_container_iterator.hpp", + "boost/iterator/transform_iterator.hpp", + "boost/iterator/zip_iterator.hpp" + ] + }, + "json": { + "deps": [ + "assert", + "container", + "core", + "endian", + "mp11", + "system", + "variant2" + ], + "exported": 306, + "gmf": [ + "boost/json/debug_printers.hpp", + "boost/json.hpp" + ] + }, + "lambda": { + "deps": [ + "config", + "tuple", + "type_traits", + "utility" + ], + "exported": 360, + "gmf": [ + "boost/lambda/algorithm.hpp", + "boost/lambda/bind.hpp", + "boost/lambda/casts.hpp", + "boost/lambda/closures.hpp", + "boost/lambda/construct.hpp", + "boost/lambda/control_structures.hpp", + "boost/lambda/exceptions.hpp", + "boost/lambda/lambda.hpp", + "boost/lambda/numeric.hpp", + "boost/lambda/switch.hpp" + ] + }, + "lambda2": { + "deps": [], + "exported": 70, + "gmf": [ + "boost/lambda2.hpp" + ] + }, + "leaf": { + "deps": [], + "exported": 207, + "gmf": [ + "boost/leaf.hpp", + "boost/leaf/common.hpp", + "boost/leaf/diagnostics.hpp", + "boost/leaf/on_error.hpp", + "boost/leaf/pred.hpp", + "boost/leaf/serialization/boost_json_encoder.hpp", + "boost/leaf/serialization/nlohmann_json_encoder.hpp", + "boost/leaf/to_variant.hpp" + ] + }, + "lexical_cast": { + "deps": [ + "assert", + "config", + "container", + "core" + ], + "exported": 55, + "gmf": [ + "boost/lexical_cast.hpp" + ] + }, + "lockfree": { + "deps": [ + "align", + "assert", + "config", + "core", + "function", + "mp11", + "type_traits", + "utility" + ], + "exported": 65, + "gmf": [ + "boost/lockfree/bounded_ticket_queue.hpp", + "boost/lockfree/mpsc_weak_queue.hpp", + "boost/lockfree/queue.hpp", + "boost/lockfree/spsc_queue.hpp", + "boost/lockfree/spsc_value.hpp", + "boost/lockfree/stack.hpp" + ] + }, + "logic": { + "deps": [ + "config", + "core" + ], + "exported": 15, + "gmf": [ + "boost/logic/tribool_io.hpp" + ] + }, + "math": { + "deps": [ + "assert", + "concept_check", + "config", + "core", + "lexical_cast", + "random" + ], + "exported": 2621, + "gmf": [ + "boost/math/ccmath/ccmath.hpp", + "boost/math/common_factor.hpp", + "boost/math/complex.hpp", + "boost/math/concepts/distributions.hpp", + "boost/math/concepts/real_concept.hpp", + "boost/math/concepts/real_type_concept.hpp", + "boost/math/concepts/std_real_concept.hpp", + "boost/math/constants/info.hpp", + "boost/math/cstdfloat/cstdfloat_complex.hpp", + "boost/math/differentiation/autodiff.hpp", + "boost/math/differentiation/lanczos_smoothing.hpp", + "boost/math/distributions.hpp", + "boost/math/distributions/empirical_cumulative_distribution_function.hpp", + "boost/math/interpolators/barycentric_rational.hpp", + "boost/math/interpolators/bezier_polynomial.hpp", + "boost/math/interpolators/bilinear_uniform.hpp", + "boost/math/interpolators/cardinal_cubic_b_spline.hpp", + "boost/math/interpolators/cardinal_quadratic_b_spline.hpp", + "boost/math/interpolators/cardinal_quintic_b_spline.hpp", + "boost/math/interpolators/catmull_rom.hpp", + "boost/math/interpolators/cubic_b_spline.hpp", + "boost/math/interpolators/cubic_hermite.hpp", + "boost/math/interpolators/makima.hpp", + "boost/math/interpolators/pchip.hpp", + "boost/math/interpolators/quintic_hermite.hpp", + "boost/math/interpolators/septic_hermite.hpp", + "boost/math/interpolators/vector_barycentric_rational.hpp", + "boost/math/interpolators/whittaker_shannon.hpp", + "boost/math/octonion.hpp", + "boost/math/optimization/differential_evolution.hpp", + "boost/math/optimization/jso.hpp", + "boost/math/optimization/minimizer.hpp", + "boost/math/optimization/random_search.hpp", + "boost/math/quadrature/gauss_kronrod.hpp", + "boost/math/quadrature/naive_monte_carlo.hpp", + "boost/math/quadrature/ooura_fourier_integrals.hpp", + "boost/math/quadrature/sinh_sinh.hpp", + "boost/math/quadrature/tanh_sinh.hpp", + "boost/math/quadrature/wavelet_transforms.hpp", + "boost/math/special_functions.hpp", + "boost/math/special_functions/bessel_iterators.hpp", + "boost/math/special_functions/cardinal_b_spline.hpp", + "boost/math/special_functions/fibonacci.hpp", + "boost/math/special_functions/fourier_transform_daubechies.hpp", + "boost/math/special_functions/logsumexp.hpp", + "boost/math/special_functions/nonfinite_num_facets.hpp", + "boost/math/special_functions/prime.hpp", + "boost/math/special_functions/rsqrt.hpp", + "boost/math/statistics/anderson_darling.hpp", + "boost/math/statistics/chatterjee_correlation.hpp", + "boost/math/statistics/linear_regression.hpp", + "boost/math/statistics/ljung_box.hpp", + "boost/math/statistics/runs_test.hpp", + "boost/math/statistics/signal_statistics.hpp", + "boost/math/statistics/t_test.hpp", + "boost/math/statistics/z_test.hpp", + "boost/math/tools/agm.hpp", + "boost/math/tools/array.hpp", + "boost/math/tools/atomic.hpp", + "boost/math/tools/bivariate_statistics.hpp", + "boost/math/tools/centered_continued_fraction.hpp", + "boost/math/tools/cohen_acceleration.hpp", + "boost/math/tools/color_maps.hpp", + "boost/math/tools/concepts.hpp", + "boost/math/tools/engel_expansion.hpp", + "boost/math/tools/luroth_expansion.hpp", + "boost/math/tools/norms.hpp", + "boost/math/tools/numerical_differentiation.hpp", + "boost/math/tools/polynomial.hpp", + "boost/math/tools/quartic_roots.hpp", + "boost/math/tools/random_vector.hpp", + "boost/math/tools/simple_continued_fraction.hpp", + "boost/math/tools/stats.hpp", + "boost/math/tools/test_value.hpp", + "boost/math/tools/ulps_plot.hpp", + "boost/math/tools/univariate_statistics.hpp", + "boost/math/tr1.hpp" + ] + }, + "move": { + "deps": [ + "config" + ], + "exported": 355, + "gmf": [ + "boost/move/algo/adaptive_merge.hpp", + "boost/move/algo/adaptive_sort.hpp", + "boost/move/algo/predicate.hpp", + "boost/move/algo/unique.hpp", + "boost/move/make_unique.hpp", + "boost/move/move.hpp" + ] + }, + "mp11": { + "deps": [], + "exported": 471, + "gmf": [ + "boost/mp11.hpp", + "boost/mp11/mpl.hpp" + ] + }, + "mqtt5": { + "deps": [ + "asio", + "assert", + "beast", + "container", + "core", + "random", + "smart_ptr", + "static_string", + "system", + "type_traits", + "utility" + ], + "exported": 327, + "gmf": [ + "boost/mqtt5.hpp", + "boost/mqtt5/websocket.hpp" + ] + }, + "multi_array": { + "deps": [ + "array", + "assert", + "concept_check", + "config", + "core", + "functional", + "iterator", + "type_traits" + ], + "exported": 55, + "gmf": [ + "boost/multi_array.hpp" + ] + }, + "multi_index": { + "deps": [ + "assert", + "bind", + "config", + "container_hash", + "core", + "integer", + "mp11", + "throw_exception", + "tuple", + "type_traits", + "utility" + ], + "exported": 274, + "gmf": [ + "boost/multi_index/hashed_index.hpp", + "boost/multi_index/key.hpp", + "boost/multi_index/key_extractors.hpp", + "boost/multi_index/ordered_index.hpp", + "boost/multi_index/random_access_index.hpp", + "boost/multi_index/ranked_index.hpp", + "boost/multi_index/safe_mode_errors.hpp", + "boost/multi_index/sequenced_index.hpp", + "boost/multi_index_container.hpp" + ] + }, + "multiprecision": { + "deps": [ + "assert", + "io", + "math", + "random" + ], + "exported": 890, + "gmf": [ + "boost/multiprecision/concepts/mp_number_archetypes.hpp", + "boost/multiprecision/cpp_complex.hpp", + "boost/multiprecision/cpp_dec_float.hpp", + "boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_floor.hpp", + "boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fma.hpp", + "boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_fpclassify.hpp", + "boost/multiprecision/cpp_df_qf/cpp_df_qf_detail_ccmath_sqrt.hpp", + "boost/multiprecision/cpp_double_fp.hpp", + "boost/multiprecision/debug_adaptor.hpp", + "boost/multiprecision/logged_adaptor.hpp", + "boost/multiprecision/miller_rabin.hpp", + "boost/multiprecision/random.hpp", + "boost/multiprecision/traits/is_backend.hpp", + "boost/multiprecision/traits/is_variable_precision.hpp", + "boost/multiprecision/traits/transcendental_reduction_type.hpp" + ] + }, + "nowide": { + "deps": [ + "config", + "filesystem", + "io" + ], + "exported": 77, + "gmf": [ + "boost/nowide/args.hpp", + "boost/nowide/cstdlib.hpp", + "boost/nowide/filesystem.hpp", + "boost/nowide/fstream.hpp", + "boost/nowide/iostream.hpp", + "boost/nowide/quoted.hpp", + "boost/nowide/stat.hpp" + ] + }, + "numeric": { + "deps": [ + "assert", + "concept_check", + "config", + "core", + "iterator", + "math", + "range", + "serialization", + "type_traits", + "utility" + ], + "exported": 1115, + "gmf": [ + "boost/numeric/conversion/bounds.hpp", + "boost/numeric/conversion/cast.hpp", + "boost/numeric/conversion/int_float_mixture.hpp", + "boost/numeric/conversion/int_float_mixture_enum.hpp", + "boost/numeric/conversion/is_subranged.hpp", + "boost/numeric/conversion/sign_mixture.hpp", + "boost/numeric/conversion/sign_mixture_enum.hpp", + "boost/numeric/conversion/udt_builtin_mixture.hpp", + "boost/numeric/conversion/udt_builtin_mixture_enum.hpp", + "boost/numeric/interval/ext/integer.hpp", + "boost/numeric/interval/io.hpp", + "boost/numeric/interval/limits.hpp", + "boost/numeric/odeint.hpp", + "boost/numeric/odeint/algebra/fusion_algebra_dispatcher.hpp", + "boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp", + "boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp", + "boost/numeric/odeint/iterator/integrate/integrate.hpp", + "boost/numeric/odeint/iterator/integrate/integrate_const.hpp", + "boost/numeric/odeint/iterator/integrate/integrate_n_steps.hpp", + "boost/numeric/odeint/iterator/integrate/integrate_times.hpp", + "boost/numeric/odeint/iterator/integrate/observer_collection.hpp", + "boost/numeric/odeint/iterator/n_step_iterator.hpp", + "boost/numeric/odeint/iterator/n_step_time_iterator.hpp", + "boost/numeric/odeint/iterator/times_iterator.hpp", + "boost/numeric/odeint/iterator/times_time_iterator.hpp", + "boost/numeric/odeint/tools/traits.hpp", + "boost/numeric/odeint/util/split.hpp", + "boost/numeric/odeint/util/split_adaptor.hpp", + "boost/numeric/ublas/assignment.hpp", + "boost/numeric/ublas/banded.hpp", + "boost/numeric/ublas/blas.hpp", + "boost/numeric/ublas/doxydoc.hpp", + "boost/numeric/ublas/experimental/sparse_view.hpp", + "boost/numeric/ublas/hermitian.hpp", + "boost/numeric/ublas/io.hpp", + "boost/numeric/ublas/matrix_vector.hpp", + "boost/numeric/ublas/operation_blocked.hpp", + "boost/numeric/ublas/operation_sparse.hpp", + "boost/numeric/ublas/operations.hpp", + "boost/numeric/ublas/symmetric.hpp", + "boost/numeric/ublas/tensor.hpp", + "boost/numeric/ublas/tensor/algorithms.hpp", + "boost/numeric/ublas/tensor/extents.hpp", + "boost/numeric/ublas/tensor/functions.hpp", + "boost/numeric/ublas/tensor/index.hpp", + "boost/numeric/ublas/tensor/multiplication.hpp", + "boost/numeric/ublas/tensor/operators_arithmetic.hpp", + "boost/numeric/ublas/tensor/operators_comparison.hpp", + "boost/numeric/ublas/tensor/ostream.hpp", + "boost/numeric/ublas/tensor/storage_traits.hpp", + "boost/numeric/ublas/tensor/strides.hpp", + "boost/numeric/ublas/tensor/tensor.hpp", + "boost/numeric/ublas/traits/c_array.hpp", + "boost/numeric/ublas/vector_of_vector.hpp" + ] + }, + "optional": { + "deps": [ + "assert", + "config", + "core" + ], + "exported": 53, + "gmf": [ + "boost/optional.hpp", + "boost/optional/optional_io.hpp" + ] + }, + "outcome": { + "deps": [ + "assert", + "config", + "core", + "smart_ptr", + "system", + "throw_exception", + "type_traits", + "version" + ], + "exported": 192, + "gmf": [ + "boost/outcome.hpp", + "boost/outcome/bad_access.hpp", + "boost/outcome/basic_outcome.hpp", + "boost/outcome/basic_result.hpp", + "boost/outcome/boost_outcome.hpp", + "boost/outcome/boost_result.hpp", + "boost/outcome/config.hpp", + "boost/outcome/convert.hpp", + "boost/outcome/coroutine_support.hpp", + "boost/outcome/iostream_support.hpp", + "boost/outcome/iostream_support_result.hpp", + "boost/outcome/outcome.hpp", + "boost/outcome/result.hpp", + "boost/outcome/std_outcome.hpp", + "boost/outcome/std_result.hpp", + "boost/outcome/success_failure.hpp", + "boost/outcome/trait.hpp", + "boost/outcome/try.hpp", + "boost/outcome/utils.hpp" + ] + }, + "parser": { + "deps": [ + "assert", + "type_index" + ], + "exported": 1062, + "gmf": [ + "boost/parser/split.hpp", + "boost/parser/transform_replace.hpp" + ] + }, + "pfr": { + "deps": [], + "exported": 155, + "gmf": [ + "boost/pfr.hpp" + ] + }, + "poly_collection": { + "deps": [ + "assert", + "config", + "mp11", + "smart_ptr", + "type_erasure", + "type_traits" + ], + "exported": 324, + "gmf": [ + "boost/poly_collection/algorithm.hpp", + "boost/poly_collection/any_collection.hpp", + "boost/poly_collection/base_collection.hpp", + "boost/poly_collection/exception.hpp", + "boost/poly_collection/function_collection.hpp", + "boost/poly_collection/variant_collection.hpp" + ] + }, + "polygon": { + "deps": [ + "config" + ], + "exported": 693, + "gmf": [ + "boost/polygon/gtl.hpp", + "boost/polygon/interval_concept.hpp", + "boost/polygon/interval_data.hpp", + "boost/polygon/interval_traits.hpp", + "boost/polygon/isotropy.hpp", + "boost/polygon/point_concept.hpp", + "boost/polygon/point_data.hpp", + "boost/polygon/point_traits.hpp", + "boost/polygon/polygon.hpp", + "boost/polygon/polygon_90_with_holes_data.hpp", + "boost/polygon/rectangle_concept.hpp", + "boost/polygon/rectangle_data.hpp", + "boost/polygon/rectangle_traits.hpp", + "boost/polygon/segment_concept.hpp", + "boost/polygon/segment_data.hpp", + "boost/polygon/segment_traits.hpp", + "boost/polygon/voronoi.hpp", + "boost/polygon/voronoi_builder.hpp", + "boost/polygon/voronoi_diagram.hpp", + "boost/polygon/voronoi_geometry_type.hpp" + ] + }, + "pool": { + "deps": [ + "assert", + "config", + "throw_exception", + "type_traits" + ], + "exported": 14, + "gmf": [ + "boost/pool/object_pool.hpp", + "boost/pool/pool_alloc.hpp" + ] + }, + "process": { + "deps": [ + "asio", + "assert", + "concept_check", + "config", + "core", + "filesystem", + "io", + "system", + "type_traits", + "utility", + "winapi" + ], + "exported": 471, + "gmf": [ + "boost/process.hpp", + "boost/process/cstring_ref.hpp", + "boost/process/ext/cmd.hpp", + "boost/process/ext/cwd.hpp", + "boost/process/ext/env.hpp", + "boost/process/ext/exe.hpp", + "boost/process/process_handle.hpp", + "boost/process/v1.hpp", + "boost/process/v1/async_pipe.hpp", + "boost/process/v1/exception.hpp", + "boost/process/v1/extend.hpp", + "boost/process/v1/windows.hpp", + "boost/process/v2/windows/show_window.hpp", + "boost/process/v2/windows/with_logon_launcher.hpp", + "boost/process/v2/windows/with_token_launcher.hpp", + "boost/process/windows/as_user_launcher.hpp", + "boost/process/windows/creation_flags.hpp", + "boost/process/windows/default_launcher.hpp", + "boost/process/windows/show_window.hpp", + "boost/process/windows/with_logon_launcher.hpp", + "boost/process/windows/with_token_launcher.hpp" + ] + }, + "program_options": { + "deps": [ + "any", + "assert", + "function", + "iterator", + "lexical_cast", + "smart_ptr" + ], + "exported": 90, + "gmf": [ + "boost/program_options.hpp", + "boost/program_options/environment_iterator.hpp", + "boost/program_options/eof_iterator.hpp" + ] + }, + "property_map": { + "deps": [ + "any", + "assert", + "config", + "core", + "function", + "iterator", + "lexical_cast", + "smart_ptr", + "throw_exception", + "type_index", + "type_traits", + "utility" + ], + "exported": 116, + "gmf": [ + "boost/property_map/compose_property_map.hpp", + "boost/property_map/dynamic_property_map.hpp", + "boost/property_map/function_property_map.hpp", + "boost/property_map/parallel/caching_property_map.hpp", + "boost/property_map/parallel/global_index_map.hpp", + "boost/property_map/parallel/local_property_map.hpp", + "boost/property_map/parallel/simple_trigger.hpp", + "boost/property_map/property_map_iterator.hpp", + "boost/property_map/shared_array_property_map.hpp", + "boost/property_map/transform_value_property_map.hpp" + ] + }, + "property_tree": { + "deps": [ + "any", + "assert", + "bind", + "concept_check", + "optional", + "range", + "serialization", + "type_traits" + ], + "exported": 147, + "gmf": [ + "boost/property_tree/info_parser.hpp", + "boost/property_tree/ini_parser.hpp", + "boost/property_tree/json_parser.hpp", + "boost/property_tree/ptree_serialization.hpp", + "boost/property_tree/xml_parser.hpp" + ] + }, + "ptr_container": { + "deps": [ + "array", + "assert", + "circular_buffer", + "config", + "core", + "range", + "smart_ptr", + "type_traits" + ], + "exported": 101, + "gmf": [ + "boost/ptr_container/clone_allocator.hpp", + "boost/ptr_container/exception.hpp", + "boost/ptr_container/nullable.hpp", + "boost/ptr_container/ptr_container.hpp", + "boost/ptr_container/serialize_ptr_container.hpp" + ] + }, + "qvm": { + "deps": [], + "exported": 2053, + "gmf": [ + "boost/qvm.hpp", + "boost/qvm/operations.hpp", + "boost/qvm/quat_traits_array.hpp" + ] + }, + "random": { + "deps": [ + "assert", + "config", + "core", + "dynamic_bitset", + "integer", + "io", + "system", + "type_traits" + ], + "exported": 248, + "gmf": [ + "boost/random.hpp", + "boost/random/faure.hpp", + "boost/random/niederreiter_base2.hpp", + "boost/random/random_device.hpp", + "boost/random/sobol.hpp" + ] + }, + "range": { + "deps": [ + "array", + "assert", + "concept_check", + "config", + "core", + "functional", + "iterator", + "optional", + "regex", + "tuple", + "type_traits" + ], + "exported": 482, + "gmf": [ + "boost/range.hpp", + "boost/range/adaptor/define_adaptor.hpp", + "boost/range/adaptor/ref_unwrapped.hpp", + "boost/range/adaptor/type_erased.hpp", + "boost/range/adaptors.hpp", + "boost/range/algorithm.hpp", + "boost/range/algorithm/swap_ranges.hpp", + "boost/range/algorithm_ext.hpp", + "boost/range/as_array.hpp", + "boost/range/as_literal.hpp", + "boost/range/combine.hpp", + "boost/range/const_reverse_iterator.hpp", + "boost/range/counting_range.hpp", + "boost/range/irange.hpp", + "boost/range/istream_range.hpp", + "boost/range/iterator_range_hash.hpp", + "boost/range/join.hpp", + "boost/range/numeric.hpp", + "boost/range/result_iterator.hpp", + "boost/range/reverse_result_iterator.hpp" + ] + }, + "ratio": { + "deps": [], + "exported": 34, + "gmf": [ + "boost/ratio.hpp", + "boost/ratio/config.hpp" + ] + }, + "rational": { + "deps": [ + "assert", + "config", + "integer", + "throw_exception", + "type_traits", + "utility" + ], + "exported": 21, + "gmf": [ + "boost/rational.hpp" + ] + }, + "regex": { + "deps": [ + "assert", + "concept_check", + "config", + "throw_exception", + "type_traits" + ], + "exported": 404, + "gmf": [ + "boost/regex/concepts.hpp", + "boost/regex/pending/object_cache.hpp", + "boost/regex/pending/unicode_iterator.hpp", + "boost/regex/user.hpp", + "boost/regex/v5/cregex.hpp", + "boost/regex/v5/iterator_category.hpp", + "boost/regex/v5/iterator_traits.hpp", + "boost/regex/v5/perl_matcher_common.hpp", + "boost/regex/v5/perl_matcher_non_recursive.hpp", + "boost/regex/v5/regex_fwd.hpp" + ] + }, + "safe_numerics": { + "deps": [ + "config", + "core", + "integer", + "logic", + "mp11", + "type_traits" + ], + "exported": 149, + "gmf": [ + "boost/safe_numerics/automatic.hpp", + "boost/safe_numerics/checked_default.hpp", + "boost/safe_numerics/checked_integer.hpp", + "boost/safe_numerics/checked_result.hpp", + "boost/safe_numerics/checked_result_operations.hpp", + "boost/safe_numerics/concept/exception_policy.hpp", + "boost/safe_numerics/concept/integer.hpp", + "boost/safe_numerics/concept/numeric.hpp", + "boost/safe_numerics/concept/promotion_policy.hpp", + "boost/safe_numerics/cpp.hpp", + "boost/safe_numerics/exception.hpp", + "boost/safe_numerics/exception_policies.hpp", + "boost/safe_numerics/interval.hpp", + "boost/safe_numerics/safe_base.hpp", + "boost/safe_numerics/safe_base_operations.hpp", + "boost/safe_numerics/safe_common.hpp", + "boost/safe_numerics/safe_compare.hpp", + "boost/safe_numerics/safe_integer.hpp", + "boost/safe_numerics/safe_integer_literal.hpp", + "boost/safe_numerics/safe_integer_range.hpp", + "boost/safe_numerics/utility.hpp" + ] + }, + "scope": { + "deps": [ + "core" + ], + "exported": 51, + "gmf": [ + "boost/scope/defer.hpp", + "boost/scope/error_code_checker.hpp", + "boost/scope/scope_fail.hpp", + "boost/scope/scope_success.hpp", + "boost/scope/unique_fd.hpp" + ] + }, + "serialization": { + "deps": [ + "array", + "assert", + "config", + "core", + "integer", + "io", + "iterator", + "move", + "optional", + "smart_ptr", + "throw_exception", + "type_traits" + ], + "exported": 401, + "gmf": [ + "boost/archive/basic_xml_archive.hpp", + "boost/archive/binary_wiarchive.hpp", + "boost/archive/binary_woarchive.hpp", + "boost/archive/impl/basic_xml_grammar.hpp", + "boost/archive/iterators/base64_exception.hpp", + "boost/archive/iterators/base64_from_binary.hpp", + "boost/archive/iterators/binary_from_base64.hpp", + "boost/archive/iterators/dataflow.hpp", + "boost/archive/iterators/insert_linebreaks.hpp", + "boost/archive/iterators/istream_iterator.hpp", + "boost/archive/iterators/mb_from_wchar.hpp", + "boost/archive/iterators/ostream_iterator.hpp", + "boost/archive/iterators/remove_whitespace.hpp", + "boost/archive/iterators/transform_width.hpp", + "boost/archive/iterators/wchar_from_mb.hpp", + "boost/archive/iterators/xml_escape.hpp", + "boost/archive/iterators/xml_unescape.hpp", + "boost/archive/iterators/xml_unescape_exception.hpp", + "boost/archive/polymorphic_binary_iarchive.hpp", + "boost/archive/polymorphic_binary_oarchive.hpp", + "boost/archive/polymorphic_iarchive.hpp", + "boost/archive/polymorphic_oarchive.hpp", + "boost/archive/polymorphic_text_iarchive.hpp", + "boost/archive/polymorphic_text_oarchive.hpp", + "boost/archive/polymorphic_text_wiarchive.hpp", + "boost/archive/polymorphic_text_woarchive.hpp", + "boost/archive/polymorphic_xml_iarchive.hpp", + "boost/archive/polymorphic_xml_oarchive.hpp", + "boost/archive/polymorphic_xml_wiarchive.hpp", + "boost/archive/polymorphic_xml_woarchive.hpp", + "boost/archive/tmpdir.hpp", + "boost/archive/wcslen.hpp", + "boost/archive/xml_archive_exception.hpp", + "boost/serialization/array.hpp", + "boost/serialization/binary_object.hpp", + "boost/serialization/bitset.hpp", + "boost/serialization/boost_array.hpp", + "boost/serialization/complex.hpp", + "boost/serialization/deque.hpp", + "boost/serialization/export.hpp", + "boost/serialization/extended_type_info_no_rtti.hpp", + "boost/serialization/extended_type_info_typeid.hpp", + "boost/serialization/forward_list.hpp", + "boost/serialization/hash_map.hpp", + "boost/serialization/hash_set.hpp", + "boost/serialization/list.hpp", + "boost/serialization/map.hpp", + "boost/serialization/optional.hpp", + "boost/serialization/priority_queue.hpp", + "boost/serialization/queue.hpp", + "boost/serialization/scoped_ptr.hpp", + "boost/serialization/set.hpp", + "boost/serialization/shared_ptr_132.hpp", + "boost/serialization/slist.hpp", + "boost/serialization/stack.hpp", + "boost/serialization/state_saver.hpp", + "boost/serialization/unique_ptr.hpp", + "boost/serialization/unordered_map.hpp", + "boost/serialization/unordered_set.hpp", + "boost/serialization/valarray.hpp", + "boost/serialization/vector_135.hpp", + "boost/serialization/weak_ptr.hpp" + ] + }, + "signals2": { + "deps": [ + "assert", + "bind", + "core", + "function", + "iterator", + "move", + "mp11", + "optional", + "smart_ptr", + "type_traits", + "variant" + ], + "exported": 124, + "gmf": [ + "boost/signals2.hpp", + "boost/signals2/trackable.hpp" + ] + }, + "smart_ptr": { + "deps": [ + "assert", + "config", + "core" + ], + "exported": 144, + "gmf": [ + "boost/smart_ptr.hpp", + "boost/smart_ptr/allocate_unique.hpp", + "boost/smart_ptr/atomic_shared_ptr.hpp", + "boost/smart_ptr/bad_weak_ptr.hpp", + "boost/smart_ptr/enable_shared_from.hpp", + "boost/smart_ptr/enable_shared_from_raw.hpp", + "boost/smart_ptr/intrusive_ptr.hpp", + "boost/smart_ptr/intrusive_ref_counter.hpp", + "boost/smart_ptr/make_local_shared.hpp", + "boost/smart_ptr/make_unique.hpp", + "boost/smart_ptr/owner_equal_to.hpp", + "boost/smart_ptr/owner_hash.hpp", + "boost/smart_ptr/owner_less.hpp", + "boost/smart_ptr/scoped_array.hpp", + "boost/smart_ptr/scoped_ptr.hpp", + "boost/smart_ptr/shared_array.hpp" + ] + }, + "sort": { + "deps": [ + "core", + "range", + "type_traits" + ], + "exported": 160, + "gmf": [ + "boost/sort/block_indirect_sort/blk_detail/constants.hpp", + "boost/sort/common/deque_cnc.hpp", + "boost/sort/common/file_vector.hpp", + "boost/sort/common/int_array.hpp", + "boost/sort/common/rearrange.hpp", + "boost/sort/common/scheduler.hpp", + "boost/sort/common/time_measure.hpp", + "boost/sort/insert_sort/insert_sort.hpp", + "boost/sort/sort.hpp" + ] + }, + "stacktrace": { + "deps": [ + "container_hash" + ], + "exported": 23, + "gmf": [ + "boost/stacktrace.hpp" + ] + }, + "statechart": { + "deps": [ + "assert", + "config", + "core", + "function", + "smart_ptr", + "thread", + "throw_exception", + "type_traits" + ], + "exported": 73, + "gmf": [ + "boost/statechart/asynchronous_state_machine.hpp", + "boost/statechart/custom_reaction.hpp", + "boost/statechart/deferral.hpp", + "boost/statechart/exception_translator.hpp", + "boost/statechart/history.hpp", + "boost/statechart/in_state_reaction.hpp", + "boost/statechart/state.hpp", + "boost/statechart/termination.hpp", + "boost/statechart/transition.hpp" + ] + }, + "static_string": { + "deps": [ + "assert", + "container_hash", + "core", + "utility" + ], + "exported": 50, + "gmf": [ + "boost/static_string.hpp" + ] + }, + "stl_interfaces": { + "deps": [ + "assert", + "config" + ], + "exported": 95, + "gmf": [ + "boost/stl_interfaces/sequence_container_interface.hpp", + "boost/stl_interfaces/view_interface.hpp" + ] + }, + "system": { + "deps": [ + "assert", + "compat", + "variant2", + "winapi" + ], + "exported": 198, + "gmf": [ + "boost/system.hpp", + "boost/system/is_error_code_enum.hpp", + "boost/system/is_error_condition_enum.hpp", + "boost/system/linux_error.hpp", + "boost/system/windows_error.hpp" + ] + }, + "thread": { + "deps": [ + "assert", + "atomic", + "chrono", + "concept_check", + "config", + "core", + "date_time", + "io", + "optional", + "smart_ptr", + "system", + "throw_exception", + "type_traits", + "utility" + ], + "exported": 446, + "gmf": [ + "boost/thread.hpp", + "boost/thread/caller_context.hpp", + "boost/thread/completion_latch.hpp", + "boost/thread/concurrent_queues/deque_adaptor.hpp", + "boost/thread/concurrent_queues/deque_views.hpp", + "boost/thread/concurrent_queues/queue_adaptor.hpp", + "boost/thread/concurrent_queues/queue_views.hpp", + "boost/thread/concurrent_queues/sync_deque.hpp", + "boost/thread/concurrent_queues/sync_timed_queue.hpp", + "boost/thread/condition.hpp", + "boost/thread/csbl/deque.hpp", + "boost/thread/csbl/list.hpp", + "boost/thread/csbl/memory.hpp", + "boost/thread/csbl/memory/shared_ptr.hpp", + "boost/thread/csbl/queue.hpp", + "boost/thread/executors/inline_executor.hpp", + "boost/thread/executors/loop_executor.hpp", + "boost/thread/executors/scheduled_thread_pool.hpp", + "boost/thread/executors/scheduler.hpp", + "boost/thread/executors/scheduling_adaptor.hpp", + "boost/thread/executors/serial_executor.hpp", + "boost/thread/executors/serial_executor_cont.hpp", + "boost/thread/executors/thread_executor.hpp", + "boost/thread/experimental/task_region.hpp", + "boost/thread/externally_locked_stream.hpp", + "boost/thread/latch.hpp", + "boost/thread/lockable_adapter.hpp", + "boost/thread/null_mutex.hpp", + "boost/thread/ostream_buffer.hpp", + "boost/thread/poly_shared_lockable_adapter.hpp", + "boost/thread/reverse_lock.hpp", + "boost/thread/sync_bounded_queue.hpp", + "boost/thread/sync_queue.hpp", + "boost/thread/synchronized_value.hpp", + "boost/thread/testable_mutex.hpp", + "boost/thread/thread_guard.hpp", + "boost/thread/thread_pool.hpp", + "boost/thread/user_scheduler.hpp", + "boost/thread/win32/mfc_thread_init.hpp", + "boost/thread/with_lock_guard.hpp" + ] + }, + "throw_exception": { + "deps": [ + "assert", + "config" + ], + "exported": 45, + "gmf": [ + "boost/throw_exception.hpp" + ] + }, + "timer": { + "deps": [ + "config" + ], + "exported": 6, + "gmf": [ + "boost/timer/progress_display.hpp", + "boost/timer/timer.hpp" + ] + }, + "tokenizer": { + "deps": [ + "assert", + "config", + "iterator", + "throw_exception", + "type_traits" + ], + "exported": 18, + "gmf": [ + "boost/tokenizer.hpp" + ] + }, + "tuple": { + "deps": [ + "core", + "type_traits" + ], + "exported": 51, + "gmf": [ + "boost/tuple/tuple_comparison.hpp", + "boost/tuple/tuple_io.hpp" + ] + }, + "type_erasure": { + "deps": [ + "assert", + "config", + "core", + "iterator", + "mp11", + "smart_ptr", + "throw_exception", + "type_traits", + "utility" + ], + "exported": 300, + "gmf": [ + "boost/type_erasure/any_cast.hpp", + "boost/type_erasure/dynamic_any_cast.hpp", + "boost/type_erasure/free.hpp", + "boost/type_erasure/is_empty.hpp", + "boost/type_erasure/iterator.hpp", + "boost/type_erasure/member.hpp", + "boost/type_erasure/register_binding.hpp", + "boost/type_erasure/same_type.hpp", + "boost/type_erasure/tuple.hpp" + ] + }, + "type_index": { + "deps": [ + "assert", + "container_hash", + "throw_exception" + ], + "exported": 24, + "gmf": [ + "boost/type_index/runtime_cast.hpp", + "boost/type_index/runtime_cast/boost_shared_ptr_cast.hpp", + "boost/type_index/runtime_cast/std_shared_ptr_cast.hpp" + ] + }, + "type_traits": { + "deps": [ + "config" + ], + "exported": 405, + "gmf": [ + "boost/type_traits.hpp", + "boost/type_traits/alignment_traits.hpp", + "boost/type_traits/arithmetic_traits.hpp", + "boost/type_traits/array_traits.hpp", + "boost/type_traits/broken_compiler_spec.hpp", + "boost/type_traits/composite_traits.hpp", + "boost/type_traits/config.hpp", + "boost/type_traits/conversion_traits.hpp", + "boost/type_traits/cv_traits.hpp", + "boost/type_traits/detected_or.hpp", + "boost/type_traits/has_operator.hpp", + "boost/type_traits/ice.hpp", + "boost/type_traits/is_base_of_tr1.hpp", + "boost/type_traits/is_bounded_array.hpp", + "boost/type_traits/is_detected.hpp", + "boost/type_traits/is_detected_convertible.hpp", + "boost/type_traits/is_detected_exact.hpp", + "boost/type_traits/is_unbounded_array.hpp", + "boost/type_traits/object_traits.hpp", + "boost/type_traits/reference_traits.hpp", + "boost/type_traits/same_traits.hpp", + "boost/type_traits/transform_traits.hpp" + ] + }, + "units": { + "deps": [ + "assert", + "config", + "io", + "lambda", + "math", + "type_traits" + ], + "exported": 1156, + "gmf": [ + "boost/units/base_units/angle/arcminute.hpp", + "boost/units/base_units/angle/arcsecond.hpp", + "boost/units/base_units/astronomical/astronomical_unit.hpp", + "boost/units/base_units/astronomical/light_day.hpp", + "boost/units/base_units/astronomical/light_hour.hpp", + "boost/units/base_units/astronomical/light_minute.hpp", + "boost/units/base_units/astronomical/light_year.hpp", + "boost/units/base_units/astronomical/parsec.hpp", + "boost/units/base_units/imperial/conversions.hpp", + "boost/units/base_units/imperial/drachm.hpp", + "boost/units/base_units/imperial/fluid_ounce.hpp", + "boost/units/base_units/imperial/foot.hpp", + "boost/units/base_units/imperial/furlong.hpp", + "boost/units/base_units/imperial/gallon.hpp", + "boost/units/base_units/imperial/gill.hpp", + "boost/units/base_units/imperial/grain.hpp", + "boost/units/base_units/imperial/hundredweight.hpp", + "boost/units/base_units/imperial/inch.hpp", + "boost/units/base_units/imperial/league.hpp", + "boost/units/base_units/imperial/mile.hpp", + "boost/units/base_units/imperial/ounce.hpp", + "boost/units/base_units/imperial/quart.hpp", + "boost/units/base_units/imperial/quarter.hpp", + "boost/units/base_units/imperial/stone.hpp", + "boost/units/base_units/imperial/thou.hpp", + "boost/units/base_units/imperial/ton.hpp", + "boost/units/base_units/metric/angstrom.hpp", + "boost/units/base_units/metric/are.hpp", + "boost/units/base_units/metric/atmosphere.hpp", + "boost/units/base_units/metric/bar.hpp", + "boost/units/base_units/metric/barn.hpp", + "boost/units/base_units/metric/day.hpp", + "boost/units/base_units/metric/fermi.hpp", + "boost/units/base_units/metric/hectare.hpp", + "boost/units/base_units/metric/hour.hpp", + "boost/units/base_units/metric/knot.hpp", + "boost/units/base_units/metric/liter.hpp", + "boost/units/base_units/metric/micron.hpp", + "boost/units/base_units/metric/minute.hpp", + "boost/units/base_units/metric/mmHg.hpp", + "boost/units/base_units/metric/nautical_mile.hpp", + "boost/units/base_units/metric/ton.hpp", + "boost/units/base_units/metric/torr.hpp", + "boost/units/base_units/metric/year.hpp", + "boost/units/base_units/us/cup.hpp", + "boost/units/base_units/us/dram.hpp", + "boost/units/base_units/us/fluid_dram.hpp", + "boost/units/base_units/us/fluid_ounce.hpp", + "boost/units/base_units/us/foot.hpp", + "boost/units/base_units/us/gallon.hpp", + "boost/units/base_units/us/gill.hpp", + "boost/units/base_units/us/grain.hpp", + "boost/units/base_units/us/hundredweight.hpp", + "boost/units/base_units/us/inch.hpp", + "boost/units/base_units/us/mil.hpp", + "boost/units/base_units/us/mile.hpp", + "boost/units/base_units/us/minim.hpp", + "boost/units/base_units/us/ounce.hpp", + "boost/units/base_units/us/pound_force.hpp", + "boost/units/base_units/us/quart.hpp", + "boost/units/base_units/us/tablespoon.hpp", + "boost/units/base_units/us/teaspoon.hpp", + "boost/units/base_units/us/ton.hpp", + "boost/units/cmath.hpp", + "boost/units/get_dimension.hpp", + "boost/units/get_system.hpp", + "boost/units/is_dim.hpp", + "boost/units/is_dimensionless.hpp", + "boost/units/is_dimensionless_quantity.hpp", + "boost/units/is_dimensionless_unit.hpp", + "boost/units/is_quantity.hpp", + "boost/units/is_quantity_of_system.hpp", + "boost/units/is_unit.hpp", + "boost/units/lambda.hpp", + "boost/units/limits.hpp", + "boost/units/physical_dimensions.hpp", + "boost/units/systems/abstract.hpp", + "boost/units/systems/angle/degrees.hpp", + "boost/units/systems/angle/gradians.hpp", + "boost/units/systems/angle/revolutions.hpp", + "boost/units/systems/cgs/io.hpp", + "boost/units/systems/information.hpp", + "boost/units/systems/si/codata/atomic-nuclear_constants.hpp", + "boost/units/systems/si/codata/physico-chemical_constants.hpp", + "boost/units/systems/si/codata_constants.hpp", + "boost/units/systems/si/io.hpp", + "boost/units/systems/si/prefixes.hpp", + "boost/units/systems/temperature/celsius.hpp", + "boost/units/systems/temperature/fahrenheit.hpp" + ] + }, + "unordered": { + "deps": [ + "assert", + "config", + "container_hash", + "core", + "mp11", + "throw_exception" + ], + "exported": 245, + "gmf": [ + "boost/unordered/concurrent_flat_map.hpp", + "boost/unordered/concurrent_flat_set.hpp", + "boost/unordered/concurrent_node_map.hpp", + "boost/unordered/concurrent_node_set.hpp", + "boost/unordered/hash_traits.hpp", + "boost/unordered/unordered_flat_map.hpp", + "boost/unordered/unordered_flat_set.hpp", + "boost/unordered/unordered_map.hpp", + "boost/unordered/unordered_map_fwd.hpp", + "boost/unordered/unordered_node_map.hpp", + "boost/unordered/unordered_node_set.hpp", + "boost/unordered/unordered_set.hpp", + "boost/unordered/unordered_set_fwd.hpp" + ] + }, + "url": { + "deps": [ + "assert", + "core", + "mp11", + "optional", + "system", + "type_traits", + "variant2" + ], + "exported": 318, + "gmf": [ + "boost/url.hpp" + ] + }, + "utility": { + "deps": [ + "assert", + "config", + "core", + "io", + "throw_exception", + "type_traits" + ], + "exported": 75, + "gmf": [ + "boost/compressed_pair.hpp", + "boost/utility.hpp", + "boost/utility/addressof.hpp", + "boost/utility/compare_pointees.hpp", + "boost/utility/declval.hpp", + "boost/utility/explicit_operator_bool.hpp", + "boost/utility/in_place_factory.hpp", + "boost/utility/result_of.hpp", + "boost/utility/string_ref_fwd.hpp", + "boost/utility/string_view.hpp", + "boost/utility/swap.hpp", + "boost/utility/typed_in_place_factory.hpp", + "boost/utility/value_init.hpp" + ] + }, + "uuid": { + "deps": [ + "assert", + "config", + "throw_exception" + ], + "exported": 113, + "gmf": [ + "boost/uuid.hpp", + "boost/uuid/basic_name_generator.hpp", + "boost/uuid/entropy_error.hpp", + "boost/uuid/invalid_uuid.hpp", + "boost/uuid/uuid_generators.hpp", + "boost/uuid/uuid_hash.hpp", + "boost/uuid/uuid_serialize.hpp" + ] + }, + "variant": { + "deps": [ + "assert", + "config", + "container_hash", + "core", + "integer", + "throw_exception", + "type_index", + "type_traits" + ], + "exported": 347, + "gmf": [ + "boost/variant.hpp", + "boost/variant/multivisitors.hpp", + "boost/variant/polymorphic_get.hpp" + ] + }, + "variant2": { + "deps": [ + "assert", + "mp11" + ], + "exported": 99, + "gmf": [ + "boost/variant2.hpp" + ] + }, + "wave": { + "deps": [ + "assert", + "concept_check", + "config", + "core", + "filesystem", + "format", + "io", + "iterator", + "mp11", + "multi_index", + "optional", + "pool", + "smart_ptr", + "thread", + "throw_exception", + "type_traits", + "utility", + "version" + ], + "exported": 878, + "gmf": [ + "boost/wave.hpp", + "boost/wave/cpplexer/cpp_lex_iterator.hpp", + "boost/wave/cpplexer/re2clex/cpp_re2c_lexer.hpp", + "boost/wave/grammars/cpp_chlit_grammar.hpp", + "boost/wave/grammars/cpp_defined_grammar.hpp", + "boost/wave/grammars/cpp_expression_grammar.hpp", + "boost/wave/grammars/cpp_grammar.hpp", + "boost/wave/grammars/cpp_has_include_grammar.hpp", + "boost/wave/grammars/cpp_intlit_grammar.hpp", + "boost/wave/grammars/cpp_predef_macros_grammar.hpp" + ] + }, + "winapi": { + "deps": [], + "exported": 427, + "gmf": [ + "boost/winapi/bcrypt.hpp", + "boost/winapi/character_code_conversion.hpp", + "boost/winapi/crypt.hpp", + "boost/winapi/dbghelp.hpp", + "boost/winapi/debugapi.hpp", + "boost/winapi/directory_management.hpp", + "boost/winapi/dll.hpp", + "boost/winapi/environment.hpp", + "boost/winapi/error_codes.hpp", + "boost/winapi/error_handling.hpp", + "boost/winapi/file_management.hpp", + "boost/winapi/file_mapping.hpp", + "boost/winapi/get_process_times.hpp", + "boost/winapi/get_thread_times.hpp", + "boost/winapi/handle_info.hpp", + "boost/winapi/handles.hpp", + "boost/winapi/jobs.hpp", + "boost/winapi/memory.hpp", + "boost/winapi/page_protection_flags.hpp", + "boost/winapi/pipes.hpp", + "boost/winapi/priority_class.hpp", + "boost/winapi/process.hpp", + "boost/winapi/security.hpp", + "boost/winapi/shell.hpp", + "boost/winapi/show_window.hpp", + "boost/winapi/stack_backtrace.hpp", + "boost/winapi/synchronization.hpp", + "boost/winapi/system.hpp", + "boost/winapi/thread.hpp", + "boost/winapi/thread_pool.hpp", + "boost/winapi/timers.hpp", + "boost/winapi/tls.hpp", + "boost/winapi/waitable_timer.hpp" + ] + }, + "yap": { + "deps": [ + "assert", + "hana", + "type_index" + ], + "exported": 130, + "gmf": [ + "boost/yap/print.hpp", + "boost/yap/yap.hpp" + ] + } + } +} diff --git a/generated/meta/skipped.txt b/generated/meta/skipped.txt new file mode 100644 index 000000000..0d654e40f --- /dev/null +++ b/generated/meta/skipped.txt @@ -0,0 +1,835 @@ +# Names the export policy (tools/export_policy.toml) guards, drops or +# adds verbatim. GENERATED by tools/gen_exports.py - DO NOT EDIT +# [if ] -- + +align drop std::alignment_of -- boost::alignment::detail::alignment_of is `using std::alignment_of` only on some compilers; other targets (clang outside x86_64) define a template of that name, which the std re-export would conflict with. +asio guard boost::asio::basic_file if defined(BOOST_ASIO_HAS_FILE) -- Asio's file support (basic_file and friends) is declared only where BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. +asio guard boost::asio::basic_random_access_file if defined(BOOST_ASIO_HAS_FILE) -- Asio's file support (basic_file and friends) is declared only where BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. +asio guard boost::asio::basic_stream_file if defined(BOOST_ASIO_HAS_FILE) -- Asio's file support (basic_file and friends) is declared only where BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. +asio guard boost::asio::detail::apc_function if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::calculate_hash_value if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::fd_set_adapter if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::hash_map if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::null_reactor if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::null_signal_blocker if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::reactor_op_queue if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::select_reactor if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::socket_ops::complete_iocp_accept if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::socket_ops::complete_iocp_connect if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::socket_ops::complete_iocp_recv if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::socket_ops::complete_iocp_recvfrom if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::socket_ops::complete_iocp_recvmsg if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::socket_ops::complete_iocp_send if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::socket_ops::msghdr if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::socket_select_interrupter if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_event if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_fd_set_adapter if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_global if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_global_impl if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_file_service if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_handle_read_op if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_handle_service if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_handle_write_op if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_io_context if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_null_buffers_op if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_operation if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_overlapped_op if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_overlapped_ptr if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_serial_port_service if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_socket_accept_op if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_socket_connect_op if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_socket_connect_op_base if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_socket_move_accept_op if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_socket_recv_op if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_socket_recvfrom_op if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_socket_recvmsg_op if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_socket_send_op if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_socket_service if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_socket_service_base if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_thread_info if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_iocp_wait_op if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_mutex if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_object_handle_service if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_static_mutex if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_thread if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_thread_base if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::win_thread_function if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::winsock_init if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::detail::winsock_init_base if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::file_base if defined(BOOST_ASIO_HAS_FILE) -- Asio's file support (basic_file and friends) is declared only where BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. +asio guard boost::asio::random_access_file if defined(BOOST_ASIO_HAS_FILE) -- Asio's file support (basic_file and friends) is declared only where BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. +asio guard boost::asio::stream_file if defined(BOOST_ASIO_HAS_FILE) -- Asio's file support (basic_file and friends) is declared only where BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. +asio guard boost::asio::windows::basic_object_handle if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::windows::basic_overlapped_handle if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::windows::basic_random_access_handle if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::windows::basic_stream_handle if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::windows::object_handle if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::windows::overlapped_handle if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::windows::overlapped_ptr if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::windows::random_access_handle if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +asio guard boost::asio::windows::stream_handle if defined(_WIN32) -- Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); POSIX builds the epoll/kqueue backends instead. +atomic guard boost::atomics::detail::convert_memory_order_to_gcc if defined(__GNUC__) -- M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw flavor). +atomic guard boost::atomics::detail::core_arch_operations_gcc_x86 if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) -- M11 platform guard: gcc_x86 backend of boost/atomic (platform.hpp); x86 only. +atomic guard boost::atomics::detail::core_arch_operations_gcc_x86_base if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) -- M11 platform guard: gcc_x86 backend of boost/atomic (platform.hpp); x86 only. +atomic guard boost::atomics::detail::core_operations_gcc_atomic if defined(__GNUC__) -- M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw flavor). +atomic guard boost::atomics::detail::fence_arch_operations_gcc_x86 if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) -- M11 platform guard: gcc_x86 backend of boost/atomic (platform.hpp); x86 only. +atomic guard boost::atomics::detail::fence_operations_gcc_atomic if defined(__GNUC__) -- M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw flavor). +atomic guard boost::atomics::detail::wait_operations_windows if defined(BOOST_WINDOWS) -- M11 platform guard: wait_ops_windows.hpp (wait backend = windows, platform.hpp BOOST_WINDOWS); POSIX uses futex/darwin_ulock/generic. +beast guard boost::beast::detail::set_file_pointer_ex if defined(_WIN32) -- Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream dstream) are Windows-only. +beast guard boost::beast::detail::win32_unicode_path if defined(_WIN32) -- Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream dstream) are Windows-only. +beast guard boost::beast::file_win32 if defined(_WIN32) -- Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream dstream) are Windows-only. +beast guard boost::beast::http::detail::highPart if defined(_WIN32) -- Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream dstream) are Windows-only. +beast guard boost::beast::http::detail::lowPart if defined(_WIN32) -- Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream dstream) are Windows-only. +beast guard boost::beast::http::detail::make_win32_error if defined(_WIN32) -- Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream dstream) are Windows-only. +beast guard boost::beast::http::detail::null_lambda if defined(_WIN32) -- Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream dstream) are Windows-only. +beast guard boost::beast::http::detail::run_write_some_win32_op if defined(_WIN32) -- Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream dstream) are Windows-only. +beast guard boost::beast::http::detail::write_some_win32_op if defined(_WIN32) -- Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream dstream) are Windows-only. +beast guard boost::beast::unit_test::basic_dstream if defined(_WIN32) -- Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream dstream) are Windows-only. +beast guard boost::beast::unit_test::detail::dstream_buf if defined(_WIN32) -- Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream dstream) are Windows-only. +bloom guard boost::bloom::detail::m128ix2 if defined(BOOST_BLOOM_SSE2) -- M9 platform guard: m128ix2 is the SSE2 branch of fast_multiblock32 (detail/sse2.hpp, __SSE2__); absent on arm64 (NEON branch). +charconv guard boost::charconv::detail::ieee754_binary80 if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 -- M11 platform guard: bit_layouts.hpp defines ieee754_binary80 only for 80-bit long double (x86-64 gcc/mingw); MSVC long double is 53-bit. +charconv guard boost::charconv::detail::to_chars128 if defined(BOOST_CHARCONV_HAS_INT128) -- M11 platform guard: to_chars128 exists only under BOOST_CHARCONV_HAS_INT128 (to_chars_integer_impl.hpp). +config guard boost::int128_type if defined(BOOST_HAS_INT128) -- M3 hand-guard (M9: moved to config.inc): suffix.hpp defines int128_type only where BOOST_HAS_INT128. +config guard boost::uint128_type if defined(BOOST_HAS_INT128) -- M3 hand-guard (M9: moved to config.inc): suffix.hpp defines uint128_type only where BOOST_HAS_INT128. +container guard ::SleepEx if defined(_WIN32) -- M11 platform guard: container_winapi DWORD_/BOOL_/SleepEx are declared only in the _WIN32 branch of container/detail/mutex.hpp. +container guard boost::container::dtl::win_critical_section if defined(_WIN32) -- M11 platform guard: win_critical_section is the non-pthread branch of container/detail/thread_mutex.hpp; POSIX uses pthread_mutex. +container guard boost::container_winapi::BOOL_ if defined(_WIN32) -- M11 platform guard: container_winapi DWORD_/BOOL_/SleepEx are declared only in the _WIN32 branch of container/detail/mutex.hpp. +container guard boost::container_winapi::DWORD_ if defined(_WIN32) -- M11 platform guard: container_winapi DWORD_/BOOL_/SleepEx are declared only in the _WIN32 branch of container/detail/mutex.hpp. +core guard boost::core::detail::copysign_impl if defined(__GNUC__) -- M3 hand-guard: boost/core/cmath.hpp defines copysign_impl only on gcc-like compilers. +core guard boost::core::detail::sp_thread_sleep if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -- M6 platform guard: sp_thread_sleep/yield live in boost::core::detail only on Windows; on POSIX (nanosleep/sched_yield branch of the header) they are declared in boost::core. +core guard boost::core::detail::sp_thread_yield if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -- M6 platform guard: sp_thread_sleep/yield live in boost::core::detail only on Windows; on POSIX (nanosleep/sched_yield branch of the header) they are declared in boost::core. +date_time guard boost::date_time::time_from_ftime if defined(_WIN32) -- The FILETIME conversions of date_time/filetime_functions.hpp exist only on Windows. +date_time guard boost::posix_time::from_ftime if defined(_WIN32) -- The FILETIME conversions of date_time/filetime_functions.hpp exist only on Windows. +decimal guard boost::decimal::detail::builtin_int128_t if defined(BOOST_DECIMAL_HAS_INT128) -- M9 platform guard: config.hpp defines the __int128 typedefs only where BOOST_DECIMAL_HAS_INT128 (off under the MSVC ABI). +decimal guard boost::decimal::detail::builtin_uint128_t if defined(BOOST_DECIMAL_HAS_INT128) -- M9 platform guard: config.hpp defines the __int128 typedefs only where BOOST_DECIMAL_HAS_INT128 (off under the MSVC ABI). +decimal guard boost::decimal::detail::ieee754_binary80 if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 -- M9 platform guard: bit_layouts.hpp defines ieee754_binary80 only for 80-bit long double (x86-64 gcc/mingw); MSVC long double is 53-bit. +decimal guard boost::decimal::detail::impl::add_carry_u64 if defined(__GNUC__) -- The builtin carry helpers are declared only in the __GNUC__ branch. +decimal guard boost::decimal::detail::impl::builtin_128_pow10 if defined(BOOST_DECIMAL_HAS_INT128) -- M9 platform guard: power_tables.hpp defines builtin_128_pow10 only under BOOST_DECIMAL_HAS_INT128. +decimal guard boost::decimal::detail::impl::mg32_u256_by_u128 if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) -- The 128-bit division intrinsics are declared only where BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). +decimal guard boost::decimal::detail::u256_add if defined(__GNUC__) -- The builtin carry helpers are declared only in the __GNUC__ branch. +decimal guard boost::int128::detail::impl::div_mod_intrinsic if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) -- The 128-bit division intrinsics are declared only where BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). +decimal guard boost::int128::detail::impl::int128_addcarry_u64 if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) -- The 128-bit division intrinsics are declared only where BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). +decimal guard boost::int128::detail::impl::int128_subborrow_u64 if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) -- The 128-bit division intrinsics are declared only where BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). +decimal guard boost::int128::detail::impl::int128_udiv128_intrinsic if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) -- The 128-bit division intrinsics are declared only where BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). +decimal guard boost::int128::detail::impl::int128_umul128_intrinsic if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) -- The 128-bit division intrinsics are declared only where BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). +decimal guard boost::int128::detail::impl::mg32_div_3by2 if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) -- The 128-bit division intrinsics are declared only where BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). +decimal guard boost::int128::detail::impl::mg32_reciprocal_2by1 if defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128) -- The 128-bit division intrinsics are declared only where BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). +dll guard boost::dll::detail::last_error_code if defined(_WIN32) -- M9 platform guard: last_error_code is in detail/windows/ path_from_handle.hpp (no POSIX counterpart). +dll guard boost::dll::detail::parser::arg_list if !defined(_MSC_VER) -- M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +dll guard boost::dll::detail::parser::const_rule if !defined(_MSC_VER) -- M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +dll guard boost::dll::detail::parser::const_rule_impl if !defined(_MSC_VER) -- M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +dll guard boost::dll::detail::parser::dummy if !defined(_MSC_VER) -- M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +dll guard boost::dll::detail::parser::parse_type if !defined(_MSC_VER) -- M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +dll guard boost::dll::detail::parser::parse_type_helper if !defined(_MSC_VER) -- M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +dll guard boost::dll::detail::parser::pure_type if !defined(_MSC_VER) -- M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +dll guard boost::dll::detail::parser::reference_rule if !defined(_MSC_VER) -- M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +dll guard boost::dll::detail::parser::reference_rule_impl if !defined(_MSC_VER) -- M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +dll guard boost::dll::detail::parser::type_name if !defined(_MSC_VER) -- M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +dll guard boost::dll::detail::parser::volatile_rule if !defined(_MSC_VER) -- M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +dll guard boost::dll::detail::parser::volatile_rule_impl if !defined(_MSC_VER) -- M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +dll guard boost::dll::experimental::demangle_symbol if !defined(_MSC_VER) -- M9 platform guard: demangle_symbol comes from demangling/itanium.hpp. +flyweight drop boost::detail::allocator::compliant_allocator_rebind_to -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::detail::allocator::construct -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::detail::allocator::destroy -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::detail::allocator::is_partial_std_allocator -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::detail::allocator::partial_std_allocator_rebind_to -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::detail::allocator::partial_std_allocator_wrapper -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::detail::allocator::rebind_to -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::detail::allocator::rebinder -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::detail::if_true -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::mpl::count -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::mpl::count_impl -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::mpl::key_type -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::mpl::key_type_impl -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::mpl::order -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::mpl::order_impl -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::mpl::value_type -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::mpl::value_type_impl -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::always_true_predicate -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::append_to_make_arg_list -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::arg_list -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::arg_list_cons -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::arg_list_factory -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::arg_list_iterator -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::arg_list_tag -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::as_parameter_requirements -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::augment_predicate -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::augment_predicate_check_consume_ref -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::augment_predicate_check_consume_ref_mp11 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::augment_predicate_check_out_ref -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::augment_predicate_check_out_ref_mp11 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::augment_predicate_mp11 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::augment_predicate_mp11_impl -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::deduce_tag -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::deduce_tag0 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::deduce_tag_condition -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::deduce_tag_condition_mp11 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::deduce_tag_condition_mpl -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::deduced_item -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::default_ -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::default_r_ -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::empty_arg_list -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::error_const_lvalue_bound_to_out_parameter -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::error_lvalue_bound_to_consume_parameter -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::error_rvalue_bound_to_out_parameter -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::flat_like_arg_list -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::flat_like_arg_tuple -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::get_predicate -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::get_predicate_or_default -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::get_reference -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::get_tag_type -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::get_tag_type0 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::has_default -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::has_key_ -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::has_nested_template_fn -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::has_nested_template_fn_impl -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::has_nested_template_fn_variadic -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::insert_ -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::insert_tagged -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_cv_reference_wrapper -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_cv_reference_wrapper_check -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_deduced -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_deduced0 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_deduced_aux -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_maybe -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_mp11_placeholder -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_mpl_placeholder -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_named_argument -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_optional -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_required -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_tagged_argument -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_tagged_argument_mp11 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::is_template_keyword -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::item -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::lambda_tag -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::lazy_default -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::make_arg_list -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::make_arg_list0 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::make_arg_list_aux -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::make_deduced_item -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::make_deduced_items -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::make_deduced_list -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::make_deduced_list_not_empty -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::make_item -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::make_items -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::make_parameter_spec_items -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::make_parameter_spec_items_helper -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::match_parameters_base_cond -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::match_parameters_base_cond_helper -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::maybe_base -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::no_tag -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::parameter_requirements -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::predicate -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::result_of0 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::satisfies -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::satisfies_requirements_of -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::set0 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tag -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tag_deduced -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tag_if_lvalue_reference -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tag_if_otherwise -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tag_if_scalar -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tag_keyword_arg -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tag_template_keyword_arg -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tag_type -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tagged_argument -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tagged_argument_base -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tagged_argument_list_of_1 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tagged_argument_rref -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tagged_argument_rref_key -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::tagged_argument_type -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::template_keyword_base -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::to_yesno -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::unmatched_argument -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::unwrap_cv_reference -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::unwrap_cv_reference_impl -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::use_default -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::use_default_tag -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::value_type_is_not_void -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::value_type_is_void -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::void_reference -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::aux::yes_tag -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::binding -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::binding0 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::binding1 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::consume_reference -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::deduced -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::forward_reference -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::in_out_reference -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::in_reference -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::keyword -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::lazy_binding -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::lazy_value_type -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::move_from_reference -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::optional -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::out_reference -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::parameters -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::required -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::template_keyword -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::value_type -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::value_type0 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::value_type1 -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +flyweight drop boost::parameter::void_ -- The bundle pulls the transitive container/interprocess/parameter surface into shared namespaces; boost.flyweight exports its own namespaces and boost:: entry points only. +functional guard boost::mpl::v_at_impl if defined(__GNUC__) -- M9 platform guard: gcc-preprocessed mpl vector headers only. +functional guard boost::mpl::v_item if defined(__GNUC__) -- M9 platform guard: gcc-preprocessed mpl vector headers only. +functional guard boost::mpl::v_mask if defined(__GNUC__) -- M9 platform guard: gcc-preprocessed mpl vector headers only. +graph guard boost::proto::detail::template_arity if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) -- M11 platform guard: proto/detail/template_arity.hpp declares template_arity only under BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template matching). +graph guard boost::proto::detail::template_arity_helper if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) -- M11 platform guard: proto/detail/template_arity.hpp declares template_arity_helper only under BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template matching). +graph guard boost::proto::detail::template_arity_impl2 if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) -- M11 platform guard: proto/detail/template_arity.hpp declares template_arity_impl2 only under BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template matching). +hof guard boost::hof::detail::bool_seq if !defined(_MSC_VER) -- C2 platform guard: bool_seq is the non-_MSC_VER branch of detail/and.hpp (the MSVC branch declares struct and_ instead). +hof guard boost::hof::detail::callable_args if !BOOST_HOF_NO_EXPRESSION_SFINAE -- C2 platform guard: callable_args is the !NO_EXPRESSION_SFINAE branch of detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). +hof guard boost::hof::detail::called_val if !BOOST_HOF_NO_EXPRESSION_SFINAE -- C2 platform guard: called_val is the !NO_EXPRESSION_SFINAE branch of detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). +hof guard boost::hof::detail::can_be_called_impl if !BOOST_HOF_NO_EXPRESSION_SFINAE -- C2 platform guard: can_be_called_impl is the !NO_EXPRESSION_SFINAE branch of detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). +hof guard boost::hof::detail::eval_helper if !BOOST_HOF_NO_ORDERED_BRACE_INIT -- C2 platform guard: eval_helper is the !NO_ORDERED_BRACE_INIT branch of apply_eval.hpp (config.hpp: _MSC_VER → 1). +hof guard boost::hof::operators::decrement if !defined(_MSC_VER) -- C2 platform guard: operators::decrement is the #ifndef _MSC_VER branch of placeholders.hpp (MSVC 2017 ICE on ++/-- constexpr). +hof guard boost::hof::operators::increment if !defined(_MSC_VER) -- C2 platform guard: operators::increment is the #ifndef _MSC_VER branch of placeholders.hpp (MSVC 2017 ICE on ++/-- constexpr). +interprocess guard boost::interprocess::basic_managed_windows_shared_memory if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::do_winapi_wait if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::file_time_to_microseconds if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::get_bootstamp if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::get_temporary_wpath if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::intermodule_singleton_common if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::intermodule_singleton_helpers::get_map_base_name if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::intermodule_singleton_helpers::get_map_name if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::intermodule_singleton_helpers::get_map_size if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::intermodule_singleton_helpers::get_pid_creation_time_str if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::intermodule_singleton_helpers::thread_safe_global_map_dependant if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::intermodule_singleton_helpers::windows_semaphore_based_map if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::intermodule_singleton_impl if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::mapping_handle_from_shm_handle if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::os_file_traits if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::ref_count_ptr if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::robust_emulation_helpers::mutex_traits if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::shm_named_mutex if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::shm_named_semaphore if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::spin_condition if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::spin_mutex if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::spin_recursive_mutex if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::spin_semaphore if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::unrestricted_permissions_holder if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::winapi_mutex_functions if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::winapi_mutex_wrapper if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::winapi_semaphore_functions if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::winapi_semaphore_wrapper if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::winapi_wrapper_timed_wait_for_single_object if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::winapi_wrapper_try_wait_for_single_object if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::winapi_wrapper_wait_for_single_object if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::windows_bootstamp if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::windows_intermodule_singleton if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::ipcdetail::wshmem_open_or_create if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::managed_windows_shared_memory if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::NtClose_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::NtDeleteFile_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::NtOpenFile if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::NtOpenFile_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::NtQueryInformationFile_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::NtQueryObject_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::NtQuerySection_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::NtQuerySemaphore_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::NtQuerySystemInformation_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::NtQueryTimerResolution_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::NtSetInformationFile_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::NtSetTimerResolution_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::buffer_to_narrow_str if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::buffer_to_wide_str if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::c_heap_deleter if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::close_handle if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::create_directory if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::create_file if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::create_file_mapping if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::dll_func if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::duplicate_current_process_handle if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::farproc_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_access_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_alignment_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_all_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_allocation_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_alternate_name_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_basic_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_both_directory_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_completion_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_compression_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_content_index_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_copy_on_write_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_directory_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_disposition_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_ea_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_end_of_file_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_full_directory_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_full_ea_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_inherit_content_index_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_internal_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_link_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_mailslot_query_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_mailslot_set_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_maximum_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_mode_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_move_cluster_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_name_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_names_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_network_open_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_object_id_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_ole_directory_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_ole_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_pipe_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_pipe_local_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_pipe_remote_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_position_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_quota_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_rename_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_reparse_point_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_standard_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_stream_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_information_class_t::file_tracking_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::file_rename_information_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::find_close if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::find_first_file if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::find_next_file if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::flush_file_buffers if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::flush_view_of_file if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::format_message if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::free_library if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::function_address_holder if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_boot_and_system_time if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_boot_and_system_time_wstr if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_boot_time if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_boot_time_str if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_current_process if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_current_process_id if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_current_thread_id if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_file_information_by_handle if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_file_mapping_size if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_file_size if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_file_type if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_last_bootup_time if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_last_error if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_module_handle if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_proc_address if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_process_times if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_registry_value if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_registry_value_buffer if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_registry_value_string if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_semaphore_info if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_shared_documents_folder if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_system_info if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_system_time_of_day_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_temp_path if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::get_tick_count if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::handle_closer if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::hkey if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::hmodule if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::initialize_object_attributes if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interlocked_compare_exchange if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interlocked_decrement if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interlocked_exchange if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interlocked_exchange_add if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interlocked_increment if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interprocess_all_access_security if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interprocess_by_handle_file_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interprocess_filetime if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interprocess_overlapped if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interprocess_section_basic_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interprocess_security_attributes if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interprocess_security_descriptor if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interprocess_semaphore_basic_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::interprocess_system_info if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::io_status_block_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::is_directory if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::library_unloader if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::load_library if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::local_free if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::lock_file_ex if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::make_lang_id if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::map_view_of_file_ex if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::nt_query_mem_deleter if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::ntquery_mem_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::object_attributes_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::object_information_class if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::object_information_class::object_all_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::object_information_class::object_basic_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::object_information_class::object_data_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::object_information_class::object_name_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::object_information_class::object_type_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::object_name_information_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::open_file_mapping if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::open_or_create_mutex if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::open_or_create_semaphore if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::open_semaphore if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::query_performance_counter if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::query_performance_frequency if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::query_timer_resolution if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::read_file if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::reg_close_key if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::reg_closer if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::reg_open_key_ex if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::reg_query_value_ex if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::release_mutex if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::release_semaphore if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::remove_directory if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::rtl_init_empty_unicode_string if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::sched_yield if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::section_information_class if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::section_information_class::section_basic_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::section_information_class::section_image_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::semaphore_information_class if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::semaphore_information_class::semaphore_basic_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::set_end_of_file if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::set_file_pointer if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::set_last_error if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::sleep if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::sleep_tick if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::system_information_class if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::system_information_class::system_basic_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::system_information_class::system_exception_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::system_information_class::system_interrupt_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::system_information_class::system_lookaside_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::system_information_class::system_performance_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::system_information_class::system_process_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::system_information_class::system_processor_performance_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::system_information_class::system_registry_quota_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::system_information_class::system_time_of_day_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::system_timeofday_information if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::unicode_string_t if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::unlink_file if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::unlock_file_ex if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::unmap_view_of_file if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::virtual_protect if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::virtual_unlock if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::wait_for_single_object if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::win32_find_data_a if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::win32_find_data_w if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::winapi_traits if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::winapi::write_file if defined(_WIN32) -- M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) is Windows-only; POSIX interprocess never declares it. +interprocess guard boost::interprocess::windows_shared_memory if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::interprocess::wmanaged_windows_shared_memory if defined(_WIN32) -- The Windows shared-memory and synchronization surface (detail/win32_api.hpp chain); POSIX interprocess never declares it. +interprocess guard boost::ipwinapiext::CreateThread if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::FlushFileBuffers if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::GetFileType if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::GetSystemInfo if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::HKEY_ if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::LPTHREAD_START_ROUTINE_ if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::LSTATUS if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::RegCloseKey if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::RegOpenKeyExA if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::RegOpenKeyExW if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::RegQueryValueExA if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::RegQueryValueExW if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::SetLastError if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::VirtualLock if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::VirtualProtect if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +interprocess guard boost::ipwinapiext::VirtualUnlock if defined(_WIN32) -- M12 platform guard: registry / virtual-memory extension surface — Windows-only (win32_api.hpp chain). +intrusive guard boost::intrusive::detail::builtin_clz_dispatch if defined(__GNUC__) -- M9 platform guard: math.hpp defines builtin_clz_dispatch only in the __GNUC__ branch of the BSR intrinsic chain. +iostreams guard boost::iostreams::detail::codecvt_impl if defined(BOOST_IOSTREAMS_NO_PRIMARY_CODECVT_DEFINITION) || \ defined(BOOST_IOSTREAMS_EMPTY_PRIMARY_CODECVT_DEFINITION) || \ defined(BOOST_IOSTREAMS_NO_LOCALE) -- M11 platform guard: detail/codecvt_helper.hpp declares codecvt_impl only on these std::codecvt workaround paths (libstdc++ mingw snapshot); the MSVC STL takes none of them. +lambda guard boost::lambda::ll::random_shuffle if !defined(BOOST_NO_CXX98_RANDOM_SHUFFLE) -- C4 flavor guard: random_shuffle is the !BOOST_NO_CXX98_RANDOM_SHUFFLE branch of algorithm.hpp (MSVC STL/libc++ under C++17 removed std::random_shuffle). +leaf extra boost::leaf::detail -- M9: gcc 16.1.0 module consumers emit a partial vtable for exception (multi-base exception_base/error_id) whose non-virtual thunks stay undefined — gcc never emits them in a module consumer TU. This extern template suppresses the consumer's implicit instantiation; the complete vtable + thunks come from the explicit instantiation in port/leaf_extras.cpp (same pattern as thread's clone_impl, cf. M7c). +math guard boost::float80_t if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 -- M11 platform guard: cstdfloat_types.hpp declares the 80-bit long-double typedefs only where long double really is 80-bit; MSVC long double is 53-bit. +math guard boost::float_fast80_t if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 -- M11 platform guard: cstdfloat_types.hpp declares the 80-bit long-double typedefs only where long double really is 80-bit; MSVC long double is 53-bit. +math guard boost::float_least80_t if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 -- M11 platform guard: cstdfloat_types.hpp declares the 80-bit long-double typedefs only where long double really is 80-bit; MSVC long double is 53-bit. +math guard boost::math::statistics::detail::chatterjee_correlation_par_impl if defined(BOOST_MATH_EXEC_COMPATIBLE) -- M11 CI platform guard: statistics chatterjee_correlation_par_impl is defined only under BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / bivariate_statistics.hpp); libc++ lacks __cpp_lib_execution. +math guard boost::math::statistics::detail::correlation_coefficient_parallel_impl if defined(BOOST_MATH_EXEC_COMPATIBLE) -- M11 CI platform guard: statistics correlation_coefficient_parallel_impl is defined only under BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / bivariate_statistics.hpp); libc++ lacks __cpp_lib_execution. +math guard boost::math::statistics::detail::means_and_covariance_parallel_impl if defined(BOOST_MATH_EXEC_COMPATIBLE) -- M11 CI platform guard: statistics means_and_covariance_parallel_impl is defined only under BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / bivariate_statistics.hpp); libc++ lacks __cpp_lib_execution. +mp11 guard boost::mp11::detail::mpmf_unwrap if !defined(__GNUC__) -- M3 hand-guard: mp_map_find.hpp (gcc bug 120161 workaround) defines mpmf_* only outside gcc. +mp11 guard boost::mp11::detail::mpmf_wrap if !defined(__GNUC__) -- M3 hand-guard: mp_map_find.hpp (gcc bug 120161 workaround) defines mpmf_* only outside gcc. +multiprecision drop boost::multiprecision::detail::unmentionable -- Detail placeholder (a member-pointer typedef used to disable overloads); gcc treats it as having no external linkage and refuses the export. +multiprecision drop boost::multiprecision::detail::unmentionable_type -- Detail placeholder (a member-pointer typedef used to disable overloads); gcc treats it as having no external linkage and refuses the export. +multiprecision guard boost::multiprecision::backends::divide_subtract if defined(BOOST_HAS_INT128) -- M12 platform guard: divide_subtract is the synthetic-double_limb_type division branch of cpp_int/misc.hpp (BOOST_HAS_INT128 only). +multiprecision guard boost::multiprecision::backends::divide_unsigned_helper if defined(BOOST_HAS_INT128) -- M12 platform guard: as above (divide_unsigned_helper). +multiprecision guard boost::multiprecision::detail::addcarry_limb if defined(BOOST_MP_HAS_IMMINTRIN_H) -- M11 platform guard: cpp_int/intel_intrinsics.hpp declares addcarry_limb only under BOOST_MP_HAS_IMMINTRIN_H (the adc intrinsics dispatch — clang on macOS arm64 unsets the macro because __builtin_ia32_addcarryx_u64 is a gcc-only builtin and BOOST_GCC is not defined). +multiprecision guard boost::multiprecision::detail::subborrow_limb if defined(BOOST_MP_HAS_IMMINTRIN_H) -- M11 platform guard: cpp_int/intel_intrinsics.hpp declares subborrow_limb only under BOOST_MP_HAS_IMMINTRIN_H (see addcarry_limb guard for rationale). +multiprecision guard boost::multiprecision::int128_type if defined(BOOST_HAS_INT128) -- M12 platform guard: detail/standalone_config.hpp defines int128_type only under BOOST_HAS_INT128 (off under the clang-msvc flavor). +multiprecision guard boost::multiprecision::uint128_type if defined(BOOST_HAS_INT128) -- M12 platform guard: as above (uint128_type). +nowide guard boost::nowide::detail::console_input_buffer if defined(_WIN32) -- M11 platform guard: console_input_buffer is the windows console machinery (detail/console_buffer.hpp); POSIX nowide uses std:: streams directly. +nowide guard boost::nowide::detail::console_output_buffer if defined(_WIN32) -- M11 platform guard: console_output_buffer is the windows console machinery (detail/console_buffer.hpp); POSIX nowide uses std:: streams directly. +nowide guard boost::nowide::detail::stat if defined(_WIN32) -- M11 platform guard: detail::stat is the BOOST_WINDOWS branch of stat.hpp; POSIX exposes ::stat via a using-declaration instead. +nowide guard boost::nowide::detail::winconsole_istream if defined(_WIN32) -- M11 platform guard: winconsole_istream is the windows console stream branch of iostream.hpp; POSIX takes std:: streams directly. +nowide guard boost::nowide::detail::winconsole_ostream if defined(_WIN32) -- M11 platform guard: winconsole_ostream is the windows console stream branch of iostream.hpp; POSIX takes std:: streams directly. +numeric guard boost::numeric::ublas::same_impl_ex if !defined(NDEBUG) && !defined(BOOST_UBLAS_NDEBUG) -- Boost.uBLAS declares same_impl_ex only when size checks are on; a release build (NDEBUG) takes BOOST_UBLAS_USE_FAST_SAME and never declares it. +pfr guard boost::pfr::detail::clang_wrapper_t if defined(__clang__) -- M9 platform guard: clang_wrapper_t is the clang-only NTTP wrapper (core_name20_static.hpp #ifdef __clang__ branch). +pfr guard boost::pfr::detail::fields_count_dispatch_impl if BOOST_PFR_USE_CPP26_REFLECTION || BOOST_PFR_USE_CPP26 -- M9 platform guard: fields_count_dispatch_impl exists only under the C++26 reflection / structured-bindings branches (fields_count.hpp). +poly_collection guard boost::mpl::item_by_order_impl if defined(__GNUC__) -- M9 platform guard: gcc-preprocessed mpl map headers only. +process guard boost::asio::windows::basic_object_handle if defined(_WIN32) -- The boost::asio::windows handles that process's Windows launcher reaches (stream_handle, basic_object_handle) exist only on Windows. +process guard boost::asio::windows::stream_handle if defined(_WIN32) -- The boost::asio::windows handles that process's Windows launcher reaches (stream_handle, basic_object_handle) exist only on Windows. +process guard boost::process::v1::detail::windows::apply_out_handles if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::associate_completion_port if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::async_handler if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::async_handler_collector if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::async_in_buffer if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::async_out_buffer if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::async_out_future if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::async_pipe if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::async_pipe_in if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::async_pipe_out if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::basic_environment_impl if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::basic_pipe if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::break_away_enabled if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::build_args if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::child_handle if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::close_in if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::close_out if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::cmd_setter_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::compare_handles if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::create_no_window_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::does_require_io_context if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::enable_break_away if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::env_init if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::env_seperator if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::eval_exit_status if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::exe_cmd_init if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::executor if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::file_descriptor if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::file_in if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::file_out if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::get_handles if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::get_id if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::group_handle if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::group_ref if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::handler_base_ext if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::in_group if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::io_context_ref if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::is_async_handler if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::is_running if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::is_stream_handle if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::limit_handles_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::make_executor if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::make_pipe_name if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::native_environment_impl if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::native_handle if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::native_handle_t if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::native_handle_type if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::null_in if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::null_out if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::on_exit_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::on_exit_handler_transformer if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::operator!= if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::operator== if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::pid_t if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::pipe_in if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::pipe_out if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::require_io_context if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::search_path if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::shell_path if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::show_window if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::start_dir_init if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::startup_info if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::startup_info_ex if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::startup_info_impl if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::terminate if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::wait if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::wait_for if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::wait_impl if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::wait_until if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::windows_file_codecvt if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::GENERIC_MAPPING_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::OBJECT_BASIC_INFORMATION_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::OBJECT_INFORMATION_CLASS_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::OBJECT_NAME_INFORMATION_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::POBJECT_BASIC_INFORMATION_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::POBJECT_INFORMATION_CLASS_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::POBJECT_NAME_INFORMATION_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::PSYSTEM_HANDLE_ENTRY_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::PSYSTEM_HANDLE_INFORMATION_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::PUNICODE_STRING_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::SYSTEM_HANDLE_ENTRY_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::SYSTEM_HANDLE_INFORMATION_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::UNICODE_STRING_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::_GENERIC_MAPPING_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::_OBJECT_BASIC_INFORMATION if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::_OBJECT_INFORMATION_CLASS_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::_OBJECT_INFORMATION_CLASS_::ObjectAllInformation if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::_OBJECT_INFORMATION_CLASS_::ObjectBasicInformation if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::_OBJECT_INFORMATION_CLASS_::ObjectDataInformation if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::_OBJECT_INFORMATION_CLASS_::ObjectNameInformation if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::_OBJECT_INFORMATION_CLASS_::ObjectTypeInformation if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::_OBJECT_NAME_INFORMATION if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::_SYSTEM_HANDLE_ENTRY_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::_SYSTEM_HANDLE_INFORMATION_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::_UNICODE_STRING_ if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::get_queued_completion_status if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::nt_query_object if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::nt_system_query_information if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v1::detail::windows::workaround::set_information_job_object if defined(_WIN32) -- M11 platform guard: v1 detail windows impls (incl. the NT workaround block below) are declared only by the windows GMF branches. +process guard boost::process::v2::_popen if defined(__MINGW32__) -- M11 platform guard: _popen is the MinGW spelling of popen (mingw stdio.h #defines popen to _popen); MSVC/POSIX expose popen. +process guard boost::process::v2::detail::all_are_initializers if defined(_WIN32) -- M11 platform guard: all_are_initializers is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::base if defined(_WIN32) -- M11 platform guard: base is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::basic_process_handle_win if defined(_WIN32) -- M11 platform guard: basic_process_handle_win is the windows variant (detail/process_handle_windows.hpp); POSIX takes process_handle_fd. +process guard boost::process::v2::detail::check_handle_ if defined(_WIN32) -- M11 platform guard: check_handle_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). +process guard boost::process::v2::detail::check_pid_ if defined(_WIN32) -- M11 platform guard: check_pid_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). +process guard boost::process::v2::detail::check_running_ if defined(_WIN32) -- M11 platform guard: check_running_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). +process guard boost::process::v2::detail::derived if defined(_WIN32) -- M11 platform guard: derived is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::get_exit_code_ if defined(_WIN32) -- M11 platform guard: get_exit_code_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). +process guard boost::process::v2::detail::handle_closer if defined(_WIN32) -- M11 platform guard: handle_closer is the Windows stdio handle wrapper (DWORD/GetStdHandle); POSIX stdio does not declare it. +process guard boost::process::v2::detail::has_on_error if defined(_WIN32) -- M11 platform guard: has_on_error is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::has_on_setup if defined(_WIN32) -- M11 platform guard: has_on_setup is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::has_on_success if defined(_WIN32) -- M11 platform guard: has_on_success is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::interrupt_ if defined(_WIN32) -- M11 platform guard: interrupt_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). +process guard boost::process::v2::detail::invoke_on_error if defined(_WIN32) -- M11 platform guard: invoke_on_error is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::invoke_on_setup if defined(_WIN32) -- M11 platform guard: invoke_on_setup is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::invoke_on_success if defined(_WIN32) -- M11 platform guard: invoke_on_success is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::is_initializer if defined(_WIN32) -- M11 platform guard: is_initializer is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::on_error if defined(_WIN32) -- M11 platform guard: on_error is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::on_setup if defined(_WIN32) -- M11 platform guard: on_setup is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::on_success if defined(_WIN32) -- M11 platform guard: on_success is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::open_process_ if defined(_WIN32) -- M11 platform guard: open_process_ lives in detail/process_handle_windows.hpp. +process guard boost::process::v2::detail::probe_on_error if defined(_WIN32) -- M11 platform guard: probe_on_error is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::probe_on_setup if defined(_WIN32) -- M11 platform guard: probe_on_setup is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::probe_on_success if defined(_WIN32) -- M11 platform guard: probe_on_success is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. +process guard boost::process::v2::detail::request_exit_ if defined(_WIN32) -- M11 platform guard: request_exit_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). +process guard boost::process::v2::detail::resume_ if defined(_WIN32) -- M11 platform guard: resume_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). +process guard boost::process::v2::detail::suspend_ if defined(_WIN32) -- M11 platform guard: suspend_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). +process guard boost::process::v2::detail::terminate_ if defined(_WIN32) -- M11 platform guard: terminate_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). +process guard boost::process::v2::detail::terminate_if_running_ if defined(_WIN32) -- M11 platform guard: terminate_if_running_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). +process guard boost::process::v2::environment::detail::is_exec_type if defined(_WIN32) -- M11 platform guard: is_exec_type lives in detail/environment_win.hpp; POSIX environment detail does not declare it. +process guard boost::process::v2::windows::as_user_launcher if defined(_WIN32) -- M11 platform guard: v2 windows launchers are Windows-only headers. +process guard boost::process::v2::windows::default_launcher if defined(_WIN32) -- M11 platform guard: v2 windows launchers are Windows-only headers. +process guard boost::process::v2::windows::process_creation_flags if defined(_WIN32) -- M11 platform guard: v2 windows launchers are Windows-only headers. +process guard boost::process::v2::windows::process_show_window if defined(_WIN32) -- M11 platform guard: v2 windows launchers are Windows-only headers. +process guard boost::process::v2::windows::with_logon_launcher if defined(_WIN32) -- M11 platform guard: v2 windows launchers are Windows-only headers. +process guard boost::process::v2::windows::with_token_launcher if defined(_WIN32) -- M11 platform guard: v2 windows launchers are Windows-only headers. +program_options guard boost::program_options::split_winmain if defined(_WIN32) -- M6 platform guard: winmain.hpp (split_winmain) is Windows-only. +qvm guard boost::qvm::qvm_detail::vec_traits_gnuc_impl if defined(__GNUC__) && defined(__SSE2__) -- M12 platform guard: vec_traits_gnuc.hpp declares vec_traits_gnuc_impl only under __GNUC__ && __SSE2__ (gcc vector_size ext_vector_traits). +range guard std::random_shuffle if defined(__GLIBCXX__) -- M9 platform guard: std::random_shuffle was removed in C++17; only libstdc++ (mingw/linux-gcc) still provides it. +signals2 guard boost::signals2::detail::critical_section if defined(BOOST_HAS_WINTHREADS) -- The critical-section mutex is the Windows-threads branch of signals2's lightweight mutex; POSIX uses pthread. +signals2 guard boost::signals2::detail::critical_section_debug if defined(BOOST_HAS_WINTHREADS) -- The critical-section mutex is the Windows-threads branch of signals2's lightweight mutex; POSIX uses pthread. +signals2 guard boost::signals2::detail::rtl_critical_section if defined(BOOST_HAS_WINTHREADS) -- The critical-section mutex is the Windows-threads branch of signals2's lightweight mutex; POSIX uses pthread. +system guard boost::system::detail::local_free if defined(BOOST_WINDOWS_API) -- M6 platform guard: snapshot = mingw flavor; these boost/system/detail entities exist only under BOOST_WINDOWS_API (system_category_message_win32.hpp / condition). +system guard boost::system::detail::message_cp_win32 if defined(BOOST_WINDOWS_API) -- M6 platform guard: snapshot = mingw flavor; these boost/system/detail entities exist only under BOOST_WINDOWS_API (system_category_message_win32.hpp / condition). +system guard boost::system::detail::system_category_condition_win32 if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::detail::system_category_message_win32 if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::detail::unknown_message_win32 if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::make_error_code if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::access_denied if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::already_exists if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::arena_trashed if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::bad_command if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::bad_environment if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::bad_format if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::bad_length if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::bad_net_path if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::bad_unit if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::broken_pipe if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::buffer_overflow if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::busy if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::cancel_violation if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::cannot_make if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::crc if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::current_directory if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::disk_full if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::dup_name if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::file_exists if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::file_not_found if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::gen_failure if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::handle_disk_full if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::handle_eof if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::invalid_access if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::invalid_block if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::invalid_drive if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::invalid_function if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::invalid_handle if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::lock_failed if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::lock_violation if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::network_busy if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::no_more_files if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::not_dos_disk if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::not_enough_memory if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::not_ready if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::not_same_device if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::not_supported if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::open_failed if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::out_of_paper if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::outofmemory if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::path_not_found if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::read_fault if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::rem_not_list if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::sector_not_found if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::seek if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::sharing_buffer_exceeded if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::sharing_violation if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::success if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::too_many_open_files if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::write_fault if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::write_protect if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +system guard boost::system::windows_error::windows_error_code::wrong_disk if defined(BOOST_WINDOWS_API) -- M6 platform guard: as above. +thread extra boost -- M7c: gcc 16.1.0 module consumers emit a partial vtable for clone_impl (virtual base clone_base) whose thunk slots stay undefined — gcc never emits the thunks in a module consumer TU. These extern-template declarations suppress the consumer's implicit instantiation; the complete vtable + thunks come from the explicit instantiation in port/thread_extras.cpp (same pattern as boost_system_extras.cpp). +thread guard boost::detail::allocate_raw_heap_memory if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::basic_condition_variable if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::basic_cv_list_entry if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::basic_recursive_mutex if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::basic_recursive_mutex_impl if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::basic_recursive_timed_mutex if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::basic_timed_mutex if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::commit_once_region if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::create_once_event if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::enter_once_region if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::free_raw_heap_memory if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::int_to_string if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::interlocked_read_acquire if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::interlocked_write_release if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::intrusive_ptr_add_ref if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::intrusive_ptr_release if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::name_once_mutex if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::once_action if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::once_action::break_ if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::once_action::continue_ if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::once_action::try_ if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::once_char_type if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::once_context if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::open_once_event if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::rollback_once_region if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::underlying_mutex if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::create_anonymous_event if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::create_anonymous_semaphore if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::create_anonymous_semaphore_nothrow if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::create_event if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::detail::gettickcount64_t if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::duplicate_handle if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::event_type if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::event_type::auto_reset_event if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::event_type::manual_reset_event if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::get_system_info if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::gettickcount64 if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::handle if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::handle_manager if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::initial_event_state if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::initial_event_state::event_initially_reset if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::initial_event_state::event_initially_set if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::interlocked_bit_test_and_reset if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::interlocked_bit_test_and_set if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::release_semaphore if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::sleep if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::system_info if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::detail::win32::ticks_type if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::this_thread::interruptible_wait if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +thread guard boost::this_thread::no_interruption_point::non_interruptible_wait if defined(_WIN32) -- The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX builds the pthread backend. +tuple guard boost::tuples::detail::ignore_t if !defined(__GNUC__) -- M3 hand-guard: ignore_t is a member-pointer typedef; gcc treats it as internal linkage. +url guard boost::urls::grammar::detail::find_if_not_pred if defined(BOOST_URL_USE_SSE2) -- M7 platform guard: charset.hpp defines the *_pred SSE2 helpers only under BOOST_URL_USE_SSE2 (x86 with SSE2); absent on arm64 (e.g. macOS). +url guard boost::urls::grammar::detail::find_if_pred if defined(BOOST_URL_USE_SSE2) -- M7 platform guard: charset.hpp defines the *_pred SSE2 helpers only under BOOST_URL_USE_SSE2 (x86 with SSE2); absent on arm64 (e.g. macOS). +utility drop boost::basic_string_ref -- Declared only via boost/utility/string_ref.hpp, which is left out of the module GMF (gcc 16.1 buffer_fill enum mismatch); consumers include the header. +utility drop boost::string_ref -- Declared only via boost/utility/string_ref.hpp, which is left out of the module GMF (gcc 16.1 buffer_fill enum mismatch); consumers include the header. +utility drop boost::u16string_ref -- Declared only via boost/utility/string_ref.hpp, which is left out of the module GMF (gcc 16.1 buffer_fill enum mismatch); consumers include the header. +utility drop boost::u32string_ref -- Declared only via boost/utility/string_ref.hpp, which is left out of the module GMF (gcc 16.1 buffer_fill enum mismatch); consumers include the header. +utility drop boost::wstring_ref -- Declared only via boost/utility/string_ref.hpp, which is left out of the module GMF (gcc 16.1 buffer_fill enum mismatch); consumers include the header. +uuid guard boost::uuids::detail::compare if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::countr_zero_nz if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::from_chars_simd if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::from_chars_simd_char_constants if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::from_chars_simd_constants if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::from_chars_simd_core if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::from_chars_simd_load_traits if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::simd_vector if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::simd_vector128 if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::simd_vector256 if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::simd_vector512 if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::to_chars_simd if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::to_chars_simd_char_constants if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::to_chars_simd_constants if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +uuid guard boost::uuids::detail::to_chars_simd_core if defined(BOOST_UUID_USE_SSE2) -- The SIMD to_chars/from_chars helpers are declared only under BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +variant guard boost::mpl::aux::arity_helper if defined(__GNUC__) -- M3 hand-guard: gcc-preprocessed mpl headers only (BOOST_MPL_CFG_COMPILER_DIR=gcc). +variant guard boost::mpl::aux::arity_tag if defined(__GNUC__) -- M3 hand-guard: gcc-preprocessed mpl headers only (BOOST_MPL_CFG_COMPILER_DIR=gcc). +variant guard boost::mpl::aux::max_arity if defined(__GNUC__) -- M3 hand-guard: as above (max_arity). +variant guard boost::mpl::aux::nested_type_wknd if defined(__GNUC__) -- M3 hand-guard: as above (nested_type_wknd). +variant guard boost::mpl::aux::template_arity_impl if defined(__GNUC__) -- M3 hand-guard: as above (template_arity_impl). +winapi drop boost::winapi::detail::winsdk_condition_variable -- Declared inside extern "C" blocks, and only without windows.h and above a Windows API version (BOOST_USE_WINAPI_VERSION); the definition differs between MinGW and the Windows SDK. Implementation detail of boost.winapi's own signatures, not a name consumers spell. +winapi drop boost::winapi::detail::winsdk_critical_section -- Declared inside extern "C" blocks, and only without windows.h and above a Windows API version (BOOST_USE_WINAPI_VERSION); the definition differs between MinGW and the Windows SDK. Implementation detail of boost.winapi's own signatures, not a name consumers spell. +winapi drop boost::winapi::detail::winsdk_srwlock -- Declared inside extern "C" blocks, and only without windows.h and above a Windows API version (BOOST_USE_WINAPI_VERSION); the definition differs between MinGW and the Windows SDK. Implementation detail of boost.winapi's own signatures, not a name consumers spell. diff --git a/mcpp.toml b/mcpp.toml index 5ca1b016d..9c7a27c06 100644 --- a/mcpp.toml +++ b/mcpp.toml @@ -306,7 +306,7 @@ cxxflags = ["-Wno-invalid-specialization"] # -- generated by tools/gen_features.py - do not edit -- [features] -default = ["optional", "variant", "variant2", "any", "core", "container-hash", "mp11", "type-traits", "algorithm", "iterator", "range", "io", "endian", "tuple", "system", "filesystem", "regex", "thread", "chrono", "json", "array", "assert", "compat", "concept-check", "config", "dynamic-bitset", "functional", "integer", "intrusive", "lambda", "lexical-cast", "move", "multi-array", "ratio", "smart-ptr", "throw-exception", "tokenizer", "type-index", "units", "utility", "winapi", "atomic", "container", "date-time", "math", "random", "serialization", "numeric", "version", "macros"] +default = ["optional", "variant", "variant2", "any", "core", "container-hash", "mp11", "type-traits", "algorithm", "iterator", "range", "io", "endian", "tuple", "system", "filesystem", "regex", "thread", "chrono", "json", "array", "assert", "bind", "compat", "concept-check", "config", "dynamic-bitset", "function", "functional", "integer", "intrusive", "lambda", "lexical-cast", "move", "multi-array", "ratio", "smart-ptr", "throw-exception", "tokenizer", "type-index", "units", "utility", "winapi", "atomic", "container", "date-time", "math", "random", "serialization", "numeric", "version", "macros"] all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "container-hash", "mp11", "static-string", "scope", "type-traits", "algorithm", "iterator", "range", "io", "rational", "endian", "tuple", "system", "filesystem", "regex", "thread", "chrono", "program-options", "stacktrace", "json", "url", "align", "array", "assert", "assign", "bimap", "bind", "bloom", "callable-traits", "circular-buffer", "compat", "concept-check", "config", "convert", "crc", "decimal", "dll", "dynamic-bitset", "flyweight", "format", "function", "functional", "hash2", "heap", "histogram", "hof", "icl", "integer", "intrusive", "lambda", "lambda2", "leaf", "lexical-cast", "lockfree", "logic", "move", "multi-array", "multi-index", "outcome", "parser", "pfr", "poly-collection", "pool", "property-map", "property-tree", "ptr-container", "ratio", "safe-numerics", "signals2", "smart-ptr", "sort", "statechart", "stl-interfaces", "throw-exception", "tokenizer", "type-index", "units", "unordered", "utility", "uuid", "winapi", "yap", "atomic", "charconv", "cobalt", "container", "contract", "date-time", "graph", "iostreams", "math", "nowide", "process", "random", "serialization", "timer", "type-erasure", "wave", "accumulators", "asio", "beast", "geometry", "gil", "hana", "interprocess", "mqtt5", "multiprecision", "numeric", "polygon", "qvm", "version", "macros"] } [features.optional] sources = ["src/optional.cppm"] @@ -325,12 +325,12 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co implies = ["assert", "config", "throw-exception"] [features.container-hash] sources = ["src/container_hash.cppm"] - implies = ["config", "mp11"] + implies = ["mp11"] [features.mp11] sources = ["src/mp11.cppm"] [features.static-string] sources = ["src/static_string.cppm"] - implies = ["assert", "container-hash", "core"] + implies = ["assert", "container-hash", "core", "utility"] [features.scope] sources = ["src/scope.cppm"] implies = ["core"] @@ -339,13 +339,13 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co implies = ["config"] [features.algorithm] sources = ["src/algorithm.cppm"] - implies = ["core", "iterator", "range", "tuple", "type-traits"] + implies = ["assert", "bind", "concept-check", "config", "core", "function", "iterator", "range", "smart-ptr", "throw-exception", "tuple", "type-traits"] [features.iterator] sources = ["src/iterator.cppm"] implies = ["assert", "concept-check", "config", "core", "mp11", "optional", "tuple", "type-traits", "utility"] [features.range] sources = ["src/range.cppm"] - implies = ["array", "assert", "concept-check", "config", "core", "functional", "iterator", "optional", "regex", "tuple", "type-traits", "utility"] + implies = ["array", "assert", "concept-check", "config", "core", "functional", "iterator", "optional", "regex", "tuple", "type-traits"] [features.io] sources = ["src/io.cppm"] implies = ["config"] @@ -354,22 +354,21 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co implies = ["assert", "config", "integer", "throw-exception", "type-traits", "utility"] [features.endian] sources = ["src/endian.cppm"] - implies = ["config"] [features.tuple] sources = ["src/tuple.cppm"] - implies = ["config", "core", "type-traits"] + implies = ["core", "type-traits"] [features.system] sources = ["src/system.cppm", "port/system_extras.cpp"] implies = ["assert", "compat", "variant2", "winapi"] [features.filesystem] sources = ["src/filesystem.cppm", "upstream/boost/libs/filesystem/src/*.cpp"] - implies = ["io", "iterator", "smart-ptr", "system"] + implies = ["container-hash", "io", "iterator", "smart-ptr", "system"] [features.regex] sources = ["src/regex.cppm", "upstream/boost/libs/regex/src/*.cpp"] implies = ["assert", "concept-check", "config", "throw-exception", "type-traits"] [features.thread] sources = ["src/thread.cppm", "upstream/boost/libs/thread/src/future.cpp", "upstream/boost/libs/thread/src/win32/*.cpp", "upstream/boost/libs/thread/src/pthread/once.cpp", "upstream/boost/libs/thread/src/pthread/thread.cpp", "port/thread_extras.cpp"] - implies = ["assert", "atomic", "chrono", "config", "core", "date-time", "io", "optional", "smart-ptr", "system", "throw-exception", "type-traits", "utility", "winapi"] + implies = ["assert", "atomic", "chrono", "concept-check", "config", "core", "date-time", "io", "optional", "smart-ptr", "system", "throw-exception", "type-traits", "utility", "winapi"] [features.chrono] sources = ["src/chrono.cppm", "upstream/boost/libs/chrono/src/*.cpp"] implies = ["assert", "config", "core", "integer", "move", "ratio", "system", "type-traits"] @@ -378,13 +377,13 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co implies = ["any", "assert", "function", "iterator", "lexical-cast", "smart-ptr"] [features.stacktrace] sources = ["src/stacktrace.cppm", "upstream/boost/libs/stacktrace/src/basic.cpp", "upstream/boost/libs/stacktrace/src/dump.cpp"] - implies = ["config"] + implies = ["config", "container-hash"] [features.json] sources = ["src/json.cppm", "upstream/boost/libs/json/src/*.cpp"] implies = ["assert", "container", "core", "endian", "mp11", "system", "variant2"] [features.url] sources = ["src/url.cppm", "upstream/boost/libs/url/src/**/*.cpp"] - implies = ["assert", "core", "optional", "system", "type-traits", "variant2"] + implies = ["assert", "core", "mp11", "optional", "system", "type-traits", "variant2"] [features.align] sources = ["src/align.cppm"] implies = ["assert", "config", "core"] @@ -410,7 +409,7 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co sources = ["src/callable_traits.cppm"] [features.circular-buffer] sources = ["src/circular_buffer.cppm"] - implies = ["assert", "config", "core", "type-traits"] + implies = ["assert", "concept-check", "config", "core", "move", "type-traits"] [features.compat] sources = ["src/compat.cppm"] implies = ["assert", "config", "throw-exception"] @@ -428,19 +427,19 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co sources = ["src/decimal.cppm"] [features.dll] sources = ["src/dll.cppm"] - implies = ["assert", "core", "filesystem", "type-index", "winapi"] + implies = ["assert", "core", "filesystem", "io", "type-index", "winapi"] [features.dynamic-bitset] sources = ["src/dynamic_bitset.cppm"] - implies = ["assert", "core"] + implies = ["assert", "container-hash", "core"] [features.flyweight] sources = ["src/flyweight.cppm"] - implies = ["assert", "config", "core", "interprocess", "mp11", "multi-index", "smart-ptr", "throw-exception", "type-traits", "unordered"] + implies = ["assert", "config", "container-hash", "core", "interprocess", "mp11", "multi-index", "smart-ptr", "throw-exception", "type-traits", "unordered"] [features.format] sources = ["src/format.cppm"] implies = ["assert", "config", "optional", "smart-ptr", "utility"] [features.function] sources = ["src/function.cppm"] - implies = ["assert", "core"] + implies = ["assert", "bind", "core"] [features.functional] sources = ["src/functional.cppm"] implies = ["assert", "config", "container-hash", "core", "type-traits", "utility"] @@ -457,7 +456,7 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co sources = ["src/hof.cppm"] [features.icl] sources = ["src/icl.cppm"] - implies = ["assert", "config", "date-time", "io", "iterator", "rational", "type-traits", "utility"] + implies = ["assert", "config", "date-time", "io", "iterator", "rational", "smart-ptr", "type-traits", "utility"] [features.integer] sources = ["src/integer.cppm"] implies = ["assert", "config", "core", "throw-exception", "type-traits"] @@ -499,16 +498,16 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co sources = ["src/pfr.cppm"] [features.poly-collection] sources = ["src/poly_collection.cppm"] - implies = ["assert", "config", "core", "iterator", "mp11", "type-erasure", "type-traits"] + implies = ["assert", "config", "core", "iterator", "mp11", "smart-ptr", "type-erasure", "type-traits"] [features.pool] sources = ["src/pool.cppm"] - implies = ["assert", "config", "integer", "throw-exception"] + implies = ["assert", "config", "integer", "throw-exception", "type-traits"] [features.property-map] sources = ["src/property_map.cppm"] implies = ["any", "assert", "config", "core", "function", "iterator", "lexical-cast", "smart-ptr", "throw-exception", "type-index", "type-traits", "utility"] [features.property-tree] sources = ["src/property_tree.cppm"] - implies = ["any", "assert", "bind", "optional", "range", "serialization", "type-traits"] + implies = ["any", "assert", "bind", "concept-check", "optional", "range", "serialization", "type-traits"] [features.ptr-container] sources = ["src/ptr_container.cppm"] implies = ["array", "assert", "circular-buffer", "config", "core", "iterator", "range", "smart-ptr", "type-traits", "unordered"] @@ -519,16 +518,16 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co implies = ["config", "core", "integer", "logic", "mp11", "type-traits"] [features.signals2] sources = ["src/signals2.cppm"] - implies = ["assert", "core", "function", "iterator", "mp11", "optional", "smart-ptr", "type-traits", "variant"] + implies = ["assert", "bind", "core", "function", "iterator", "move", "mp11", "optional", "smart-ptr", "type-traits", "variant"] [features.smart-ptr] sources = ["src/smart_ptr.cppm"] implies = ["assert", "config", "core"] [features.sort] sources = ["src/sort.cppm"] - implies = ["core", "type-traits"] + implies = ["core", "range", "type-traits"] [features.statechart] sources = ["src/statechart.cppm"] - implies = ["assert", "config", "core", "smart-ptr", "thread", "throw-exception", "type-traits"] + implies = ["assert", "config", "core", "function", "smart-ptr", "thread", "throw-exception", "type-traits"] [features.stl-interfaces] sources = ["src/stl_interfaces.cppm"] implies = ["assert", "config"] @@ -543,7 +542,7 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co implies = ["assert", "container-hash", "throw-exception"] [features.units] sources = ["src/units.cppm"] - implies = ["assert", "config", "lambda", "math", "type-traits"] + implies = ["assert", "config", "io", "lambda", "math", "type-traits"] [features.unordered] sources = ["src/unordered.cppm"] implies = ["assert", "config", "container-hash", "core", "mp11", "throw-exception"] @@ -567,7 +566,7 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co implies = ["assert", "core"] [features.cobalt] sources = ["src/cobalt.cppm", "upstream/boost/libs/cobalt/src/*.cpp", "upstream/boost/libs/cobalt/src/detail/*.cpp", "upstream/boost/libs/cobalt/src/io/steady_timer.cpp", "upstream/boost/libs/cobalt/src/io/system_timer.cpp", "upstream/boost/libs/cobalt/src/io/signal_set.cpp", "upstream/boost/libs/cobalt/src/io/sleep.cpp", "upstream/boost/libs/cobalt/src/io/read.cpp", "upstream/boost/libs/cobalt/src/io/write.cpp", "upstream/boost/libs/cobalt/src/io/serial_port.cpp", "upstream/boost/libs/cobalt/src/io/pipe.cpp", "upstream/boost/libs/cobalt/src/io/file.cpp", "upstream/boost/libs/cobalt/src/io/random_access_file.cpp", "upstream/boost/libs/cobalt/src/io/stream_file.cpp", "upstream/boost/libs/cobalt/src/io/endpoint.cpp", "upstream/boost/libs/cobalt/src/io/socket.cpp", "upstream/boost/libs/cobalt/src/io/datagram_socket.cpp", "upstream/boost/libs/cobalt/src/io/seq_packet_socket.cpp", "upstream/boost/libs/cobalt/src/io/stream_socket.cpp", "upstream/boost/libs/cobalt/src/io/resolver.cpp", "upstream/boost/libs/cobalt/src/io/acceptor.cpp"] - implies = ["asio", "assert", "callable-traits", "circular-buffer", "config", "core", "endian", "intrusive", "mp11", "smart-ptr", "static-string", "system", "variant2"] + implies = ["asio", "assert", "callable-traits", "circular-buffer", "config", "core", "endian", "intrusive", "mp11", "smart-ptr", "static-string", "system", "utility", "variant2"] [features.container] sources = ["src/container.cppm", "upstream/boost/libs/container/src/global_resource.cpp", "upstream/boost/libs/container/src/monotonic_buffer_resource.cpp", "upstream/boost/libs/container/src/pool_resource.cpp", "upstream/boost/libs/container/src/synchronized_pool_resource.cpp", "upstream/boost/libs/container/src/unsynchronized_pool_resource.cpp"] implies = ["assert", "config", "intrusive", "move"] @@ -576,13 +575,13 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co implies = ["any", "assert", "config", "core", "function", "optional", "smart-ptr", "thread", "type-traits", "utility"] [features.date-time] sources = ["src/date_time.cppm", "upstream/boost/libs/date_time/src/gregorian/greg_month.cpp"] - implies = ["algorithm", "assert", "core", "io", "iterator", "numeric", "throw-exception", "tokenizer", "type-traits"] + implies = ["algorithm", "assert", "core", "io", "iterator", "numeric", "smart-ptr", "throw-exception", "tokenizer", "type-traits"] [features.graph] sources = ["src/graph.cppm", "upstream/boost/libs/graph/src/*.cpp"] implies = ["algorithm", "any", "array", "assert", "bimap", "concept-check", "config", "container-hash", "core", "function", "integer", "iterator", "lexical-cast", "math", "move", "mp11", "multi-index", "multiprecision", "numeric", "optional", "property-map", "property-tree", "random", "range", "serialization", "smart-ptr", "throw-exception", "tuple", "type-traits", "unordered", "utility", "version"] [features.iostreams] sources = ["src/iostreams.cppm", "upstream/boost/libs/iostreams/src/file_descriptor.cpp", "upstream/boost/libs/iostreams/src/mapped_file.cpp"] - implies = ["assert", "config", "core", "iterator", "random", "range", "smart-ptr", "throw-exception", "type-traits", "utility"] + implies = ["assert", "concept-check", "config", "core", "iterator", "random", "range", "smart-ptr", "throw-exception", "type-traits", "utility"] [features.log] sources = ["upstream/boost/libs/log/src/attribute_name.cpp", "upstream/boost/libs/log/src/attribute_set.cpp", "upstream/boost/libs/log/src/attribute_value_set.cpp", "upstream/boost/libs/log/src/code_conversion.cpp", "upstream/boost/libs/log/src/core.cpp", "upstream/boost/libs/log/src/date_time_format_parser.cpp", "upstream/boost/libs/log/src/default_attribute_names.cpp", "upstream/boost/libs/log/src/default_sink.cpp", "upstream/boost/libs/log/src/dump.cpp", "upstream/boost/libs/log/src/event.cpp", "upstream/boost/libs/log/src/exceptions.cpp", "upstream/boost/libs/log/src/format_parser.cpp", "upstream/boost/libs/log/src/global_logger_storage.cpp", "upstream/boost/libs/log/src/named_scope.cpp", "upstream/boost/libs/log/src/named_scope_format_parser.cpp", "upstream/boost/libs/log/src/once_block.cpp", "upstream/boost/libs/log/src/permissions.cpp", "upstream/boost/libs/log/src/process_id.cpp", "upstream/boost/libs/log/src/process_name.cpp", "upstream/boost/libs/log/src/record_ostream.cpp", "upstream/boost/libs/log/src/severity_level.cpp", "upstream/boost/libs/log/src/spirit_encoding.cpp", "upstream/boost/libs/log/src/syslog_backend.cpp", "upstream/boost/libs/log/src/text_file_backend.cpp", "upstream/boost/libs/log/src/text_multifile_backend.cpp", "upstream/boost/libs/log/src/text_ostream_backend.cpp", "upstream/boost/libs/log/src/thread_id.cpp", "upstream/boost/libs/log/src/thread_specific.cpp", "upstream/boost/libs/log/src/threadsafe_queue.cpp", "upstream/boost/libs/log/src/timer.cpp", "upstream/boost/libs/log/src/timestamp.cpp", "upstream/boost/libs/log/src/trivial.cpp", "upstream/boost/libs/log/src/setup/default_filter_factory.cpp", "upstream/boost/libs/log/src/setup/default_formatter_factory.cpp", "upstream/boost/libs/log/src/setup/filter_parser.cpp", "upstream/boost/libs/log/src/setup/formatter_parser.cpp", "upstream/boost/libs/log/src/setup/init_from_settings.cpp", "upstream/boost/libs/log/src/setup/init_from_stream.cpp", "upstream/boost/libs/log/src/setup/matches_relation_factory.cpp", "upstream/boost/libs/log/src/setup/parser_utils.cpp", "upstream/boost/libs/log/src/setup/settings_parser.cpp", "upstream/boost/libs/log/src/windows/debug_output_backend.cpp", "upstream/boost/libs/log/src/windows/event_log_backend.cpp", "upstream/boost/libs/log/src/windows/ipc_reliable_message_queue.cpp", "upstream/boost/libs/log/src/windows/ipc_sync_wrappers.cpp", "upstream/boost/libs/log/src/windows/is_debugger_present.cpp", "upstream/boost/libs/log/src/windows/light_rw_mutex.cpp", "upstream/boost/libs/log/src/windows/mapped_shared_memory.cpp", "upstream/boost/libs/log/src/windows/object_name.cpp", "upstream/boost/libs/log/src/posix/ipc_reliable_message_queue.cpp", "upstream/boost/libs/log/src/posix/object_name.cpp"] flags = [{ glob = "upstream/boost/libs/log/src/windows/**", defines = ["SECURITY_WIN32"] }] @@ -592,10 +591,10 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co implies = ["assert", "concept-check", "config", "core", "lexical-cast", "random"] [features.nowide] sources = ["src/nowide.cppm", "upstream/boost/libs/nowide/src/*.cpp"] - implies = ["config", "filesystem"] + implies = ["config", "filesystem", "io"] [features.process] sources = ["src/process.cppm", "upstream/boost/libs/process/src/**/*.cpp"] - implies = ["asio", "assert", "config", "core", "filesystem", "iterator", "system", "type-traits", "utility", "winapi"] + implies = ["asio", "assert", "concept-check", "config", "core", "filesystem", "io", "iterator", "system", "type-traits", "utility", "winapi"] [features.random] sources = ["src/random.cppm", "upstream/boost/libs/random/src/random_device.cpp"] implies = ["assert", "config", "core", "dynamic-bitset", "integer", "io", "system", "type-traits"] @@ -610,25 +609,25 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co implies = ["config"] [features.type-erasure] sources = ["src/type_erasure.cppm", "upstream/boost/libs/type_erasure/src/dynamic_binding.cpp"] - implies = ["assert", "config", "core", "iterator", "smart-ptr", "throw-exception", "type-traits", "utility"] + implies = ["assert", "config", "core", "iterator", "mp11", "smart-ptr", "throw-exception", "type-traits", "utility"] [features.wave] sources = ["src/wave.cppm", "upstream/boost/libs/wave/src/*.cpp", "upstream/boost/libs/wave/src/cpplexer/**/*.cpp"] - implies = ["assert", "concept-check", "config", "core", "filesystem", "format", "iterator", "multi-index", "optional", "pool", "smart-ptr", "thread", "throw-exception", "type-traits", "utility", "version"] + implies = ["assert", "concept-check", "config", "core", "filesystem", "format", "io", "iterator", "mp11", "multi-index", "optional", "pool", "smart-ptr", "thread", "throw-exception", "type-traits", "utility", "version"] [features.accumulators] sources = ["src/accumulators.cppm"] - implies = ["assert", "circular-buffer", "config", "core", "numeric", "type-traits", "utility"] + implies = ["array", "assert", "circular-buffer", "concept-check", "config", "core", "iterator", "mp11", "numeric", "type-traits", "utility"] [features.asio] sources = ["src/asio.cppm"] - implies = ["align", "assert", "date-time", "system"] + implies = ["align", "assert", "date-time", "smart-ptr", "system", "type-traits"] [features.beast] sources = ["src/beast.cppm"] - implies = ["asio", "assert", "config", "core", "endian", "logic", "optional", "smart-ptr", "static-string", "system", "throw-exception", "type-index", "winapi"] + implies = ["asio", "assert", "config", "container-hash", "core", "endian", "intrusive", "logic", "mp11", "optional", "smart-ptr", "static-string", "system", "throw-exception", "type-index", "utility", "winapi"] [features.geometry] sources = ["src/geometry.cppm"] - implies = ["any", "array", "assert", "concept-check", "config", "container", "core", "graph", "integer", "iterator", "math", "mp11", "polygon", "qvm", "range", "rational", "thread", "throw-exception", "tuple", "type-traits", "unordered", "utility", "variant", "variant2"] + implies = ["any", "array", "assert", "concept-check", "config", "container", "core", "graph", "integer", "iterator", "math", "mp11", "polygon", "qvm", "range", "rational", "smart-ptr", "thread", "throw-exception", "tokenizer", "tuple", "type-traits", "unordered", "utility", "variant", "variant2"] [features.gil] sources = ["src/gil.cppm"] - implies = ["assert", "config", "core", "integer", "iterator", "mp11", "variant2"] + implies = ["assert", "concept-check", "config", "container-hash", "core", "integer", "iterator", "mp11", "type-traits", "variant2"] [features.hana] sources = ["src/hana.cppm"] implies = ["core", "tuple", "type-traits"] @@ -637,13 +636,13 @@ all-modules = { implies = ["optional", "variant", "variant2", "any", "core", "co implies = ["assert", "config", "container", "intrusive", "move", "winapi"] [features.mqtt5] sources = ["src/mqtt5.cppm"] - implies = ["asio", "assert", "beast", "container", "core", "random", "smart-ptr", "static-string", "system"] + implies = ["asio", "assert", "beast", "container", "core", "random", "smart-ptr", "static-string", "system", "type-traits", "utility"] [features.multiprecision] sources = ["src/multiprecision.cppm"] - implies = ["assert", "math", "random"] + implies = ["assert", "io", "math", "random"] [features.numeric] sources = ["src/numeric.cppm"] - implies = ["assert", "config", "core", "iterator", "lexical-cast", "math", "multi-array", "range", "serialization", "type-traits", "units", "utility"] + implies = ["assert", "concept-check", "config", "core", "iterator", "lexical-cast", "math", "multi-array", "range", "serialization", "type-traits", "units", "utility"] [features.polygon] sources = ["src/polygon.cppm"] implies = ["config"] diff --git a/patches/README.md b/patches/README.md index 4fb4c54d7..16976d978 100644 --- a/patches/README.md +++ b/patches/README.md @@ -1,29 +1,32 @@ # patches -Replayable adaptations. `tools/reapply_hand_edits.py` applies them in two -rounds — vendored upstream first, regenerated module sources second — and is -idempotent in both directions (an applied patch is skipped by the reverse check). +Adaptations of the vendored Boost tree. `tools/apply_patches.py` applies every +`*.patch` here to `upstream/boost/` after `tools/import_boost.py` restored the +pinned release, and is idempotent in both directions (an applied patch is +skipped by the reverse check; `patch -p1` is the fallback without Git). -| Set | Applies to | Reason | -|---|---|---| -| `*.patch` listed in `VENDORED_PATCHES` | `upstream/boost/**` | Minimal upstream adaptations: TU-local objects promoted to `inline constexpr` so a CMI and a consumer GMF cannot emit the same mangled symbol twice; internal-linkage/static helpers given external linkage for the export surface; platform guards for the vendored 1.92.0 tree; the `system` split that moves function-local statics out of headers. | -| `*.patch` listed in `SRC_PATCHES` | `src/**`, `generated/exports/**` | Module-side adaptations the generator cannot know: extra GMF includes, platform guards on exported entities, export-ownership moves, explanatory comments kept in the generated lists. | -| `final/` | the same paths | The hand-maintained final form of files whose content intentionally diverges from generator output. Stored as whole files, not diffs, so replay needs no Git history. | +The patches are minimal upstream adaptations: TU-local objects promoted to +`inline constexpr` so a CMI and a consumer GMF cannot emit the same mangled +symbol twice; internal-linkage/static helpers given external linkage for the +export surface; platform guards for the vendored 1.92.0 tree; the `system` +split that moves function-local statics out of headers. -`numeric.patch` is the one functional adaptation with a release-mode edge: Boost.uBLAS -tensor spells `BOOST_UBLAS_INLINE` before the `template<...>` head in a few member -functions. `BOOST_UBLAS_INLINE` is empty in a checked build but `inline` under -`NDEBUG`, and `inline template<...>` is ill-formed (gcc rejects it, clang misreads it -as an explicit instantiation), so a release build of the numeric module needs the -swap. The exported `same_impl_ex` follows the same header condition through an -`.inc` guard in `tools/reapply_hand_edits.py`, so the release module neither exports -a name the header hides nor fails on it. +Only the vendored tree is patched. The module layer is not: the export lists +under `generated/exports/` are written by `tools/gen_exports.py` alone — every +guard, drop or verbatim line it needs is a rule with a written reason in +`tools/export_policy.toml` — and `src/*.cppm` are hand-maintained facades that +`gen_exports.py --check` verifies against the generated data. Nothing is +replayed over generator output. -Every upstream patch is minimal and is reviewed against the 1.92.0 tag it was -written for; `upstream/boost/SOURCE.md` records the archive and checksum the tree -comes from. A patch whose anchor is missing fails the replay unless it is listed -as tolerant in `tools/reapply_hand_edits.py` with a written reason (`json`, -`core`, `io` — transitional no-ops superseded by stored final forms). +`numeric.patch` is the one functional adaptation with a release-mode edge: +Boost.uBLAS tensor spells `BOOST_UBLAS_INLINE` before the `template<...>` head +in a few member functions. `BOOST_UBLAS_INLINE` is empty in a checked build but +`inline` under `NDEBUG`, and `inline template<...>` is ill-formed (gcc rejects +it, clang misreads it as an explicit instantiation), so a release build of the +numeric module needs the swap. The exported `same_impl_ex` follows the same +header condition through the `numeric` guard in `tools/export_policy.toml`, so +the release module neither exports a name the header hides nor fails on it. -Replacing a `final/` entry is an interface change: apply the edit, then copy the -edited file over the stored form so the replay keeps reproducing it. +Every patch is reviewed against the 1.92.0 tag it was written for; +`upstream/boost/SOURCE.md` records the archive and checksum the tree comes +from. A patch that neither applies nor is already applied fails the replay. diff --git a/patches/align.patch b/patches/align.patch deleted file mode 100644 index 4bdf7c153..000000000 --- a/patches/align.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff --git a/generated/exports/align.inc b/generated/exports/align.inc -index 4dd7a9b..e63d583 100644 ---- a/generated/exports/align.inc -+++ b/generated/exports/align.inc -@@ -26,7 +26,6 @@ export namespace boost { namespace alignment { namespace detail { - using boost::alignment::detail::not_pointer; - using boost::alignment::detail::throw_exception; - using std::add_lvalue_reference; -- using std::alignment_of; - using std::false_type; - using std::integral_constant; - using std::remove_all_extents; diff --git a/patches/atomic.patch b/patches/atomic.patch deleted file mode 100644 index ecbd2ea3c..000000000 --- a/patches/atomic.patch +++ /dev/null @@ -1,80 +0,0 @@ -diff --git a/generated/exports/atomic.inc b/generated/exports/atomic.inc -index 27f56c2..362e28c 100644 ---- a/generated/exports/atomic.inc -+++ b/generated/exports/atomic.inc -@@ -62,12 +62,20 @@ export namespace boost { - using boost::ipc_atomic; - using boost::ipc_atomic_flag; - using boost::ipc_atomic_ref; -+#if defined(BOOST_HAS_INT128) -+ // M11 platform guard: atomic/detail/type_traits/is_integral.hpp (and -+ // is_signed) pull the boost:: trait only under BOOST_HAS_INT128 (libstdc++ -+ // __int128 workaround); the MSVC ABI takes the std:: trait instead. - using boost::is_integral; - using boost::is_signed; -+#endif - using boost::make_atomic_ref; - using boost::make_ipc_atomic_ref; -+#if defined(BOOST_HAS_INT128) -+ // M11 platform guard: atomic/detail/type_traits/make_signed.hpp — as above. - using boost::make_signed; - using boost::make_unsigned; -+#endif - using boost::memory_order; - using boost::memory_order_acq_rel; - using boost::memory_order_acquire; -@@ -162,14 +170,26 @@ export namespace boost { namespace atomics { namespace detail { - using boost::atomics::detail::classify; - using boost::atomics::detail::classify_pointer; - using boost::atomics::detail::clear_tail_padding_bits; -+#if defined(__GNUC__) -+ // M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw flavor). - using boost::atomics::detail::convert_memory_order_to_gcc; -+#endif - using boost::atomics::detail::core_arch_operations; -+#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) -+ // M11 platform guard: gcc_x86 backend of boost/atomic (platform.hpp); x86 only. - using boost::atomics::detail::core_arch_operations_gcc_x86; -+#endif -+#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) -+ // M11 platform guard: gcc_x86 backend of boost/atomic (platform.hpp); x86 only. - using boost::atomics::detail::core_arch_operations_gcc_x86_base; -+#endif - using boost::atomics::detail::core_operations; - using boost::atomics::detail::core_operations_emulated; - using boost::atomics::detail::core_operations_emulated_base; -+#if defined(__GNUC__) -+ // M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw flavor). - using boost::atomics::detail::core_operations_gcc_atomic; -+#endif - using boost::atomics::detail::deduce_failure_order; - using boost::atomics::detail::extra_fp_negate_generic; - using boost::atomics::detail::extra_fp_operations; -@@ -179,9 +199,15 @@ export namespace boost { namespace atomics { namespace detail { - using boost::atomics::detail::extra_operations_emulated; - using boost::atomics::detail::extra_operations_generic; - using boost::atomics::detail::fence_arch_operations; -+#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) -+ // M11 platform guard: gcc_x86 backend of boost/atomic (platform.hpp); x86 only. - using boost::atomics::detail::fence_arch_operations_gcc_x86; -+#endif - using boost::atomics::detail::fence_operations; -+#if defined(__GNUC__) -+ // M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw flavor). - using boost::atomics::detail::fence_operations_gcc_atomic; -+#endif - using boost::atomics::detail::fp_operations; - using boost::atomics::detail::fp_operations_emulated; - using boost::atomics::detail::fp_operations_generic; -@@ -198,7 +224,11 @@ export namespace boost { namespace atomics { namespace detail { - using boost::atomics::detail::wait_operations; - using boost::atomics::detail::wait_operations_emulated; - using boost::atomics::detail::wait_operations_generic; -+#if defined(BOOST_WINDOWS) -+ // M11 platform guard: wait_ops_windows.hpp (wait backend = windows, -+ // platform.hpp BOOST_WINDOWS); POSIX uses futex/darwin_ulock/generic. - using boost::atomics::detail::wait_operations_windows; -+#endif - using boost::atomics::detail::wait_some; - using boost::atomics::detail::zero_extend; - using boost::atomics::detail::zero_extend_impl; diff --git a/patches/bloom.patch b/patches/bloom.patch deleted file mode 100644 index 9af0cfd9f..000000000 --- a/patches/bloom.patch +++ /dev/null @@ -1,16 +0,0 @@ -diff --git a/generated/exports/bloom.inc b/generated/exports/bloom.inc -index e80c888..4c3201e 100644 ---- a/generated/exports/bloom.inc -+++ b/generated/exports/bloom.inc -@@ -40,7 +40,11 @@ export namespace boost { namespace bloom { namespace detail { - using boost::bloom::detail::is_transparent; - using boost::bloom::detail::is_unsigned_integral_or_extended_unsigned_integral; - using boost::bloom::detail::is_unsigned_or_extended_unsigned; -+#if defined(BOOST_BLOOM_SSE2) -+ // M9 platform guard: m128ix2 is the SSE2 branch of fast_multiblock32 -+ // (detail/sse2.hpp, __SSE2__); absent on arm64 (NEON branch). - using boost::bloom::detail::m128ix2; -+#endif - using boost::bloom::detail::move_assign_if; - using boost::bloom::detail::multiblock_fpr_base; - using boost::bloom::detail::mulx64; diff --git a/patches/charconv.patch b/patches/charconv.patch deleted file mode 100644 index fb3b63a82..000000000 --- a/patches/charconv.patch +++ /dev/null @@ -1,28 +0,0 @@ -diff --git a/generated/exports/charconv.inc b/generated/exports/charconv.inc -index 4a120e5..fbcd79f 100644 ---- a/generated/exports/charconv.inc -+++ b/generated/exports/charconv.inc -@@ -29,7 +29,11 @@ export namespace boost { namespace charconv { namespace detail { - using boost::charconv::detail::ieee754_binary16; - using boost::charconv::detail::ieee754_binary32; - using boost::charconv::detail::ieee754_binary64; -+#if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 -+ // M11 platform guard: bit_layouts.hpp defines ieee754_binary80 only for -+ // 80-bit long double (x86-64 gcc/mingw); MSVC long double is 53-bit. - using boost::charconv::detail::ieee754_binary80; -+#endif - using boost::charconv::detail::is_int128; - using boost::charconv::detail::is_signed; - using boost::charconv::detail::is_uint128; -@@ -53,7 +57,11 @@ export namespace boost { namespace charconv { namespace detail { - using boost::charconv::detail::operator^; - using boost::charconv::detail::operator|; - using boost::charconv::detail::operator~; -+#if defined(BOOST_CHARCONV_HAS_INT128) -+ // M11 platform guard: to_chars128 exists only under BOOST_CHARCONV_HAS_INT128 -+ // (to_chars_integer_impl.hpp). - using boost::charconv::detail::to_chars128; -+#endif - using boost::charconv::detail::to_chars_128integer_impl; - using boost::charconv::detail::to_chars_int; - using boost::charconv::detail::to_chars_integer_impl; diff --git a/patches/cobalt.patch b/patches/cobalt.patch deleted file mode 100644 index 7e2309a51..000000000 --- a/patches/cobalt.patch +++ /dev/null @@ -1,25 +0,0 @@ -diff --git a/src/cobalt.cppm b/src/cobalt.cppm -index a243313..64aa3f0 100644 ---- a/src/cobalt.cppm -+++ b/src/cobalt.cppm -@@ -1,6 +1,20 @@ - // GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) - module; - #include -+// M11 platform guard (POSIX): asio reactor/hash_map details were only -+// reached through windows-flavored chains in the mingw snapshot (POSIX -+// cobalt selects the epoll reactor); include them explicitly so the -+// shared-surface `using` lines resolve. -+#include -+#include -+#include -+// fd_set_adapter / reactor_op_queue / socket_select_interrupter are -+// per-OS-selected headers with no outer platform guard; the reactor -+// headers above self-guard empty on the epoll/kqueue paths (their -+// entities are guarded _WIN32 in the .inc instead). -+#include -+#include -+#include - #include - #include - #include diff --git a/patches/config.patch b/patches/config.patch deleted file mode 100644 index 7480e66d5..000000000 --- a/patches/config.patch +++ /dev/null @@ -1,19 +0,0 @@ -diff --git a/generated/exports/config.inc b/generated/exports/config.inc -index 1afefda..aae1d6c 100644 ---- a/generated/exports/config.inc -+++ b/generated/exports/config.inc -@@ -2,8 +2,14 @@ - // lib=config boost=1.92.0 target=x86_64-w64-mingw32 entities=4 - - export namespace boost { -+#if defined(BOOST_HAS_INT128) -+ // M3 hand-guard (M9: moved to config.inc): suffix.hpp defines int128_type only where BOOST_HAS_INT128. - using boost::int128_type; -+#endif - using boost::long_long_type; -+#if defined(BOOST_HAS_INT128) -+ // M3 hand-guard (M9: moved to config.inc): suffix.hpp defines uint128_type only where BOOST_HAS_INT128. - using boost::uint128_type; -+#endif - using boost::ulong_long_type; - } diff --git a/patches/container.patch b/patches/container.patch deleted file mode 100644 index fdce22e98..000000000 --- a/patches/container.patch +++ /dev/null @@ -1,31 +0,0 @@ -diff --git a/generated/exports/container.inc b/generated/exports/container.inc ---- a/generated/exports/container.inc -+++ b/generated/exports/container.inc -@@ -826,7 +826,11 @@ - using boost::container::dtl::version; - using boost::container::dtl::version_type; - using boost::container::dtl::void_t; -+#if defined(_WIN32) -+ // M11 platform guard: win_critical_section is the non-pthread branch -+ // of container/detail/thread_mutex.hpp; POSIX uses pthread_mutex. - using boost::container::dtl::win_critical_section; -+#endif - }}} - - export namespace boost { namespace container { namespace dtl { namespace adl_range { -@@ -988,11 +992,15 @@ - using boost::container::stable_vector_detail::node_base; - }}} - -+#if defined(_WIN32) - export namespace boost { namespace container_winapi { -+ // M11 platform guard: container_winapi DWORD_/BOOL_/SleepEx are -+ // declared only in the _WIN32 branch of container/detail/mutex.hpp. - using ::SleepEx; - using boost::container_winapi::BOOL_; - using boost::container_winapi::DWORD_; - }} -+#endif - - export namespace boost { namespace interprocess { - using boost::interprocess::offset_ptr; diff --git a/patches/core.patch b/patches/core.patch deleted file mode 100644 index 6472f5d9e..000000000 --- a/patches/core.patch +++ /dev/null @@ -1,31 +0,0 @@ -diff --git a/generated/exports/core.inc b/generated/exports/core.inc -index e8e2d79..8f30e11 100644 ---- a/generated/exports/core.inc -+++ b/generated/exports/core.inc -@@ -160,7 +160,10 @@ export namespace boost { namespace core { namespace detail { - using boost::core::detail::bit_ceil_impl; - using boost::core::detail::byteswap_impl; - using boost::core::detail::class_template_name; -+#if defined(__GNUC__) -+ // M3 hand-guard: boost/core/cmath.hpp defines copysign_impl only on gcc-like compilers. - using boost::core::detail::copysign_impl; -+#endif - using boost::core::detail::countl_impl; - using boost::core::detail::countr_impl; - using boost::core::detail::fix_typeid_name; -@@ -174,8 +177,15 @@ export namespace boost { namespace core { namespace detail { - using boost::core::detail::popcount_impl; - using boost::core::detail::sequence_template_name; - using boost::core::detail::set_template_name; -+#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -+ // M6 platform guard: sp_thread_sleep/yield live in boost::core::detail only on Windows; -+ // on POSIX (nanosleep/sched_yield branch of the header) they are declared in boost::core. - using boost::core::detail::sp_thread_sleep; - using boost::core::detail::sp_thread_yield; -+#else -+ using boost::core::sp_thread_sleep; -+ using boost::core::sp_thread_yield; -+#endif - using boost::core::detail::tn_add_each; - using boost::core::detail::tn_add_each_impl; - using boost::core::detail::tn_holder; diff --git a/patches/decimal.patch b/patches/decimal.patch deleted file mode 100644 index 766f7d5fc..000000000 --- a/patches/decimal.patch +++ /dev/null @@ -1,42 +0,0 @@ -diff --git a/generated/exports/decimal.inc b/generated/exports/decimal.inc -index 217dbd9..5d69be3 100644 ---- a/generated/exports/decimal.inc -+++ b/generated/exports/decimal.inc -@@ -271,9 +271,13 @@ export namespace boost { namespace decimal { namespace detail { - using boost::decimal::detail::beta_impl; - using boost::decimal::detail::bias; - using boost::decimal::detail::bias_v; - using boost::decimal::detail::buffer_length_exp; -+#if defined(BOOST_DECIMAL_HAS_INT128) -+ // M9 platform guard: config.hpp defines the __int128 typedefs only where -+ // BOOST_DECIMAL_HAS_INT128 (off under the MSVC ABI). - using boost::decimal::detail::builtin_int128_t; - using boost::decimal::detail::builtin_uint128_t; -+#endif - using boost::decimal::detail::cbrt_impl; - using boost::decimal::detail::check_non_finite; - using boost::decimal::detail::coefficient_rounding; -@@ -409,7 +413,11 @@ export namespace boost { namespace decimal { namespace detail { - using boost::decimal::detail::ieee754_binary128; - using boost::decimal::detail::ieee754_binary32; - using boost::decimal::detail::ieee754_binary64; -+#if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 -+ // M9 platform guard: bit_layouts.hpp defines ieee754_binary80 only for 80-bit -+ // long double (x86-64 gcc/mingw); MSVC long double is 53-bit. - using boost::decimal::detail::ieee754_binary80; -+#endif - using boost::decimal::detail::int_round_impl; - using boost::decimal::detail::is_decimal_floating_point; - using boost::decimal::detail::is_decimal_floating_point_components; -@@ -653,7 +661,11 @@ export namespace boost { namespace decimal { namespace detail { namespace impl { - using boost::decimal::detail::impl::basic_lt_impl; - using boost::decimal::detail::impl::basic_or_impl; - using boost::decimal::detail::impl::bias_v; -+#if defined(BOOST_DECIMAL_HAS_INT128) -+ // M9 platform guard: power_tables.hpp defines builtin_128_pow10 only under -+ // BOOST_DECIMAL_HAS_INT128. - using boost::decimal::detail::impl::builtin_128_pow10; -+#endif - using boost::decimal::detail::impl::combination_field_width_v; - using boost::decimal::detail::impl::countl_impl; - using boost::decimal::detail::impl::decimal_components; diff --git a/patches/dll.patch b/patches/dll.patch deleted file mode 100644 index eddfbf646..000000000 --- a/patches/dll.patch +++ /dev/null @@ -1,41 +0,0 @@ -diff --git a/generated/exports/dll.inc b/generated/exports/dll.inc -index dd4dca0..ba276d8 100644 ---- a/generated/exports/dll.inc -+++ b/generated/exports/dll.inc -@@ -55,7 +55,11 @@ export namespace boost { namespace dll { namespace detail { - using boost::dll::detail::get_mem_fn_type; - using boost::dll::detail::import_type; - using boost::dll::detail::integer_t; -+#if defined(_WIN32) -+ // M9 platform guard: last_error_code is in detail/windows/ -+ // path_from_handle.hpp (no POSIX counterpart). - using boost::dll::detail::last_error_code; -+#endif - using boost::dll::detail::library_function; - using boost::dll::detail::load_command_; - using boost::dll::detail::load_command_types; -@@ -94,6 +98,9 @@ export namespace boost { namespace dll { namespace detail { - }}} - - export namespace boost { namespace dll { namespace detail { namespace parser { -+#if !defined(_MSC_VER) -+ // M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) -+ // is selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). - using boost::dll::detail::parser::arg_list; - using boost::dll::detail::parser::const_rule; - using boost::dll::detail::parser::const_rule_impl; -@@ -106,10 +113,14 @@ export namespace boost { namespace dll { namespace detail { namespace parser { - using boost::dll::detail::parser::type_name; - using boost::dll::detail::parser::volatile_rule; - using boost::dll::detail::parser::volatile_rule_impl; -+#endif - }}}} - - export namespace boost { namespace dll { namespace experimental { -+#if !defined(_MSC_VER) -+ // M9 platform guard: demangle_symbol comes from demangling/itanium.hpp. - using boost::dll::experimental::demangle_symbol; -+#endif - using boost::dll::experimental::get; - using boost::dll::experimental::import_class; - using boost::dll::experimental::import_mangled; diff --git a/patches/final/generated/exports/algorithm.deps b/patches/final/generated/exports/algorithm.deps deleted file mode 100644 index 4204b5fc6..000000000 --- a/patches/final/generated/exports/algorithm.deps +++ /dev/null @@ -1,5 +0,0 @@ -mcpplibs.mwrap.boost.core -mcpplibs.mwrap.boost.iterator -mcpplibs.mwrap.boost.range -mcpplibs.mwrap.boost.tuple -mcpplibs.mwrap.boost.type_traits diff --git a/patches/final/generated/exports/algorithm.inc b/patches/final/generated/exports/algorithm.inc deleted file mode 100644 index 74afb3364..000000000 --- a/patches/final/generated/exports/algorithm.inc +++ /dev/null @@ -1,639 +0,0 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=algorithm boost=1.92.0 target=x86_64-w64-mingw32 entities=630 - -export namespace boost { - using boost::_arg_eq; - using boost::all; - using boost::arg; - using boost::atomic_compare_exchange; - using boost::atomic_compare_exchange_explicit; - using boost::atomic_exchange; - using boost::atomic_exchange_explicit; - using boost::atomic_is_lock_free; - using boost::atomic_load; - using boost::atomic_load_explicit; - using boost::atomic_store; - using boost::atomic_store_explicit; - using boost::bad_weak_ptr; - using boost::bind; - using boost::const_formatter; - using boost::const_pointer_cast; - using boost::contains; - using boost::dissect_formatter; - using boost::dynamic_pointer_cast; - using boost::empty_formatter; - using boost::enable_shared_from_raw; - using boost::enable_shared_from_this; - using boost::ends_with; - using boost::equals; - using boost::erase_all; - using boost::erase_all_copy; - using boost::erase_first; - using boost::erase_first_copy; - using boost::erase_head; - using boost::erase_head_copy; - using boost::erase_last; - using boost::erase_last_copy; - using boost::erase_nth; - using boost::erase_nth_copy; - using boost::erase_range; - using boost::erase_range_copy; - using boost::erase_tail; - using boost::erase_tail_copy; - using boost::error_info; - using boost::error_info_name; - using boost::find_all; - using boost::find_first; - using boost::find_format; - using boost::find_format_all; - using boost::find_format_all_copy; - using boost::find_format_copy; - using boost::find_head; - using boost::find_iterator; - using boost::find_last; - using boost::find_nth; - using boost::find_tail; - using boost::find_token; - using boost::first_finder; - using boost::first_max_element; - using boost::first_min_element; - using boost::first_min_first_max_element; - using boost::first_min_last_max_element; - using boost::get_deleter; - using boost::get_pointer; - using boost::has_to_string; - using boost::hash_value; - using boost::head_finder; - using boost::icontains; - using boost::identity_formatter; - using boost::iends_with; - using boost::iequals; - using boost::ierase_all; - using boost::ierase_all_copy; - using boost::ierase_first; - using boost::ierase_first_copy; - using boost::ierase_last; - using boost::ierase_last_copy; - using boost::ierase_nth; - using boost::ierase_nth_copy; - using boost::ifind_all; - using boost::ifind_first; - using boost::ifind_last; - using boost::ifind_nth; - using boost::ilexicographical_compare; - using boost::ireplace_all; - using boost::ireplace_all_copy; - using boost::ireplace_first; - using boost::ireplace_first_copy; - using boost::ireplace_last; - using boost::ireplace_last_copy; - using boost::ireplace_nth; - using boost::ireplace_nth_copy; - using boost::is_alnum; - using boost::is_alpha; - using boost::is_any_of; - using boost::is_bind_expression; - using boost::is_blank; - using boost::is_classified; - using boost::is_cntrl; - using boost::is_digit; - using boost::is_equal; - using boost::is_from_range; - using boost::is_graph; - using boost::is_iequal; - using boost::is_iless; - using boost::is_less; - using boost::is_lower; - using boost::is_not_greater; - using boost::is_not_igreater; - using boost::is_output_streamable; - using boost::is_placeholder; - using boost::is_print; - using boost::is_punct; - using boost::is_space; - using boost::is_upper; - using boost::is_xdigit; - using boost::istarts_with; - using boost::iter_find; - using boost::iter_split; - using boost::join; - using boost::join_if; - using boost::last_finder; - using boost::last_max_element; - using boost::last_min_element; - using boost::last_min_first_max_element; - using boost::last_min_last_max_element; - using boost::make_find_iterator; - using boost::make_split_iterator; - using boost::minmax; - using boost::minmax_element; - using boost::nth_finder; - using boost::operator!=; - using boost::operator<; - using boost::operator<<; - using boost::operator==; - using boost::range_finder; - using boost::reinterpret_pointer_cast; - using boost::replace_all; - using boost::replace_all_copy; - using boost::replace_first; - using boost::replace_first_copy; - using boost::replace_head; - using boost::replace_head_copy; - using boost::replace_last; - using boost::replace_last_copy; - using boost::replace_nth; - using boost::replace_nth_copy; - using boost::replace_range; - using boost::replace_range_copy; - using boost::replace_tail; - using boost::replace_tail_copy; - using boost::shared_ptr; - using boost::split; - using boost::split_iterator; - using boost::starts_with; - using boost::static_pointer_cast; - using boost::swap; - using boost::tag_type_name; - using boost::tail_finder; - using boost::to_lower; - using boost::to_lower_copy; - using boost::to_string; - using boost::to_string_stub; - using boost::to_upper; - using boost::to_upper_copy; - using boost::token_compress_off; - using boost::token_compress_on; - using boost::token_finder; - using boost::trim; - using boost::trim_all; - using boost::trim_all_copy; - using boost::trim_all_copy_if; - using boost::trim_all_if; - using boost::trim_copy; - using boost::trim_copy_if; - using boost::trim_fill; - using boost::trim_fill_copy; - using boost::trim_fill_copy_if; - using boost::trim_fill_if; - using boost::trim_if; - using boost::trim_left; - using boost::trim_left_copy; - using boost::trim_left_copy_if; - using boost::trim_left_if; - using boost::trim_right; - using boost::trim_right_copy; - using boost::trim_right_copy_if; - using boost::trim_right_if; - using boost::type; - using boost::type_name; - using boost::visit_each; - using boost::weak_ptr; -} - -export namespace boost { namespace _bi { - using boost::_bi::accept_lambda; - using boost::_bi::add_cref; - using boost::_bi::add_value; - using boost::_bi::add_value_2; - using boost::_bi::dm_result; - using boost::_bi::equal; - using boost::_bi::equal_lambda; - using boost::_bi::function_equal; - using boost::_bi::greater; - using boost::_bi::greater_equal; - using boost::_bi::index_sequence; - using boost::_bi::index_sequence_for; - using boost::_bi::integer_sequence; - using boost::_bi::isref; - using boost::_bi::less; - using boost::_bi::less_equal; - using boost::_bi::list; - using boost::_bi::list_av; - using boost::_bi::logical_and; - using boost::_bi::logical_not; - using boost::_bi::logical_or; - using boost::_bi::make_index_sequence; - using boost::_bi::make_integer_sequence; - using boost::_bi::not_equal; - using boost::_bi::operator!; - using boost::_bi::operator!=; - using boost::_bi::operator&&; - using boost::_bi::operator<; - using boost::_bi::operator<=; - using boost::_bi::operator==; - using boost::_bi::operator>; - using boost::_bi::operator>=; - using boost::_bi::operator||; - using boost::_bi::ref_compare; - using boost::_bi::result_traits; - using boost::_bi::rrlist; - using boost::_bi::tuple_for_each; - using boost::_bi::tuple_for_each_impl; - using boost::_bi::type; - using boost::_bi::unspecified; - using boost::_bi::unwrapper; - using boost::_bi::value; - using boost::_bi::visit_each; -}} - -export namespace boost { namespace algorithm { - using boost::algorithm::FinderConcept; - using boost::algorithm::FormatterConcept; - using boost::algorithm::all; - using boost::algorithm::all_of; - using boost::algorithm::all_of_equal; - using boost::algorithm::any_of; - using boost::algorithm::any_of_equal; - using boost::algorithm::apply_permutation; - using boost::algorithm::apply_reverse_permutation; - using boost::algorithm::bad_char; - using boost::algorithm::bad_char_; - using boost::algorithm::boyer_moore; - using boost::algorithm::boyer_moore_horspool; - using boost::algorithm::boyer_moore_horspool_search; - using boost::algorithm::boyer_moore_search; - using boost::algorithm::clamp; - using boost::algorithm::clamp_range; - using boost::algorithm::const_formatter; - using boost::algorithm::contains; - using boost::algorithm::copy_if; - using boost::algorithm::copy_if_until; - using boost::algorithm::copy_if_while; - using boost::algorithm::copy_n; - using boost::algorithm::copy_until; - using boost::algorithm::copy_while; - using boost::algorithm::dissect_formatter; - using boost::algorithm::empty_formatter; - using boost::algorithm::ends_with; - using boost::algorithm::equal; - using boost::algorithm::equals; - using boost::algorithm::erase_all; - using boost::algorithm::erase_all_copy; - using boost::algorithm::erase_first; - using boost::algorithm::erase_first_copy; - using boost::algorithm::erase_head; - using boost::algorithm::erase_head_copy; - using boost::algorithm::erase_last; - using boost::algorithm::erase_last_copy; - using boost::algorithm::erase_nth; - using boost::algorithm::erase_nth_copy; - using boost::algorithm::erase_range; - using boost::algorithm::erase_range_copy; - using boost::algorithm::erase_tail; - using boost::algorithm::erase_tail_copy; - using boost::algorithm::exclusive_scan; - using boost::algorithm::find; - using boost::algorithm::find_all; - using boost::algorithm::find_backward; - using boost::algorithm::find_first; - using boost::algorithm::find_format; - using boost::algorithm::find_format_all; - using boost::algorithm::find_format_all_copy; - using boost::algorithm::find_format_copy; - using boost::algorithm::find_head; - using boost::algorithm::find_if_backward; - using boost::algorithm::find_if_not; - using boost::algorithm::find_if_not_backward; - using boost::algorithm::find_iterator; - using boost::algorithm::find_last; - using boost::algorithm::find_not; - using boost::algorithm::find_not_backward; - using boost::algorithm::find_nth; - using boost::algorithm::find_tail; - using boost::algorithm::find_token; - using boost::algorithm::first_finder; - using boost::algorithm::for_each_n; - using boost::algorithm::gather; - using boost::algorithm::has_const_time_erase; - using boost::algorithm::has_const_time_insert; - using boost::algorithm::has_native_replace; - using boost::algorithm::has_stable_iterators; - using boost::algorithm::head_finder; - using boost::algorithm::hex; - using boost::algorithm::hex_decode_error; - using boost::algorithm::hex_lower; - using boost::algorithm::icontains; - using boost::algorithm::identity_formatter; - using boost::algorithm::identity_operation; - using boost::algorithm::iends_with; - using boost::algorithm::iequals; - using boost::algorithm::ierase_all; - using boost::algorithm::ierase_all_copy; - using boost::algorithm::ierase_first; - using boost::algorithm::ierase_first_copy; - using boost::algorithm::ierase_last; - using boost::algorithm::ierase_last_copy; - using boost::algorithm::ierase_nth; - using boost::algorithm::ierase_nth_copy; - using boost::algorithm::ifind_all; - using boost::algorithm::ifind_first; - using boost::algorithm::ifind_last; - using boost::algorithm::ifind_nth; - using boost::algorithm::ilexicographical_compare; - using boost::algorithm::inclusive_scan; - using boost::algorithm::iota; - using boost::algorithm::iota_n; - using boost::algorithm::ireplace_all; - using boost::algorithm::ireplace_all_copy; - using boost::algorithm::ireplace_first; - using boost::algorithm::ireplace_first_copy; - using boost::algorithm::ireplace_last; - using boost::algorithm::ireplace_last_copy; - using boost::algorithm::ireplace_nth; - using boost::algorithm::ireplace_nth_copy; - using boost::algorithm::is_alnum; - using boost::algorithm::is_alpha; - using boost::algorithm::is_any_of; - using boost::algorithm::is_blank; - using boost::algorithm::is_clamped; - using boost::algorithm::is_classified; - using boost::algorithm::is_cntrl; - using boost::algorithm::is_decreasing; - using boost::algorithm::is_digit; - using boost::algorithm::is_equal; - using boost::algorithm::is_from_range; - using boost::algorithm::is_graph; - using boost::algorithm::is_iequal; - using boost::algorithm::is_iless; - using boost::algorithm::is_increasing; - using boost::algorithm::is_less; - using boost::algorithm::is_lower; - using boost::algorithm::is_not_greater; - using boost::algorithm::is_not_igreater; - using boost::algorithm::is_palindrome; - using boost::algorithm::is_partitioned; - using boost::algorithm::is_partitioned_until; - using boost::algorithm::is_permutation; - using boost::algorithm::is_print; - using boost::algorithm::is_punct; - using boost::algorithm::is_sorted; - using boost::algorithm::is_sorted_until; - using boost::algorithm::is_space; - using boost::algorithm::is_strictly_decreasing; - using boost::algorithm::is_strictly_increasing; - using boost::algorithm::is_upper; - using boost::algorithm::is_xdigit; - using boost::algorithm::istarts_with; - using boost::algorithm::iter_find; - using boost::algorithm::iter_split; - using boost::algorithm::join; - using boost::algorithm::join_if; - using boost::algorithm::knuth_morris_pratt; - using boost::algorithm::knuth_morris_pratt_search; - using boost::algorithm::last_finder; - using boost::algorithm::lexicographical_compare; - using boost::algorithm::make_boyer_moore; - using boost::algorithm::make_boyer_moore_horspool; - using boost::algorithm::make_find_iterator; - using boost::algorithm::make_knuth_morris_pratt; - using boost::algorithm::make_split_iterator; - using boost::algorithm::mismatch; - using boost::algorithm::no_type; - using boost::algorithm::non_hex_input; - using boost::algorithm::none_of; - using boost::algorithm::none_of_equal; - using boost::algorithm::not_enough_input; - using boost::algorithm::nth_finder; - using boost::algorithm::one_of; - using boost::algorithm::one_of_equal; - using boost::algorithm::operator!; - using boost::algorithm::operator&&; - using boost::algorithm::operator||; - using boost::algorithm::partition_copy; - using boost::algorithm::partition_point; - using boost::algorithm::partition_subrange; - using boost::algorithm::power; - using boost::algorithm::predicate_facade; - using boost::algorithm::range_finder; - using boost::algorithm::reduce; - using boost::algorithm::replace_all; - using boost::algorithm::replace_all_copy; - using boost::algorithm::replace_first; - using boost::algorithm::replace_first_copy; - using boost::algorithm::replace_head; - using boost::algorithm::replace_head_copy; - using boost::algorithm::replace_last; - using boost::algorithm::replace_last_copy; - using boost::algorithm::replace_nth; - using boost::algorithm::replace_nth_copy; - using boost::algorithm::replace_range; - using boost::algorithm::replace_range_copy; - using boost::algorithm::replace_tail; - using boost::algorithm::replace_tail_copy; - using boost::algorithm::size_descriptor; - using boost::algorithm::sort_subrange; - using boost::algorithm::split; - using boost::algorithm::split_iterator; - using boost::algorithm::starts_with; - using boost::algorithm::tail_finder; - using boost::algorithm::to_lower; - using boost::algorithm::to_lower_copy; - using boost::algorithm::to_upper; - using boost::algorithm::to_upper_copy; - using boost::algorithm::token_compress_mode_type; - using boost::algorithm::token_compress_mode_type::token_compress_off; - using boost::algorithm::token_compress_mode_type::token_compress_on; - using boost::algorithm::token_finder; - using boost::algorithm::transform_exclusive_scan; - using boost::algorithm::transform_inclusive_scan; - using boost::algorithm::trim; - using boost::algorithm::trim_all; - using boost::algorithm::trim_all_copy; - using boost::algorithm::trim_all_copy_if; - using boost::algorithm::trim_all_if; - using boost::algorithm::trim_copy; - using boost::algorithm::trim_copy_if; - using boost::algorithm::trim_fill; - using boost::algorithm::trim_fill_copy; - using boost::algorithm::trim_fill_copy_if; - using boost::algorithm::trim_fill_if; - using boost::algorithm::trim_if; - using boost::algorithm::trim_left; - using boost::algorithm::trim_left_copy; - using boost::algorithm::trim_left_copy_if; - using boost::algorithm::trim_left_if; - using boost::algorithm::trim_right; - using boost::algorithm::trim_right_copy; - using boost::algorithm::trim_right_copy_if; - using boost::algorithm::trim_right_if; - using boost::algorithm::unhex; - using boost::algorithm::yes_type; -}} - -export namespace boost { namespace algorithm { namespace detail { - using boost::algorithm::detail::BM_traits; - using boost::algorithm::detail::PrintTable; - using boost::algorithm::detail::bounded_copy; - using boost::algorithm::detail::check_find_result; - using boost::algorithm::detail::const_formatF; - using boost::algorithm::detail::copy_iterator_rangeF; - using boost::algorithm::detail::copy_to_storage; - using boost::algorithm::detail::decode_one; - using boost::algorithm::detail::dissect_formatF; - using boost::algorithm::detail::empty_container; - using boost::algorithm::detail::empty_formatF; - using boost::algorithm::detail::encode_one; - using boost::algorithm::detail::ends_with_iter_select; - using boost::algorithm::detail::eq; - using boost::algorithm::detail::equal; - using boost::algorithm::detail::erase; - using boost::algorithm::detail::find_format_all_copy_impl; - using boost::algorithm::detail::find_format_all_copy_impl2; - using boost::algorithm::detail::find_format_all_impl; - using boost::algorithm::detail::find_format_all_impl2; - using boost::algorithm::detail::find_format_copy_impl; - using boost::algorithm::detail::find_format_copy_impl2; - using boost::algorithm::detail::find_format_impl; - using boost::algorithm::detail::find_format_impl2; - using boost::algorithm::detail::find_format_store; - using boost::algorithm::detail::find_head_impl; - using boost::algorithm::detail::find_iterator_base; - using boost::algorithm::detail::find_tail_impl; - using boost::algorithm::detail::first_finderF; - using boost::algorithm::detail::head_finderF; - using boost::algorithm::detail::hex_char_to_int; - using boost::algorithm::detail::hex_iterator_traits; - using boost::algorithm::detail::identity_formatF; - using boost::algorithm::detail::insert; - using boost::algorithm::detail::is_any_ofF; - using boost::algorithm::detail::is_classifiedF; - using boost::algorithm::detail::is_from_rangeF; - using boost::algorithm::detail::is_permutation_inner; - using boost::algorithm::detail::is_permutation_tag; - using boost::algorithm::detail::iter_end; - using boost::algorithm::detail::last_finderF; - using boost::algorithm::detail::move_from_storage; - using boost::algorithm::detail::nth_finderF; - using boost::algorithm::detail::pred_andF; - using boost::algorithm::detail::pred_notF; - using boost::algorithm::detail::pred_orF; - using boost::algorithm::detail::process_segment; - using boost::algorithm::detail::process_segment_helper; - using boost::algorithm::detail::ptr_end; - using boost::algorithm::detail::range_finderF; - using boost::algorithm::detail::replace; - using boost::algorithm::detail::replace_const_time_helper; - using boost::algorithm::detail::replace_native_helper; - using boost::algorithm::detail::skip_table; - using boost::algorithm::detail::tail_finderF; - using boost::algorithm::detail::to_lowerF; - using boost::algorithm::detail::to_upperF; - using boost::algorithm::detail::token_finderF; - using boost::algorithm::detail::transform_range; - using boost::algorithm::detail::transform_range_copy; - using boost::algorithm::detail::trim_begin; - using boost::algorithm::detail::trim_end; - using boost::algorithm::detail::trim_end_iter_select; - using boost::algorithm::detail::value_predicate; -}}} - -export namespace boost { namespace detail { - using boost::detail::atomic_conditional_increment; - using boost::detail::atomic_decrement; - using boost::detail::atomic_increment; - using boost::detail::basic_first_max_element; - using boost::detail::basic_first_min_element; - using boost::detail::basic_first_min_last_max_element; - using boost::detail::basic_get_deleter; - using boost::detail::basic_get_local_deleter; - using boost::detail::basic_last_max_element; - using boost::detail::basic_last_min_element; - using boost::detail::basic_last_min_first_max_element; - using boost::detail::basic_last_min_last_max_element; - using boost::detail::basic_minmax_element; - using boost::detail::binary_pred_over_iter; - using boost::detail::esft2_deleter_wrapper; - using boost::detail::get_local_deleter; - using boost::detail::less_over_iter; - using boost::detail::local_counted_base; - using boost::detail::local_counted_impl; - using boost::detail::local_counted_impl_em; - using boost::detail::local_sp_deleter; - using boost::detail::shared_count; - using boost::detail::sp_array_access; - using boost::detail::sp_assert_convertible; - using boost::detail::sp_convert_reference; - using boost::detail::sp_convertible; - using boost::detail::sp_counted_base; - using boost::detail::sp_counted_impl_p; - using boost::detail::sp_counted_impl_pd; - using boost::detail::sp_counted_impl_pda; - using boost::detail::sp_deleter_construct; - using boost::detail::sp_dereference; - using boost::detail::sp_element; - using boost::detail::sp_empty; - using boost::detail::sp_enable_if_convertible; - using boost::detail::sp_enable_if_convertible_impl; - using boost::detail::sp_enable_shared_from_this; - using boost::detail::sp_extent; - using boost::detail::sp_hash_pointer; - using boost::detail::sp_inplace_tag; - using boost::detail::sp_internal_constructor_tag; - using boost::detail::sp_member_access; - using boost::detail::sp_nothrow_tag; - using boost::detail::sp_pointer_construct; - using boost::detail::sp_reference_wrapper; - using boost::detail::sp_typeinfo_; - using boost::detail::spinlock; - using boost::detail::spinlock_pool; - using boost::detail::weak_count; - using boost::detail::yield; -}} - -export namespace boost { namespace exception_detail { - using boost::exception_detail::check_prefix; - using boost::exception_detail::check_suffix; - using boost::exception_detail::cpp11_prefix; - using boost::exception_detail::cpp11_suffix; - using boost::exception_detail::derives_boost_exception; - using boost::exception_detail::encoder_adaptor; - using boost::exception_detail::error_info_container_impl; - using boost::exception_detail::first_arg; - using boost::exception_detail::get_pretty_tag_type_name; - using boost::exception_detail::object_hex_dump; - using boost::exception_detail::pretty_type_name; - using boost::exception_detail::set_info; - using boost::exception_detail::set_info_rv; - using boost::exception_detail::string_stub_dump; - using boost::exception_detail::to_string_dispatcher; -}} - -export namespace boost { namespace exception_detail { namespace to_string_dispatch { - using boost::exception_detail::to_string_dispatch::dispatch; -}}} - -export namespace boost { namespace exception_serialization { - using boost::exception_serialization::encoder_adl; - using boost::exception_serialization::serialize; -}} - -export namespace boost { namespace movelib { - using boost::movelib::unique_ptr; -}} - -export namespace boost { namespace n { - using boost::n::p; - using boost::n::r; -}} - -export namespace boost { namespace placeholders { - using boost::placeholders::_1; - using boost::placeholders::_2; - using boost::placeholders::_3; - using boost::placeholders::_4; - using boost::placeholders::_5; - using boost::placeholders::_6; - using boost::placeholders::_7; - using boost::placeholders::_8; - using boost::placeholders::_9; -}} - -export namespace boost { namespace to_string_detail { - using boost::to_string_detail::has_to_string_impl; - using boost::to_string_detail::is_output_streamable_impl; - using boost::to_string_detail::operator<<; - using boost::to_string_detail::partial_ordering_helper1; - using boost::to_string_detail::partial_ordering_helper2; - using boost::to_string_detail::to_string; -}} diff --git a/patches/final/generated/exports/flyweight.inc b/patches/final/generated/exports/flyweight.inc deleted file mode 100644 index 7f19975c6..000000000 --- a/patches/final/generated/exports/flyweight.inc +++ /dev/null @@ -1,105 +0,0 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT -// lib=flyweight boost=1.92.0 target=x86_64-w64-mingw32 entities=932 -// -// M9 hand-trim: the generator leaked the entire transitive surface of -// boost.container / boost.interprocess / boost.intrusive / boost.move_detail / -// boost.mpl / boost.parameter / boost.multi_index / boost.interprocess.winapi -// into flyweight.inc (932 entities). Those namespaces are internal dependencies -// whose availability is platform-dependent (the interprocess winapi block is -// Windows-only; the container option types are macro-generated and only -// declared on the include path of the mingw snapshot). Trimmed to flyweight's -// own public surface (boost::flyweight + boost::flyweights::*). Mirrors the -// algorithm.inc restore_from_git convention in reapply_hand_edits.py. - -export namespace boost { - using boost::flyweight; -} - -export namespace boost { namespace flyweights { - using boost::flyweights::assoc_container_factory; - using boost::flyweights::assoc_container_factory_class; - using boost::flyweights::concurrent_factory; - using boost::flyweights::concurrent_factory_class; - using boost::flyweights::factory; - using boost::flyweights::factory_marker; - using boost::flyweights::flyweight; - using boost::flyweights::hash_value; - using boost::flyweights::hashed_factory; - using boost::flyweights::hashed_factory_class; - using boost::flyweights::holder; - using boost::flyweights::holder_marker; - using boost::flyweights::insert_and_visit; - using boost::flyweights::intermodule_holder; - using boost::flyweights::intermodule_holder_class; - using boost::flyweights::is_factory; - using boost::flyweights::is_holder; - using boost::flyweights::is_locking; - using boost::flyweights::is_tracking; - using boost::flyweights::key_value; - using boost::flyweights::load; - using boost::flyweights::locking; - using boost::flyweights::locking_marker; - using boost::flyweights::no_key_from_value; - using boost::flyweights::no_locking; - using boost::flyweights::no_tracking; - using boost::flyweights::operator!=; - using boost::flyweights::operator<; - using boost::flyweights::operator<<; - using boost::flyweights::operator<=; - using boost::flyweights::operator==; - using boost::flyweights::operator>; - using boost::flyweights::operator>=; - using boost::flyweights::operator>>; - using boost::flyweights::refcounted; - using boost::flyweights::save; - using boost::flyweights::serialize; - using boost::flyweights::set_factory; - using boost::flyweights::set_factory_class; - using boost::flyweights::simple_locking; - using boost::flyweights::static_holder; - using boost::flyweights::static_holder_class; - using boost::flyweights::swap; - using boost::flyweights::tag; - using boost::flyweights::tracking; - using boost::flyweights::tracking_marker; -}} - -export namespace boost { namespace flyweights { namespace concurrent_factory_detail { - using boost::flyweights::concurrent_factory_detail::check_concurrent_factory_class_params; - using boost::flyweights::concurrent_factory_detail::concurrent_factory_class_empty_base; - using boost::flyweights::concurrent_factory_detail::concurrent_factory_class_impl; - using boost::flyweights::concurrent_factory_detail::refcounted_entry; - using boost::flyweights::concurrent_factory_detail::refcounted_handle; -}}} - -export namespace boost { namespace flyweights { namespace detail { - using boost::flyweights::detail::archive_constructed; - using boost::flyweights::detail::default_value_policy; - using boost::flyweights::detail::flyweight_core; - using boost::flyweights::detail::flyweight_core_tracking_helper; - using boost::flyweights::detail::flyweight_signature; - using boost::flyweights::detail::flyweight_unmatched_signature; - using boost::flyweights::detail::flyweight_value_address; - using boost::flyweights::detail::insert_and_visit; - using boost::flyweights::detail::is_placeholder_expression; - using boost::flyweights::detail::is_placeholder_expression_helper; - using boost::flyweights::detail::is_tag; - using boost::flyweights::detail::is_value; - using boost::flyweights::detail::load_helper; - using boost::flyweights::detail::nested_iterator_if_not_placeholder_expression; - using boost::flyweights::detail::nested_iterator_if_not_placeholder_expression_helper; - using boost::flyweights::detail::nested_value_type_if_not_placeholder_expression; - using boost::flyweights::detail::nested_value_type_if_not_placeholder_expression_helper; - using boost::flyweights::detail::not_a_ph_expr; - using boost::flyweights::detail::product_key_value; - using boost::flyweights::detail::recursive_lightweight_mutex; - using boost::flyweights::detail::refcounted_handle; - using boost::flyweights::detail::refcounted_value; - using boost::flyweights::detail::save_helper; - using boost::flyweights::detail::swap; - using boost::flyweights::detail::tag_marker; - using boost::flyweights::detail::unmatched_arg; - using boost::flyweights::detail::value; - using boost::flyweights::detail::value_marker; - using boost::flyweights::detail::variant_key_value; -}}} diff --git a/patches/final/src/algorithm.cppm b/patches/final/src/algorithm.cppm deleted file mode 100644 index 9eb5c672b..000000000 --- a/patches/final/src/algorithm.cppm +++ /dev/null @@ -1,57 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -// NB: string_regex.hpp is NOT in the GFM (replaced by the string.hpp -// aggregate): gcc 16.1.0 rejects the boost::regex v5 abi-tag surface inside a -// module interface ("mismatching abi tags for get_catalog_name_inst") even -// though the same headers compile standalone. The *regex family was pruned -// from gen_exports/algorithm.inc accordingly (clang keeps the full surface). -// Re-evaluated when mcpplibs.mwrap.boost.regex lands in M4. -module; -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -export module mcpplibs.mwrap.boost.algorithm; - -export import mcpplibs.mwrap.boost.core; -export import mcpplibs.mwrap.boost.iterator; -export import mcpplibs.mwrap.boost.range; -export import mcpplibs.mwrap.boost.tuple; -export import mcpplibs.mwrap.boost.type_traits; - -#include "../generated/exports/algorithm.inc" - diff --git a/patches/final/src/any.cppm b/patches/final/src/any.cppm deleted file mode 100644 index bfcc197b2..000000000 --- a/patches/final/src/any.cppm +++ /dev/null @@ -1,10 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include -#include -#include - -export module mcpplibs.mwrap.boost.any; - -#include "../generated/exports/any.inc" - diff --git a/patches/final/src/container_hash.cppm b/patches/final/src/container_hash.cppm deleted file mode 100644 index b53a58bdb..000000000 --- a/patches/final/src/container_hash.cppm +++ /dev/null @@ -1,11 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include -#include - -export module mcpplibs.mwrap.boost.container_hash; - -export import mcpplibs.mwrap.boost.mp11; - -#include "../generated/exports/container_hash.inc" - diff --git a/patches/final/src/core.cppm b/patches/final/src/core.cppm deleted file mode 100644 index 593998bd7..000000000 --- a/patches/final/src/core.cppm +++ /dev/null @@ -1,54 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized). -// -// C5 (2026-09-09): BOOST_VERSION / BOOST_LIB_VERSION moved out of this module -// to a dedicated `mcpplibs.mwrap.boost.version` module (src/version.cppm — LIBS_SPECIAL tier -// in tools/boost_common.py; no .inc, no .deps, hand-written TU that -// `#include ` then `#undef`s the object macros and re-exposes -// them as `boost::BOOST_VERSION` / `boost::BOOST_LIB_VERSION` constexprs). -// Consumers wanting the same constants in their TU now `import mcpplibs.mwrap.boost.version;` -// (default feature set, §4.3 of the consolidated design doc). Macro-form -// consumers (`#if BOOST_VERSION >= 109200`) include -// directly — the upstream header is self-contained and no longer wrapped by -// this package. -module; -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -export module mcpplibs.mwrap.boost.core; - -#include "../generated/exports/core.inc" - diff --git a/patches/final/src/endian.cppm b/patches/final/src/endian.cppm deleted file mode 100644 index b57b1e0dd..000000000 --- a/patches/final/src/endian.cppm +++ /dev/null @@ -1,8 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include - -export module mcpplibs.mwrap.boost.endian; - -#include "../generated/exports/endian.inc" - diff --git a/patches/final/src/io.cppm b/patches/final/src/io.cppm deleted file mode 100644 index aabe5672f..000000000 --- a/patches/final/src/io.cppm +++ /dev/null @@ -1,13 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include -#include -// M11: ostream_put.hpp curated out of the io module GMF — its -// buffer_fill enum mismatches between the mcpplibs.mwrap.boost.io/mcpplibs.mwrap.boost.utility CMIs -// on gcc 16.1; consumers include the header themselves. -#include - -export module mcpplibs.mwrap.boost.io; - -#include "../generated/exports/io.inc" - diff --git a/patches/final/src/iterator.cppm b/patches/final/src/iterator.cppm deleted file mode 100644 index bb0116d14..000000000 --- a/patches/final/src/iterator.cppm +++ /dev/null @@ -1,31 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -export module mcpplibs.mwrap.boost.iterator; - -export import mcpplibs.mwrap.boost.core; -export import mcpplibs.mwrap.boost.mp11; -export import mcpplibs.mwrap.boost.optional; -export import mcpplibs.mwrap.boost.type_traits; - -#include "../generated/exports/iterator.inc" - diff --git a/patches/final/src/mp11.cppm b/patches/final/src/mp11.cppm deleted file mode 100644 index a5d70baee..000000000 --- a/patches/final/src/mp11.cppm +++ /dev/null @@ -1,9 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include -#include - -export module mcpplibs.mwrap.boost.mp11; - -#include "../generated/exports/mp11.inc" - diff --git a/patches/final/src/optional.cppm b/patches/final/src/optional.cppm deleted file mode 100644 index 2ad6aafad..000000000 --- a/patches/final/src/optional.cppm +++ /dev/null @@ -1,12 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include -#include - -export module mcpplibs.mwrap.boost.optional; - -export import mcpplibs.mwrap.boost.core; -export import mcpplibs.mwrap.boost.type_traits; - -#include "../generated/exports/optional.inc" - diff --git a/patches/final/src/range.cppm b/patches/final/src/range.cppm deleted file mode 100644 index bbb6831a8..000000000 --- a/patches/final/src/range.cppm +++ /dev/null @@ -1,33 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -export module mcpplibs.mwrap.boost.range; - -export import mcpplibs.mwrap.boost.core; -export import mcpplibs.mwrap.boost.iterator; -export import mcpplibs.mwrap.boost.optional; -export import mcpplibs.mwrap.boost.tuple; -export import mcpplibs.mwrap.boost.type_traits; - -#include "../generated/exports/range.inc" - diff --git a/patches/final/src/rational.cppm b/patches/final/src/rational.cppm deleted file mode 100644 index ab3360f24..000000000 --- a/patches/final/src/rational.cppm +++ /dev/null @@ -1,10 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include - -export module mcpplibs.mwrap.boost.rational; - -export import mcpplibs.mwrap.boost.type_traits; - -#include "../generated/exports/rational.inc" - diff --git a/patches/final/src/scope.cppm b/patches/final/src/scope.cppm deleted file mode 100644 index 915fdb925..000000000 --- a/patches/final/src/scope.cppm +++ /dev/null @@ -1,19 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include -#include -#include -#include -#include - -export module mcpplibs.mwrap.boost.scope; - -// NB: no `export import mcpplibs.mwrap.boost.core;` — gcc 16.1.0 ICEs (Segmentation fault at -// the export-module line) when this GMF include set (which pulls -// unique_fd.hpp, whose entities depend on mcpplibs.mwrap.boost.core) is combined with -// re-exporting mcpplibs.mwrap.boost.core. scope.inc carries no boost::core:: entities (they -// are claimed by mcpplibs.mwrap.boost.core itself), so consumers import mcpplibs.mwrap.boost.core on their -// own. (Clang has no such issue; tracked as a gcc bug for M6 CI.) - -#include "../generated/exports/scope.inc" - diff --git a/patches/final/src/static_string.cppm b/patches/final/src/static_string.cppm deleted file mode 100644 index ba6cf9586..000000000 --- a/patches/final/src/static_string.cppm +++ /dev/null @@ -1,11 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include - -export module mcpplibs.mwrap.boost.static_string; - -export import mcpplibs.mwrap.boost.container_hash; -export import mcpplibs.mwrap.boost.core; - -#include "../generated/exports/static_string.inc" - diff --git a/patches/final/src/tuple.cppm b/patches/final/src/tuple.cppm deleted file mode 100644 index 06f951bc4..000000000 --- a/patches/final/src/tuple.cppm +++ /dev/null @@ -1,11 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include -#include - -export module mcpplibs.mwrap.boost.tuple; - -export import mcpplibs.mwrap.boost.core; - -#include "../generated/exports/tuple.inc" - diff --git a/patches/final/src/type_traits.cppm b/patches/final/src/type_traits.cppm deleted file mode 100644 index 3b083e460..000000000 --- a/patches/final/src/type_traits.cppm +++ /dev/null @@ -1,29 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -export module mcpplibs.mwrap.boost.type_traits; - -#include "../generated/exports/type_traits.inc" - diff --git a/patches/final/src/variant.cppm b/patches/final/src/variant.cppm deleted file mode 100644 index fa80ecf44..000000000 --- a/patches/final/src/variant.cppm +++ /dev/null @@ -1,13 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include -#include -#include - -export module mcpplibs.mwrap.boost.variant; - -export import mcpplibs.mwrap.boost.core; -export import mcpplibs.mwrap.boost.type_traits; - -#include "../generated/exports/variant.inc" - diff --git a/patches/final/src/variant2.cppm b/patches/final/src/variant2.cppm deleted file mode 100644 index 4f8a4c9d4..000000000 --- a/patches/final/src/variant2.cppm +++ /dev/null @@ -1,8 +0,0 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) -module; -#include - -export module mcpplibs.mwrap.boost.variant2; - -#include "../generated/exports/variant2.inc" - diff --git a/patches/functional.patch b/patches/functional.patch deleted file mode 100644 index 119ceb24e..000000000 --- a/patches/functional.patch +++ /dev/null @@ -1,20 +0,0 @@ -diff --git a/generated/exports/functional.inc b/generated/exports/functional.inc -index 92b6f93..e5cceea 100644 ---- a/generated/exports/functional.inc -+++ b/generated/exports/functional.inc -@@ -368,10 +368,15 @@ export namespace boost { namespace mpl { - using boost::mpl::reverse_remove; - using boost::mpl::reverse_remove_if; - using boost::mpl::v_at; -+#if defined(__GNUC__) -+ // M9 platform guard: gcc-preprocessed mpl vector headers only. - using boost::mpl::v_at_impl; - using boost::mpl::v_item; -+#endif - using boost::mpl::v_iter; -+#if defined(__GNUC__) - using boost::mpl::v_mask; -+#endif - using boost::mpl::vector0; - using boost::mpl::vector1; - using boost::mpl::vector10; diff --git a/patches/graph.patch b/patches/graph.patch deleted file mode 100644 index b4bfbd9db..000000000 --- a/patches/graph.patch +++ /dev/null @@ -1,26 +0,0 @@ -diff --git a/generated/exports/graph.inc b/generated/exports/graph.inc -index 1c9be11..8761173 100644 ---- a/generated/exports/graph.inc -+++ b/generated/exports/graph.inc -@@ -2251,9 +2251,21 @@ export namespace boost { namespace proto { namespace detail { - using boost::proto::detail::same_cv; - using boost::proto::detail::sized_type; - using boost::proto::detail::static_const; -+#if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) -+ // M11 platform guard: proto/detail/template_arity.hpp declares template_arity only under -+ // BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template matching). - using boost::proto::detail::template_arity; -+#endif -+#if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) -+ // M11 platform guard: proto/detail/template_arity.hpp declares template_arity_helper only under -+ // BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template matching). - using boost::proto::detail::template_arity_helper; -+#endif -+#if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) -+ // M11 platform guard: proto/detail/template_arity.hpp declares template_arity_impl2 only under -+ // BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template matching). - using boost::proto::detail::template_arity_impl2; -+#endif - using boost::proto::detail::term_traits; - using boost::proto::detail::terminal_matches; - using boost::proto::detail::test_poly_function; diff --git a/patches/hana.patch b/patches/hana.patch deleted file mode 100644 index c8cc3ce4e..000000000 --- a/patches/hana.patch +++ /dev/null @@ -1,50 +0,0 @@ -diff --git a/generated/exports/hana.inc b/generated/exports/hana.inc -index 7368c47..25e52c5 100644 ---- a/generated/exports/hana.inc -+++ b/generated/exports/hana.inc -@@ -834,30 +834,30 @@ export namespace boost { namespace hana { namespace experimental { namespace pri - }}}} - - export namespace boost { namespace hana { namespace ext { namespace boost { -- using boost::hana::ext::boost::tuple_tag; -+ using ::boost::hana::ext::boost::tuple_tag; - }}}} - - export namespace boost { namespace hana { namespace ext { namespace boost { namespace fusion { -- using boost::hana::ext::boost::fusion::deque_tag; -- using boost::hana::ext::boost::fusion::list_tag; -- using boost::hana::ext::boost::fusion::tuple_tag; -- using boost::hana::ext::boost::fusion::vector_tag; -+ using ::boost::hana::ext::boost::fusion::deque_tag; -+ using ::boost::hana::ext::boost::fusion::list_tag; -+ using ::boost::hana::ext::boost::fusion::tuple_tag; -+ using ::boost::hana::ext::boost::fusion::vector_tag; - }}}}} - - export namespace boost { namespace hana { namespace ext { namespace boost { namespace mpl { -- using boost::hana::ext::boost::mpl::integral_c_tag; -- using boost::hana::ext::boost::mpl::list_tag; -- using boost::hana::ext::boost::mpl::vector_tag; -+ using ::boost::hana::ext::boost::mpl::integral_c_tag; -+ using ::boost::hana::ext::boost::mpl::list_tag; -+ using ::boost::hana::ext::boost::mpl::vector_tag; - }}}}} - - export namespace boost { namespace hana { namespace ext { namespace std { -- using boost::hana::ext::std::array_tag; -- using boost::hana::ext::std::integer_sequence_tag; -- using boost::hana::ext::std::integral_constant_tag; -- using boost::hana::ext::std::pair_tag; -- using boost::hana::ext::std::ratio_tag; -- using boost::hana::ext::std::tuple_tag; -- using boost::hana::ext::std::vector_tag; -+ using ::boost::hana::ext::std::array_tag; -+ using ::boost::hana::ext::std::integer_sequence_tag; -+ using ::boost::hana::ext::std::integral_constant_tag; -+ using ::boost::hana::ext::std::pair_tag; -+ using ::boost::hana::ext::std::ratio_tag; -+ using ::boost::hana::ext::std::tuple_tag; -+ using ::boost::hana::ext::std::vector_tag; - }}}} - - export namespace boost { namespace hana { namespace ic_detail { diff --git a/patches/heap.patch b/patches/heap.patch deleted file mode 100644 index 1c8acfc9c..000000000 --- a/patches/heap.patch +++ /dev/null @@ -1,17 +0,0 @@ -diff --git a/src/heap.cppm b/src/heap.cppm -index ce5b28e..da587aa 100644 ---- a/src/heap.cppm -+++ b/src/heap.cppm -@@ -19,5 +19,12 @@ export import mcpplibs.mwrap.boost.iterator; - export import mcpplibs.mwrap.boost.mp11; - export import mcpplibs.mwrap.boost.type_traits; - -+// M9: heap's container templates (d_ary_heap etc.) instantiate the intrusive -+// placement new (`::new(p, boost_move_new_t()) T`) in the consumer TU, where -+// the global operator new overload from move/detail/placement_new.hpp (a GMF -+// include) is not visible. M0 rule: re-export the global operator new -+// overloads from the module purview. -+export using ::operator new; -+ - #include "../generated/exports/heap.inc" - diff --git a/patches/hof_src.patch b/patches/hof_src.patch deleted file mode 100644 index 8768a05a5..000000000 --- a/patches/hof_src.patch +++ /dev/null @@ -1,70 +0,0 @@ -diff --git a/generated/exports/hof.inc b/generated/exports/hof.inc -index d276ea2..f99651f 100644 ---- a/generated/exports/hof.inc -+++ b/generated/exports/hof.inc -@@ -145,15 +145,31 @@ export namespace boost { namespace hof { namespace detail { - using boost::hof::detail::args_at; - using boost::hof::detail::basic_first_of_adaptor; - using boost::hof::detail::bind_transformer; -+#if !defined(_MSC_VER) -+ // C2 platform guard: bool_seq is the non-_MSC_VER branch of -+ // detail/and.hpp (the MSVC branch declares struct and_ instead). - using boost::hof::detail::bool_seq; -+#endif - using boost::hof::detail::by_eval; - using boost::hof::detail::by_void_eval; -+#if !BOOST_HOF_NO_EXPRESSION_SFINAE -+ // C2 platform guard: callable_args is the !NO_EXPRESSION_SFINAE branch -+ // of detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). - using boost::hof::detail::callable_args; -+#endif - using boost::hof::detail::callable_base; - using boost::hof::detail::callable_base_type; -+#if !BOOST_HOF_NO_EXPRESSION_SFINAE -+ // C2 platform guard: called_val is the !NO_EXPRESSION_SFINAE branch -+ // of detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). - using boost::hof::detail::called_val; -+#endif - using boost::hof::detail::can_be_called; -+#if !BOOST_HOF_NO_EXPRESSION_SFINAE -+ // C2 platform guard: can_be_called_impl is the !NO_EXPRESSION_SFINAE branch -+ // of detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). - using boost::hof::detail::can_be_called_impl; -+#endif - using boost::hof::detail::capture_f; - using boost::hof::detail::capture_invoke; - using boost::hof::detail::capture_pack; -@@ -176,7 +192,11 @@ export namespace boost { namespace hof { namespace detail { - using boost::hof::detail::decoration; - using boost::hof::detail::decorator_invoke; - using boost::hof::detail::enable_if_constructible; -+#if !BOOST_HOF_NO_ORDERED_BRACE_INIT -+ // C2 platform guard: eval_helper is the !NO_ORDERED_BRACE_INIT branch -+ // of apply_eval.hpp (config.hpp: _MSC_VER → 1). - using boost::hof::detail::eval_helper; -+#endif - using boost::hof::detail::fix_adaptor_base; - using boost::hof::detail::fix_result; - using boost::hof::detail::flow_kernel; -@@ -339,13 +359,21 @@ export namespace boost { namespace hof { namespace operators { - using boost::hof::operators::bit_or; - using boost::hof::operators::call; - using boost::hof::operators::compl_; -+#if !defined(_MSC_VER) -+ // C2 platform guard: operators::decrement is the #ifndef _MSC_VER -+ // branch of placeholders.hpp (MSVC 2017 ICE on ++/-- constexpr). - using boost::hof::operators::decrement; -+#endif - using boost::hof::operators::dereference; - using boost::hof::operators::divide; - using boost::hof::operators::equal; - using boost::hof::operators::greater_than; - using boost::hof::operators::greater_than_equal; -+#if !defined(_MSC_VER) -+ // C2 platform guard: operators::increment is the #ifndef _MSC_VER -+ // branch of placeholders.hpp (MSVC 2017 ICE on ++/-- constexpr). - using boost::hof::operators::increment; -+#endif - using boost::hof::operators::less_than; - using boost::hof::operators::less_than_equal; - using boost::hof::operators::multiply; diff --git a/patches/interprocess.patch b/patches/interprocess.patch deleted file mode 100644 index ecbe9689d..000000000 --- a/patches/interprocess.patch +++ /dev/null @@ -1,58 +0,0 @@ -diff --git a/src/interprocess.cppm b/src/interprocess.cppm -index 6871a9f..099ecc6 100644 ---- a/src/interprocess.cppm -+++ b/src/interprocess.cppm -@@ -26,7 +26,12 @@ module; - #include - #include - #include -+#if defined(_WIN32) || defined(__CYGWIN__) -+// M12 platform guard: managed_windows_shared_memory.hpp pulls -+// windows_shared_memory.hpp / detail/win32_api.hpp, which #error off-Windows -+// (M9 winapi.cppm convention). - #include -+#endif - #include - #include - #include -diff --git a/generated/exports/interprocess.inc b/generated/exports/interprocess.inc -index bdb8362..24c0189 100644 ---- a/generated/exports/interprocess.inc -+++ b/generated/exports/interprocess.inc -@@ -507,7 +507,10 @@ export namespace boost { namespace interprocess { namespace ipcdetail_really_dee - using boost::interprocess::ipcdetail_really_deep_namespace::dummy; - }}} - -+#if defined(_WIN32) - export namespace boost { namespace interprocess { namespace winapi { -+ // M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) -+ // is Windows-only; POSIX interprocess never declares it. - using boost::interprocess::winapi::NtClose_t; - using boost::interprocess::winapi::NtDeleteFile_t; - using boost::interprocess::winapi::NtOpenFile; -@@ -692,13 +695,17 @@ export namespace boost { namespace interprocess { namespace winapi { - using boost::interprocess::winapi::winapi_traits; - using boost::interprocess::winapi::write_file; - }}} -+#endif - - export namespace boost { namespace intrusive { - using boost::intrusive::max_pointer_plus_bits; - using boost::intrusive::pointer_plus_bits; - }} - -+#if defined(_WIN32) - export namespace boost { namespace ipwinapiext { -+ // M12 platform guard: registry / virtual-memory extension surface — -+ // Windows-only (win32_api.hpp chain). - using boost::ipwinapiext::CreateThread; - using boost::ipwinapiext::FlushFileBuffers; - using boost::ipwinapiext::GetFileType; -@@ -716,6 +723,7 @@ export namespace boost { namespace ipwinapiext { - using boost::ipwinapiext::VirtualProtect; - using boost::ipwinapiext::VirtualUnlock; - }} -+#endif - - export namespace boost { namespace move_detail { - using boost::move_detail::is_trivially_destructible; diff --git a/patches/intrusive.patch b/patches/intrusive.patch deleted file mode 100644 index 4bc626b43..000000000 --- a/patches/intrusive.patch +++ /dev/null @@ -1,16 +0,0 @@ -diff --git a/generated/exports/intrusive.inc b/generated/exports/intrusive.inc -index cc0eeb2..114d098 100644 ---- a/generated/exports/intrusive.inc -+++ b/generated/exports/intrusive.inc -@@ -382,7 +382,11 @@ export namespace boost { namespace intrusive { namespace detail { - using boost::intrusive::detail::boost_intrusive_has_type_size_type; - using boost::intrusive::detail::boost_intrusive_has_type_value_traits_ptr; - using boost::intrusive::detail::bstree_node_checker; -+#if defined(__GNUC__) -+ // M9 platform guard: math.hpp defines builtin_clz_dispatch only in the -+ // __GNUC__ branch of the BSR intrinsic chain. - using boost::intrusive::detail::builtin_clz_dispatch; -+#endif - using boost::intrusive::detail::calculate_h_sqrt2; - using boost::intrusive::detail::ceil_log2; - using boost::intrusive::detail::ceil_pow2; diff --git a/patches/iostreams.patch b/patches/iostreams.patch deleted file mode 100644 index c79c76371..000000000 --- a/patches/iostreams.patch +++ /dev/null @@ -1,19 +0,0 @@ -diff --git a/generated/exports/iostreams.inc b/generated/exports/iostreams.inc -index c31f321..5181bf4 100644 ---- a/generated/exports/iostreams.inc -+++ b/generated/exports/iostreams.inc -@@ -269,7 +269,14 @@ export namespace boost { namespace iostreams { namespace detail { - using boost::iostreams::detail::codecvt_extern; - using boost::iostreams::detail::codecvt_helper; - using boost::iostreams::detail::codecvt_holder; -+#if defined(BOOST_IOSTREAMS_NO_PRIMARY_CODECVT_DEFINITION) || \ -+ defined(BOOST_IOSTREAMS_EMPTY_PRIMARY_CODECVT_DEFINITION) || \ -+ defined(BOOST_IOSTREAMS_NO_LOCALE) -+ // M11 platform guard: detail/codecvt_helper.hpp declares codecvt_impl only -+ // on these std::codecvt workaround paths (libstdc++ mingw snapshot); the -+ // MSVC STL takes none of them. - using boost::iostreams::detail::codecvt_impl; -+#endif - using boost::iostreams::detail::codecvt_intern; - using boost::iostreams::detail::codecvt_state; - using boost::iostreams::detail::combination_traits; diff --git a/patches/json.patch b/patches/json.patch deleted file mode 100644 index c4706e6cd..000000000 --- a/patches/json.patch +++ /dev/null @@ -1,14 +0,0 @@ -diff --git a/src/json.cppm b/src/json.cppm -index dcf5a04..df0e7dc 100644 ---- a/src/json.cppm -+++ b/src/json.cppm -@@ -1,7 +1,8 @@ - // GENERATED by scripts/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) - module; -+// M4: 定义移入库 TU src/src.cpp, GMF 不再 include src.hpp (防双定义) — 2026-08-11-m4-compiled-libs.md §4 - #include --#include -+#include - - export module mcpplibs.mwrap.boost.json; - diff --git a/patches/lambda_src.patch b/patches/lambda_src.patch deleted file mode 100644 index 1276c4e30..000000000 --- a/patches/lambda_src.patch +++ /dev/null @@ -1,17 +0,0 @@ -diff --git a/generated/exports/lambda.inc b/generated/exports/lambda.inc -index e1c45b5..bd586f7 100644 ---- a/generated/exports/lambda.inc -+++ b/generated/exports/lambda.inc -@@ -343,7 +343,12 @@ export namespace boost { namespace lambda { namespace ll { - using boost::lambda::ll::pop_heap; - using boost::lambda::ll::prev_permutation; - using boost::lambda::ll::push_heap; -+#if !defined(BOOST_NO_CXX98_RANDOM_SHUFFLE) -+ // C4 flavor guard: random_shuffle is the -+ // !BOOST_NO_CXX98_RANDOM_SHUFFLE branch of algorithm.hpp -+ // (MSVC STL/libc++ under C++17 removed std::random_shuffle). - using boost::lambda::ll::random_shuffle; -+#endif - using boost::lambda::ll::remove; - using boost::lambda::ll::remove_copy; - using boost::lambda::ll::remove_copy_if; diff --git a/patches/leaf.patch b/patches/leaf.patch deleted file mode 100644 index 458168f0c..000000000 --- a/patches/leaf.patch +++ /dev/null @@ -1,19 +0,0 @@ -diff --git a/generated/exports/leaf.inc b/generated/exports/leaf.inc -index 61e4e45..64dfaaf 100644 ---- a/generated/exports/leaf.inc -+++ b/generated/exports/leaf.inc -@@ -97,6 +97,14 @@ export namespace boost { namespace leaf { namespace detail { - using boost::leaf::detail::encoder_adaptor; - using boost::leaf::detail::enforce_std_exception; - using boost::leaf::detail::exception; -+ // M9: gcc 16.1.0 module consumers emit a partial vtable for -+ // exception (multi-base exception_base/error_id) whose -+ // non-virtual thunks stay undefined — gcc never emits them in a module -+ // consumer TU. This extern template suppresses the consumer's implicit -+ // instantiation; the complete vtable + thunks come from the explicit -+ // instantiation in port/leaf_extras.cpp (same pattern as thread's -+ // clone_impl, cf. M7c). -+ extern template class boost::leaf::detail::exception; - using boost::leaf::detail::exception_base; - using boost::leaf::detail::find_in_tuple; - using boost::leaf::detail::fn_arg_type; diff --git a/patches/math.patch b/patches/math.patch deleted file mode 100644 index 950a3e78d..000000000 --- a/patches/math.patch +++ /dev/null @@ -1,64 +0,0 @@ -diff --git a/generated/exports/math.inc b/generated/exports/math.inc -index 3221ae3..1b01fd8 100644 ---- a/generated/exports/math.inc -+++ b/generated/exports/math.inc -@@ -4,13 +4,25 @@ - export namespace boost { - using boost::float32_t; - using boost::float64_t; -+#if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 -+ // M11 platform guard: cstdfloat_types.hpp declares the 80-bit long-double -+ // typedefs only where long double really is 80-bit; MSVC long double is 53-bit. - using boost::float80_t; -+#endif - using boost::float_fast32_t; - using boost::float_fast64_t; -+#if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 -+ // M11 platform guard: cstdfloat_types.hpp declares the 80-bit long-double -+ // typedefs only where long double really is 80-bit; MSVC long double is 53-bit. - using boost::float_fast80_t; -+#endif - using boost::float_least32_t; - using boost::float_least64_t; -+#if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 -+ // M11 platform guard: cstdfloat_types.hpp declares the 80-bit long-double -+ // typedefs only where long double really is 80-bit; MSVC long double is 53-bit. - using boost::float_least80_t; -+#endif - using boost::floatmax_t; - } - -@@ -2272,10 +2284,20 @@ export namespace boost { namespace math { namespace statistics { - }}} - - export namespace boost { namespace math { namespace statistics { namespace detail { -+#if defined(BOOST_MATH_EXEC_COMPATIBLE) -+ // M11 CI platform guard: statistics chatterjee_correlation_par_impl is defined only under -+ // BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / -+ // bivariate_statistics.hpp); libc++ lacks __cpp_lib_execution. - using boost::math::statistics::detail::chatterjee_correlation_par_impl; -+#endif - using boost::math::statistics::detail::chatterjee_correlation_seq_impl; - using boost::math::statistics::detail::chatterjee_transform; -+#if defined(BOOST_MATH_EXEC_COMPATIBLE) -+ // M11 CI platform guard: statistics correlation_coefficient_parallel_impl is defined only under -+ // BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / -+ // bivariate_statistics.hpp); libc++ lacks __cpp_lib_execution. - using boost::math::statistics::detail::correlation_coefficient_parallel_impl; -+#endif - using boost::math::statistics::detail::correlation_coefficient_seq_impl; - using boost::math::statistics::detail::first_four_moments_parallel_impl; - using boost::math::statistics::detail::first_four_moments_sequential_impl; -@@ -2283,7 +2305,12 @@ export namespace boost { namespace math { namespace statistics { namespace detai - using boost::math::statistics::detail::gini_coefficient_sequential_impl; - using boost::math::statistics::detail::gini_range_fraction; - using boost::math::statistics::detail::mean_sequential_impl; -+#if defined(BOOST_MATH_EXEC_COMPATIBLE) -+ // M11 CI platform guard: statistics means_and_covariance_parallel_impl is defined only under -+ // BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / -+ // bivariate_statistics.hpp); libc++ lacks __cpp_lib_execution. - using boost::math::statistics::detail::means_and_covariance_parallel_impl; -+#endif - using boost::math::statistics::detail::means_and_covariance_seq_impl; - using boost::math::statistics::detail::mode_impl; - using boost::math::statistics::detail::one_sample_t_test_impl; diff --git a/patches/mp11.patch b/patches/mp11.patch deleted file mode 100644 index 9b5dfef32..000000000 --- a/patches/mp11.patch +++ /dev/null @@ -1,16 +0,0 @@ -diff --git a/generated/exports/mp11.inc b/generated/exports/mp11.inc -index 158a957..10bf901 100644 ---- a/generated/exports/mp11.inc -+++ b/generated/exports/mp11.inc -@@ -438,8 +438,11 @@ export namespace boost { namespace mp11 { namespace detail { - using boost::mp11::detail::mp_valid_impl; - using boost::mp11::detail::mp_void_impl; - using boost::mp11::detail::mp_with_index_impl_; -+#if !defined(__GNUC__) -+ // M3 hand-guard: mp_map_find.hpp (gcc bug 120161 workaround) defines mpmf_* only outside gcc. - using boost::mp11::detail::mpmf_unwrap; - using boost::mp11::detail::mpmf_wrap; -+#endif - using boost::mp11::detail::select_max; - using boost::mp11::detail::select_min; - using boost::mp11::detail::tp_extract; diff --git a/patches/multiprecision.patch b/patches/multiprecision.patch deleted file mode 100644 index 8f81c1cd6..000000000 --- a/patches/multiprecision.patch +++ /dev/null @@ -1,118 +0,0 @@ -diff --git a/generated/exports/multiprecision.inc b/generated/exports/multiprecision.inc -index 017ec61..a2bc91f 100644 ---- a/generated/exports/multiprecision.inc -+++ b/generated/exports/multiprecision.inc -@@ -143,7 +143,11 @@ export namespace boost { namespace multiprecision { - using boost::multiprecision::import_bits; - using boost::multiprecision::int1024_t; - using boost::multiprecision::int128_t; -+#if defined(BOOST_HAS_INT128) -+ // M12 platform guard: detail/standalone_config.hpp defines int128_type only -+ // under BOOST_HAS_INT128 (off under the clang-msvc flavor). - using boost::multiprecision::int128_type; -+#endif - using boost::multiprecision::int256_t; - using boost::multiprecision::int512_t; - using boost::multiprecision::integer_modulus; -@@ -284,7 +288,10 @@ export namespace boost { namespace multiprecision { - using boost::multiprecision::trunc; - using boost::multiprecision::uint1024_t; - using boost::multiprecision::uint128_t; -+#if defined(BOOST_HAS_INT128) -+ // M12 platform guard: as above (uint128_type). - using boost::multiprecision::uint128_type; -+#endif - using boost::multiprecision::uint256_t; - using boost::multiprecision::uint512_t; - using boost::multiprecision::uniform_int_distribution; -@@ -316,8 +323,15 @@ export namespace boost { namespace multiprecision { namespace backends { - using boost::multiprecision::backends::digit_base_type; - using boost::multiprecision::backends::digit_base_type::digit_base_10; - using boost::multiprecision::backends::digit_base_type::digit_base_2; -+#if defined(BOOST_HAS_INT128) -+ // M12 platform guard: divide_subtract is the synthetic-double_limb_type -+ // division branch of cpp_int/misc.hpp (BOOST_HAS_INT128 only). - using boost::multiprecision::backends::divide_subtract; -+#endif -+#if defined(BOOST_HAS_INT128) -+ // M12 platform guard: as above (divide_unsigned_helper). - using boost::multiprecision::backends::divide_unsigned_helper; -+#endif - using boost::multiprecision::backends::do_eval_add; - using boost::multiprecision::backends::do_eval_subtract; - using boost::multiprecision::backends::eval_abs; -@@ -689,7 +703,13 @@ export namespace boost { namespace multiprecision { namespace detail { - using boost::multiprecision::detail::abs; - using boost::multiprecision::detail::abs_funct; - using boost::multiprecision::detail::add_immediates; -+#if defined(BOOST_MP_HAS_IMMINTRIN_H) -+ // M11 platform guard: cpp_int/intel_intrinsics.hpp declares addcarry_limb -+ // only under BOOST_MP_HAS_IMMINTRIN_H (the adc intrinsics dispatch — clang on -+ // macOS arm64 unsets the macro because __builtin_ia32_addcarryx_u64 is a -+ // gcc-only builtin and BOOST_GCC is not defined). - using boost::multiprecision::detail::addcarry_limb; -+#endif - using boost::multiprecision::detail::arg_type; - using boost::multiprecision::detail::assign_bits; - using boost::multiprecision::detail::backend_type; -@@ -881,13 +901,19 @@ export namespace boost { namespace multiprecision { namespace detail { - using boost::multiprecision::detail::scoped_target_precision; - using boost::multiprecision::detail::shift_left; - using boost::multiprecision::detail::shift_right; -+#if defined(BOOST_MP_HAS_IMMINTRIN_H) -+ // M11 platform guard: cpp_int/intel_intrinsics.hpp declares subborrow_limb -+ // only under BOOST_MP_HAS_IMMINTRIN_H (see addcarry_limb guard for rationale). - using boost::multiprecision::detail::subborrow_limb; -+#endif - using boost::multiprecision::detail::subtract_immediates; - using boost::multiprecision::detail::terminal; - using boost::multiprecision::detail::transcendental_reduction_type; - using boost::multiprecision::detail::uint_t; -- using boost::multiprecision::detail::unmentionable; -- using boost::multiprecision::detail::unmentionable_type; -+ // M12: unmentionable dropped — no external linkage (multiprecision detail -+ // placeholder); gcc refuses the export. -+ // M12: unmentionable_type dropped — no external linkage (multiprecision detail -+ // placeholder); gcc refuses the export. - using boost::multiprecision::detail::unsigned_abs; - using boost::multiprecision::detail::use_empty_value_base; - }}} -@@ -1034,7 +1060,12 @@ export namespace boost { namespace serialization { namespace cpp_int_detail { - using boost::serialization::cpp_int_detail::denominator; - using boost::serialization::cpp_int_detail::digit_base_type; - using boost::serialization::cpp_int_detail::divide_qr; -+#if defined(BOOST_HAS_INT128) -+ // M12 platform guard: serialize.hpp's `using namespace -+ // boost::multiprecision(::backends)` exposes the divide_subtract entity into -+ // cpp_int_detail — present only under BOOST_HAS_INT128. - using boost::serialization::cpp_int_detail::divide_subtract; -+#endif - using boost::serialization::cpp_int_detail::divide_unsigned_helper; - using boost::serialization::cpp_int_detail::do_eval_add; - using boost::serialization::cpp_int_detail::do_eval_subtract; -@@ -1148,7 +1179,12 @@ export namespace boost { namespace serialization { namespace cpp_int_detail { - using boost::serialization::cpp_int_detail::import_bits; - using boost::serialization::cpp_int_detail::int1024_t; - using boost::serialization::cpp_int_detail::int128_t; -+#if defined(BOOST_HAS_INT128) -+ // M12 platform guard: serialize.hpp's `using namespace -+ // boost::multiprecision(::backends)` exposes the int128_type entity into -+ // cpp_int_detail — present only under BOOST_HAS_INT128. - using boost::serialization::cpp_int_detail::int128_type; -+#endif - using boost::serialization::cpp_int_detail::int256_t; - using boost::serialization::cpp_int_detail::int512_t; - using boost::serialization::cpp_int_detail::integer_modulus; -@@ -1314,7 +1350,12 @@ export namespace boost { namespace serialization { namespace cpp_int_detail { - using boost::serialization::cpp_int_detail::trunc; - using boost::serialization::cpp_int_detail::uint1024_t; - using boost::serialization::cpp_int_detail::uint128_t; -+#if defined(BOOST_HAS_INT128) -+ // M12 platform guard: serialize.hpp's `using namespace -+ // boost::multiprecision(::backends)` exposes the uint128_type entity into -+ // cpp_int_detail — present only under BOOST_HAS_INT128. - using boost::serialization::cpp_int_detail::uint128_type; -+#endif - using boost::serialization::cpp_int_detail::uint256_t; - using boost::serialization::cpp_int_detail::uint512_t; - using boost::serialization::cpp_int_detail::uniform_int_distribution; diff --git a/patches/nowide.patch b/patches/nowide.patch deleted file mode 100644 index caf5a9491..000000000 --- a/patches/nowide.patch +++ /dev/null @@ -1,59 +0,0 @@ -diff --git a/src/nowide.cppm b/src/nowide.cppm -index 5ee766a..56b655d 100644 ---- a/src/nowide.cppm -+++ b/src/nowide.cppm -@@ -5,6 +5,13 @@ module; - #include - #include - #include -+// M11 platform guard (POSIX): cstdio/stackstring/convert were reached -+// only via windows-flavored transitive includes in the mingw snapshot; -+// include the cross-platform headers explicitly so the shared-surface -+// `using` lines resolve. -+#include -+#include -+#include - #include - #include - -diff --git a/generated/exports/nowide.inc b/generated/exports/nowide.inc -index 8709b1e..79ea26e 100644 ---- a/generated/exports/nowide.inc -+++ b/generated/exports/nowide.inc -@@ -45,8 +45,14 @@ export namespace boost { namespace nowide { namespace detail { - using boost::nowide::detail::StreamTypeInOut; - using boost::nowide::detail::StreamTypeOut; - using boost::nowide::detail::buf_holder; -+#if defined(_WIN32) -+ // M11 platform guard: console_input_buffer is the windows console machinery (detail/console_buffer.hpp); POSIX nowide uses std:: streams directly. - using boost::nowide::detail::console_input_buffer; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: console_output_buffer is the windows console machinery (detail/console_buffer.hpp); POSIX nowide uses std:: streams directly. - using boost::nowide::detail::console_output_buffer; -+#endif - using boost::nowide::detail::const_data_result; - using boost::nowide::detail::copy_uint16_t; - using boost::nowide::detail::enable_if_path_t; -@@ -70,11 +76,21 @@ export namespace boost { namespace nowide { namespace detail { - using boost::nowide::detail::requires_wide_char; - using boost::nowide::detail::requires_wide_string_container; - using boost::nowide::detail::size_result; -+#if defined(_WIN32) -+ // M11 platform guard: detail::stat is the BOOST_WINDOWS branch of -+ // stat.hpp; POSIX exposes ::stat via a using-declaration instead. - using boost::nowide::detail::stat; -+#endif - using boost::nowide::detail::void_t; - using boost::nowide::detail::wfopen; -+#if defined(_WIN32) -+ // M11 platform guard: winconsole_istream is the windows console stream branch of iostream.hpp; POSIX takes std:: streams directly. - using boost::nowide::detail::winconsole_istream; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: winconsole_ostream is the windows console stream branch of iostream.hpp; POSIX takes std:: streams directly. - using boost::nowide::detail::winconsole_ostream; -+#endif - using boost::nowide::detail::write_state; - }}} - diff --git a/patches/parser.patch b/patches/parser.patch deleted file mode 100644 index 24ebd9d87..000000000 --- a/patches/parser.patch +++ /dev/null @@ -1,22 +0,0 @@ -diff --git a/generated/exports/parser.inc b/generated/exports/parser.inc ---- a/generated/exports/parser.inc -+++ b/generated/exports/parser.inc -@@ -514,12 +514,12 @@ - using boost::parser::detail::numeric::unpacks_to_chars; - }}}} - --export namespace boost { namespace parser { namespace detail { namespace numeric { namespace std_charconv { -- using boost::parser::detail::numeric::std_charconv::parse_int; -- using boost::parser::detail::numeric::std_charconv::parse_real; -- using boost::parser::detail::numeric::std_charconv::use_charconv_int; -- using boost::parser::detail::numeric::std_charconv::use_charconv_real; --}}}}} -+export namespace boost { namespace parser { namespace detail { namespace numeric { -+ using boost::parser::detail::numeric::parse_int; -+ using boost::parser::detail::numeric::parse_real; -+ using boost::parser::detail::numeric::use_charconv_int; -+ using boost::parser::detail::numeric::use_charconv_real; -+}}}} - - export namespace boost { namespace parser { namespace detail { namespace stl_interfaces { - using boost::parser::detail::stl_interfaces::access; diff --git a/patches/pfr.patch b/patches/pfr.patch deleted file mode 100644 index 3e49cad22..000000000 --- a/patches/pfr.patch +++ /dev/null @@ -1,28 +0,0 @@ -diff --git a/generated/exports/pfr.inc b/generated/exports/pfr.inc -index 0724c06..2c36dda 100644 ---- a/generated/exports/pfr.inc -+++ b/generated/exports/pfr.inc -@@ -46,7 +46,11 @@ export namespace boost { namespace pfr { namespace detail { - using boost::pfr::detail::binary_visit; - using boost::pfr::detail::can_not_apply; - using boost::pfr::detail::clang_workaround; -+#if defined(__clang__) -+ // M9 platform guard: clang_wrapper_t is the clang-only NTTP wrapper -+ // (core_name20_static.hpp #ifdef __clang__ branch). - using boost::pfr::detail::clang_wrapper_t; -+#endif - using boost::pfr::detail::comp_eq_detector; - using boost::pfr::detail::comp_eq_detector_msvc_helper; - using boost::pfr::detail::comp_ge_detector; -@@ -87,7 +91,11 @@ export namespace boost { namespace pfr { namespace detail { - using boost::pfr::detail::fake_object; - using boost::pfr::detail::fields_count; - using boost::pfr::detail::fields_count_dispatch; -+#if BOOST_PFR_USE_CPP26_REFLECTION || BOOST_PFR_USE_CPP26 -+ // M9 platform guard: fields_count_dispatch_impl exists only under the -+ // C++26 reflection / structured-bindings branches (fields_count.hpp). - using boost::pfr::detail::fields_count_dispatch_impl; -+#endif - using boost::pfr::detail::for_each_field; - using boost::pfr::detail::for_each_field_dispatcher; - using boost::pfr::detail::for_each_field_impl; diff --git a/patches/poly_collection.patch b/patches/poly_collection.patch deleted file mode 100644 index daec90b7a..000000000 --- a/patches/poly_collection.patch +++ /dev/null @@ -1,15 +0,0 @@ -diff --git a/generated/exports/poly_collection.inc b/generated/exports/poly_collection.inc -index 09740fa..39f469b 100644 ---- a/generated/exports/poly_collection.inc -+++ b/generated/exports/poly_collection.inc -@@ -14,7 +14,10 @@ export namespace boost { namespace mpl { - using boost::mpl::contains_impl; - using boost::mpl::has_key_impl; - using boost::mpl::item_by_order; -+#if defined(__GNUC__) -+ // M9 platform guard: gcc-preprocessed mpl map headers only. - using boost::mpl::item_by_order_impl; -+#endif - using boost::mpl::lambda; - using boost::mpl::m_at; - using boost::mpl::m_item; diff --git a/patches/process.patch b/patches/process.patch deleted file mode 100644 index 14bf0bb9f..000000000 --- a/patches/process.patch +++ /dev/null @@ -1,229 +0,0 @@ -diff --git a/generated/exports/process.inc b/generated/exports/process.inc -index 48bd1fda..b91f7888 100644 ---- a/generated/exports/process.inc -+++ b/generated/exports/process.inc -@@ -248,7 +248,10 @@ export namespace boost { namespace process { namespace v1 { namespace detail { - using boost::process::v1::detail::valid_argument_list; - }}}} - -+#if defined(_WIN32) - export namespace boost { namespace process { namespace v1 { namespace detail { namespace windows { -+ // M11 platform guard: v1 detail windows impls (incl. the NT workaround -+ // block below) are declared only by the windows GMF branches. - using boost::process::v1::detail::windows::apply_out_handles; - using boost::process::v1::detail::windows::associate_completion_port; - using boost::process::v1::detail::windows::async_handler; -@@ -352,6 +355,7 @@ export namespace boost { namespace process { namespace v1 { namespace detail { n - using boost::process::v1::detail::windows::workaround::nt_system_query_information; - using boost::process::v1::detail::windows::workaround::set_information_job_object; - }}}}}} -+#endif - - export namespace boost { namespace process { namespace v1 { namespace extend { - using boost::process::v1::extend::foreach_used_handle; -@@ -366,7 +370,11 @@ export namespace boost { namespace process { namespace v1 { namespace extend { - }}}} - - export namespace boost { namespace process { namespace v2 { -+#if defined(__MINGW32__) -+ // M11 platform guard: _popen is the MinGW spelling of popen -+ // (mingw stdio.h #defines popen to _popen); MSVC/POSIX expose popen. - using boost::process::v2::_popen; -+#endif - using boost::process::v2::all_pids; - using boost::process::v2::async_execute; - using boost::process::v2::basic_cstring_ref; -@@ -404,51 +412,140 @@ export namespace boost { namespace process { namespace v2 { - }}} - - export namespace boost { namespace process { namespace v2 { namespace detail { -+#if defined(_WIN32) -+ // M11 platform guard: all_are_initializers is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::all_are_initializers; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: base is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::base; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: basic_process_handle_win is the windows variant -+ // (detail/process_handle_windows.hpp); POSIX takes process_handle_fd. - using boost::process::v2::detail::basic_process_handle_win; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: check_handle_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). - using boost::process::v2::detail::check_handle_; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: check_pid_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). - using boost::process::v2::detail::check_pid_; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: check_running_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). - using boost::process::v2::detail::check_running_; -+#endif - using boost::process::v2::detail::conv_string; - using boost::process::v2::detail::convert_to_utf8; - using boost::process::v2::detail::convert_to_wide; -+#if defined(_WIN32) -+ // M11 platform guard: derived is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::derived; -+#endif - using boost::process::v2::detail::do_throw_error; - using boost::process::v2::detail::execute_op; -+#if defined(_WIN32) -+ // M11 platform guard: get_exit_code_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). - using boost::process::v2::detail::get_exit_code_; -+#endif - using boost::process::v2::detail::get_last_error; -+#if defined(_WIN32) -+ // M11 platform guard: handle_closer is the Windows stdio handle -+ // wrapper (DWORD/GetStdHandle); POSIX stdio does not declare it. - using boost::process::v2::detail::handle_closer; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: has_on_error is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::has_on_error; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: has_on_setup is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::has_on_setup; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: has_on_success is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::has_on_success; -+#endif - using boost::process::v2::detail::index_sequence; -+#if defined(_WIN32) -+ // M11 platform guard: interrupt_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). - using boost::process::v2::detail::interrupt_; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: invoke_on_error is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::invoke_on_error; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: invoke_on_setup is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::invoke_on_setup; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: invoke_on_success is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::invoke_on_success; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: is_initializer is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::is_initializer; -+#endif - using boost::process::v2::detail::make_index_sequence; - using boost::process::v2::detail::make_index_sequence_impl; - using boost::process::v2::detail::make_index_sequence_t; -+#if defined(_WIN32) -+ // M11 platform guard: on_error is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::on_error; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: on_setup is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::on_setup; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: on_success is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::on_success; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: open_process_ lives in detail/process_handle_windows.hpp. - using boost::process::v2::detail::open_process_; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: probe_on_error is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::probe_on_error; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: probe_on_setup is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::probe_on_setup; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: probe_on_success is the windows generic-launcher machinery (flat v2::detail); POSIX nests a different set under v2::posix::detail. - using boost::process::v2::detail::probe_on_success; -+#endif - using boost::process::v2::detail::process_error_binding; - using boost::process::v2::detail::process_input_binding; - using boost::process::v2::detail::process_io_binding; - using boost::process::v2::detail::process_output_binding; -+#if defined(_WIN32) -+ // M11 platform guard: request_exit_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). - using boost::process::v2::detail::request_exit_; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: resume_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). - using boost::process::v2::detail::resume_; -+#endif - using boost::process::v2::detail::size_as_utf8; - using boost::process::v2::detail::size_as_wide; -+#if defined(_WIN32) -+ // M11 platform guard: suspend_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). - using boost::process::v2::detail::suspend_; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: terminate_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). - using boost::process::v2::detail::terminate_; -+#endif -+#if defined(_WIN32) -+ // M11 platform guard: terminate_if_running_ lives in detail/process_handle_windows.hpp (no fd-variant counterpart). - using boost::process::v2::detail::terminate_if_running_; -+#endif - using boost::process::v2::detail::throw_error; - }}}} - -@@ -496,7 +593,11 @@ export namespace boost { namespace process { namespace v2 { namespace environmen - using boost::process::v2::environment::detail::find_key; - using boost::process::v2::environment::detail::get; - using boost::process::v2::environment::detail::hash_step; -+#if defined(_WIN32) -+ // M11 platform guard: is_exec_type lives in detail/environment_win.hpp; -+ // POSIX environment detail does not declare it. - using boost::process::v2::environment::detail::is_exec_type; -+#endif - using boost::process::v2::environment::detail::is_executable; - using boost::process::v2::environment::detail::load_native_handle; - using boost::process::v2::environment::detail::native_handle_deleter; -@@ -521,7 +622,9 @@ export namespace boost { namespace process { namespace v2 { namespace ext { - using boost::process::v2::ext::exe; - }}}} - -+#if defined(_WIN32) - export namespace boost { namespace process { namespace v2 { namespace windows { -+ // M11 platform guard: v2 windows launchers are Windows-only headers. - using boost::process::v2::windows::as_user_launcher; - using boost::process::v2::windows::default_launcher; - using boost::process::v2::windows::process_creation_flags; -@@ -529,6 +632,7 @@ export namespace boost { namespace process { namespace v2 { namespace windows { - using boost::process::v2::windows::with_logon_launcher; - using boost::process::v2::windows::with_token_launcher; - }}}} -+#endif - - export namespace boost { namespace system { - using boost::system::error_category; -diff --git a/src/process.cppm b/src/process.cppm -index 8e851574..b6e83f0e 100644 ---- a/src/process.cppm -+++ b/src/process.cppm -@@ -11,6 +11,10 @@ module; - #include - #include - #include -+// M11 platform guard: v1/v2 windows launchers are Windows-only headers -+// (boost/winapi basic_types.hpp #errors off-Windows); M9 winapi.cppm -+// convention. POSIX face = platform-neutral + posix-self-guarded surface. -+#if defined(_WIN32) || defined(__CYGWIN__) - #include - #include - #include -@@ -21,6 +25,7 @@ module; - #include - #include - #include -+#endif - - export module mcpplibs.mwrap.boost.process; - diff --git a/patches/program_options.patch b/patches/program_options.patch deleted file mode 100644 index b9f4d783c..000000000 --- a/patches/program_options.patch +++ /dev/null @@ -1,15 +0,0 @@ -diff --git a/generated/exports/program_options.inc b/generated/exports/program_options.inc -index 5464ae3..bcc6d9b 100644 ---- a/generated/exports/program_options.inc -+++ b/generated/exports/program_options.inc -@@ -55,7 +55,10 @@ export namespace boost { namespace program_options { - using boost::program_options::reading_file; - using boost::program_options::required_option; - using boost::program_options::split_unix; -+#if defined(_WIN32) -+ // M6 platform guard: winmain.hpp (split_winmain) is Windows-only. - using boost::program_options::split_winmain; -+#endif - using boost::program_options::store; - using boost::program_options::strip_prefixes; - using boost::program_options::to_internal; diff --git a/patches/qvm.patch b/patches/qvm.patch deleted file mode 100644 index d348e60fe..000000000 --- a/patches/qvm.patch +++ /dev/null @@ -1,16 +0,0 @@ -diff --git a/generated/exports/qvm.inc b/generated/exports/qvm.inc -index 770ffb0..02f99b8 100644 ---- a/generated/exports/qvm.inc -+++ b/generated/exports/qvm.inc -@@ -2007,7 +2007,11 @@ export namespace boost { namespace qvm { namespace qvm_detail { - using boost::qvm::qvm_detail::vec_register_common; - using boost::qvm::qvm_detail::vec_register_read; - using boost::qvm::qvm_detail::vec_register_write; -+#if defined(__GNUC__) && defined(__SSE2__) -+ // M12 platform guard: vec_traits_gnuc.hpp declares vec_traits_gnuc_impl -+ // only under __GNUC__ && __SSE2__ (gcc vector_size ext_vector_traits). - using boost::qvm::qvm_detail::vec_traits_gnuc_impl; -+#endif - using boost::qvm::qvm_detail::vector_scalar_cast_; - using boost::qvm::qvm_detail::vector_w; - using boost::qvm::qvm_detail::vref_; diff --git a/patches/range.patch b/patches/range.patch deleted file mode 100644 index b7ecf992b..000000000 --- a/patches/range.patch +++ /dev/null @@ -1,16 +0,0 @@ -diff --git a/generated/exports/range.inc b/generated/exports/range.inc -index e8431a5..ee5583c 100644 ---- a/generated/exports/range.inc -+++ b/generated/exports/range.inc -@@ -329,7 +329,11 @@ export namespace boost { namespace range { namespace detail { - using boost::range::detail::less; - using boost::range::detail::max_element; - using boost::range::detail::min_element; -+#if defined(__GLIBCXX__) -+ // M9 platform guard: std::random_shuffle was removed in C++17; only -+ // libstdc++ (mingw/linux-gcc) still provides it. - using std::random_shuffle; -+#endif - }}} - - export namespace boost { namespace range_adl_barrier { diff --git a/patches/safe_numerics_src.patch b/patches/safe_numerics_src.patch deleted file mode 100644 index 8ab77ccc8..000000000 --- a/patches/safe_numerics_src.patch +++ /dev/null @@ -1,13 +0,0 @@ -diff --git a/src/safe_numerics.cppm b/src/safe_numerics.cppm -index 8b3673d..32ba56a 100644 ---- a/src/safe_numerics.cppm -+++ b/src/safe_numerics.cppm -@@ -1,5 +1,8 @@ - // GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) - module; -+// M9: checked_result_operations.hpp uses std::terminate without ; -+// libstdc++/libc++ doesn't transitively include it (MSVC STL does). -+#include - #include - #include - #include diff --git a/patches/stacktrace.patch b/patches/stacktrace.patch deleted file mode 100644 index 36cf000d3..000000000 --- a/patches/stacktrace.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff --git a/src/stacktrace.cppm b/src/stacktrace.cppm -index 3cc5f76..8c757be 100644 ---- a/src/stacktrace.cppm -+++ b/src/stacktrace.cppm -@@ -1,5 +1,7 @@ - // GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) - module; -+// M4: BOOST_STACKTRACE_LINK 切到外链模式, 定义来自 libs/stacktrace/src/basic.cpp — 2026-08-11-m4-compiled-libs.md §3 -+#define BOOST_STACKTRACE_LINK - #include - - export module mcpplibs.mwrap.boost.stacktrace; diff --git a/patches/system_src.patch b/patches/system_src.patch deleted file mode 100644 index bc6050b00..000000000 --- a/patches/system_src.patch +++ /dev/null @@ -1,50 +0,0 @@ -diff --git a/generated/exports/system.inc b/generated/exports/system.inc -index 2aff312..c6d77ea 100644 ---- a/generated/exports/system.inc -+++ b/generated/exports/system.inc -@@ -57,18 +57,28 @@ export namespace boost { namespace system { namespace detail { - using boost::system::detail::is_errc_t; - using boost::system::detail::is_result; - using boost::system::detail::is_value_convertible_to; -+#if defined(BOOST_WINDOWS_API) -+ // M6 platform guard: snapshot = mingw flavor; these boost/system/detail entities -+ // exist only under BOOST_WINDOWS_API (system_category_message_win32.hpp / condition). - using boost::system::detail::local_free; -- using boost::system::detail::lock_guard; - using boost::system::detail::message_cp_win32; -+#endif -+ using boost::system::detail::lock_guard; - using boost::system::detail::reference_to_temporary; - using boost::system::detail::remove_cvref; - using boost::system::detail::std_category; - using boost::system::detail::system_cat_holder; -+#if defined(BOOST_WINDOWS_API) -+ // M6 platform guard: as above. - using boost::system::detail::system_category_condition_win32; - using boost::system::detail::system_category_message_win32; -+#endif - using boost::system::detail::system_error_category; - using boost::system::detail::system_error_category_message; -+#if defined(BOOST_WINDOWS_API) -+ // M6 platform guard: as above. - using boost::system::detail::unknown_message_win32; -+#endif - using std::enable_if; - using std::is_same; - using std::mutex; -@@ -160,6 +170,7 @@ export namespace boost { namespace system { namespace errc { - using boost::system::errc::make_error_condition; - }}} - -+#if defined(BOOST_WINDOWS_API) - export namespace boost { namespace system { namespace windows_error { - using boost::system::windows_error::make_error_code; - using boost::system::windows_error::windows_error_code; -@@ -216,6 +227,7 @@ export namespace boost { namespace system { namespace windows_error { - using boost::system::windows_error::windows_error_code::write_protect; - using boost::system::windows_error::windows_error_code::wrong_disk; - }}} -+#endif - - export namespace boost { namespace variant2 { - using boost::variant2::in_place_index_t; diff --git a/patches/thread.patch b/patches/thread.patch deleted file mode 100644 index 3fd15cacd..000000000 --- a/patches/thread.patch +++ /dev/null @@ -1,41 +0,0 @@ -diff --git a/generated/exports/thread.inc b/generated/exports/thread.inc -index 1ad0748..6cf744e 100644 ---- a/generated/exports/thread.inc -+++ b/generated/exports/thread.inc -@@ -20,6 +20,15 @@ export namespace boost { - using boost::basic_lockable_adapter; - using boost::basic_poly_lockable; - using boost::broken_promise; -+ // M7c: gcc 16.1.0 module consumers emit a partial vtable for clone_impl -+ // (virtual base clone_base) whose thunk slots stay undefined — gcc never -+ // emits the thunks in a module consumer TU. These extern-template -+ // declarations suppress the consumer's implicit instantiation; the complete -+ // vtable + thunks come from the explicit instantiation in -+ // port/thread_extras.cpp (same pattern as boost_system_extras.cpp). -+ extern template class boost::exception_detail::clone_impl; -+ extern template class boost::exception_detail::clone_impl; -+ extern template class boost::exception_detail::clone_impl; - using boost::call_once; - using boost::caller_context_t; - using boost::completion_latch; -@@ -352,6 +361,7 @@ export namespace boost { namespace detail { namespace thread { - using boost::detail::thread::cleanup_func_t; - }}} - -+#if defined(_WIN32) - export namespace boost { namespace detail { namespace win32 { - using boost::detail::win32::create_anonymous_event; - using boost::detail::win32::create_anonymous_semaphore; -@@ -375,9 +385,12 @@ export namespace boost { namespace detail { namespace win32 { - using boost::detail::win32::system_info; - using boost::detail::win32::ticks_type; - }}} -+#endif - - export namespace boost { namespace detail { namespace win32 { namespace detail { -+#if defined(_WIN32) - using boost::detail::win32::detail::gettickcount64_t; -+#endif - }}}} - - export namespace boost { namespace exception_detail { diff --git a/patches/tuple.patch b/patches/tuple.patch deleted file mode 100644 index ea9603543..000000000 --- a/patches/tuple.patch +++ /dev/null @@ -1,15 +0,0 @@ -diff --git a/generated/exports/tuple.inc b/generated/exports/tuple.inc -index 6bd19cf..68a520a 100644 ---- a/generated/exports/tuple.inc -+++ b/generated/exports/tuple.inc -@@ -46,7 +46,10 @@ export namespace boost { namespace tuples { namespace detail { - using boost::tuples::detail::gt; - using boost::tuples::detail::gte; - using boost::tuples::detail::handle_width; -+#if !defined(__GNUC__) -+ // M3 hand-guard: ignore_t is a member-pointer typedef; gcc treats it as internal linkage. - using boost::tuples::detail::ignore_t; -+#endif - using boost::tuples::detail::lt; - using boost::tuples::detail::lte; - using boost::tuples::detail::make_tuple_mapper; diff --git a/patches/url.patch b/patches/url.patch deleted file mode 100644 index 2bef8ba4f..000000000 --- a/patches/url.patch +++ /dev/null @@ -1,17 +0,0 @@ -diff --git a/generated/exports/url.inc b/generated/exports/url.inc -index d1a974b..8053da1 100644 ---- a/generated/exports/url.inc -+++ b/generated/exports/url.inc -@@ -266,8 +266,12 @@ export namespace boost { namespace urls { namespace grammar { namespace detail { - using boost::urls::grammar::detail::error_cat_type; - using boost::urls::grammar::detail::find_if; - using boost::urls::grammar::detail::find_if_not; -+#if defined(BOOST_URL_USE_SSE2) -+ // M7 platform guard: charset.hpp defines the *_pred SSE2 helpers only under -+ // BOOST_URL_USE_SSE2 (x86 with SSE2); absent on arm64 (e.g. macOS). - using boost::urls::grammar::detail::find_if_not_pred; - using boost::urls::grammar::detail::find_if_pred; -+#endif - using boost::urls::grammar::detail::get; - using boost::urls::grammar::detail::has_find_if; - using boost::urls::grammar::detail::has_find_if_not; diff --git a/patches/utility.patch b/patches/utility.patch deleted file mode 100644 index b52853954..000000000 --- a/patches/utility.patch +++ /dev/null @@ -1,43 +0,0 @@ -diff --git a/generated/exports/utility.inc b/generated/exports/utility.inc -index c99e1c2..38e9acc 100644 ---- a/generated/exports/utility.inc -+++ b/generated/exports/utility.inc -@@ -3,7 +3,8 @@ - - export namespace boost { - using boost::base_from_member; -- using boost::basic_string_ref; -+ // M11: basic_string_ref dropped — declared only via string_ref.hpp (curated out of -+ // the module GMF; gcc 16.1 buffer_fill enum mismatch). - using boost::basic_string_view; - using boost::compressed_pair; - using boost::enable_if_c; -@@ -37,7 +38,8 @@ export namespace boost { - using boost::operator>; - using boost::operator>=; - using boost::result_of; -- using boost::string_ref; -+ // M11: string_ref dropped — declared only via string_ref.hpp (curated out of -+ // the module GMF; gcc 16.1 buffer_fill enum mismatch). - using boost::string_view; - using boost::swap; - using boost::tr1_result_of; -@@ -53,12 +55,15 @@ export namespace boost { - using boost::typed_in_place_factory8; - using boost::typed_in_place_factory9; - using boost::typed_in_place_factory_base; -- using boost::u16string_ref; -+ // M11: u16string_ref dropped — declared only via string_ref.hpp (curated out of -+ // the module GMF; gcc 16.1 buffer_fill enum mismatch). - using boost::u16string_view; -- using boost::u32string_ref; -+ // M11: u32string_ref dropped — declared only via string_ref.hpp (curated out of -+ // the module GMF; gcc 16.1 buffer_fill enum mismatch). - using boost::u32string_view; - using boost::value_initialized; -- using boost::wstring_ref; -+ // M11: wstring_ref dropped — declared only via string_ref.hpp (curated out of -+ // the module GMF; gcc 16.1 buffer_fill enum mismatch). - using boost::wstring_view; - } - diff --git a/patches/variant.patch b/patches/variant.patch deleted file mode 100644 index 2b131d148..000000000 --- a/patches/variant.patch +++ /dev/null @@ -1,44 +0,0 @@ -diff --git a/generated/exports/variant.inc b/generated/exports/variant.inc -index a75569c..3cdc92b 100644 ---- a/generated/exports/variant.inc -+++ b/generated/exports/variant.inc -@@ -293,8 +293,11 @@ export namespace boost { namespace mpl { namespace aux { - using boost::mpl::aux::advance_backward; - using boost::mpl::aux::advance_forward; - using boost::mpl::aux::and_impl; -+#if defined(__GNUC__) -+ // M3 hand-guard: gcc-preprocessed mpl headers only (BOOST_MPL_CFG_COMPILER_DIR=gcc). - using boost::mpl::aux::arity_helper; - using boost::mpl::aux::arity_tag; -+#endif - using boost::mpl::aux::begin_type; - using boost::mpl::aux::cast1st_impl; - using boost::mpl::aux::cast2nd_impl; -@@ -329,10 +332,16 @@ export namespace boost { namespace mpl { namespace aux { - using boost::mpl::aux::le_result4; - using boost::mpl::aux::le_result5; - using boost::mpl::aux::list_tag; -+#if defined(__GNUC__) -+ // M3 hand-guard: as above (max_arity). - using boost::mpl::aux::max_arity; -+#endif - using boost::mpl::aux::msvc_eti_base; - using boost::mpl::aux::msvc_type; -+#if defined(__GNUC__) -+ // M3 hand-guard: as above (nested_type_wknd). - using boost::mpl::aux::nested_type_wknd; -+#endif - using boost::mpl::aux::no_tag; - using boost::mpl::aux::not_impl; - using boost::mpl::aux::or_impl; -@@ -346,7 +355,10 @@ export namespace boost { namespace mpl { namespace aux { - using boost::mpl::aux::sequence_tag_impl; - using boost::mpl::aux::tag_impl; - using boost::mpl::aux::template_arity; -+#if defined(__GNUC__) -+ // M3 hand-guard: as above (template_arity_impl). - using boost::mpl::aux::template_arity_impl; -+#endif - using boost::mpl::aux::transform1_impl; - using boost::mpl::aux::transform2_impl; - using boost::mpl::aux::type_wrapper; diff --git a/patches/winapi.patch b/patches/winapi.patch deleted file mode 100644 index b98ae976b..000000000 --- a/patches/winapi.patch +++ /dev/null @@ -1,26 +0,0 @@ -diff --git a/src/winapi.cppm b/src/winapi.cppm -index d4b1ae7..8d03e9e 100644 ---- a/src/winapi.cppm -+++ b/src/winapi.cppm -@@ -1,5 +1,7 @@ - // GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) - module; -+// M9 platform guard: boost/winapi/* #error off-Windows (basic_types.hpp). -+#if defined(_WIN32) || defined(__CYGWIN__) - #include - #include - #include -@@ -33,10 +35,13 @@ module; - #include - #include - #include -+#endif - - export module mcpplibs.mwrap.boost.winapi; - - export import mcpplibs.mwrap.boost.config; - -+#if defined(_WIN32) || defined(__CYGWIN__) - #include "../generated/exports/winapi.inc" -+#endif - diff --git a/src/accumulators.cppm b/src/accumulators.cppm index 118da9c4b..377cc6af8 100644 --- a/src/accumulators.cppm +++ b/src/accumulators.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.accumulators — module facade over generated/exports/accumulators.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -7,10 +8,14 @@ module; export module mcpplibs.mwrap.boost.accumulators; +export import mcpplibs.mwrap.boost.array; export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.circular_buffer; +export import mcpplibs.mwrap.boost.concept_check; export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; +export import mcpplibs.mwrap.boost.iterator; +export import mcpplibs.mwrap.boost.mp11; export import mcpplibs.mwrap.boost.numeric; export import mcpplibs.mwrap.boost.type_traits; export import mcpplibs.mwrap.boost.utility; diff --git a/src/algorithm.cppm b/src/algorithm.cppm index 9eb5c672b..4a6c72889 100644 --- a/src/algorithm.cppm +++ b/src/algorithm.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.algorithm — module facade over generated/exports/algorithm.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) // NB: string_regex.hpp is NOT in the GFM (replaced by the string.hpp // aggregate): gcc 16.1.0 rejects the boost::regex v5 abi-tag surface inside a // module interface ("mismatching abi tags for get_catalog_name_inst") even @@ -47,9 +48,16 @@ module; export module mcpplibs.mwrap.boost.algorithm; +export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.bind; +export import mcpplibs.mwrap.boost.concept_check; +export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; +export import mcpplibs.mwrap.boost.function; export import mcpplibs.mwrap.boost.iterator; export import mcpplibs.mwrap.boost.range; +export import mcpplibs.mwrap.boost.smart_ptr; +export import mcpplibs.mwrap.boost.throw_exception; export import mcpplibs.mwrap.boost.tuple; export import mcpplibs.mwrap.boost.type_traits; diff --git a/src/align.cppm b/src/align.cppm index 636551703..8e5120faa 100644 --- a/src/align.cppm +++ b/src/align.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.align — module facade over generated/exports/align.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/any.cppm b/src/any.cppm index bfcc197b2..a62c2c989 100644 --- a/src/any.cppm +++ b/src/any.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.any — module facade over generated/exports/any.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -6,5 +7,10 @@ module; export module mcpplibs.mwrap.boost.any; +export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.config; +export import mcpplibs.mwrap.boost.throw_exception; +export import mcpplibs.mwrap.boost.type_index; + #include "../generated/exports/any.inc" diff --git a/src/array.cppm b/src/array.cppm index 1cd54f151..7ccd3545d 100644 --- a/src/array.cppm +++ b/src/array.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.array — module facade over generated/exports/array.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/asio.cppm b/src/asio.cppm index 357d53ebe..0a22ca49f 100644 --- a/src/asio.cppm +++ b/src/asio.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.asio — module facade over generated/exports/asio.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -22,7 +23,9 @@ export module mcpplibs.mwrap.boost.asio; export import mcpplibs.mwrap.boost.align; export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.date_time; +export import mcpplibs.mwrap.boost.smart_ptr; export import mcpplibs.mwrap.boost.system; +export import mcpplibs.mwrap.boost.type_traits; #include "../generated/exports/asio.inc" diff --git a/src/assert.cppm b/src/assert.cppm index 4f05a4a0c..665e7abe9 100644 --- a/src/assert.cppm +++ b/src/assert.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.assert — module facade over generated/exports/assert.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/assign.cppm b/src/assign.cppm index ca06686b5..0550bf44d 100644 --- a/src/assign.cppm +++ b/src/assign.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.assign — module facade over generated/exports/assign.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/atomic.cppm b/src/atomic.cppm index a4adb2319..24bbb05d0 100644 --- a/src/atomic.cppm +++ b/src/atomic.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.atomic — module facade over generated/exports/atomic.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/beast.cppm b/src/beast.cppm index e3a8f6503..572f72719 100644 --- a/src/beast.cppm +++ b/src/beast.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.beast — module facade over generated/exports/beast.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -16,15 +17,19 @@ export module mcpplibs.mwrap.boost.beast; export import mcpplibs.mwrap.boost.asio; export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.config; +export import mcpplibs.mwrap.boost.container_hash; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.endian; +export import mcpplibs.mwrap.boost.intrusive; export import mcpplibs.mwrap.boost.logic; +export import mcpplibs.mwrap.boost.mp11; export import mcpplibs.mwrap.boost.optional; export import mcpplibs.mwrap.boost.smart_ptr; export import mcpplibs.mwrap.boost.static_string; export import mcpplibs.mwrap.boost.system; export import mcpplibs.mwrap.boost.throw_exception; export import mcpplibs.mwrap.boost.type_index; +export import mcpplibs.mwrap.boost.utility; export import mcpplibs.mwrap.boost.winapi; #include "../generated/exports/beast.inc" diff --git a/src/bimap.cppm b/src/bimap.cppm index 9b6c51458..bb53aea64 100644 --- a/src/bimap.cppm +++ b/src/bimap.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.bimap — module facade over generated/exports/bimap.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/bind.cppm b/src/bind.cppm index 31d91294f..3482a49a7 100644 --- a/src/bind.cppm +++ b/src/bind.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.bind — module facade over generated/exports/bind.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/bloom.cppm b/src/bloom.cppm index 525b45c46..5a9f6e180 100644 --- a/src/bloom.cppm +++ b/src/bloom.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.bloom — module facade over generated/exports/bloom.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/callable_traits.cppm b/src/callable_traits.cppm index be1fcfaf7..f7b4040cb 100644 --- a/src/callable_traits.cppm +++ b/src/callable_traits.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.callable_traits — module facade over generated/exports/callable_traits.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/charconv.cppm b/src/charconv.cppm index 2135720ee..833107083 100644 --- a/src/charconv.cppm +++ b/src/charconv.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.charconv — module facade over generated/exports/charconv.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/chrono.cppm b/src/chrono.cppm index 19c136fc5..eb2407e78 100644 --- a/src/chrono.cppm +++ b/src/chrono.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.chrono — module facade over generated/exports/chrono.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/circular_buffer.cppm b/src/circular_buffer.cppm index eb3b9ae70..603a41218 100644 --- a/src/circular_buffer.cppm +++ b/src/circular_buffer.cppm @@ -1,12 +1,15 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.circular_buffer — module facade over generated/exports/circular_buffer.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include export module mcpplibs.mwrap.boost.circular_buffer; export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.concept_check; export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; +export import mcpplibs.mwrap.boost.move; export import mcpplibs.mwrap.boost.type_traits; #include "../generated/exports/circular_buffer.inc" diff --git a/src/cobalt.cppm b/src/cobalt.cppm index 027c781ef..6e65bcdc5 100644 --- a/src/cobalt.cppm +++ b/src/cobalt.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.cobalt — module facade over generated/exports/cobalt.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include // M11 platform guard (POSIX): asio reactor/hash_map details were only @@ -34,6 +35,7 @@ export import mcpplibs.mwrap.boost.mp11; export import mcpplibs.mwrap.boost.smart_ptr; export import mcpplibs.mwrap.boost.static_string; export import mcpplibs.mwrap.boost.system; +export import mcpplibs.mwrap.boost.utility; export import mcpplibs.mwrap.boost.variant2; #include "../generated/exports/cobalt.inc" diff --git a/src/compat.cppm b/src/compat.cppm index fb7e7c736..774dfa846 100644 --- a/src/compat.cppm +++ b/src/compat.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.compat — module facade over generated/exports/compat.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/concept_check.cppm b/src/concept_check.cppm index 8be8f6d2b..797c0dd31 100644 --- a/src/concept_check.cppm +++ b/src/concept_check.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.concept_check — module facade over generated/exports/concept_check.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/config.cppm b/src/config.cppm index f7c3ecd8e..ae6175f02 100644 --- a/src/config.cppm +++ b/src/config.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.config — module facade over generated/exports/config.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/container.cppm b/src/container.cppm index bac138a0b..6495d872c 100644 --- a/src/container.cppm +++ b/src/container.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.container — module facade over generated/exports/container.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/container_hash.cppm b/src/container_hash.cppm index b53a58bdb..c39c92625 100644 --- a/src/container_hash.cppm +++ b/src/container_hash.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.container_hash — module facade over generated/exports/container_hash.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/contract.cppm b/src/contract.cppm index 28984bd33..38f96b24b 100644 --- a/src/contract.cppm +++ b/src/contract.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.contract — module facade over generated/exports/contract.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/convert.cppm b/src/convert.cppm index fc3ed7ef8..950a625b5 100644 --- a/src/convert.cppm +++ b/src/convert.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.convert — module facade over generated/exports/convert.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/core.cppm b/src/core.cppm index 593998bd7..597a93dc8 100644 --- a/src/core.cppm +++ b/src/core.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized). +// mcpplibs.mwrap.boost.core — module facade over generated/exports/core.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) // // C5 (2026-09-09): BOOST_VERSION / BOOST_LIB_VERSION moved out of this module // to a dedicated `mcpplibs.mwrap.boost.version` module (src/version.cppm — LIBS_SPECIAL tier @@ -50,5 +51,9 @@ module; export module mcpplibs.mwrap.boost.core; +export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.config; +export import mcpplibs.mwrap.boost.throw_exception; + #include "../generated/exports/core.inc" diff --git a/src/crc.cppm b/src/crc.cppm index 281e04862..4de1a9aac 100644 --- a/src/crc.cppm +++ b/src/crc.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.crc — module facade over generated/exports/crc.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/date_time.cppm b/src/date_time.cppm index 9d5cc515c..9b3f5f0f5 100644 --- a/src/date_time.cppm +++ b/src/date_time.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.date_time — module facade over generated/exports/date_time.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -14,6 +15,7 @@ export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.io; export import mcpplibs.mwrap.boost.iterator; export import mcpplibs.mwrap.boost.numeric; +export import mcpplibs.mwrap.boost.smart_ptr; export import mcpplibs.mwrap.boost.throw_exception; export import mcpplibs.mwrap.boost.tokenizer; export import mcpplibs.mwrap.boost.type_traits; diff --git a/src/decimal.cppm b/src/decimal.cppm index ed39067d1..21b86b7ca 100644 --- a/src/decimal.cppm +++ b/src/decimal.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.decimal — module facade over generated/exports/decimal.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/dll.cppm b/src/dll.cppm index 65b5c43fe..f3d46016d 100644 --- a/src/dll.cppm +++ b/src/dll.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.dll — module facade over generated/exports/dll.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -9,6 +10,7 @@ export module mcpplibs.mwrap.boost.dll; export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.filesystem; +export import mcpplibs.mwrap.boost.io; export import mcpplibs.mwrap.boost.type_index; export import mcpplibs.mwrap.boost.winapi; diff --git a/src/dynamic_bitset.cppm b/src/dynamic_bitset.cppm index 74fc05a8f..215c17aaa 100644 --- a/src/dynamic_bitset.cppm +++ b/src/dynamic_bitset.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.dynamic_bitset — module facade over generated/exports/dynamic_bitset.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -6,6 +7,7 @@ module; export module mcpplibs.mwrap.boost.dynamic_bitset; export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.container_hash; export import mcpplibs.mwrap.boost.core; #include "../generated/exports/dynamic_bitset.inc" diff --git a/src/endian.cppm b/src/endian.cppm index b57b1e0dd..c9073a235 100644 --- a/src/endian.cppm +++ b/src/endian.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.endian — module facade over generated/exports/endian.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/filesystem.cppm b/src/filesystem.cppm index c417576e0..571eb6b2a 100644 --- a/src/filesystem.cppm +++ b/src/filesystem.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.filesystem — module facade over generated/exports/filesystem.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -6,6 +7,7 @@ module; export module mcpplibs.mwrap.boost.filesystem; +export import mcpplibs.mwrap.boost.container_hash; export import mcpplibs.mwrap.boost.io; export import mcpplibs.mwrap.boost.iterator; export import mcpplibs.mwrap.boost.smart_ptr; diff --git a/src/flyweight.cppm b/src/flyweight.cppm index 66854fc08..bdd9533da 100644 --- a/src/flyweight.cppm +++ b/src/flyweight.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.flyweight — module facade over generated/exports/flyweight.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -13,6 +14,7 @@ export module mcpplibs.mwrap.boost.flyweight; export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.config; +export import mcpplibs.mwrap.boost.container_hash; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.interprocess; export import mcpplibs.mwrap.boost.mp11; diff --git a/src/format.cppm b/src/format.cppm index 17120aa95..81be52cf3 100644 --- a/src/format.cppm +++ b/src/format.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.format — module facade over generated/exports/format.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/function.cppm b/src/function.cppm index 6d9d26692..37c128b4f 100644 --- a/src/function.cppm +++ b/src/function.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.function — module facade over generated/exports/function.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -17,6 +18,7 @@ module; export module mcpplibs.mwrap.boost.function; export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.bind; export import mcpplibs.mwrap.boost.core; #include "../generated/exports/function.inc" diff --git a/src/functional.cppm b/src/functional.cppm index b2d1ced4e..5ad6f9daf 100644 --- a/src/functional.cppm +++ b/src/functional.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.functional — module facade over generated/exports/functional.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/geometry.cppm b/src/geometry.cppm index 206e7be51..99d0ab1e5 100644 --- a/src/geometry.cppm +++ b/src/geometry.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.geometry — module facade over generated/exports/geometry.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -103,8 +104,10 @@ export import mcpplibs.mwrap.boost.polygon; export import mcpplibs.mwrap.boost.qvm; export import mcpplibs.mwrap.boost.range; export import mcpplibs.mwrap.boost.rational; +export import mcpplibs.mwrap.boost.smart_ptr; export import mcpplibs.mwrap.boost.thread; export import mcpplibs.mwrap.boost.throw_exception; +export import mcpplibs.mwrap.boost.tokenizer; export import mcpplibs.mwrap.boost.tuple; export import mcpplibs.mwrap.boost.type_traits; export import mcpplibs.mwrap.boost.unordered; diff --git a/src/gil.cppm b/src/gil.cppm index 110d0892d..497df492e 100644 --- a/src/gil.cppm +++ b/src/gil.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.gil — module facade over generated/exports/gil.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -22,11 +23,14 @@ module; export module mcpplibs.mwrap.boost.gil; export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.concept_check; export import mcpplibs.mwrap.boost.config; +export import mcpplibs.mwrap.boost.container_hash; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.integer; export import mcpplibs.mwrap.boost.iterator; export import mcpplibs.mwrap.boost.mp11; +export import mcpplibs.mwrap.boost.type_traits; export import mcpplibs.mwrap.boost.variant2; #include "../generated/exports/gil.inc" diff --git a/src/graph.cppm b/src/graph.cppm index 0f5ef3ec4..4869e2701 100644 --- a/src/graph.cppm +++ b/src/graph.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.graph — module facade over generated/exports/graph.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/hana.cppm b/src/hana.cppm index d018dd384..bb953f29f 100644 --- a/src/hana.cppm +++ b/src/hana.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.hana — module facade over generated/exports/hana.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/hash2.cppm b/src/hash2.cppm index 4f47b333e..8cdb2d540 100644 --- a/src/hash2.cppm +++ b/src/hash2.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.hash2 — module facade over generated/exports/hash2.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/heap.cppm b/src/heap.cppm index 73669d5d1..5d135d9e2 100644 --- a/src/heap.cppm +++ b/src/heap.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.heap — module facade over generated/exports/heap.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/histogram.cppm b/src/histogram.cppm index 13fa52dce..66f03dfed 100644 --- a/src/histogram.cppm +++ b/src/histogram.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.histogram — module facade over generated/exports/histogram.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/hof.cppm b/src/hof.cppm index 7be645d5b..6c31a4041 100644 --- a/src/hof.cppm +++ b/src/hof.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.hof — module facade over generated/exports/hof.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/icl.cppm b/src/icl.cppm index 1dc462c5a..3aa10cdd4 100644 --- a/src/icl.cppm +++ b/src/icl.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.icl — module facade over generated/exports/icl.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -23,6 +24,7 @@ export import mcpplibs.mwrap.boost.date_time; export import mcpplibs.mwrap.boost.io; export import mcpplibs.mwrap.boost.iterator; export import mcpplibs.mwrap.boost.rational; +export import mcpplibs.mwrap.boost.smart_ptr; export import mcpplibs.mwrap.boost.type_traits; export import mcpplibs.mwrap.boost.utility; diff --git a/src/integer.cppm b/src/integer.cppm index 329391acc..347a9547d 100644 --- a/src/integer.cppm +++ b/src/integer.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.integer — module facade over generated/exports/integer.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/interprocess.cppm b/src/interprocess.cppm index b88a15015..b4ba43f9e 100644 --- a/src/interprocess.cppm +++ b/src/interprocess.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.interprocess — module facade over generated/exports/interprocess.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/intrusive.cppm b/src/intrusive.cppm index ab44a63a8..db350a21d 100644 --- a/src/intrusive.cppm +++ b/src/intrusive.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.intrusive — module facade over generated/exports/intrusive.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/io.cppm b/src/io.cppm index aabe5672f..e8b014b8d 100644 --- a/src/io.cppm +++ b/src/io.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.io — module facade over generated/exports/io.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -9,5 +10,7 @@ module; export module mcpplibs.mwrap.boost.io; +export import mcpplibs.mwrap.boost.config; + #include "../generated/exports/io.inc" diff --git a/src/iostreams.cppm b/src/iostreams.cppm index 17160abf4..3094a9b8b 100644 --- a/src/iostreams.cppm +++ b/src/iostreams.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.iostreams — module facade over generated/exports/iostreams.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -22,6 +23,7 @@ module; export module mcpplibs.mwrap.boost.iostreams; export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.concept_check; export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.iterator; diff --git a/src/iterator.cppm b/src/iterator.cppm index bb0116d14..ee9a1dca7 100644 --- a/src/iterator.cppm +++ b/src/iterator.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.iterator — module facade over generated/exports/iterator.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -9,7 +10,6 @@ module; #include #include #include -#include #include #include #include @@ -22,10 +22,15 @@ module; export module mcpplibs.mwrap.boost.iterator; +export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.concept_check; +export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.mp11; export import mcpplibs.mwrap.boost.optional; +export import mcpplibs.mwrap.boost.tuple; export import mcpplibs.mwrap.boost.type_traits; +export import mcpplibs.mwrap.boost.utility; #include "../generated/exports/iterator.inc" diff --git a/src/json.cppm b/src/json.cppm index 12b8675b0..42948ad3a 100644 --- a/src/json.cppm +++ b/src/json.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.json — module facade over generated/exports/json.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/lambda.cppm b/src/lambda.cppm index ee9b54586..3cb14c6b0 100644 --- a/src/lambda.cppm +++ b/src/lambda.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.lambda — module facade over generated/exports/lambda.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/lambda2.cppm b/src/lambda2.cppm index aef78cb30..9df266fd0 100644 --- a/src/lambda2.cppm +++ b/src/lambda2.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.lambda2 — module facade over generated/exports/lambda2.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/leaf.cppm b/src/leaf.cppm index 05a9c1687..2a729d659 100644 --- a/src/leaf.cppm +++ b/src/leaf.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.leaf — module facade over generated/exports/leaf.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/lexical_cast.cppm b/src/lexical_cast.cppm index 3e6d36c79..c2a430535 100644 --- a/src/lexical_cast.cppm +++ b/src/lexical_cast.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.lexical_cast — module facade over generated/exports/lexical_cast.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/lockfree.cppm b/src/lockfree.cppm index abb1d74c1..3c2a90439 100644 --- a/src/lockfree.cppm +++ b/src/lockfree.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.lockfree — module facade over generated/exports/lockfree.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/logic.cppm b/src/logic.cppm index 1d0cee46b..f32868397 100644 --- a/src/logic.cppm +++ b/src/logic.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.logic — module facade over generated/exports/logic.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/math.cppm b/src/math.cppm index 636391152..6d779d4d6 100644 --- a/src/math.cppm +++ b/src/math.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.math — module facade over generated/exports/math.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/move.cppm b/src/move.cppm index 837e5ea92..93b9e2684 100644 --- a/src/move.cppm +++ b/src/move.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.move — module facade over generated/exports/move.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/mp11.cppm b/src/mp11.cppm index a5d70baee..c0dab5d1b 100644 --- a/src/mp11.cppm +++ b/src/mp11.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.mp11 — module facade over generated/exports/mp11.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/mqtt5.cppm b/src/mqtt5.cppm index 043d54c0f..a442d9f72 100644 --- a/src/mqtt5.cppm +++ b/src/mqtt5.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.mqtt5 — module facade over generated/exports/mqtt5.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -14,6 +15,8 @@ export import mcpplibs.mwrap.boost.random; export import mcpplibs.mwrap.boost.smart_ptr; export import mcpplibs.mwrap.boost.static_string; export import mcpplibs.mwrap.boost.system; +export import mcpplibs.mwrap.boost.type_traits; +export import mcpplibs.mwrap.boost.utility; #include "../generated/exports/mqtt5.inc" diff --git a/src/multi_array.cppm b/src/multi_array.cppm index e401a4a43..e68dda340 100644 --- a/src/multi_array.cppm +++ b/src/multi_array.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.multi_array — module facade over generated/exports/multi_array.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/multi_index.cppm b/src/multi_index.cppm index 3fcad0aab..bca954ac8 100644 --- a/src/multi_index.cppm +++ b/src/multi_index.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.multi_index — module facade over generated/exports/multi_index.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/multiprecision.cppm b/src/multiprecision.cppm index 7cc6d5f36..d0f413887 100644 --- a/src/multiprecision.cppm +++ b/src/multiprecision.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.multiprecision — module facade over generated/exports/multiprecision.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -19,6 +20,7 @@ module; export module mcpplibs.mwrap.boost.multiprecision; export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.io; export import mcpplibs.mwrap.boost.math; export import mcpplibs.mwrap.boost.random; diff --git a/src/nowide.cppm b/src/nowide.cppm index 31442fbcf..1d6f08b1c 100644 --- a/src/nowide.cppm +++ b/src/nowide.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.nowide — module facade over generated/exports/nowide.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -19,6 +20,7 @@ export module mcpplibs.mwrap.boost.nowide; export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.filesystem; +export import mcpplibs.mwrap.boost.io; #include "../generated/exports/nowide.inc" diff --git a/src/numeric.cppm b/src/numeric.cppm index 2acc9f6bc..7b5a63702 100644 --- a/src/numeric.cppm +++ b/src/numeric.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.numeric — module facade over generated/exports/numeric.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -58,6 +59,7 @@ module; export module mcpplibs.mwrap.boost.numeric; export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.concept_check; export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.iterator; diff --git a/src/optional.cppm b/src/optional.cppm index 2ad6aafad..ebe3783fe 100644 --- a/src/optional.cppm +++ b/src/optional.cppm @@ -1,10 +1,13 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.optional — module facade over generated/exports/optional.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include export module mcpplibs.mwrap.boost.optional; +export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.type_traits; diff --git a/src/outcome.cppm b/src/outcome.cppm index 3efcbef44..44cf93f87 100644 --- a/src/outcome.cppm +++ b/src/outcome.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.outcome — module facade over generated/exports/outcome.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/parser.cppm b/src/parser.cppm index 9a94de3c4..0de8fd74a 100644 --- a/src/parser.cppm +++ b/src/parser.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.parser — module facade over generated/exports/parser.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/pfr.cppm b/src/pfr.cppm index f664a873b..7dccbdd97 100644 --- a/src/pfr.cppm +++ b/src/pfr.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.pfr — module facade over generated/exports/pfr.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/poly_collection.cppm b/src/poly_collection.cppm index 058a1bc56..fdba985f1 100644 --- a/src/poly_collection.cppm +++ b/src/poly_collection.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.poly_collection — module facade over generated/exports/poly_collection.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -14,6 +15,7 @@ export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.iterator; export import mcpplibs.mwrap.boost.mp11; +export import mcpplibs.mwrap.boost.smart_ptr; export import mcpplibs.mwrap.boost.type_erasure; export import mcpplibs.mwrap.boost.type_traits; diff --git a/src/polygon.cppm b/src/polygon.cppm index 188e75f97..5be612f83 100644 --- a/src/polygon.cppm +++ b/src/polygon.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.polygon — module facade over generated/exports/polygon.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/pool.cppm b/src/pool.cppm index 58b38d2bb..763e2020d 100644 --- a/src/pool.cppm +++ b/src/pool.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.pool — module facade over generated/exports/pool.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -9,6 +10,7 @@ export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.integer; export import mcpplibs.mwrap.boost.throw_exception; +export import mcpplibs.mwrap.boost.type_traits; #include "../generated/exports/pool.inc" diff --git a/src/process.cppm b/src/process.cppm index 4cf4aff1b..e844de9dc 100644 --- a/src/process.cppm +++ b/src/process.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.process — module facade over generated/exports/process.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -31,9 +32,11 @@ export module mcpplibs.mwrap.boost.process; export import mcpplibs.mwrap.boost.asio; export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.concept_check; export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.filesystem; +export import mcpplibs.mwrap.boost.io; export import mcpplibs.mwrap.boost.iterator; export import mcpplibs.mwrap.boost.system; export import mcpplibs.mwrap.boost.type_traits; diff --git a/src/program_options.cppm b/src/program_options.cppm index 6977f7522..da1ee7519 100644 --- a/src/program_options.cppm +++ b/src/program_options.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.program_options — module facade over generated/exports/program_options.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/property_map.cppm b/src/property_map.cppm index 63f2b709a..582ee7b62 100644 --- a/src/property_map.cppm +++ b/src/property_map.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.property_map — module facade over generated/exports/property_map.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/property_tree.cppm b/src/property_tree.cppm index eaf2b6532..0136c0fa8 100644 --- a/src/property_tree.cppm +++ b/src/property_tree.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.property_tree — module facade over generated/exports/property_tree.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -11,6 +12,7 @@ export module mcpplibs.mwrap.boost.property_tree; export import mcpplibs.mwrap.boost.any; export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.bind; +export import mcpplibs.mwrap.boost.concept_check; export import mcpplibs.mwrap.boost.optional; export import mcpplibs.mwrap.boost.range; export import mcpplibs.mwrap.boost.serialization; diff --git a/src/ptr_container.cppm b/src/ptr_container.cppm index 40607a788..ab8691471 100644 --- a/src/ptr_container.cppm +++ b/src/ptr_container.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.ptr_container — module facade over generated/exports/ptr_container.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/qvm.cppm b/src/qvm.cppm index 935117dcc..2d57ec19c 100644 --- a/src/qvm.cppm +++ b/src/qvm.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.qvm — module facade over generated/exports/qvm.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/random.cppm b/src/random.cppm index f07142d1e..7e8410792 100644 --- a/src/random.cppm +++ b/src/random.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.random — module facade over generated/exports/random.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/range.cppm b/src/range.cppm index bbb6831a8..593dba629 100644 --- a/src/range.cppm +++ b/src/range.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.range — module facade over generated/exports/range.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -23,7 +24,12 @@ module; export module mcpplibs.mwrap.boost.range; +export import mcpplibs.mwrap.boost.array; +export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.concept_check; +export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; +export import mcpplibs.mwrap.boost.functional; export import mcpplibs.mwrap.boost.iterator; export import mcpplibs.mwrap.boost.optional; export import mcpplibs.mwrap.boost.tuple; diff --git a/src/ratio.cppm b/src/ratio.cppm index ab66de00b..9a1a75816 100644 --- a/src/ratio.cppm +++ b/src/ratio.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.ratio — module facade over generated/exports/ratio.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/rational.cppm b/src/rational.cppm index ab3360f24..c87386849 100644 --- a/src/rational.cppm +++ b/src/rational.cppm @@ -1,10 +1,16 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.rational — module facade over generated/exports/rational.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include export module mcpplibs.mwrap.boost.rational; +export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.config; +export import mcpplibs.mwrap.boost.integer; +export import mcpplibs.mwrap.boost.throw_exception; export import mcpplibs.mwrap.boost.type_traits; +export import mcpplibs.mwrap.boost.utility; #include "../generated/exports/rational.inc" diff --git a/src/regex.cppm b/src/regex.cppm index 997ea38ba..9b59df6d1 100644 --- a/src/regex.cppm +++ b/src/regex.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.regex — module facade over generated/exports/regex.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/safe_numerics.cppm b/src/safe_numerics.cppm index 09089af23..916d922e3 100644 --- a/src/safe_numerics.cppm +++ b/src/safe_numerics.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.safe_numerics — module facade over generated/exports/safe_numerics.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; // M9: checked_result_operations.hpp uses std::terminate without ; // libstdc++/libc++ doesn't transitively include it (MSVC STL does). diff --git a/src/scope.cppm b/src/scope.cppm index 915fdb925..e3a3d987c 100644 --- a/src/scope.cppm +++ b/src/scope.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.scope — module facade over generated/exports/scope.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/serialization.cppm b/src/serialization.cppm index 053729dd0..8df6a9704 100644 --- a/src/serialization.cppm +++ b/src/serialization.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.serialization — module facade over generated/exports/serialization.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/signals2.cppm b/src/signals2.cppm index b99cb1450..e7f551e9a 100644 --- a/src/signals2.cppm +++ b/src/signals2.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.signals2 — module facade over generated/exports/signals2.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -6,9 +7,11 @@ module; export module mcpplibs.mwrap.boost.signals2; export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.bind; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.function; export import mcpplibs.mwrap.boost.iterator; +export import mcpplibs.mwrap.boost.move; export import mcpplibs.mwrap.boost.mp11; export import mcpplibs.mwrap.boost.optional; export import mcpplibs.mwrap.boost.smart_ptr; diff --git a/src/smart_ptr.cppm b/src/smart_ptr.cppm index 8cbf324bd..057e9fb5c 100644 --- a/src/smart_ptr.cppm +++ b/src/smart_ptr.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.smart_ptr — module facade over generated/exports/smart_ptr.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/sort.cppm b/src/sort.cppm index 9b931204c..0da22f89b 100644 --- a/src/sort.cppm +++ b/src/sort.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.sort — module facade over generated/exports/sort.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/stacktrace.cppm b/src/stacktrace.cppm index 47e700547..1fa315f37 100644 --- a/src/stacktrace.cppm +++ b/src/stacktrace.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.stacktrace — module facade over generated/exports/stacktrace.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; // M4: BOOST_STACKTRACE_LINK 切到外链模式, 定义来自 libs/stacktrace/src/basic.cpp — 2026-08-11-m4-compiled-libs.md §3 #define BOOST_STACKTRACE_LINK @@ -7,6 +8,7 @@ module; export module mcpplibs.mwrap.boost.stacktrace; export import mcpplibs.mwrap.boost.config; +export import mcpplibs.mwrap.boost.container_hash; #include "../generated/exports/stacktrace.inc" diff --git a/src/statechart.cppm b/src/statechart.cppm index 17abde6ff..73c564ae1 100644 --- a/src/statechart.cppm +++ b/src/statechart.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.statechart — module facade over generated/exports/statechart.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -15,6 +16,7 @@ export module mcpplibs.mwrap.boost.statechart; export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; +export import mcpplibs.mwrap.boost.function; export import mcpplibs.mwrap.boost.smart_ptr; export import mcpplibs.mwrap.boost.thread; export import mcpplibs.mwrap.boost.throw_exception; diff --git a/src/static_string.cppm b/src/static_string.cppm index ba6cf9586..52b24ad33 100644 --- a/src/static_string.cppm +++ b/src/static_string.cppm @@ -1,11 +1,14 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.static_string — module facade over generated/exports/static_string.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include export module mcpplibs.mwrap.boost.static_string; +export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.container_hash; export import mcpplibs.mwrap.boost.core; +export import mcpplibs.mwrap.boost.utility; #include "../generated/exports/static_string.inc" diff --git a/src/stl_interfaces.cppm b/src/stl_interfaces.cppm index ab1b1e83a..61a15c8d9 100644 --- a/src/stl_interfaces.cppm +++ b/src/stl_interfaces.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.stl_interfaces — module facade over generated/exports/stl_interfaces.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/system.cppm b/src/system.cppm index 19adc536d..a0a94864a 100644 --- a/src/system.cppm +++ b/src/system.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.system — module facade over generated/exports/system.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/thread.cppm b/src/thread.cppm index 6f1de826d..b339dfb9d 100644 --- a/src/thread.cppm +++ b/src/thread.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.thread — module facade over generated/exports/thread.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -46,6 +47,7 @@ export module mcpplibs.mwrap.boost.thread; export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.atomic; export import mcpplibs.mwrap.boost.chrono; +export import mcpplibs.mwrap.boost.concept_check; export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.date_time; diff --git a/src/throw_exception.cppm b/src/throw_exception.cppm index 4b29474a6..3c38b3aee 100644 --- a/src/throw_exception.cppm +++ b/src/throw_exception.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.throw_exception — module facade over generated/exports/throw_exception.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/timer.cppm b/src/timer.cppm index 68e2ac74e..8f5fa56d0 100644 --- a/src/timer.cppm +++ b/src/timer.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.timer — module facade over generated/exports/timer.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/tokenizer.cppm b/src/tokenizer.cppm index 0e481df83..37fe71df4 100644 --- a/src/tokenizer.cppm +++ b/src/tokenizer.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.tokenizer — module facade over generated/exports/tokenizer.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include diff --git a/src/tuple.cppm b/src/tuple.cppm index 06f951bc4..dcf337917 100644 --- a/src/tuple.cppm +++ b/src/tuple.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.tuple — module facade over generated/exports/tuple.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -6,6 +7,7 @@ module; export module mcpplibs.mwrap.boost.tuple; export import mcpplibs.mwrap.boost.core; +export import mcpplibs.mwrap.boost.type_traits; #include "../generated/exports/tuple.inc" diff --git a/src/type_erasure.cppm b/src/type_erasure.cppm index 96b344353..862f2daf5 100644 --- a/src/type_erasure.cppm +++ b/src/type_erasure.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.type_erasure — module facade over generated/exports/type_erasure.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -16,6 +17,7 @@ export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.iterator; +export import mcpplibs.mwrap.boost.mp11; export import mcpplibs.mwrap.boost.smart_ptr; export import mcpplibs.mwrap.boost.throw_exception; export import mcpplibs.mwrap.boost.type_traits; diff --git a/src/type_index.cppm b/src/type_index.cppm index b7705b26f..08df29918 100644 --- a/src/type_index.cppm +++ b/src/type_index.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.type_index — module facade over generated/exports/type_index.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/type_traits.cppm b/src/type_traits.cppm index 3b083e460..54f6c27b1 100644 --- a/src/type_traits.cppm +++ b/src/type_traits.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.type_traits — module facade over generated/exports/type_traits.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -25,5 +26,7 @@ module; export module mcpplibs.mwrap.boost.type_traits; +export import mcpplibs.mwrap.boost.config; + #include "../generated/exports/type_traits.inc" diff --git a/src/units.cppm b/src/units.cppm index 29a54d4bd..316b900ee 100644 --- a/src/units.cppm +++ b/src/units.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.units — module facade over generated/exports/units.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -94,6 +95,7 @@ export module mcpplibs.mwrap.boost.units; export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.config; +export import mcpplibs.mwrap.boost.io; export import mcpplibs.mwrap.boost.lambda; export import mcpplibs.mwrap.boost.math; export import mcpplibs.mwrap.boost.type_traits; diff --git a/src/unordered.cppm b/src/unordered.cppm index a0e53620f..fcb4007b1 100644 --- a/src/unordered.cppm +++ b/src/unordered.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.unordered — module facade over generated/exports/unordered.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/url.cppm b/src/url.cppm index 171db661c..6dcdde5cb 100644 --- a/src/url.cppm +++ b/src/url.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.url — module facade over generated/exports/url.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include @@ -6,6 +7,7 @@ export module mcpplibs.mwrap.boost.url; export import mcpplibs.mwrap.boost.assert; export import mcpplibs.mwrap.boost.core; +export import mcpplibs.mwrap.boost.mp11; export import mcpplibs.mwrap.boost.optional; export import mcpplibs.mwrap.boost.system; export import mcpplibs.mwrap.boost.type_traits; diff --git a/src/utility.cppm b/src/utility.cppm index e53f68f5b..c04a37300 100644 --- a/src/utility.cppm +++ b/src/utility.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.utility — module facade over generated/exports/utility.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/uuid.cppm b/src/uuid.cppm index cf08f551f..26f363112 100644 --- a/src/uuid.cppm +++ b/src/uuid.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.uuid — module facade over generated/exports/uuid.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/src/variant.cppm b/src/variant.cppm index fa80ecf44..0c2523e10 100644 --- a/src/variant.cppm +++ b/src/variant.cppm @@ -1,4 +1,5 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.variant — module facade over generated/exports/variant.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -6,7 +7,13 @@ module; export module mcpplibs.mwrap.boost.variant; +export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.config; +export import mcpplibs.mwrap.boost.container_hash; export import mcpplibs.mwrap.boost.core; +export import mcpplibs.mwrap.boost.integer; +export import mcpplibs.mwrap.boost.throw_exception; +export import mcpplibs.mwrap.boost.type_index; export import mcpplibs.mwrap.boost.type_traits; #include "../generated/exports/variant.inc" diff --git a/src/variant2.cppm b/src/variant2.cppm index 4f8a4c9d4..280d1974c 100644 --- a/src/variant2.cppm +++ b/src/variant2.cppm @@ -1,8 +1,12 @@ -// M3 final form (derived from the tools/gen_exports.py draft; hand-finalized) +// mcpplibs.mwrap.boost.variant2 — module facade over generated/exports/variant2.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include export module mcpplibs.mwrap.boost.variant2; +export import mcpplibs.mwrap.boost.assert; +export import mcpplibs.mwrap.boost.mp11; + #include "../generated/exports/variant2.inc" diff --git a/src/wave.cppm b/src/wave.cppm index aacacc186..466d97bf6 100644 --- a/src/wave.cppm +++ b/src/wave.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.wave — module facade over generated/exports/wave.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include @@ -19,7 +20,9 @@ export import mcpplibs.mwrap.boost.config; export import mcpplibs.mwrap.boost.core; export import mcpplibs.mwrap.boost.filesystem; export import mcpplibs.mwrap.boost.format; +export import mcpplibs.mwrap.boost.io; export import mcpplibs.mwrap.boost.iterator; +export import mcpplibs.mwrap.boost.mp11; export import mcpplibs.mwrap.boost.multi_index; export import mcpplibs.mwrap.boost.optional; export import mcpplibs.mwrap.boost.pool; diff --git a/src/winapi.cppm b/src/winapi.cppm index dbfa3938f..0b083d199 100644 --- a/src/winapi.cppm +++ b/src/winapi.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.winapi — module facade over generated/exports/winapi.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; // M9 platform guard: boost/winapi/* #error off-Windows (basic_types.hpp). #if defined(_WIN32) || defined(__CYGWIN__) diff --git a/src/yap.cppm b/src/yap.cppm index 569538aec..13839c985 100644 --- a/src/yap.cppm +++ b/src/yap.cppm @@ -1,4 +1,5 @@ -// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form) +// mcpplibs.mwrap.boost.yap — module facade over generated/exports/yap.inc +// (hand-maintained; tools/gen_exports.py --check verifies its GMF include set) module; #include #include diff --git a/tests/algorithm.cpp b/tests/algorithm.cpp index fc5d0b498..13de1143b 100644 --- a/tests/algorithm.cpp +++ b/tests/algorithm.cpp @@ -1,4 +1,5 @@ -// mcpplibs.mwrap.boost.algorithm smoke — clamp, hex, minmax, is_palindrome, find, copy_if +// mcpplibs.mwrap.boost.algorithm smoke — clamp, hex, minmax, is_palindrome, find, copy_if, +// split/join and names the module re-exports from its dependencies #include "test_assert.hpp" import std; import mcpplibs.mwrap.boost.algorithm; @@ -27,5 +28,23 @@ int main() { assert(boost::algorithm::all_of(v.begin(), v.end(), [](int i) { return i > 0; })); std::vector d{1, 2, 3, 4, 5}; assert(boost::algorithm::find_backward(d, 3) - d.begin() == 2); + // Namespace-scope using-declarations: unscoped enumerators + // (`using algorithm::token_compress_on;`) and a name range also injects + // (boost::join from algorithm::join, not only range::join). + std::vector parts; + boost::split(parts, std::string("a,,b"), boost::is_any_of(","), + boost::token_compress_on); + assert(parts == std::vector({"a", "b"})); + boost::split(parts, std::string("a,,b"), boost::is_any_of(","), + boost::token_compress_off); + assert(parts.size() == 3); + // range::join(r1, r2) wins overload resolution for a plain call, so name + // algorithm::join through boost::join by its exact function type. + std::string (*join_fn)(const std::vector&, const char (&)[2]) = + &boost::join; + assert(join_fn(parts, "-") == "a--b"); + // Entities owned by modules the facade re-exports (smart_ptr via .deps). + boost::shared_ptr sp(new int(7)); + assert(*sp == 7 && sp.use_count() == 1); return 0; } diff --git a/tests/range.cpp b/tests/range.cpp index 81f4aaa9c..97ce728d1 100644 --- a/tests/range.cpp +++ b/tests/range.cpp @@ -39,5 +39,11 @@ int main() { assert(me != boost::end(rng) && *me == 5); assert(boost::accumulate(rng, 0) == 14); assert(boost::as_literal("abc").size() == 3); + // `namespace range { using boost::range_detail::formatted_range; }` + // publishes boost::range::formatted_range. + using fmt_t = boost::range::formatted_range< + std::vector::const_iterator, char, char, char>; + static_assert(std::is_same_v< + decltype(boost::adaptors::format(v, ',', '{', '}')), fmt_t>); return 0; } diff --git a/tools/apply_patches.py b/tools/apply_patches.py new file mode 100644 index 000000000..d48faa207 --- /dev/null +++ b/tools/apply_patches.py @@ -0,0 +1,134 @@ +#!/usr/bin/env python3 +"""apply_patches.py — replay the vendored adaptations under upstream/boost/. + +`tools/import_boost.py` restores the pinned Boost tree byte for byte, which +removes the adaptations this package carries on it. This tool re-applies them: + + python3 tools/import_boost.py --tarball + python3 tools/apply_patches.py + +Only the vendored tree is patched. The module layer is not: the export lists +under generated/exports/ are written by tools/gen_exports.py alone (its +decisions live in tools/export_policy.toml) and src/*.cppm are hand-maintained +facades, so nothing has to be replayed over generator output. + +Every `patches/.patch` is a unified diff against upstream/boost/, +applied with `git apply` (or POSIX `patch -p1` where Git is unavailable) and +idempotent: a patch already contained in the tree is skipped by the reverse +check, so a checkout, a source archive and a bare worktree all end in the same +bytes. A patch that neither applies nor is already applied is an error. +""" + +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +PATCH_DIR = ROOT / "patches" + +# One entry per patches/.patch; see patches/README.md for each reason. +PATCHES = [ + "accumulators", "asio", "beast", "config_platform", "config_user", "hof", + "io", "lambda", "mqtt5", "multi_array", "parameter", "range_adaptors", + "numeric", "regex", "safe_numerics", "serialization", "system", "test", + "ublas", "units", +] + +# A vendored file that is an addition, not a patch of an upstream file. +ADDED_FILES = { + # M11: replacement for the mc.exe-generated header. Upstream builds it + # from simple_event_log.mc at configure time (libs/log/CMakeLists.txt); + # the vendored tree has no build-time code generation, so the constants + # (self-consistent event IDs passed to ReportEvent) are written directly, + # mirroring the .mc MessageId/Severity layout. + "upstream/boost/libs/log/src/windows/simple_event_log.h": """ +/* + * Copyright Andrey Semashev 2007 - 2015. + * 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) + */ + +/* + * M11: hand-written replacement for the mc.exe-generated header. Upstream + * builds it from simple_event_log.mc at configure/build time (see + * libs/log/CMakeLists.txt); the vendored tree has no build-time code + * generation, so the constants (which only need to be self-consistent event + * IDs passed to ReportEvent) are defined here directly, mirroring the .mc + * MessageId/Severity layout. + */ + +#pragma once + +#define BOOST_LOG_SEVERITY_DEBUG 0x00000000L +#define BOOST_LOG_SEVERITY_INFO 0x00000001L +#define BOOST_LOG_SEVERITY_WARNING 0x00000002L +#define BOOST_LOG_SEVERITY_ERROR 0x00000003L + +#define BOOST_LOG_MSG_DEBUG ((DWORD)0x01000100L) +#define BOOST_LOG_MSG_INFO ((DWORD)0x01000101L) +#define BOOST_LOG_MSG_WARNING ((DWORD)0x01000102L) +#define BOOST_LOG_MSG_ERROR ((DWORD)0x01000103L) +""", +} + + +def _run(*cmd): + """Run cmd in ROOT; a missing executable is a failed run (exit 127), so + the patch -p1 fallback is reachable on hosts without Git.""" + try: + return subprocess.run(cmd, cwd=ROOT, capture_output=True, text=True, + encoding="utf-8", errors="replace") + except FileNotFoundError as e: + return subprocess.CompletedProcess(cmd, 127, "", str(e)) + + +def apply_patch_file(name): + """Apply patches/.patch; skip when already applied.""" + rel = "patches/{}.patch".format(name) + r = _run("git", "apply", "--whitespace=nowarn", rel) + if r.returncode == 0: + print(" patched {}".format(rel)) + return + if _run("git", "apply", "--check", "--reverse", rel).returncode == 0: + print(" skip {} (already applied)".format(rel)) + return + p = _run("patch", "-p1", "--dry-run", "--forward", "-i", rel) + if p.returncode == 0: + p = _run("patch", "-p1", "--forward", "-i", rel) + if p.returncode == 0: + print(" patched {} (patch -p1)".format(rel)) + return + elif _run("patch", "-p1", "--dry-run", "--reverse", + "-i", rel).returncode == 0: + print(" skip {} (already applied)".format(rel)) + return + raise SystemExit( + "{}: failed to apply\n git: {}\n patch: {}".format( + rel, (r.stderr or r.stdout)[:300].strip(), + (p.stderr or p.stdout)[:300].strip())) + + +def ensure_file(rel, content): + """Create an added vendored file (no-op when already present).""" + p = ROOT / rel + if p.exists(): + print(" skip {} (already present)".format(rel)) + return + p.parent.mkdir(parents=True, exist_ok=True) + p.write_text(content, encoding="utf-8", newline="\n") + print(" created {}".format(rel)) + + +def main(): + print("applying vendored patches (patches/ -> upstream/boost)...") + for name in PATCHES: + apply_patch_file(name) + for rel, content in ADDED_FILES.items(): + ensure_file(rel, content) + print("done.") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/ast_json.py b/tools/ast_json.py new file mode 100644 index 000000000..74ad9d491 --- /dev/null +++ b/tools/ast_json.py @@ -0,0 +1,624 @@ +#!/usr/bin/env python3 +"""ast_json.py — the compiler's own AST as the generator's only input. + +The export lists are computed from what clang itself reports about a bundle +translation unit, never from a re-implementation of C++ parsing: + + clang++ -fsyntax-only -Xclang -ast-dump=json \ + -Xclang -ast-dump-filter=boost bundle.cpp + +`-ast-dump-filter=boost` keeps the declarations whose qualified name contains +`boost` (every `namespace boost` reopening is dumped whole and nothing of the +std/SDK headers around it), which is everything the module layer exports. +The same invocation is the syntax gate: its exit status and diagnostics decide +whether the include set compiles, so the gate and the AST can never disagree. + +The dump is still large (an instantiation-heavy library such as geometry +prints several GB), so it is consumed as a stream: clang's JSON writer +pretty-prints one key per line with a two-space indent, and the reader below +turns that line stream into a flat declaration table without materializing +the tree. While streaming it + + * tracks the delta-encoded `loc.file` / `loc.line` (clang prints a file only + when it differs from the previously printed location, so the state is + carried across every location in output order, skipped ones included); + * drops implicit template instantiations (every declaration in a + `*TemplateDecl` after the template pattern), `UsingShadowDecl` target + copies, comments, source ranges and record definition data; + * attributes the references found in a declaration's subtree (declaration + references, lookups, type-node declarations, written types) to the + namespace-scope entity that owns the subtree. + +Only `clang++` is required — no libclang, no Python bindings. +""" + +import os +import re +import shutil +import subprocess + + +# --------------------------------------------------------------------------- +# compiler invocation +# --------------------------------------------------------------------------- + +def clang_command(*args): + """clang++ command line. CXX selects the driver; CLANG_NO_DEFAULT_CONFIG + drops the host config file xlings' LLVM installs for native builds (the + generator parses for an explicit cross target and sysroot).""" + command = [os.environ.get("CXX") or "clang++"] + if os.environ.get("CLANG_NO_DEFAULT_CONFIG"): + command.append("--no-default-config") + return command + list(args) + + +_VERSION = None + + +def clang_version(): + """First line of `clang++ --version` — the generator identity recorded in + caches and in the committed API surface.""" + global _VERSION + if _VERSION is None: + exe = shutil.which(clang_command()[0]) + if exe is None: + raise RuntimeError("clang++ not found (set CXX or add LLVM to PATH)") + r = subprocess.run(clang_command("--version"), capture_output=True, + text=True) + out = (r.stdout or r.stderr).splitlines() + _VERSION = out[0].strip() if out else "unknown" + return _VERSION + + +def clang_release(): + """'clang version 23.1.3 (...)' -> '23.1.3' (stable across builds).""" + m = re.search(r"version\s+(\d+(?:\.\d+)*)", clang_version()) + return m.group(1) if m else clang_version() + + +class DumpError(Exception): + """The bundle did not compile; `stderr` holds the diagnostics.""" + + def __init__(self, returncode, stderr): + super().__init__("clang++ exited with {}".format(returncode)) + self.returncode = returncode + self.stderr = stderr + + +def dump(source, args, cwd=None): + """Compile `source` once and return its declaration table (`TU`). + + Raises DumpError with the compiler's diagnostics when the translation unit + does not compile — the caller decides whether to prune includes and retry. + The AST stream is consumed while clang writes it; stderr goes to a + temporary file so a chatty failure cannot block the pipe.""" + import tempfile + fd, depfile = tempfile.mkstemp(suffix=".d") + os.close(fd) + cmd = clang_command("-fsyntax-only", *args, "-MD", "-MF", depfile, + "-Xclang", "-ast-dump=json", + "-Xclang", "-ast-dump-filter=boost", str(source)) + try: + with tempfile.TemporaryFile() as err: + proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=err, + cwd=cwd, bufsize=1 << 20) + try: + tu = TU.from_stream(proc.stdout) + finally: + proc.stdout.close() + rc = proc.wait() + err.seek(0) + stderr = err.read().decode("utf-8", errors="replace") + if rc != 0: + raise DumpError(rc, stderr) + with open(depfile, encoding="utf-8", errors="surrogateescape") as f: + tu.inputs = parse_depfile(f.read()) + finally: + # clang removes the dependency file itself when the compile fails + if os.path.exists(depfile): + os.unlink(depfile) + return tu + + +def parse_depfile(text): + """Prerequisites of a Make-style dependency file (`clang -MD`): the + files after the first `target: `, with backslash-newline continuations + and the `\\ ` / `\\#` / `$$` escapes undone. Other backslashes are + path separators (Windows) and stay.""" + text = re.sub(r"\\\r?\n", " ", text) + head, sep, rest = text.partition(": ") + if not sep: + return [] + out, cur, i, n = [], [], 0, len(rest) + while i < n: + c = rest[i] + if c == "\\" and i + 1 < n and rest[i + 1] in " #": + cur.append(rest[i + 1]) + i += 2 + continue + if c == "$" and i + 1 < n and rest[i + 1] == "$": + cur.append("$") + i += 2 + continue + if c.isspace(): + if cur: + out.append("".join(cur)) + cur = [] + else: + cur.append(c) + i += 1 + if cur: + out.append("".join(cur)) + return out + + +# --------------------------------------------------------------------------- +# declaration table +# --------------------------------------------------------------------------- + +# Declarations that open a scope other entities can be declared in. +CONTEXT_KINDS = frozenset(( + "NamespaceDecl", "LinkageSpecDecl", "CXXRecordDecl", "RecordDecl", + "ClassTemplateDecl", "ClassTemplatePartialSpecializationDecl", + "ClassTemplateSpecializationDecl", "EnumDecl", "ExportDecl", +)) +RECORD_KINDS = frozenset(( + "CXXRecordDecl", "RecordDecl", "ClassTemplateSpecializationDecl", + "ClassTemplatePartialSpecializationDecl", +)) +TEMPLATE_KINDS = frozenset(( + "ClassTemplateDecl", "FunctionTemplateDecl", "VarTemplateDecl", + "TypeAliasTemplateDecl", +)) +TEMPLATE_PARAM_KINDS = frozenset(( + "TemplateTypeParmDecl", "NonTypeTemplateParmDecl", + "TemplateTemplateParmDecl", +)) +FUNCTION_KINDS = frozenset(( + "FunctionDecl", "CXXMethodDecl", "CXXConstructorDecl", + "CXXDestructorDecl", "CXXConversionDecl", "CXXDeductionGuideDecl", +)) +# Declarations whose `type` is spelled in the source (the stand-in for +# libclang's TYPE_REF / TEMPLATE_REF cursors, which JSON does not print). +WRITTEN_TYPE_KINDS = frozenset(( + "VarDecl", "ParmVarDecl", "FieldDecl", "TypedefDecl", "TypeAliasDecl", + "CXXStaticCastExpr", "CXXDynamicCastExpr", "CXXReinterpretCastExpr", + "CXXConstCastExpr", "CStyleCastExpr", "CXXFunctionalCastExpr", + "CXXTemporaryObjectExpr", "CXXUnresolvedConstructExpr", + "NonTypeTemplateParmDecl", +)) | FUNCTION_KINDS + +_SCALAR_ATTRS = frozenset(( + "name", "mangledName", "storageClass", "inline", "constexpr", + "isImplicit", "previousDecl", "parentDeclContextId", "completeDefinition", + "tagUsed", "scopedEnumTag", "init", "isInline", "explicitlyDeleted", + "explicitlyDefaulted", "fixedUnderlyingType", "templateName", "argType", + "referencedMemberDecl", "language", +)) + + +class Decl: + """One declaration node in a declaration context (namespace / class / + linkage specification / translation unit). Declarations inside function + bodies are not recorded; their references belong to the owning entity.""" + + __slots__ = ("id", "kind", "name", "parent", "file", "line", "attrs", + "type", "dtype", "children", "params", "bases", "refs", + "written", "has_body", "targs", "pattern", "friend", + "target", "seq", "_qn", "_ns") + + def __init__(self, nid, kind): + self.id = nid + self.seq = 0 # pre-order position in the dump + self.kind = kind + self.name = "" + self.parent = None + self.file = "" + self.line = 0 + self.attrs = {} + self.type = "" # type.qualType + self.dtype = "" # type.desugaredQualType + self.children = [] + self.params = [] # ParmVarDecl type strings (direct children) + self.bases = [] # base-specifier type strings + self.refs = None # entity owner only: referenced decl ids + self.written = None # entity owner only: written type strings + self.has_body = False + self.targs = False # carries template arguments (specialization) + self.pattern = None # *TemplateDecl -> templated declaration + self.friend = False # declared through a friend declaration + self.target = "" # UsingShadowDecl target / UsingDirective ns + self._qn = None + self._ns = None + + def __repr__(self): + return "<{} {} {}>".format(self.kind, self.name, self.id) + + +class TU: + """Flat declaration table of one translation unit.""" + + def __init__(self): + self.decls = [] # every recorded Decl, in close order + self.by_id = {} # id -> Decl (first occurrence wins) + # id of every node inside a dropped implicit instantiation -> id of + # the template whose instantiation it belongs to (references to + # `foo` and its members resolve to the template `foo`). + self.alias = {} + # every file clang read for this TU (its -MD dependency list), as + # printed: absolute, or relative to the compile's working directory + self.inputs = [] + + def resolve(self, nid): + """Decl for a referenced id, following instantiation aliases.""" + d = self.by_id.get(nid) + if d is None: + t = self.alias.get(nid) + if t is not None: + d = self.by_id.get(t) + return d + + # -- construction ------------------------------------------------------ + + @classmethod + def from_stream(cls, stream): + tu = cls() + _Reader(tu).run(stream) + return tu + + @classmethod + def from_file(cls, path): + with open(path, "rb", buffering=1 << 20) as f: + return cls.from_stream(f) + + +class _Reader: + """Line-oriented reader for clang's pretty-printed JSON AST. + + Frame layout (lists for speed): [indent, tag, node, extra] + tag 'N' AST node object (node = _Node) + tag 'A' array; extra = owning _Node, node = array key + tag 'O' nested object; node = owning _Node, extra = object key + """ + + def __init__(self, tu): + self.tu = tu + + def run(self, stream): + tu = self.tu + frames = [] + cur_file = "" + cur_line = 0 + ignore_file = False + skip = -1 + loc_owner = None + pending = None + pend_ind = 0 + intern = {} + seq = 0 + alias = tu.alias + alias_to = None # template id while skipping an instantiation + after_open = False + skip_arrays = [] # (indent, key) of arrays open in the skip + + for raw in stream: + s = raw.lstrip(b" ") + ind = len(raw) - len(s) + # location state: every printed location, skipped ones included + if s.startswith(b'"file": "'): + if ignore_file: + ignore_file = False + else: + cur_file = _unquote(s[8:]) + elif s.startswith(b'"line": '): + cur_line = int(s[8:].rstrip(b",\r\n")) + elif s.startswith(b'"includedFrom": {'): + ignore_file = True + if skip >= 0: + if alias_to is not None: + # Only nodes of the instantiation (elements of "inner") + # alias to the template; elements of other arrays + # (lookups, ...) name declarations it merely refers to. + if after_open and s.startswith(b'"id": "'): + alias[_unquote(s[6:])] = alias_to + c = s[:1] + if c == b'"' and s.rstrip().endswith(b"["): + skip_arrays.append((ind, s[1:s.index(b'"', 1)])) + elif c == b"]" and skip_arrays \ + and skip_arrays[-1][0] == ind: + skip_arrays.pop() + after_open = c == b"{" and bool(skip_arrays) \ + and skip_arrays[-1][1] == b"inner" + if ind == skip and s[:1] in (b"}", b"]"): + skip = -1 + alias_to = None + skip_arrays.clear() + if loc_owner is not None: + f = intern.get(cur_file) + if f is None: + f = intern[cur_file] = cur_file + loc_owner.file = f + loc_owner.line = cur_line + loc_owner = None + continue + if pending is not None: + # buffered node head: decide on the kind before descending + if s.startswith(b'"kind": "'): + kind = _unquote(s[8:]) + arr = frames[-1] + owner = arr[2] + # Top level: only `namespace boost` subtrees. The filter + # also matches std-side declarations whose printed name + # mentions boost (std::hash members, ...); + # those arrive without their context and are not ours. + drop = kind == "FullComment" or ( + owner is None and kind != "NamespaceDecl") + if owner is not None and owner.kind in TEMPLATE_KINDS \ + and arr[3] == b"inner" \ + and kind not in TEMPLATE_PARAM_KINDS \ + and kind != "TemplateArgument": + if owner.npat: + drop = True # implicit instantiation + else: + owner.npat = 1 + if drop: + skip = pend_ind + if owner is not None and kind != "FullComment": + alias_to = owner.id + if pending: + alias[pending] = owner.id + after_open = False + pending = None + continue + node = _Node(pending, kind, owner) + seq += 1 + node.seq = seq + frames.append([pend_ind, "N", node, None]) + pending = None + elif s.startswith(b'"id": "'): + pending = _unquote(s[6:]) + continue + c = s[:1] + if c == b"}" or c == b"]": + fr = frames.pop() + if fr[1] == "N": + fr[2].close(tu) + continue + if c == b"{": + if s[1:2] == b"}": + continue # null child (`{}`) + top = frames[-1] if frames else None + if top is None or (top[1] == "A" and top[3] == b"inner"): + pending = "" + pend_ind = ind + if top is None: + frames.append([-1, "A", None, b"inner"]) + continue + # element of another array (lookups, bases, ...) + frames.append([ind, "O", top[2], top[3]]) + continue + if c != b'"': + continue + k_end = s.index(b'"', 1) + key = s[1:k_end] + rest = s[k_end + 3:] + top = frames[-1] + r0 = rest[:1] + if r0 == b"{": + if rest[1:2] == b"}": + continue + if key == b"loc": + skip = ind + loc_owner = top[2] if top[1] == "N" else None + continue + if key in (b"range", b"definitionData"): + skip = ind + continue + owner = top[2] + if top[1] == "O" and top[3] == b"bases" and key == b"type": + frames.append([ind, "O", owner, b"bases.type"]) + else: + frames.append([ind, "O", owner, + key if top[1] == "N" else b"-"]) + continue + if r0 == b"[": + if rest[1:2] == b"]": + continue + if top[1] != "N": + frames.append([ind, "A", None, b"-"]) + continue + node = top[2] + if key == b"inner" and node.kind == "UsingShadowDecl": + skip = ind + continue + frames.append([ind, "A", node, key]) + continue + # scalar + tag = top[1] + if tag == "N": + node = top[2] + k = key.decode() + if k in _SCALAR_ATTRS: + node.attrs[k] = _scalar(rest) + continue + if tag == "O": + node = top[2] + if node is None: + continue + okey = top[3] + if okey == b"type": + if key == b"qualType": + node.type = _scalar(rest) + elif key == b"desugaredQualType": + node.dtype = _scalar(rest) + elif okey == b"bases.type": + if key == b"qualType": + node.bases.append(_scalar(rest)) + elif key == b"id" and okey in (b"referencedDecl", b"decl", + b"lookups", b"target", + b"nominatedNamespace"): + node.refs.append(_scalar(rest)) + return tu + + +class _Node: + """Transient node while its subtree is being read.""" + + __slots__ = ("id", "kind", "parent", "attrs", "type", "dtype", "bases", + "refs", "file", "line", "npat", "decl", "params", "children", + "has_body", "targs", "written", "seq") + + def __init__(self, nid, kind, parent): + self.id = nid + self.kind = kind + self.parent = parent + self.attrs = {} + self.type = "" + self.dtype = "" + self.bases = [] + self.refs = [] + self.file = parent.file if parent is not None else "" + self.line = parent.line if parent is not None else 0 + self.npat = 0 + self.decl = None + self.params = [] + self.children = [] + self.has_body = False + self.targs = False + self.written = [] + self.seq = 0 + + def close(self, tu): + """Fold this node into its parent (or into the declaration table).""" + kind = self.kind + parent = self.parent + rec = kind.endswith("Decl") and _in_context(self) + if rec: + d = Decl(self.id, kind) + d.seq = self.seq + d.name = self.attrs.get("name", "") + d.attrs = self.attrs + d.type = self.type + d.dtype = self.dtype + d.file = self.file + d.line = self.line + d.params = self.params + d.bases = self.bases + d.has_body = self.has_body + d.targs = self.targs + d.children = self.children + d.friend = _under_friend(self) + if kind in ("UsingShadowDecl", "UsingDirectiveDecl"): + d.target = self.refs[0] if self.refs else "" + for ch in d.children: + ch.parent = d + if d.kind in TEMPLATE_KINDS and d.pattern is None \ + and ch.kind not in TEMPLATE_PARAM_KINDS: + d.pattern = ch + if _is_entity_scope(self): + refs = set(self.refs) + written = set(self.written) + if self.type and kind in WRITTEN_TYPE_KINDS: + written.add(self.type) + written.update(self.bases) + d.refs = refs + d.written = written + self.decl = d + tu.decls.append(d) + if d.id and d.id not in tu.by_id: + tu.by_id[d.id] = d + if parent is None: + return + # ---- fold into the parent node ---- + if rec: + parent.children.append(self.decl) + if kind == "ParmVarDecl" and parent.kind in FUNCTION_KINDS: + parent.params.append(self.type) + elif kind == "CompoundStmt" and parent.kind in FUNCTION_KINDS: + parent.has_body = True + elif kind == "TemplateArgument" and parent.kind in FUNCTION_KINDS: + parent.targs = True + if rec and _is_entity_scope(self): + return # entity owner keeps its own references + if kind in ("NamespaceDecl", "LinkageSpecDecl"): + return # namespaces own no references + parent.refs.extend(self.refs) + if self.written: + parent.written.extend(self.written) + if self.type and kind in WRITTEN_TYPE_KINDS: + parent.written.append(self.type) + if self.bases: + parent.written.extend(self.bases) + tname = self.attrs.get("templateName") + if tname: + parent.written.append(tname) + at = self.attrs.get("argType") + if at: + parent.written.append(at) + mem = self.attrs.get("referencedMemberDecl") + if mem: + parent.refs.append(mem) + # members keep their own scalars on the Decl; nothing else to fold + + +def _in_context(node): + """True when every ancestor is a declaration context (namespace, class, + linkage specification, template wrapper, friend) — i.e. the declaration is + not local to a function body, an expression or a type.""" + p = node.parent + while p is not None: + k = p.kind + if k in CONTEXT_KINDS or k in TEMPLATE_KINDS or k == "FriendDecl": + p = p.parent + continue + return False + return True + + +def _under_friend(node): + p = node.parent + while p is not None: + if p.kind == "FriendDecl": + return True + if p.kind in ("NamespaceDecl", "LinkageSpecDecl"): + return False + p = p.parent + return False + + +def _is_entity_scope(node): + """The node is a namespace-scope declaration (directly in a namespace, + linkage specification or the translation unit) — the unit references are + attributed to, like libclang's per-entity cursor walk.""" + if node.kind in ("NamespaceDecl", "LinkageSpecDecl"): + return False + p = node.parent + return p is None or p.kind in ("NamespaceDecl", "LinkageSpecDecl", + "ExportDecl") + + +def _unquote(b): + """b'"text",\\n' -> 'text' (JSON string escapes decoded).""" + b = b.rstrip(b",\r\n") + if b"\\" in b: + import json + return json.loads(b) + return b[1:-1].decode("utf-8", errors="replace") + + +def _scalar(b): + b = b.rstrip(b",\r\n") + c = b[:1] + if c == b'"': + if b"\\" in b: + import json + return json.loads(b) + return b[1:-1].decode("utf-8", errors="replace") + if b == b"true": + return True + if b == b"false": + return False + try: + return int(b) + except ValueError: + return b.decode() diff --git a/tools/boost_common.py b/tools/boost_common.py index 4c8165553..ce63a72fa 100644 --- a/tools/boost_common.py +++ b/tools/boost_common.py @@ -1,12 +1,14 @@ #!/usr/bin/env python3 -"""boost_common.py — shared plumbing for the M2 module-export generators. +"""boost_common.py — shared plumbing for the module-export generators. Handles the vendored layout: all library headers live under upstream/boost/boost/ (the aggregated include root; libs// has no include/). This module knows -the target library list, resolves each library's public headers, builds one -"bundle" translation unit per library (mirroring the future .cppm GMF include -set), and provides libclang helpers shared by gen_exports.py / gen_audit.py. +the target library list, resolves each library's public headers (the bundle +translation unit / .cppm GMF include set), the include-based dependency graph +and the clang++ command line shared by gen_exports.py / gen_audit.py. The AST +itself comes from the compiler (tools/ast_json.py); nothing here needs +libclang. """ import json @@ -30,6 +32,18 @@ AUDIT_DIR = ROOT / "target" / "gen" / "audit" MODULE_PREFIX = "mcpplibs.mwrap.boost" + +def _boost_version(): + """Upstream version from mcpp.toml [package.metadata.mwrap] (the single + place it is recorded; generated headers and the API surface read it).""" + import tomllib + with open(ROOT / "mcpp.toml", "rb") as f: + meta = tomllib.load(f) + return meta["package"]["metadata"]["mwrap"]["upstream-version"] + + +BOOST_VERSION = _boost_version() + # M3 header-only libraries, then M4 compiled libraries (plan order), then the # M9 T1a batch (regular header-only libs, no src/ TU, no public macro surface). # C1 downgrade (2026-09-06): scope_exit is include-only now — its public API @@ -63,7 +77,7 @@ # internal-linkage `static`/`const constexpr` objects — boost::hof::compose/_1 # and boost::units::si::meter etc.). The C2 vendored macro patches # (hof/detail/static_const_var.hpp + units/static_constant.hpp → -# `inline constexpr`, replayed by reapply_hand_edits.py) give the objects +# `inline constexpr`, replayed by apply_patches.py) give the objects # external linkage, so both libraries are target libs again. # C4 re-entry (2026-09-07): bind + lambda + lambda2 were excluded in M10 as T3 # "macro-driven" — a misattribution: their macro counts are tiny and every @@ -73,7 +87,7 @@ # boost::placeholders::_1.._9 via BOOST_INLINE_CONSTEXPR) and lambda2 (inline # constexpr) were already module-safe as-is. Classic lambda needed the C2 # treatment: its _1.._3/_e placeholders were TU-local (anonymous namespace) — -# the C4 vendored patches (replayed by reapply_hand_edits.py) convert them to +# the C4 vendored patches (replayed by apply_patches.py) convert them to # inline constexpr (external linkage). Caveat: the deprecated boost/bind.hpp # global `using namespace boost::placeholders;` cannot be reproduced by a # module — consumers of the module face write their own using-directive @@ -199,8 +213,8 @@ LIBS_COMPILED_INCLUDE_ONLY = ["log", "test"] # Target triple for the bundle AST snapshot. The committed .inc files are a -# mingw-flavor snapshot (platform-specific entities are wrapped in guards by -# reapply_hand_edits.py), so the default stays x86_64-w64-mingw32. Set +# mingw-flavor snapshot (platform-specific entities are wrapped in the guards of +# tools/export_policy.toml), so the default stays x86_64-w64-mingw32. Set # BOOST_MODULE_GEN_TARGET (e.g. x86_64-linux-gnu) to snapshot another flavor. _DEFAULT_GEN_TARGET = "x86_64-w64-mingw32" GEN_TARGET = os.environ.get("BOOST_MODULE_GEN_TARGET", _DEFAULT_GEN_TARGET) @@ -248,9 +262,8 @@ def _bundled_sysroot(): if GEN_SYSROOT: TARGET_ARGS.append("--sysroot=" + GEN_SYSROOT) -# Platform defines every bundle TU is parsed under, shared by both the libclang -# AST snapshot and the clang++ gate (gen_exports._parse_bundle passes CLANG_ARGS -# to each), so the two can never disagree: +# Platform defines every bundle TU is compiled under (the AST dump and the +# syntax gate are the same clang++ invocation, so they cannot disagree): # _WIN32_WINNT=0x0A00 — Win10 API set. MinGW's default is older and hides # e.g. WaitOnAddress from boost.winapi, which made the gate mis-prune # boost/atomic.hpp under the pinned sysroot. @@ -268,12 +281,8 @@ def _bundled_sysroot(): GEN_DEFINES = _ENV_GEN_DEFINES.split() if _ENV_GEN_DEFINES.strip() \ else list(_DEFAULT_GEN_DEFINES) -# clang command-line used for every bundle TU (same as M0 probe 4). -# The libclang resource dir (-I .../lib/clang//include) is appended at -# load time: without it libclang cannot find its own builtin headers (e.g. -# mm_malloc.h), the mingw chain breaks, the std surface degrades, -# and every declaration touching std::size_t/std types silently drops out of -# the AST (mp11's mp_at_c/mp_iota_c were lost this way in M2). +# clang++ command line used for every bundle TU. The driver finds its own +# builtin headers; tools/ast_json.py adds the AST-dump flags. CLANG_ARGS = [ "-std=c++23", "-I" + str(DEPS), @@ -284,144 +293,6 @@ def _bundled_sysroot(): ] -def _append_resource_dir(): - """Locate libclang's bundled clang resource dir (bin/libclang.dll or - lib/libclang.so ↔ ../lib/clang//include) and add it to CLANG_ARGS - (idempotent). CLANG_RESOURCE_DIR can specify the builtin include directory - explicitly; it must belong to the selected libclang's LLVM release. - pip's libclang wheel ships no resource dir at all. Refuse to silently - generate an incomplete AST when no builtin headers can be found.""" - explicit = os.environ.get("CLANG_RESOURCE_DIR") - if explicit: - inc = Path(explicit).expanduser() - if not (inc.is_dir() and (inc / "stddef.h").is_file()): - raise RuntimeError( - "CLANG_RESOURCE_DIR does not contain clang builtin headers: " - + str(inc) - ) - flag = "-I{}".format(inc) - if flag not in CLANG_ARGS: - CLANG_ARGS.append(flag) - return - try: - import clang.cindex as ci - # Two loading modes: set_library_path(dir) leaves library_path set, - # set_library_file(dll) sets library_file with library_path None - # (clang-on-PATH fallback and LIBCLANG_PATH= form). - if ci.Config.library_file: - dll = Path(ci.Config.library_file) - elif ci.Config.library_path: - base = Path(ci.Config.library_path) - # linux/macOS name the shared object libclang.so/.dylib; the - # resource dir lives next to it (../lib/clang//include). - cands = sorted(base.glob("libclang.*")) - dll = cands[0] if cands else base / "libclang.dll" - else: - raise RuntimeError("libclang library location is unknown") - except ImportError as e: - raise RuntimeError("libclang is not installed") from e - for base in (dll.parent.parent / "lib" / "clang", - dll.parent / "lib" / "clang", - dll.parent.parent / "include" / "clang"): - try: - vers = sorted([p for p in base.glob("*/include") - if (p / "stddef.h").is_file()], - key=lambda p: p.name, reverse=True) - except Exception: - continue - if not vers: - continue - inc = "-I{}".format(vers[0]) - if inc not in CLANG_ARGS: - CLANG_ARGS.append(inc) - return - raise RuntimeError( - "clang builtin headers not found for {}. The pip libclang wheel " - "does not include them; set LIBCLANG_PATH to a full LLVM installation " - "(with matching libclang and builtin headers).".format(dll) - ) - - -# --------------------------------------------------------------------------- -# libclang bootstrap -# --------------------------------------------------------------------------- - -_CI = None - - -def _libclang_in(directory): - """Path to a libclang shared library in `directory`, or None. - - Accepts the Windows (.dll), Linux (.so[.N]) and macOS (.dylib) names so - LIBCLANG_PATH works as a directory on every platform.""" - for pattern in ("libclang.dll", "libclang.so", "libclang.so.*", - "libclang.dylib"): - for p in sorted(directory.glob(pattern)): - if p.is_file(): - return p - return None - - -def load_libclang(): - """Prefer a full LLVM installation over pip's older bundled libclang. - - LIBCLANG_PATH accepts a file or a library directory; LLVM_PATH also - accepts an installation prefix. Otherwise use the clang++ gate's LLVM - (CXX or PATH), looking in both bin/ (Windows) and lib/ (Unix). - """ - import clang.cindex as ci - env = os.environ.get("LIBCLANG_PATH") or os.environ.get("LLVM_PATH") - if env: - p = Path(env) - lib = _libclang_in_installation(p) if p.is_dir() else p - if lib is None: - raise RuntimeError("libclang not found under " + str(p)) - ci.Config.set_library_file(str(lib)) - return ci - import shutil - exe = shutil.which(os.environ.get("CXX") or "clang++") - if exe: - bindir = Path(exe).resolve().parent - lib = _libclang_in_installation(bindir.parent) - if lib is not None: - ci.Config.set_library_file(str(lib)) - return ci - try: - ci.Index.create() - return ci - except Exception: - pass - raise RuntimeError( - "libclang not found — set LIBCLANG_PATH to the directory containing " - "libclang in a full LLVM installation") - - -def _libclang_in_installation(prefix): - """Find the C API library, not libclang-cpp or compiler-rt libraries.""" - for directory in (prefix, prefix / "bin", prefix / "lib", prefix / "lib64"): - lib = _libclang_in(directory) - if lib is not None: - return lib - return None - - -def libclang_version(): - """Identity of the AST parser (which need not be the clang++ driver).""" - ci = get_ci() - version = ci.conf.lib.clang_getClangVersion - version.restype = ci._CXString - return ci._CXString.from_result(version()) - - -def get_ci(): - """Cached libclang module (loads on first use).""" - global _CI - if _CI is None: - _CI = load_libclang() - _append_resource_dir() - return _CI - - # --------------------------------------------------------------------------- # header resolution (official tarball layout: all headers under boost/boost/) # --------------------------------------------------------------------------- @@ -567,10 +438,8 @@ def scan_libs_json(): """Regenerate libs.json from the heuristic, dropping root headers that do not compile standalone (legacy opt-in headers — e.g. boost/algorithm/string/std/rope_traits.hpp requires the SGI header - that modern libstdc++ no longer ships). The bundle TU check cannot be - trusted for these: libclang silently swallows some missing-include fatals, - while a standalone parse reports them (verified empirically). Human-curate - the result afterwards if needed.""" + that modern libstdc++ no longer ships). Human-curate the result + afterwards if needed.""" db = {} for lib in TARGET_LIBS: kept, dropped = standalone_compile_filter(resolve_headers_heuristic(lib)) @@ -581,29 +450,30 @@ def scan_libs_json(): def standalone_compile_filter(headers): - """Return (kept, dropped) — root headers whose standalone parse produces a - severe diagnostic located under upstream/boost/ are dropped (they cannot be - part of any compilable module GMF). System-header noise (e.g. the missing - mm_malloc.h inside mingw's malloc.h) is ignored. NB: libclang reports - paths relative to the CWD, so locations are resolved before comparison.""" - ci = get_ci() - idx = ci.Index.create() - boost_prefix = str((BOOST_ROOT).resolve()).lower() + """Return (kept, dropped) — root headers whose standalone compile reports + an error located under upstream/boost/ are dropped (they cannot be part of + any compilable module GMF). System-header noise is ignored.""" + import subprocess + import ast_json + boost_prefix = str(BOOST_ROOT.resolve()).replace("\\", "/").lower() kept, dropped = [], [] - for i, h in enumerate(headers): - tmp = ROOT / "target" / "gen" / ("standalone_%d.cpp" % i) + tmp = ROOT / "target" / "gen" / "standalone.cpp" + tmp.parent.mkdir(parents=True, exist_ok=True) + for h in headers: tmp.write_text("#include <{}>\n".format( h.relative_to(BOOST_ROOT.parent).as_posix()), encoding="utf-8") - tu = idx.parse(str(tmp.resolve()), args=CLANG_ARGS, - options=ci.TranslationUnit.PARSE_SKIP_FUNCTION_BODIES) - bad = [d for d in tu.diagnostics - if d.severity >= ci.Diagnostic.Error and d.location.file - and str(Path(d.location.file.name).resolve()).lower().startswith(boost_prefix)] + r = subprocess.run(ast_json.clang_command("-fsyntax-only", *CLANG_ARGS, + str(tmp)), + capture_output=True, text=True, cwd=str(ROOT)) + bad = [line for line in r.stderr.splitlines() + if ": error:" in line or ": fatal error:" in line] + bad = [line for line in bad + if line.replace("\\", "/").lower().startswith(boost_prefix)] if bad: - dropped.append((h, bad[0].spelling[:100])) + dropped.append((h, bad[0].split("error:", 1)[-1].strip()[:100])) else: kept.append(h) - tmp.unlink(missing_ok=True) + tmp.unlink(missing_ok=True) return kept, dropped @@ -655,6 +525,41 @@ def _lib_of_include(rel: str): return top if top in TARGET_LIBS else "" +def lib_deps(lib, headers, file_to_lib=None): + """Target libraries whose headers `headers` include (transitively through + headers no target library owns) — one row of dep_graph().""" + deps = set() + visited = set() + queue = list(headers) + while queue: + h = queue.pop() + try: + key = str(h.resolve()).lower() + except OSError: + continue + if key in visited: + continue + visited.add(key) + try: + text = h.read_text(encoding="utf-8", errors="ignore") + except OSError: + continue + for m in _INC_RE.finditer(text): + rel = m.group(1) + dep = _lib_of_include(rel) + if dep: + if dep != lib: + deps.add(dep) + continue # target-owned root: don't recurse + p = BOOST_ROOT.parent / rel + if p.suffix != ".hpp" or not p.is_file(): + continue + if str(p.resolve()).lower() in visited: + continue + queue.append(p) + return deps + + def dep_graph(headers_by_lib=None): """{lib: set(lib)} — which target libs' headers a lib's headers include. headers_by_lib overrides the header set per lib (defaults to libs.json / @@ -671,43 +576,11 @@ def dep_graph(headers_by_lib=None): walk stops at target-owned roots and system/std headers. This keeps the topological order (and first-wins claiming) consistent with what the module GMF actually compiles.""" - file_to_lib = build_file_to_lib() - graph = {lib: set() for lib in TARGET_LIBS} + graph = {} for lib in TARGET_LIBS: headers = (headers_by_lib.get(lib) if headers_by_lib else None) \ or headers_of(lib) - visited = set() - queue = list(headers) - while queue: - h = queue.pop() - try: - key = str(h.resolve()).lower() - except OSError: - continue - if key in visited: - continue - visited.add(key) - try: - text = h.read_text(encoding="utf-8", errors="ignore") - except OSError: - continue - for m in _INC_RE.finditer(text): - rel = m.group(1) - dep = _lib_of_include(rel) - p = BOOST_ROOT.parent / rel - if dep: - if dep != lib: - graph[lib].add(dep) - continue # target-owned root: don't recurse - # non-target include: recurse through vendored boost headers - # (e.g. boost/date_time/..., boost/mpl/..., boost/version.hpp) - # when the file exists under the include root. - p = BOOST_ROOT.parent / rel - if p.suffix != ".hpp" or not p.is_file(): - continue - if str(p.resolve()).lower() in visited: - continue - queue.append(p) + graph[lib] = lib_deps(lib, headers) return graph @@ -730,150 +603,3 @@ def visit(lib, stack): for lib in TARGET_LIBS: visit(lib, set()) return order - - -# --------------------------------------------------------------------------- -# libclang cursor helpers -# --------------------------------------------------------------------------- - -def iter_descendants(cursor): - """Depth-first over the cursor subtree, skipping FRIEND_DECL subtrees.""" - ci = get_ci() - stack = [cursor] - while stack: - cur = stack.pop() - for child in cur.get_children(): - try: - is_friend = child.kind == ci.CursorKind.FRIEND_DECL - except ValueError: - is_friend = False # cursor kinds unknown to older bindings - if is_friend: - continue - yield child - stack.append(child) - - -def kind_of(cursor): - """Cursor kind or None when the loaded bindings do not know it.""" - try: - return cursor.kind - except Exception: - return None - - -def linkage_ok(cursor): - """External linkage only (static / anonymous-namespace entities cannot be - exported through a using-declaration). Typedefs/aliases have no linkage - concept at all (libclang reports NO_LINKAGE for them), yet a namespace- - scope typedef name is a namespace member that a using-declaration can - re-export (e.g. boost::endian::big_uint16_t) — so they pass unconditionally.""" - try: - k = str(cursor.kind).replace("CursorKind.", "") - if k in ("TYPEDEF_DECL", "TYPE_ALIAS_DECL"): - return True - return cursor.linkage == get_ci().LinkageKind.EXTERNAL - except Exception: - return False - - -def namespace_chain(cursor): - """Namespace names from the TU down to the entity, e.g. ['boost','mp11']. - - Returns [] when the entity is not namespace-scoped (class member, friend, - local, or inside an anonymous namespace).""" - ci = get_ci() - chain = [] - cur = cursor - while True: - parent = cur.semantic_parent - if parent is None or parent == cur: - return [] - pk = kind_of(parent) - if pk == ci.CursorKind.TRANSLATION_UNIT: - return chain[::-1] - if pk != ci.CursorKind.NAMESPACE: - return [] - try: - if parent.is_anonymous(): - return [] - except Exception: - return [] - chain.append(parent.spelling) - cur = parent - - -def qualified_name(cursor): - """Full qualified name like boost::mp11::mp_list; '' when the entity is not - reachable through plain qualified names (members include the class name, - e.g. boost::X::Inner; anonymous namespaces yield '').""" - ci = get_ci() - parts = [] - cur = cursor - while True: - parent = cur.semantic_parent - if parent is None or parent == cur: - return "" - pk = kind_of(parent) - if pk == ci.CursorKind.TRANSLATION_UNIT: - # cur is the outermost namespace; parts holds the chain below it - # bottom-up, so reverse it under cur's name for top-down order. - if not cur.spelling: - return "" - return "::".join([cur.spelling] + parts[::-1]) - if pk == ci.CursorKind.NAMESPACE: - try: - if parent.is_anonymous(): - return "" - except Exception: - return "" - if pk not in (ci.CursorKind.NAMESPACE, - ci.CursorKind.CLASS_DECL, - ci.CursorKind.STRUCT_DECL, - ci.CursorKind.UNION_DECL, - ci.CursorKind.ENUM_DECL, - ci.CursorKind.CLASS_TEMPLATE, - ci.CursorKind.TYPE_ALIAS_DECL, - ci.CursorKind.TYPEDEF_DECL): - return "" - if pk == ci.CursorKind.ENUM_DECL and cur.spelling.startswith("(unnamed"): - # Anonymous enums contribute no name to qualified names: - # their enumerators are members of the enclosing namespace/class. - cur = parent - continue - parts.append(cur.spelling) - cur = parent - - -def cursor_file(cursor): - try: - return Path(cursor.location.file.name) - except Exception: - return None - - -def usr_of(cursor): - try: - return cursor.get_usr() - except Exception: - return None - - -def tokens_of(tu, cursor): - """Token list over a cursor's extent, tolerant of the two libclang - binding generations (extent= vs ranges=[...]).""" - try: - return list(tu.get_tokens(extent=cursor.extent)) - except TypeError: - return list(tu.get_tokens(ranges=[cursor.extent])) - except Exception: - return [] - - -def is_specialization(cursor): - """True for explicit instantiation / explicit specialization decls.""" - try: - ci = get_ci() - r = ci.conf.lib.clang_getSpecializedCursorTemplate(cursor) - return r is not None and r.kind != ci.CursorKind.INVALID - except Exception: - return False diff --git a/tools/ci/check_cache_drift.py b/tools/ci/check_cache_drift.py new file mode 100644 index 000000000..e0807ee79 --- /dev/null +++ b/tools/ci/check_cache_drift.py @@ -0,0 +1,333 @@ +#!/usr/bin/env python3 +"""Nightly check that the generator cache replays what a cold run computes. + +``gen_exports.py --check`` on pull requests runs with the CI cache restored, so +a cache entry that survives a change of one of its real inputs makes the check +pass on stale output. This driver produces three versions of ``generated/``: + + A regenerated with the restored CI cache (what --check compares) + B regenerated from an empty cache (the ground truth) + C the committed files + +A != B means a cache key misses an input: a generator bug. B != C means the +committed output is wrong (most likely merged on the strength of a stale +cache) and needs a regeneration and review. Either fails the run. + +``gen_audit.py`` caches its linkage reports in the same directory. They are +not committed, so a stale replay has nothing to be caught against on pull +requests: each pass also runs the audit, and its reports must match between +A and B as well. + +The evidence (diffs, both versions of the affected cache entries, generator +logs) is written to --out for upload, and the cold run leaves a clean cache +in target/gen/exports-cache for the workflow to save over the stale one. + +``--summarize DIR`` turns the per-platform results under DIR into the body +of the tracking issue. + +Usage: + python3 tools/ci/check_cache_drift.py --out target/cache-drift + python3 tools/ci/check_cache_drift.py --summarize DIR --run-url URL +""" + +import argparse +import difflib +import json +import os +import platform +import shutil +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +TOOLS = ROOT / "tools" +sys.path.insert(0, str(TOOLS)) +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +DIFF_LINES = 60 # per file in report.md +ISSUE_DIFF_LINES = 120 # per platform in the issue body +MARKER = "" + + +def generate(label, out): + """Run gen_exports.py into the work tree, keep a copy of its output and + log, then restore the committed files.""" + import gen_exports + from verify_generated import git + log = out / "logs" / (label + ".log") + log.parent.mkdir(parents=True, exist_ok=True) + command = [sys.executable, str(TOOLS / "gen_exports.py")] + print("\n==> [{}] {}".format(label, " ".join(command)), flush=True) + last = "" + with open(log, "w", encoding="utf-8") as f: + proc = subprocess.Popen(command, cwd=ROOT, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, text=True, + encoding="utf-8", errors="replace") + for line in proc.stdout: + sys.stdout.write(line) + f.write(line) + if line.strip(): + last = line + rc = proc.wait() + # Facade problems are reported after every generated file is written; + # they are verify-scripts' business. Any other failure leaves partial + # output that must not be read as drift. + if rc != 0 and "facade problem(s)" not in last: + raise SystemExit("[{}] gen_exports.py failed with exit code {}" + .format(label, rc)) + files = gen_exports._snapshot(ROOT) + git("checkout", "--", "generated") + git("clean", "-fdq", "--", "generated") + return files, rc + + +def audit(label, out): + """Run the linkage audit into a scratch directory; {file name: bytes} + of its reports.""" + dest = out / "work" / ("audit-" + label) + shutil.rmtree(dest, ignore_errors=True) + log = out / "logs" / (label + "-audit.log") + command = [sys.executable, str(TOOLS / "gen_audit.py"), "--out", str(dest)] + print("\n==> [{}] {}".format(label, " ".join(command)), flush=True) + with open(log, "w", encoding="utf-8") as f: + proc = subprocess.Popen(command, cwd=ROOT, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, text=True, + encoding="utf-8", errors="replace") + for line in proc.stdout: + sys.stdout.write(line) + f.write(line) + rc = proc.wait() + if rc != 0: + raise SystemExit("[{}] gen_audit.py failed with exit code {}" + .format(label, rc)) + return {"target/gen/audit/" + p.name: p.read_bytes() + for p in sorted(dest.glob("*.txt"))} + + +def diff_files(old, new): + return sorted(p for p in set(old) | set(new) if old.get(p) != new.get(p)) + + +def unified(rel, old, new, a, b, limit): + lines = list(difflib.unified_diff( + old.get(rel, b"").decode("utf-8", "replace").splitlines(), + new.get(rel, b"").decode("utf-8", "replace").splitlines(), + "{}/{}".format(a, rel), "{}/{}".format(b, rel), lineterm="", n=1)) + if limit and len(lines) > limit: + lines = lines[:limit] + ["... ({} more diff lines)".format( + len(lines) - limit)] + return lines + + +def affected_libs(paths, old, new): + """Libraries whose output differs: their .inc/.deps, or their entry in + the API surface.""" + libs = set() + for p in paths: + name = p.rsplit("/", 1)[-1] + if p.startswith(("generated/exports/", "target/gen/audit/")): + libs.add(name.rsplit(".", 1)[0]) + elif name == "api-surface.json": + o = json.loads(old.get(p) or b"{}").get("libraries", {}) + n = json.loads(new.get(p) or b"{}").get("libraries", {}) + libs |= {k for k in set(o) | set(n) if o.get(k) != n.get(k)} + return sorted(libs) + + +def write_diff(path, paths, old, new, a, b): + with open(path, "w", encoding="utf-8", newline="\n") as f: + for p in paths: + f.write("\n".join(unified(p, old, new, a, b, 0)) + "\n") + + +def copy_entries(src, dst, libs): + for lib in libs: + for name in (lib + ".skip.json", lib + ".gate.json", + lib + ".audit.json"): + if (src / name).is_file(): + dst.mkdir(parents=True, exist_ok=True) + shutil.copy2(src / name, dst / name) + + +def check(out): + # The generator modules are imported here: --summarize runs from a + # sparse checkout without the generator's inputs. + import ast_json as aj + import boost_common as bc + import gen_exports + from verify_generated import assert_clean, run_step + + out.mkdir(parents=True, exist_ok=True) + assert_clean("initial checkout") + run_step("fetch_mingw_sysroot.py") + run_step("apply_patches.py") + + cache = bc.CACHE_DIR + restored = out / "work" / "cache-restored" + entries = sorted(cache.glob("*.skip.json")) if cache.is_dir() else [] + print("restored cache: {} library entries".format(len(entries))) + if cache.is_dir(): + shutil.copytree(cache, restored) + + committed = gen_exports._snapshot(ROOT) + cached, rc_a = generate("A-cached", out) + audit_cached = audit("A-cached", out) + shutil.rmtree(cache, ignore_errors=True) + cold, rc_b = generate("B-cold", out) + audit_cold = audit("B-cold", out) + + cache_paths = diff_files(cold, cached) + audit_paths = diff_files(audit_cold, audit_cached) + commit_paths = diff_files(committed, cold) + status = { + "os": "{} ({})".format(os.environ.get("RUNNER_OS") or + platform.system(), platform.machine()), + "clang": aj.clang_version(), + "clang_command": aj.clang_command(*bc.CLANG_ARGS), + "restored_entries": len(entries), + "cache_drift": cache_paths, + "cache_drift_libs": affected_libs(cache_paths, cold, cached), + "audit_drift": audit_paths, + "audit_drift_libs": affected_libs(audit_paths, audit_cold, + audit_cached), + "committed_drift": commit_paths, + "committed_drift_libs": affected_libs(commit_paths, committed, cold), + "exit_codes": {"A-cached": rc_a, "B-cold": rc_b}, + } + + report = [] + if cache_paths: + write_diff(out / "cache-vs-cold.diff", cache_paths, cold, cached, + "cold", "cached") + libs = status["cache_drift_libs"] + copy_entries(restored, out / "evidence" / "restored", libs) + copy_entries(cache, out / "evidence" / "cold", libs) + report += ["## Cache drift (A != B)", "", + "Libraries: " + (", ".join(libs) or "-"), "", "```diff"] + for p in cache_paths: + report += unified(p, cold, cached, "cold", "cached", DIFF_LINES) + report += ["```", ""] + if audit_paths: + write_diff(out / "audit-cache-vs-cold.diff", audit_paths, audit_cold, + audit_cached, "cold", "cached") + libs = status["audit_drift_libs"] + copy_entries(restored, out / "evidence" / "restored", libs) + copy_entries(cache, out / "evidence" / "cold", libs) + report += ["## Audit cache drift (A != B)", "", + "Libraries: " + (", ".join(libs) or "-"), "", "```diff"] + for p in audit_paths: + report += unified(p, audit_cold, audit_cached, "cold", "cached", + DIFF_LINES) + report += ["```", ""] + if commit_paths: + write_diff(out / "committed-vs-cold.diff", commit_paths, committed, + cold, "committed", "cold") + report += ["## Committed output differs from a cold run (B != C)", "", + "Libraries: " + (", ".join(status["committed_drift_libs"]) + or "-"), "", "```diff"] + for p in commit_paths: + report += unified(p, committed, cold, "committed", "cold", + DIFF_LINES) + report += ["```", ""] + (out / "status.json").write_text(json.dumps(status, indent=1) + "\n", + encoding="utf-8") + if report: + (out / "report.md").write_text("\n".join(report) + "\n", + encoding="utf-8") + shutil.rmtree(out / "work", ignore_errors=True) + + gh_out = os.environ.get("GITHUB_OUTPUT") + if gh_out: + with open(gh_out, "a", encoding="utf-8") as f: + f.write("cache_drift={}\n".format( + "true" if cache_paths or audit_paths else "false")) + f.write("committed_drift={}\n".format( + "true" if commit_paths else "false")) + + print("\ncache vs cold run: {} file(s) differ".format(len(cache_paths))) + print("audit cache vs cold run: {} report(s) differ".format( + len(audit_paths))) + print("committed vs cold run: {} file(s) differ".format( + len(commit_paths))) + if cache_paths or audit_paths or commit_paths: + print("drift detected; evidence in {}".format(out), file=sys.stderr) + return 1 + print("no drift: the cache replays exactly what a cold run computes") + return 0 + + +def summarize(src, run_url): + """Issue body for every platform that drifted; empty when none did.""" + legs = [] + for f in sorted(Path(src).glob("*/status.json")): + status = json.loads(f.read_text(encoding="utf-8")) + if status["cache_drift"] or status["audit_drift"] \ + or status["committed_drift"]: + legs.append((f.parent, status)) + if not legs: + return "" + body = [MARKER, "## Generator cache drift", "", + "Run: {}".format(run_url), "", + "| Platform | Cache vs cold run (A != B) | " + "Audit cache vs cold run (A != B) | " + "Committed vs cold run (B != C) | Restored entries |", + "|---|---|---|---|---|"] + for _, s in legs: + body.append("| {} | {} | {} | {} | {} |".format( + s["os"], ", ".join(s["cache_drift_libs"]) or "-", + ", ".join(s["audit_drift_libs"]) or "-", + ", ".join(s["committed_drift_libs"]) or "-", + s["restored_entries"])) + body += [ + "", + "- **A != B**: a cache key misses an input; the CI cache replayed " + "stale output, so `gen_exports.py --check` could pass on it. Fix the " + "generator; the run has already saved a cold cache over the stale " + "one.", + "- **Audit A != B**: `gen_audit.py`'s cache key misses an input; the " + "linkage reports replayed from the CI cache are stale. Fix the audit " + "key; the cold cache saved by the run replaces the stale entries.", + "- **B != C**: the committed `generated/` is not what the generator " + "computes. Regenerate and review the diff, including the facades " + "that import the affected modules.", + "", + "The run's `cache-drift-*` artifacts hold the full diffs, the " + "restored and cold cache entries of the affected libraries, and the " + "generator logs.", + ] + budget = 60000 + for leg, s in legs: + report = leg / "report.md" + if not report.is_file(): + continue + lines = report.read_text(encoding="utf-8").splitlines() + if len(lines) > ISSUE_DIFF_LINES: + lines = lines[:ISSUE_DIFF_LINES] + ["```", "(truncated)"] + block = ["", "
{}: diff excerpt".format( + s["os"]), ""] + lines + ["", "
"] + text = "\n".join(block) + if len("\n".join(body)) + len(text) > budget: + body.append("\n(further excerpts omitted: see the artifacts)") + break + body.append(text) + return "\n".join(body) + "\n" + + +def main(): + ap = argparse.ArgumentParser( + description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("--out", type=Path, default=ROOT / "target" / "cache-drift", + help="evidence directory (default: target/cache-drift)") + ap.add_argument("--summarize", type=Path, metavar="DIR", + help="print the issue body for the results under DIR") + ap.add_argument("--run-url", default="", help="link to the workflow run") + args = ap.parse_args() + if args.summarize: + sys.stdout.write(summarize(args.summarize, args.run_url)) + return 0 + return check(args.out.resolve()) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/ci/verify_generated.py b/tools/ci/verify_generated.py index 6c18370db..7814df9e8 100644 --- a/tools/ci/verify_generated.py +++ b/tools/ci/verify_generated.py @@ -1,18 +1,18 @@ #!/usr/bin/env python3 -"""Verify that the repository's generation steps are idempotent. +"""Verify that the committed generated files are exactly the generators' output. -The repository commits the outputs of the generation scripts. CI therefore -runs each step from a clean checkout and uses ``git diff`` as the oracle: a -step is allowed to create ignored caches, but it must not modify tracked -files (or leave non-ignored untracked files behind). +The repository commits the outputs of the generation scripts. Each generator +has a ``--check`` mode that regenerates into a scratch location and compares +byte for byte without touching the tree (``gen_exports.py --check``, +``gen_features.py --check``); this driver runs them from a clean checkout and +finally asserts that no step modified tracked files or left untracked ones. ``import_boost.py`` is different from the other steps. Re-vendoring restores the upstream files under ``upstream/boost/`` and intentionally removes the -project's vendored patches; ``reapply_hand_edits.py`` must be run afterwards. +project's vendored patches; ``apply_patches.py`` must be run afterwards. The workflow runs this optional pair only once, on the Linux leg, when -``tools/import_boost.py`` changed relative to the CI base revision. The tool -caches and the LLVM/libclang payload the AST steps need are prepared from -``tools/uv.lock`` and are not committed. +``tools/import_boost.py`` changed relative to the CI base revision. The AST +steps need only ``clang++`` (no libclang) and the pinned MinGW sysroot. Usage: python3 tools/ci/verify_generated.py @@ -138,24 +138,19 @@ def main(): if args.import_boost_if_changed and import_boost_changed(): # import_boost intentionally removes the vendored patches, so its - # intermediate diff is expected. The following reapply step is the + # intermediate diff is expected. The following apply_patches step is the # idempotent boundary checked by CI and restores the committed state. run_step("import_boost.py", check_diff=False) - run_step("reapply_hand_edits.py") + run_step("apply_patches.py") elif args.import_boost_if_changed: print("skip tools/import_boost.py (unchanged)") - # Keep this order aligned with docs/architecture.md and the documented - # regeneration flow: provision the pinned target headers, replay the - # vendored adaptations, generate the export surface, replay the - # module-side hand edits, then regenerate the derived metadata. + # Keep this order aligned with docs/architecture.md: provision the pinned + # target headers, confirm the vendored adaptations are in place, then + # prove every generated file is current. run_step("fetch_mingw_sysroot.py") - # gen_exports emits drafts before the required hand-edit replay. Its - # intermediate diff is therefore expected; the replay below is the - # idempotent boundary for this generation pair. - run_step("gen_exports.py", "--emit-cppm", check_diff=False) - run_step("reapply_hand_edits.py") - run_step("gen_features.py") + run_step("apply_patches.py") + run_step("gen_exports.py", "--check") run_step("gen_features.py", "--check") run_step("gen_audit.py") run_step("gen_audit.py", "--macros") diff --git a/tools/curated/README.md b/tools/curated/README.md deleted file mode 100644 index 0e5c1d187..000000000 --- a/tools/curated/README.md +++ /dev/null @@ -1,11 +0,0 @@ -# curated/ — generator blind-spot overrides - -兜底清单目录 (计划: `tools/curated/.txt`)。gen_exports.py 生成器看不见的 -实体 (宏生成、GMF 全局辅助实体等) 由此处的每行一个限定名补入导出列表: - -- `boost::foo::bar` — 在 `boost::foo` 命名空间块内输出 `using boost::foo::bar;` -- `::operator new` — 全局作用域实体, 输出 `export using ::operator new;` - (M0 坑 A: gcc 的 GMF 全局辅助实体需显式再导出, 如 container 的 placement_new) - -当前 27 个目标库均未触发 (M0 已知的 container 坑不在目标集内); M3 遇到 -编译器实现缺口时在此登记并同步 gen_exports.py 读取逻辑 (尚未实现读取, 需要时加)。 diff --git a/tools/curated/any.txt b/tools/curated/any.txt deleted file mode 100644 index 8aab809fd..000000000 --- a/tools/curated/any.txt +++ /dev/null @@ -1,32 +0,0 @@ -# curated/any.txt — generator blind-spot overrides for the boost.any module -# -# boost::any::type() returns const boost::typeindex::type_info&, and any_cast's -# template body compares type_info against type_index (boost/any.hpp:300). -# The closure walks declarations only (not bodies), and canonicalization -# resolves boost::typeindex::type_info down to std::type_info — so none of the -# typeindex surface is reachable from any's signatures. These names are -# visible in the module GMF (any.hpp pulls type_index.hpp transitively), so -# exporting them here is safe. -# -# NOTE: only the RTTI flavor (stl_*) is listed — ctti_* exists solely under -# BOOST_NO_RTTI which the fixed build flavor (this snapshot) does not define. -# -# M4: the operator set is ALSO a cross-module re-export override — the -# 27-lib regeneration claims boost::typeindex::operator* for boost.variant -# (first-wins), but any_cast's template body (instantiated in consumer TUs) -# needs them reachable from boost.any's own interface, so they are force- -# listed here regardless of the claim (legal duplicate re-export; M3 had the -# same surface in both modules). -boost::typeindex::type_index -boost::typeindex::type_info -boost::typeindex::type_id -boost::typeindex::type_id_with_cvr -boost::typeindex::type_id_runtime -boost::typeindex::stl_type_index -boost::typeindex::type_index_facade -boost::typeindex::operator== -boost::typeindex::operator!= -boost::typeindex::operator< -boost::typeindex::operator> -boost::typeindex::operator<= -boost::typeindex::operator>= diff --git a/tools/curated/filesystem.txt b/tools/curated/filesystem.txt deleted file mode 100644 index ac56220ff..000000000 --- a/tools/curated/filesystem.txt +++ /dev/null @@ -1,22 +0,0 @@ -# curated/filesystem.txt — generator blind-spot overrides for the boost.filesystem module -# -# directory_iterator / recursive_directory_iterator derive from -# boost::iterators::iterator_facade, whose comparison operators are friend -# function TEMPLATES declared inside boost::iterators::iterator_core_access -# (boost/iterator/iterator_facade.hpp). They are not namespace-scope entities, -# so the generator's collectors never see them; and because the declarations -# live in the module's global module fragment (GMF include of -# boost/filesystem/*.hpp), they are NOT visible to ADL from consumer TUs — -# `it != end` fails to compile. Re-exporting the names from the module -# interface makes them reachable. Only the single-pass operators are needed -# (== and !=); the random-access set (<, >, <=, >=, +, -, ++) is included for -# interoperability with other iterator_facade consumers. -boost::iterators::operator== -boost::iterators::operator!= -boost::iterators::operator< -boost::iterators::operator> -boost::iterators::operator<= -boost::iterators::operator>= -boost::iterators::operator+ -boost::iterators::operator- -boost::iterators::operator++ diff --git a/tools/export_policy.toml b/tools/export_policy.toml new file mode 100644 index 000000000..848be2221 --- /dev/null +++ b/tools/export_policy.toml @@ -0,0 +1,2222 @@ +# export_policy.toml — what the AST cannot decide about the module surface. +# +# tools/gen_exports.py computes every export list from clang's AST of the +# library's bundle TU. This file holds the remaining human decisions, each +# with a written reason, and the generator applies them while writing +# generated/exports/*.inc. Nothing edits the generated files afterwards; every +# name touched here is listed in generated/meta/skipped.txt. +# +# [] +# gmf = exact GMF/bundle include set (paths below upstream/boost) +# defines = extra -D macros of the bundle (must match the .cppm GMF) +# inline-namespaces = inline namespaces whose members are exported through +# the enclosing namespace (macro-selected inline names) +# add = names no collector reaches that consumers need +# +# [[.guard]] if = "", names = [...], +# reason = "...", else = ["", ...] (optional) +# [[.drop]] names = [...], reason = "..." +# [[.extra]] namespace = "boost", lines = [...], reason = "..." +# [.deps] add = [...], remove = [...], reason = "..." +# +# A `names` entry with `::` matches one qualified name exactly; a bare +# identifier matches any `::` segment of an exported name. +# +# Guards exist because the snapshot is one platform flavor (MinGW x86_64, +# libstdc++): a declaration that only that flavor's preprocessor branch +# declares is exported under the upstream header's own condition, so other +# platforms compile the same list. + +[json] +# The compiled definitions live in libs/json/src/src.cpp; the module GMF must +# not include src.hpp (it pulls the .ipp implementation declarations). +gmf = ["boost/json/debug_printers.hpp", "boost/json.hpp"] + +[outcome] +# The experimental/status-code subtree (marked EXPERIMENTAL upstream) +# redeclares Win32 APIs (FormatMessageW, ...) in extern "C" and conflicts with +# the MinGW SDK once the whole outcome header set lands in one TU. The module +# keeps the supported surface; the experimental headers stay include-only. +gmf = [ + "boost/outcome.hpp", + "boost/outcome/bad_access.hpp", + "boost/outcome/basic_outcome.hpp", + "boost/outcome/basic_result.hpp", + "boost/outcome/boost_outcome.hpp", + "boost/outcome/boost_result.hpp", + "boost/outcome/config.hpp", + "boost/outcome/convert.hpp", + "boost/outcome/coroutine_support.hpp", + "boost/outcome/iostream_support.hpp", + "boost/outcome/iostream_support_result.hpp", + "boost/outcome/outcome.hpp", + "boost/outcome/result.hpp", + "boost/outcome/std_outcome.hpp", + "boost/outcome/std_result.hpp", + "boost/outcome/success_failure.hpp", + "boost/outcome/trait.hpp", + "boost/outcome/try.hpp", + "boost/outcome/utils.hpp", +] + +[stacktrace] +# src/stacktrace.cppm defines BOOST_STACKTRACE_LINK in its GMF (link mode, the +# implementation is libs/stacktrace/src/basic.cpp); the export list must be +# computed under the same macro. +defines = ["BOOST_STACKTRACE_LINK"] + +[any] +# boost::any::type() returns const boost::typeindex::type_info&, and +# any_cast's template body compares type_info against type_index. Neither the +# signature closure nor ownership reaches the typeindex surface, and +# boost.variant claims the operators first; any_cast is instantiated in +# consumer TUs, so the names must be reachable from boost.any itself (legal +# duplicate re-export). RTTI flavor only: ctti_* exists solely under +# BOOST_NO_RTTI, which the build does not define. +add = [ + "boost::typeindex::type_index", + "boost::typeindex::type_info", + "boost::typeindex::type_id", + "boost::typeindex::type_id_with_cvr", + "boost::typeindex::type_id_runtime", + "boost::typeindex::stl_type_index", + "boost::typeindex::type_index_facade", + "boost::typeindex::operator==", + "boost::typeindex::operator!=", + "boost::typeindex::operator<", + "boost::typeindex::operator>", + "boost::typeindex::operator<=", + "boost::typeindex::operator>=", +] + +[filesystem] +# directory_iterator / recursive_directory_iterator derive from +# boost::iterators::iterator_facade, whose comparison operators are friend +# function templates of iterator_core_access. Declared in the GMF they are not +# visible to ADL from consumer TUs (`it != end` fails), so the module +# re-exports the names; the random-access set is included for other +# iterator_facade consumers. +add = [ + "boost::iterators::operator==", + "boost::iterators::operator!=", + "boost::iterators::operator<", + "boost::iterators::operator>", + "boost::iterators::operator<=", + "boost::iterators::operator>=", + "boost::iterators::operator+", + "boost::iterators::operator-", + "boost::iterators::operator++", +] + +[algorithm] +# gcc 16.1.0 rejects the boost::regex v5 abi-tag surface inside a module +# interface ("mismatching abi tags for get_catalog_name_inst") although the same +# headers compile standalone, so the module GMF takes the boost/algorithm/ +# string.hpp aggregate instead of string_regex.hpp and the *_regex family stays +# include-only (clang would accept the full surface). +gmf = [ + "boost/algorithm/algorithm.hpp", + "boost/algorithm/apply_permutation.hpp", + "boost/algorithm/clamp.hpp", + "boost/algorithm/cxx11/all_of.hpp", + "boost/algorithm/cxx11/any_of.hpp", + "boost/algorithm/cxx11/copy_if.hpp", + "boost/algorithm/cxx11/copy_n.hpp", + "boost/algorithm/cxx11/find_if_not.hpp", + "boost/algorithm/cxx11/iota.hpp", + "boost/algorithm/cxx11/is_partitioned.hpp", + "boost/algorithm/cxx11/is_sorted.hpp", + "boost/algorithm/cxx11/one_of.hpp", + "boost/algorithm/cxx11/partition_copy.hpp", + "boost/algorithm/cxx11/partition_point.hpp", + "boost/algorithm/cxx14/equal.hpp", + "boost/algorithm/cxx14/is_permutation.hpp", + "boost/algorithm/cxx17/exclusive_scan.hpp", + "boost/algorithm/cxx17/for_each_n.hpp", + "boost/algorithm/cxx17/inclusive_scan.hpp", + "boost/algorithm/cxx17/reduce.hpp", + "boost/algorithm/cxx17/transform_exclusive_scan.hpp", + "boost/algorithm/cxx17/transform_inclusive_scan.hpp", + "boost/algorithm/cxx17/transform_reduce.hpp", + "boost/algorithm/find_backward.hpp", + "boost/algorithm/find_not.hpp", + "boost/algorithm/gather.hpp", + "boost/algorithm/hex.hpp", + "boost/algorithm/is_clamped.hpp", + "boost/algorithm/is_palindrome.hpp", + "boost/algorithm/is_partitioned_until.hpp", + "boost/algorithm/minmax.hpp", + "boost/algorithm/minmax_element.hpp", + "boost/algorithm/searching/boyer_moore.hpp", + "boost/algorithm/searching/boyer_moore_horspool.hpp", + "boost/algorithm/searching/knuth_morris_pratt.hpp", + "boost/algorithm/sort_subrange.hpp", + "boost/algorithm/string.hpp", + "boost/algorithm/string/trim_all.hpp", +] + +[cobalt] +# POSIX cobalt selects the epoll reactor; asio's reactor/hash_map details are +# reached only through Windows-flavored chains in the MinGW snapshot. The +# facade includes them so the shared-surface using-declarations resolve on +# every platform (they are not part of the export computation). +facade-includes = [ + "boost/asio/detail/fd_set_adapter.hpp", + "boost/asio/detail/hash_map.hpp", + "boost/asio/detail/null_reactor.hpp", + "boost/asio/detail/reactor_op_queue.hpp", + "boost/asio/detail/select_reactor.hpp", + "boost/asio/detail/socket_select_interrupter.hpp", +] + +[nowide] +# cstdio/stackstring/convert are reached only via Windows-flavored transitive +# includes in the MinGW snapshot; the facade includes the cross-platform +# headers explicitly so the shared-surface using-declarations resolve. +facade-includes = [ + "boost/nowide/convert.hpp", + "boost/nowide/cstdio.hpp", + "boost/nowide/stackstring.hpp", +] + +[parser] +# boost/parser/detail/numeric.hpp selects the inline namespace by macro +# (std_charconv / boost_charconv / spirit_parsers, depending on +# support); exporting through the enclosing namespace names the same +# entities on every platform. +inline-namespaces = ["boost::parser::detail::numeric::std_charconv"] + +[[align.drop]] +names = ["std::alignment_of"] +reason = """ +boost::alignment::detail::alignment_of is `using std::alignment_of` only on +some compilers; other targets (clang outside x86_64) define a template of that +name, which the std re-export would conflict with. +""" + +[[utility.drop]] +names = [ + "boost::basic_string_ref", + "boost::string_ref", + "boost::u16string_ref", + "boost::u32string_ref", + "boost::wstring_ref", +] +reason = """ +Declared only via boost/utility/string_ref.hpp, which is left out of the +module GMF (gcc 16.1 buffer_fill enum mismatch); consumers include the header. +""" + +[[multiprecision.drop]] +names = [ + "boost::multiprecision::detail::unmentionable", + "boost::multiprecision::detail::unmentionable_type", +] +reason = """ +Detail placeholder (a member-pointer typedef used to disable overloads); gcc +treats it as having no external linkage and refuses the export. +""" + +[[winapi.drop]] +names = [ + "boost::winapi::detail::winsdk_condition_variable", + "boost::winapi::detail::winsdk_critical_section", + "boost::winapi::detail::winsdk_srwlock", +] +reason = """ +Declared inside extern "C" blocks, and only without windows.h and above a +Windows API version (BOOST_USE_WINAPI_VERSION); the definition differs between +MinGW and the Windows SDK. Implementation detail of boost.winapi's own +signatures, not a name consumers spell. +""" + +[[flyweight.drop]] +namespaces = ["boost::detail", "boost::mpl", "boost::parameter"] +reason = """ +The bundle pulls the transitive container/interprocess/parameter surface into +shared namespaces; boost.flyweight exports its own namespaces and boost:: +entry points only. +""" + +[[type_erasure.guard]] +if = "defined(__GNUC__)" +reason = """ +boost::mpl::item_by_order_impl is declared by the gcc-preprocessed mpl map +headers only (absent from the msvc-flavor preprocessing); type_erasure claims +it when it is processed before poly_collection. +""" +names = ["boost::mpl::item_by_order_impl"] + +[version.deps] +# Hand-written module (src/version.cppm): the thin entry re-exports the macro +# mapping module, where the constants live (one export owner). +add = ["macros"] + +# -------------------------------------------------------------------------- +# asio + +[[asio.guard]] +if = "defined(BOOST_ASIO_HAS_FILE)" +reason = ''' +Asio's file support (basic_file and friends) is declared only where +BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. +''' +names = [ # any :: segment + "basic_file", + "basic_random_access_file", + "basic_stream_file", + "file_base", + "random_access_file", + "stream_file", +] + +[[asio.guard]] +if = "defined(_WIN32)" +reason = ''' +Asio's Windows backend (IOCP, winsock, select reactor, Windows handles); +POSIX builds the epoll/kqueue backends instead. +''' +names = [ # any :: segment + "apc_function", + "calculate_hash_value", + "random_access_handle", + "stream_handle", + "fd_set_adapter", + "hash_map", + "null_reactor", + "select_reactor", + "null_signal_blocker", + "socket_select_interrupter", + "reactor_op_queue", + "win_event", + "win_fd_set_adapter", + "win_global", + "win_global_impl", + "win_iocp_file_service", + "win_iocp_handle_read_op", + "win_iocp_handle_service", + "win_iocp_handle_write_op", + "win_iocp_io_context", + "win_iocp_null_buffers_op", + "win_iocp_operation", + "win_iocp_overlapped_ptr", + "win_iocp_serial_port_service", + "win_iocp_socket_accept_op", + "win_iocp_socket_connect_op", + "win_iocp_socket_connect_op_base", + "win_iocp_socket_move_accept_op", + "win_iocp_socket_recv_op", + "win_iocp_socket_recvfrom_op", + "win_iocp_socket_recvmsg_op", + "win_iocp_socket_send_op", + "win_iocp_socket_service", + "win_iocp_socket_service_base", + "win_iocp_thread_info", + "win_iocp_wait_op", + "win_iocp_overlapped_op", + "win_object_handle_service", + "win_mutex", + "win_static_mutex", + "win_thread", + "win_thread_base", + "win_thread_function", + "winsock_init", + "winsock_init_base", + "basic_object_handle", + "basic_overlapped_handle", + "basic_random_access_handle", + "basic_stream_handle", + "object_handle", + "overlapped_handle", + "overlapped_ptr", + "complete_iocp_accept", + "complete_iocp_connect", + "complete_iocp_recv", + "complete_iocp_recvfrom", + "complete_iocp_recvmsg", + "complete_iocp_send", + "msghdr", +] + +# -------------------------------------------------------------------------- +# atomic + +[[atomic.guard]] +if = "defined(__GNUC__)" +reason = ''' +M11 platform guard: gcc-only branch of boost/atomic (snapshot = mingw +flavor). +''' +names = [ + "boost::atomics::detail::convert_memory_order_to_gcc", + "boost::atomics::detail::core_operations_gcc_atomic", + "boost::atomics::detail::fence_operations_gcc_atomic", +] + +[[atomic.guard]] +if = "defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))" +reason = ''' +M11 platform guard: gcc_x86 backend of boost/atomic (platform.hpp); x86 +only. +''' +names = [ + "boost::atomics::detail::core_arch_operations_gcc_x86", + "boost::atomics::detail::core_arch_operations_gcc_x86_base", + "boost::atomics::detail::fence_arch_operations_gcc_x86", +] + +[[atomic.guard]] +if = "defined(BOOST_WINDOWS)" +reason = ''' +M11 platform guard: wait_ops_windows.hpp (wait backend = windows, +platform.hpp BOOST_WINDOWS); POSIX uses futex/darwin_ulock/generic. +''' +names = [ + "boost::atomics::detail::wait_operations_windows", +] + +# -------------------------------------------------------------------------- +# beast + +[[beast.guard]] +if = "defined(_WIN32)" +reason = ''' +Beast's Win32 file and debug-stream helpers (file_win32.hpp, detail/ostream +dstream) are Windows-only. +''' +names = [ # any :: segment + "file_win32", + "set_file_pointer_ex", + "win32_unicode_path", + "highPart", + "lowPart", + "make_win32_error", + "null_lambda", + "run_write_some_win32_op", + "write_some_win32_op", + "basic_dstream", + "dstream_buf", +] + +# -------------------------------------------------------------------------- +# bloom + +[[bloom.guard]] +if = "defined(BOOST_BLOOM_SSE2)" +reason = ''' +M9 platform guard: m128ix2 is the SSE2 branch of fast_multiblock32 +(detail/sse2.hpp, __SSE2__); absent on arm64 (NEON branch). +''' +names = [ + "boost::bloom::detail::m128ix2", +] + +# -------------------------------------------------------------------------- +# charconv + +[[charconv.guard]] +if = "LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384" +reason = ''' +M11 platform guard: bit_layouts.hpp defines ieee754_binary80 only for 80-bit +long double (x86-64 gcc/mingw); MSVC long double is 53-bit. +''' +names = [ + "boost::charconv::detail::ieee754_binary80", +] + +[[charconv.guard]] +if = "defined(BOOST_CHARCONV_HAS_INT128)" +reason = ''' +M11 platform guard: to_chars128 exists only under BOOST_CHARCONV_HAS_INT128 +(to_chars_integer_impl.hpp). +''' +names = [ + "boost::charconv::detail::to_chars128", +] + +# -------------------------------------------------------------------------- +# cobalt + +[[cobalt.guard]] +if = "defined(BOOST_ASIO_HAS_FILE)" +reason = ''' +Asio's file support (basic_file and friends) is declared only where +BOOST_ASIO_HAS_FILE (IOCP / io_uring); the MinGW snapshot has it. +''' +names = [ # any :: segment + "basic_file", + "basic_random_access_file", + "basic_stream_file", + "file_base", +] + +[[cobalt.guard]] +if = "defined(_WIN32)" +reason = ''' +Asio's Windows backend (IOCP, winsock, select reactor, Windows handles), +reached through cobalt's GMF; POSIX builds the epoll/kqueue backends +instead. +''' +names = [ # any :: segment + "apc_function", + "null_reactor", + "select_reactor", + "null_signal_blocker", + "socket_select_interrupter", + "win_event", + "win_fd_set_adapter", + "win_global", + "win_global_impl", + "win_iocp_file_service", + "win_iocp_handle_read_op", + "win_iocp_handle_service", + "win_iocp_handle_write_op", + "win_iocp_io_context", + "win_iocp_null_buffers_op", + "win_iocp_operation", + "win_iocp_overlapped_ptr", + "win_iocp_serial_port_service", + "win_iocp_socket_accept_op", + "win_iocp_socket_connect_op", + "win_iocp_socket_connect_op_base", + "win_iocp_socket_move_accept_op", + "win_iocp_socket_recv_op", + "win_iocp_socket_recvfrom_op", + "win_iocp_socket_recvmsg_op", + "win_iocp_socket_send_op", + "win_iocp_socket_service", + "win_iocp_socket_service_base", + "win_iocp_thread_info", + "win_iocp_wait_op", + "win_mutex", + "win_static_mutex", + "win_thread", + "win_thread_base", + "win_thread_function", + "winsock_init", + "winsock_init_base", + "win_iocp_overlapped_op", + "win_object_handle_service", + "basic_object_handle", + "basic_overlapped_handle", + "basic_random_access_handle", + "basic_stream_handle", + "object_handle", + "overlapped_handle", + "overlapped_ptr", + "random_access_handle", + "stream_handle", + "complete_iocp_accept", + "complete_iocp_connect", + "complete_iocp_recv", + "complete_iocp_recvfrom", + "complete_iocp_recvmsg", + "complete_iocp_send", + "msghdr", +] + +# -------------------------------------------------------------------------- +# config + +[[config.guard]] +if = "defined(BOOST_HAS_INT128)" +reason = ''' +M3 hand-guard (M9: moved to config.inc): suffix.hpp defines int128_type only +where BOOST_HAS_INT128. +''' +names = [ + "boost::int128_type", +] + +[[config.guard]] +if = "defined(BOOST_HAS_INT128)" +reason = ''' +M3 hand-guard (M9: moved to config.inc): suffix.hpp defines uint128_type +only where BOOST_HAS_INT128. +''' +names = [ + "boost::uint128_type", +] + +# -------------------------------------------------------------------------- +# container + +[[container.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: win_critical_section is the non-pthread branch of +container/detail/thread_mutex.hpp; POSIX uses pthread_mutex. +''' +names = [ + "boost::container::dtl::win_critical_section", +] + +[[container.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: container_winapi DWORD_/BOOL_/SleepEx are declared only +in the _WIN32 branch of container/detail/mutex.hpp. +''' +names = [ + "::SleepEx", + "boost::container_winapi::BOOL_", + "boost::container_winapi::DWORD_", +] + +# -------------------------------------------------------------------------- +# core + +[[core.guard]] +if = "defined(__GNUC__)" +reason = ''' +M3 hand-guard: boost/core/cmath.hpp defines copysign_impl only on gcc-like +compilers. +''' +names = [ + "boost::core::detail::copysign_impl", +] + +[[core.guard]] +if = "defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)" +reason = ''' +M6 platform guard: sp_thread_sleep/yield live in boost::core::detail only on +Windows; on POSIX (nanosleep/sched_yield branch of the header) they are +declared in boost::core. +''' +names = [ + "boost::core::detail::sp_thread_sleep", + "boost::core::detail::sp_thread_yield", +] +else = [ + "using boost::core::sp_thread_sleep;", + "using boost::core::sp_thread_yield;", +] + +# -------------------------------------------------------------------------- +# date_time + +[[date_time.guard]] +if = "defined(_WIN32)" +reason = ''' +The FILETIME conversions of date_time/filetime_functions.hpp exist only on +Windows. +''' +names = [ # any :: segment + "time_from_ftime", + "from_ftime", +] + +# -------------------------------------------------------------------------- +# decimal + +[[decimal.guard]] +if = "defined(BOOST_DECIMAL_HAS_INT128)" +reason = ''' +M9 platform guard: config.hpp defines the __int128 typedefs only where +BOOST_DECIMAL_HAS_INT128 (off under the MSVC ABI). +''' +names = [ + "boost::decimal::detail::builtin_int128_t", + "boost::decimal::detail::builtin_uint128_t", +] + +[[decimal.guard]] +if = "LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384" +reason = ''' +M9 platform guard: bit_layouts.hpp defines ieee754_binary80 only for 80-bit +long double (x86-64 gcc/mingw); MSVC long double is 53-bit. +''' +names = [ + "boost::decimal::detail::ieee754_binary80", +] + +[[decimal.guard]] +if = "defined(BOOST_DECIMAL_HAS_INT128)" +reason = ''' +M9 platform guard: power_tables.hpp defines builtin_128_pow10 only under +BOOST_DECIMAL_HAS_INT128. +''' +names = [ + "boost::decimal::detail::impl::builtin_128_pow10", +] + +[[decimal.guard]] +if = "defined(__GNUC__)" +reason = ''' +The builtin carry helpers are declared only in the __GNUC__ branch. +''' +names = [ # any :: segment + "add_carry_u64", + "u256_add", +] + +[[decimal.guard]] +if = "defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128)" +reason = ''' +The 128-bit division intrinsics are declared only where +BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128 (x86-64 gcc/clang). +''' +names = [ # any :: segment + "div_mod_intrinsic", + "int128_addcarry_u64", + "int128_subborrow_u64", + "int128_udiv128_intrinsic", + "int128_umul128_intrinsic", + "mg32_div_3by2", + "mg32_reciprocal_2by1", + "mg32_u256_by_u128", +] + +# -------------------------------------------------------------------------- +# dll + +[[dll.guard]] +if = "defined(_WIN32)" +reason = ''' +M9 platform guard: last_error_code is in detail/windows/ +path_from_handle.hpp (no POSIX counterpart). +''' +names = [ + "boost::dll::detail::last_error_code", +] + +[[dll.guard]] +if = "!defined(_MSC_VER)" +reason = ''' +M9 platform guard: the itanium demangling parser (demangling/itanium.hpp) is +selected only outside _MSC_VER (dll/detail/ctor_dtor.hpp). +''' +names = [ + "boost::dll::detail::parser::arg_list", + "boost::dll::detail::parser::const_rule", + "boost::dll::detail::parser::const_rule_impl", + "boost::dll::detail::parser::dummy", + "boost::dll::detail::parser::parse_type", + "boost::dll::detail::parser::parse_type_helper", + "boost::dll::detail::parser::pure_type", + "boost::dll::detail::parser::reference_rule", + "boost::dll::detail::parser::reference_rule_impl", + "boost::dll::detail::parser::type_name", + "boost::dll::detail::parser::volatile_rule", + "boost::dll::detail::parser::volatile_rule_impl", +] + +[[dll.guard]] +if = "!defined(_MSC_VER)" +reason = ''' +M9 platform guard: demangle_symbol comes from demangling/itanium.hpp. +''' +names = [ + "boost::dll::experimental::demangle_symbol", +] + +# -------------------------------------------------------------------------- +# functional + +[[functional.guard]] +if = "defined(__GNUC__)" +reason = ''' +M9 platform guard: gcc-preprocessed mpl vector headers only. +''' +names = [ + "boost::mpl::v_at_impl", + "boost::mpl::v_item", + "boost::mpl::v_mask", +] + +# -------------------------------------------------------------------------- +# graph + +[[graph.guard]] +if = "defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING)" +reason = ''' +M11 platform guard: proto/detail/template_arity.hpp declares template_arity +only under BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc +extended-template matching). +''' +names = [ + "boost::proto::detail::template_arity", +] + +[[graph.guard]] +if = "defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING)" +reason = ''' +M11 platform guard: proto/detail/template_arity.hpp declares +template_arity_helper only under +BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template +matching). +''' +names = [ + "boost::proto::detail::template_arity_helper", +] + +[[graph.guard]] +if = "defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING)" +reason = ''' +M11 platform guard: proto/detail/template_arity.hpp declares +template_arity_impl2 only under +BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING (gcc extended-template +matching). +''' +names = [ + "boost::proto::detail::template_arity_impl2", +] + +# -------------------------------------------------------------------------- +# hof + +[[hof.guard]] +if = "!defined(_MSC_VER)" +reason = ''' +C2 platform guard: bool_seq is the non-_MSC_VER branch of detail/and.hpp +(the MSVC branch declares struct and_ instead). +''' +names = [ + "boost::hof::detail::bool_seq", +] + +[[hof.guard]] +if = "!BOOST_HOF_NO_EXPRESSION_SFINAE" +reason = ''' +C2 platform guard: callable_args is the !NO_EXPRESSION_SFINAE branch of +detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). +''' +names = [ + "boost::hof::detail::callable_args", +] + +[[hof.guard]] +if = "!BOOST_HOF_NO_EXPRESSION_SFINAE" +reason = ''' +C2 platform guard: called_val is the !NO_EXPRESSION_SFINAE branch of +detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). +''' +names = [ + "boost::hof::detail::called_val", +] + +[[hof.guard]] +if = "!BOOST_HOF_NO_EXPRESSION_SFINAE" +reason = ''' +C2 platform guard: can_be_called_impl is the !NO_EXPRESSION_SFINAE branch of +detail/can_be_called.hpp (config.hpp: _MSC_VER → 1). +''' +names = [ + "boost::hof::detail::can_be_called_impl", +] + +[[hof.guard]] +if = "!BOOST_HOF_NO_ORDERED_BRACE_INIT" +reason = ''' +C2 platform guard: eval_helper is the !NO_ORDERED_BRACE_INIT branch of +apply_eval.hpp (config.hpp: _MSC_VER → 1). +''' +names = [ + "boost::hof::detail::eval_helper", +] + +[[hof.guard]] +if = "!defined(_MSC_VER)" +reason = ''' +C2 platform guard: operators::decrement is the #ifndef _MSC_VER branch of +placeholders.hpp (MSVC 2017 ICE on ++/-- constexpr). +''' +names = [ + "boost::hof::operators::decrement", +] + +[[hof.guard]] +if = "!defined(_MSC_VER)" +reason = ''' +C2 platform guard: operators::increment is the #ifndef _MSC_VER branch of +placeholders.hpp (MSVC 2017 ICE on ++/-- constexpr). +''' +names = [ + "boost::hof::operators::increment", +] + +# -------------------------------------------------------------------------- +# interprocess + +[[interprocess.guard]] +if = "defined(_WIN32)" +reason = ''' +M12 platform guard: the interprocess::winapi surface (detail/win32_api.hpp) +is Windows-only; POSIX interprocess never declares it. +''' +names = [ + "boost::interprocess::winapi::NtClose_t", + "boost::interprocess::winapi::NtDeleteFile_t", + "boost::interprocess::winapi::NtOpenFile", + "boost::interprocess::winapi::NtOpenFile_t", + "boost::interprocess::winapi::NtQueryInformationFile_t", + "boost::interprocess::winapi::NtQueryObject_t", + "boost::interprocess::winapi::NtQuerySection_t", + "boost::interprocess::winapi::NtQuerySemaphore_t", + "boost::interprocess::winapi::NtQuerySystemInformation_t", + "boost::interprocess::winapi::NtQueryTimerResolution_t", + "boost::interprocess::winapi::NtSetInformationFile_t", + "boost::interprocess::winapi::NtSetTimerResolution_t", + "boost::interprocess::winapi::buffer_to_narrow_str", + "boost::interprocess::winapi::buffer_to_wide_str", + "boost::interprocess::winapi::c_heap_deleter", + "boost::interprocess::winapi::close_handle", + "boost::interprocess::winapi::create_directory", + "boost::interprocess::winapi::create_file", + "boost::interprocess::winapi::create_file_mapping", + "boost::interprocess::winapi::dll_func", + "boost::interprocess::winapi::duplicate_current_process_handle", + "boost::interprocess::winapi::farproc_t", + "boost::interprocess::winapi::file_information_class_t", + "boost::interprocess::winapi::file_information_class_t::file_access_information", + "boost::interprocess::winapi::file_information_class_t::file_alignment_information", + "boost::interprocess::winapi::file_information_class_t::file_all_information", + "boost::interprocess::winapi::file_information_class_t::file_allocation_information", + "boost::interprocess::winapi::file_information_class_t::file_alternate_name_information", + "boost::interprocess::winapi::file_information_class_t::file_basic_information", + "boost::interprocess::winapi::file_information_class_t::file_both_directory_information", + "boost::interprocess::winapi::file_information_class_t::file_completion_information", + "boost::interprocess::winapi::file_information_class_t::file_compression_information", + "boost::interprocess::winapi::file_information_class_t::file_content_index_information", + "boost::interprocess::winapi::file_information_class_t::file_copy_on_write_information", + "boost::interprocess::winapi::file_information_class_t::file_directory_information", + "boost::interprocess::winapi::file_information_class_t::file_disposition_information", + "boost::interprocess::winapi::file_information_class_t::file_ea_information", + "boost::interprocess::winapi::file_information_class_t::file_end_of_file_information", + "boost::interprocess::winapi::file_information_class_t::file_full_directory_information", + "boost::interprocess::winapi::file_information_class_t::file_full_ea_information", + "boost::interprocess::winapi::file_information_class_t::file_inherit_content_index_information", + "boost::interprocess::winapi::file_information_class_t::file_internal_information", + "boost::interprocess::winapi::file_information_class_t::file_link_information", + "boost::interprocess::winapi::file_information_class_t::file_mailslot_query_information", + "boost::interprocess::winapi::file_information_class_t::file_mailslot_set_information", + "boost::interprocess::winapi::file_information_class_t::file_maximum_information", + "boost::interprocess::winapi::file_information_class_t::file_mode_information", + "boost::interprocess::winapi::file_information_class_t::file_move_cluster_information", + "boost::interprocess::winapi::file_information_class_t::file_name_information", + "boost::interprocess::winapi::file_information_class_t::file_names_information", + "boost::interprocess::winapi::file_information_class_t::file_network_open_information", + "boost::interprocess::winapi::file_information_class_t::file_object_id_information", + "boost::interprocess::winapi::file_information_class_t::file_ole_directory_information", + "boost::interprocess::winapi::file_information_class_t::file_ole_information", + "boost::interprocess::winapi::file_information_class_t::file_pipe_information", + "boost::interprocess::winapi::file_information_class_t::file_pipe_local_information", + "boost::interprocess::winapi::file_information_class_t::file_pipe_remote_information", + "boost::interprocess::winapi::file_information_class_t::file_position_information", + "boost::interprocess::winapi::file_information_class_t::file_quota_information", + "boost::interprocess::winapi::file_information_class_t::file_rename_information", + "boost::interprocess::winapi::file_information_class_t::file_reparse_point_information", + "boost::interprocess::winapi::file_information_class_t::file_standard_information", + "boost::interprocess::winapi::file_information_class_t::file_stream_information", + "boost::interprocess::winapi::file_information_class_t::file_tracking_information", + "boost::interprocess::winapi::file_rename_information_t", + "boost::interprocess::winapi::find_close", + "boost::interprocess::winapi::find_first_file", + "boost::interprocess::winapi::find_next_file", + "boost::interprocess::winapi::flush_file_buffers", + "boost::interprocess::winapi::flush_view_of_file", + "boost::interprocess::winapi::format_message", + "boost::interprocess::winapi::free_library", + "boost::interprocess::winapi::function_address_holder", + "boost::interprocess::winapi::get_boot_and_system_time", + "boost::interprocess::winapi::get_boot_and_system_time_wstr", + "boost::interprocess::winapi::get_boot_time", + "boost::interprocess::winapi::get_boot_time_str", + "boost::interprocess::winapi::get_current_process", + "boost::interprocess::winapi::get_current_process_id", + "boost::interprocess::winapi::get_current_thread_id", + "boost::interprocess::winapi::get_file_information_by_handle", + "boost::interprocess::winapi::get_file_mapping_size", + "boost::interprocess::winapi::get_file_size", + "boost::interprocess::winapi::get_file_type", + "boost::interprocess::winapi::get_last_bootup_time", + "boost::interprocess::winapi::get_last_error", + "boost::interprocess::winapi::get_module_handle", + "boost::interprocess::winapi::get_proc_address", + "boost::interprocess::winapi::get_process_times", + "boost::interprocess::winapi::get_registry_value", + "boost::interprocess::winapi::get_registry_value_buffer", + "boost::interprocess::winapi::get_registry_value_string", + "boost::interprocess::winapi::get_semaphore_info", + "boost::interprocess::winapi::get_shared_documents_folder", + "boost::interprocess::winapi::get_system_info", + "boost::interprocess::winapi::get_system_time_of_day_information", + "boost::interprocess::winapi::get_temp_path", + "boost::interprocess::winapi::get_tick_count", + "boost::interprocess::winapi::handle_closer", + "boost::interprocess::winapi::hkey", + "boost::interprocess::winapi::hmodule", + "boost::interprocess::winapi::initialize_object_attributes", + "boost::interprocess::winapi::interlocked_compare_exchange", + "boost::interprocess::winapi::interlocked_decrement", + "boost::interprocess::winapi::interlocked_exchange", + "boost::interprocess::winapi::interlocked_exchange_add", + "boost::interprocess::winapi::interlocked_increment", + "boost::interprocess::winapi::interprocess_all_access_security", + "boost::interprocess::winapi::interprocess_by_handle_file_information", + "boost::interprocess::winapi::interprocess_filetime", + "boost::interprocess::winapi::interprocess_overlapped", + "boost::interprocess::winapi::interprocess_section_basic_information", + "boost::interprocess::winapi::interprocess_security_attributes", + "boost::interprocess::winapi::interprocess_security_descriptor", + "boost::interprocess::winapi::interprocess_semaphore_basic_information", + "boost::interprocess::winapi::interprocess_system_info", + "boost::interprocess::winapi::io_status_block_t", + "boost::interprocess::winapi::is_directory", + "boost::interprocess::winapi::library_unloader", + "boost::interprocess::winapi::load_library", + "boost::interprocess::winapi::local_free", + "boost::interprocess::winapi::lock_file_ex", + "boost::interprocess::winapi::make_lang_id", + "boost::interprocess::winapi::map_view_of_file_ex", + "boost::interprocess::winapi::nt_query_mem_deleter", + "boost::interprocess::winapi::ntquery_mem_t", + "boost::interprocess::winapi::object_attributes_t", + "boost::interprocess::winapi::object_information_class", + "boost::interprocess::winapi::object_information_class::object_all_information", + "boost::interprocess::winapi::object_information_class::object_basic_information", + "boost::interprocess::winapi::object_information_class::object_data_information", + "boost::interprocess::winapi::object_information_class::object_name_information", + "boost::interprocess::winapi::object_information_class::object_type_information", + "boost::interprocess::winapi::object_name_information_t", + "boost::interprocess::winapi::open_file_mapping", + "boost::interprocess::winapi::open_or_create_mutex", + "boost::interprocess::winapi::open_or_create_semaphore", + "boost::interprocess::winapi::open_semaphore", + "boost::interprocess::winapi::query_performance_counter", + "boost::interprocess::winapi::query_performance_frequency", + "boost::interprocess::winapi::query_timer_resolution", + "boost::interprocess::winapi::read_file", + "boost::interprocess::winapi::reg_close_key", + "boost::interprocess::winapi::reg_closer", + "boost::interprocess::winapi::reg_open_key_ex", + "boost::interprocess::winapi::reg_query_value_ex", + "boost::interprocess::winapi::release_mutex", + "boost::interprocess::winapi::release_semaphore", + "boost::interprocess::winapi::remove_directory", + "boost::interprocess::winapi::rtl_init_empty_unicode_string", + "boost::interprocess::winapi::sched_yield", + "boost::interprocess::winapi::section_information_class", + "boost::interprocess::winapi::section_information_class::section_basic_information", + "boost::interprocess::winapi::section_information_class::section_image_information", + "boost::interprocess::winapi::semaphore_information_class", + "boost::interprocess::winapi::semaphore_information_class::semaphore_basic_information", + "boost::interprocess::winapi::set_end_of_file", + "boost::interprocess::winapi::set_file_pointer", + "boost::interprocess::winapi::set_last_error", + "boost::interprocess::winapi::sleep", + "boost::interprocess::winapi::sleep_tick", + "boost::interprocess::winapi::system_information_class", + "boost::interprocess::winapi::system_information_class::system_basic_information", + "boost::interprocess::winapi::system_information_class::system_exception_information", + "boost::interprocess::winapi::system_information_class::system_interrupt_information", + "boost::interprocess::winapi::system_information_class::system_lookaside_information", + "boost::interprocess::winapi::system_information_class::system_performance_information", + "boost::interprocess::winapi::system_information_class::system_process_information", + "boost::interprocess::winapi::system_information_class::system_processor_performance_information", + "boost::interprocess::winapi::system_information_class::system_registry_quota_information", + "boost::interprocess::winapi::system_information_class::system_time_of_day_information", + "boost::interprocess::winapi::system_timeofday_information", + "boost::interprocess::winapi::unicode_string_t", + "boost::interprocess::winapi::unlink_file", + "boost::interprocess::winapi::unlock_file_ex", + "boost::interprocess::winapi::unmap_view_of_file", + "boost::interprocess::winapi::virtual_protect", + "boost::interprocess::winapi::virtual_unlock", + "boost::interprocess::winapi::wait_for_single_object", + "boost::interprocess::winapi::win32_find_data_a", + "boost::interprocess::winapi::win32_find_data_w", + "boost::interprocess::winapi::winapi_traits", + "boost::interprocess::winapi::write_file", +] + +[[interprocess.guard]] +if = "defined(_WIN32)" +reason = ''' +M12 platform guard: registry / virtual-memory extension surface — +Windows-only (win32_api.hpp chain). +''' +names = [ + "boost::ipwinapiext::CreateThread", + "boost::ipwinapiext::FlushFileBuffers", + "boost::ipwinapiext::GetFileType", + "boost::ipwinapiext::GetSystemInfo", + "boost::ipwinapiext::HKEY_", + "boost::ipwinapiext::LPTHREAD_START_ROUTINE_", + "boost::ipwinapiext::LSTATUS", + "boost::ipwinapiext::RegCloseKey", + "boost::ipwinapiext::RegOpenKeyExA", + "boost::ipwinapiext::RegOpenKeyExW", + "boost::ipwinapiext::RegQueryValueExA", + "boost::ipwinapiext::RegQueryValueExW", + "boost::ipwinapiext::SetLastError", + "boost::ipwinapiext::VirtualLock", + "boost::ipwinapiext::VirtualProtect", + "boost::ipwinapiext::VirtualUnlock", +] + +[[interprocess.guard]] +if = "defined(_WIN32)" +reason = ''' +The Windows shared-memory and synchronization surface (detail/win32_api.hpp +chain); POSIX interprocess never declares it. +''' +names = [ # any :: segment + "basic_managed_windows_shared_memory", + "managed_windows_shared_memory", + "windows_shared_memory", + "wmanaged_windows_shared_memory", + "do_winapi_wait", + "winapi_mutex_functions", + "winapi_mutex_wrapper", + "winapi_semaphore_functions", + "winapi_semaphore_wrapper", + "winapi_wrapper_timed_wait_for_single_object", + "winapi_wrapper_try_wait_for_single_object", + "winapi_wrapper_wait_for_single_object", + "windows_bootstamp", + "windows_intermodule_singleton", + "windows_semaphore_based_map", + "file_time_to_microseconds", + "get_bootstamp", + "get_temporary_wpath", + "intermodule_singleton_common", + "intermodule_singleton_impl", + "mapping_handle_from_shm_handle", + "os_file_traits", + "ref_count_ptr", + "shm_named_mutex", + "shm_named_semaphore", + "spin_condition", + "spin_mutex", + "spin_recursive_mutex", + "spin_semaphore", + "unrestricted_permissions_holder", + "wshmem_open_or_create", + "get_map_base_name", + "get_map_name", + "get_map_size", + "get_pid_creation_time_str", + "thread_safe_global_map_dependant", + "mutex_traits", +] + +# -------------------------------------------------------------------------- +# intrusive + +[[intrusive.guard]] +if = "defined(__GNUC__)" +reason = ''' +M9 platform guard: math.hpp defines builtin_clz_dispatch only in the +__GNUC__ branch of the BSR intrinsic chain. +''' +names = [ + "boost::intrusive::detail::builtin_clz_dispatch", +] + +# -------------------------------------------------------------------------- +# iostreams + +[[iostreams.guard]] +if = '''defined(BOOST_IOSTREAMS_NO_PRIMARY_CODECVT_DEFINITION) || \ + defined(BOOST_IOSTREAMS_EMPTY_PRIMARY_CODECVT_DEFINITION) || \ + defined(BOOST_IOSTREAMS_NO_LOCALE)''' +reason = ''' +M11 platform guard: detail/codecvt_helper.hpp declares codecvt_impl only on +these std::codecvt workaround paths (libstdc++ mingw snapshot); the MSVC STL +takes none of them. +''' +names = [ + "boost::iostreams::detail::codecvt_impl", +] + +# -------------------------------------------------------------------------- +# lambda + +[[lambda.guard]] +if = "!defined(BOOST_NO_CXX98_RANDOM_SHUFFLE)" +reason = ''' +C4 flavor guard: random_shuffle is the !BOOST_NO_CXX98_RANDOM_SHUFFLE branch +of algorithm.hpp (MSVC STL/libc++ under C++17 removed std::random_shuffle). +''' +names = [ + "boost::lambda::ll::random_shuffle", +] + +# -------------------------------------------------------------------------- +# leaf + +[[leaf.extra]] +namespace = "boost::leaf::detail" +reason = ''' +M9: gcc 16.1.0 module consumers emit a partial vtable for +exception (multi-base exception_base/error_id) whose non-virtual +thunks stay undefined — gcc never emits them in a module consumer TU. This +extern template suppresses the consumer's implicit instantiation; the +complete vtable + thunks come from the explicit instantiation in +port/leaf_extras.cpp (same pattern as thread's clone_impl, cf. M7c). +''' +lines = [ + "extern template class boost::leaf::detail::exception;", +] + +# -------------------------------------------------------------------------- +# math + +[[math.guard]] +if = "LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384" +reason = ''' +M11 platform guard: cstdfloat_types.hpp declares the 80-bit long-double +typedefs only where long double really is 80-bit; MSVC long double is +53-bit. +''' +names = [ + "boost::float80_t", + "boost::float_fast80_t", + "boost::float_least80_t", +] + +[[math.guard]] +if = "defined(BOOST_MATH_EXEC_COMPATIBLE)" +reason = ''' +M11 CI platform guard: statistics chatterjee_correlation_par_impl is defined +only under BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / +bivariate_statistics.hpp); libc++ lacks __cpp_lib_execution. +''' +names = [ + "boost::math::statistics::detail::chatterjee_correlation_par_impl", +] + +[[math.guard]] +if = "defined(BOOST_MATH_EXEC_COMPATIBLE)" +reason = ''' +M11 CI platform guard: statistics correlation_coefficient_parallel_impl is +defined only under BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / +bivariate_statistics.hpp); libc++ lacks __cpp_lib_execution. +''' +names = [ + "boost::math::statistics::detail::correlation_coefficient_parallel_impl", +] + +[[math.guard]] +if = "defined(BOOST_MATH_EXEC_COMPATIBLE)" +reason = ''' +M11 CI platform guard: statistics means_and_covariance_parallel_impl is +defined only under BOOST_MATH_EXEC_COMPATIBLE (chatterjee_correlation.hpp / +bivariate_statistics.hpp); libc++ lacks __cpp_lib_execution. +''' +names = [ + "boost::math::statistics::detail::means_and_covariance_parallel_impl", +] + +# -------------------------------------------------------------------------- +# mp11 + +[[mp11.guard]] +if = "!defined(__GNUC__)" +reason = ''' +M3 hand-guard: mp_map_find.hpp (gcc bug 120161 workaround) defines mpmf_* +only outside gcc. +''' +names = [ + "boost::mp11::detail::mpmf_unwrap", + "boost::mp11::detail::mpmf_wrap", +] + +# -------------------------------------------------------------------------- +# multiprecision + +[[multiprecision.guard]] +if = "defined(BOOST_HAS_INT128)" +reason = ''' +M12 platform guard: detail/standalone_config.hpp defines int128_type only +under BOOST_HAS_INT128 (off under the clang-msvc flavor). +''' +names = [ + "boost::multiprecision::int128_type", +] + +[[multiprecision.guard]] +if = "defined(BOOST_HAS_INT128)" +reason = ''' +M12 platform guard: as above (uint128_type). +''' +names = [ + "boost::multiprecision::uint128_type", +] + +[[multiprecision.guard]] +if = "defined(BOOST_HAS_INT128)" +reason = ''' +M12 platform guard: divide_subtract is the synthetic-double_limb_type +division branch of cpp_int/misc.hpp (BOOST_HAS_INT128 only). +''' +names = [ + "boost::multiprecision::backends::divide_subtract", +] + +[[multiprecision.guard]] +if = "defined(BOOST_HAS_INT128)" +reason = ''' +M12 platform guard: as above (divide_unsigned_helper). +''' +names = [ + "boost::multiprecision::backends::divide_unsigned_helper", +] + +[[multiprecision.guard]] +if = "defined(BOOST_MP_HAS_IMMINTRIN_H)" +reason = ''' +M11 platform guard: cpp_int/intel_intrinsics.hpp declares addcarry_limb only +under BOOST_MP_HAS_IMMINTRIN_H (the adc intrinsics dispatch — clang on macOS +arm64 unsets the macro because __builtin_ia32_addcarryx_u64 is a gcc-only +builtin and BOOST_GCC is not defined). +''' +names = [ + "boost::multiprecision::detail::addcarry_limb", +] + +[[multiprecision.guard]] +if = "defined(BOOST_MP_HAS_IMMINTRIN_H)" +reason = ''' +M11 platform guard: cpp_int/intel_intrinsics.hpp declares subborrow_limb +only under BOOST_MP_HAS_IMMINTRIN_H (see addcarry_limb guard for rationale). +''' +names = [ + "boost::multiprecision::detail::subborrow_limb", +] + +[[multiprecision.guard]] +if = "defined(BOOST_HAS_INT128)" +reason = ''' +M12 platform guard: serialize.hpp's `using namespace +boost::multiprecision(::backends)` exposes the divide_subtract entity into +cpp_int_detail — present only under BOOST_HAS_INT128. +''' +names = [ + "boost::serialization::cpp_int_detail::divide_subtract", +] + +[[multiprecision.guard]] +if = "defined(BOOST_HAS_INT128)" +reason = ''' +M12 platform guard: serialize.hpp's `using namespace +boost::multiprecision(::backends)` exposes the int128_type entity into +cpp_int_detail — present only under BOOST_HAS_INT128. +''' +names = [ + "boost::serialization::cpp_int_detail::int128_type", +] + +[[multiprecision.guard]] +if = "defined(BOOST_HAS_INT128)" +reason = ''' +M12 platform guard: serialize.hpp's `using namespace +boost::multiprecision(::backends)` exposes the uint128_type entity into +cpp_int_detail — present only under BOOST_HAS_INT128. +''' +names = [ + "boost::serialization::cpp_int_detail::uint128_type", +] + +# -------------------------------------------------------------------------- +# nowide + +[[nowide.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: console_input_buffer is the windows console machinery +(detail/console_buffer.hpp); POSIX nowide uses std:: streams directly. +''' +names = [ + "boost::nowide::detail::console_input_buffer", +] + +[[nowide.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: console_output_buffer is the windows console machinery +(detail/console_buffer.hpp); POSIX nowide uses std:: streams directly. +''' +names = [ + "boost::nowide::detail::console_output_buffer", +] + +[[nowide.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: detail::stat is the BOOST_WINDOWS branch of stat.hpp; +POSIX exposes ::stat via a using-declaration instead. +''' +names = [ + "boost::nowide::detail::stat", +] + +[[nowide.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: winconsole_istream is the windows console stream branch +of iostream.hpp; POSIX takes std:: streams directly. +''' +names = [ + "boost::nowide::detail::winconsole_istream", +] + +[[nowide.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: winconsole_ostream is the windows console stream branch +of iostream.hpp; POSIX takes std:: streams directly. +''' +names = [ + "boost::nowide::detail::winconsole_ostream", +] + +# -------------------------------------------------------------------------- +# numeric + +[[numeric.guard]] +if = "!defined(NDEBUG) && !defined(BOOST_UBLAS_NDEBUG)" +reason = ''' +Boost.uBLAS declares same_impl_ex only when size checks are on; a release +build (NDEBUG) takes BOOST_UBLAS_USE_FAST_SAME and never declares it. +''' +names = [ # any :: segment + "same_impl_ex", +] + +# -------------------------------------------------------------------------- +# pfr + +[[pfr.guard]] +if = "defined(__clang__)" +reason = ''' +M9 platform guard: clang_wrapper_t is the clang-only NTTP wrapper +(core_name20_static.hpp #ifdef __clang__ branch). +''' +names = [ + "boost::pfr::detail::clang_wrapper_t", +] + +[[pfr.guard]] +if = "BOOST_PFR_USE_CPP26_REFLECTION || BOOST_PFR_USE_CPP26" +reason = ''' +M9 platform guard: fields_count_dispatch_impl exists only under the C++26 +reflection / structured-bindings branches (fields_count.hpp). +''' +names = [ + "boost::pfr::detail::fields_count_dispatch_impl", +] + +# -------------------------------------------------------------------------- +# poly_collection + +[[poly_collection.guard]] +if = "defined(__GNUC__)" +reason = ''' +M9 platform guard: gcc-preprocessed mpl map headers only. +''' +names = [ + "boost::mpl::item_by_order_impl", +] + +# -------------------------------------------------------------------------- +# process + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: v1 detail windows impls (incl. the NT workaround block +below) are declared only by the windows GMF branches. +''' +names = [ + "boost::process::v1::detail::windows::apply_out_handles", + "boost::process::v1::detail::windows::associate_completion_port", + "boost::process::v1::detail::windows::async_handler", + "boost::process::v1::detail::windows::async_handler_collector", + "boost::process::v1::detail::windows::async_in_buffer", + "boost::process::v1::detail::windows::async_out_buffer", + "boost::process::v1::detail::windows::async_out_future", + "boost::process::v1::detail::windows::async_pipe", + "boost::process::v1::detail::windows::async_pipe_in", + "boost::process::v1::detail::windows::async_pipe_out", + "boost::process::v1::detail::windows::basic_environment_impl", + "boost::process::v1::detail::windows::basic_pipe", + "boost::process::v1::detail::windows::break_away_enabled", + "boost::process::v1::detail::windows::build_args", + "boost::process::v1::detail::windows::child_handle", + "boost::process::v1::detail::windows::close_in", + "boost::process::v1::detail::windows::close_out", + "boost::process::v1::detail::windows::cmd_setter_", + "boost::process::v1::detail::windows::compare_handles", + "boost::process::v1::detail::windows::create_no_window_", + "boost::process::v1::detail::windows::does_require_io_context", + "boost::process::v1::detail::windows::enable_break_away", + "boost::process::v1::detail::windows::env_init", + "boost::process::v1::detail::windows::env_seperator", + "boost::process::v1::detail::windows::eval_exit_status", + "boost::process::v1::detail::windows::exe_cmd_init", + "boost::process::v1::detail::windows::executor", + "boost::process::v1::detail::windows::file_descriptor", + "boost::process::v1::detail::windows::file_in", + "boost::process::v1::detail::windows::file_out", + "boost::process::v1::detail::windows::get_handles", + "boost::process::v1::detail::windows::get_id", + "boost::process::v1::detail::windows::group_handle", + "boost::process::v1::detail::windows::group_ref", + "boost::process::v1::detail::windows::handler_base_ext", + "boost::process::v1::detail::windows::in_group", + "boost::process::v1::detail::windows::io_context_ref", + "boost::process::v1::detail::windows::is_async_handler", + "boost::process::v1::detail::windows::is_running", + "boost::process::v1::detail::windows::is_stream_handle", + "boost::process::v1::detail::windows::limit_handles_", + "boost::process::v1::detail::windows::make_executor", + "boost::process::v1::detail::windows::make_pipe_name", + "boost::process::v1::detail::windows::native_environment_impl", + "boost::process::v1::detail::windows::native_handle", + "boost::process::v1::detail::windows::native_handle_t", + "boost::process::v1::detail::windows::native_handle_type", + "boost::process::v1::detail::windows::null_in", + "boost::process::v1::detail::windows::null_out", + "boost::process::v1::detail::windows::on_exit_", + "boost::process::v1::detail::windows::on_exit_handler_transformer", + "boost::process::v1::detail::windows::operator!=", + "boost::process::v1::detail::windows::operator==", + "boost::process::v1::detail::windows::pid_t", + "boost::process::v1::detail::windows::pipe_in", + "boost::process::v1::detail::windows::pipe_out", + "boost::process::v1::detail::windows::require_io_context", + "boost::process::v1::detail::windows::search_path", + "boost::process::v1::detail::windows::shell_path", + "boost::process::v1::detail::windows::show_window", + "boost::process::v1::detail::windows::start_dir_init", + "boost::process::v1::detail::windows::startup_info", + "boost::process::v1::detail::windows::startup_info_ex", + "boost::process::v1::detail::windows::startup_info_impl", + "boost::process::v1::detail::windows::terminate", + "boost::process::v1::detail::windows::wait", + "boost::process::v1::detail::windows::wait_for", + "boost::process::v1::detail::windows::wait_impl", + "boost::process::v1::detail::windows::wait_until", + "boost::process::v1::detail::windows::windows_file_codecvt", + "boost::process::v1::detail::windows::workaround::GENERIC_MAPPING_", + "boost::process::v1::detail::windows::workaround::OBJECT_BASIC_INFORMATION_", + "boost::process::v1::detail::windows::workaround::OBJECT_INFORMATION_CLASS_", + "boost::process::v1::detail::windows::workaround::OBJECT_NAME_INFORMATION_", + "boost::process::v1::detail::windows::workaround::POBJECT_BASIC_INFORMATION_", + "boost::process::v1::detail::windows::workaround::POBJECT_INFORMATION_CLASS_", + "boost::process::v1::detail::windows::workaround::POBJECT_NAME_INFORMATION_", + "boost::process::v1::detail::windows::workaround::PSYSTEM_HANDLE_ENTRY_", + "boost::process::v1::detail::windows::workaround::PSYSTEM_HANDLE_INFORMATION_", + "boost::process::v1::detail::windows::workaround::PUNICODE_STRING_", + "boost::process::v1::detail::windows::workaround::SYSTEM_HANDLE_ENTRY_", + "boost::process::v1::detail::windows::workaround::SYSTEM_HANDLE_INFORMATION_", + "boost::process::v1::detail::windows::workaround::UNICODE_STRING_", + "boost::process::v1::detail::windows::workaround::_GENERIC_MAPPING_", + "boost::process::v1::detail::windows::workaround::_OBJECT_BASIC_INFORMATION", + "boost::process::v1::detail::windows::workaround::_OBJECT_INFORMATION_CLASS_", + "boost::process::v1::detail::windows::workaround::_OBJECT_INFORMATION_CLASS_::ObjectAllInformation", + "boost::process::v1::detail::windows::workaround::_OBJECT_INFORMATION_CLASS_::ObjectBasicInformation", + "boost::process::v1::detail::windows::workaround::_OBJECT_INFORMATION_CLASS_::ObjectDataInformation", + "boost::process::v1::detail::windows::workaround::_OBJECT_INFORMATION_CLASS_::ObjectNameInformation", + "boost::process::v1::detail::windows::workaround::_OBJECT_INFORMATION_CLASS_::ObjectTypeInformation", + "boost::process::v1::detail::windows::workaround::_OBJECT_NAME_INFORMATION", + "boost::process::v1::detail::windows::workaround::_SYSTEM_HANDLE_ENTRY_", + "boost::process::v1::detail::windows::workaround::_SYSTEM_HANDLE_INFORMATION_", + "boost::process::v1::detail::windows::workaround::_UNICODE_STRING_", + "boost::process::v1::detail::windows::workaround::get_queued_completion_status", + "boost::process::v1::detail::windows::workaround::nt_query_object", + "boost::process::v1::detail::windows::workaround::nt_system_query_information", + "boost::process::v1::detail::windows::workaround::set_information_job_object", +] + +[[process.guard]] +if = "defined(__MINGW32__)" +reason = ''' +M11 platform guard: _popen is the MinGW spelling of popen (mingw stdio.h +#defines popen to _popen); MSVC/POSIX expose popen. +''' +names = [ + "boost::process::v2::_popen", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: all_are_initializers is the windows generic-launcher +machinery (flat v2::detail); POSIX nests a different set under +v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::all_are_initializers", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: base is the windows generic-launcher machinery (flat +v2::detail); POSIX nests a different set under v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::base", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: basic_process_handle_win is the windows variant +(detail/process_handle_windows.hpp); POSIX takes process_handle_fd. +''' +names = [ + "boost::process::v2::detail::basic_process_handle_win", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: check_handle_ lives in detail/process_handle_windows.hpp +(no fd-variant counterpart). +''' +names = [ + "boost::process::v2::detail::check_handle_", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: check_pid_ lives in detail/process_handle_windows.hpp +(no fd-variant counterpart). +''' +names = [ + "boost::process::v2::detail::check_pid_", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: check_running_ lives in +detail/process_handle_windows.hpp (no fd-variant counterpart). +''' +names = [ + "boost::process::v2::detail::check_running_", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: derived is the windows generic-launcher machinery (flat +v2::detail); POSIX nests a different set under v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::derived", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: get_exit_code_ lives in +detail/process_handle_windows.hpp (no fd-variant counterpart). +''' +names = [ + "boost::process::v2::detail::get_exit_code_", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: handle_closer is the Windows stdio handle wrapper +(DWORD/GetStdHandle); POSIX stdio does not declare it. +''' +names = [ + "boost::process::v2::detail::handle_closer", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: has_on_error is the windows generic-launcher machinery +(flat v2::detail); POSIX nests a different set under v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::has_on_error", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: has_on_setup is the windows generic-launcher machinery +(flat v2::detail); POSIX nests a different set under v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::has_on_setup", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: has_on_success is the windows generic-launcher machinery +(flat v2::detail); POSIX nests a different set under v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::has_on_success", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: interrupt_ lives in detail/process_handle_windows.hpp +(no fd-variant counterpart). +''' +names = [ + "boost::process::v2::detail::interrupt_", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: invoke_on_error is the windows generic-launcher +machinery (flat v2::detail); POSIX nests a different set under +v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::invoke_on_error", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: invoke_on_setup is the windows generic-launcher +machinery (flat v2::detail); POSIX nests a different set under +v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::invoke_on_setup", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: invoke_on_success is the windows generic-launcher +machinery (flat v2::detail); POSIX nests a different set under +v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::invoke_on_success", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: is_initializer is the windows generic-launcher machinery +(flat v2::detail); POSIX nests a different set under v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::is_initializer", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: on_error is the windows generic-launcher machinery (flat +v2::detail); POSIX nests a different set under v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::on_error", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: on_setup is the windows generic-launcher machinery (flat +v2::detail); POSIX nests a different set under v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::on_setup", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: on_success is the windows generic-launcher machinery +(flat v2::detail); POSIX nests a different set under v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::on_success", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: open_process_ lives in +detail/process_handle_windows.hpp. +''' +names = [ + "boost::process::v2::detail::open_process_", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: probe_on_error is the windows generic-launcher machinery +(flat v2::detail); POSIX nests a different set under v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::probe_on_error", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: probe_on_setup is the windows generic-launcher machinery +(flat v2::detail); POSIX nests a different set under v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::probe_on_setup", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: probe_on_success is the windows generic-launcher +machinery (flat v2::detail); POSIX nests a different set under +v2::posix::detail. +''' +names = [ + "boost::process::v2::detail::probe_on_success", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: request_exit_ lives in detail/process_handle_windows.hpp +(no fd-variant counterpart). +''' +names = [ + "boost::process::v2::detail::request_exit_", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: resume_ lives in detail/process_handle_windows.hpp (no +fd-variant counterpart). +''' +names = [ + "boost::process::v2::detail::resume_", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: suspend_ lives in detail/process_handle_windows.hpp (no +fd-variant counterpart). +''' +names = [ + "boost::process::v2::detail::suspend_", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: terminate_ lives in detail/process_handle_windows.hpp +(no fd-variant counterpart). +''' +names = [ + "boost::process::v2::detail::terminate_", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: terminate_if_running_ lives in +detail/process_handle_windows.hpp (no fd-variant counterpart). +''' +names = [ + "boost::process::v2::detail::terminate_if_running_", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: is_exec_type lives in detail/environment_win.hpp; POSIX +environment detail does not declare it. +''' +names = [ + "boost::process::v2::environment::detail::is_exec_type", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +M11 platform guard: v2 windows launchers are Windows-only headers. +''' +names = [ + "boost::process::v2::windows::as_user_launcher", + "boost::process::v2::windows::default_launcher", + "boost::process::v2::windows::process_creation_flags", + "boost::process::v2::windows::process_show_window", + "boost::process::v2::windows::with_logon_launcher", + "boost::process::v2::windows::with_token_launcher", +] + +[[process.guard]] +if = "defined(_WIN32)" +reason = ''' +The boost::asio::windows handles that process's Windows launcher reaches +(stream_handle, basic_object_handle) exist only on Windows. +''' +names = [ # any :: segment + "stream_handle", + "boost::asio::windows::basic_object_handle", +] + +# -------------------------------------------------------------------------- +# program_options + +[[program_options.guard]] +if = "defined(_WIN32)" +reason = ''' +M6 platform guard: winmain.hpp (split_winmain) is Windows-only. +''' +names = [ + "boost::program_options::split_winmain", +] + +# -------------------------------------------------------------------------- +# qvm + +[[qvm.guard]] +if = "defined(__GNUC__) && defined(__SSE2__)" +reason = ''' +M12 platform guard: vec_traits_gnuc.hpp declares vec_traits_gnuc_impl only +under __GNUC__ && __SSE2__ (gcc vector_size ext_vector_traits). +''' +names = [ + "boost::qvm::qvm_detail::vec_traits_gnuc_impl", +] + +# -------------------------------------------------------------------------- +# range + +[[range.guard]] +if = "defined(__GLIBCXX__)" +reason = ''' +M9 platform guard: std::random_shuffle was removed in C++17; only libstdc++ +(mingw/linux-gcc) still provides it. +''' +names = [ + "std::random_shuffle", +] + +[range.facade] +omit-imports = ["regex"] +reason = ''' +The regex adaptors reference entities regex owns, but src/range.cppm does not +`export import` regex: gcc 16.1.0 rejects the boost::regex v5 abi-tag surface +inside a module interface (see [algorithm]), so the edge stays out of the +facade. +''' + +# -------------------------------------------------------------------------- +# scope + +[scope.facade] +omit-imports = ["core"] +reason = ''' +gcc 16.1.0 ICEs (segmentation fault at the export-module line) when the scope +GMF (unique_fd.hpp, whose entities depend on core) is combined with re-exporting +mcpplibs.mwrap.boost.core; clang has no such issue (see src/scope.cppm). +Consumers import mcpplibs.mwrap.boost.core on their own. +''' + +# -------------------------------------------------------------------------- +# signals2 + +[[signals2.guard]] +if = "defined(BOOST_HAS_WINTHREADS)" +reason = ''' +The critical-section mutex is the Windows-threads branch of signals2's +lightweight mutex; POSIX uses pthread. +''' +names = [ # any :: segment + "critical_section", + "critical_section_debug", + "rtl_critical_section", +] + +# -------------------------------------------------------------------------- +# sort + +[sort.facade] +omit-imports = ["range"] +reason = ''' +range exports `using boost::sort;` (boost::range::sort injected into boost), +which collides with namespace boost::sort: re-exporting range makes every +`boost::sort::...` in sort.inc ambiguous. The body references to range stay a +.deps edge only. +''' + +# -------------------------------------------------------------------------- +# system + +[[system.guard]] +if = "defined(BOOST_WINDOWS_API)" +reason = ''' +M6 platform guard: snapshot = mingw flavor; these boost/system/detail +entities exist only under BOOST_WINDOWS_API +(system_category_message_win32.hpp / condition). +''' +names = [ + "boost::system::detail::local_free", + "boost::system::detail::message_cp_win32", +] + +[[system.guard]] +if = "defined(BOOST_WINDOWS_API)" +reason = ''' +M6 platform guard: as above. +''' +names = [ + "boost::system::detail::system_category_condition_win32", + "boost::system::detail::system_category_message_win32", + "boost::system::detail::unknown_message_win32", + "boost::system::windows_error::make_error_code", + "boost::system::windows_error::windows_error_code", + "boost::system::windows_error::windows_error_code::access_denied", + "boost::system::windows_error::windows_error_code::already_exists", + "boost::system::windows_error::windows_error_code::arena_trashed", + "boost::system::windows_error::windows_error_code::bad_command", + "boost::system::windows_error::windows_error_code::bad_environment", + "boost::system::windows_error::windows_error_code::bad_format", + "boost::system::windows_error::windows_error_code::bad_length", + "boost::system::windows_error::windows_error_code::bad_net_path", + "boost::system::windows_error::windows_error_code::bad_unit", + "boost::system::windows_error::windows_error_code::broken_pipe", + "boost::system::windows_error::windows_error_code::buffer_overflow", + "boost::system::windows_error::windows_error_code::busy", + "boost::system::windows_error::windows_error_code::cancel_violation", + "boost::system::windows_error::windows_error_code::cannot_make", + "boost::system::windows_error::windows_error_code::crc", + "boost::system::windows_error::windows_error_code::current_directory", + "boost::system::windows_error::windows_error_code::disk_full", + "boost::system::windows_error::windows_error_code::dup_name", + "boost::system::windows_error::windows_error_code::file_exists", + "boost::system::windows_error::windows_error_code::file_not_found", + "boost::system::windows_error::windows_error_code::gen_failure", + "boost::system::windows_error::windows_error_code::handle_disk_full", + "boost::system::windows_error::windows_error_code::handle_eof", + "boost::system::windows_error::windows_error_code::invalid_access", + "boost::system::windows_error::windows_error_code::invalid_block", + "boost::system::windows_error::windows_error_code::invalid_drive", + "boost::system::windows_error::windows_error_code::invalid_function", + "boost::system::windows_error::windows_error_code::invalid_handle", + "boost::system::windows_error::windows_error_code::lock_failed", + "boost::system::windows_error::windows_error_code::lock_violation", + "boost::system::windows_error::windows_error_code::network_busy", + "boost::system::windows_error::windows_error_code::no_more_files", + "boost::system::windows_error::windows_error_code::not_dos_disk", + "boost::system::windows_error::windows_error_code::not_enough_memory", + "boost::system::windows_error::windows_error_code::not_ready", + "boost::system::windows_error::windows_error_code::not_same_device", + "boost::system::windows_error::windows_error_code::not_supported", + "boost::system::windows_error::windows_error_code::open_failed", + "boost::system::windows_error::windows_error_code::out_of_paper", + "boost::system::windows_error::windows_error_code::outofmemory", + "boost::system::windows_error::windows_error_code::path_not_found", + "boost::system::windows_error::windows_error_code::read_fault", + "boost::system::windows_error::windows_error_code::rem_not_list", + "boost::system::windows_error::windows_error_code::sector_not_found", + "boost::system::windows_error::windows_error_code::seek", + "boost::system::windows_error::windows_error_code::sharing_buffer_exceeded", + "boost::system::windows_error::windows_error_code::sharing_violation", + "boost::system::windows_error::windows_error_code::success", + "boost::system::windows_error::windows_error_code::too_many_open_files", + "boost::system::windows_error::windows_error_code::write_fault", + "boost::system::windows_error::windows_error_code::write_protect", + "boost::system::windows_error::windows_error_code::wrong_disk", +] + +# -------------------------------------------------------------------------- +# thread + +[[thread.guard]] +if = "defined(_WIN32)" +reason = ''' +The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX +builds the pthread backend. +''' +names = [ + "boost::detail::win32::create_anonymous_event", + "boost::detail::win32::create_anonymous_semaphore", + "boost::detail::win32::create_anonymous_semaphore_nothrow", + "boost::detail::win32::create_event", + "boost::detail::win32::detail::gettickcount64_t", + "boost::detail::win32::duplicate_handle", + "boost::detail::win32::event_type", + "boost::detail::win32::event_type::auto_reset_event", + "boost::detail::win32::event_type::manual_reset_event", + "boost::detail::win32::get_system_info", + "boost::detail::win32::gettickcount64", + "boost::detail::win32::handle", + "boost::detail::win32::handle_manager", + "boost::detail::win32::initial_event_state", + "boost::detail::win32::initial_event_state::event_initially_reset", + "boost::detail::win32::initial_event_state::event_initially_set", + "boost::detail::win32::interlocked_bit_test_and_reset", + "boost::detail::win32::interlocked_bit_test_and_set", + "boost::detail::win32::release_semaphore", + "boost::detail::win32::sleep", + "boost::detail::win32::system_info", + "boost::detail::win32::ticks_type", +] + +[[thread.guard]] +if = "defined(_WIN32)" +reason = ''' +The Win32 thread backend (boost/thread/win32/*) of the MinGW snapshot; POSIX +builds the pthread backend. +''' +names = [ # any :: segment + "intrusive_ptr", + "wait_operations_windows", + "time_from_ftime", + "from_ftime", + "interruptible_wait", + "non_interruptible_wait", + "allocate_raw_heap_memory", + "free_raw_heap_memory", + "basic_condition_variable", + "basic_cv_list_entry", + "basic_recursive_mutex", + "basic_recursive_mutex_impl", + "basic_recursive_timed_mutex", + "basic_timed_mutex", + "commit_once_region", + "create_once_event", + "enter_once_region", + "rollback_once_region", + "int_to_string", + "interlocked_read_acquire", + "interlocked_write_release", + "intrusive_ptr_add_ref", + "intrusive_ptr_release", + "name_once_mutex", + "once_action", + "once_char_type", + "once_context", + "open_once_event", + "underlying_mutex", +] + +[[thread.extra]] +namespace = "boost" +reason = ''' +M7c: gcc 16.1.0 module consumers emit a partial vtable for clone_impl +(virtual base clone_base) whose thunk slots stay undefined — gcc never emits +the thunks in a module consumer TU. These extern-template declarations +suppress the consumer's implicit instantiation; the complete vtable + thunks +come from the explicit instantiation in port/thread_extras.cpp (same pattern +as boost_system_extras.cpp). +''' +lines = [ + "extern template class boost::exception_detail::clone_impl;", + "extern template class boost::exception_detail::clone_impl;", + "extern template class boost::exception_detail::clone_impl;", +] + +# -------------------------------------------------------------------------- +# tuple + +[[tuple.guard]] +if = "!defined(__GNUC__)" +reason = ''' +M3 hand-guard: ignore_t is a member-pointer typedef; gcc treats it as +internal linkage. +''' +names = [ + "boost::tuples::detail::ignore_t", +] + +# -------------------------------------------------------------------------- +# url + +[[url.guard]] +if = "defined(BOOST_URL_USE_SSE2)" +reason = ''' +M7 platform guard: charset.hpp defines the *_pred SSE2 helpers only under +BOOST_URL_USE_SSE2 (x86 with SSE2); absent on arm64 (e.g. macOS). +''' +names = [ + "boost::urls::grammar::detail::find_if_not_pred", + "boost::urls::grammar::detail::find_if_pred", +] + +# -------------------------------------------------------------------------- +# uuid + +[[uuid.guard]] +if = "defined(BOOST_UUID_USE_SSE2)" +reason = ''' +The SIMD to_chars/from_chars helpers are declared only under +BOOST_UUID_USE_SSE2 (x86); arm64 takes the scalar path. +''' +names = [ # any :: segment + "compare", + "countr_zero_nz", + "from_chars_simd", + "from_chars_simd_char_constants", + "from_chars_simd_constants", + "from_chars_simd_core", + "from_chars_simd_load_traits", + "simd_vector", + "simd_vector128", + "simd_vector256", + "simd_vector512", + "to_chars_simd", + "to_chars_simd_char_constants", + "to_chars_simd_constants", + "to_chars_simd_core", +] + +# -------------------------------------------------------------------------- +# variant + +[[variant.guard]] +if = "defined(__GNUC__)" +reason = ''' +M3 hand-guard: gcc-preprocessed mpl headers only +(BOOST_MPL_CFG_COMPILER_DIR=gcc). +''' +names = [ + "boost::mpl::aux::arity_helper", + "boost::mpl::aux::arity_tag", +] + +[[variant.guard]] +if = "defined(__GNUC__)" +reason = ''' +M3 hand-guard: as above (max_arity). +''' +names = [ + "boost::mpl::aux::max_arity", +] + +[[variant.guard]] +if = "defined(__GNUC__)" +reason = ''' +M3 hand-guard: as above (nested_type_wknd). +''' +names = [ + "boost::mpl::aux::nested_type_wknd", +] + +[[variant.guard]] +if = "defined(__GNUC__)" +reason = ''' +M3 hand-guard: as above (template_arity_impl). +''' +names = [ + "boost::mpl::aux::template_arity_impl", +] + diff --git a/tools/fetch_mingw_sysroot.py b/tools/fetch_mingw_sysroot.py index 62b410650..eb8f8f5eb 100644 --- a/tools/fetch_mingw_sysroot.py +++ b/tools/fetch_mingw_sysroot.py @@ -4,7 +4,7 @@ Why this exists --------------- -`gen_exports.py` drives libclang and the real clang++ driver with +`gen_exports.py` runs the clang++ driver (`-ast-dump=json`) with `--target=x86_64-w64-mingw32 --sysroot=...` (see boost_common.GEN_TARGET) to reproduce the committed mingw-flavor `generated/exports/*.inc` snapshots. The generator only ever runs `-fsyntax-only` and never links, so it needs the diff --git a/tools/gen_audit.py b/tools/gen_audit.py index 84bee6268..7ef81a2d1 100644 --- a/tools/gen_audit.py +++ b/tools/gen_audit.py @@ -1,7 +1,8 @@ #!/usr/bin/env python3 """gen_audit.py — audit target libraries for entities that cannot be exported. -Default mode (linkage audit), per library: +Default mode (linkage audit), per library, from clang's AST of the bundle TU +(tools/ast_json.py — the same compile gen_exports.py runs): - namespace-scope `static` / internal-linkage functions (the static-inline manual-replacement list — M0: 27 target libs should be ~0) - anonymous-namespace entities @@ -9,7 +10,10 @@ only; a specialization declared here is lost to module consumers) - friend operators (informational: re-exported through the class by ADL) -Output: target/gen/audit/.txt + stdout summary. +Output: target/gen/audit/.txt + stdout summary. Each library's report is +cached in target/gen/exports-cache/.audit.json, keyed on the compile gate +key, this tool's and the generator's code, and valid only while every file +clang read for it is unchanged: a hit skips the AST dump. --macros mode (M10, T3 boundary check): macro-surface statistics per library — how many macros the library's own public header set #defines (minus #undefs), @@ -28,6 +32,8 @@ """ import argparse +import hashlib +import json import re import sys from collections import Counter @@ -35,8 +41,6 @@ import boost_common as bc -ci = None - # --------------------------------------------------------------------------- # --macros mode (M10): macro-surface statistics # --------------------------------------------------------------------------- @@ -161,8 +165,8 @@ def macros_audit(libs, out): t3 = set(bc.LIBS_T3 + bc.LIBS_INCLUDE_ONLY_M9) out.mkdir(parents=True, exist_ok=True) with open(out / "macro_surface.txt", "w", encoding="utf-8") as fh: - fh.write("# boost-module macro-surface audit (boost 1.92.0) - M10 T3 " - "boundary check\n") + fh.write("# boost-module macro-surface audit (boost {}) - M10 T3 " + "boundary check\n".format(bc.BOOST_VERSION)) fh.write("# macros = unique names #defined in the library's own " "public header set (libs.json for module libs,\n") fh.write("# boost//**.hpp non-detail heuristic otherwise), " @@ -184,97 +188,86 @@ def macros_audit(libs, out): return 0 -def _is_explicit_specialization(cursor, tu): - """`template<>` explicit specializations (see gen_exports for rationale).""" - try: - toks = bc.tokens_of(tu, cursor) - except Exception: - return False - if len(toks) < 3: - return False - return toks[0].spelling == "template" and toks[1].spelling == "<" and \ - toks[2].spelling in (">", ">>") - - -def audit_lib(lib, headers, out_dir): - idx = ci.Index.create() - # gen_exports.py writes bundle TUs into its (gitignored) cache dir; - # fall back to the historical location when only old bundles exist. - bundle = bc.CACHE_DIR / "bundles" / (lib + ".cpp") - if not bundle.exists(): - bundle = Path(bc.ROOT / "target" / "gen" / "bundles" / (lib + ".cpp")) - tu = idx.parse(str(bundle), args=bc.CLANG_ARGS, - options=ci.TranslationUnit.PARSE_SKIP_FUNCTION_BODIES | - ci.TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD) - file_to_lib = bc.build_file_to_lib() - - static_fns, anon, specs, friends = [], [], [], [] +def _audit_key(lib, gfm, policy): + import gen_exports as ge + h = hashlib.sha256() + h.update(b"gate:" + ge.gate_key(lib, gfm, policy).encode()) + h.update(b"code:" + ge._code_hash().encode()) + h.update(b"audit:" + hashlib.sha256( + Path(__file__).read_bytes()).hexdigest().encode()) + return h.hexdigest() - def rec(cursor, in_anon_ns): - try: - kind = str(cursor.kind).replace("CursorKind.", "") - except Exception: - kind = "UNKNOWN" - if kind not in ("NAMESPACE", "FUNCTION_DECL", "FUNCTION_TEMPLATE", - "CLASS_DECL", "STRUCT_DECL", "UNION_DECL", "ENUM_DECL", - "VAR_DECL", "TYPEDEF_DECL", "TYPE_ALIAS_DECL", - "FRIEND_DECL"): - # expressions/statements: recurse without per-node file lookups - for child in cursor.get_children(): - rec(child, in_anon_ns) - return - f = bc.cursor_file(cursor) - in_lib = f is not None and bc.home_lib_of_file(f, file_to_lib) == lib - - if kind == "NAMESPACE" and cursor.is_anonymous(): - for child in cursor.get_children(): - rec(child, True) - return - if in_lib: - loc = "{}:{}".format(f.name, cursor.location.line) - if in_anon_ns and bc.qualified_name(cursor).startswith("boost::"): - anon.append("{} {}".format(loc, bc.qualified_name(cursor))) - if kind in ("FUNCTION_DECL", "FUNCTION_TEMPLATE"): - if bc.namespace_chain(cursor) and not bc.linkage_ok(cursor): - static_fns.append("{} {} (linkage={})" - .format(loc, bc.qualified_name(cursor), - cursor.linkage.name)) - if kind in ("FUNCTION_DECL", "FUNCTION_TEMPLATE", "CLASS_DECL", - "STRUCT_DECL", "UNION_DECL", "CLASS_TEMPLATE", - "CLASS_TEMPLATE_PARTIAL_SPECIALIZATION"): - if (bc.is_specialization(cursor) or - _is_explicit_specialization(cursor, tu)) and \ - bc.qualified_name(cursor).startswith("boost::"): - specs.append("{} {}".format(loc, bc.qualified_name(cursor))) - for child in cursor.get_children(): - try: - is_friend = child.kind == ci.CursorKind.FRIEND_DECL - except ValueError: - is_friend = False - if is_friend and in_lib: - friends.append("{}:{}".format(f.name, child.location.line)) - continue - rec(child, in_anon_ns) - - rec(tu.cursor, False) +def audit_lib(lib, out_dir, policy, use_cache=True): + """Linkage audit of one library from the compiler's AST of its bundle TU + (the same compile gen_exports.py runs; its pruned-GMF cache is reused).""" + import gen_exports as ge + g = policy.gmf(lib) + gfm = [bc.DEPS / h for h in g] if g else bc.gfm_headers_of(lib) out = out_dir / (lib + ".txt") + cache = bc.CACHE_DIR / (lib + ".audit.json") + key = _audit_key(lib, gfm, policy) if use_cache else None + cached = ge._load_json(cache) if use_cache else None + if cached is not None and cached.get("key") == key \ + and ge._manifest_ok(cached.get("inputs")): + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(cached["text"], encoding="utf-8", newline="\n") + return tuple(cached["counts"]) + + parsed = ge.parse_bundle(lib, gfm, policy, use_cache=use_cache) + if parsed is None: + raise SystemExit("error: {} does not compile".format(lib)) + tu = parsed[0] + m = ge.Model(tu) + + static_fns, anon, specs, friends = [], [], [], [] + for d in m.decls: + if ge.home_of_file(d.file) != lib: + continue + loc = "{}:{}".format(Path(d.file).name, d.line) + if d.kind == "FriendDecl": + friends.append(loc) + continue + if d.attrs.get("isImplicit") or d.friend or m.is_pattern(d): + continue + parent = d.parent + if parent is not None and parent.kind == "NamespaceDecl" and \ + not parent.name and d.kind in ge.EXPORT_KINDS: + anon.append("{} {}".format(loc, d.name or "")) + continue + qn = m.qualified_name(d) + if not qn.startswith("boost::"): + continue + if d.kind in ("FunctionDecl", "FunctionTemplateDecl") and \ + m.namespace_chain(d) and not m.linkage_ok(d): + static_fns.append("{} {} (internal linkage)".format(loc, qn)) + if m.is_specialization(d) and m.namespace_chain(m.primary(d)): + specs.append("{} {}".format(loc, qn)) + + text = "".join(( + "# audit {} (boost {})\n".format(lib, bc.BOOST_VERSION), + "# {} static/internal free functions\n".format(len(static_fns)), + "\n".join(sorted(static_fns)) + "\n\n", + "# {} anonymous-namespace entities\n".format(len(anon)), + "\n".join(sorted(anon)) + "\n\n", + "# {} explicit specializations\n".format(len(specs)), + "\n".join(sorted(specs)) + "\n\n", + "# {} friend operator decls (info)\n".format(len(friends)), + "\n".join(sorted(friends)) + "\n", + )) + counts = (len(static_fns), len(anon), len(specs), len(friends)) out.parent.mkdir(parents=True, exist_ok=True) - with open(out, "w", encoding="utf-8") as fh: - fh.write("# audit {} (boost 1.92.0)\n".format(lib)) - fh.write("# {} static/internal free functions\n".format(len(static_fns))) - fh.write("\n".join(sorted(static_fns)) + "\n\n") - fh.write("# {} anonymous-namespace entities\n".format(len(anon))) - fh.write("\n".join(sorted(anon)) + "\n\n") - fh.write("# {} explicit specializations\n".format(len(specs))) - fh.write("\n".join(sorted(specs)) + "\n\n") - fh.write("# {} friend operator decls (info)\n".format(len(friends))) - fh.write("\n".join(sorted(friends)) + "\n") - return len(static_fns), len(anon), len(specs), len(friends) + out.write_text(text, encoding="utf-8", newline="\n") + if use_cache: + bc.CACHE_DIR.mkdir(parents=True, exist_ok=True) + cache.write_text(json.dumps( + {"key": key, "inputs": ge._input_manifest(tu, bc.ROOT), + "text": text, "counts": list(counts)}), + encoding="utf-8") + return counts def main() -> int: - global ci ap = argparse.ArgumentParser(description=__doc__) ap.add_argument("--libs", nargs="*", default=None, help="subset of libraries (default: all target libs, " @@ -290,7 +283,9 @@ def main() -> int: bc.TARGET_LIBS + bc.LIBS_T3 + bc.LIBS_INCLUDE_ONLY_M9 return macros_audit(libs, args.out) - ci = bc.get_ci() + import gen_exports as ge + ge._FILE_TO_LIB.update(bc.build_file_to_lib()) + policy = ge.Policy.load() libs = args.libs or bc.TARGET_LIBS total = [0, 0, 0, 0] for lib in libs: @@ -299,8 +294,7 @@ def main() -> int: if lib in bc.LIBS_SPECIAL: print("skip {} (hand-written module, no generated bundle)".format(lib)) continue - headers = bc.headers_of(lib) - n = audit_lib(lib, headers, args.out) + n = audit_lib(lib, args.out, policy) total = [t + x for t, x in zip(total, n)] print("{}: static={} anon={} specs={} friends={}".format(lib, *n)) print("TOTAL: static={} anon={} specs={} friends={}".format(*total)) diff --git a/tools/gen_exports.py b/tools/gen_exports.py index abbec1aee..58740a47f 100644 --- a/tools/gen_exports.py +++ b/tools/gen_exports.py @@ -1,1424 +1,978 @@ #!/usr/bin/env python3 -"""gen_exports.py — generate export using-lists for the Boost module layer. - -For each target library, parses one "bundle" TU that includes all of the -library's public headers (the future .cppm GMF include set), collects every -namespace-scope boost:: entity with external linkage declared in those headers, -computes a dependency closure over the entity signatures (cross-library: e.g. -filesystem pulls boost::system::error_code), and emits generated/exports/.inc -containing M0-verified `export namespace boost { using ...; }` blocks. - -Cross-module dedup: libraries are processed dependencies-first (include-based -topological order); the first library to claim an entity's USR owns it, later -libraries omit it and record `export import mcpplibs.mwrap.boost.;` hints in .deps. - -Two-pass .deps completion (2026-09-08, fixes the C4 §4.2 structural defect): -pass 1 (above) is left untouched — first-wins ownership is frozen, so .inc -output is bit-identical to the pre-fix generator. Pass 2 then walks the -BODIES of every exported entity (signatures alone under-approximate: view -iterators reach boost.iterator entities only through bodies/base specs, and -the include-graph extra_deps walk stops at target-owned roots — together -these lost bimap's boost.iterator edge when lambda became a target lib, C4 -§4.1). Each boost:: entity referenced from an exported body contributes a -candidate edge to its home lib; edges that are already transitive or would -close a cycle are dropped, the rest are unioned into .deps. Pass 2 also -re-tokenizes variable-template declarations (libclang hides their initializer -behind an opaque UNEXPOSED_DECL) and resolves the qualified name chains in the -initializer — `boost::...` as-is (A1) and relative names against the variable -template's enclosing namespaces (A2); macro-expanded / aliased references -remain uncovered. +"""gen_exports.py — generate the export using-lists of the Boost module layer. + +Principle (see docs/architecture.md §5): the compiler computes the public +surface, the generator only lists it. For each target library one bundle +translation unit includes the library's public headers (the module's GMF +include set) and is compiled once with + + clang++ -fsyntax-only -Xclang -ast-dump=json -Xclang -ast-dump-filter=boost + +(tools/ast_json.py). From that AST the generator collects every namespace- +scope `boost::` entity with external linkage the library owns, closes the set +over the entity signatures, and writes + + generated/exports/.inc export namespace boost { using ...; } + generated/exports/.deps export-import edges (complete module names) + generated/meta/api-surface.json generator identity + per-library summary + generated/meta/skipped.txt every name the policy guards or drops + +Nothing else edits these files. What the AST cannot decide — platform-only +declarations of the fixed MinGW snapshot, names that must not be exported, +GMF overrides, verbatim lines — is declared in tools/export_policy.toml with a +written reason and applied here, so the committed output is exactly what the +generator writes and `--check` can prove it byte for byte. + +The `src/.cppm` interfaces are hand-maintained facades: GMF includes, +`export import` edges and `#include` of the generated list. The generator never +rewrites them; `--check` verifies that each facade's GMF include set equals the +bundle's (gate-pruned) include set the export list was computed from, and +that its `export import` block covers every .deps edge. + +Ownership and dedup: libraries are processed dependencies-first (include-based +topological order); the first library to claim an entity owns it, later +libraries omit it and record `export import mcpplibs.mwrap.boost.;` in +.deps. Pass 2 walks the bodies of every exported entity and adds the +edges a consumer of that module needs (cycles and transitive edges skipped). Usage: + python tools/gen_exports.py # all target libraries + python tools/gen_exports.py --libs optional system + python tools/gen_exports.py --check # byte-compare, write nothing + python tools/gen_exports.py --emit-cppm # draft facades that are missing python tools/gen_exports.py --scan # regenerate generated/meta/libs.json - python tools/gen_exports.py # all 27 target libs - python tools/gen_exports.py --libs optional system --full-closure - python tools/gen_exports.py --emit-cppm # also draft src/.cppm """ import argparse +import difflib import hashlib import json import os import re +import shutil import sys +import tempfile import time +import tomllib from collections import deque from pathlib import Path +import ast_json as aj import boost_common as bc -ci = None +POLICY_FILE = bc.TOOLS / "export_policy.toml" +SURFACE_JSON = bc.ROOT / "generated" / "meta" / "api-surface.json" +SKIPPED_TXT = bc.ROOT / "generated" / "meta" / "skipped.txt" # --------------------------------------------------------------------------- -# caching (incremental skip + clang++ gate verdicts) +# policy (tools/export_policy.toml) # --------------------------------------------------------------------------- -_CODE_HASH = None +class Policy: + """Per-library decisions the AST cannot make, each with a reason. + + [] + gmf exact GMF/bundle include set (relative to upstream/boost) + defines extra -D macros for the bundle (match the .cppm GMF) + inline-namespaces export these inline namespaces' members through the + enclosing namespace (macro-selected inline namespace) + add qualified names to export even though no collector + reaches them (body-only references, ADL-only friends) + facade-includes headers the src/.cppm GMF includes beyond the + bundle (not part of the export computation) + [[.guard]] if / reason / names / else — wrap the matching exports + in `#if `; `else` lines go to the `#else` branch + [[.drop]] reason / names / namespaces — never export the + matching names (or anything inside the namespaces) + [[.extra]] namespace / reason / lines — verbatim declarations + [.deps] add / remove / reason — module edge corrections + [.facade] omit-imports / reason — .deps edges src/.cppm + cannot `export import` (checked by check_facade) + + A `names` entry containing `::` matches a qualified name exactly; a bare + identifier matches any `::` segment of the exported name. + """ + def __init__(self, data): + self.data = data -def _code_hash(): - """Hash of the generator sources — any logic change invalidates caches.""" - global _CODE_HASH - if _CODE_HASH is None: - h = hashlib.sha256() - for p in (Path(__file__).resolve(), - (bc.TOOLS / "boost_common.py").resolve()): - h.update(p.name.encode("utf-8")) - h.update(p.read_bytes()) - _CODE_HASH = h.hexdigest() - return _CODE_HASH + @classmethod + def load(cls, path=POLICY_FILE): + if not path.is_file(): + return cls({}) + with open(path, "rb") as f: + return cls(tomllib.load(f)) + def lib(self, lib): + return self.data.get(lib, {}) -_CLANG_VERSION = None + def gmf(self, lib): + return self.lib(lib).get("gmf") + def defines(self, lib): + return list(self.lib(lib).get("defines", ())) -def _clang_command(*args): - """Build the clang++ command used by the syntax gate. + def inline_namespaces(self, lib): + return list(self.lib(lib).get("inline-namespaces", ())) - xlings' host LLVM package installs a default config file for native builds. - The generator is a cross-target MinGW parse, so CI can request that clang - ignore the host config while retaining the explicit target/sysroot flags. - """ - command = [os.environ.get("CXX") or "clang++"] - if os.environ.get("CLANG_NO_DEFAULT_CONFIG"): - command.append("--no-default-config") - return command + list(args) + def add(self, lib): + return list(self.lib(lib).get("add", ())) + def guards(self, lib): + return list(self.lib(lib).get("guard", ())) -def _clang_version(): - global _CLANG_VERSION - if _CLANG_VERSION is None: - import subprocess - r = subprocess.run(_clang_command("--version"), capture_output=True, - text=True) - _CLANG_VERSION = (r.stdout or r.stderr).splitlines()[0] \ - if (r.stdout or r.stderr) else "unknown" - return _CLANG_VERSION + def drops(self, lib): + return list(self.lib(lib).get("drop", ())) + def extras(self, lib): + return list(self.lib(lib).get("extra", ())) -def _initial_gfm(lib, gfm_headers): - """Include set _parse_bundle starts from (GMF override applied).""" - if lib in GMF_OVERRIDE: - return [bc.DEPS / h for h in GMF_OVERRIDE[lib]] - return list(gfm_headers) + def deps(self, lib): + return self.lib(lib).get("deps", {}) + def facade_includes(self, lib): + return list(self.lib(lib).get("facade-includes", ())) -def _bundle_text(gfm): - return "\n".join("#include <{}>".format( - h.relative_to(bc.DEPS).as_posix()) for h in gfm) + "\n" + def facade_omit_imports(self, lib): + return list(self.lib(lib).get("facade", {}).get("omit-imports", ())) + def digest(self, lib): + return hashlib.sha256(json.dumps( + self.lib(lib), sort_keys=True).encode()).hexdigest() -_FILE_HASH = {} -_INC_CACHE = {} -_HDR_INFO = {} +def _matches(qname, names): + segments = qname.lstrip(":").split("::") + for n in names: + if "::" in n: + if qname.lstrip(":") == n.lstrip(":"): + return True + elif n in segments: + return True + return False -def _file_hash(path): - h = _FILE_HASH.get(path) - if h is None: - try: - h = hashlib.sha256(path.read_bytes()).hexdigest() - except OSError: - h = "missing" - _FILE_HASH[path] = h - return h +# --------------------------------------------------------------------------- +# semantic model over the AST declaration table +# --------------------------------------------------------------------------- -def _boost_includes(path): - incs = _INC_CACHE.get(path) - if incs is None: - try: - text = path.read_text(encoding="utf-8", errors="ignore") - except OSError: - text = "" - incs = _INC_CACHE[path] = [m.group(1) - for m in bc._INC_RE.finditer(text)] - return incs - - -def _norm(path): - """Memoized normcase/abspath — Path.resolve() is a filesystem syscall on - Windows and is prohibitively slow at closure-walk volume.""" - key = str(path) - v = _HDR_INFO.get("n:" + key) - if v is None: - try: - v = str(path.resolve()).lower() - except OSError: - v = key.lower() - _HDR_INFO["n:" + key] = v - return v - - -def _hdr_info(path): - """(abspath, rel, content-hash, [include target Paths]) per header, all - memoized — the closure walk below is then a pure graph traversal.""" - key = _norm(path) - info = _HDR_INFO.get(key) - if info is None: - p = Path(key) - try: - rel = p.relative_to(bc.DEPS).as_posix() - except ValueError: - rel = p.as_posix() - h = _file_hash(p) - incs = [] - for r in _boost_includes(p): - ip = bc.BOOST_ROOT.parent / r - ikey = str(ip) - ex = _HDR_INFO.get("e:" + ikey) - if ex is None: - ex = _HDR_INFO["e:" + ikey] = ip.is_file() - if ex: - incs.append(ip) - info = _HDR_INFO[key] = (rel, h, incs) - return (key,) + info - - -def _closure_hash(lib, gfm): - """Content hash over every boost header transitively reachable from the - bundle's include set — header edits anywhere in the closure invalidate - the caches. All per-file work is memoized (see _hdr_info).""" - h = hashlib.sha256() - h.update("lib:{}\n".format(lib).encode()) - seen = set() - stack = [list(gfm)] - while stack: - for f in stack.pop(): - key, rel, digest, incs = _hdr_info(f) - if key in seen: +EXPORT_KINDS = frozenset(( + "CXXRecordDecl", "RecordDecl", "EnumDecl", "EnumConstantDecl", + "FunctionDecl", "FunctionTemplateDecl", "VarDecl", "VarTemplateDecl", + "TypedefDecl", "TypeAliasDecl", "TypeAliasTemplateDecl", + "ClassTemplateDecl", "ClassTemplatePartialSpecializationDecl", + "ConceptDecl", +)) +SPECIALIZATION_KINDS = frozenset(( + "ClassTemplateSpecializationDecl", "ClassTemplatePartialSpecializationDecl", + "VarTemplateSpecializationDecl", "VarTemplatePartialSpecializationDecl", +)) +CLASS_KINDS = frozenset(("CXXRecordDecl", "RecordDecl", "ClassTemplateDecl", + "ClassTemplateSpecializationDecl")) +TYPE_ENTITY_KINDS = frozenset(( + "CXXRecordDecl", "RecordDecl", "EnumDecl", "ClassTemplateDecl", + "ClassTemplatePartialSpecializationDecl", + "ClassTemplateSpecializationDecl", +)) +ALIAS_KINDS = frozenset(("TypedefDecl", "TypeAliasDecl", + "TypeAliasTemplateDecl")) +METHOD_KINDS = frozenset(("CXXMethodDecl", "CXXConstructorDecl", + "CXXDestructorDecl", "CXXConversionDecl")) +VAR_TEMPLATE_KIND = "VarTemplateDecl" + +# Identifiers that can appear in a printed type but never name an entity. +_TYPE_WORDS = frozenset(""" + const volatile typename struct class union enum unsigned signed short long + int char bool void float double auto decltype sizeof alignof noexcept + wchar_t char8_t char16_t char32_t nullptr_t restrict template operator + __int128 _Bool __restrict true false requires +""".split()) +_ID_CHAIN = re.compile(r"(?])((?:::)?[A-Za-z_]\w*(?:::[A-Za-z_]\w*)*)") +_UNNAMED = re.compile(r"\((?:unnamed|anonymous|lambda)[^()]*\)") + + +def names_in_type(text): + """Qualified-id chains spelled in a printed type (`boost::a::b` + yields boost::a::b, T, c::d). Members of dependent types (`X::type`) + are not chains of their own.""" + if not text: + return + text = _UNNAMED.sub("", text) + for m in _ID_CHAIN.finditer(text): + name = m.group(1) + if name in _TYPE_WORDS: + continue + yield name + + +_UNKNOWN = aj.Decl("", "") + + +class Model: + """Semantic queries over one bundle TU (ast_json.TU).""" + + def __init__(self, tu): + self.tu = tu + self.by_id = tu.by_id + self.decls = sorted(tu.decls, key=lambda d: d.seq) + self._canon = {} + self._group = {} + self._qn = {} + self._qindex = None + self._export_qindex = None + self._export_keys = None + for d in self.decls: + self._group.setdefault(self.canon(d), []).append(d) + # `typedef enum { a, b } name;` — the typedef gives the unnamed enum + # its name for linkage purposes; the enumerators are spelled + # `ns::name::a` and have external linkage. + unnamed = {d.id: d for d in self.decls + if d.kind == "EnumDecl" and not d.name} + if unnamed: + for d in self.decls: + if d.kind == "TypedefDecl" and d.refs: + for rid in d.refs: + e = unnamed.get(rid) + if e is not None and e.parent is d.parent: + e.name = d.name + del unnamed[rid] + break + + # -- structure --------------------------------------------------------- + + def canon(self, d): + """First declaration of `d`'s redeclaration chain.""" + c = self._canon.get(d.id) + if c is not None: + return c + cur, seen = d, set() + while True: + prev = cur.attrs.get("previousDecl") + p = self.by_id.get(prev) if prev else None + if p is None or p.id in seen: + break + seen.add(cur.id) + cur = p + self._canon[d.id] = cur + return cur + + def redecls(self, d): + return self._group.get(self.canon(d), [d]) + + @staticmethod + def is_pattern(d): + p = d.parent + return p is not None and p.kind in aj.TEMPLATE_KINDS and p.pattern is d + + def entity(self, d): + """The declaration that stands for `d` as an exportable entity: the + template for a template pattern, `d` itself otherwise.""" + if self.is_pattern(d): + return d.parent + return d + + def sem_parent(self, d): + """Semantic parent: `parentDeclContextId` when clang prints one (an + out-of-line definition), else the lexical parent. A context that was + dropped as an instantiation resolves to its template; an unknown one + yields the `_UNKNOWN` placeholder, never the lexical namespace.""" + pid = d.attrs.get("parentDeclContextId") + if pid: + p = self.tu.resolve(pid) + return p if p is not None else _UNKNOWN + return d.parent + + def qualified_name(self, d): + """boost::a::b for namespace members and class members (class name + included); '' inside anonymous namespaces, functions or linkage + specifications, mirroring the scopes a using-declaration can name.""" + q = self._qn.get(d.id) + if q is not None: + return q + names = [] + cur = d + result = "" + while True: + p = self.sem_parent(cur) + if p is not None and p.kind in aj.TEMPLATE_KINDS and \ + p.pattern is cur: + cur = p # template wrapper: same entity continue - seen.add(key) - h.update("{} {}\n".format(rel, digest).encode()) - if incs: - stack.append(incs) - return h.hexdigest() + if p is None: + if cur.name: + result = "::".join([cur.name] + names[::-1]) + break + pk = p.kind + if pk == "NamespaceDecl": + if not p.name: + break # anonymous namespace + elif pk == "EnumDecl": + if not p.name: + if cur.name: # unnamed enum is transparent + names.append(cur.name) + cur = p + continue + elif pk not in CLASS_KINDS and pk not in ALIAS_KINDS: + break + if not cur.name: + break + names.append(cur.name) + cur = p + self._qn[d.id] = result + return result + + def namespace_chain(self, d): + """['boost', 'mp11'] for a namespace-scope declaration; [] for class + members, locals, anonymous-namespace and linkage-spec contents.""" + chain = [] + cur = self.entity(d) + while True: + p = self.sem_parent(cur) + if p is None: + return chain[::-1] + if p.kind != "NamespaceDecl" or not p.name: + return [] + chain.append(p.name) + cur = p + + def scope_names(self, d): + """Qualified scope prefixes for unqualified lookup from inside `d`, + innermost first (class scopes included).""" + qn = self.qualified_name(self.entity(d)) + parts = qn.split("::") if qn else [] + return ["::".join(parts[:k]) for k in range(len(parts), 0, -1)] + + def in_anonymous_namespace(self, d): + cur = d + while cur is not None: + p = self.sem_parent(cur) + if p is not None and p.kind == "NamespaceDecl" and not p.name: + return True + cur = p + return False + # -- definitions, files, linkage -------------------------------------- + + @staticmethod + def is_definition(d): + k = d.kind + if k in aj.TEMPLATE_KINDS: + return d.pattern is not None and Model.is_definition(d.pattern) + if k in aj.RECORD_KINDS: + return bool(d.attrs.get("completeDefinition")) + if k in aj.FUNCTION_KINDS: + return d.has_body or bool(d.attrs.get("explicitlyDefaulted")) or \ + bool(d.attrs.get("explicitlyDeleted")) + if k == "VarDecl": + return d.attrs.get("storageClass") != "extern" or "init" in d.attrs + if k == "EnumDecl": + return bool(d.children) or "fixedUnderlyingType" in d.attrs + return True -def _skip_key(lib, gfm_headers, upstream_keys, libs, full_closure, - no_body_deps): - """Incremental-skip cache key: everything the .inc/.deps output for `lib` - deterministically depends on, plus the keys of its upstream libs (so any - upstream regeneration invalidates downstream).""" - h = hashlib.sha256() - h.update(b"code:" + _code_hash().encode()) - h.update(b"bundle:" + _bundle_text( - _initial_gfm(lib, gfm_headers)).encode()) - h.update(b"closure:" + _closure_hash(lib, gfm_headers).encode()) - h.update(b"extra:" + ",".join(EXTRA_DEFINES.get(lib, ())).encode()) - h.update(b"clang_args:" + " ".join(bc.CLANG_ARGS).encode()) - h.update(b"libclang:" + bc.libclang_version().encode()) - curated = bc.CURATED_DIR / (lib + ".txt") - if curated.exists(): - h.update(b"curated:" + curated.read_bytes()) - h.update(b"full_closure:" + str(full_closure).encode()) - h.update(b"no_body_deps:" + str(no_body_deps).encode()) - # The libs subset shapes first-wins claiming, so it is part of the key. - h.update(b"libs:" + ",".join(sorted(libs)).encode()) - for u in sorted(upstream_keys): - h.update("up:{}:{}\n".format(u, upstream_keys[u]).encode()) - return h.hexdigest() + def definition(self, d): + for r in self.redecls(d): + if self.is_definition(r): + return r + return None + def linkage_ok(self, d): + """External linkage (what a using-declaration may export). Typedef + names have no linkage but are exportable namespace members.""" + k = d.kind + if k in ("TypedefDecl", "TypeAliasDecl"): + return True + if self.in_anonymous_namespace(d): + return False + if k == "EnumConstantDecl": + enum = self.sem_parent(d) + return enum is not None and bool(enum.name) and \ + self.linkage_ok(enum) + if k in TYPE_ENTITY_KINDS or k in ("TypeAliasTemplateDecl", + "ConceptDecl"): + return bool(d.name) + target = d.pattern if k in aj.TEMPLATE_KINDS else d + if target is None: + return True + for r in self.redecls(d): + t = r.pattern if r.kind in aj.TEMPLATE_KINDS else r + if t is not None and t.attrs.get("storageClass") == "static": + return False + if target.kind == "VarDecl" and k == "VarDecl": + mangled = target.attrs.get("mangledName", "") + if mangled: + return not _internal_mangling(mangled) + return not (_top_const(target.type) and + not target.attrs.get("inline") and + target.attrs.get("storageClass") != "extern") + if target.kind in aj.FUNCTION_KINDS: + mangled = target.attrs.get("mangledName", "") + if mangled and _internal_mangling(mangled): + return False + return True -def _load_json(path): - try: - return json.loads(path.read_text(encoding="utf-8")) - except (OSError, ValueError): - return None + def is_specialization(self, d): + if d.kind in SPECIALIZATION_KINDS: + return True + return d.kind in aj.FUNCTION_KINDS and d.targs + # -- indexes ------------------------------------------------------------ -def _artifacts_ok(out_dir, lib, sk): - """A cache hit is only usable when the cached outputs still exist.""" - gen = out_dir / "generated" / "exports" - if not (gen / (lib + ".inc")).exists(): + def indexed(self): + """Pre-order declarations the module layer can see (not compiler- + implicit, not friend-only declarations).""" + for d in self.decls: + if d.attrs.get("isImplicit") or d.friend: + continue + if self.is_pattern(d): + continue + yield d + + def qindex(self): + """{qualified name: [decl, ...]} over every visible declaration. + Enumerators of an unscoped enum are also found through the enclosing + scope (`boost::algorithm::token_compress_on`), as name lookup finds + them.""" + if self._qindex is None: + idx = {} + for d in self.indexed(): + qn = self.qualified_name(d) + if not qn: + continue + idx.setdefault(qn, []).append(d) + if d.kind == "EnumConstantDecl": + enum = self.sem_parent(d) + if enum is not None and enum.name and \ + not enum.attrs.get("scopedEnumTag") and \ + qn.count("::") >= 2: + outer = qn.rsplit("::", 2)[0] + "::" + d.name + idx.setdefault(outer, []).append(d) + self._qindex = idx + return self._qindex + + def export_qindex(self): + """{qualified name: [decl, ...]} over exportable kinds only.""" + if self._export_qindex is None: + idx = {} + for qn, ds in self.qindex().items(): + es = [d for d in ds if d.kind in EXPORT_KINDS] + if es: + idx[qn] = es + self._export_qindex = idx + return self._export_qindex + + def export_index(self): + """{stable key: decl} over exportable kinds, first declaration wins.""" + if self._export_keys is None: + idx = {} + for d in self.indexed(): + if d.kind in EXPORT_KINDS: + idx.setdefault(self.stable_key(d), d) + self._export_keys = idx + return self._export_keys + + def lookup(self, chain, scopes): + """Declarations a written name chain denotes: relative names are + looked up from the innermost enclosing scope outwards, then globally; + `::x` is global only.""" + idx = self.qindex() + if chain.startswith("::"): + cands = [chain[2:]] + else: + cands = [s + "::" + chain for s in scopes] + [chain] + for c in cands: + ds = idx.get(c) + if ds: + return ds + return () + + def promote(self, d): + """Climb from a class member to the namespace-scope entity; an + explicit specialization stands for its primary template.""" + cur = self.primary(self.entity(d)) + while True: + p = self.sem_parent(cur) + if p is None: + return cur + if p.kind in CLASS_KINDS: + cur = self.primary(self.entity(p)) + continue + return cur + + def primary(self, d): + """Primary template of a specialization (itself otherwise).""" + if d.kind in SPECIALIZATION_KINDS or ( + d.kind in aj.FUNCTION_KINDS and d.targs): + want = {"ClassTemplateSpecializationDecl": "ClassTemplateDecl", + "ClassTemplatePartialSpecializationDecl": + "ClassTemplateDecl", + "VarTemplateSpecializationDecl": "VarTemplateDecl", + "VarTemplatePartialSpecializationDecl": + "VarTemplateDecl"}.get(d.kind, "FunctionTemplateDecl") + for t in self.qindex().get(self.qualified_name(d), ()): + if t.kind == want: + return t + return d + + def namespaces(self): + """Qualified names of every named namespace in the TU.""" + return {self.qualified_name(d) for d in self.decls + if d.kind == "NamespaceDecl" and d.name} - {""} + + def type_targets(self, text, scopes, depth=0, seen=None): + """Entities a printed type refers to, with typedefs and alias + templates looked through (the canonical-type view of a signature).""" + if seen is None: + seen = set() + for name in names_in_type(text): + for t in self.lookup(name, scopes): + if t.id in seen: + continue + seen.add(t.id) + k = t.kind + if k in ALIAS_KINDS: + if depth >= 8: + continue + a = t.pattern if k == "TypeAliasTemplateDecl" else t + if a is None: + continue + yield from self.type_targets( + a.dtype or a.type, self.scope_names(t), depth + 1, + seen) + elif k in TYPE_ENTITY_KINDS: + yield t + + def stable_key(self, d): + """Cross-TU identity of an entity (the role libclang's USR played): + the Itanium mangling where clang prints one, else kind + qualified + name (+ signature for function templates).""" + d = self.canon(d) # every redeclaration maps to one key + k = d.kind + qn = self.qualified_name(d) + if k in aj.FUNCTION_KINDS or k == "VarDecl": + m = d.attrs.get("mangledName") + if m: + return "m:" + m + return "{}:{}|{}".format(k, qn, d.dtype or d.type) + if k == "FunctionTemplateDecl": + p = d.pattern + return "ft:{}|{}".format(qn, p.type if p is not None else "") + if k in ("CXXRecordDecl", "RecordDecl", "ClassTemplateDecl"): + return "c:" + qn + if k in SPECIALIZATION_KINDS: + return "s:{}|{}".format(qn, d.id) + return "{}:{}".format(k, qn) + + +def _internal_mangling(m): + """Itanium marks internal-linkage names with `L` before the source name: + `_ZL3foo`, `_ZN5boost6detailL3fooE`.""" + if m.startswith("_ZL"): + return True + if not m.startswith("_ZN"): return False - return (gen / (lib + ".deps")).exists() == bool(sk.get("deps_present")) - + i = 3 + while i < len(m) and m[i] in "rVK": + i += 1 + while i < len(m): + c = m[i] + if c == "L": + return True + if c.isdigit(): + j = i + while j < len(m) and m[j].isdigit(): + j += 1 + i = j + int(m[i:j]) + elif m.startswith("St", i): + i += 2 + else: + return False + return False -# --------------------------------------------------------------------------- -# entity collection (one bundle TU per library) -# --------------------------------------------------------------------------- -# Cursor kinds that can be exported as namespace-scope entities. -# Per-library extra preprocessor defines applied to the bundle TU (libclang -# parse AND the clang++ gate), so the .inc snapshot matches the module TU's -# macro state — e.g. stacktrace.cppm GMF defines BOOST_STACKTRACE_LINK -# (M4: link mode, impl in libs/stacktrace/src/basic.cpp), so the exported -# surface must be generated under the same macro. -EXTRA_DEFINES = { - "stacktrace": ["BOOST_STACKTRACE_LINK"], -} - -# Per-library GMF override (exact include set, relative to upstream/boost/): the -# module TU's real GMF when it deliberately diverges from the libs.json root -# set. json: M4 moves the compiled definitions into libs/json/src/src.cpp, so -# the module GMF (and thus the .inc snapshot) must not include src.hpp (which -# pulls the .ipp implementation declarations). -GMF_OVERRIDE = { - "json": ["boost/json/debug_printers.hpp", "boost/json.hpp"], - # outcome: the experimental/status-code subtree (system_code2 etc., marked - # EXPERIMENTAL upstream) redeclares Win32 APIs (FormatMessageW, ...) in - # extern "C" and conflicts with the mingw SDK once the whole outcome header - # set lands in one TU. Keep the module GMF to the supported (non- - # experimental) surface; the experimental headers remain include-only. - "outcome": ["boost/outcome.hpp"] + [ - "boost/outcome/{}.hpp".format(h) for h in ( - "bad_access", "basic_outcome", "basic_result", "boost_outcome", - "boost_result", "config", "convert", "coroutine_support", - "iostream_support", "iostream_support_result", "outcome", - "result", "std_outcome", "std_result", "success_failure", - "trait", "try", "utils") - ], -} - -EXPORT_KINDS = ( - "CLASS_DECL", "STRUCT_DECL", "UNION_DECL", "ENUM_DECL", - "ENUM_CONSTANT_DECL", - "FUNCTION_DECL", "FUNCTION_TEMPLATE", "VAR_DECL", - "TYPEDEF_DECL", "TYPE_ALIAS_DECL", "TYPE_ALIAS_TEMPLATE_DECL", - "CLASS_TEMPLATE", "CLASS_TEMPLATE_PARTIAL_SPECIALIZATION", - "CONCEPT_DECL", -) - -MEMBER_KINDS = ( - "CXX_METHOD", "CONSTRUCTOR", "DESTRUCTOR", "CONVERSION_FUNCTION", - "FIELD_DECL", -) - -# Lexical parents that can host a namespace-scope entity: anything else -# (function bodies, compound statements, templates of expressions) is local. -_LEXICAL_OK = ( - "NAMESPACE", "CLASS_DECL", "STRUCT_DECL", "UNION_DECL", "ENUM_DECL", - "CLASS_TEMPLATE", "CLASS_TEMPLATE_PARTIAL_SPECIALIZATION", - "TRANSLATION_UNIT", "LINKAGE_SPEC", -) - - -def _kind_name(cursor): - try: - return str(cursor.kind).replace("CursorKind.", "") - except Exception: - return "UNKNOWN" - - -# libclang has no cursor kind for variable templates: `VarTemplateDecl` (and -# its partial/explicit specializations) surfaces as UNEXPOSED_DECL, with a -# valid USR and EXTERNAL linkage, and without a visible child VarDecl. The -# primary template is recognized from its token stream and exported under this -# synthetic kind; partial/explicit specializations are not exported separately -# (a using-declaration of the primary name makes them all reachable). -# -# NB: under libclang error recovery a function template can also be reported as -# UNEXPOSED_DECL with a truncated extent (no parameter list), so it can be -# misread as a variable template. The resulting using-declaration is redundant -# (emit_inc dedups by qualified name) and harmless; internal-linkage targets -# are still rejected by bc.linkage_ok. -VAR_TEMPLATE_KIND = "VAR_TEMPLATE_DECL" - -_VT_CLASS = {} # usr -> "primary" | "partial" | "explicit" | None - - -def _classify_var_template(cursor, tu): - """'primary' | 'partial' | 'explicit' | None for an UNEXPOSED_DECL token - stream. Explicit specializations are `template <> ...`; partial ones carry - a `<...>` argument list right after the declared name.""" - toks = [t.spelling for t in bc.tokens_of(tu, cursor)] - if len(toks) < 2 or toks[0] != "template" or toks[1] != "<": - return None - if len(toks) >= 3 and toks[2] in (">", ">>"): - return "explicit" - depth, i = 0, 1 - while i < len(toks): - if toks[i] == "<": - depth += 1 - elif toks[i] in (">", ">>"): - depth -= 1 - if depth == 0: +def _top_const(qt): + """Top-level const of a printed object type: `const T`, `T *const`.""" + t = re.sub(r"<[^<>]*>", "", qt or "") + while "<" in t: + n = re.sub(r"<[^<>]*>", "", t) + if n == t: break - i += 1 - j = i + 1 - while j < len(toks) and toks[j] != cursor.spelling: - j += 1 - if j + 1 < len(toks) and toks[j + 1] == "<": - return "partial" - return "primary" + t = n + t = t.strip() + if "(" in t: + return False + ptr = max(t.rfind("*"), t.rfind("&")) + if ptr >= 0: + return bool(re.search(r"\bconst\b", t[ptr + 1:])) + return bool(re.search(r"\bconst\b", t)) -def _var_template_class(cursor, tu): - """Memoized classification of an UNEXPOSED_DECL as a variable template.""" - if _kind_name(cursor) != "UNEXPOSED_DECL" or not cursor.spelling: - return None - usr = bc.usr_of(cursor) - if usr and usr in _VT_CLASS: - return _VT_CLASS[usr] - result = _classify_var_template(cursor, tu) - if usr: - _VT_CLASS[usr] = result - return result - - -def _is_boost_var_template(cursor, tu): - """Cheap pre-filter (boost namespace) before token classification — the - std headers are full of variable templates (is_void_v, conjunction_v, ...) - that must not be indexed or tokenized.""" - if _kind_name(cursor) != "UNEXPOSED_DECL" or not cursor.spelling: - return False - chain = bc.namespace_chain(cursor) - if not chain or chain[0] != "boost": - return False - return _var_template_class(cursor, tu) == "primary" +# --------------------------------------------------------------------------- +# collectors +# --------------------------------------------------------------------------- +_FILE_TO_LIB = {} +_HOME_MEMO = {} -def is_export_kind(cursor, tu=None): - if _kind_name(cursor) in EXPORT_KINDS: - return True - return tu is not None and _var_template_class(cursor, tu) == "primary" + +def home_of_file(path): + h = _HOME_MEMO.get(path) + if h is None: + h = _HOME_MEMO[path] = bc.home_lib_of_file(Path(path), _FILE_TO_LIB) \ + if path else "shared" + return h -def entity_record(cursor, home): - """Stable dict describing one exportable entity.""" - kind = _kind_name(cursor) - # Enumerators are injected into the enum's enclosing namespace (upstream - # spelling: boost::red), so they group under the enum's namespace chain. - ns = (bc.namespace_chain(cursor.semantic_parent) - if kind == "ENUM_CONSTANT_DECL" else bc.namespace_chain(cursor)) +def entity_record(m, d, home): + kind = d.kind + ns = (m.namespace_chain(m.sem_parent(d)) if kind == "EnumConstantDecl" + else m.namespace_chain(d)) return { - "name": cursor.spelling, - "qname": bc.qualified_name(cursor), - "usr": bc.usr_of(cursor), + "name": d.name, + "qname": m.qualified_name(d), + "usr": m.stable_key(d), "ns": ns, - "file": str(bc.cursor_file(cursor)) if bc.cursor_file(cursor) else "", + "file": d.file, "home": home, "kind": kind, } -def _is_scoped_enum(cursor, tu): - """Scoped enums (enum class/struct, incl. macro-generated ones like - boost::thread's BOOST_SCOPED_ENUM_*) do not inject their enumerators into - the enclosing scope. Uses clang_EnumDecl_isScoped (macro-generated enums - have no tokens over their extent, so token sniffing fails for them).""" - try: - ci = bc.get_ci() - r = ci.conf.lib.clang_EnumDecl_isScoped(cursor) - return bool(r) - except Exception: - pass - try: - for tok in bc.tokens_of(tu, cursor): - if tok.spelling == "enum": - continue - if tok.spelling in ("class", "struct"): - return True - return False - except Exception: - return False - return False - +def _owner_file(m, d): + """Ownership follows the definition, not the first declaration: a forward + declaration in another library's header must not let that library claim + the entity (boost::rational forward-declared by boost.integer).""" + dd = m.definition(d) + return (dd or d).file -DECL_KINDS = set(EXPORT_KINDS) | set(MEMBER_KINDS) | { - "PARM_DECL", "CXX_BASE_SPECIFIER", "ENUM_DECL", "NAMESPACE", - # using-declarations / directives: namespace-scope `using boost::X;` / - # `using namespace boost::X;` re-exports that give entities their public - # spelling (ADL-barrier pattern — see collect_injections). - "USING_DECLARATION", "USING_DIRECTIVE", -} - - -def _index_key(cursor): - """usr_index key — real USRs for entities; a location-based fallback for - using-directives (clang gives them no USR at all).""" - usr = bc.usr_of(cursor) - if usr: - return usr - if _kind_name(cursor) == "USING_DIRECTIVE": - f = bc.cursor_file(cursor) - if f is not None: - # line+column: two directives on the same source line must not - # share a key (first index entry wins and would swallow the rest). - return "dir:{}:{}:{}".format(f, cursor.location.line, - cursor.location.column) - return None - - -def build_usr_index(tu): - """One pass over the whole TU building {usr: cursor} for every decl. - - Closure lookups then become O(1) instead of re-walking the AST per entity - (which made json/url generation quadratic). FRIEND_DECL subtrees are - skipped: friend functions are re-exported through their class by ADL and - cannot be using-exported.""" - _VT_CLASS.clear() # per-TU memo (error recovery is TU-specific) - idx = {} - - def rec(cursor): - if _kind_name(cursor) in DECL_KINDS or _is_boost_var_template(cursor, tu): - key = _index_key(cursor) - if key and key not in idx: - idx[key] = cursor - for child in cursor.get_children(): - if bc.kind_of(child) == ci.CursorKind.FRIEND_DECL: - continue - rec(child) - - rec(tu.cursor) - return idx - - -def _is_explicit_specialization(cursor, tu): - """Explicit specializations (`template<> ...`) of templates are not - exportable via using-declarations. clang_getSpecializedCursorTemplate - returns null for them (unlike explicit instantiations), so detect the - empty template-parameter list via the token stream of the decl extent.""" - try: - toks = bc.tokens_of(tu, cursor) - except Exception: - return False - if len(toks) < 3: - return False - return toks[0].spelling == "template" and toks[1].spelling == "<" and \ - toks[2].spelling in (">", ">>") - -def collect_candidates(lib, tu, file_to_lib, usr_index): +def collect_candidates(lib, m): """External-linkage namespace-scope boost:: entities reachable through the - library's bundle TU, owned by this library or by no target library - ('shared'). Entities owned by other target libraries are pulled in by the - closure instead (they are exported by their own module, reached via the - export-import chain recorded in .deps). Returns {usr: record}.""" + bundle TU, owned by this library or by no target library ('shared').""" found = {} - - def visit(cursor): - if not is_export_kind(cursor, tu): - return - f = bc.cursor_file(cursor) - if f is None: - return - # Ownership follows the DEFINITION, not the first declaration: a - # forward declaration in another lib's header (e.g. class rational - # forward-declared in boost/integer/common_factor_rt.hpp) must not let - # that lib claim the entity's USR (M9: integer claimed boost::rational - # this way and rational lost it). Resolve to the definition when one - # exists elsewhere. - try: - if not cursor.is_definition(): - d = cursor.get_definition() - if d is not None and d != cursor: - df = bc.cursor_file(d) - if df is not None: - f = df - except Exception: - pass - home = bc.home_lib_of_file(f, file_to_lib) + for d in m.indexed(): + if d.kind not in EXPORT_KINDS: + continue + home = home_of_file(_owner_file(m, d)) if home not in (lib, "shared"): - return - if not bc.linkage_ok(cursor): - return - if bc.is_specialization(cursor): - return - if _is_explicit_specialization(cursor, tu): - return - if cursor.spelling.startswith("<"): - return # C++17 deduction guides (spelled "") - # Declarations whose lexical context is inside a function body are - # body-local (e.g. clang's vexing-parse artifact: a local - # `std::string cat_name(...)` reported as a namespace-scope function - # with external linkage in cpp_regex_traits.hpp:966). - if _kind_name(cursor.lexical_parent) not in _LEXICAL_OK: - return - # friend-in-class declarations (operators etc.): lexical parent is the - # class while the semantic parent is a namespace; they are re-exported - # through the class by ADL (M0 §1) and cannot be using-exported. - pk = bc.kind_of(cursor.lexical_parent) - if pk in (ci.CursorKind.CLASS_DECL, ci.CursorKind.STRUCT_DECL, - ci.CursorKind.UNION_DECL, ci.CursorKind.CLASS_TEMPLATE): - return - qn = bc.qualified_name(cursor) + continue + if m.is_specialization(d): + continue + if not d.name or not (d.name[0].isalpha() or d.name[0] == "_"): + continue # deduction guides, anonymous entities + lex = d.parent + if lex is not None and lex.kind not in ( + "NamespaceDecl", "LinkageSpecDecl", "EnumDecl", "ExportDecl"): + continue # class member / friend-in-class + qn = m.qualified_name(d) if not qn.startswith("boost::"): - return - if _kind_name(cursor) == "ENUM_CONSTANT_DECL": - # Enumerators of enums nested in classes are class members - # (exported with their class, e.g. isref::value_type::value); - # only namespace-scope enums inject their enumerators into the - # enclosing namespace. Scoped (enum class) enumerators come with - # the enum itself. - enum = cursor.semantic_parent - if not bc.namespace_chain(enum): - return - if _is_scoped_enum(enum, tu): - return - elif not bc.namespace_chain(cursor): - return # class member: exported with its class - usr = bc.usr_of(cursor) - if not usr or usr in found: - return - # Prefer the first (definition) declaration seen per entity. - rec = entity_record(cursor, home) - if _kind_name(cursor) == "UNEXPOSED_DECL": - rec["kind"] = VAR_TEMPLATE_KIND - found[usr] = rec - - for usr, cursor in usr_index.items(): - visit(cursor) + continue + if d.kind == "EnumConstantDecl": + enum = m.sem_parent(d) + if not m.namespace_chain(enum): + continue + if enum.attrs.get("scopedEnumTag"): + continue # enum class: enumerators come with it + elif not m.namespace_chain(d): + continue + if not m.linkage_ok(d): + continue + if any(r.parent is not None and r.parent.kind == "LinkageSpecDecl" + for r in m.redecls(d)): + continue # C language linkage: not namespace API + key = m.stable_key(d) + if key in found: + continue + found[key] = entity_record(m, d, home) return found -# --------------------------------------------------------------------------- -# using-injection collection (M3 round-3 generator fix) -# --------------------------------------------------------------------------- - -def _enclosing_ns(cursor): - """Namespace chain of a using-* declaration's lexical parent, e.g. - ['boost','tuples'] — the scope the injected name lands in.""" +def _enclosing_ns(m, d): + """Namespace chain of a using-* declaration's lexical scope ([] inside an + anonymous namespace).""" parts = [] - cur = cursor.lexical_parent - while cur is not None: - if bc.kind_of(cur) != ci.CursorKind.NAMESPACE: - break - try: - if cur.is_anonymous(): - return [] - except Exception: + cur = d.parent + while cur is not None and cur.kind == "NamespaceDecl": + if not cur.name: return [] - parts.append(cur.spelling) - cur = cur.semantic_parent + parts.append(cur.name) + cur = cur.parent return parts[::-1] -def _using_target_name(cursor, tu): - """Injected name of a namespace-scope using-declaration, derived from its - token stream. Boost writes two shapes: - - `using boost::iterators::counting_iterator;` (fully qualified) - `using range::count;` inside `namespace boost` (relative — injects - boost::range::count into boost::count) - - libclang's USING_DECLARATION carries no usable referenced target, its - spelling holds only the last name segment, and the token extent starts at - 'using' and often omits the trailing ';' — so the tokens are joined and - the missing prefix is reconstructed from the lexical parent chain. - - Returns (injected_qname, target_qname) — the name re-exported into the - enclosing scope, and the qualified name the using refers to ('' each when - the shape is not usable). For the fully-qualified shape the two coincide - (the name is re-exported at its own qualified location); for the relative - shape the injected name is the last segment prefixed with the enclosing - namespace chain (e.g. boost::count for `using range::count;` inside - namespace boost) while the target keeps the intermediate namespaces - (boost::range::count).""" - try: - toks = bc.tokens_of(tu, cursor) - except Exception: - return "", "" - toks = [t.spelling for t in toks] - if not toks or toks[0] != "using" or (len(toks) > 1 and toks[1] == "namespace"): - return "", "" - # The token extent can include the terminating ';' and — on a - # multi-statement line — everything after it. Cut at the first ';' so - # trailing content cannot corrupt the reconstructed qualified name. - if ";" in toks: - toks = toks[:toks.index(";")] - rel = "".join(toks[1:]).rstrip(";") - # `using ::boost::bimaps::bimap;` / `using ::GetCurrentProcessId;` — - # global-scope qualification: the using injects only the LAST segment into - # the enclosing namespace (boost::bimap / boost::winapi::GetCurrentProcessId) - # while the target keeps the intermediate namespaces (or is global — M9). - if rel.startswith("::"): - rel = rel[2:] - parts = _enclosing_ns(cursor) - if not parts or parts[0] != "boost": - return "", "" - prefix = "::".join(parts) - return prefix + "::" + rel.rsplit("::", 1)[-1], rel +def _using_target_name(m, d): + """(injected qname, target qname) of a namespace-scope using-declaration + from the name clang prints as written (`range::count`, + `boost::iterators::counting_iterator`, `::boost::bimaps::bimap`, + `std::ratio`, `::GetCurrentProcessId`).""" + rel = d.name or "" if not rel: return "", "" - if rel.startswith("std::"): - # boost-namespace alias of a std entity (`using std::ratio;` inside - # namespace boost — Boost.Ratio 1.92 is a std::ratio facade). The - # injected name is boost::; the module must re-export the - # std:: target itself (`using std::ratio;`), because a using-decl of a - # using-decl is not exportable (M9). - parts = _enclosing_ns(cursor) + parts = _enclosing_ns(m, d) + absolute = rel.startswith("::") + if absolute: + rel = rel[2:] + if absolute or rel.startswith(("std::", "boost::")): + # Fully qualified target: the declaration still injects its last + # segment into the enclosing namespace (`namespace boost::range { + # using boost::range_detail::formatted_range; }` publishes + # boost::range::formatted_range). if not parts or parts[0] != "boost": return "", "" - prefix = "::".join(parts) - return prefix + "::" + rel.rsplit("::", 1)[-1], rel - if rel.startswith("boost::"): - return rel, rel - # Relative: prefix with the enclosing namespace chain. - parts = _enclosing_ns(cursor) + return "::".join(parts) + "::" + rel.rsplit("::", 1)[-1], rel if not parts or parts[0] != "boost": return "", "" prefix = "::".join(parts) return prefix + "::" + rel.split("::")[-1], prefix + "::" + rel -def _using_namespace_target(cursor, tu): - """Target namespace of a namespace-scope `using namespace X;` directive - (boost's ADL-barrier variant: `using namespace range_adl_barrier;` inside - namespace boost). Returns the target's qualified name ('' - when unusable).""" - try: - toks = bc.tokens_of(tu, cursor) - except Exception: - return "" - toks = [t.spelling for t in toks] - if len(toks) < 3 or toks[0] != "using" or toks[1] != "namespace": - return "" - rel = "".join(toks[2:]).rstrip(";") - if not rel or rel.startswith("::") or rel.startswith("std::"): - return "" - if rel.startswith("boost::"): - return rel - parts = _enclosing_ns(cursor) - if not parts or parts[0] != "boost": - return "" - return "::".join(parts) + "::" + rel - - -def collect_injections(tu, lib, file_to_lib, claimed, usr_index): - """Namespace-scope `using boost::X;` declarations that re-export entities - under their public spelling. Boost uses this pervasively to hide - implementation namespaces while keeping the API at a fixed qualified name: - - boost::range_adl_barrier::{count,find,...} → boost::count - - boost::iterators::{counting_iterator,...} → boost::counting_iterator - - boost::system::detail::*, boost::optional_detail::* → boost::* - - Such names never appear as declaration entities (the generator would only - see boost::range_adl_barrier::count), so consumers would lose the public - spelling. The public name is collected as its own record: the module - purview can `export using boost::count;` because the GMF (which includes - exactly the bundle headers) makes the name visible — using-declarations - are reachable exactly when their file is in the GFM include-DAG, so a - record produced here always compiles. - - M9: injected names must denote an EXTERNAL-linkage entity — a using- - declaration of an internal-linkage name (e.g. boost::hof's placeholder - objects, `static constexpr auto& _1 = ...`) cannot be exported. The - injection's target is resolved through the qname→cursors map and the - entity's linkage checked (all cursors of the qname must be external; a - single internal overload poisons the using-declaration). - - claimed: {public_qname: lib} — cross-module dedup for injected names - (first wins, like USR claiming). Returns {qname: record}.""" +def collect_injections(lib, m, claimed): + """Namespace-scope `using boost::X;` / `using namespace X;` that give + entities their public spelling (ADL barriers, detail re-exports). The + injected name must denote external-linkage entities only.""" out = {} - directives = [] # (target_chain, inject_prefix) pairs - qname_cursors = {} - for usr, cursor in usr_index.items(): - if not is_export_kind(cursor, tu): - continue - qn = bc.qualified_name(cursor) - if qn: - qname_cursors.setdefault(qn, []).append(cursor) - for usr, cursor in usr_index.items(): - kind = _kind_name(cursor) - if kind not in ("USING_DECLARATION", "USING_DIRECTIVE"): + qmap = m.export_qindex() + directives = [] + for d in m.indexed(): + if d.kind not in ("UsingDecl", "UsingDirectiveDecl"): continue - if _kind_name(cursor.lexical_parent) != "NAMESPACE": + if d.parent is None or d.parent.kind != "NamespaceDecl": continue - f = bc.cursor_file(cursor) - if f is None: + if home_of_file(d.file) not in (lib, "shared"): continue - if bc.home_lib_of_file(f, file_to_lib) not in (lib, "shared"): - continue - if kind == "USING_DECLARATION": - q, target = _using_target_name(cursor, tu) - if not q: - continue - if q in claimed: + if d.kind == "UsingDecl": + q, target = _using_target_name(m, d) + # First wins per (name, target): `boost::join` from range::join + # and from algorithm::join are different overload sets, and an + # exported using-declaration carries only what its own GMF sees. + ckey = q + "=" + target + if not q or q in claimed or ckey in claimed: continue - # M9: the injected name must denote an EXTERNAL-linkage entity — - # resolve the using's target declaration (the relative shape - # re-exports the last segment but the entity lives in the full - # target namespace) and require external linkage; an - # internal-linkage target (e.g. boost::hof's placeholder objects, - # `static constexpr auto& _1 = ...`) cannot be exported. - # std:: targets (boost-namespace aliases of std entities, e.g. - # boost::ratio = std::ratio) and global targets (e.g. - # `using ::GetCurrentProcessId;` inside boost::winapi — the - # declaration lives at global scope, never in the boost qname map) - # skip the check — both always have external linkage. if target.startswith("std::") or not target.startswith("boost::"): - # `using std::ratio;` / `using ::AreFileApisANSI;` — global - # targets must stay qualified in the emitted line (an - # unqualified `using X;` would look inside the enclosing - # namespace block). - emit_q = target if target.startswith("std::") else "::" + target + emit_q = target if target.startswith("std::") \ + else "::" + target else: emit_q = q - cur_list = qname_cursors.get(target) or qname_cursors.get(q) - if not cur_list: - continue # not declared in this TU: nothing to inject - if any(not bc.linkage_ok(c) for c in cur_list): - continue # internal linkage: not exportable (M9) - claimed[q] = lib + cur = qmap.get(target) or qmap.get(q) + if not cur: + continue + if any(not m.linkage_ok(c) for c in cur): + continue + claimed[ckey] = lib out[q] = { - "name": emit_q.rsplit("::", 1)[-1], - "qname": emit_q, - "usr": "inject:" + q, # not a real USR — excluded from closure - "ns": q.split("::")[:-1], - "file": str(f), - "home": lib, - "kind": "USING_INJECT", + "name": emit_q.rsplit("::", 1)[-1], "qname": emit_q, + "usr": "inject:" + ckey, "ns": q.split("::")[:-1], + "file": d.file, "home": lib, "kind": "USING_INJECT", } else: - tgt = _using_namespace_target(cursor, tu) - if not tgt: + ns = m.by_id.get(d.target) + if ns is None: + continue + tgt = m.qualified_name(ns) + if not tgt.startswith("boost::"): continue - parts = _enclosing_ns(cursor) + parts = _enclosing_ns(m, d) if not parts: continue - directives.append((tgt.split("::"), "::".join(parts), f)) + prefix = "::".join(parts) + if not tgt.startswith(prefix + "::"): + # Only the ADL-barrier shape re-publishes names: a namespace + # nested in the directive's own scope (`namespace boost { + # namespace range_adl_barrier {...} using namespace + # range_adl_barrier; }`). A directive that pulls a sibling + # detail namespace in (`using namespace detail;` inside + # poly_collection::common_impl) is an implementation + # convenience, not a public spelling. + continue + directives.append((tgt.split("::"), prefix, d.file)) for tgt_chain, prefix, df in directives: - for usr, cursor in usr_index.items(): - if not is_export_kind(cursor, tu): + for d in m.indexed(): + if d.kind not in EXPORT_KINDS: continue - try: - chain = bc.namespace_chain(cursor) - except Exception: + if m.namespace_chain(d) != tgt_chain: continue - if chain != tgt_chain: + if not m.linkage_ok(d): continue - if not bc.linkage_ok(cursor): - continue # internal linkage: not exportable (M9) - q = prefix + "::" + cursor.spelling - if not q.startswith("boost::") or q in claimed: + q = prefix + "::" + d.name + ckey = q + "=" + "::".join(tgt_chain) + "::" + d.name + if not q.startswith("boost::") or q in claimed or ckey in claimed: continue - claimed[q] = lib + claimed[ckey] = lib out[q] = { - "name": cursor.spelling, - "qname": q, - "usr": "inject:" + q, - "ns": q.split("::")[:-1], - "file": str(df), - "home": lib, + "name": d.name, "qname": q, "usr": "inject:" + ckey, + "ns": q.split("::")[:-1], "file": df, "home": lib, "kind": "USING_INJECT", } return out -def collect_curated(lib, claimed, usr_index=None, tu=None): - """tools/curated/.txt — hand-written blind-spot overrides (M2 §2.3, - read-out implemented in M3). One qualified name per line; lines starting - with '#' are comments. Records are emitted exactly like using-injections - (`export using boost::xxx;`), so every listed name must be visible in the - module's GMF (it is, when the header chain that declares it is included). - - M9: like injections, curated names must denote external-linkage entities - in the TU; when usr_index is given, names that resolve to no declaration - or to an internal-linkage declaration are dropped with a warning. - - Use cases: - - entities reachable only through template bodies (closure walks - declarations, not bodies — e.g. boost::typeindex::* behind - any_cast's body in boost/any.hpp); - - boost-namespace aliases of std entities that the canonicalization in - the closure resolves away (type_info → std::type_info). - - cross-module re-export overrides: an entity already claimed by an - earlier-processed module (first-wins) can be force-listed here when - the module's exported template BODIES require it — e.g. - boost::any's any_cast body compares typeinfo, so the typeindex - operator set must be reachable from consumers importing only - boost.any even though the 27-lib run claims it for boost.variant. - Re-exporting the same entity from two modules is legal (they denote - the same declaration); M3 did exactly that before cross-module - dedup existed.""" - f = bc.CURATED_DIR / (lib + ".txt") - if not f.exists(): - return {} +def collect_added(lib, m, policy, claimed): + """Policy `add` names: exported like using-injections when the TU + declares them (a name the GMF cannot see would not compile).""" out = {} - for line in f.read_text(encoding="utf-8").splitlines(): - q = line.strip() - if not q or q.startswith("#"): - continue + qmap = m.export_qindex() + for q in policy.add(lib): if not q.startswith("boost::"): continue - if usr_index is not None: - found = any( - is_export_kind(c, tu) and bc.qualified_name(c) == q - for usr, c in usr_index.items()) - if not found: - print(" curated skip (not in TU): {}".format(q)) - continue + if q not in qmap: + print(" policy add skipped (not in TU): {}".format(q)) + continue claimed.setdefault(q, lib) out[q] = { - "name": q.rsplit("::", 1)[-1], - "qname": q, - "usr": "inject:" + q, - "ns": q.split("::")[:-1], - "file": str(f), - "home": lib, - "kind": "CURATED", + "name": q.rsplit("::", 1)[-1], "qname": q, "usr": "inject:" + q, + "ns": q.split("::")[:-1], "file": str(POLICY_FILE), "home": lib, + "kind": "POLICY_ADD", } return out # --------------------------------------------------------------------------- -# dependency closure +# signature closure (pass 1) # --------------------------------------------------------------------------- -def referenced_types(cursor): - """Yield the types referenced by a namespace-scope entity's declaration: - function params/return, base classes, typedef/variable types.""" - kinds = set() - try: - kind = cursor.kind - except Exception: - kind = None - - if kind == ci.CursorKind.FUNCTION_DECL: - kinds = {"FUNCTION_DECL"} - elif kind == ci.CursorKind.FUNCTION_TEMPLATE: - kinds = {"FUNCTION_TEMPLATE"} - elif kind in (ci.CursorKind.CLASS_DECL, ci.CursorKind.STRUCT_DECL, - ci.CursorKind.UNION_DECL, - ci.CursorKind.CLASS_TEMPLATE, - ci.CursorKind.CLASS_TEMPLATE_PARTIAL_SPECIALIZATION): - kinds = {"CLASS"} - elif kind in (ci.CursorKind.TYPEDEF_DECL, ci.CursorKind.TYPE_ALIAS_DECL, - ci.CursorKind.TYPE_ALIAS_TEMPLATE_DECL, ci.CursorKind.VAR_DECL): - kinds = {"TYPE"} - elif kind == ci.CursorKind.CONCEPT_DECL: - return - - for child in cursor.get_children(): - ck = bc.kind_of(child) - if ck == ci.CursorKind.PARM_DECL: - yield child.type - elif ck == ci.CursorKind.CXX_BASE_SPECIFIER: - yield child.type - elif ck == ci.CursorKind.FIELD_DECL and "CLASS" in kinds: - yield child.type - elif _kind_name(child) in ("CXX_METHOD", "CONSTRUCTOR", "DESTRUCTOR", - "CONVERSION_FUNCTION", "STATIC_DATA_MEMBER"): - yield child.type - - # Return type of functions / underlying type of typedefs/vars. - try: - t = cursor.type - if t is not None and t.kind != ci.TypeKind.INVALID: - if kind == ci.CursorKind.FUNCTION_DECL or \ - _kind_name(cursor) == "CXX_METHOD" or \ - _kind_name(cursor) == "CONVERSION_FUNCTION": - try: - yield t.get_result() - except Exception: - pass - elif "TYPE" in kinds: - yield t - except Exception: - pass - - -def iter_type_types(t): - """Walk a clang Type recursively, yielding the leaf (canonicalized) types - reachable through pointers, references, functions and template args.""" - try: - t = t.get_canonical() - except Exception: - return - kind = t.kind - if kind == ci.TypeKind.INVALID: - return - if kind in (ci.TypeKind.POINTER, ci.TypeKind.LVALUEREFERENCE, - ci.TypeKind.RVALUEREFERENCE, ci.TypeKind.MEMBERPOINTER): - try: - yield from iter_type_types(t.get_pointee()) - except Exception: - pass - return - if kind == ci.TypeKind.FUNCTIONPROTO: - try: - yield from iter_type_types(t.get_result()) - except Exception: - pass - return - if kind in (ci.TypeKind.CONSTANTARRAY, ci.TypeKind.INCOMPLETEARRAY, - ci.TypeKind.VARIABLEARRAY, ci.TypeKind.DEPENDENTSIZEDARRAY): - try: - yield from iter_type_types(t.get_pointee()) - except Exception: - pass - return - try: - n = t.get_num_template_arguments() - if n >= 0: - for i in range(n): - yield from iter_type_types(t.get_template_argument_type(i)) - # Template types: the template itself is not a leaf we need; the - # instantiation decl carries the args above. - except Exception: - pass - yield t - - -def closure_from(cands, tu, usr_index): - """BFS over candidate entity signatures; returns {usr: record} for every - boost:: entity reachable through their declarations (exported entities and - closure pulls alike).""" +def signature_types(m, d): + """(type text, lookup scopes) pairs of an entity's declaration: function + parameters and result, base classes, fields, member results, static data + members, typedef/variable types.""" + k = d.kind + scopes = m.scope_names(d) + if k == "FunctionDecl": + for t in d.params: + yield t, scopes + yield _result_type(d.type), scopes + elif k == "FunctionTemplateDecl": + if d.pattern is not None: + for t in d.pattern.params: + yield t, scopes + elif k in ("CXXRecordDecl", "RecordDecl", "ClassTemplateDecl", + "ClassTemplatePartialSpecializationDecl"): + rec = d.pattern if k == "ClassTemplateDecl" else d + if rec is None: + return + inner = m.scope_names(rec) if k != "ClassTemplateDecl" else scopes + for b in rec.bases: + yield b, inner + for ch in rec.children: + ck = ch.kind + if ck == "FieldDecl" or ck == "VarDecl": + yield ch.type, inner + elif ck in METHOD_KINDS: + yield _result_type(ch.type), inner + elif k in ("TypedefDecl", "TypeAliasDecl", "VarDecl"): + yield d.dtype or d.type, scopes + + +def _result_type(ftype): + """Result part of a printed function type `R (params)`; the trailing + form `auto (params) -> R` yields R.""" + if not ftype: + return "" + depth = 0 + for i, c in enumerate(ftype): + if c in "<[": + depth += 1 + elif c in ">]": + depth -= 1 + elif c == "(" and depth == 0: + head = ftype[:i].strip() + if head == "auto": + tail = ftype.rsplit("->", 1) + return tail[1].strip() if len(tail) == 2 else "" + return head + return "" + + +def closure_from(m, cands): + """BFS over candidate signatures; {key: record} for every boost:: entity + reachable through the declarations (exports and closure pulls).""" records = dict(cands) - queue = deque(cands.values()) - seen = set(cands) - + queue = deque(r for r in cands.values() + if not r["usr"].startswith("inject:")) + by_key = m.export_index() + pulled = {} # closure targets by_key lacks; it is shared + seen = set(records) while queue: rec = queue.popleft() - cursor = usr_index.get(rec["usr"]) - if cursor is None: + d = by_key.get(rec["usr"]) or pulled.get(rec["usr"]) + if d is None: continue - for t in referenced_types(cursor): - for leaf in iter_type_types(t): - try: - decl = leaf.get_declaration() - if decl is None or not decl.spelling and not decl.location.file: - continue - except Exception: - continue - qn = bc.qualified_name(decl) + for text, scopes in signature_types(m, d): + for t in m.type_targets(text, scopes): + target = m.promote(t) + qn = m.qualified_name(target) if not qn.startswith("boost::"): continue - # Promote members to their containing class, friends to their - # namespace-level home. - target = _promote(decl) - usr = bc.usr_of(target) - if not usr or usr in seen: + key = m.stable_key(target) + if key in seen: continue - qnt = bc.qualified_name(target) - if not qnt.startswith("boost::"): - continue - f = bc.cursor_file(target) - home = bc.home_lib_of_file(f, _FILE_TO_LIB) if f else "shared" - seen.add(usr) - records[usr] = entity_record(target, home) - queue.append(records[usr]) + seen.add(key) + if key not in by_key: + pulled.setdefault(key, target) + home = home_of_file(_owner_file(m, target)) + records[key] = entity_record(m, target, home) + queue.append(records[key]) return records -def _promote(cursor): - """Climb from a member cursor to the namespace-scope entity containing it.""" - cur = cursor - while True: - parent = cur.semantic_parent - if parent is None or parent == cur: - return cursor - pk = bc.kind_of(parent) - if pk in (ci.CursorKind.CLASS_DECL, - ci.CursorKind.STRUCT_DECL, - ci.CursorKind.UNION_DECL, - ci.CursorKind.CLASS_TEMPLATE): - cur = parent - continue - return cur - - -_FILE_TO_LIB = {} - - -# --------------------------------------------------------------------------- -# output -# --------------------------------------------------------------------------- - -def emit_inc(lib, records, out_dir, full_closure, claimed, extra_deps=()): - """Write generated/exports/.inc with M0-verified export block spelling. - - Cross-module dedup (first wins): entities already claimed by an earlier - module are dropped from the export list and recorded in .deps as - `export import mcpplibs.mwrap.boost.;` hints. Within one library, duplicate - qualified names collapse into a single using-declaration (which imports - every overload of the name — M0 rule for free operators). - - extra_deps: target libraries whose headers the bundle TU pulls in but - whose entities may not appear in any signature (e.g. boost::swap) — the - M3 .cppm must export-import those modules for a complete surface. - - Returns (exported_count, deps_hints). - """ - own = [r for r in records.values() if r["home"] == lib] - pulled = [r for r in records.values() - if r["home"] != lib and r["usr"] not in claimed] - deps = sorted({r["home"] for r in records.values() - if r["home"] != lib and r["home"] != "shared" - and r["usr"] in claimed} | (set(extra_deps) if not full_closure else set())) - - # qname dedup (one using per qualified name; overloads come along). - exports, seen = [], set() - for rec in sorted(own + pulled, key=lambda r: r["qname"]): - if rec["qname"] in seen: - continue - seen.add(rec["qname"]) - exports.append(rec) - - groups = {} - for rec in exports: - groups.setdefault(tuple(rec["ns"]), []).append(rec) - - lines = [ - "// GENERATED by tools/gen_exports.py - DO NOT EDIT", - "// lib={} boost=1.92.0 target={} entities={}".format( - lib, bc.GEN_TARGET, len(exports)), - "", - ] - for key in sorted(groups): - depth = len(key) - opens = " ".join("namespace {} {{".format(n) for n in key) - lines.append("export " + opens) - for rec in sorted(groups[key], key=lambda r: r["qname"]): - lines.append(" using {};".format(rec["qname"])) - lines.append("}" * depth) - lines.append("") - - # Match the committed LF snapshots on every host. Git attributes govern - # checkout, not Python's default Windows text-mode newline translation. - (out_dir / "generated" / "exports").mkdir(parents=True, exist_ok=True) - (out_dir / "generated" / "exports" / (lib + ".inc")).write_text( - "\n".join(lines), encoding="utf-8", newline="\n") - - if deps: - (out_dir / "generated" / "exports" / (lib + ".deps")).write_text( - "\n".join(bc.MODULE_PREFIX + "." + d for d in deps) + "\n", encoding="utf-8", newline="\n") - return len(exports), deps - - -def emit_cppm(lib, out_dir, gfm_headers=None): - """Draft src/.cppm: GMF include of the aggregate (DAG-source, gate- - pruned) headers + export blocks from the .inc. M3 owns the final form - (macro consistency, export import wiring for the .deps).""" - headers = gfm_headers if gfm_headers is not None else bc.gfm_headers_of(lib) - deps = out_dir / "generated" / "exports" / (lib + ".deps") - imports = "" - if deps.exists(): - imports = "\n".join( - "export import {};".format(line.strip()) - for line in deps.read_text(encoding="utf-8").splitlines() if line.strip()) - lines = [ - "// GENERATED by tools/gen_exports.py - DO NOT EDIT (draft; M3 owns final form)", - "module;", - ] - lines += ["#include <{}>".format(h.relative_to(bc.DEPS).as_posix()) - for h in headers] - lines += [ - "", - "export module {}.{};".format(bc.MODULE_PREFIX, lib), - "", - ] - if imports: - lines += [imports, ""] - lines += [ - '#include "../generated/exports/{}.inc"'.format(lib), - "", - # NB: no `module :private;` — private module fragments are not yet - # implemented by gcc, and nothing here needs hiding. - "", - ] - (out_dir / "src" / (lib + ".cppm")).write_text( - "\n".join(lines), encoding="utf-8", newline="\n") - - # --------------------------------------------------------------------------- -# pass 2: body-reference edge completion (C4 §4.2 structural-defect fix) +# pass 2: body-reference edge completion # --------------------------------------------------------------------------- -# Cursor kinds that carry a reference to a declaration. Referenced decls are -# resolved through clang_getCursorReferenced (null when the reference stays -# unresolved — e.g. dependent names in uninstantiated templates resolve only -# partially; those are best-effort). -_REF_KIND_NAMES = ( - "DECL_REF_EXPR", "MEMBER_REF_EXPR", "MEMBER_REF", "TYPE_REF", - "TEMPLATE_REF", "NAMESPACE_REF", "UNRESOLVED_LOOKUP_EXPR", - "UNRESOLVED_MEMBER", "OVERLOADED_DECL_REF", -) - - -def _template_of_instantiation(cursor): - """The class/function template behind an implicit instantiation (None - otherwise). An instantiation cursor's location can be the instantiation - point, so its file is useless for home resolution — the template's own - definition file is the entity's true home.""" - try: - ci = bc.get_ci() - r = ci.conf.lib.clang_getSpecializedCursorTemplate(cursor) - if r is not None and r.kind != ci.CursorKind.INVALID: - return r - except Exception: - pass - return None - - -def _identifier(tok): - return bool(tok) and tok.isidentifier() - - -def _qname_cursor_index(usr_index): - """{boost::qualified_name: [cursor, ...]} over a TU's decl index — used to - resolve textually recovered qualified names (variable-template - initializers, which libclang does not expose as an AST subtree).""" - idx = {} - for cur in usr_index.values(): - qn = bc.qualified_name(cur) - if qn.startswith("boost::"): - idx.setdefault(qn, []).append(cur) - return idx - - -def _var_template_initializer_names(tu, cursor, max_lines=100): - """Yield qualified name chains (`a::b::c`) from a variable template's - initializer (A1 + A2). - - libclang hides the initializer: the `VarTemplateDecl` surfaces as an - UNEXPOSED_DECL with no children, an INVALID type, and an extent that stops - right after the declared name (LLVM 22/23). Re-tokenize the - declaration from `cursor.extent.start` up to its top-level `;`, take the - tokens after the `=` that follows the declared name, and read off - `ident (:: ident)+` chains — both `boost::...` (A1, resolved as-is) and - relative names like `mp11::mp_size` (A2, resolved against the variable - template's enclosing namespaces). Bare single identifiers are skipped: - only qualified chains are unambiguous enough to resolve textually. - Macro-expanded / aliased names are still missed by design. - """ - cf = cursor.location.file # cindex File (for SourceLocation) - if cf is None: - return - # Tokenize from the declaration start (NOT extent.end): whether libclang - # truncates the extent after the name (LLVM 22) or not, we must see the - # whole declaration up to its top-level ';'. - beg = cursor.extent.start - toks, line, col, budget = [], beg.line, beg.column, max_lines - while budget > 0: - chunk = min(25, budget) - try: - start = ci.SourceLocation.from_position(tu, cf, line, col) - stop = ci.SourceLocation.from_position(tu, cf, line + chunk, 1) - toks.extend(t.spelling for t in tu.get_tokens( - extent=ci.SourceRange.from_locations(start, stop))) - except Exception: +def collect_body_edges(lib, m, records, claimed): + """{home: set(key)} — other target libraries whose entities the BODIES of + this library's exported entities refer to (references clang resolved, and + the types they spell). The signature closure under-approximates what a + consumer instantiating those bodies needs (bimap -> boost.iterator).""" + edges = {} + seen_pairs = set() + + def add_edge(r): + r = m.promote(r) + if not m.qualified_name(r).startswith("boost::"): return - depth, cut = 0, None - for i, s in enumerate(toks): - if s in ("(", "[", "{"): - depth += 1 - elif s in (")", "]", "}"): - depth = depth - 1 if depth else 0 - elif s == ";" and depth == 0: - cut = i - break - if cut is not None: - toks = toks[:cut] - break - line, col = line + chunk, 1 - budget -= chunk - else: - return # no statement terminator within the window - - # Keep only the initializer: tokens after the '=' that follows the declared - # name (default template arguments sit before the name and are ignored). - try: - name_i = toks.index(cursor.spelling) - except ValueError: - return - eq_i = None - for i in range(name_i + 1, len(toks)): - if toks[i] == "=": - eq_i = i - break - if eq_i is None: - return - toks = toks[eq_i + 1:] - - n = len(toks) - i = 0 - while i < n: - if _identifier(toks[i]) and i + 1 < n and toks[i + 1] == "::": - parts, k = [toks[i]], i + 1 - while k + 1 < n and toks[k] == "::" and _identifier(toks[k + 1]): - parts.append(toks[k + 1]) - k += 2 - yield "::".join(parts) - i = k - else: - i += 1 - - -def _namespace_matches_home(qn, home): - """Heuristic guard for namespace-level fallback matches: a namespace like - `boost::mp11` / `boost::typeindex` corresponds to its home library, while a - generic shared namespace (`boost::detail`, ...) may be attributed to any - library by its first declaration and must not produce an edge.""" - parts = qn.split("::") - if len(parts) < 2: - return False - seg = parts[1].replace("_", "").lower() - h = home.replace("_", "").lower() - return seg == h or seg.startswith(h) or h.startswith(seg) - - -def _initializer_lookup_qnames(chain, ns_chain): - """Candidate qualified names for an initializer name chain, most specific - first, each with its successive namespace prefixes appended (the textual - stand-in for C++ name lookup + the longest-prefix fallback A1 already used - for entities libclang does not index, e.g. alias templates). - - `boost::...` chains are looked up as-is. Relative chains are looked up in - the variable template's enclosing namespaces, innermost first, then under - `boost::` and finally at global scope.""" - if chain.startswith("boost::"): - bases = [chain] - else: - bases = [] - for k in range(len(ns_chain), -1, -1): - pref = "::".join(ns_chain[:k]) - bases.append(pref + "::" + chain if pref else chain) - for base in bases: - qn = base - while qn: - yield qn - if "::" not in qn: - break - qn = qn.rsplit("::", 1)[0] - - -def collect_body_edges(lib, records, claimed, usr_index, tu=None): - """Pass-2 collection: {home: set(usr)} — other target libraries whose - entities are referenced from the BODIES of this library's exported - entities (own + first-wins pulls, exactly the emit_inc export set). - - closure_from walks declarations only, so entities reachable solely - through bodies / base-specifier instantiations never enter the records - and their homes produce no dep edge (the C4 bimap → boost.iterator loss). - The include-graph extra_deps walk cannot recover them either: dep_graph() - stops at target-owned roots, so the edge is invisible whenever the - reference is reached through another target lib's headers (C4 §4.1). - - Emitted `export import mcpplibs.mwrap.boost.;` edges are also *sufficient*: the - home module always exports its own entities (emit_inc `own` has no - claimed filter), so pointing at the definition's home is sound even when - the entity was first-claimed elsewhere. - - Entities already pulled (unclaimed, hence exported here) are walked too: - their bodies' cross-home references are needed by consumers importing - only this module — except references resolving to an entity that is - itself on this module's face (own or pulled): those ride along with the - export and must not produce a redundant edge (keeps restored final-form - .cppm files, which hand-sync their import block, free of stray edges). - """ - edges = {} # home -> set(usr) - _seen_pairs = set() - - def add_edge(r, namespace_match=False): - """Record an edge to `r`'s home library; True when one was added. - - `namespace_match` is set by the textual var-template lookup: it may - fall back from `boost::mp11::mp_at_c` to the `boost::mp11` namespace - (alias templates et al. are not indexed), and the same fallback on a - shared namespace such as `boost::detail` would attribute an arbitrary - home lib. Namespace-REF body edges are unaffected (a referenced - namespace is a real reference).""" - t = _template_of_instantiation(r) - if t is not None: - r = t - r = _promote(r) - if not bc.qualified_name(r).startswith("boost::"): - return False - usr = bc.usr_of(r) - if not usr: - return False - # The entity may already ride on this module's own face: entities - # first-claimed HERE (own + unclaimed pulls) are exported by this - # module, so consumers reach them without an import edge. Only - # entities claimed elsewhere (or seen solely through bodies) need - # the edge. - rec = records.get(usr) - if rec is not None and (rec["home"] == lib or usr not in claimed): - return False - f = bc.cursor_file(r) - home = bc.home_lib_of_file(f, _FILE_TO_LIB) if f else "shared" + key = m.stable_key(r) + rec = records.get(key) + if rec is not None and (rec["home"] == lib or key not in claimed): + return # rides on this module's own face + home = home_of_file(_owner_file(m, r)) if home == lib or home == "shared" or home not in bc.TARGET_LIBS: - return False - if namespace_match and bc.kind_of(r) == ci.CursorKind.NAMESPACE and \ - not _namespace_matches_home(bc.qualified_name(r), home): - return False - if (usr, home) in _seen_pairs: - return False - _seen_pairs.add((usr, home)) - edges.setdefault(home, set()).add(usr) - return True - - def resolve(ref): - try: - r = ref.referenced - except Exception: return - if r is None: + if (key, home) in seen_pairs: return - add_edge(r) - - def walk(cursor): - stack = [cursor] - while stack: - cur = stack.pop() - if _kind_name(cur) in _REF_KIND_NAMES: - resolve(cur) - try: - stack.extend(cur.get_children()) - except Exception: - pass + seen_pairs.add((key, home)) + edges.setdefault(home, set()).add(key) + by_key = m.export_index() for rec in records.values(): if rec["home"] != lib and rec["usr"] in claimed: - continue # claimed elsewhere: not exported here - if rec["usr"].startswith("inject:"): - continue # using-injections carry no body - cur = usr_index.get(rec["usr"]) - if cur is None: + continue # claimed elsewhere: not exported here + d = by_key.get(rec["usr"]) + if d is None: continue - walk(cur) - try: - d = cur.get_definition() - except Exception: - d = None - if d is not None and d != cur: # out-of-line bodies, class defs - walk(d) - - # Variable templates: libclang exposes VarTemplateDecl as an opaque - # UNEXPOSED_DECL (no children, INVALID type, extent truncated after the - # name), so walk(cur) above sees nothing. Re-tokenize the declaration from - # its start, read off the qualified name chains in the initializer and - # resolve them textually: `boost::...` as-is (A1), relative names against - # the variable template's enclosing namespaces (A2). Same export set and - # filters as the body walk; add_edge reports success so the first useful - # lookup wins and enclosing-namespace false matches are skipped. - if tu is not None: - qname_cursors = None - for rec in records.values(): - if rec.get("kind") != VAR_TEMPLATE_KIND: - continue - if rec["home"] != lib and rec["usr"] in claimed: - continue # claimed elsewhere: not exported here - cur = usr_index.get(rec["usr"]) - if cur is None: - continue - ns_chain = bc.namespace_chain(cur) - for chain in _var_template_initializer_names(tu, cur): - if qname_cursors is None: - qname_cursors = _qname_cursor_index(usr_index) - for qn in _initializer_lookup_qnames(chain, ns_chain): - cur_list = qname_cursors.get(qn) - if cur_list and add_edge(cur_list[0], namespace_match=True): - break + walked = [d] + dd = m.definition(d) + if dd is not None and dd is not d: + walked.append(dd) + for w in walked: + if w.refs: + for rid in w.refs: + r = m.tu.resolve(rid) + if r is not None: + add_edge(r) + if w.written: + scopes = m.scope_names(w) + for text in w.written: + for name in names_in_type(text): + for r in m.lookup(name, scopes): + if r.kind in EXPORT_KINDS: + add_edge(r) return edges -def merge_body_edges(out_dir, order, body_edges): - """Union pass-2 candidate edges into generated/exports/.deps. - - Filters, in processing (topological) order: - - already a direct edge → skip; - - already transitive (home reachable through the current dep graph) → - skip (keeps the edge set minimal and avoids topo churn); - - would close a cycle → skip with a warning (mcpp rejects import - cycles; a genuinely cyclic consumer need cannot be fixed by edges). - - Returns {lib: {home: ref_count}} for the edges actually added. - """ +def merge_body_edges(out_dir, order, body_edges, policy): + """Union pass-2 candidate edges into generated/exports/.deps, in + topological order: direct, transitive and cycle-closing edges are + skipped (mcpp rejects import cycles).""" deps_dir = out_dir / "generated" / "exports" graph = {} for p in sorted(deps_dir.glob("*.deps")): @@ -1446,6 +1000,8 @@ def reachable(src, dst): for home in sorted(body_edges.get(lib, ())): if home == lib or home in graph.get(lib, ()): continue + if home in policy.deps(lib).get("remove", ()): + continue if reachable(lib, home): continue if reachable(home, lib): @@ -1465,337 +1021,800 @@ def reachable(src, dst): return added -def main() -> int: - global ci, _FILE_TO_LIB - ap = argparse.ArgumentParser(description=__doc__, - formatter_class=argparse.RawDescriptionHelpFormatter) - ap.add_argument("--scan", action="store_true", - help="regenerate generated/meta/libs.json from the heuristic and exit") - ap.add_argument("--libs", nargs="*", default=None, - help="subset of target libraries (default: all 27)") - ap.add_argument("--out", type=Path, default=bc.ROOT, - help="repo root (generated/exports written below it)") - ap.add_argument("--full-closure", action="store_true", - help="emit the complete closure per module (no cross-module dedup)") - ap.add_argument("--emit-cppm", action="store_true", - help="also draft src/.cppm (M3 owns final form)") - ap.add_argument("--no-body-deps", action="store_true", - help="disable the pass-2 body-reference .deps completion") - ap.add_argument("--no-cache", action="store_true", - help="disable the incremental-skip and gate caches " - "(full regeneration)") - args = ap.parse_args() +# --------------------------------------------------------------------------- +# output +# --------------------------------------------------------------------------- + +def _spell(qname, ns, namespaces): + """Qualified name as written inside `export namespace `: a leading + `::` is required when a namespace visible from the block shadows the first + segment (inside boost::hana::ext::std, `boost::x` finds + boost::hana::ext::boost).""" + if qname.startswith("::"): + return qname + first = qname.split("::", 1)[0] + for j in range(1, len(ns) + 1): + if "::".join(ns[:j]) + "::" + first in namespaces: + return "::" + qname + return qname + + +def emit_inc(lib, records, out_dir, claimed, policy, extra_deps=(), + namespaces=frozenset()): + """Write generated/exports/.inc (+ .deps). + + Cross-module dedup (first wins): entities claimed by an earlier module are + left out and their homes become `.deps` edges. One using-declaration per + qualified name (it brings every overload). Policy guards, drops, inline- + namespace collapses and verbatim lines are applied here, and every name + they touch is returned for generated/meta/skipped.txt. + + Returns (exported_count, deps, skipped_entries).""" + own = [r for r in records.values() if r["home"] == lib] + pulled = [r for r in records.values() + if r["home"] != lib and r["usr"] not in claimed] + deps = {r["home"] for r in records.values() + if r["home"] != lib and r["home"] != "shared" + and r["usr"] in claimed} | set(extra_deps) + dpol = policy.deps(lib) + deps |= set(dpol.get("add", ())) + deps -= set(dpol.get("remove", ())) + deps = sorted(deps) + + collapse = policy.inline_namespaces(lib) + drops = policy.drops(lib) + guards = policy.guards(lib) + skipped = [] + + exports, seen = [], set() + for rec in sorted(own + pulled, key=lambda r: r["qname"]): + q, ns = rec["qname"], list(rec["ns"]) + for inl in collapse: + if q.startswith(inl + "::"): + q = inl.rsplit("::", 1)[0] + q[len(inl):] + ns = inl.split("::")[:-1] + ns[len(inl.split("::")):] + if q in seen: + continue + seen.add(q) + rule = next((r for r in drops if _matches(q, r.get("names", ())) + or any(q.startswith(n + "::") + for n in r.get("namespaces", ()))), None) + if rule is not None: + skipped.append((lib, "drop", q, "", rule["reason"])) + continue + guard = next((g for g in guards if _matches(q, g["names"])), None) + if guard is not None: + skipped.append((lib, "guard", q, guard["if"], guard["reason"])) + exports.append((tuple(ns), q, guard)) + + groups = {} + for ns, q, guard in exports: + groups.setdefault(ns, []).append((q, guard)) + extras = {} + for x in policy.extras(lib): + extras.setdefault(tuple(x["namespace"].split("::")), []).append(x) + skipped.append((lib, "extra", x["namespace"], "", x["reason"])) + + lines = [ + "// GENERATED by tools/gen_exports.py - DO NOT EDIT", + "// lib={} boost={} target={} entities={}".format( + lib, bc.BOOST_VERSION, bc.GEN_TARGET, len(exports)), + "", + ] + for key in sorted(set(groups) | set(extras)): + lines.append("export " + " ".join( + "namespace {} {{".format(n) for n in key)) + for x in extras.get(key, ()): + lines += _comment(x["reason"]) + lines += [" " + ln for ln in x["lines"]] + open_guard = None + for q, guard in sorted(groups.get(key, ()), key=lambda e: e[0]): + if guard is not open_guard: + if open_guard is not None: + lines += _close_guard(open_guard) + if guard is not None: + lines.append("#if " + guard["if"]) + lines += _comment(guard["reason"]) + open_guard = guard + lines.append(" using {};".format(_spell(q, key, namespaces))) + if open_guard is not None: + lines += _close_guard(open_guard) + lines.append("}" * len(key)) + lines.append("") + + gen = out_dir / "generated" / "exports" + gen.mkdir(parents=True, exist_ok=True) + (gen / (lib + ".inc")).write_text("\n".join(lines), encoding="utf-8", + newline="\n") + dfile = gen / (lib + ".deps") + if deps: + dfile.write_text("\n".join(bc.MODULE_PREFIX + "." + d for d in deps) + + "\n", encoding="utf-8", newline="\n") + elif dfile.exists(): + dfile.unlink() + return len(exports), deps, skipped + + +def _comment(reason): + out = [] + for para in reason.strip().splitlines(): + out.append(" // " + para.strip() if para.strip() else " //") + return out + + +def _close_guard(guard): + out = [] + if guard.get("else"): + out.append("#else") + out += [" " + ln for ln in guard["else"]] + out.append("#endif") + return out + + +def emit_cppm(lib, out_dir, gfm_headers): + """Draft a facade for a library that has none yet (never overwrites).""" + path = out_dir / "src" / (lib + ".cppm") + if path.exists(): + return False + deps = out_dir / "generated" / "exports" / (lib + ".deps") + imports = [l.strip() for l in deps.read_text(encoding="utf-8").splitlines() + if l.strip()] if deps.exists() else [] + lines = ["// {}.{} — module facade".format(bc.MODULE_PREFIX, lib), + "module;"] + lines += ["#include <{}>".format(h.relative_to(bc.DEPS).as_posix()) + for h in gfm_headers] + lines += ["", "export module {}.{};".format(bc.MODULE_PREFIX, lib), ""] + if imports: + lines += ["export import {};".format(i) for i in imports] + [""] + lines += ['#include "../generated/exports/{}.inc"'.format(lib), ""] + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text("\n".join(lines), encoding="utf-8", newline="\n") + return True + + +_GMF_INCLUDE = re.compile(r'^\s*#\s*include\s*<(boost/[^>]+)>', re.MULTILINE) + + +_EXPORT_IMPORT = re.compile(r'^\s*export\s+import\s+([\w.]+)\s*;', re.MULTILINE) + + +def check_facade(lib, gfm_headers, extra_includes=(), deps=(), + omit_imports=()): + """Problems of src/.cppm against the generated data: its GMF must + include exactly the bundle's header set (the export list was computed + from it), plus the `facade-includes` the policy declares. Its `export + import` block must cover every .deps edge: the .inc leaves out what an + earlier module claimed, so an edge the facade does not re-export loses + those names for consumers. An edge the facade cannot take (range -> + regex: abi-tag mismatch under gcc) is declared in the policy's + [.facade] omit-imports with a reason.""" + path = bc.ROOT / "src" / (lib + ".cppm") + if not path.is_file(): + return ["src/{}.cppm is missing (run --emit-cppm)".format(lib)] + text = path.read_text(encoding="utf-8") + head, sep, body = text.partition("export module ") + if not sep: + return ["src/{}.cppm has no module declaration".format(lib)] + have = set(_GMF_INCLUDE.findall(head)) + want = {h.relative_to(bc.DEPS).as_posix() for h in gfm_headers} + problems = [] + for h in sorted(want - have): + problems.append("src/{}.cppm GMF lacks #include <{}>".format(lib, h)) + for h in sorted(have - want - set(extra_includes)): + problems.append("src/{}.cppm GMF includes <{}>, which the export " + "list was not generated from".format(lib, h)) + imported = set(_EXPORT_IMPORT.findall(body)) + omit = {bc.MODULE_PREFIX + "." + d for d in omit_imports} + for dep in sorted(set(deps) - imported - omit): + problems.append("src/{}.cppm lacks `export import {};` (a .deps edge; " + "declare it in [{}.facade] omit-imports if the facade " + "cannot take it)".format(lib, dep, lib)) + for dep in sorted(omit - set(deps)): + problems.append("[{}.facade] omit-imports lists {}, which is not a " + ".deps edge".format(lib, dep)) + for dep in sorted(omit & imported): + problems.append("[{}.facade] omit-imports lists {}, but src/{}.cppm " + "imports it".format(lib, dep, lib)) + return problems + + +def write_meta(out_dir, summary, skipped): + """generated/meta/api-surface.json + skipped.txt (sorted, no paths, no + timestamps — byte-stable for --check).""" + meta = out_dir / "generated" / "meta" + meta.mkdir(parents=True, exist_ok=True) + surface = { + "boost": bc.BOOST_VERSION, + "generator": { + "tool": "tools/gen_exports.py", + "ast": "clang++ -ast-dump=json", + "clang": aj.clang_release(), + "target": bc.GEN_TARGET, + "defines": bc.GEN_DEFINES, + }, + "libraries": {lib: summary[lib] for lib in sorted(summary)}, + } + (meta / "api-surface.json").write_text( + json.dumps(surface, indent=1, sort_keys=True) + "\n", + encoding="utf-8", newline="\n") + lines = [ + "# Names the export policy (tools/export_policy.toml) guards, drops or", + "# adds verbatim. GENERATED by tools/gen_exports.py - DO NOT EDIT", + "# [if ] -- ", + "", + ] + for lib, action, name, cond, reason in sorted(set(skipped)): + cond = " ".join(cond.split()) + lines.append("{} {} {}{} -- {}".format( + lib, action, name, " if " + cond if cond else "", + " ".join(reason.split()))) + (meta / "skipped.txt").write_text("\n".join(lines) + "\n", + encoding="utf-8", newline="\n") + + +# --------------------------------------------------------------------------- +# bundle TU: compile, prune, cache +# --------------------------------------------------------------------------- + +def _bundle_text(gfm): + return "".join("#include <{}>\n".format(h.relative_to(bc.DEPS).as_posix()) + for h in gfm) - if args.scan: - db = bc.scan_libs_json() - bc.LIBS_JSON.write_text(json.dumps(db, indent=1, sort_keys=True) + "\n", - encoding="utf-8", newline="\n") - total = sum(len(v) for v in db.values()) - print("wrote {} with {} headers across {} libraries" - .format(bc.LIBS_JSON, total, len(db))) - return 0 - ci = bc.get_ci() - print("AST parser: {} ({})".format( - bc.libclang_version(), ci.conf.get_filename()), flush=True) +def _code_hash(): + h = hashlib.sha256() + for name in ("gen_exports.py", "boost_common.py", "ast_json.py"): + h.update((bc.TOOLS / name).read_bytes()) + return h.hexdigest() + + +_FILE_HASH = {} + + +def _file_hash(path): + h = _FILE_HASH.get(path) + if h is None: + try: + h = hashlib.sha256(path.read_bytes()).hexdigest() + except OSError: + h = "missing" + _FILE_HASH[path] = h + return h + + +def _closure_hash(gfm): + """Content hash over every boost header transitively reachable from the + include set (any header edit invalidates the caches).""" + h = hashlib.sha256() + seen = set() + stack = list(gfm) + while stack: + f = stack.pop() + key = str(f) + if key in seen: + continue + seen.add(key) + try: + rel = f.relative_to(bc.DEPS).as_posix() + except ValueError: + rel = f.as_posix() + h.update("{} {}\n".format(rel, _file_hash(f)).encode()) + try: + text = f.read_text(encoding="utf-8", errors="ignore") + except OSError: + continue + for mt in bc._INC_RE.finditer(text): + p = bc.DEPS / mt.group(1) + if str(p) not in seen and p.is_file(): + stack.append(p) + return h.hexdigest() + + +def _input_manifest(tu, cwd): + """{file: content hash} of every file clang read for the TU (its + depfile), keyed relative to the repository when inside it. The bundle + itself is left out: its text is part of the cache keys.""" + out = {} + root = os.path.normcase(os.path.normpath(str(bc.ROOT))) + bundles = Path(os.path.normpath(str(bc.CACHE_DIR / "bundles"))) + for raw in tu.inputs: + f = Path(os.path.normpath(os.path.join(str(cwd), raw))) + if f.parent == bundles: + continue + if os.path.normcase(str(f)).startswith(root + os.sep): + key = f.relative_to(bc.ROOT).as_posix() + else: + key = f.as_posix() + out[key] = _file_hash(f) + return out + + +def _manifest_ok(manifest): + """The files an entry was computed from still have the recorded content. + This covers what the include-closure walk cannot see (relative and + macro-computed includes, the sysroot); an entry without one is stale.""" + if not manifest: + return False + for key, h in manifest.items(): + f = Path(key) + if not f.is_absolute(): + f = bc.ROOT / key + if _file_hash(f) != h: + return False + return True + + +class _ClaimView: + """A claim table seen through one library's processing: records the + owner (None = unclaimed) of every name it probes or claims, as it was + before the library touched it. A cache entry is valid only while those + observations still hold (first-wins ownership depends on every library + processed earlier, not only on include-graph upstreams).""" + + def __init__(self, table): + self.table = table + self.seen = {} + + def _see(self, k): + if k not in self.seen: + self.seen[k] = self.table.get(k) + + def __contains__(self, k): + self._see(k) + return k in self.table + + def __setitem__(self, k, v): + self._see(k) + self.table[k] = v + + def setdefault(self, k, v): + self._see(k) + return self.table.setdefault(k, v) + + +def _claims_hold(sk, claimed, claimed_inject): + """The ownership an entry was computed under still holds: the same + closure members are already claimed, and every probed injection name has + the same owner.""" + pre = sk.get("pre_claimed") + view = sk.get("inject_view") + if pre is None or view is None: + return False + probes = {u for u, _ in sk["claims"]} + if {u for u in probes if u in claimed} != set(pre): + return False + return all(claimed_inject.get(k) == o for k, o in view) + + +def _load_json(path): + try: + return json.loads(path.read_text(encoding="utf-8")) + except (OSError, ValueError): + return None + + +def _bundle_args(lib, policy): + return [*bc.CLANG_ARGS, *("-D" + d for d in policy.defines(lib))] + + +def gate_key(lib, headers, policy): + """Cache key of the compile gate for an include set: bundle text, + header-closure hash, the driver line (with the policy's defines) and the + compiler version. gen_audit.py keys its results on it too.""" + gh = hashlib.sha256() + gh.update(_bundle_text(headers).encode()) + gh.update(_closure_hash(headers).encode()) + gh.update(" ".join(aj.clang_command(*_bundle_args(lib, policy))).encode()) + gh.update(aj.clang_version().encode()) + return gh.hexdigest() + + +def parse_bundle(lib, headers, policy, use_cache=True): + """Compile the bundle TU once per attempt; the compile is the gate. + + A failing compile names the GMF headers that cannot be included directly + on this platform (both boost/thread/pthread and win32 define heap_new; + the aggregate selects one): those are pruned and the bundle recompiled, + up to six rounds. The pruned include set is cached by bundle content, + header-closure hash, flags and compiler version. Returns (TU, gfm) or + None when the include set cannot be made to compile.""" + bundle = (bc.CACHE_DIR / "bundles" / (lib + ".cpp")).resolve() + bundle.parent.mkdir(parents=True, exist_ok=True) + gfm = list(headers) + args = _bundle_args(lib, policy) + gkey = gate_key(lib, gfm, policy) + gate_cache = bc.CACHE_DIR / (lib + ".gate.json") + cached = _load_json(gate_cache) if use_cache else None + if cached is not None and cached.get("key") == gkey \ + and _manifest_ok(cached.get("inputs")): + gfm = [bc.DEPS / rel for rel in cached["gfm"]] + + for attempt in range(7): + bundle.write_text(_bundle_text(gfm), encoding="utf-8", newline="\n") + try: + tu = aj.dump(bundle, args, cwd=str(bc.ROOT)) + break + except aj.DumpError as e: + stderr = e.stderr + offenders = set() + for line in stderr.splitlines(): + head = re.split(r":\d+(?::\d+)?:", line, maxsplit=1)[0] + head = head.strip().replace("\\", "/") + if not head.endswith(".hpp"): + continue + for h in gfm: + if head.endswith(h.relative_to(bc.DEPS).as_posix()): + offenders.add(h) + if not offenders or attempt == 6: + print(" clang++ FAILED for {}:".format(lib)) + for line in stderr.splitlines()[:8]: + print(" {}".format(line.strip())) + return None + for h in sorted(offenders, key=lambda p: p.as_posix()): + print(" gate pruned from GMF: {}".format( + h.relative_to(bc.DEPS).as_posix())) + gfm.remove(h) + if use_cache: + bc.CACHE_DIR.mkdir(parents=True, exist_ok=True) + gate_cache.write_text(json.dumps( + {"key": gkey, + "gfm": [h.relative_to(bc.DEPS).as_posix() for h in gfm], + "inputs": _input_manifest(tu, bc.ROOT)}), + encoding="utf-8") + return tu, gfm + + +# --------------------------------------------------------------------------- +# driver +# --------------------------------------------------------------------------- + +GENERATED = ("generated/exports", "generated/meta/api-surface.json", + "generated/meta/skipped.txt") + + +def _skip_key(lib, gfm, upstream_keys, no_body_deps, policy): + h = hashlib.sha256() + h.update(b"code:" + _code_hash().encode()) + h.update(b"bundle:" + _bundle_text(gfm).encode()) + h.update(b"closure:" + _closure_hash(gfm).encode()) + # The driver line, as the gate key hashes it: CXX and + # CLANG_NO_DEFAULT_CONFIG change what clang parses. + h.update(b"clang_args:" + + " ".join(aj.clang_command(*bc.CLANG_ARGS)).encode()) + h.update(b"clang:" + aj.clang_version().encode()) + h.update(b"policy:" + policy.digest(lib).encode()) + h.update(b"no_body_deps:" + str(no_body_deps).encode()) + for u in sorted(upstream_keys): + h.update("up:{}:{}\n".format(u, upstream_keys[u]).encode()) + return h.hexdigest() + + +def generate(args, out): + """Run the generation into `out` (a repo root). Returns (rc, facade + problems).""" + global _FILE_TO_LIB + policy = Policy.load() + print("AST: {} (target {})".format(aj.clang_version(), bc.GEN_TARGET), + flush=True) _FILE_TO_LIB = bc.build_file_to_lib() - libs = args.libs or bc.TARGET_LIBS + libs = list(args.libs) if args.libs else list(bc.TARGET_LIBS) for lib in libs: if lib not in bc.TARGET_LIBS: print("error: unknown library '{}'".format(lib), file=sys.stderr) - return 1 - + return 1, [] use_cache = not args.no_cache graph = bc.dep_graph() order = bc.topo_order(graph) print("processing order: {}".format(" -> ".join(order))) - # Incremental-skip keys, computed dependencies-first (topo order) so each - # lib's key can fold in its upstream keys. A lib in an include cycle - # (unkeyable upstream) is never cacheable — conservative. - libs = list(args.libs) if args.libs else list(bc.TARGET_LIBS) - gfm_memo = {} - lib_keys = {} + gfm_memo, lib_keys = {}, {} for lib in order: + if lib in bc.LIBS_SPECIAL: + continue uk = {} for u in sorted(graph.get(lib, ())): + if u in bc.LIBS_SPECIAL: + continue ku = lib_keys.get(u) if ku is None: uk = None break uk[u] = ku - if uk is None: - lib_keys[lib] = None - continue - gfm_memo[lib] = bc.gfm_headers_of(lib) - lib_keys[lib] = _skip_key(lib, gfm_memo[lib], uk, libs, - args.full_closure, args.no_body_deps) - - claimed = {} - claimed_inject = {} - summary = {} - body_all = {} # lib -> {home: set(usr)} pass-2 candidates - gfm_by_lib = {} # lib -> gate-pruned GFM (for post-merge emit_cppm) - cache_payloads = {} # lib -> skip.json payload (written after pass 2) + g = policy.gmf(lib) + gfm_memo[lib] = [bc.DEPS / h for h in g] if g else bc.gfm_headers_of(lib) + lib_keys[lib] = None if uk is None else _skip_key( + lib, gfm_memo[lib], uk, args.no_body_deps, policy) + + old_surface = _load_json(out / "generated" / "meta" / "api-surface.json") + old_libs = (old_surface or {}).get("libraries", {}) + old_skipped = _read_skipped(out / "generated" / "meta" / "skipped.txt") + + claimed, claimed_inject = {}, {} + summary, skipped, body_all, gfm_by_lib, deps_by_lib = {}, [], {}, {}, {} + cache_payloads = {} for lib in order: - if lib not in libs: - continue if lib in bc.LIBS_SPECIAL: - # hand-maintained module (boost.version): no bundle, no .inc, no - # .cppm draft — regenerating would clobber src/version.cppm and - # emit an unused exports/version.inc. continue key = lib_keys[lib] sk = _load_json(bc.CACHE_DIR / (lib + ".skip.json")) \ if use_cache and key else None - if sk is not None and sk.get("key") == key and \ - _artifacts_ok(args.out, lib, sk): - # Cache hit: replay this lib's claims so downstream misses see the - # same first-wins state a full run would produce. - for usr, owner in sk.get("claims", []): + hit = sk is not None and sk.get("key") == key \ + and _manifest_ok(sk.get("inputs")) \ + and _claims_hold(sk, claimed, claimed_inject) + if lib not in libs: + # Not regenerated: its committed output stays, but its claims + # shape first-wins ownership downstream, so replay them. + if lib in old_libs: + summary[lib] = old_libs[lib] + skipped += [e for e in old_skipped if e[0] == lib] + if hit: + for usr, owner in sk["claims"]: + claimed.setdefault(usr, owner) + for q, owner in sk["inject_claims"]: + claimed_inject.setdefault(q, owner) + else: + print("warning: no current cache for {}; a --libs run " + "may claim differently from a full run".format(lib)) + continue + if hit and (out / "generated" / "exports" / (lib + ".inc")).exists(): + for usr, owner in sk["claims"]: claimed.setdefault(usr, owner) - for q, owner in sk.get("inject_claims", []): + for q, owner in sk["inject_claims"]: claimed_inject.setdefault(q, owner) gfm_by_lib[lib] = [bc.DEPS / rel for rel in sk["gfm"]] summary[lib] = sk["summary"] + deps_by_lib[lib] = sk["summary"]["deps"] + skipped += [tuple(e) for e in sk["skipped"]] + gen = out / "generated" / "exports" + (gen / (lib + ".inc")).write_text(sk["inc"], encoding="utf-8", + newline="\n") + dfile = gen / (lib + ".deps") + if sk["deps_text"]: + dfile.write_text(sk["deps_text"], encoding="utf-8", + newline="\n") + elif dfile.exists(): + dfile.unlink() + if sk["body"]: + body_all[lib] = {h: set(v) for h, v in sk["body"].items()} print("skipped {} (cache hit, exported={})".format( - lib, sk["summary"].get("exported")), flush=True) + lib, sk["summary"]["exported"]), flush=True) continue t0 = time.time() - headers = bc.headers_of(lib) - gfm_headers = gfm_memo.get(lib) - if gfm_headers is None: - gfm_headers = gfm_memo[lib] = bc.gfm_headers_of(lib) - print("parsing {} ({} headers, {} in GFM)...".format( - lib, len(headers), len(gfm_headers)), flush=True) - parsed = _parse_bundle(lib, gfm_headers, use_cache) + print("parsing {} ({} headers in GMF)...".format( + lib, len(gfm_memo[lib])), flush=True) + parsed = parse_bundle(lib, gfm_memo[lib], policy, use_cache) if parsed is None: print("error: parse failed for {}".format(lib), file=sys.stderr) - return 1 + return 1, [] tu, gfm_final = parsed - usr_index = build_usr_index(tu) - cands = collect_candidates(lib, tu, _FILE_TO_LIB, usr_index) - injects = collect_injections(tu, lib, _FILE_TO_LIB, claimed_inject, - usr_index) - curated = collect_curated(lib, claimed_inject, usr_index, tu) - records = closure_from(dict(cands, **injects, **curated), tu, usr_index) - if args.full_closure: - claimed.clear() - claimed_inject.clear() - exports, deps = emit_inc(lib, records, args.out, args.full_closure, - claimed, extra_deps=bc.dep_graph( - {lib: gfm_final})[lib]) - # Pass 2 collection: bodies of exactly the emit_inc export set - # (own + unclaimed pulls) — must run while `claimed` still holds the - # pre-emit state emit_inc saw. - body_deps = {} if (args.full_closure or args.no_body_deps) else \ - collect_body_edges(lib, records, claimed, usr_index, tu) - if body_deps: - body_all[lib] = body_deps + m = Model(tu) + cands = collect_candidates(lib, m) + inject_view = _ClaimView(claimed_inject) + injects = collect_injections(lib, m, inject_view) + added = collect_added(lib, m, policy, inject_view) + records = closure_from(m, dict(cands, **injects, **added)) + pre_claimed = sorted({r["usr"] for r in records.values() + if r["usr"] in claimed}) + exports, deps, sk_entries = emit_inc( + lib, records, out, claimed, policy, + extra_deps=bc.lib_deps(lib, gfm_final), + namespaces=m.namespaces()) + body = {} if args.no_body_deps else \ + collect_body_edges(lib, m, records, claimed) + if body: + body_all[lib] = body gfm_by_lib[lib] = gfm_final + deps_by_lib[lib] = deps for rec in records.values(): claimed.setdefault(rec["usr"], lib) - summary[lib] = {"candidates": len(cands), - "closure": len(records), - "exported": exports, - "deps": sorted(deps), - "var_templates": sorted( - r["qname"] for r in records.values() - if r.get("kind") == VAR_TEMPLATE_KIND)} - if body_deps: - summary[lib]["body_deps"] = {h: sorted(v) - for h, v in body_deps.items()} + summary[lib] = { + "gmf": [h.relative_to(bc.DEPS).as_posix() for h in gfm_final], + "exported": exports, + "deps": deps, + } + skipped += sk_entries print(" candidates={} closure={} exported={} deps={} body-deps={} " - "({:.1f}s)".format( - len(cands), len(records), exports, sorted(deps) or "-", - ", ".join(sorted(body_deps)) or "-", time.time() - t0), - flush=True) + "({:.1f}s)".format(len(cands), len(records), exports, + deps or "-", ", ".join(sorted(body)) or "-", + time.time() - t0), flush=True) if use_cache and key: + gen = out / "generated" / "exports" + dfile = gen / (lib + ".deps") cache_payloads[lib] = { "key": key, - "gfm": [h.relative_to(bc.DEPS).as_posix() - for h in gfm_final], - "summary": summary[lib], - # First-wins claims contributed by this lib (replayed with - # setdefault in topo order on a cache hit). - "claims": [[rec["usr"], lib] for rec in records.values()], - "inject_claims": [[q, owner] - for q, owner in claimed_inject.items() - if owner == lib], + "gfm": summary[lib]["gmf"], + "summary": dict(summary[lib]), + "skipped": sk_entries, + "inc": (gen / (lib + ".inc")).read_text(encoding="utf-8"), + "deps_text": dfile.read_text(encoding="utf-8") + if dfile.exists() else "", + "body": {h: sorted(v) for h, v in body.items()}, + "claims": [[r["usr"], lib] for r in records.values()], + "inject_claims": [[q, o] for q, o in claimed_inject.items() + if o == lib], + "pre_claimed": pre_claimed, + "inject_view": sorted([k, o] for k, o in + inject_view.seen.items()), + "inputs": _input_manifest(tu, bc.ROOT), } + del m, tu - if not (args.full_closure or args.no_body_deps): + added = {} + if not args.no_body_deps: print("pass 2: body-reference .deps completion...") - added = merge_body_edges(args.out, order, body_all) + added = merge_body_edges(out, order, body_all, policy) if not added: print(" no edges to add") - else: - added = {} - + for lib, homes in added.items(): + if lib in summary: + summary[lib]["deps"] = sorted(set(summary[lib]["deps"]) | + set(homes)) + deps_by_lib[lib] = summary[lib]["deps"] + + # The cache holds each library's pass-1 output and its pass-2 candidate + # edges; pass 2 is re-run from them on every run, so its additions never + # invalidate an entry. if use_cache and cache_payloads: bc.CACHE_DIR.mkdir(parents=True, exist_ok=True) - if added: - # pass-2 rewrote .deps files — every cached key is stale; drop the - # skip cache so the next run regenerates (gate cache stays valid). - n = 0 - for p in bc.CACHE_DIR.glob("*.skip.json"): - p.unlink() - n += 1 - if n: - print(" pass-2 added edges: cleared {} skip-cache entries" - .format(n)) - else: - for lib, payload in cache_payloads.items(): - payload["deps_present"] = (args.out / "generated" / "exports" / - (lib + ".deps")).exists() - (bc.CACHE_DIR / (lib + ".skip.json")).write_text( - json.dumps(payload, sort_keys=True) + "\n", - encoding="utf-8") - - # .cppm drafts are emitted after the pass-2 merge so their export-import - # block reflects the completed .deps (emit_cppm reads the .deps file). + for lib, payload in cache_payloads.items(): + (bc.CACHE_DIR / (lib + ".skip.json")).write_text( + json.dumps(payload, sort_keys=True) + "\n", encoding="utf-8") + + # Hand-written modules (version, macros) have no bundle; their import + # edges are declared in the policy so generated/ holds generated files only. + for lib in bc.LIBS_SPECIAL: + if args.libs and lib not in args.libs: + continue + add = sorted(policy.deps(lib).get("add", ())) + dfile = out / "generated" / "exports" / (lib + ".deps") + if add: + dfile.parent.mkdir(parents=True, exist_ok=True) + dfile.write_text("".join(bc.MODULE_PREFIX + "." + d + "\n" + for d in add), encoding="utf-8", + newline="\n") + elif dfile.exists(): + dfile.unlink() + + write_meta(out, summary, skipped) + if args.emit_cppm: for lib in order: - if lib in gfm_by_lib: - emit_cppm(lib, args.out, gfm_by_lib[lib]) - - out = args.out / "target" / "gen" / "gen_report.json" - out.parent.mkdir(parents=True, exist_ok=True) - out.write_text(json.dumps(summary, indent=1, sort_keys=True) + "\n", - encoding="utf-8") - print("report -> {} ({} pass-2 edges added across {} libs)".format( - out, sum(len(v) for v in added.values()), len(added))) - return 0 + if lib in gfm_by_lib and emit_cppm(lib, out, gfm_by_lib[lib]): + print("drafted src/{}.cppm".format(lib)) + problems = [] + for lib in order: + if lib in gfm_by_lib: + dfile = out / "generated" / "exports" / (lib + ".deps") + deps = dfile.read_text(encoding="utf-8").split() \ + if dfile.exists() else [] + problems += check_facade(lib, gfm_by_lib[lib], + policy.facade_includes(lib), deps, + policy.facade_omit_imports(lib)) + report = bc.ROOT / "target" / "gen" / "gen_report.json" + report.parent.mkdir(parents=True, exist_ok=True) + report.write_text(json.dumps(summary, indent=1, sort_keys=True) + "\n", + encoding="utf-8") + return 0, problems + + +def _read_skipped(path): + """Committed skipped.txt entries (kept for libraries not regenerated).""" + out = [] + if not path.is_file(): + return out + for line in path.read_text(encoding="utf-8").splitlines(): + if not line or line.startswith("#"): + continue + head, _, reason = line.partition(" -- ") + parts = head.split(" ", 3) + if len(parts) < 3: + continue + lib, action, name = parts[:3] + cond = "" + if len(parts) == 4 and parts[3].startswith("if "): + cond = parts[3][3:] + out.append((lib, action, name, cond, reason)) + return out -def _parse_bundle(lib, headers, use_cache=True): - """One TU including the GFM headers (like the future .cppm GMF), gated by - the real clang++ driver. - The bundle TU lives in target/gen/exports-cache/bundles/ (gitignored). +def _snapshot(root): + """{relative path: bytes} of every generated file below `root`.""" + files = {} + for rel in GENERATED: + p = root / rel + if p.is_dir(): + for f in sorted(p.iterdir()): + if f.is_file(): + files[f.relative_to(root).as_posix()] = f.read_bytes() + elif p.is_file(): + files[rel] = p.read_bytes() + return files + + +def check(args): + """Regenerate into a scratch copy and compare byte for byte; the + repository is never written.""" + with tempfile.TemporaryDirectory(prefix="gen-exports-check-") as tmp: + tmp = Path(tmp) + for rel in GENERATED: + src = bc.ROOT / rel + if src.is_dir(): + shutil.copytree(src, tmp / rel) + elif src.is_file(): + (tmp / rel).parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(src, tmp / rel) + rc, problems = generate(args, tmp) + if rc: + return rc + want = _snapshot(tmp) + have = _snapshot(bc.ROOT) + stale = sorted(p for p in set(want) | set(have) + if want.get(p) != have.get(p)) + for p in stale: + if p not in want: + print("stale: {} (the generator no longer writes it)".format(p)) + continue + if p not in have: + print("missing: {}".format(p)) + continue + diff = difflib.unified_diff( + have[p].decode("utf-8", "replace").splitlines(), + want[p].decode("utf-8", "replace").splitlines(), + "a/" + p, "b/" + p, lineterm="", n=1) + out = list(diff) + print("\n".join(out[:40])) + if len(out) > 40: + print("... ({} more diff lines)".format(len(out) - 40)) + for line in problems: + print("facade: " + line) + if stale or problems: + print("\ngen_exports --check: {} generated file(s) differ, {} facade " + "problem(s); run tools/gen_exports.py and review the diff" + .format(len(stale), len(problems)), file=sys.stderr) + return 1 + print("gen_exports --check: generated exports are up to date") + return 0 - The clang++ gate is cached: its verdict is keyed on the initial bundle - content + gate command line + clang version, so an unchanged bundle skips - the (up to 6-round) syntax-check loop entirely and replays the pruned GFM - set. The libclang parse itself always runs (the AST is not cached). - libclang's missing-include reporting is unreliable once an include chain - gets long (verified: a fatal 'file not found' surfaced for a bare header - but not when the same header was reached after many others), so the bundle - is additionally syntax-checked with clang++ — the same engine the module - build uses. Gate failures identify source headers that must not be - included directly on this platform (e.g. both boost/thread/pthread and - win32/thread_heap_alloc.hpp define heap_new; the aggregate selects one via - a computed include): those files are pruned from the GFM set and the - bundle re-checked. Returns None when the include set cannot be made to - compile, else the TU for the final (pruned) include set. - """ - import subprocess - _ci = bc.get_ci() - idx = _ci.Index.create() - bundle = (bc.CACHE_DIR / "bundles" / (lib + ".cpp")).resolve() - bundle.parent.mkdir(parents=True, exist_ok=True) - gfm = list(headers) - if lib in GMF_OVERRIDE: - gfm = [bc.DEPS / h for h in GMF_OVERRIDE[lib]] - - def write_bundle(): - bundle.write_text(_bundle_text(gfm), encoding="utf-8") - - extra = ["-D" + d for d in EXTRA_DEFINES.get(lib, ())] - # The gate must use the same macro set as the libclang parse below - # (bc.CLANG_ARGS + extra): a divergence makes the gate's prune verdict - # disagree with the AST snapshot. In particular, dropping - # _WIN32_WINNT/WIN32_LEAN_AND_MEAN used to make the gate mis-prune - # boost/atomic.hpp under the pinned MinGW sysroot. - gate_args = ["-fsyntax-only", *bc.CLANG_ARGS, *extra] - - def gate(): - r = subprocess.run(_clang_command(*gate_args, str(bundle)), - capture_output=True, text=True, cwd=str(bc.ROOT)) - return r - - # Gate cache: verdict keyed on the INITIAL bundle text (the pruning - # outcome is deterministic), the gate command line and the clang version. - gh = hashlib.sha256() - gh.update(b"bundle:" + _bundle_text(gfm).encode()) - gh.update(b"closure:" + _closure_hash(lib, gfm).encode()) - gh.update(b"extra:" + ",".join(extra).encode()) - gh.update(("gate:clang++ " + " ".join(gate_args)).encode()) - gh.update(b"clang-command:" + " ".join(_clang_command()).encode()) - gh.update(b"clang:" + _clang_version().encode()) - gkey = gh.hexdigest() - gate_cache = bc.CACHE_DIR / (lib + ".gate.json") - cached_gate = _load_json(gate_cache) if use_cache else None - if cached_gate is not None and cached_gate.get("key") == gkey: - if not cached_gate.get("ok"): - print(" clang++ gate FAILED for {} (cached):".format(lib)) - for line in cached_gate.get("stderr", [])[:8]: - print(" {}".format(line.strip())) - return None - gfm = [bc.DEPS / rel for rel in cached_gate["gfm"]] - write_bundle() - else: - cached_gate = None - for attempt in range(6): - write_bundle() - r = gate() - if r.returncode == 0: - break - offenders = set() - for line in r.stderr.splitlines(): - # Split at the diagnostic's line/column suffix, not the drive - # letter in Windows paths. Include-stack entries identify the - # GMF root when the actual failure is in a transitive header. - head = re.split(r":\d+(?::\d+)?:", line, maxsplit=1)[0] - head = head.strip().replace("\\", "/") - if not head.endswith(".hpp"): - continue - for h in gfm: - if h.relative_to(bc.DEPS).as_posix() in head: - offenders.add(h) - if not offenders: - print(" clang++ gate FAILED for {}:".format(lib)) - for line in r.stderr.splitlines()[:8]: - print(" {}".format(line.strip())) - if use_cache: - bc.CACHE_DIR.mkdir(parents=True, exist_ok=True) - gate_cache.write_text(json.dumps( - {"key": gkey, "ok": False, - "stderr": r.stderr.splitlines()[:8]}), - encoding="utf-8") - return None - for h in sorted(offenders, key=lambda p: p.as_posix()): - print(" gate pruned from GFM: {}".format( - h.relative_to(bc.DEPS).as_posix())) - gfm.remove(h) - else: - print(" clang++ gate FAILED for {} (still failing after pruning):".format(lib)) - for line in r.stderr.splitlines()[:8]: - print(" {}".format(line.strip())) - if use_cache: - bc.CACHE_DIR.mkdir(parents=True, exist_ok=True) - gate_cache.write_text(json.dumps( - {"key": gkey, "ok": False, - "stderr": r.stderr.splitlines()[:8]}), - encoding="utf-8") - return None - if use_cache: - bc.CACHE_DIR.mkdir(parents=True, exist_ok=True) - gate_cache.write_text(json.dumps( - {"key": gkey, "ok": True, - "gfm": [h.relative_to(bc.DEPS).as_posix() for h in gfm]}), - encoding="utf-8") - - tu = idx.parse(str(bundle), args=bc.CLANG_ARGS + extra, - options=_ci.TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD) - errs = [d for d in tu.diagnostics if d.severity >= _ci.Diagnostic.Error] - if errs: - print(" libclang: {} errors (non-fatal)".format(len(errs))) - for d in errs[:6]: - print(" {}: {}".format(d.location, d.spelling)) - return tu, gfm +def main() -> int: + ap = argparse.ArgumentParser(description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("--scan", action="store_true", + help="regenerate generated/meta/libs.json and exit") + ap.add_argument("--libs", nargs="*", default=None, + help="subset of target libraries (default: all)") + ap.add_argument("--check", action="store_true", + help="compare the committed output byte for byte with a " + "fresh generation; write nothing") + ap.add_argument("--emit-cppm", action="store_true", + help="draft src/.cppm for libraries without a facade") + ap.add_argument("--no-body-deps", action="store_true", + help="disable the pass-2 body-reference .deps completion") + ap.add_argument("--no-cache", action="store_true", + help="ignore and do not write the generator caches") + args = ap.parse_args() + + if args.scan: + db = bc.scan_libs_json() + bc.LIBS_JSON.write_text(json.dumps(db, indent=1, sort_keys=True) + "\n", + encoding="utf-8", newline="\n") + print("wrote {} ({} headers, {} libraries)".format( + bc.LIBS_JSON, sum(len(v) for v in db.values()), len(db))) + return 0 + if args.check: + if args.emit_cppm: + ap.error("--check writes nothing; drop --emit-cppm") + return check(args) + rc, problems = generate(args, bc.ROOT) + for line in problems: + print("facade: " + line) + if problems: + print("error: {} facade problem(s)".format(len(problems)), + file=sys.stderr) + return 1 + return rc if __name__ == "__main__": diff --git a/tools/gen_features.py b/tools/gen_features.py index 2fcbdc3b5..32fb187ac 100644 --- a/tools/gen_features.py +++ b/tools/gen_features.py @@ -57,7 +57,7 @@ MODULES_LST = ROOT / "generated" / "meta" / "modules.lst" # The full module-library list — derived from boost_common.TARGET_LIBS (which -# knows the tier tables). boost_common has no hard dependency on libclang at +# knows the tier tables). boost_common needs no compiler at # import time, so plain `uv run tools/gen_features.py` works. The compiled # include-only libs (log, test — C1) are re-inserted at their former T2 slots # so the generated feature block stays diff-stable. diff --git a/tools/pyproject.toml b/tools/pyproject.toml index 9c863e9f7..a7a775848 100644 --- a/tools/pyproject.toml +++ b/tools/pyproject.toml @@ -2,10 +2,10 @@ name = "boost-m-tools" version = "0.1.0" description = "Tooling for generating and auditing the Boost mwrap package sources" -requires-python = ">=3.9" -dependencies = [ - "libclang", -] +# tomllib (export policy, mcpp.toml) is in the standard library from 3.11. +# The generators need no third-party packages: the AST comes from clang++. +requires-python = ">=3.11" +dependencies = [] [tool.uv] package = false diff --git a/tools/reapply_hand_edits.py b/tools/reapply_hand_edits.py deleted file mode 100644 index 9fa6a7c8d..000000000 --- a/tools/reapply_hand_edits.py +++ /dev/null @@ -1,564 +0,0 @@ -#!/usr/bin/env python3 -"""Re-apply hand edits that tools/gen_exports.py --emit-cppm overwrites. - -Run after ANY full regeneration: - - python3 tools/import_boost.py --tarball - python3 tools/reapply_hand_edits.py # vendored adaptations first - python3 tools/gen_exports.py --libs ... --emit-cppm - python3 tools/reapply_hand_edits.py # module-side adaptations - -Nothing here reads Git history: a checkout, a source archive and a bare -worktree with the committed files reproduce the same bytes. Three kinds of -hand edit exist: - - * `patches/*.patch` — unified diffs against the regenerated file, applied - with `git apply` (or `patch -p1` where Git is unavailable) and idempotent: - a patch already contained in the file is skipped by the reverse check. A - missing anchor is an error unless the patch is listed in TOLERANT, which - needs a written reason there. - * `patches/final/` — the hand-maintained final form of files whose - content intentionally diverges from anything the generator writes (the M3 - "final form" interfaces and their export lists). The stored bytes are the - input; no history is consulted, and an unchanged file keeps its mtime. - * the programmatic .inc platform guards and the vendored file addition - below, whose anchors depend on regenerated content. - -Replacing a `patches/final/` entry is a deliberate interface change: -edit the file in place, then copy it over the stored final form. Regenerating -a patch file: apply the hand edit to the freshly regenerated file, diff it -against the regenerated state, and save that diff as patches/.patch. -Hunks for several files of one module go into the same .patch. -""" - -import subprocess -import sys -from pathlib import Path - -ROOT = Path(__file__).resolve().parent.parent -PATCH_DIR = ROOT / "patches" - -# One entry per patches/.patch. Files are independent, so the order is -# irrelevant except for readability (vendored upstream/boosts patches first). -# json/core/io are "tolerant": their anchors may legitimately be absent in the -# committed state (json's explanatory comment never got committed; the -# core.cppm/io.cppm hunks were transitional no-ops, superseded by the stored -# final forms in patches/final/). -# The former bimap entry (C4 boost.iterator pin) is gone: gen_exports pass 2 -# (body-reference .deps completion) emits the edge naturally since 2026-09-08. -TOLERANT = {"json", "core", "io"} - -VENDORED_PATCHES = [ - "accumulators", "asio", "beast", "config_platform", "config_user", "hof", - "io", "lambda", "mqtt5", "multi_array", "parameter", "range_adaptors", - "numeric", "regex", "safe_numerics", "serialization", "system", "test", - "ublas", "units", -] - -SRC_PATCHES = [ - "align", "atomic", "bloom", "charconv", "cobalt", "config", - "container", "core", "decimal", "dll", "functional", "graph", "hana", - "heap", "hof", "hof_src", "interprocess", "intrusive", "iostreams", - "json", "lambda", "lambda_src", "leaf", "math", "mp11", "multiprecision", - "nowide", "parameter", "parser", "pfr", "poly_collection", "process", - "program_options", "qvm", "range", "safe_numerics", "safe_numerics_src", - "stacktrace", "system_src", "thread", "tuple", "url", "utility", - "variant", "winapi", -] -# note: the vendored/module split — hof/io/lambda/safe_numerics/system spanned -# upstream/boost/ AND regenerated module files in one diff, which cannot replay -# after a regeneration (the vendored part is already applied ⇒ forward fails; -# the module part is freshly regenerated ⇒ reverse fails). The vendored hunks -# stay in VENDORED_PATCHES, the module hunks moved to _src.patch -# (io_src dropped: src/io.cppm is replayed from its stored final form right -# after, its hunk was a transitional no-op; core.patch's core.cppm hunk dropped -# for the same reason). hana was orphaned (never listed) — the ::boost:: -# ext-tag spelling regressed on every regeneration. - - -def apply_patch_file(name): - """Apply patches/.patch; skip when already applied.""" - rel = f"patches/{name}.patch" - r = subprocess.run(["git", "apply", "--whitespace=nowarn", rel], cwd=ROOT, - capture_output=True, text=True, encoding="utf-8", - errors="replace") - if r.returncode == 0: - print(f" patched {rel}") - return - c = subprocess.run(["git", "apply", "--check", "--reverse", rel], cwd=ROOT, - capture_output=True, text=True, encoding="utf-8", - errors="replace") - if c.returncode == 0: - print(f" skip {rel} (already applied)") - return - # A source archive or a bare worktree may have no Git; the same patch still - # applies with POSIX patch, and the reverse dry-run tells us it is applied. - if subprocess.run(["patch", "-p1", "--dry-run", "--forward", "-i", rel], - cwd=ROOT, capture_output=True).returncode == 0: - subprocess.run(["patch", "-p1", "--forward", "-i", rel], cwd=ROOT, - capture_output=True, check=True) - print(f" patched {rel} (patch -p1)") - return - if subprocess.run(["patch", "-p1", "--dry-run", "--reverse", "-i", rel], - cwd=ROOT, capture_output=True).returncode == 0: - print(f" skip {rel} (already applied)") - return - if name in TOLERANT: - print(f" skip {rel} (anchor not present, tolerated)") - return - raise SystemExit(f"{rel}: failed to apply\n" - f" stdout: {r.stdout[:300]}\n stderr: {r.stderr[:300]}") - - -def patch(rel, old, new, *, required=True): - """Fallback for patches that cannot be expressed as a static diff: - the type_erasure.inc anchor only exists when the C4 mpl-entity ownership - flips back to poly_collection after a regeneration.""" - p = ROOT / rel - s = p.read_text(encoding="utf-8") - if new in s: - print(f" skip {rel} (already applied)") - return - n = s.count(old) - if n == 1: - p.write_text(s.replace(old, new), encoding="utf-8", newline="\n") - print(f" patched {rel}") - return - if n == 0 and not required: - print(f" skip {rel} (anchor not present, not required)") - return - raise SystemExit(f"{rel}: expected 1 anchor, found {n}\n anchor: {old[:80]!r}") - - -def restore_final(rel): - """Copy the stored final form of a hand-maintained file into place. - - The bytes live in patches/final/ and are part of the repository, so - the replay needs no Git history: a source archive, a shallow checkout and a - bare worktree all reproduce the same content. An unchanged file keeps its - bytes and mtime.""" - src = PATCH_DIR / "final" / rel - dst = ROOT / rel - if not src.is_file(): - raise SystemExit(f"missing stored final form: {src}") - data = src.read_bytes() - if dst.is_file() and dst.read_bytes() == data: - print(f" skip {rel} (already the stored final form)") - return - dst.parent.mkdir(parents=True, exist_ok=True) - dst.write_bytes(data) - print(f" restored {rel} (stored final form)") - - -def guard_entity_lines(rel, cond, names): - """Wrap each ` using boost::...;` line whose entity appears in `names` - (as a ::-delimited segment) in `#if cond` / `#endif`. Idempotent — a line - already sitting between a #if/#endif pair is left alone. - - M6: the committed .inc files are a mingw-flavor snapshot, so Windows-only - entities (guarded by #if defined(_WIN32) in the upstream headers) must not - be exported on POSIX. This mirrors the upstream header condition in the - module surface instead of hard-coding per-platform .inc files. - """ - import re - p = ROOT / rel - lines = p.read_text(encoding="utf-8").splitlines(keepends=True) - out = [] - changed = 0 - for i, line in enumerate(lines): - prev_is_if = bool(out) and out[-1].lstrip().startswith("#if ") - next_is_endif = (i + 1 < len(lines)) and lines[i + 1].lstrip().startswith("#endif") - if prev_is_if or next_is_endif: - out.append(line) - continue - stripped = line.strip() - m = re.fullmatch(r"using boost::([A-Za-z0-9_:]+);", stripped) - if m is None: - out.append(line) - continue - segments = m.group(1).split("::") - if any(seg in names for seg in segments): - out.append(f"#if {cond}\n") - out.append(line) - out.append("#endif\n") - changed += 1 - else: - out.append(line) - if changed: - p.write_text("".join(out), encoding="utf-8", newline="\n") - print(f" guarded {changed} entity line(s) in {rel}") - - -def ensure_file(rel, content): - """Create a vendored file that is an addition, not an upstream patch - (no-op when already present).""" - p = ROOT / rel - if p.exists(): - print(f" skip {rel} (already present)") - return - p.parent.mkdir(parents=True, exist_ok=True) - p.write_text(content, encoding="utf-8", newline="\n") - print(f" created {rel}") - - -def main(): - print("reapplying hand edits...") - - # ---- vendored header patches under upstream/boost/: import_boost.py - # wipes them on re-vendoring, so they replay before the .inc/.cppm pass - # below. patches/.patch, applied with git apply / patch -p1. ---- - print("applying vendored patches (patches/, upstream/boost)...") - for name in VENDORED_PATCHES: - apply_patch_file(name) - - print("applying module-side patches (patches/, src/ + generated/)...") - for name in SRC_PATCHES: - apply_patch_file(name) - - # ---- conditional C4 ownership anchor: cannot be a static diff ---- - patch("generated/exports/type_erasure.inc", - " using boost::mpl::item_by_order_impl;", - "#if defined(__GNUC__)\n" - " // M9 platform guard (C4 moved the claim here from\n" - " // poly_collection): gcc-preprocessed mpl map headers only -\n" - " // absent from the msvc-flavor TU, keep the export gcc-only.\n" - " using boost::mpl::item_by_order_impl;\n" - "#endif", - required=False) # C4: the entity may be claimed by type_erasure - - # M11 (M11 §6.4): new vendored file (mc.exe stub), not an upstream patch. - ensure_file("upstream/boost/libs/log/src/windows/simple_event_log.h", """ -/* - * Copyright Andrey Semashev 2007 - 2015. - * 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) - */ - -/* - * M11: hand-written replacement for the mc.exe-generated header. Upstream - * builds it from simple_event_log.mc at configure/build time (see - * libs/log/CMakeLists.txt); the vendored tree has no build-time code - * generation, so the constants (which only need to be self-consistent event - * IDs passed to ReportEvent) are defined here directly, mirroring the .mc - * MessageId/Severity layout. - */ - -#pragma once - -#define BOOST_LOG_SEVERITY_DEBUG 0x00000000L -#define BOOST_LOG_SEVERITY_INFO 0x00000001L -#define BOOST_LOG_SEVERITY_WARNING 0x00000002L -#define BOOST_LOG_SEVERITY_ERROR 0x00000003L - -#define BOOST_LOG_MSG_DEBUG ((DWORD)0x01000100L) -#define BOOST_LOG_MSG_INFO ((DWORD)0x01000101L) -#define BOOST_LOG_MSG_WARNING ((DWORD)0x01000102L) -#define BOOST_LOG_MSG_ERROR ((DWORD)0x01000103L) -""") - # ---- .inc platform guards (M3 §5, M6/M9/M11/M12 platform flavors): - # the committed .inc files are a mingw-flavor snapshot; wrap Windows-only - # / compiler-specific entities in the upstream header conditions. These - # stay programmatic (the wrapped line set depends on the regenerated - # .inc content, not on fixed anchors). ---- - guard_entity_lines("generated/exports/date_time.inc", "defined(_WIN32)", [ - "time_from_ftime", - "from_ftime", - ]) - guard_entity_lines("generated/exports/cobalt.inc", "defined(BOOST_ASIO_HAS_FILE)", [ - "basic_file", - "basic_random_access_file", - "basic_stream_file", - "file_base", - ]) - guard_entity_lines("generated/exports/cobalt.inc", "defined(_WIN32)", [ - "apc_function", - "null_reactor", - "select_reactor", - "null_signal_blocker", - "socket_select_interrupter", - "win_event", - "win_fd_set_adapter", - "win_global", - "win_global_impl", - "win_iocp_file_service", - "win_iocp_handle_read_op", - "win_iocp_handle_service", - "win_iocp_handle_write_op", - "win_iocp_io_context", - "win_iocp_null_buffers_op", - "win_iocp_operation", - "win_iocp_overlapped_ptr", - "win_iocp_serial_port_service", - "win_iocp_socket_accept_op", - "win_iocp_socket_connect_op", - "win_iocp_socket_connect_op_base", - "win_iocp_socket_move_accept_op", - "win_iocp_socket_recv_op", - "win_iocp_socket_recvfrom_op", - "win_iocp_socket_recvmsg_op", - "win_iocp_socket_send_op", - "win_iocp_socket_service", - "win_iocp_socket_service_base", - "win_iocp_thread_info", - "win_iocp_wait_op", - "win_mutex", - "win_static_mutex", - "win_thread", - "win_thread_base", - "win_thread_function", - "winsock_init", - "winsock_init_base", - "win_iocp_overlapped_op", - "win_object_handle_service", - "basic_object_handle", - "basic_overlapped_handle", - "basic_random_access_handle", - "basic_stream_handle", - "object_handle", - "overlapped_handle", - "overlapped_ptr", - "random_access_handle", - "stream_handle", - "complete_iocp_accept", - "complete_iocp_connect", - "complete_iocp_recv", - "complete_iocp_recvfrom", - "complete_iocp_recvmsg", - "complete_iocp_send", - "msghdr", - ]) - guard_entity_lines("generated/exports/uuid.inc", "defined(BOOST_UUID_USE_SSE2)", [ - "compare", - "countr_zero_nz", - "from_chars_simd", - "from_chars_simd_char_constants", - "from_chars_simd_constants", - "from_chars_simd_core", - "from_chars_simd_load_traits", - "simd_vector", - "simd_vector128", - "simd_vector256", - "simd_vector512", - "to_chars_simd", - "to_chars_simd_char_constants", - "to_chars_simd_constants", - "to_chars_simd_core", - ]) - guard_entity_lines("generated/exports/signals2.inc", "defined(BOOST_HAS_WINTHREADS)", [ - "critical_section", - "critical_section_debug", - "rtl_critical_section", - ]) - # numeric: Boost.uBLAS declares same_impl_ex only when size checks are on. - # A release build (NDEBUG) takes upstream's BOOST_UBLAS_USE_FAST_SAME path - # and never declares it, so the export must follow the header condition - # instead of exporting a name the release module cannot see. - guard_entity_lines("generated/exports/numeric.inc", - "!defined(NDEBUG) && !defined(BOOST_UBLAS_NDEBUG)", [ - "same_impl_ex", - ]) - guard_entity_lines("generated/exports/interprocess.inc", "defined(_WIN32)", [ - "basic_managed_windows_shared_memory", - "managed_windows_shared_memory", - "windows_shared_memory", - "wmanaged_windows_shared_memory", - "do_winapi_wait", - "winapi_mutex_functions", - "winapi_mutex_wrapper", - "winapi_semaphore_functions", - "winapi_semaphore_wrapper", - "winapi_wrapper_timed_wait_for_single_object", - "winapi_wrapper_try_wait_for_single_object", - "winapi_wrapper_wait_for_single_object", - "windows_bootstamp", - "windows_intermodule_singleton", - "windows_semaphore_based_map", - "file_time_to_microseconds", - "get_bootstamp", - "get_temporary_wpath", - "intermodule_singleton_common", - "intermodule_singleton_impl", - "mapping_handle_from_shm_handle", - "os_file_traits", - "ref_count_ptr", - "shm_named_mutex", - "shm_named_semaphore", - "spin_condition", - "spin_mutex", - "spin_recursive_mutex", - "spin_semaphore", - "unrestricted_permissions_holder", - "wshmem_open_or_create", - "get_map_base_name", - "get_map_name", - "get_map_size", - "get_pid_creation_time_str", - "thread_safe_global_map_dependant", - "mutex_traits", - ]) - guard_entity_lines("generated/exports/process.inc", "defined(_WIN32)", [ - "stream_handle", - ]) - guard_entity_lines("generated/exports/decimal.inc", "defined(__GNUC__)", [ - "add_carry_u64", - "u256_add", - ]) - guard_entity_lines("generated/exports/decimal.inc", - "defined(BOOST_DECIMAL_DETAIL_INT128_HAS_FAST_DIV128)", [ - "div_mod_intrinsic", - "int128_addcarry_u64", - "int128_subborrow_u64", - "int128_udiv128_intrinsic", - "int128_umul128_intrinsic", - "mg32_div_3by2", - "mg32_reciprocal_2by1", - "mg32_u256_by_u128", - ]) - guard_entity_lines("generated/exports/asio.inc", "defined(BOOST_ASIO_HAS_FILE)", [ - "basic_file", - "basic_random_access_file", - "basic_stream_file", - "file_base", - "random_access_file", - "stream_file", - ]) - guard_entity_lines("generated/exports/asio.inc", "defined(_WIN32)", [ - "apc_function", - "calculate_hash_value", - "random_access_handle", - "stream_handle", - "fd_set_adapter", - "hash_map", - "null_reactor", - "select_reactor", - "null_signal_blocker", - "socket_select_interrupter", - "reactor_op_queue", - "win_event", - "win_fd_set_adapter", - "win_global", - "win_global_impl", - "win_iocp_file_service", - "win_iocp_handle_read_op", - "win_iocp_handle_service", - "win_iocp_handle_write_op", - "win_iocp_io_context", - "win_iocp_null_buffers_op", - "win_iocp_operation", - "win_iocp_overlapped_ptr", - "win_iocp_serial_port_service", - "win_iocp_socket_accept_op", - "win_iocp_socket_connect_op", - "win_iocp_socket_connect_op_base", - "win_iocp_socket_move_accept_op", - "win_iocp_socket_recv_op", - "win_iocp_socket_recvfrom_op", - "win_iocp_socket_recvmsg_op", - "win_iocp_socket_send_op", - "win_iocp_socket_service", - "win_iocp_socket_service_base", - "win_iocp_thread_info", - "win_iocp_wait_op", - "win_iocp_overlapped_op", - "win_object_handle_service", - "win_mutex", - "win_static_mutex", - "win_thread", - "win_thread_base", - "win_thread_function", - "winsock_init", - "winsock_init_base", - "basic_object_handle", - "basic_overlapped_handle", - "basic_random_access_handle", - "basic_stream_handle", - "object_handle", - "overlapped_handle", - "overlapped_ptr", - "complete_iocp_accept", - "complete_iocp_connect", - "complete_iocp_recv", - "complete_iocp_recvfrom", - "complete_iocp_recvmsg", - "complete_iocp_send", - "msghdr", - ]) - guard_entity_lines("generated/exports/beast.inc", "defined(_WIN32)", [ - "file_win32", - "set_file_pointer_ex", - "win32_unicode_path", - "highPart", - "lowPart", - "make_win32_error", - "null_lambda", - "run_write_some_win32_op", - "write_some_win32_op", - "basic_dstream", - "dstream_buf", - ]) - # ---- M3/M9 "final form" restores: these files are hand-maintained and a - # regeneration would clobber them, so replay the stored bytes ---- - # M9: flyweight — restore the hand-trimmed committed form (the - # generator leaks the transitive container/interprocess surface). - restore_final("generated/exports/flyweight.inc") - guard_entity_lines("generated/exports/thread.inc", "defined(_WIN32)", [ - "intrusive_ptr", - "wait_operations_windows", - "time_from_ftime", - "from_ftime", - "interruptible_wait", - "non_interruptible_wait", - "allocate_raw_heap_memory", - "free_raw_heap_memory", - "basic_condition_variable", - "basic_cv_list_entry", - "basic_recursive_mutex", - "basic_recursive_mutex_impl", - "basic_recursive_timed_mutex", - "basic_timed_mutex", - "commit_once_region", - "create_once_event", - "enter_once_region", - "rollback_once_region", - "int_to_string", - "interlocked_read_acquire", - "interlocked_write_release", - "intrusive_ptr_add_ref", - "intrusive_ptr_release", - "name_once_mutex", - "once_action", - "once_char_type", - "once_context", - "open_once_event", - "underlying_mutex", - ]) - # ---- algorithm: M3 workaround (string.hpp GFM + *regex pruning) ---- - # The committed M3 form is the source of truth; regenerate-free. - restore_final("generated/exports/algorithm.inc") - restore_final("generated/exports/algorithm.deps") - # ---- M3 libs whose .cppm are unchanged (regen only rewrites the - # header comment): keep the M3 "final form" convention. scope_exit - # left the list in C1: the scope module is include-only now. ---- - restore_final("src/algorithm.cppm") - restore_final("src/any.cppm") - restore_final("src/container_hash.cppm") - restore_final("src/core.cppm") - restore_final("src/endian.cppm") - restore_final("src/io.cppm") - restore_final("src/iterator.cppm") - restore_final("src/mp11.cppm") - restore_final("src/optional.cppm") - restore_final("src/range.cppm") - restore_final("src/rational.cppm") - restore_final("src/scope.cppm") - restore_final("src/static_string.cppm") - restore_final("src/tuple.cppm") - restore_final("src/type_traits.cppm") - restore_final("src/variant.cppm") - restore_final("src/variant2.cppm") - print("done.") - - -if __name__ == "__main__": - main() diff --git a/tools/tests/test_apply_patches.py b/tools/tests/test_apply_patches.py new file mode 100644 index 000000000..2c7f3ab23 --- /dev/null +++ b/tools/tests/test_apply_patches.py @@ -0,0 +1,117 @@ +"""Vendored patches replay idempotently and checkouts keep generated bytes.""" +import subprocess +import tempfile +import unittest +from pathlib import Path +from unittest import mock + +import apply_patches +import gen_exports + + +class VendoredPatchTests(unittest.TestCase): + def test_every_patch_targets_the_vendored_tree(self): + listed = set(apply_patches.PATCHES) + on_disk = {p.stem for p in apply_patches.PATCH_DIR.glob("*.patch")} + self.assertEqual(listed, on_disk) + for name in sorted(listed): + text = (apply_patches.PATCH_DIR / (name + ".patch")).read_text( + encoding="utf-8") + for line in text.splitlines(): + if line.startswith("+++ b/"): + with self.subTest(patch=name): + self.assertTrue(line[6:].startswith("upstream/boost/"), + line) + + def test_applied_patch_is_skipped_with_git(self): + name = "io" + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + (root / "patches").mkdir() + patch = apply_patches.PATCH_DIR / (name + ".patch") + (root / "patches" / patch.name).write_bytes(patch.read_bytes()) + for line in patch.read_text(encoding="utf-8").splitlines(): + if line.startswith("+++ b/"): + rel = line[6:] + dst = root / rel + dst.parent.mkdir(parents=True, exist_ok=True) + dst.write_bytes((apply_patches.ROOT / rel).read_bytes()) + before = {p: p.read_bytes() for p in root.rglob("*.hpp")} + with mock.patch.object(apply_patches, "ROOT", root), \ + mock.patch("subprocess.run", wraps=subprocess.run) as run: + apply_patches.apply_patch_file(name) + self.assertEqual({p: p.read_bytes() for p in before}, before) + self.assertTrue(all(call.args[0][0] == "git" + for call in run.call_args_list)) + + + def test_missing_git_falls_back_to_patch(self): + real = subprocess.run + + def no_git(cmd, *a, **kw): + if cmd[0] == "git": + raise FileNotFoundError(2, "No such file", "git") + return real(cmd, *a, **kw) + + calls = [] + ok = subprocess.CompletedProcess([], 0, "", "") + + def fake(cmd, *a, **kw): + calls.append(list(cmd)) + if cmd[0] == "git": + return no_git(cmd, *a, **kw) + return ok + + with mock.patch("subprocess.run", side_effect=fake): + apply_patches.apply_patch_file("io") + self.assertEqual([c[0] for c in calls], + ["git", "git", "patch", "patch"]) + self.assertNotIn("--dry-run", calls[-1]) + + def test_failure_reports_both_tools(self): + def fail(cmd, *a, **kw): + if cmd[0] == "git": + raise FileNotFoundError(2, "No such file", "git") + return subprocess.CompletedProcess(cmd, 1, "", "hunk FAILED") + + with mock.patch("subprocess.run", side_effect=fail), \ + self.assertRaises(SystemExit) as cm: + apply_patches.apply_patch_file("io") + self.assertIn("No such file", str(cm.exception)) + self.assertIn("hunk FAILED", str(cm.exception)) + +class CheckoutTests(unittest.TestCase): + def test_windows_checkout_preserves_generation_bytes(self): + # Exercise Git's actual Windows-style checkout conversion on every OS. + paths = ( + "patches/io.patch", "src/winapi.cppm", + "generated/exports/winapi.inc", "generated/exports/system.deps", + "generated/meta/skipped.txt", "tools/export_policy.toml", + ) + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + + def git(*args): + return subprocess.run( + ["git", "-c", "core.autocrlf=true", *args], cwd=root, + capture_output=True, check=True) + + git("init") + (root / ".gitattributes").write_bytes( + (gen_exports.bc.ROOT / ".gitattributes").read_bytes()) + for rel in paths: + dst = root / rel + dst.parent.mkdir(parents=True, exist_ok=True) + dst.write_bytes((gen_exports.bc.ROOT / rel).read_bytes()) + git("add", ".") + for rel in paths: + (root / rel).unlink() + git("checkout-index", "--all", "--force") + for rel in paths: + with self.subTest(path=rel): + self.assertEqual((root / rel).read_bytes(), + (gen_exports.bc.ROOT / rel).read_bytes()) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_ast_json.py b/tools/tests/test_ast_json.py new file mode 100644 index 000000000..6817ac3ab --- /dev/null +++ b/tools/tests/test_ast_json.py @@ -0,0 +1,189 @@ +"""The streaming reader of clang's JSON AST (tools/ast_json.py).""" +import io +import json +import unittest + +import ast_json + + +def stream(*objs): + """clang prints one pretty-printed object per filter match, indent 2; + json.dumps(indent=2) produces the same line layout.""" + text = "".join(json.dumps(o, indent=2) + "\n" for o in objs) + return io.BytesIO(text.encode()) + + +def loc(file=None, line=None, included_from=None): + out = {"offset": 1} + if file is not None: + out["file"] = file + if line is not None: + out["line"] = line + out["col"] = 1 + if included_from is not None: + out["includedFrom"] = {"file": included_from} + return out + + +def ns(nid, name, inner, l=None): + return {"id": nid, "kind": "NamespaceDecl", "loc": l or loc(), + "range": {"begin": loc(), "end": loc()}, "name": name, + "inner": inner} + + +class ReaderTests(unittest.TestCase): + def test_file_is_delta_encoded_across_locations(self): + tu = ast_json.TU.from_stream(stream(ns("0x1", "boost", [ + {"id": "0x2", "kind": "CXXRecordDecl", + "loc": loc("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/b/a.hpp", 3, included_from="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/b/x.hpp"), + "range": {"begin": loc(), "end": loc()}, "name": "a", + "tagUsed": "struct"}, + # no "file": same file as the previously printed location, and + # includedFrom's file must not count as one + {"id": "0x3", "kind": "CXXRecordDecl", + "loc": loc(line=9, included_from="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/b/other.hpp"), + "name": "b", "tagUsed": "struct"}, + # a file printed inside a (dropped) range still moves the state + {"id": "0x4", "kind": "TypedefDecl", "loc": loc(line=1), + "range": {"begin": loc("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/b/c.hpp", 2), "end": loc()}, + "name": "c", "type": {"qualType": "int"}}, + {"id": "0x5", "kind": "TypedefDecl", "loc": loc(line=4), + "name": "d", "type": {"qualType": "int"}}, + ], loc("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/b/a.hpp", 1)))) + files = {d.name: (d.file, d.line) for d in tu.decls} + self.assertEqual(files["a"], ("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/b/a.hpp", 3)) + self.assertEqual(files["b"], ("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/b/a.hpp", 9)) + self.assertEqual(files["c"], ("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/b/a.hpp", 1)) + self.assertEqual(files["d"], ("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/b/c.hpp", 4)) + + def test_macro_location_uses_the_expansion_file(self): + tu = ast_json.TU.from_stream(stream(ns("0x1", "boost", [ + {"id": "0x2", "kind": "VarDecl", + "loc": {"spellingLoc": loc("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/b/macro.hpp", 5), + "expansionLoc": loc("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/b/user.hpp", 7)}, + "name": "v", "type": {"qualType": "int"}}, + ], loc("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/b/user.hpp", 1)))) + v = next(d for d in tu.decls if d.name == "v") + self.assertEqual((v.file, v.line), ("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/b/user.hpp", 7)) + + def test_implicit_instantiations_are_dropped_and_aliased(self): + tu = ast_json.TU.from_stream(stream(ns("0x1", "boost", [ + {"id": "0x10", "kind": "ClassTemplateDecl", "loc": loc("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/b/t.hpp", 1), + "name": "box", "inner": [ + {"id": "0x11", "kind": "TemplateTypeParmDecl", "name": "T"}, + {"id": "0x12", "kind": "CXXRecordDecl", "name": "box", + "tagUsed": "struct", "completeDefinition": True}, + {"id": "0x13", "kind": "ClassTemplateSpecializationDecl", + "loc": loc("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/b/elsewhere.hpp", 8), "name": "box", + "inner": [{"id": "0x14", "kind": "CXXMethodDecl", + "name": "get"}]}, + ]}, + {"id": "0x20", "kind": "FunctionDecl", "loc": loc(line=30), + "name": "use", "type": {"qualType": "void ()"}, "inner": [ + {"id": "0x21", "kind": "CompoundStmt", "inner": [ + {"id": "0x22", "kind": "DeclRefExpr", + "referencedDecl": {"id": "0x14", "kind": "CXXMethodDecl", + "name": "get"}}, + ]}, + ]}, + ]))) + kinds = [d.kind for d in tu.decls] + self.assertNotIn("ClassTemplateSpecializationDecl", kinds) + tmpl = tu.by_id["0x10"] + self.assertEqual(tmpl.pattern.id, "0x12") + self.assertIs(tu.resolve("0x13"), tmpl) + self.assertIs(tu.resolve("0x14"), tmpl) + use = tu.by_id["0x20"] + self.assertTrue(use.has_body) + self.assertIn("0x14", use.refs) + # the skipped instantiation printed a file: clang's delta state moved, + # and the reader followed it + self.assertEqual(use.file, "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/b/elsewhere.hpp") + + def test_lookups_inside_an_instantiation_are_not_aliased(self): + # An UnresolvedLookupExpr in the instantiated body lists the + # declarations it may call (std::swap); those are not part of the + # instantiation and must keep resolving to themselves. + tu = ast_json.TU.from_stream(stream(ns("0x1", "boost", [ + {"id": "0x10", "kind": "ClassTemplateDecl", "loc": loc("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/b/t.hpp", 1), + "name": "box", "inner": [ + {"id": "0x11", "kind": "TemplateTypeParmDecl", "name": "T"}, + {"id": "0x12", "kind": "CXXRecordDecl", "name": "box", + "tagUsed": "struct", "completeDefinition": True}, + {"id": "0x13", "kind": "ClassTemplateSpecializationDecl", + "name": "box", "inner": [ + {"id": "0x14", "kind": "CXXMethodDecl", "name": "swap", + "inner": [{"id": "0x15", "kind": "CompoundStmt", + "inner": [{ + "id": "0x16", + "kind": "UnresolvedLookupExpr", + "lookups": [ + {"id": "0x99", + "kind": "FunctionTemplateDecl", + "name": "swap"}], + "inner": [{"id": "0x17", + "kind": "DeclRefExpr"}]}]}]}, + ]}, + ]}, + ]))) + tmpl = tu.by_id["0x10"] + for nid in ("0x13", "0x14", "0x15", "0x16", "0x17"): + self.assertIs(tu.resolve(nid), tmpl, nid) + self.assertNotIn("0x99", tu.alias) + + def test_null_children_and_foreign_top_level_objects(self): + tu = ast_json.TU.from_stream(stream( + {"id": "0x90", "kind": "CXXRecordDecl", "loc": loc("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/std/x.h", 1), + "name": "hash"}, + ns("0x1", "boost", [ + {}, + {"id": "0x2", "kind": "EnumDecl", "loc": loc("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/b/e.hpp", 2), + "name": "color", "inner": [ + {"id": "0x3", "kind": "EnumConstantDecl", "name": "red", + "type": {"qualType": "boost::color"}}, + ]}, + ]))) + names = sorted(d.name for d in tu.decls) + self.assertEqual(names, ["boost", "color", "red"]) + red = tu.by_id["0x3"] + self.assertIs(red.parent, tu.by_id["0x2"]) + self.assertIs(tu.by_id["0x2"].parent, tu.by_id["0x1"]) + + def test_signature_and_using_details(self): + tu = ast_json.TU.from_stream(stream(ns("0x1", "boost", [ + {"id": "0x2", "kind": "CXXRecordDecl", "loc": loc("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/b/r.hpp", 1), + "name": "r", "tagUsed": "struct", "completeDefinition": True, + "bases": [{"access": "public", + "type": {"qualType": "iterators::facade"}, + "writtenAccess": "none"}], + "inner": [ + {"id": "0x3", "kind": "FieldDecl", "name": "f", + "type": {"qualType": "detail::impl"}}, + ]}, + {"id": "0x4", "kind": "UsingDecl", "name": "range::count"}, + {"id": "0x5", "kind": "UsingShadowDecl", "isImplicit": True, + "target": {"id": "0x77", "kind": "FunctionDecl", "name": "count"}, + "inner": [{"id": "0x77", "kind": "FunctionDecl", "name": "count", + "loc": loc("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/b/range.hpp", 40)}]}, + {"id": "0x6", "kind": "UsingDirectiveDecl", + "nominatedNamespace": {"id": "0x9", "kind": "NamespaceDecl", + "name": "adl"}}, + {"id": "0x7", "kind": "FunctionDecl", "loc": loc(line=50), "name": "g", + "type": {"qualType": "int (const boost::r &)"}, + "inner": [{"id": "0x8", "kind": "ParmVarDecl", "name": "x", + "type": {"qualType": "const boost::r &"}}]}, + ], loc("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/b/r.hpp", 1)))) + r = tu.by_id["0x2"] + self.assertEqual(r.bases, ["iterators::facade"]) + self.assertIn("iterators::facade", r.written) + self.assertEqual(tu.by_id["0x4"].name, "range::count") + self.assertEqual(tu.by_id["0x5"].target, "0x77") + self.assertNotIn("0x77", tu.by_id) # shadow copy not recorded + self.assertEqual(tu.by_id["0x6"].target, "0x9") + self.assertEqual(tu.by_id["0x7"].params, ["const boost::r &"]) + # the location inside the skipped shadow copy still moved the state + self.assertEqual(tu.by_id["0x7"].file, "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/b/range.hpp") + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_gen_audit.py b/tools/tests/test_gen_audit.py index 5a5e5efb0..345268b21 100644 --- a/tools/tests/test_gen_audit.py +++ b/tools/tests/test_gen_audit.py @@ -1,36 +1,97 @@ -"""Hand-written modules must not require nonexistent generated bundle TUs.""" +"""Hand-written modules must not require nonexistent generated bundle TUs; +the linkage audit reuses its last report while its inputs hold.""" +import tempfile import unittest +from pathlib import Path from unittest import mock +import ast_json import gen_audit +import gen_exports class AuditSpecialModulesTests(unittest.TestCase): def test_linkage_audit_skips_special_modules(self): with mock.patch("sys.argv", ["gen_audit.py"]), \ - mock.patch.object(gen_audit.bc, "get_ci"), \ mock.patch.object(gen_audit.bc, "TARGET_LIBS", ["atomic", "version"]), \ - mock.patch.object(gen_audit.bc, "headers_of", return_value=[]) as headers, \ mock.patch.object(gen_audit, "audit_lib", return_value=(0, 0, 0, 0)) as audit: self.assertEqual(gen_audit.main(), 0) - headers.assert_called_once_with("atomic") - audit.assert_called_once_with("atomic", [], gen_audit.bc.AUDIT_DIR) + audit.assert_called_once() + self.assertEqual(audit.call_args.args[:2], ("atomic", gen_audit.bc.AUDIT_DIR)) def test_explicit_special_module_needs_no_bundle(self): with mock.patch("sys.argv", ["gen_audit.py", "--libs", "version"]), \ - mock.patch.object(gen_audit.bc, "get_ci"), \ mock.patch.object(gen_audit, "audit_lib") as audit: self.assertEqual(gen_audit.main(), 0) audit.assert_not_called() def test_macro_audit_keeps_special_module_headers(self): with mock.patch("sys.argv", ["gen_audit.py", "--macros", "--libs", "version"]), \ - mock.patch.object(gen_audit.bc, "get_ci") as get_ci, \ + mock.patch.object(gen_audit, "audit_lib") as linkage, \ mock.patch.object(gen_audit, "macros_audit", return_value=0) as audit: self.assertEqual(gen_audit.main(), 0) - get_ci.assert_not_called() + linkage.assert_not_called() audit.assert_called_once_with(["version"], gen_audit.bc.AUDIT_DIR) +class AuditCacheTests(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.addCleanup(self.tmp.cleanup) + self.root = Path(self.tmp.name) + self.deps = self.root / "upstream/boost" + self.header = self.deps / "boost/x.hpp" + self.header.parent.mkdir(parents=True) + self.header.write_text("one") + self.out = self.root / "audit" + self.policy = gen_exports.Policy({"x": {"gmf": ["boost/x.hpp"]}}) + self.tu = ast_json.TU() + self.tu.inputs = [str(self.header)] + for patcher in ( + mock.patch.object(gen_exports.bc, "ROOT", self.root), + mock.patch.object(gen_exports.bc, "DEPS", self.deps), + mock.patch.object(gen_exports.bc, "CACHE_DIR", self.root / "cache"), + mock.patch.object(gen_exports.bc, "CLANG_ARGS", []), + mock.patch.object(gen_exports, "_closure_hash", return_value="closure"), + mock.patch.object(gen_exports.aj, "clang_version", return_value="clang 23"), + mock.patch.dict(gen_exports._FILE_HASH, clear=True), + ): + patcher.start() + self.addCleanup(patcher.stop) + + def audit(self): + with mock.patch.object(gen_exports, "parse_bundle", return_value=( + self.tu, [self.header])) as parse: + counts = gen_audit.audit_lib("x", self.out, self.policy) + return counts, parse.call_count + + def test_hit_skips_the_dump(self): + first, dumps = self.audit() + self.assertEqual(dumps, 1) + report = (self.out / "x.txt").read_text() + (self.out / "x.txt").unlink() + self.assertEqual(self.audit(), (first, 0)) + self.assertEqual((self.out / "x.txt").read_text(), report) + + def test_edit_to_a_read_file_invalidates(self): + self.audit() + self.header.write_text("two") + gen_exports._FILE_HASH.clear() + self.assertEqual(self.audit()[1], 1) + + def test_gate_key_change_invalidates(self): + self.audit() + self.policy = gen_exports.Policy( + {"x": {"gmf": ["boost/x.hpp"], "defines": ["X_ONLY"]}}) + self.assertEqual(self.audit()[1], 1) + + def test_no_cache_always_dumps(self): + self.audit() + with mock.patch.object(gen_exports, "parse_bundle", return_value=( + self.tu, [self.header])) as parse: + gen_audit.audit_lib("x", self.out, self.policy, use_cache=False) + parse.assert_called_once() + + if __name__ == "__main__": unittest.main() diff --git a/tools/tests/test_gen_exports_cache.py b/tools/tests/test_gen_exports_cache.py new file mode 100644 index 000000000..3f1c04969 --- /dev/null +++ b/tools/tests/test_gen_exports_cache.py @@ -0,0 +1,108 @@ +"""Generator cache entries stay valid only while their inputs hold: the files +clang read and the first-wins ownership seen when they were computed.""" +import shutil +import tempfile +import unittest +from pathlib import Path +from unittest import mock + +import ast_json +import gen_exports + + +class DepfileTests(unittest.TestCase): + def test_continuations_and_escapes(self): + text = ("bundle.o: /r/bundle.cpp /r/a\\ b.hpp \\\n" + " /r/c\\#d.hpp /r/$$e.hpp \\\r\n" + " D:\\a\\x.hpp\n") + self.assertEqual(ast_json.parse_depfile(text), [ + "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/r/bundle.cpp", "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/r/a b.hpp", "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/r/c#d.hpp", "/r/$e.hpp", + "D:\\a\\x.hpp"]) + + def test_empty(self): + self.assertEqual(ast_json.parse_depfile(""), []) + + @unittest.skipUnless(shutil.which(ast_json.clang_command()[0]), + "clang++ not on PATH") + def test_macro_computed_include_is_an_input(self): + # The include-closure regex cannot see `#include NAME()`; clang's + # dependency list must. + with tempfile.TemporaryDirectory() as tmp: + d = Path(tmp) + (d / "hidden.hpp").write_text("namespace boost { int h; }\n") + (d / "t.cpp").write_text('#define NAME() "hidden.hpp"\n' + "#include NAME()\n") + tu = ast_json.dump(d / "t.cpp", ["-std=c++23"], + cwd=str(gen_exports.bc.ROOT)) + names = {Path(p).name for p in tu.inputs} + self.assertIn("hidden.hpp", names) + + +class ManifestTests(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.addCleanup(self.tmp.cleanup) + self.root = Path(self.tmp.name) + for patcher in ( + mock.patch.object(gen_exports.bc, "ROOT", self.root), + mock.patch.object(gen_exports.bc, "CACHE_DIR", + self.root / "cache"), + mock.patch.dict(gen_exports._FILE_HASH, clear=True), + ): + patcher.start() + self.addCleanup(patcher.stop) + + def test_edit_to_any_read_file_invalidates(self): + inc = self.root / "upstream/boost/boost/x/detail/rel.hpp" + inc.parent.mkdir(parents=True) + inc.write_text("one") + bundle = self.root / "cache/bundles/x.cpp" + bundle.parent.mkdir(parents=True) + bundle.write_text("#include \n") + tu = ast_json.TU() + tu.inputs = [str(bundle), "upstream/boost/boost/x/detail/rel.hpp"] + man = gen_exports._input_manifest(tu, self.root) + self.assertEqual(list(man), ["upstream/boost/boost/x/detail/rel.hpp"]) + self.assertTrue(gen_exports._manifest_ok(man)) + inc.write_text("two") + gen_exports._FILE_HASH.clear() + self.assertFalse(gen_exports._manifest_ok(man)) + + def test_entry_without_manifest_is_stale(self): + self.assertFalse(gen_exports._manifest_ok(None)) + self.assertFalse(gen_exports._manifest_ok({})) + + +class ClaimViewTests(unittest.TestCase): + def test_view_records_the_owner_before_the_library(self): + table = {"boost::a=boost::x::a": "range"} + view = gen_exports._ClaimView(table) + self.assertIn("boost::a=boost::x::a", view) + self.assertNotIn("boost::b", view) + view["boost::b"] = "algorithm" + self.assertIn("boost::b", view) # second probe: own claim + view.setdefault("boost::c", "algorithm") + self.assertEqual(view.seen, {"boost::a=boost::x::a": "range", + "boost::b": None, "boost::c": None}) + self.assertEqual(table["boost::b"], "algorithm") + + def test_entry_holds_only_under_the_same_ownership(self): + sk = {"claims": [["u1", "te"], ["u2", "te"]], + "pre_claimed": ["u2"], + "inject_view": [["boost::j", None]]} + self.assertTrue(gen_exports._claims_hold(sk, {"u2": "pc"}, {})) + # an earlier library (not an include-graph upstream) now claims u1 + self.assertFalse(gen_exports._claims_hold( + sk, {"u1": "pc", "u2": "pc"}, {})) + # ... or released u2 + self.assertFalse(gen_exports._claims_hold(sk, {}, {})) + # ... or now injects the same name first + self.assertFalse(gen_exports._claims_hold( + sk, {"u2": "pc"}, {"boost::j": "range"})) + # entries written before the view existed are stale + self.assertFalse(gen_exports._claims_hold( + {"claims": []}, {}, {})) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_gen_exports_gate.py b/tools/tests/test_gen_exports_gate.py index 08f8570af..e37e066c7 100644 --- a/tools/tests/test_gen_exports_gate.py +++ b/tools/tests/test_gen_exports_gate.py @@ -1,11 +1,10 @@ -"""The syntax gate must prune the same headers on every host platform.""" -import subprocess +"""The compile gate must prune the same headers on every host platform.""" import tempfile -import types import unittest from pathlib import Path from unittest import mock +import ast_json import gen_exports @@ -17,19 +16,15 @@ def setUp(self): self.deps = self.root / "upstream" / "boost" self.icu = self.deps / "boost/regex/icu.hpp" self.regex = self.deps / "boost/regex.hpp" - self.tu = types.SimpleNamespace(diagnostics=[]) - self.index = mock.Mock() - self.index.parse.return_value = self.tu - self.ci = mock.Mock() - self.ci.Index.create.return_value = self.index + self.tu = ast_json.TU() + self.policy = gen_exports.Policy({}) for patcher in ( mock.patch.object(gen_exports.bc, "ROOT", self.root), mock.patch.object(gen_exports.bc, "DEPS", self.deps), mock.patch.object(gen_exports.bc, "CACHE_DIR", self.root / "cache"), mock.patch.object(gen_exports.bc, "CLANG_ARGS", []), - mock.patch.object(gen_exports.bc, "get_ci", return_value=self.ci), mock.patch.object(gen_exports, "_closure_hash", return_value="closure"), - mock.patch.object(gen_exports, "_clang_version", return_value="clang 23"), + mock.patch.object(gen_exports.aj, "clang_version", return_value="clang 23"), ): patcher.start() self.addCleanup(patcher.stop) @@ -45,25 +40,32 @@ def test_prune_missing_optional_dependency(self): "{0}/boost/regex/v5/icu.hpp:23:10: fatal error: " "'unicode/utypes.h' file not found\n" ).format(prefix) - with mock.patch("subprocess.run", side_effect=[ - subprocess.CompletedProcess([], 1, "", stderr), - subprocess.CompletedProcess([], 0, "", ""), - ]) as gate: - result = gen_exports._parse_bundle( - "regex", [self.icu, self.regex], use_cache=False) + with mock.patch.object(gen_exports.aj, "dump", side_effect=[ + ast_json.DumpError(1, stderr), self.tu, + ]) as dump: + result = gen_exports.parse_bundle( + "regex", [self.icu, self.regex], self.policy, + use_cache=False) self.assertEqual(result, (self.tu, [self.regex])) - self.assertEqual(gate.call_count, 2) + self.assertEqual(dump.call_count, 2) bundle = self.root / "cache/bundles/regex.cpp" self.assertEqual(bundle.read_text(), "#include \n") def test_unrelated_error_still_fails(self): stderr = "D:/sdk/missing.hpp:12:3: fatal error: 'missing.h' file not found\n" - with mock.patch("subprocess.run", return_value= - subprocess.CompletedProcess([], 1, "", stderr)) as gate: - self.assertIsNone(gen_exports._parse_bundle( - "regex", [self.icu, self.regex], use_cache=False)) - gate.assert_called_once() - self.index.parse.assert_not_called() + with mock.patch.object(gen_exports.aj, "dump", side_effect= + ast_json.DumpError(1, stderr)) as dump: + self.assertIsNone(gen_exports.parse_bundle( + "regex", [self.icu, self.regex], self.policy, use_cache=False)) + dump.assert_called_once() + + def test_policy_defines_reach_the_compile(self): + policy = gen_exports.Policy({"regex": {"defines": ["X_ONLY"]}}) + with mock.patch.object(gen_exports.aj, "dump", + return_value=self.tu) as dump: + gen_exports.parse_bundle("regex", [self.regex], policy, + use_cache=False) + self.assertIn("-DX_ONLY", dump.call_args.args[1]) if __name__ == "__main__": diff --git a/tools/tests/test_gen_exports_inject.py b/tools/tests/test_gen_exports_inject.py new file mode 100644 index 000000000..f13374e2d --- /dev/null +++ b/tools/tests/test_gen_exports_inject.py @@ -0,0 +1,163 @@ +"""Namespace-scope using-declarations must export the name they publish.""" +import io +import json +import tempfile +import unittest +from pathlib import Path +from unittest import mock + +import ast_json +import gen_exports + +HDR = "/b/boost/algorithm/string/constants.hpp" + + +def loc(file=None, line=1): + out = {"offset": 1, "line": line, "col": 1} + if file is not None: + out["file"] = file + return out + + +def ns(nid, name, inner): + return {"id": nid, "kind": "NamespaceDecl", "loc": loc(), + "range": {"begin": loc(), "end": loc()}, "name": name, + "inner": inner} + + +def using(nid, name, line): + return {"id": nid, "kind": "UsingDecl", "loc": loc(line=line), + "name": name} + + +def enum(nid, name, enumerators, line, scoped=False): + d = {"id": nid, "kind": "EnumDecl", "loc": loc(line=line), "name": name, + "inner": [{"id": "{}{}".format(nid, i), "kind": "EnumConstantDecl", + "loc": loc(line=line), "name": e, + "type": {"qualType": name}} + for i, e in enumerate(enumerators)]} + if scoped: + d["scopedEnumTag"] = "class" + return d + + +def model(): + """namespace boost { + namespace algorithm { + enum token_compress_mode_type { token_compress_on, ... }; + enum class mode { fast }; + void join(); + } + using algorithm::token_compress_on; + using algorithm::join; + namespace range_detail { struct formatted_range; } + namespace range { using boost::range_detail::formatted_range; } + }""" + text = json.dumps(ns("0x1", "boost", [ + ns("0x2", "algorithm", [ + {**enum("0x10", "token_compress_mode_type", + ["token_compress_on", "token_compress_off"], 2), + "loc": loc(HDR, 2)}, + enum("0x20", "mode", ["fast"], 3, scoped=True), + {"id": "0x30", "kind": "FunctionDecl", "loc": loc(line=4), + "name": "join", "mangledName": "_ZN5boost9algorithm4joinEv", + "type": {"qualType": "void ()"}}, + ]), + using("0x40", "algorithm::token_compress_on", 6), + using("0x41", "algorithm::join", 7), + ns("0x3", "range_detail", [ + {"id": "0x50", "kind": "CXXRecordDecl", "loc": loc(line=8), + "name": "formatted_range", "tagUsed": "struct", + "completeDefinition": True}, + ]), + ns("0x4", "range", [ + using("0x60", "boost::range_detail::formatted_range", 9), + ]), + ]), indent=2) + "\n" + tu = ast_json.TU.from_stream(io.BytesIO(text.encode())) + return gen_exports.Model(tu) + + +class InjectionTests(unittest.TestCase): + def setUp(self): + patcher = mock.patch.object(gen_exports, "home_of_file", + return_value="algorithm") + patcher.start() + self.addCleanup(patcher.stop) + self.m = model() + + def test_unscoped_enumerator_found_through_enclosing_scope(self): + idx = self.m.qindex() + self.assertIn("boost::algorithm::token_compress_on", idx) + self.assertIn( + "boost::algorithm::token_compress_mode_type::token_compress_on", + idx) + self.assertNotIn("boost::algorithm::fast", idx) # enum class + out = gen_exports.collect_injections("algorithm", self.m, {}) + self.assertEqual(out["boost::token_compress_on"]["qname"], + "boost::token_compress_on") + + def test_qualified_target_injects_its_last_segment(self): + out = gen_exports.collect_injections("algorithm", self.m, {}) + self.assertIn("boost::range::formatted_range", out) + self.assertNotIn("boost::range_detail::formatted_range", out) + d = self.m.by_id["0x60"] + self.assertEqual(gen_exports._using_target_name(self.m, d), + ("boost::range::formatted_range", + "boost::range_detail::formatted_range")) + + def test_same_name_other_target_is_not_deduplicated(self): + claimed = {"boost::join=boost::range::join": "range"} + out = gen_exports.collect_injections("algorithm", self.m, claimed) + self.assertEqual(out["boost::join"]["qname"], "boost::join") + self.assertEqual(claimed["boost::join=boost::algorithm::join"], + "algorithm") + + def test_same_name_same_target_is_deduplicated(self): + claimed = {"boost::join=boost::algorithm::join": "string_algo"} + out = gen_exports.collect_injections("algorithm", self.m, claimed) + self.assertNotIn("boost::join", out) + + +class FacadeImportTests(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.addCleanup(self.tmp.cleanup) + self.root = Path(self.tmp.name) + self.deps = self.root / "upstream" / "boost" + for patcher in ( + mock.patch.object(gen_exports.bc, "ROOT", self.root), + mock.patch.object(gen_exports.bc, "DEPS", self.deps), + ): + patcher.start() + self.addCleanup(patcher.stop) + (self.root / "src").mkdir() + (self.root / "src" / "range.cppm").write_text( + "module;\n#include \n" + "export module mcpplibs.mwrap.boost.range;\n" + "export import mcpplibs.mwrap.boost.core;\n" + '#include "../generated/exports/range.inc"\n') + self.gmf = [self.deps / "boost/range.hpp"] + + def check(self, deps, omit=()): + return gen_exports.check_facade( + "range", self.gmf, (), + ["mcpplibs.mwrap.boost." + d for d in deps], omit) + + def test_missing_edge_is_reported(self): + problems = self.check(["core", "smart_ptr"]) + self.assertEqual(len(problems), 1) + self.assertIn("export import mcpplibs.mwrap.boost.smart_ptr;", + problems[0]) + + def test_declared_omission_is_accepted(self): + self.assertEqual(self.check(["core", "regex"], ["regex"]), []) + + def test_stale_omission_is_reported(self): + self.assertEqual(len(self.check(["core"], ["regex"])), 1) + self.assertIn("but src/range.cppm imports it", + self.check(["core"], ["core"])[0]) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_gen_exports_newlines.py b/tools/tests/test_gen_exports_newlines.py index 60131383b..33c6e7a22 100644 --- a/tools/tests/test_gen_exports_newlines.py +++ b/tools/tests/test_gen_exports_newlines.py @@ -38,8 +38,9 @@ def test_export_and_dependency_files(self): "qname": "boost::example", "ns": ["boost"]}, } self.assertEqual(gen_exports.emit_inc( - "example", records, self.root, False, {}, extra_deps=["core"]), - (1, ["core"])) + "example", records, self.root, {}, gen_exports.Policy({}), + extra_deps=["core"]), + (1, ["core"], [])) self.assertIn(b" using boost::example;\n", self.assert_lf("generated/exports/example.inc")) self.assertEqual(self.assert_lf("generated/exports/example.deps"), @@ -59,11 +60,22 @@ def test_body_dependency_merge(self): prefix = gen_exports.bc.MODULE_PREFIX (deps / "example.deps").write_bytes((prefix + ".core\n").encode()) added = gen_exports.merge_body_edges( - self.root, ["example"], {"example": {"system": ["reference"]}}) + self.root, ["example"], {"example": {"system": ["reference"]}}, + gen_exports.Policy({})) self.assertEqual(added, {"example": {"system": 1}}) self.assertEqual(self.assert_lf("generated/exports/example.deps"), (prefix + ".core\n" + prefix + ".system\n").encode()) + def test_meta_files(self): + with mock.patch.object(gen_exports.aj, "clang_release", + return_value="23.1.3"): + gen_exports.write_meta( + self.root, {"example": {"exported": 1, "deps": [], "gmf": []}}, + [("example", "guard", "boost::x", "defined(_WIN32)", "why")]) + self.assert_lf("generated/meta/api-surface.json") + self.assertIn(b"example guard boost::x if defined(_WIN32) -- why\n", + self.assert_lf("generated/meta/skipped.txt")) + def test_scanned_metadata(self): output = self.root / "libs.json" with mock.patch.object(gen_exports.bc, "LIBS_JSON", output), \ diff --git a/tools/tests/test_libclang_setup.py b/tools/tests/test_libclang_setup.py deleted file mode 100644 index dac2d2d36..000000000 --- a/tools/tests/test_libclang_setup.py +++ /dev/null @@ -1,153 +0,0 @@ -"""Regression tests for selecting the AST parser, not just the clang++ gate.""" -import os -import sys -import tempfile -import types -import unittest -from pathlib import Path -from unittest import mock - -import boost_common as bc -import gen_exports - - -class LibclangSetupTests(unittest.TestCase): - def setUp(self): - self.tmp = tempfile.TemporaryDirectory() - self.addCleanup(self.tmp.cleanup) - self.root = Path(self.tmp.name) - self.ci = types.ModuleType("clang.cindex") - self.ci.Config = mock.Mock(library_file=None, library_path=None) - self.ci.Index = mock.Mock() - clang = types.ModuleType("clang") - clang.cindex = self.ci - patcher = mock.patch.dict(sys.modules, { - "clang": clang, "clang.cindex": self.ci, - }) - patcher.start() - self.addCleanup(patcher.stop) - patcher = mock.patch.dict(os.environ, {}, clear=True) - patcher.start() - self.addCleanup(patcher.stop) - - def file(self, rel): - path = self.root / rel - path.parent.mkdir(parents=True, exist_ok=True) - path.touch() - return path - - def test_explicit_library_file_wins(self): - library = self.file("custom/libclang.so") - os.environ["LIBCLANG_PATH"] = str(library) - os.environ["LLVM_PATH"] = str(self.root / "other-llvm") - with mock.patch("shutil.which") as which: - self.assertIs(bc.load_libclang(), self.ci) - self.ci.Config.set_library_file.assert_called_once_with(str(library)) - self.ci.Index.create.assert_not_called() - which.assert_not_called() - - def test_explicit_library_directory(self): - library = self.file("custom/libclang.dylib") - os.environ["LIBCLANG_PATH"] = str(library.parent) - bc.load_libclang() - self.ci.Config.set_library_file.assert_called_once_with(str(library)) - - def test_llvm_path_accepts_installation_prefix(self): - library = self.file("llvm/lib/libclang.so.23.1.3") - os.environ["LLVM_PATH"] = str(self.root / "llvm") - bc.load_libclang() - self.ci.Config.set_library_file.assert_called_once_with(str(library)) - - def test_windows_prefix_uses_bin(self): - library = self.file("llvm/bin/libclang.dll") - os.environ["LLVM_PATH"] = str(self.root / "llvm") - bc.load_libclang() - self.ci.Config.set_library_file.assert_called_once_with(str(library)) - - def test_invalid_prefix_does_not_fall_back_to_wheel(self): - os.environ["LLVM_PATH"] = str(self.root) - with self.assertRaisesRegex(RuntimeError, "libclang not found under"): - bc.load_libclang() - self.ci.Index.create.assert_not_called() - - def test_cxx_library_precedes_bundled_libclang(self): - driver = self.file("llvm/bin/clang++") - library = self.file("llvm/lib/libclang.so") - os.environ["CXX"] = str(driver) - with mock.patch("shutil.which", return_value=str(driver)) as which: - bc.load_libclang() - which.assert_called_once_with(str(driver)) - self.ci.Config.set_library_file.assert_called_once_with(str(library.resolve())) - self.ci.Index.create.assert_not_called() - - def test_path_driver_symlink_resolves_to_full_installation(self): - driver = self.file("llvm/bin/clang++") - library = self.file("llvm/lib/libclang.dylib") - shim = self.root / "clang++" - try: - shim.symlink_to(driver) - except OSError: - self.skipTest("symlink creation is not available") - with mock.patch("shutil.which", return_value=str(shim)) as which: - bc.load_libclang() - which.assert_called_once_with("clang++") - self.ci.Config.set_library_file.assert_called_once_with(str(library.resolve())) - - def test_driver_under_symlinked_prefix_uses_canonical_library_path(self): - # Reproduce macOS /var -> /private/var even on a Linux test host. - # - # macOS resolves `/var` through `/private/var`. Driver-discovery tests must - # expect canonical library paths, matching production's `Path.resolve()`. - # A directory-symlink regression test reproduces this on Linux as well. - driver = self.file("real-llvm/bin/clang++") - library = self.file("real-llvm/lib/libclang.dylib") - prefix = self.root / "linked-llvm" - try: - prefix.symlink_to(driver.parent.parent, target_is_directory=True) - except OSError: - self.skipTest("directory symlink creation is not available") - linked_driver = prefix / "bin" / "clang++" - with mock.patch("shutil.which", return_value=str(linked_driver)): - bc.load_libclang() - self.ci.Config.set_library_file.assert_called_once_with(str(library.resolve())) - - def test_not_confused_with_clang_cpp_or_compiler_rt(self): - self.file("lib/libclang-cpp.so.23.1") - self.file("lib/libclang_rt.asan.so") - self.assertIsNone(bc._libclang_in_installation(self.root)) - - def test_bundled_fallback_without_native_library(self): - with mock.patch("shutil.which", return_value=None): - bc.load_libclang() - self.ci.Index.create.assert_called_once_with() - self.ci.Config.set_library_file.assert_not_called() - - def test_missing_builtins_fail_before_generating_incomplete_ast(self): - self.ci.Config.library_file = str(self.file("wheel/libclang.so")) - with mock.patch.object(bc, "CLANG_ARGS", []): - with self.assertRaisesRegex(RuntimeError, "builtin headers not found"): - bc._append_resource_dir() - - def test_native_builtin_headers_are_found_once(self): - self.ci.Config.library_file = str(self.file("llvm/lib/libclang.so.23")) - header = self.file("llvm/lib/clang/23/include/stddef.h") - with mock.patch.object(bc, "CLANG_ARGS", []): - bc._append_resource_dir() - bc._append_resource_dir() - self.assertEqual(bc.CLANG_ARGS, ["-I" + str(header.parent)]) - - def test_invalid_explicit_resource_dir_fails(self): - os.environ["CLANG_RESOURCE_DIR"] = str(self.root) - with self.assertRaisesRegex(RuntimeError, "does not contain clang builtin"): - bc._append_resource_dir() - - def test_cache_key_includes_ast_parser_version(self): - with mock.patch.object(bc, "libclang_version", return_value="clang 18"): - old = gen_exports._skip_key("atomic", [], {}, ["atomic"], False, False) - with mock.patch.object(bc, "libclang_version", return_value="clang 23"): - new = gen_exports._skip_key("atomic", [], {}, ["atomic"], False, False) - self.assertNotEqual(old, new) - - -if __name__ == "__main__": - unittest.main() diff --git a/tools/tests/test_reapply_hand_edits.py b/tools/tests/test_reapply_hand_edits.py deleted file mode 100644 index aea6eac40..000000000 --- a/tools/tests/test_reapply_hand_edits.py +++ /dev/null @@ -1,85 +0,0 @@ -"""Module-side patches must replay over the current generator's drafts.""" -import subprocess -import tempfile -import unittest -from pathlib import Path -from unittest import mock - -import gen_exports -import reapply_hand_edits - - -class ModulePatchTests(unittest.TestCase): - def test_regenerated_patches_are_idempotent(self): - for lib in ("winapi", "cobalt", "safe_numerics", "stacktrace"): - with self.subTest(lib=lib): - self.check_regenerated_patch(lib) - - def check_regenerated_patch(self, lib): - name = "safe_numerics_src" if lib == "safe_numerics" else lib - with tempfile.TemporaryDirectory() as tmp: - root = Path(tmp) - (root / "src").mkdir() - (root / "patches").mkdir() - patch = reapply_hand_edits.PATCH_DIR / (name + ".patch") - (root / "patches" / patch.name).write_bytes(patch.read_bytes()) - deps = root / "generated/exports" - deps.mkdir(parents=True) - (deps / (lib + ".deps")).write_bytes( - (gen_exports.bc.GEN_DIR / (lib + ".deps")).read_bytes()) - headers = gen_exports.bc.gfm_headers_of(lib) - # The clang++ gate removes this non-self-contained header before - # emitting the safe_numerics draft in the full generation pass. - if lib == "safe_numerics": - headers = [h for h in headers if h.name != "range_value.hpp"] - gen_exports.emit_cppm(lib, root, gfm_headers=headers) - output = root / "src" / (lib + ".cppm") - expected = (gen_exports.bc.ROOT / "src" / output.name).read_bytes() - - # Require git apply to work without relying on patch(1)'s fuzz or - # its availability on the host. The second pass must reverse-check. - with mock.patch.object(reapply_hand_edits, "ROOT", root), \ - mock.patch("subprocess.run", wraps=subprocess.run) as run: - reapply_hand_edits.apply_patch_file(name) - self.assertEqual(output.read_bytes(), expected) - reapply_hand_edits.apply_patch_file(name) - self.assertEqual(output.read_bytes(), expected) - self.assertTrue(all(call.args[0][0] == "git" - for call in run.call_args_list)) - self.assertEqual(sorted(p.name for p in (root / "src").iterdir()), - [output.name]) - - def test_windows_checkout_preserves_generation_bytes(self): - # Exercise Git's actual Windows-style checkout conversion on every OS. - paths = ( - "patches/winapi.patch", "src/winapi.cppm", - "generated/exports/winapi.inc", "generated/exports/winapi.deps", - "patches/final/generated/exports/algorithm.inc", - ) - with tempfile.TemporaryDirectory() as tmp: - root = Path(tmp) - - def git(*args): - return subprocess.run( - ["git", "-c", "core.autocrlf=true", *args], cwd=root, - capture_output=True, check=True) - - git("init") - (root / ".gitattributes").write_bytes( - (gen_exports.bc.ROOT / ".gitattributes").read_bytes()) - for rel in paths: - dst = root / rel - dst.parent.mkdir(parents=True, exist_ok=True) - dst.write_bytes((gen_exports.bc.ROOT / rel).read_bytes()) - git("add", ".") - for rel in paths: - (root / rel).unlink() - git("checkout-index", "--all", "--force") - for rel in paths: - with self.subTest(path=rel): - self.assertEqual((root / rel).read_bytes(), - (gen_exports.bc.ROOT / rel).read_bytes()) - - -if __name__ == "__main__": - unittest.main() diff --git a/tools/uv.lock b/tools/uv.lock index 3295774c0..dde48cbee 100644 --- a/tools/uv.lock +++ b/tools/uv.lock @@ -1,31 +1,8 @@ version = 1 revision = 5 -requires-python = ">=3.9" +requires-python = ">=3.11" [[package]] name = "boost-m-tools" version = "0.1.0" source = { virtual = "." } -dependencies = [ - { name = "libclang" }, -] - -[package.metadata] -requires-dist = [{ name = "libclang" }] - -[[package]] -name = "libclang" -version = "18.1.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6e/5c/ca35e19a4f142adffa27e3d652196b7362fa612243e2b916845d801454fc/libclang-18.1.1.tar.gz", hash = "sha256:a1214966d08d73d971287fc3ead8dfaf82eb07fb197680d8b3859dbbbbf78250", size = 39612, upload-time = "2024-03-17T16:04:37.434Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/4b/49/f5e3e7e1419872b69f6f5e82ba56e33955a74bd537d8a1f5f1eff2f3668a/libclang-18.1.1-1-py2.py3-none-macosx_11_0_arm64.whl", hash = "sha256:0b2e143f0fac830156feb56f9231ff8338c20aecfe72b4ffe96f19e5a1dbb69a", size = 25836045, upload-time = "2024-06-30T17:40:31.646Z" }, - { url = "https://files.pythonhosted.org/packages/e2/e5/fc61bbded91a8830ccce94c5294ecd6e88e496cc85f6704bf350c0634b70/libclang-18.1.1-py2.py3-none-macosx_10_9_x86_64.whl", hash = "sha256:6f14c3f194704e5d09769108f03185fce7acaf1d1ae4bbb2f30a72c2400cb7c5", size = 26502641, upload-time = "2024-03-18T15:52:26.722Z" }, - { url = "https://files.pythonhosted.org/packages/db/ed/1df62b44db2583375f6a8a5e2ca5432bbdc3edb477942b9b7c848c720055/libclang-18.1.1-py2.py3-none-macosx_11_0_arm64.whl", hash = "sha256:83ce5045d101b669ac38e6da8e58765f12da2d3aafb3b9b98d88b286a60964d8", size = 26420207, upload-time = "2024-03-17T15:00:26.63Z" }, - { url = "https://files.pythonhosted.org/packages/1d/fc/716c1e62e512ef1c160e7984a73a5fc7df45166f2ff3f254e71c58076f7c/libclang-18.1.1-py2.py3-none-manylinux2010_x86_64.whl", hash = "sha256:c533091d8a3bbf7460a00cb6c1a71da93bffe148f172c7d03b1c31fbf8aa2a0b", size = 24515943, upload-time = "2024-03-17T16:03:45.942Z" }, - { url = "https://files.pythonhosted.org/packages/3c/3d/f0ac1150280d8d20d059608cf2d5ff61b7c3b7f7bcf9c0f425ab92df769a/libclang-18.1.1-py2.py3-none-manylinux2014_aarch64.whl", hash = "sha256:54dda940a4a0491a9d1532bf071ea3ef26e6dbaf03b5000ed94dd7174e8f9592", size = 23784972, upload-time = "2024-03-17T16:12:47.677Z" }, - { url = "https://files.pythonhosted.org/packages/fe/2f/d920822c2b1ce9326a4c78c0c2b4aa3fde610c7ee9f631b600acb5376c26/libclang-18.1.1-py2.py3-none-manylinux2014_armv7l.whl", hash = "sha256:cf4a99b05376513717ab5d82a0db832c56ccea4fd61a69dbb7bccf2dfb207dbe", size = 20259606, upload-time = "2024-03-17T16:17:42.437Z" }, - { url = "https://files.pythonhosted.org/packages/2d/c2/de1db8c6d413597076a4259cea409b83459b2db997c003578affdd32bf66/libclang-18.1.1-py2.py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:69f8eb8f65c279e765ffd28aaa7e9e364c776c17618af8bff22a8df58677ff4f", size = 24921494, upload-time = "2024-03-17T16:14:20.132Z" }, - { url = "https://files.pythonhosted.org/packages/0b/2d/3f480b1e1d31eb3d6de5e3ef641954e5c67430d5ac93b7fa7e07589576c7/libclang-18.1.1-py2.py3-none-win_amd64.whl", hash = "sha256:4dd2d3b82fab35e2bf9ca717d7b63ac990a3519c7e312f19fa8e86dcc712f7fb", size = 26415083, upload-time = "2024-03-17T16:42:21.703Z" }, - { url = "https://files.pythonhosted.org/packages/71/cf/e01dc4cc79779cd82d77888a88ae2fa424d93b445ad4f6c02bfc18335b70/libclang-18.1.1-py2.py3-none-win_arm64.whl", hash = "sha256:3f0e1f49f04d3cd198985fea0511576b0aee16f9ff0e0f0cad7f9c57ec3c20e8", size = 22361112, upload-time = "2024-03-17T16:42:59.565Z" }, -]