Visual Studio compilation working in test harness (#979)

* Work in progress to be able to invoke VS from within code.

* First pass at windows version of refactor of OSProcessSpawner

* Closer to getting VS path lookup working.

* Make OSString assignable/ctor able

* Work out program files directory directly, so don't have to expand %%.

* WIP: Improve handling of process spawning.

* Add support for splitting input by line.

* * Correctly locates visual studio install
* Added functionality to invoke vs via cmd

* Add option to execute the command line.

* Handle in ProcessUtil for windows -> WinHandle.

* Rename files slang-win-visual-studio-util.cpp/.h and slang-process-util.h

* First pass at unix/linux version of ProcessUtil.

* Fix reading Visual Studio path from the registry.

* Get compiling on linux with.

* Fix vcvarsall.bat name

* Use ProcessUtil to execute external code.

* Remove OSProcessSpawner.

* Remove includes for "os.h" where no longer needed.

* Fix tabbing issue in premake5.lua
Remove test code from slang-test-main.cpp

* Fix premake4.lua tabbing issue.

* Small fixes to slang-process-util.h
Init ExecuteResult on Win execute.

* Improve comments.

* Fix bug in StringUtil::calcLines - with oddly terminated source input being able to read past end.
Make slang-generate use StringUtil over it's own impl.

* Fix off by one bug in working out Visual Studio version.

* Fix bug in calculating Visual Studio Version

* Fix compilation on linux with string parameter being passed to messageFormat.

* Remove erroneous use of kOSError codes - use Result.

* First effort to generate standard compiler options.

* Initial efforts in compiling source code in test framework for VisualStudio.

* Testing compiling c code on VisualStudio on Windows.

* Fix warning on linux.

* Fix clang on linux warning (and therefore failing) returning a StringBuilder as String.

* Disable return-std-move on clang.

1 files changed, 102 insertions, 3 deletions

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;
     }