Projects in 'build' and Slang API separation (#1624)

* #include an absolute path didn't work - because paths were taken to always be relative.

* Move reflection to reflection-api.

* Slight reorg to pull out potentially Slang internal functions from the reflection API impls.

* Remove visual studio projects

* Fix for slang-binaries copy.

* Add the visual studio projects in build/visual-studio

* Remove miniz project.

* Differentiate the linePath from the filePath.

* Improve comment in premake5.lua + to kick of CI.

* Kick CI.

1 files changed, 698 insertions, 0 deletions

diff --git a/source/slang/slang-api.cpp b/source/slang/slang-api.cpp
new file mode 100644
index 000000000..ea6c7820b
--- /dev/null
+++ b/source/slang/slang-api.cpp
@@ -0,0 +1,698 @@
+// slang-api.cpp
+
+#include "slang-compiler.h"
+
+#include "slang-repro.h"
+
+#include "../../slang-tag-version.h"
+
+// implementation of C interface
+
+SLANG_API SlangSession* spCreateSession(const char*)
+{
+    Slang::ComPtr<slang::IGlobalSession> globalSession;
+    if (SLANG_FAILED(slang_createGlobalSession(SLANG_API_VERSION, globalSession.writeRef())))
+    {
+        return nullptr;
+    }
+    // Will be returned with a refcount of 1
+    return globalSession.detach();
+}
+
+SLANG_API SlangResult slang_createGlobalSession(
+    SlangInt                apiVersion,
+    slang::IGlobalSession** outGlobalSession)
+{
+    Slang::ComPtr<slang::IGlobalSession> globalSession;
+    SLANG_RETURN_ON_FAIL(slang_createGlobalSessionWithoutStdLib(apiVersion, globalSession.writeRef()));
+    SLANG_RETURN_ON_FAIL(globalSession->compileStdLib());
+    *outGlobalSession = globalSession.detach();
+    return SLANG_OK;
+}
+
+SLANG_API SlangResult slang_createGlobalSessionWithoutStdLib(
+    SlangInt                apiVersion,
+    slang::IGlobalSession** outGlobalSession)
+{
+    if (apiVersion != 0)
+        return SLANG_E_NOT_IMPLEMENTED;
+
+    // Create the session
+    Slang::Session* globalSession = new Slang::Session();
+    // Put an interface ref on it
+    Slang::ComPtr<slang::IGlobalSession> result(globalSession);
+
+    // Initialize it
+    globalSession->init();
+
+    *outGlobalSession = result.detach();
+    return SLANG_OK;
+}
+
+SLANG_API void spDestroySession(
+    SlangSession*   inSession)
+{
+    if (!inSession) return;
+
+    Slang::Session* session = Slang::asInternal(inSession);
+    // It is assumed there is only a single reference on the session (the one placed
+    // with spCreateSession) if this function is called
+    SLANG_ASSERT(session->debugGetReferenceCount() == 1);
+    // Release
+    session->release();
+}
+
+SLANG_API const char* spGetBuildTagString()
+{
+    return SLANG_TAG_VERSION;
+}
+
+SLANG_API void spAddBuiltins(
+    SlangSession*   session,
+    char const*     sourcePath,
+    char const*     sourceString)
+{
+    session->addBuiltins(sourcePath, sourceString);
+}
+
+SLANG_API void spSessionSetSharedLibraryLoader(
+    SlangSession*               session,
+    ISlangSharedLibraryLoader* loader)
+{
+    session->setSharedLibraryLoader(loader);
+}
+
+SLANG_API ISlangSharedLibraryLoader* spSessionGetSharedLibraryLoader(
+    SlangSession*               session)
+{
+    return session->getSharedLibraryLoader();
+}
+
+SLANG_API SlangResult spSessionCheckCompileTargetSupport(
+    SlangSession*                session,
+    SlangCompileTarget           target)
+{
+    return session->checkCompileTargetSupport(target);
+}
+
+SLANG_API SlangResult spSessionCheckPassThroughSupport(
+    SlangSession*       session,
+    SlangPassThrough    passThrough)
+{
+    return session->checkPassThroughSupport(passThrough);
+}
+
+SLANG_API SlangCompileRequest* spCreateCompileRequest(
+    SlangSession* session)
+{
+    slang::ICompileRequest* request = nullptr;
+    // Will return with suitable ref count
+    session->createCompileRequest(&request);
+    return request;
+}
+
+SLANG_API SlangProfileID spFindProfile(
+    SlangSession* session,
+    char const*     name)
+{
+    return session->findProfile(name);
+}
+
+/* !!!!!!!!!!!!!!!!!!SlangCompileRequest API!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
+
+/*!
+@brief Destroy a compile request.
+*/
+SLANG_API void spDestroyCompileRequest(
+    slang::ICompileRequest*    request)
+{
+    if (request)
+    {
+        request->release();
+    }
+}
+
+/* All other functions just call into the ICompileResult interface. */
+
+SLANG_API void spSetFileSystem(
+    slang::ICompileRequest*    request,
+    ISlangFileSystem*       fileSystem)
+{
+    SLANG_ASSERT(request);
+    request->setFileSystem(fileSystem);
+}
+
+SLANG_API void spSetCompileFlags(
+    slang::ICompileRequest*    request,
+    SlangCompileFlags       flags)
+{
+    SLANG_ASSERT(request);
+    request->setCompileFlags(flags);
+}
+
+SLANG_API void spSetDumpIntermediates(
+    slang::ICompileRequest*    request,
+    int                     enable)
+{
+    SLANG_ASSERT(request);
+    request->setDumpIntermediates(enable);
+}
+
+SLANG_API void spSetDumpIntermediatePrefix(
+    slang::ICompileRequest*    request,
+    const char* prefix)
+{
+    SLANG_ASSERT(request);
+    request->setDumpIntermediatePrefix(prefix);
+}
+
+SLANG_API void spSetLineDirectiveMode(
+    slang::ICompileRequest*    request,
+    SlangLineDirectiveMode  mode)
+{
+    SLANG_ASSERT(request);
+    request->setLineDirectiveMode(mode);
+}
+
+SLANG_API void spSetCommandLineCompilerMode(
+    slang::ICompileRequest* request)
+{
+    SLANG_ASSERT(request);
+    request->setCommandLineCompilerMode();
+}
+
+SLANG_API void spSetCodeGenTarget(
+    slang::ICompileRequest*    request,
+    SlangCompileTarget target)
+{
+    SLANG_ASSERT(request);
+    request->setCodeGenTarget(target);
+}
+
+SLANG_API int spAddCodeGenTarget(
+    slang::ICompileRequest*    request,
+    SlangCompileTarget      target)
+{
+    SLANG_ASSERT(request);
+    return request->addCodeGenTarget(target);
+}
+
+SLANG_API void spSetTargetProfile(
+    slang::ICompileRequest*    request,
+    int                     targetIndex,
+    SlangProfileID          profile)
+{
+    SLANG_ASSERT(request);
+    request->setTargetProfile(targetIndex, profile);
+}
+
+SLANG_API void spSetTargetFlags(
+    slang::ICompileRequest*    request,
+    int                     targetIndex,
+    SlangTargetFlags        flags)
+{
+    SLANG_ASSERT(request);
+    request->setTargetFlags(targetIndex, flags);
+}
+
+SLANG_API void spSetTargetFloatingPointMode(
+    slang::ICompileRequest*    request,
+    int                     targetIndex,
+    SlangFloatingPointMode  mode)
+{
+    SLANG_ASSERT(request);
+    request->setTargetFloatingPointMode(targetIndex, mode);
+}
+
+SLANG_API void spSetMatrixLayoutMode(
+    slang::ICompileRequest*    request,
+    SlangMatrixLayoutMode   mode)
+{
+    SLANG_ASSERT(request);
+    request->setMatrixLayoutMode(mode);
+}
+
+SLANG_API void spSetTargetMatrixLayoutMode(
+    slang::ICompileRequest*    request,
+    int                     targetIndex,
+    SlangMatrixLayoutMode   mode)
+{
+    SLANG_ASSERT(request);
+    request->setTargetMatrixLayoutMode(targetIndex, mode);
+}
+
+SLANG_API void spSetDebugInfoLevel(
+    slang::ICompileRequest*    request,
+    SlangDebugInfoLevel     level)
+{
+    SLANG_ASSERT(request);
+    request->setDebugInfoLevel(level);
+}
+
+SLANG_API void spSetOptimizationLevel(
+    slang::ICompileRequest*    request,
+    SlangOptimizationLevel  level)
+{
+    SLANG_ASSERT(request);
+    request->setOptimizationLevel(level);
+}
+
+SLANG_API void spSetOutputContainerFormat(
+    slang::ICompileRequest*    request,
+    SlangContainerFormat    format)
+{
+    SLANG_ASSERT(request);
+    request->setOutputContainerFormat(format);
+}
+
+SLANG_API void spSetPassThrough(
+    slang::ICompileRequest*    request,
+    SlangPassThrough        passThrough)
+{
+    SLANG_ASSERT(request);
+    request->setPassThrough(passThrough);
+}
+
+SLANG_API void spSetDiagnosticCallback(
+    slang::ICompileRequest*    request,
+    SlangDiagnosticCallback callback,
+    void const*             userData)
+{
+    SLANG_ASSERT(request);
+    request->setDiagnosticCallback(callback, userData);
+}
+
+SLANG_API void spSetWriter(
+    slang::ICompileRequest*    request,
+    SlangWriterChannel      chan,
+    ISlangWriter*           writer)
+{
+    SLANG_ASSERT(request);
+    request->setWriter(chan, writer);
+}
+
+SLANG_API ISlangWriter* spGetWriter(
+    slang::ICompileRequest*    request,
+    SlangWriterChannel      chan)
+{
+    SLANG_ASSERT(request);
+    return request->getWriter(chan);
+}
+
+SLANG_API void spAddSearchPath(
+    slang::ICompileRequest*    request,
+    const char*             path)
+{
+    SLANG_ASSERT(request);
+    request->addSearchPath(path);
+}
+
+SLANG_API void spAddPreprocessorDefine(
+    slang::ICompileRequest*    request,
+    const char*             key,
+    const char*             value)
+{
+    SLANG_ASSERT(request);
+    request->addPreprocessorDefine(key, value);
+}
+
+SLANG_API char const* spGetDiagnosticOutput(
+    slang::ICompileRequest*    request)
+{
+    SLANG_ASSERT(request);
+    return request->getDiagnosticOutput();
+}
+
+SLANG_API SlangResult spGetDiagnosticOutputBlob(
+    slang::ICompileRequest*    request,
+    ISlangBlob**            outBlob)
+{
+    SLANG_ASSERT(request);
+    return request->getDiagnosticOutputBlob(outBlob);
+}
+
+// New-fangled compilation API
+
+SLANG_API int spAddTranslationUnit(
+    slang::ICompileRequest*    request,
+    SlangSourceLanguage     language,
+    char const*             inName)
+{
+    SLANG_ASSERT(request);
+    return request->addTranslationUnit(language, inName);
+}
+
+SLANG_API void spSetDefaultModuleName(
+    slang::ICompileRequest*    request,
+    const char* defaultModuleName)
+{
+    SLANG_ASSERT(request);
+    request->setDefaultModuleName(defaultModuleName);
+}
+
+SLANG_API SlangResult spAddLibraryReference(
+    slang::ICompileRequest*    request,
+    const void* libData,
+    size_t libDataSize)
+{
+    SLANG_ASSERT(request);
+    return request->addLibraryReference(libData, libDataSize);
+}
+
+SLANG_API void spTranslationUnit_addPreprocessorDefine(
+    slang::ICompileRequest*    request,
+    int                     translationUnitIndex,
+    const char*             key,
+    const char*             value)
+{
+    SLANG_ASSERT(request);
+    request->addTranslationUnitPreprocessorDefine(translationUnitIndex, key, value);
+}
+
+SLANG_API void spAddTranslationUnitSourceFile(
+    slang::ICompileRequest*    request,
+    int                     translationUnitIndex,
+    char const*             path)
+{
+    SLANG_ASSERT(request);
+    request->addTranslationUnitSourceFile(translationUnitIndex, path);
+}
+
+SLANG_API void spAddTranslationUnitSourceString(
+    slang::ICompileRequest*    request,
+    int                     translationUnitIndex,
+    char const*             path,
+    char const*             source)
+{
+    SLANG_ASSERT(request);
+    request->addTranslationUnitSourceString(translationUnitIndex, path, source);
+}
+
+SLANG_API void spAddTranslationUnitSourceStringSpan(
+    slang::ICompileRequest*    request,
+    int                     translationUnitIndex,
+    char const*             path,
+    char const*             sourceBegin,
+    char const*             sourceEnd)
+{
+    SLANG_ASSERT(request);
+    request->addTranslationUnitSourceStringSpan(translationUnitIndex, path, sourceBegin, sourceEnd);
+}
+
+SLANG_API void spAddTranslationUnitSourceBlob(
+    slang::ICompileRequest*    request,
+    int                     translationUnitIndex,
+    char const*             path,
+    ISlangBlob*             sourceBlob)
+{
+    SLANG_ASSERT(request);
+    request->addTranslationUnitSourceBlob(translationUnitIndex, path, sourceBlob);
+}
+
+SLANG_API int spAddEntryPoint(
+    slang::ICompileRequest*    request,
+    int                     translationUnitIndex,
+    char const*             name,
+    SlangStage              stage)
+{
+    SLANG_ASSERT(request);
+    return request->addEntryPoint(translationUnitIndex, name, stage);
+}
+
+SLANG_API int spAddEntryPointEx(
+    slang::ICompileRequest*    request,
+    int                     translationUnitIndex,
+    char const*             name,
+    SlangStage              stage,
+    int                     genericParamTypeNameCount,
+    char const **           genericParamTypeNames)
+{
+    SLANG_ASSERT(request);
+    return request->addEntryPointEx(translationUnitIndex, name, stage, genericParamTypeNameCount, genericParamTypeNames);
+}
+
+SLANG_API SlangResult spSetGlobalGenericArgs(
+    slang::ICompileRequest*    request,
+    int                     genericArgCount,
+    char const**            genericArgs)
+{
+    SLANG_ASSERT(request);
+    return request->setGlobalGenericArgs(genericArgCount, genericArgs);
+}
+
+SLANG_API SlangResult spSetTypeNameForGlobalExistentialTypeParam(
+    slang::ICompileRequest*    request,
+    int                     slotIndex,
+    char const*             typeName)
+{
+    SLANG_ASSERT(request);
+    return request->setTypeNameForGlobalExistentialTypeParam(slotIndex, typeName);
+}
+
+SLANG_API SlangResult spSetTypeNameForEntryPointExistentialTypeParam(
+    slang::ICompileRequest*    request,
+    int                     entryPointIndex,
+    int                     slotIndex,
+    char const*             typeName)
+{
+    SLANG_ASSERT(request);
+    return request->setTypeNameForEntryPointExistentialTypeParam(entryPointIndex, slotIndex, typeName);
+}
+
+SLANG_API SlangResult spCompile(
+    slang::ICompileRequest*    request)
+{
+    SLANG_ASSERT(request);
+    return request->compile();
+}
+
+SLANG_API int
+spGetDependencyFileCount(
+    slang::ICompileRequest*    request)
+{
+    SLANG_ASSERT(request);
+    return request->getDependencyFileCount();
+}
+
+SLANG_API char const*
+spGetDependencyFilePath(
+    slang::ICompileRequest*    request,
+    int                     index)
+{
+    SLANG_ASSERT(request);
+    return request->getDependencyFilePath(index);
+}
+
+SLANG_API int
+spGetTranslationUnitCount(
+    slang::ICompileRequest*    request)
+{
+    SLANG_ASSERT(request);
+    return request->getTranslationUnitCount();
+}
+
+SLANG_API void const* spGetEntryPointCode(
+    slang::ICompileRequest*    request,
+    int                     entryPointIndex,
+    size_t*                 outSize)
+{
+    SLANG_ASSERT(request);
+    return request->getEntryPointCode(entryPointIndex, outSize);
+}
+
+SLANG_API SlangResult spGetEntryPointCodeBlob(
+    slang::ICompileRequest*    request,
+    int                     entryPointIndex,
+    int                     targetIndex,
+    ISlangBlob**            outBlob)
+{
+    SLANG_ASSERT(request);
+    return request->getEntryPointCodeBlob(entryPointIndex, targetIndex, outBlob);
+}
+
+SLANG_API SlangResult spGetEntryPointHostCallable(
+    slang::ICompileRequest*    request,
+    int                     entryPointIndex,
+    int                     targetIndex,
+    ISlangSharedLibrary**   outSharedLibrary)
+{
+    SLANG_ASSERT(request);
+    return request->getEntryPointHostCallable(entryPointIndex, targetIndex, outSharedLibrary);
+}
+
+SLANG_API SlangResult spGetTargetCodeBlob(
+    slang::ICompileRequest* request,
+    int targetIndex,
+    ISlangBlob** outBlob)
+{
+    SLANG_ASSERT(request);
+    return request->getTargetCodeBlob(targetIndex, outBlob);
+}
+
+SLANG_API SlangResult spGetTargetHostCallable(
+    slang::ICompileRequest* request,
+    int targetIndex,
+    ISlangSharedLibrary** outSharedLibrary)
+{
+    SLANG_ASSERT(request);
+    return request->getTargetHostCallable(targetIndex, outSharedLibrary);
+}
+
+SLANG_API char const* spGetEntryPointSource(
+    slang::ICompileRequest*    request,
+    int                     entryPointIndex)
+{
+    SLANG_ASSERT(request);
+    return request->getEntryPointSource(entryPointIndex);
+}
+
+SLANG_API void const* spGetCompileRequestCode(
+    slang::ICompileRequest*    request,
+    size_t*                 outSize)
+{
+    SLANG_ASSERT(request);
+    return request->getCompileRequestCode(outSize);
+}
+
+SLANG_API SlangResult spGetContainerCode(
+    slang::ICompileRequest*    request,
+    ISlangBlob**            outBlob)
+{
+    SLANG_ASSERT(request);
+    return request->getContainerCode(outBlob);
+}
+
+SLANG_API SlangResult spLoadRepro(
+    slang::ICompileRequest* request,
+    ISlangFileSystem* fileSystem,
+    const void* data,
+    size_t size)
+{
+    SLANG_ASSERT(request);
+    return request->loadRepro(fileSystem, data, size);
+}
+
+SLANG_API SlangResult spSaveRepro(
+    slang::ICompileRequest* request,
+    ISlangBlob** outBlob)
+{
+    SLANG_ASSERT(request);
+    return request->saveRepro(outBlob);
+}
+
+SLANG_API SlangResult spEnableReproCapture(
+    slang::ICompileRequest* request)
+{
+    SLANG_ASSERT(request);
+    return request->enableReproCapture();
+}
+
+SLANG_API SlangResult spCompileRequest_getProgram(
+    slang::ICompileRequest*    request,
+    slang::IComponentType** outProgram)
+{
+    SLANG_ASSERT(request);
+    return request->getProgram(outProgram);
+}
+
+SLANG_API SlangResult spCompileRequest_getModule(
+    slang::ICompileRequest*    request,
+    SlangInt                translationUnitIndex,
+    slang::IModule**        outModule)
+{
+    SLANG_ASSERT(request);
+    return request->getModule(translationUnitIndex, outModule);
+}
+
+SLANG_API SlangResult spCompileRequest_getSession(
+    slang::ICompileRequest* request,
+    slang::ISession** outSession)
+{
+    SLANG_ASSERT(request);
+    return request->getSession(outSession);
+}
+
+SLANG_API SlangResult spCompileRequest_getEntryPoint(
+    slang::ICompileRequest*    request,
+    SlangInt                entryPointIndex,
+    slang::IComponentType** outEntryPoint)
+{
+    SLANG_ASSERT(request);
+    return request->getEntryPoint(entryPointIndex, outEntryPoint);
+}
+
+// Get the output code associated with a specific translation unit
+SLANG_API char const* spGetTranslationUnitSource(
+    slang::ICompileRequest*    /*request*/,
+    int                     /*translationUnitIndex*/)
+{
+    fprintf(stderr, "DEPRECATED: spGetTranslationUnitSource()\n");
+    return nullptr;
+}
+
+SLANG_API SlangResult spProcessCommandLineArguments(
+    SlangCompileRequest*    request,
+    char const* const*      args,
+    int                     argCount)
+{
+    return request->processCommandLineArguments(args, argCount);
+}
+
+// Reflection API
+
+SLANG_API SlangReflection* spGetReflection(
+    slang::ICompileRequest*    request)
+{
+    SLANG_ASSERT(request);
+    return request->getReflection();
+}
+
+// ... rest of reflection API implementation is in `Reflection.cpp`
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!! Session !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
+
+SLANG_API SlangResult spExtractRepro(SlangSession* session, const void* reproData, size_t reproDataSize, ISlangMutableFileSystem* fileSystem)
+{
+    using namespace Slang;
+    SLANG_UNUSED(session);
+
+    List<uint8_t> buffer;
+    {
+        MemoryStreamBase memoryStream(FileAccess::Read, reproData, reproDataSize);
+        SLANG_RETURN_ON_FAIL(ReproUtil::loadState(&memoryStream, buffer));
+    }
+
+    MemoryOffsetBase base;
+    base.set(buffer.getBuffer(), buffer.getCount());
+
+    ReproUtil::RequestState* requestState = ReproUtil::getRequest(buffer);
+    return ReproUtil::extractFiles(base, requestState, fileSystem);
+}
+
+SLANG_API SlangResult spLoadReproAsFileSystem(
+    SlangSession* session,
+    const void* reproData,
+    size_t reproDataSize,
+    ISlangFileSystem* replaceFileSystem,
+    ISlangFileSystemExt** outFileSystem)
+{
+    using namespace Slang;
+
+    SLANG_UNUSED(session);
+
+    MemoryStreamBase stream(FileAccess::Read, reproData, reproDataSize);
+
+    List<uint8_t> buffer;
+    SLANG_RETURN_ON_FAIL(ReproUtil::loadState(&stream, buffer));
+
+    auto requestState = ReproUtil::getRequest(buffer);
+    MemoryOffsetBase base;
+    base.set(buffer.getBuffer(), buffer.getCount());
+
+    RefPtr<CacheFileSystem> cacheFileSystem;
+    SLANG_RETURN_ON_FAIL(ReproUtil::loadFileSystem(base, requestState, replaceFileSystem, cacheFileSystem));
+
+    *outFileSystem = cacheFileSystem.detach();
+    return SLANG_OK;
+}
+