MWCC/command_line/PluginLib/Src/Library/DropInCompilerLinkerPrivate.cpp

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