@@ -243,6 +243,57 @@ limit, and the second names `xcode-27` and reads
 version 21.0.0` with `ImageOS=macos27` (run on 2026-09-16T19:16Z). Because the label names an Xcode and its
 base OS has changed once, every macOS 27 leg asserts that `sw_vers` reports 27.
 
+## 5.2 The first macOS 27 run: the std module does not build
+
+Both macOS 27 legs failed on their first run (runs 35139712291 and
+35139712295): the std module precompile with llvm 22.1.8 stops at
+`<complex>:1012: use of undeclared identifier 'INFINITY'` (14 errors), in the
+raw clang step and in mcpp's own std module build. The maintainer asked for the
+fix in the same pull request, with the host kept to the minimum. Three probe
+rounds on the `xcode-27` image (#659) read:
+
+- The 27.0 SDK's `<math.h>` defines `INFINITY` and `NAN` itself only when
+  `__has_feature(modules)` is false; with modules on it includes `<float.h>`
+  with `__need_infinity_nan` and expects the compiler's header to supply them.
+- A module interface unit has `__has_feature(modules)` true; a plain unit does
+  not.
+- `-std=c++23` and `-std=c++26` fail; `-std=gnu++23`, `-U__STRICT_ANSI__`, the
+  26.5 SDK, `-D__need_infinity_nan`, and `-DINFINITY=HUGE_VALF
+  -DNAN=__builtin_nanf("0x7fc00000")` build. `-fbuiltin-headers-in-system-modules`
+  and `-fno-implicit-module-maps` do not.
+- The CLT SDK and the Xcode SDK on the image are the same 27.0 SDK, so the
+  sysroot choice is not the cause.
+
+Adopted: `apple_float_macro_words` (hostflags.cppm) states the two macros with
+the SDK's own GNU-mode spellings for clang on an Apple target. The alternatives
+were rejected on their effect beyond the defect: `gnu++23` changes the language
+dialect of every unit, `-U__STRICT_ANSI__` exposes non-standard declarations of
+the C library, and `-D__need_infinity_nan` makes the first inclusion of
+`<float.h>` supply only the two macros, so a unit that includes it once loses
+`FLT_MAX` (clang's `float.h` lines 15-46). The identical spellings make the
+redefinition in the SDK's non-module path silent; plain C and C++ units
+including `<math.h>`, `<cmath>`, `<float.h>` and `<cfloat>` build with
+`-Wall -Werror` on the 27.0 SDK. The value holds quotes and parentheses, so the
+decision is a list of words and each reader quotes it: the ninja compile flags
+(`ninja_command_word`), the std module command (single quotes), the
+graph-supplied std module flags (`shq`) and a build program's argv (none). The
+decision reads the target triple only; it reads nothing from the host.
+
+The same round found two host-shaped test defects on the Windows runner of the
+first push, both in this pull request's own code: `normalize_include_flags`
+wrote every word back through `flag_element`, which quoted any backslash, so
+Windows paths came back single-quoted; and two `split_flags` tests assumed
+POSIX quoting on every host. `flag_element` now quotes a backslash only where
+the syntax would read it as an escape, an element whose words did not change
+keeps its spelling, and the POSIX-quoting tests are POSIX-only with a Windows
+counterpart.
+
+It also found a compatibility defect of the syntax itself: `NinjaBackend.
+QuotesFlagValueWithSpace` (mcpp#234) failed, because `-DT=long long` read as
+two words. Every release since #234 passed such an element as one argument, so
+the syntax gained one exception (SPEC-004 §8 rule 8): an element that begins
+with `-D` or `/D` and contains a space is one word, verbatim.
+
 ## 8. Residuals
 
 - `ldflags`, `dialect_cxxflags` and `std-module-flags` keep their current
 
@@ -72,6 +72,15 @@ jobs:
           echo "=== Module manifest ==="
           "$CXX" -print-library-module-manifest-path 2>/dev/null || echo "(not available)"
 
+      # THE TWO FLOATING MACROS mcpp STATES FOR AN APPLE TARGET
+      # (src/toolchain/hostflags.cppm, apple_float_macro_words). The macOS 27
+      # SDK leaves INFINITY and NAN to <float.h> once modules are on, and clang
+      # 22's header does not supply them in a -std=c++23 compile, so these raw
+      # compiles state them the way mcpp does. Unquoted words with no spaces, so
+      # plain word splitting of the variable is exact.
+      - name: The floating macros mcpp states for an Apple target
+        run: echo 'APPLE_FLOAT_MACROS=-DINFINITY=HUGE_VALF -DNAN=__builtin_nanf("0x7fc00000")' >> "$GITHUB_ENV"
+
       - name: Test — non-module C++23 compilation
         run: |
           WORK=$(mktemp -d)
@@ -84,7 +93,7 @@ jobs:
               return 0;
           }
           EOF
-          "$CXX" -std=c++23 -o hello main.cpp
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS -o hello main.cpp
           ./hello
 
       - name: Test — import std (two-stage module compilation)
@@ -103,11 +112,11 @@ jobs:
 
           echo "=== Step 1: Precompile std module ==="
           mkdir -p pcm.cache
-          "$CXX" -std=c++23 -Wno-reserved-module-identifier \
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS -Wno-reserved-module-identifier \
             --precompile "$STD_CPPM" -o pcm.cache/std.pcm
 
           echo "=== Step 2: Compile std.pcm → std.o ==="
-          "$CXX" -std=c++23 -Wno-reserved-module-identifier \
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS -Wno-reserved-module-identifier \
             pcm.cache/std.pcm -c -o std.o
 
           echo "=== Step 3: Compile main.cpp with import std ==="
@@ -118,7 +127,7 @@ jobs:
               return 0;
           }
           EOF
-          "$CXX" -std=c++23 -fmodule-file=std=pcm.cache/std.pcm -c main.cpp -o main.o
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS -fmodule-file=std=pcm.cache/std.pcm -c main.cpp -o main.o
 
           echo "=== Step 4: Link ==="
           "$CXX" main.o std.o -o hello_modules
@@ -141,16 +150,16 @@ jobs:
 
           mkdir -p pcm.cache
           # Build std first
-          "$CXX" -std=c++23 -Wno-reserved-module-identifier \
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS -Wno-reserved-module-identifier \
             --precompile "$STD_CPPM" -o pcm.cache/std.pcm
-          "$CXX" -std=c++23 -Wno-reserved-module-identifier \
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS -Wno-reserved-module-identifier \
             pcm.cache/std.pcm -c -o std.o
 
           # Build std.compat (depends on std)
-          "$CXX" -std=c++23 -Wno-reserved-module-identifier \
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS -Wno-reserved-module-identifier \
             -fmodule-file=std=pcm.cache/std.pcm \
             --precompile "$STD_COMPAT_CPPM" -o pcm.cache/std.compat.pcm
-          "$CXX" -std=c++23 -Wno-reserved-module-identifier \
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS -Wno-reserved-module-identifier \
             -fmodule-file=std=pcm.cache/std.pcm \
             pcm.cache/std.compat.pcm -c -o std.compat.o
 
@@ -162,7 +171,7 @@ jobs:
               return 0;
           }
           EOF
-          "$CXX" -std=c++23 \
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS \
             -fmodule-file=std=pcm.cache/std.pcm \
             -fmodule-file=std.compat=pcm.cache/std.compat.pcm \
             -c main.cpp -o main.o
@@ -178,9 +187,9 @@ jobs:
           mkdir -p pcm.cache
 
           # Build std
-          "$CXX" -std=c++23 -Wno-reserved-module-identifier \
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS -Wno-reserved-module-identifier \
             --precompile "$STD_CPPM" -o pcm.cache/std.pcm
-          "$CXX" -std=c++23 -Wno-reserved-module-identifier \
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS -Wno-reserved-module-identifier \
             pcm.cache/std.pcm -c -o std.o
 
           # User module: greeter
@@ -193,9 +202,9 @@ jobs:
               }
           }
           EOF
-          "$CXX" -std=c++23 -fmodule-file=std=pcm.cache/std.pcm \
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS -fmodule-file=std=pcm.cache/std.pcm \
             --precompile greeter.cppm -o pcm.cache/greeter.pcm
-          "$CXX" -std=c++23 -fmodule-file=std=pcm.cache/std.pcm \
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS -fmodule-file=std=pcm.cache/std.pcm \
             pcm.cache/greeter.pcm -c -o greeter.o
 
           # Main
@@ -207,7 +216,7 @@ jobs:
               return 0;
           }
           EOF
-          "$CXX" -std=c++23 \
+          "$CXX" -std=c++23 $APPLE_FLOAT_MACROS \
             -fmodule-file=std=pcm.cache/std.pcm \
             -fmodule-file=greeter=pcm.cache/greeter.pcm \
             -c main.cpp -o main.o
 
@@ -29,6 +29,12 @@ libarchive、bzip2、lz4、xz、zlib 与 zstd 的每个 C 文件都无法解析
   这样的元素。
 - Windows 上 `shell_quote_arg` 按 MSVCRT 规则加倍引号前与结尾处的反斜杠,以 `\` 结尾的
   词不再吞掉闭合引号。
+- **macOS 27 上 `import std` 可以构建。** 27.0 SDK 的 `<math.h>` 在模块开启时把 `INFINITY` 与
+  `NAN` 交给 `<float.h>`,而 clang 22 的头在 `-std=c++23` 下不提供它们,std 模块预编译因此失败
+  (`<complex>:1012: use of undeclared identifier 'INFINITY'`)。对 Apple 目标上的 clang,mcpp 以
+  SDK 自身的拼写陈述这两个宏(`-DINFINITY=HUGE_VALF -DNAN=__builtin_nanf("0x7fc00000")`),
+  普通单元中的重定义逐词相同,不产生警告。判据只读目标三元组。
+- **以 `-D` 或 `/D` 开头且含空格的元素仍是一个参数**,按原样传入,与 mcpp#234 以来各版本相同。
 - **CI 覆盖 macOS 27。** `ci-macos` 与 `ci-macos-e2e` 在 `macos-15` 与 macOS 27 上各跑一遍,
   `ci-fresh-install` 的 xlings 与 Homebrew 两条安装渠道在 `macos-14` 与 macOS 27 上各跑一遍。
   GitHub 以预览标签 `xcode-27` 提供 macOS 27(无 `macos-27` 标签),每条 macOS 27 的腿断言
 
@@ -430,7 +430,8 @@ written: `[build]`, `[targets.<name>]`, a `flags` glob entry, a feature, a
 |---|---|
 | `"-O2 -g"` | `-O2`, `-g` |
 | `"-include config.h"` | `-include`, `config.h` |
-| `"'-DNAME=a b'"` or `"-DNAME=\"a b\""` | `-DNAME=a b` |
+| `"'-DNAME=a b'"` or `"-I\"my dir\""` | `-DNAME=a b`, `-Imy dir` |
+| `"-DNAME=long long"` | `-DNAME=long long` (see below) |
 | `"-DNAME=\\\"text\\\""` | `-DNAME="text"` (a string literal) |
 | `"-I/opt/my\\ dir/include"` | `-I/opt/my dir/include` |
 | `"-IC:\\sdk\\include"` | `-IC:\sdk\include` |
@@ -445,7 +446,9 @@ escapes):
 - outside quotes, a backslash before a space, a tab, `"`, `'` or `\` stands for
   that character; any other backslash is literal;
 - quoted and unquoted pieces that touch form one word;
-- `$`, `*`, `;`, `|` and the other shell operators have no meaning.
+- `$`, `*`, `;`, `|` and the other shell operators have no meaning;
+- an element that begins with `-D` or `/D` and contains a space is one word,
+  taken verbatim, as in every earlier release.
 
 A `defines` entry is one value and is not read by this syntax: `defines =
 ["NAME=\"text\""]` passes the single word `-DNAME="text"`. `ldflags`,
 
@@ -352,6 +352,8 @@ feature、`[profile.<n>]`、`[target.<selector>.build]`、xpkg 描述符,以及
 6. 未闭合的引号区域延伸到元素末尾。
 7. 除上述字符外,任何字符没有特殊含义;实现**禁止**对 `$`、`*`、`?`、`;`、`|`、`&`、`<`、
    `>`、`` ` ``、`~` 做展开或解释。
+8. 例外:以 `-D` 或 `/D` 开头且含空格(U+0020)的元素代表一个词,即元素文本本身,规则 1 至 7
+   不适用。自 mcpp#234 起,每个版本在宿主读取之前都把这样的元素整体加引号,该例外保持其含义不变。
 
 `defines` 的一个条目 `X` 是一个值:它代表一个词 `-D` 与 `X` 的拼接,**禁止**按上述规则
 读取。实现向这三个列表插入一个词 `w` 时,**必须**使用一个按上述规则读回恰为 `w` 的拼写。
 
@@ -382,7 +382,8 @@ glob 条目、feature、`[target.<selector>.build]`、xpkg 描述符,以及构
 |---|---|
 | `"-O2 -g"` | `-O2`、`-g` |
 | `"-include config.h"` | `-include`、`config.h` |
-| `"'-DNAME=a b'"` 或 `"-DNAME=\"a b\""` | `-DNAME=a b` |
+| `"'-DNAME=a b'"` 或 `"-I\"my dir\""` | `-DNAME=a b`、`-Imy dir` |
+| `"-DNAME=long long"` | `-DNAME=long long`(见下) |
 | `"-DNAME=\\\"text\\\""` | `-DNAME="text"`(字符串字面量) |
 | `"-I/opt/my\\ dir/include"` | `-I/opt/my dir/include` |
 | `"-IC:\\sdk\\include"` | `-IC:\sdk\include` |
@@ -395,7 +396,8 @@ glob 条目、feature、`[target.<selector>.build]`、xpkg 描述符,以及构
 - `"..."` 按字面取,只有 `\"` 与 `\\` 分别代表 `"` 与 `\`;
 - 引号之外,反斜杠后跟空格、制表符、`"`、`'` 或 `\` 时代表该字符,其余反斜杠按字面;
 - 相邻的带引号与不带引号的片段组成一个词;
-- `$`、`*`、`;`、`|` 等 shell 运算符没有特殊含义。
+- `$`、`*`、`;`、`|` 等 shell 运算符没有特殊含义;
+- 以 `-D` 或 `/D` 开头且含空格的元素是一个词,按原样取,与此前各版本相同。
 
 `defines` 的一个条目是一个值,不按此写法读取:`defines = ["NAME=\"text\""]` 传入的是
 一个词 `-DNAME="text"`。`ldflags`、`dialect_cxxflags` 与 `std-module-flags` 不在本节范围内。
 
@@ -27,10 +27,17 @@
 //   - outside quotes, a backslash before a space, a tab, `"`, `'` or `\`
 //     stands for that character, and any other backslash is literal;
 //   - quoted and unquoted pieces that touch form one word, so `""` is an
-//     empty word and `-DV="a b"` is the single word `-DV=a b`.
+//     empty word and `-I"my dir"` is the single word `-Imy dir`.
 //
-// `$`, `*`, `;` and the other shell operators have no meaning. The one
-// spelling the published index relies on, libarchive's
+// `$`, `*`, `;` and the other shell operators have no meaning.
+//
+// ONE EXCEPTION, KEPT FOR COMPATIBILITY. An element that begins with `-D` or
+// `/D` and contains a space is one word, taken verbatim. Every release since
+// mcpp#234 quoted such an element whole before the host read it, so
+// `-DT=long long` has always been the single argument `-DT=long long` on every
+// host; reading it as two words would change working manifests.
+//
+// The one spelling the published index relies on, libarchive's
 // `-DPLATFORM_CONFIG_H=\"mcpp_libarchive_config.h\"`, reads as the word
 // `-DPLATFORM_CONFIG_H="mcpp_libarchive_config.h"`, which is what both hosts
 // passed before. pkg-config's `\ ` for a space in a path reads as a space.
@@ -81,6 +88,8 @@ bool escapable_outside_quotes(char c) {
 }  // namespace
 
 std::vector<std::string> flag_words(std::string_view s) {
+    if ((s.starts_with("-D") || s.starts_with("/D")) && s.find(' ') != std::string_view::npos)
+        return {std::string(s)};
     std::vector<std::string> out;
     std::string word;
     bool started = false;
@@ -125,8 +134,17 @@ std::vector<std::string> flag_words(const std::vector<std::string>& elements) {
 }
 
 std::string flag_element(std::string_view word) {
-    const bool plain = !word.empty()
-        && word.find_first_of(" \t\"'\\") == std::string_view::npos;
+    // A word with a space that begins with -D or /D is its own element (the
+    // exception above); quoting it as well would be equally correct, and
+    // leaving it keeps the spelling every release wrote.
+    if ((word.starts_with("-D") || word.starts_with("/D")) && word.find(' ') != std::string_view::npos)
+        return std::string(word);
+    // Plain means the syntax reads the word back unchanged: no blank, no
+    // quote, and no backslash in front of a character it would escape. A
+    // Windows path (`C:\sdk\include`) is plain and keeps its spelling.
+    bool plain = !word.empty() && word.find_first_of(" \t\"'") == std::string_view::npos;
+    for (std::size_t i = 0; plain && i + 1 < word.size(); ++i)
+        if (word[i] == '\\' && escapable_outside_quotes(word[i + 1])) plain = false;
     if (plain) return std::string(word);
     // Single quotes hold everything except `'`, which closes the region, is
     // written as an escaped quote outside it, and reopens it.
 
@@ -23,15 +23,22 @@ TEST(FlagWords, TheSyntaxTable) {
         // Quotes inside a word are quoting, as in `sh`.
         {R"(-DMID="mid")", {"-DMID=mid"}},
         {"-DSQ='sq'", {"-DSQ=sq"}},
-        {R"(-DV="a b")", {"-DV=a b"}},
         {"'-DV=a b'", {"-DV=a b"}},
+        // The compatibility exception: a -D or /D element with a space is one
+        // word, verbatim (mcpp#234), quotes and backslashes included.
+        {"-DT=long long", {"-DT=long long"}},
+        {R"(-DV="a b")", {R"(-DV="a b")"}},
+        {"/DV=a b", {"/DV=a b"}},
+        {"-DA=1 -DB=2", {"-DA=1 -DB=2"}},
         // compat.lua's descriptor: one element, two words.
         {"-include mcpp_lua_platform_config.h", {"-include", "mcpp_lua_platform_config.h"}},
         // pkg-config writes a space in a path as `\ `.
         {R"(-I/opt/my\ dir/include)", {"-I/opt/my dir/include"}},
         // A backslash before an ordinary character is literal: Windows paths.
         {R"(-IC:\Users\x\include)", {R"(-IC:\Users\x\include)"}},
         {R"("-IC:\Program Files\x")", {R"(-IC:\Program Files\x)"}},
+        // Without a space the syntax applies to a -D element as to any other.
+        {R"(-DV="mid")", {"-DV=mid"}},
         // Escapes a backslash can make outside and inside double quotes.
         {R"(-DV=a\\b)", {R"(-DV=a\b)"}},
         {R"("a\"b\\c\d")", {R"(a"b\c\d)"}},
@@ -49,7 +56,7 @@ TEST(FlagWords, TheSyntaxTable) {
         {"''", {""}},
         {R"(-DV="")", {"-DV="}},
         // An unterminated quote extends to the end of the element.
-        {R"(-DV="a b)", {"-DV=a b"}},
+        {R"(-I"a b)", {"-Ia b"}},
         // A trailing backslash has nothing to escape.
         {R"(-DV=a\)", {R"(-DV=a\)"}},
     };
@@ -58,22 +65,24 @@ TEST(FlagWords, TheSyntaxTable) {
 }
 
 TEST(FlagWords, AListIsTheConcatenationOfItsElements) {
-    const std::vector<std::string> list{"-include x.h", R"(-DV="a b")", "", "-O2"};
-    EXPECT_EQ(flag_words(list), (Words{"-include", "x.h", "-DV=a b", "-O2"}));
+    const std::vector<std::string> list{"-include x.h", R"(-I"my dir")", "", "-O2"};
+    EXPECT_EQ(flag_words(list), (Words{"-include", "x.h", "-Imy dir", "-O2"}));
 }
 
 TEST(FlagWords, APlainWordIsItsOwnElement) {
-    for (std::string_view w : {"-O2", "-DV=1", "-IC:/x", "/std:c++latest", "-Wl,-z,defs", "$x"})
+    for (std::string_view w : {"-O2", "-DV=1", "-IC:/x", "/std:c++latest", "-Wl,-z,defs", "$x",
+                               R"(-IC:\sdk\include)", R"(C:\dir\)"})
         EXPECT_EQ(flag_element(w), w);
 }
 
 // The property the engine relies on when it inserts a value into a flag list:
 // the element it writes reads back as exactly that one word.
 TEST(FlagWords, AnElementReadsBackAsItsWord) {
     Words words{"", " ", "a b", "'", "\"", "\\", "a\\", "\\\\srv\\share", "it's",
-                "-DV=\"def\"", "-DV='c'", "x\ty", "a\"b'c\\d e"};
+                "-DV=\"def\"", "-DV='c'", "x\ty", "a\"b'c\\d e", "-DT=long long",
+                "-DV=\"a b\"", "/DV=x y"};
     // A deterministic walk over the characters the syntax gives meaning to.
-    const std::string alphabet = "ab \t\"'\\$";
+    const std::string alphabet = "ab \t\"'\\$-D";
     std::uint32_t state = 655;
     for (int n = 0; n < 2000; ++n) {
         std::string w;
 
@@ -509,6 +509,7 @@ std::vector<std::string> host_base_flags(const mcpp::toolchain::Toolchain& tc,
 
     const mcpp::toolchain::PathEscape plain = mcpp::toolchain::no_escape;
     auto f = mcpp::toolchain::host_compile_tokens(tc, opt, plain);
+    for (auto& w : mcpp::toolchain::apple_float_macro_words(tc)) f.push_back(std::move(w));
     for (auto& t : mcpp::toolchain::host_link_tokens(tc, opt, plain))
         f.push_back(t);
     return f;
 
@@ -741,6 +741,8 @@ CompileFlags compute_flags(const BuildPlan& plan) {
         hopt.appleSdkCxxHeaders = plan.toolchain.appleSdkCxxHeaders;
         compile_toolchain_flags = mcpp::toolchain::render_tokens(
             mcpp::toolchain::host_compile_tokens(plan.toolchain, hopt, ninjaEsc));
+        for (auto const& w : mcpp::toolchain::apple_float_macro_words(plan.toolchain))
+            compile_toolchain_flags += " " + ninja_command_word(w);
     } else {
         // Skipped entirely, not filtered. What this block emits is the
         // HOST's world reconstructed by hand — libc++'s headers, glibc's