reorganise things a bit to align further with the actual names/structure

1 files changed, 501 insertions, 0 deletions

diff --git a/command_line/PluginLib/Src/Library/DropInCompilerLinkerPrivate.cpp b/command_line/PluginLib/Src/Library/DropInCompilerLinkerPrivate.cpp
new file mode 100644
index 0000000..2c0a0c7
--- /dev/null
+++ b/command_line/PluginLib/Src/Library/DropInCompilerLinkerPrivate.cpp
@@ -0,0 +1,501 @@
+#include "plugin_internal.h"
+
+static CWCompilerLinkerContext *GetContext(CWPluginContext context) {
+    if (context && (context->pluginType == CWDROPINCOMPILERTYPE || context->pluginType == CWDROPINLINKERTYPE))
+        return static_cast<CWCompilerLinkerContext *>(context);
+    else
+        return 0;
+}
+
+CW_CALLBACK CWIsPrecompiling(CWPluginContext context, Boolean* isPrecompiling) {
+    CWCompilerLinkerContext *cl;
+    if (!isPrecompiling)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    *isPrecompiling = cl->precompile;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWIsAutoPrecompiling(CWPluginContext context, Boolean* isAutoPrecompiling) {
+    CWCompilerLinkerContext *cl;
+    if (!isAutoPrecompiling)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    *isAutoPrecompiling = cl->autoprecompile;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWIsPreprocessing(CWPluginContext context, Boolean* isPreprocessing) {
+    CWCompilerLinkerContext *cl;
+    if (!isPreprocessing)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    *isPreprocessing = cl->preprocess;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWIsGeneratingDebugInfo(CWPluginContext context, Boolean* isGenerating) {
+    CWCompilerLinkerContext *cl;
+    if (!isGenerating)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    *isGenerating = cl->debuginfo;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWIsCachingPrecompiledHeaders(CWPluginContext context, Boolean* isCaching) {
+    CWCompilerLinkerContext *cl;
+    if (!isCaching)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    *isCaching = cl->cachingPCH;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetBrowseOptions(CWPluginContext context, CWBrowseOptions* browseOptions) {
+    CWCompilerLinkerContext *cl;
+    if (!browseOptions)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    *browseOptions = cl->browseoptions;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetBuildSequenceNumber(CWPluginContext context, SInt32* sequenceNumber) {
+    CWCompilerLinkerContext *cl;
+    if (!sequenceNumber)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    *sequenceNumber = cl->sequenceID;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetTargetInfo(CWPluginContext context, CWTargetInfo* targetInfo) {
+    CWCompilerLinkerContext *cl;
+    if (!targetInfo)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (cl->apiVersion >= 10) {
+        *targetInfo = *cl->targetinfo;
+    } else if (cl->apiVersion >= 8) {
+        CWTargetInfo *ti = cl->targetinfo;
+        targetInfo->outputType = ti->outputType;
+        targetInfo->outfile = ti->outfile;
+        targetInfo->symfile = ti->symfile;
+        targetInfo->runfile = ti->runfile;
+        targetInfo->linkType = ti->linkType;
+        targetInfo->canRun = ti->canRun;
+        targetInfo->canDebug = ti->canDebug;
+        targetInfo->targetCPU = ti->targetCPU;
+        targetInfo->targetOS = ti->targetOS;
+#if CWPLUGIN_HOST == CWPLUGIN_HOST_MACOS
+        targetInfo->outfileCreator = ti->outfileCreator;
+        targetInfo->outfileType = ti->outfileType;
+        targetInfo->debuggerCreator = ti->debuggerCreator;
+        targetInfo->runHelperCreator = ti->runHelperCreator;
+#endif
+    } else {
+        memset(targetInfo, 0, sizeof(CWTargetInfo));
+        if (CWFileSpecNotEmpty(&cl->targetinfo_V7.outfile))
+            targetInfo->outputType = linkOutputFile;
+        else
+            targetInfo->outputType = linkOutputNone;
+        targetInfo->outfile = cl->targetinfo_V7.outfile;
+        targetInfo->symfile = cl->targetinfo_V7.symfile;
+        targetInfo->runfile = cl->targetinfo_V7.outfile;
+        targetInfo->linkType = cl->targetinfo_V7.linkType;
+        targetInfo->canRun = cl->targetinfo_V7.canRun;
+        targetInfo->canDebug = cl->targetinfo_V7.canDebug;
+#if CWPLUGIN_HOST == CWPLUGIN_HOST_MACOS
+        targetInfo->debuggerCreator = cl->targetinfo_V7.debuggerCreator;
+        targetInfo->runHelperCreator = cl->targetinfo_V7.runHelperCreator;
+#endif
+    }
+    return cwNoErr;
+}
+
+CW_CALLBACK CWSetTargetInfo(CWPluginContext context, CWTargetInfo* targetInfo) {
+    CWCompilerLinkerContext *cl;
+    if (!targetInfo)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (cl->apiVersion >= 10) {
+        *cl->targetinfo = *targetInfo;
+    } else if (cl->apiVersion >= 8) {
+        CWTargetInfo *ti = cl->targetinfo;
+        ti->outputType = targetInfo->outputType;
+        ti->outfile = targetInfo->outfile;
+        ti->symfile = targetInfo->symfile;
+        ti->runfile = targetInfo->runfile;
+        ti->linkType = targetInfo->linkType;
+        ti->canRun = targetInfo->canRun;
+        ti->canDebug = targetInfo->canDebug;
+        ti->targetCPU = targetInfo->targetCPU;
+        ti->targetOS = targetInfo->targetOS;
+#if CWPLUGIN_HOST == CWPLUGIN_HOST_MACOS
+        ti->outfileCreator = targetInfo->outfileCreator;
+        ti->outfileType = targetInfo->outfileType;
+        ti->debuggerCreator = targetInfo->debuggerCreator;
+        ti->runHelperCreator = targetInfo->runHelperCreator;
+#endif
+    } else {
+        cl->targetinfo_V7.outfile = targetInfo->outfile;
+        cl->targetinfo_V7.symfile = targetInfo->symfile;
+        cl->targetinfo_V7.linkType = targetInfo->linkType;
+        cl->targetinfo_V7.canRun = targetInfo->canRun;
+        cl->targetinfo_V7.canDebug = targetInfo->canDebug;
+#if CWPLUGIN_HOST == CWPLUGIN_HOST_MACOS
+        cl->targetinfo_V7.useRunHelperApp = targetInfo->runHelperCreator != 0;
+        cl->targetinfo_V7.debuggerCreator = targetInfo->debuggerCreator;
+        cl->targetinfo_V7.runHelperCreator = targetInfo->runHelperCreator;
+#endif
+    }
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetMainFileNumber(CWPluginContext context, SInt32* fileNumber) {
+    CWCompilerLinkerContext *cl;
+    if (!fileNumber)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    *fileNumber = cl->whichfile;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetMainFileID(CWPluginContext context, short* fileID) {
+    CWCompilerLinkerContext *cl;
+    if (!fileID)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    *fileID = cl->fileID;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetMainFileSpec(CWPluginContext context, CWFileSpec* fileSpec) {
+    CWCompilerLinkerContext *cl;
+    if (!fileSpec)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    *fileSpec = cl->sourcefile;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetMainFileText(CWPluginContext context, const char** text, SInt32* textLength) {
+    CWCompilerLinkerContext *cl;
+    if (!text)
+        return cwErrInvalidParameter;
+    if (!textLength)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    *text = cl->sourcetext;
+    *textLength = cl->sourcetextsize;
+    return cwNoErr;
+}
+
+CW_CALLBACK	CWLoadObjectData(CWPluginContext context, SInt32 whichfile, CWMemHandle* objectdata) {
+    CWCompilerLinkerContext *cl;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbLoadObjectData(cl, whichfile, objectdata);
+}
+
+CW_CALLBACK	CWStoreObjectData(CWPluginContext context, SInt32 whichfile, CWObjectData* object) {
+    CWCompilerLinkerContext *cl;
+    if (!object)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbStoreObjectData(cl, whichfile, object);
+}
+
+CW_CALLBACK	CWFreeObjectData(CWPluginContext context, SInt32 whichfile, CWMemHandle objectdata) {
+    CWCompilerLinkerContext *cl;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbFreeObjectData(cl, whichfile, objectdata);
+}
+
+CW_CALLBACK	CWGetSuggestedObjectFileSpec(CWPluginContext context, SInt32 whichfile, CWFileSpec* fileSpec) {
+    CWCompilerLinkerContext *cl;
+    if (!fileSpec)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (context->apiVersion < 10)
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbGetSuggestedObjectFileSpec(cl, whichfile, fileSpec);
+}
+
+CW_CALLBACK	CWGetStoredObjectFileSpec(CWPluginContext context, SInt32 whichfile, CWFileSpec* fileSpec) {
+    CWCompilerLinkerContext *cl;
+    if (!fileSpec)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (context->apiVersion < 10)
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbGetStoredObjectFileSpec(cl, whichfile, fileSpec);
+}
+
+CW_CALLBACK	CWDisplayLines(CWPluginContext context, SInt32 nlines) {
+    CWCompilerLinkerContext *cl;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbDisplayLines(cl, nlines);
+}
+
+CW_CALLBACK	CWGetResourceFile(CWPluginContext context, CWFileSpec* filespec) {
+    CWCompilerLinkerContext *cl;
+    if (!filespec)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbGetResourceFile(cl, filespec);
+}
+
+CW_CALLBACK	CWPutResourceFile(CWPluginContext context, const char* prompt, const char* name, CWFileSpec* filespec) {
+    CWCompilerLinkerContext *cl;
+    if (!prompt)
+        return cwErrInvalidParameter;
+    if (!name)
+        return cwErrInvalidParameter;
+    if (!filespec)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbPutResourceFile(cl, prompt, name, filespec);
+}
+
+CW_CALLBACK	CWCachePrecompiledHeader(CWPluginContext context, const CWFileSpec* filespec, CWMemHandle pchhandle) {
+    CWCompilerLinkerContext *cl;
+    if (!filespec)
+        return cwErrInvalidParameter;
+    if (!pchhandle)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbCachePrecompiledHeader(cl, filespec, pchhandle);
+}
+
+CW_CALLBACK	CWGetPrecompiledHeaderSpec(CWPluginContext context, CWFileSpec *pchspec, const char *target) {
+    CWCompilerLinkerContext *cl;
+    if (!pchspec)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbGetPrecompiledHeaderSpec(cl, pchspec, target);
+}
+
+CW_CALLBACK CWBeginSubCompile(CWPluginContext context, SInt32 whichfile, CWPluginContext* subContext) {
+    CWCompilerLinkerContext *cl;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbBeginSubCompile(cl, whichfile, subContext);
+}
+
+CW_CALLBACK CWEndSubCompile(CWPluginContext subContext) {
+    CWCompilerLinkerContext *cl;
+    if (!(cl = GetContext(subContext)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbEndSubCompile(subContext);
+}
+
+CW_CALLBACK	CWLookUpUnit(CWPluginContext context, const char* name, Boolean isdependency, const void** unitdata, SInt32* unitdatalength) {
+    CWCompilerLinkerContext *cl;
+    if (!name)
+        return cwErrInvalidParameter;
+    if (!unitdata)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbLookUpUnit(cl, name, isdependency, unitdata, unitdatalength);
+}
+
+CW_CALLBACK	CWSBMfiles(CWPluginContext context, short libref) {
+    CWCompilerLinkerContext *cl;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbSBMfiles(cl, libref);
+}
+
+CW_CALLBACK CWStoreUnit(CWPluginContext context, const char* unitname, CWMemHandle unitdata, CWDependencyTag dependencytag) {
+    CWCompilerLinkerContext *cl;
+    if (!unitname)
+        return cwErrInvalidParameter;
+    if (!unitdata)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbStoreUnit(cl, unitname, unitdata, dependencytag);
+}
+
+CW_CALLBACK CWReleaseUnit(CWPluginContext context, void* unitdata) {
+    CWCompilerLinkerContext *cl;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbReleaseUnit(cl, unitdata);
+}
+
+CW_CALLBACK	CWUnitNameToFileName(CWPluginContext context, const char* unitname, char* filename) {
+    CWCompilerLinkerContext *cl;
+    if (!unitname)
+        return cwErrInvalidParameter;
+    if (!filename)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbUnitNameToFileName(cl, unitname, filename);
+}
+
+CW_CALLBACK	CWGetTargetStorage(CWPluginContext context, void** storage) {
+    CWCompilerLinkerContext *cl;
+    if (!storage)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (cl->apiVersion >= 8) {
+        *storage = cl->targetStorage;
+        return cwNoErr;
+    } else {
+        return cwErrRequestFailed;
+    }
+}
+
+CW_CALLBACK	CWSetTargetStorage(CWPluginContext context, void* storage) {
+    CWCompilerLinkerContext *cl;
+    if (!storage)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (cl->apiVersion >= 8) {
+        cl->targetStorage = storage;
+        return cwNoErr;
+    } else {
+        return cwErrRequestFailed;
+    }
+}
+
+CW_CALLBACK	CWOSErrorMessage(CWPluginContext context, const char *msg, OSErr errorcode) {
+    CWCompilerLinkerContext *cl;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbOSErrorMessage(cl, msg, errorcode);
+}
+
+CW_CALLBACK	CWOSAlert(CWPluginContext context, const char* message, OSErr errorcode) {
+    CWCompilerLinkerContext *cl;
+    if (!message)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbOSAlert(cl, message, errorcode);
+}
+
+CW_CALLBACK CWGetModifiedFiles(CWPluginContext context, SInt32* modifiedFileCount, const SInt32** modifiedFiles) {
+    CWCompilerLinkerContext *cl;
+    if (!modifiedFileCount)
+        return cwErrInvalidParameter;
+    if (!modifiedFiles)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (context->apiVersion < 9)
+        return cwErrInvalidCallback;
+    return cl->callbacks->cbGetModifiedFiles(cl, modifiedFileCount, modifiedFiles);
+}
+
+CW_CALLBACK CWGetCommandLineArgs(CWPluginContext context, const char** commandLineArgs) {
+    CWCompilerLinkerContext *cl;
+    if (!commandLineArgs)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (cl->apiVersion < 11)
+        return cwErrInvalidCallback;
+    if (!cl->commandLineArgs && cl->callbacks->cbGetRuntimeSettings(cl))
+        return cwErrRequestFailed;
+    *commandLineArgs = cl->commandLineArgs;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetWorkingDirectory(CWPluginContext context, CWFileSpec* workingDirectorySpec) {
+    CWCompilerLinkerContext *cl;
+    if (!workingDirectorySpec)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (cl->apiVersion < 11)
+        return cwErrInvalidCallback;
+    if (!cl->commandLineArgs && cl->callbacks->cbGetRuntimeSettings(cl))
+        return cwErrRequestFailed;
+    *workingDirectorySpec = *cl->workingDirectorySpec;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetEnvironmentVariableCount(CWPluginContext context, SInt32* count) {
+    CWCompilerLinkerContext *cl;
+    if (!count)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (cl->apiVersion < 11)
+        return cwErrInvalidCallback;
+    if (!cl->commandLineArgs && cl->callbacks->cbGetRuntimeSettings(cl))
+        return cwErrRequestFailed;
+    *count = cl->numEnvironmentVariables;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetEnvironmentVariable(CWPluginContext context, SInt32 index, const char** name, const char** value) {
+    CWCompilerLinkerContext *cl;
+    if (!name)
+        return cwErrInvalidParameter;
+    if (!value)
+        return cwErrInvalidParameter;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (cl->apiVersion < 11)
+        return cwErrInvalidCallback;
+    if (!cl->commandLineArgs && cl->callbacks->cbGetRuntimeSettings(cl))
+        return cwErrRequestFailed;
+    if (index < 0 || index >= cl->numEnvironmentVariables)
+        return cwErrInvalidParameter;
+    *name = cl->environmentVariables[index].name;
+    *value = cl->environmentVariables[index].value;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetFrameworkCount(CWPluginContext context, SInt32* frameworkCount) {
+    CWCompilerLinkerContext *cl;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (cl->apiVersion < 11)
+        return cwErrInvalidCallback;
+    if (!cl->commandLineArgs && cl->callbacks->cbGetFrameworkCount(cl, frameworkCount))
+        return cwErrRequestFailed;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetFrameworkInfo(CWPluginContext context, SInt32 whichFramework, CWFrameworkInfo* frameworkInfo) {
+    CWCompilerLinkerContext *cl;
+    if (!(cl = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (cl->apiVersion < 11)
+        return cwErrInvalidCallback;
+    if (!cl->commandLineArgs && cl->callbacks->cbGetFrameworkInfo(cl, whichFramework, frameworkInfo))
+        return cwErrRequestFailed;
+    return cwNoErr;
+}