Change spelling of toolchain template args

src/dds/toolchain/from_json.cpp

             if (lang == language::cxx) {
                 extend(ret, {"/EHsc"});
             }
-            extend(ret, {"/nologo", "/permissive-", "<FLAGS>", "/c", "<IN>", "/Fo<OUT>"});
+            extend(ret, {"/nologo", "/permissive-", "[flags]", "/c", "[in]", "/Fo[out]"});
         } else if (is_gnu_like) {
             if (do_optimize.has_value() && *do_optimize) {
                 extend(ret, {"-O2"});
             if (do_debug.has_value() && *do_debug) {
                 extend(ret, {"-g"});
             }
-            extend(ret, {"-fPIC", "-pthread", "<FLAGS>", "-c", "<IN>", "-o<OUT>"});
+            extend(ret, {"-fPIC", "-pthread", "[flags]", "-c", "[in]", "-o[out]"});
         }
         if (common_flags) {
             extend(ret, *common_flags);
             fail(context, "Cannot deduce 'include_template' without 'compiler_id'");
         }
         if (is_gnu_like) {
-            return {"-I", "<PATH>"};
+            return {"-I", "[path]"};
         } else if (is_msvc) {
-            return {"/I", "<PATH>"};
+            return {"/I", "[path]"};
         }
         assert(false && "'include_template' deduction failed");
         std::terminate();
             return tc.include_template;
         }
         if (is_gnu_like) {
-            return {"-isystem", "<PATH>"};
+            return {"-isystem", "[path]"};
         } else if (is_msvc) {
             // MSVC has external-header support inbound, but it is not fully ready yet
-            return {"/I", "<PATH>"};
+            return {"/I", "[path]"};
         }
         assert(false && "external_include_template deduction failed");
         std::terminate();
             fail(context, "Cannot deduce 'define_template' without 'compiler_id'");
         }
         if (is_gnu_like) {
-            return {"-D", "<DEF>"};
+            return {"-D", "[def]"};
         } else if (is_msvc) {
-            return {"/D", "<DEF>"};
+            return {"/D", "[def]"};
         }
         assert(false && "define_template deduction failed");
         std::terminate();
             fail(context, "Unable to deduce archive creation rules without a 'compiler_id'");
         }
         if (is_msvc) {
-            return {"lib", "/nologo", "/OUT:<OUT>", "<IN>"};
+            return {"lib", "/nologo", "/OUT:[out]", "[in]"};
         } else if (is_gnu_like) {
-            return {"ar", "rcs", "<OUT>", "<IN>"};
+            return {"ar", "rcs", "[out]", "[in]"};
         }
         assert(false && "No archive command");
         std::terminate();
             ret = {get_compiler_executable_path(language::cxx),
                    "/nologo",
                    "/EHsc",
-                   "<IN>",
-                   "/Fe<OUT>"};
+                   "[in]",
+                   "/Fe[out]"};
         } else if (is_gnu_like) {
             ret = {get_compiler_executable_path(language::cxx),
                    "-fPIC",
-                   "<IN>",
+                   "[in]",
                    "-pthread",
-                   "-o<OUT>"};
+                   "-o[out]"};
         } else {
             assert(false && "No link-exe command");
             std::terminate();

src/dds/toolchain/toolchain.cpp

 }
 
 vector<string> toolchain::include_args(const fs::path& p) const noexcept {
-    return replace(_inc_template, "<PATH>", p.string());
+    return replace(_inc_template, "[path]", p.string());
 }
 
 vector<string> toolchain::external_include_args(const fs::path& p) const noexcept {
-    return replace(_extern_inc_template, "<PATH>", p.string());
+    return replace(_extern_inc_template, "[path]", p.string());
 }
 
 vector<string> toolchain::definition_args(std::string_view s) const noexcept {
-    return replace(_def_template, "<DEF>", s);
+    return replace(_def_template, "[def]", s);
 }
 
 compile_command_info toolchain::create_compile_command(const compile_file_spec& spec,
     vector<string> command;
     auto&          cmd_template = lang == language::c ? _c_compile : _cxx_compile;
     for (auto arg : cmd_template) {
-        if (arg == "<FLAGS>") {
+        if (arg == "[flags]") {
             extend(command, flags);
         } else {
-            arg = replace(arg, "<IN>", spec.source_path.string());
-            arg = replace(arg, "<OUT>", spec.out_path.string());
+            arg = replace(arg, "[in]", spec.source_path.string());
+            arg = replace(arg, "[out]", spec.out_path.string());
             command.push_back(arg);
         }
     }
                                                  toolchain_knobs) const noexcept {
     vector<string> cmd;
     for (auto& arg : _link_archive) {
-        if (arg == "<IN>") {
+        if (arg == "[in]") {
             std::transform(spec.input_files.begin(),
                            spec.input_files.end(),
                            std::back_inserter(cmd),
                            [](auto&& p) { return p.string(); });
         } else {
-            cmd.push_back(replace(arg, "<OUT>", spec.out_path.string()));
+            cmd.push_back(replace(arg, "[out]", spec.out_path.string()));
         }
     }
     return cmd;
                                                          toolchain_knobs) const noexcept {
     vector<string> cmd;
     for (auto& arg : _link_exe) {
-        if (arg == "<IN>") {
+        if (arg == "[in]") {
             std::transform(spec.inputs.begin(),
                            spec.inputs.end(),
                            std::back_inserter(cmd),
                            [](auto&& p) { return p.string(); });
         } else {
-            cmd.push_back(replace(arg, "<OUT>", spec.output.string()));
+            cmd.push_back(replace(arg, "[out]", spec.output.string()));
         }
     }
     return cmd;