summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--premake5.lua2
-rw-r--r--source/core/slang-io.cpp2
-rw-r--r--source/core/slang-process-util.h3
-rw-r--r--source/core/unix/slang-unix-process-util.cpp8
-rw-r--r--source/core/windows/slang-win-process-util.cpp63
-rw-r--r--source/core/windows/slang-win-visual-studio-util.cpp121
-rw-r--r--source/core/windows/slang-win-visual-studio-util.h44
-rw-r--r--tests/cross-compile/c-compile.c10
-rw-r--r--tests/cross-compile/c-compile.c.expected6
-rw-r--r--tools/slang-test/slang-test-main.cpp105
10 files changed, 347 insertions, 17 deletions
diff --git a/premake5.lua b/premake5.lua
index 03b05adfc..9924d8c2c 100644
--- a/premake5.lua
+++ b/premake5.lua
@@ -145,7 +145,7 @@ workspace "slang"
buildoptions { "-Wno-unused-but-set-variable", "-Wno-implicit-fallthrough" }
filter { "toolset:clang" }
- buildoptions { "-Wno-deprecated-register", "-Wno-tautological-compare", "-Wno-missing-braces", "-Wno-undefined-var-template", "-Wno-unused-function"}
+ buildoptions { "-Wno-deprecated-register", "-Wno-tautological-compare", "-Wno-missing-braces", "-Wno-undefined-var-template", "-Wno-unused-function", "-Wno-return-std-move"}
-- When compiling the debug configuration, we want to turn
-- optimization off, make sure debug symbols are output,
diff --git a/source/core/slang-io.cpp b/source/core/slang-io.cpp
index ae2520a78..e52ea0704 100644
--- a/source/core/slang-io.cpp
+++ b/source/core/slang-io.cpp
@@ -281,7 +281,7 @@ namespace Slang
builder.Append(splitPath[i]);
}
- return builder;
+ return builder.ToString();
}
bool Path::createDirectory(const String& path)
diff --git a/source/core/slang-process-util.h b/source/core/slang-process-util.h
index 19ae7c0d1..75ea945fe 100644
--- a/source/core/slang-process-util.h
+++ b/source/core/slang-process-util.h
@@ -54,6 +54,9 @@ struct ProcessUtil
/// Execute the command line
static SlangResult execute(const CommandLine& commandLine, ExecuteResult& outExecuteResult);
+
+ /// Append text escaped for using on a command line
+ static void appendCommandLineEscaped(const UnownedStringSlice& slice, StringBuilder& out);
};
}
diff --git a/source/core/unix/slang-unix-process-util.cpp b/source/core/unix/slang-unix-process-util.cpp
index 7795463b7..ee61cbc85 100644
--- a/source/core/unix/slang-unix-process-util.cpp
+++ b/source/core/unix/slang-unix-process-util.cpp
@@ -23,9 +23,9 @@ namespace Slang {
return UnownedStringSlice::fromLiteral("");
}
-static void _appendEscaped(const UnownedStringSlice& slice, StringBuilder& out)
+/* static */void ProcessUtil::appendCommandLineEscaped(const UnownedStringSlice& slice, StringBuilder& out)
{
- // TODO(JS): This escaping is not complete... !
+ // TODO(JS): This escaping is not complete... !
if (slice.indexOf(' ') >= 0 || slice.indexOf('"') >= 0)
{
out << "\"";
@@ -60,11 +60,11 @@ static void _appendEscaped(const UnownedStringSlice& slice, StringBuilder& out)
/* static */String ProcessUtil::getCommandLineString(const CommandLine& commandLine)
{
StringBuilder cmd;
- _appendEscaped(commandLine.m_executable.getUnownedSlice(), cmd);
+ appendCommandLineEscaped(commandLine.m_executable.getUnownedSlice(), cmd);
for (const auto& arg : commandLine.m_args)
{
cmd << " ";
- _appendEscaped(arg.getUnownedSlice(), cmd);
+ appendCommandLineEscaped(arg.getUnownedSlice(), cmd);
}
return cmd.ToString();
}
diff --git a/source/core/windows/slang-win-process-util.cpp b/source/core/windows/slang-win-process-util.cpp
index 424b87128..680864acb 100644
--- a/source/core/windows/slang-win-process-util.cpp
+++ b/source/core/windows/slang-win-process-util.cpp
@@ -154,10 +154,39 @@ static DWORD WINAPI _readerThreadProc(LPVOID threadParam)
return UnownedStringSlice::fromLiteral(".exe");
}
-static void _appendEscaped(const UnownedStringSlice& slice, StringBuilder& out)
+static bool _isLetter(char c)
+{
+ return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+}
+
+/* Special case handling for command line switches of the form /LINKPATH: that it is immediately followed
+potentially by a path. This detects that kind of switch, and returns the index of the first character after
+the :. If doesn't have the right format returns -1, to indicate that it's not this style of switch */
+static int _calcIndexOfColonSwitch(const UnownedStringSlice& slice)
+{
+ if (!slice.startsWith("/"))
+ {
+ return -1;
+ }
+ int index = slice.indexOf(':');
+ if (index > 0)
+ {
+ for (int i = 1; i < index; ++i)
+ {
+ if (!_isLetter(slice[i]))
+ {
+ return -1;
+ }
+ }
+ }
+ return index + 1;
+}
+
+static void _appendCommandLineEscaped(const UnownedStringSlice& slice, StringBuilder& out)
{
// TODO(JS): This escaping is not complete... !
- if (slice.indexOf(' ') >= 0 || slice.indexOf('"') >= 0)
+
+ if ((slice.indexOf(' ') >= 0 || slice.indexOf('"') >= 0))
{
out << "\"";
@@ -166,7 +195,7 @@ static void _appendEscaped(const UnownedStringSlice& slice, StringBuilder& out)
while (cur < end)
{
- char c= *cur++;
+ char c = *cur++;
switch (c)
{
case '\"':
@@ -181,21 +210,39 @@ static void _appendEscaped(const UnownedStringSlice& slice, StringBuilder& out)
}
out << "\"";
-
return;
}
+ else
+ {
+ out << slice;
+ }
+}
- out << slice;
+/* static */void ProcessUtil::appendCommandLineEscaped(const UnownedStringSlice& slice, StringBuilder& out)
+{
+ // Check if starts with a colon ending switch, as we need to special case escaping in this case
+ const int index = _calcIndexOfColonSwitch(slice);
+ if (index >= 0)
+ {
+ // Append the switch prefix as is (ie /linkpath:)
+ out << UnownedStringSlice(slice.begin(), index);
+ // Append the stuff after the prefix escaping if needed
+ _appendCommandLineEscaped(UnownedStringSlice(slice.begin() + index, slice.end()), out);
+ }
+ else
+ {
+ _appendCommandLineEscaped(slice, out);
+ }
}
/* static */String ProcessUtil::getCommandLineString(const CommandLine& commandLine)
{
StringBuilder cmd;
- _appendEscaped(commandLine.m_executable.getUnownedSlice(), cmd);
+ appendCommandLineEscaped(commandLine.m_executable.getUnownedSlice(), cmd);
for (const auto& arg : commandLine.m_args)
{
cmd << " ";
- _appendEscaped(arg.getUnownedSlice(), cmd);
+ appendCommandLineEscaped(arg.getUnownedSlice(), cmd);
}
return cmd.ToString();
}
@@ -260,7 +307,7 @@ static void _appendEscaped(const UnownedStringSlice& slice, StringBuilder& out)
if (commandLine.m_executableType == CommandLine::ExecutableType::Path)
{
StringBuilder cmd;
- _appendEscaped(commandLine.m_executable.getUnownedSlice(), cmd);
+ appendCommandLineEscaped(commandLine.m_executable.getUnownedSlice(), cmd);
pathBuffer = cmd.toWString();
path = pathBuffer.begin();
diff --git a/source/core/windows/slang-win-visual-studio-util.cpp b/source/core/windows/slang-win-visual-studio-util.cpp
index edf33110c..5fc56d091 100644
--- a/source/core/windows/slang-win-visual-studio-util.cpp
+++ b/source/core/windows/slang-win-visual-studio-util.cpp
@@ -336,4 +336,125 @@ static SlangResult _find(int versionIndex, WinVisualStudioUtil::VersionPath& out
}
}
+/* static */void WinVisualStudioUtil::calcArgs(const CPPCompileOptions& options, CommandLine& cmdLine)
+{
+ typedef CPPCompileOptions::OptimizationLevel OptimizationLevel;
+ typedef CPPCompileOptions::TargetType TargetType;
+ typedef CPPCompileOptions::DebugInfoType DebugInfoType;
+
+ // https://docs.microsoft.com/en-us/cpp/build/reference/compiler-options-listed-alphabetically?view=vs-2019
+
+ cmdLine.addArg("/nologo");
+ // Generate complete debugging information
+ cmdLine.addArg("/Zi");
+ // Display full path of source files in diagnostics
+ cmdLine.addArg("/FC");
+
+ switch (options.optimizationLevel)
+ {
+ case OptimizationLevel::Debug:
+ {
+ // No optimization
+ cmdLine.addArg("/Od");
+
+ cmdLine.addArg("/MDd");
+ break;
+ }
+ case OptimizationLevel::Normal:
+ {
+ cmdLine.addArg("/O2");
+ // Multithreaded DLL
+ cmdLine.addArg("/MD");
+ break;
+ }
+ default: break;
+ }
+
+ // /Fd - followed by name of the pdb file
+ if (options.debugInfoType != DebugInfoType::None)
+ {
+ StringBuilder builder;
+ builder << "/Fd" << options.modulePath << ".pdb";
+ cmdLine.addArg(builder);
+ }
+
+ switch (options.targetType)
+ {
+ case TargetType::SharedLibrary:
+ {
+ // Create dynamic link library
+ if (options.optimizationLevel == OptimizationLevel::Debug)
+ {
+ cmdLine.addArg("/LDd");
+ }
+ else
+ {
+ cmdLine.addArg("/LD");
+ }
+
+ StringBuilder builder;
+ builder << "/Fe" << options.modulePath << ".dll";
+ cmdLine.addArg(builder);
+ break;
+ }
+ case TargetType::Executable:
+ {
+ StringBuilder builder;
+ builder << "/Fe" << options.modulePath << ".exe";
+ cmdLine.addArg(builder);
+ break;
+ }
+ default: break;
+ }
+
+ // Object file specify it's location - needed if we are out
+ {
+ StringBuilder builder;
+ builder << "/Fo" << options.modulePath << ".obj";
+ cmdLine.addArg(builder);
+ }
+
+ // Add defines
+ for (const auto& define : options.defines)
+ {
+ StringBuilder builder;
+ builder << define.nameWithSig;
+ if (define.value.getLength())
+ {
+ builder << "=" << define.value;
+ }
+
+ cmdLine.addArg(builder);
+ }
+
+ // Add includes
+ for (const auto& include : options.includePaths)
+ {
+ cmdLine.addArg("/I");
+ cmdLine.addArg(include);
+ }
+
+
+ // https://docs.microsoft.com/en-us/cpp/build/reference/eh-exception-handling-model?view=vs-2019
+ // /Eha - Specifies the model of exception handling. (a, s, c, r are options)
+
+ // Files to compile
+ for (const auto& sourceFile : options.sourceFiles)
+ {
+ cmdLine.addArg(sourceFile);
+ }
+
+ // Link options (parameters past /link go to linker)
+ cmdLine.addArg("/link");
+
+ for (const auto& libPath : options.libraryPaths)
+ {
+ // Note that any escaping of the path is handled in the ProcessUtil::
+ StringBuilder builder;
+ builder << "/LIBPATH:" << libPath;
+
+ cmdLine.addArg(builder);
+ }
+}
+
} // namespace Slang
diff --git a/source/core/windows/slang-win-visual-studio-util.h b/source/core/windows/slang-win-visual-studio-util.h
index aec4493df..fefb9ad0f 100644
--- a/source/core/windows/slang-win-visual-studio-util.h
+++ b/source/core/windows/slang-win-visual-studio-util.h
@@ -8,6 +8,47 @@
namespace Slang {
+struct CPPCompileOptions
+{
+ enum class OptimizationLevel
+ {
+ Normal, ///< Normal optimization
+ Debug, ///< General has no optimizations
+ };
+
+ enum DebugInfoType
+ {
+ None, ///< Binary has no debug information
+ Maximum, ///< Has maximum debug information
+ Normal, ///< Has normal debug information
+ };
+ enum TargetType
+ {
+ Executable, ///< Produce an executable
+ SharedLibrary, ///< Produce a shared library object/dll
+ Object, ///< Produce an object file
+ };
+
+ struct Define
+ {
+ String nameWithSig; ///< If macro takes parameters include in brackets
+ String value;
+ };
+
+ OptimizationLevel optimizationLevel = OptimizationLevel::Debug;
+ DebugInfoType debugInfoType = DebugInfoType::Normal;
+ TargetType targetType = TargetType::Executable;
+
+ String modulePath; ///< The path/name of the output module. Should not have the extension, as that will be added for each of the target types
+
+ List<Define> defines;
+
+ List<String> sourceFiles;
+
+ List<String> includePaths;
+ List<String> libraryPaths;
+};
+
struct WinVisualStudioUtil
{
enum class Version: uint32_t
@@ -43,6 +84,9 @@ struct WinVisualStudioUtil
/// Convert a version number into a string
static void append(Version version, StringBuilder& outBuilder);
+ /// Calculate the command line args
+ static void calcArgs(const CPPCompileOptions& options, CommandLine& cmdLine);
+
};
} // namespace Slang
diff --git a/tests/cross-compile/c-compile.c b/tests/cross-compile/c-compile.c
new file mode 100644
index 000000000..775d7b9d3
--- /dev/null
+++ b/tests/cross-compile/c-compile.c
@@ -0,0 +1,10 @@
+//TEST:EXECUTE_C:
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(int argc, char** argv)
+{
+ printf("Hello World!\n");
+ return 0;
+}
diff --git a/tests/cross-compile/c-compile.c.expected b/tests/cross-compile/c-compile.c.expected
new file mode 100644
index 000000000..0e042b53b
--- /dev/null
+++ b/tests/cross-compile/c-compile.c.expected
@@ -0,0 +1,6 @@
+result code = 0
+standard error = {
+}
+standard output = {
+Hello World!
+}
diff --git a/tools/slang-test/slang-test-main.cpp b/tools/slang-test/slang-test-main.cpp
index dac6ff9fe..5c83d4f18 100644
--- a/tools/slang-test/slang-test-main.cpp
+++ b/tools/slang-test/slang-test-main.cpp
@@ -18,6 +18,10 @@ using namespace Slang;
#include "options.h"
#include "slangc-tool.h"
+#ifdef _WIN32
+# include "../../source/core/windows/slang-win-visual-studio-util.h"
+#endif
+
#include "../../source/core/slang-process-util.h"
#define STB_IMAGE_IMPLEMENTATION
@@ -1089,6 +1093,98 @@ String getExpectedOutput(String const& outputStem)
return expectedOutput;
}
+static TestResult runExecuteC(TestContext* context, TestInput& input)
+{
+#ifdef _WIN32
+ // If we are just collecting requirements, say it passed
+ if (context->isCollectingRequirements())
+ {
+ return TestResult::Pass;
+ }
+
+ auto filePath = input.filePath;
+ auto outputStem = input.outputStem;
+
+ // Find
+ List<WinVisualStudioUtil::VersionPath> versionPaths;
+ WinVisualStudioUtil::find(versionPaths);
+
+ // Didn't find the visual studio compiler
+ if (versionPaths.getCount() <= 0)
+ {
+ return TestResult::Ignored;
+ }
+
+ // Make the module name the same as the source file
+ String directory = Path::getParentDirectory(input.outputStem);
+ String moduleName = Path::getFileNameWithoutExt(filePath);
+
+ String modulePath = Path::combine(directory, moduleName);
+
+ {
+ CPPCompileOptions options;
+
+ // Compile this source
+ options.sourceFiles.add(filePath);
+ options.modulePath = modulePath;
+
+ CommandLine cmdLine;
+ WinVisualStudioUtil::calcArgs(options, cmdLine);
+
+ options.modulePath = moduleName;
+
+ ExecuteResult exeRes;
+ if (SLANG_FAILED(WinVisualStudioUtil::executeCompiler(versionPaths[0], cmdLine, exeRes)))
+ {
+ return TestResult::Fail;
+ }
+ }
+
+ // Execute the binary and see what we get
+ {
+ CommandLine cmdLine;
+
+ StringBuilder exePath;
+ exePath << modulePath << ProcessUtil::getExecutableSuffix();
+
+ cmdLine.setExecutablePath(exePath);
+
+ ExecuteResult exeRes;
+ if (SLANG_FAILED(ProcessUtil::execute(cmdLine, exeRes)))
+ {
+ return TestResult::Fail;
+ }
+
+ // Write the output, and compare to expected
+ String actualOutput = getOutput(exeRes);
+ String actualOutputPath = outputStem + ".actual";
+ Slang::File::writeAllText(actualOutputPath, actualOutput);
+
+ // Read the expected
+ String expectedOutput;
+ try
+ {
+ String expectedOutputPath = outputStem + ".expected";
+ expectedOutput = Slang::File::readAllText(expectedOutputPath);
+ }
+ catch (Slang::IOException)
+ {
+ }
+
+ // Compare if they are the same
+ if (actualOutput != expectedOutput)
+ {
+ context->reporter->dumpOutputDifference(expectedOutput, actualOutput);
+ return TestResult::Fail;
+ }
+ }
+
+ return TestResult::Pass;
+#else
+ return TestResult::Ignored;
+#endif
+}
+
TestResult runCrossCompilerTest(TestContext* context, TestInput& input)
{
// need to execute the stand-alone Slang compiler on the file
@@ -1895,6 +1991,7 @@ static const TestCommandInfo s_testCommandInfos[] =
{ "COMPARE_RENDER_COMPUTE", &runSlangRenderComputeComparisonTest},
{ "COMPARE_GLSL", &runGLSLComparisonTest},
{ "CROSS_COMPILE", &runCrossCompilerTest},
+ { "EXECUTE_C", &runExecuteC},
};
TestResult runTest(
@@ -2223,11 +2320,13 @@ static bool endsWithAllowedExtension(
".chit",
".miss",
".rgen",
- nullptr };
+ ".c",
+ ".cpp",
+ };
- for( auto ii = allowedExtensions; *ii; ++ii )
+ for( auto allowedExtension : allowedExtensions)
{
- if(filePath.endsWith(*ii))
+ if(filePath.endsWith(allowedExtension))
return true;
}
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-01 22:14:16 +0000