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

command_line/PluginLib/Src/Library/CWParserPluginsPrivate.cpp

@@ -0,0 +1,207 @@
+#include "plugin_internal.h"
+
+static CWParserContext *GetContext(CWPluginContext context) {
+    if (context && (context->pluginType == CWDROPINPARSERTYPE))
+        return static_cast<CWParserContext *>(context);
+    else
+        return 0;
+}
+
+CW_CALLBACK CWParserGetBuildDate(CWPluginContext context, const char **bdate, const char **btime) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!bdate)
+        return cwErrInvalidParameter;
+    if (!btime)
+        return cwErrInvalidParameter;
+    *bdate = pc->build_date;
+    *btime = pc->build_time;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWParserGetCommandLine(CWPluginContext context, CWCommandLineArgs **args) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!args)
+        return cwErrInvalidParameter;
+    *args = pc->args;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWParserGetTargetInfo(CWPluginContext context, CWDataType *cpu, CWDataType *os) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!cpu)
+        return cwErrInvalidParameter;
+    if (!os)
+        return cwErrInvalidParameter;
+    *cpu = pc->cpu;
+    *os = pc->os;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWParserGetToolInfo(CWPluginContext context, const ToolVersionInfo **toolVersionInfo) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!toolVersionInfo)
+        return cwErrInvalidParameter;
+    *toolVersionInfo = pc->build_tool;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWParserGetPlugins(CWPluginContext context, int *numPlugins, const CLPluginInfo **pluginInfo) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!numPlugins)
+        return cwErrInvalidParameter;
+    if (!pluginInfo)
+        return cwErrInvalidParameter;
+    *numPlugins = pc->numPlugins;
+    *pluginInfo = pc->plugins;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWParserGetPanels(CWPluginContext context, int *numPanels, const char ***panelNames) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!numPanels)
+        return cwErrInvalidParameter;
+    if (!panelNames)
+        return cwErrInvalidParameter;
+    *numPanels = pc->numPanels;
+    *panelNames = pc->panelNames;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWParserStoreCommandLineForPanel(CWPluginContext context, int index, const CWCommandLineArgs *args) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (index < 0 || index >= pc->numPanels)
+        return cwErrInvalidParameter;
+    if (!args)
+        return cwErrInvalidParameter;
+    pc->panel_args[index] = *args;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWParserStoreCommandLineForPlugin(CWPluginContext context, int index, const CWCommandLineArgs *args) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (index < 0 || index >= pc->numPlugins)
+        return cwErrInvalidParameter;
+    if (!args)
+        return cwErrInvalidParameter;
+    pc->plugin_args[index] = *args;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWParserSetNamedPreferences(CWPluginContext context, const char *panelName, Handle paneldata) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!panelName)
+        return cwErrInvalidParameter;
+    return pc->callbacks->cbParserSetNamedPreferences(pc, panelName, paneldata);
+}
+
+CW_CALLBACK CWParserAddAccessPath(CWPluginContext context, const CWNewAccessPathInfo *api) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!api)
+        return cwErrInvalidParameter;
+    return pc->callbacks->cbParserAddAccessPath(pc, api);
+}
+
+CW_CALLBACK CWParserSwapAccessPaths(CWPluginContext context) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    return pc->callbacks->cbParserSwapAccessPaths(pc);
+}
+
+CW_CALLBACK CWParserSetOutputFileDirectory(CWPluginContext context, const CWFileSpec *idefss) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!idefss)
+        return cwErrInvalidParameter;
+    return pc->callbacks->cbParserSetOutputFileDirectory(pc, idefss);
+}
+
+CW_CALLBACK CWParserSetFileOutputName(CWPluginContext context, SInt32 position, short which, const char *outfilename) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!outfilename)
+        return cwErrInvalidParameter;
+    return pc->callbacks->cbParserSetFileOutputName(pc, position, which, outfilename);
+}
+
+CW_CALLBACK CWParserAddOverlay1Group(CWPluginContext context, const char *name, const CWAddr64 *addr, SInt32 *newGroupNumber) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!name)
+        return cwErrInvalidParameter;
+    if (!addr)
+        return cwErrInvalidParameter;
+    if (!newGroupNumber)
+        return cwErrInvalidParameter;
+    return pc->callbacks->cbParserAddOverlay1Group(pc, name, addr, newGroupNumber);
+}
+
+CW_CALLBACK CWParserAddOverlay1(CWPluginContext context, const char *name, SInt32 groupNumber, SInt32 *newOverlayNumber) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!name)
+        return cwErrInvalidParameter;
+    if (!newOverlayNumber)
+        return cwErrInvalidParameter;
+    return pc->callbacks->cbParserAddOverlay1(pc, name, groupNumber, newOverlayNumber);
+}
+
+CW_CALLBACK CWParserAddSegment(CWPluginContext context, const char *name, short attrs, SInt32 *newSegmentNumber) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!name)
+        return cwErrInvalidParameter;
+    if (!newSegmentNumber)
+        return cwErrInvalidParameter;
+    return pc->callbacks->cbParserAddSegment(pc, name, attrs, newSegmentNumber);
+}
+
+CW_CALLBACK CWParserSetSegment(CWPluginContext context, SInt32 segmentNumber, const char *name, short attrs) {
+    CWParserContext *pc;
+    if (!(pc = GetContext(context)))
+        return cwErrInvalidCallback;
+    if (!name)
+        return cwErrInvalidParameter;
+    return pc->callbacks->cbParserSetSegment(pc, segmentNumber, name, attrs);
+}
+
+CW_CALLBACK CWParserCreateVirtualFile(CWPluginContext context, const char *name, CWMemHandle text) {
+    CWNewTextDocumentInfo info;
+    info.documentname = name;
+    info.text = text;
+    info.markDirty = 1;
+    return CWCreateNewTextDocument(context, &info);
+}
+
+CW_CALLBACK CWParserDisplayTextHandle(CWPluginContext context, const char *name, CWMemHandle text) {
+    CWNewTextDocumentInfo info;
+    info.documentname = name;
+    info.text = text;
+    info.markDirty = 0;
+    return CWCreateNewTextDocument(context, &info);
+}

command_line/PluginLib/Src/Library/CWPluginsPrivate.cpp

@@ -0,0 +1,513 @@
+#include "plugin_internal.h"
+
+// Forward declarations
+CWResult OSErrtoCWResult(OSErr err);
+
+static Boolean ValidateContext(CWPluginContext context) {
+    return context
+           && (context->shellSignature == CWFOURCHAR('C','W','I','E'))
+           && (context->request != reqInitialize)
+           && (context->request != reqTerminate)
+           && (context->request != reqIdle);
+}
+
+static Boolean ValidateInitTermContext(CWPluginContext context) {
+    return context
+           && (context->shellSignature == CWFOURCHAR('C','W','I','E'))
+           && ((context->request == reqInitialize)
+           || (context->request == reqTerminate)
+           || (context->request == reqIdle));
+}
+
+static Boolean IsVCSContext(CWPluginContext context) {
+    return context && (context->pluginType == CWDROPINVCSTYPE);
+}
+
+CW_CALLBACK CWGetPluginRequest(CWPluginContext context, SInt32 *request) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    if (request == NULL)
+        return cwErrInvalidParameter;
+
+    *request = context->request;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetAPIVersion(CWPluginContext context, SInt32 *version) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    if (version == NULL)
+        return cwErrInvalidParameter;
+
+    *version = context->apiVersion;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetIDEInfo(CWPluginContext context, CWIDEInfo *info) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    if (info == NULL)
+        return cwErrInvalidParameter;
+
+    *info = *context->shellInfo;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetCallbackOSError(CWPluginContext context, CWOSResult *error) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    if (error == NULL)
+        return cwErrInvalidParameter;
+
+    *error = context->callbackOSError;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWSetPluginOSError(CWPluginContext context, CWOSResult error) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+
+    context->pluginOSError = error;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetProjectFile(CWPluginContext context, CWFileSpec *projectSpec) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (projectSpec == NULL)
+        return cwErrInvalidParameter;
+
+    *projectSpec = context->projectFile;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetTargetDataDirectory(CWPluginContext context, CWFileSpec *targetDataDirectorySpec) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (targetDataDirectorySpec == NULL)
+        return cwErrInvalidParameter;
+    if (context->targetDataDirectorySpec == NULL)
+        return cwErrInvalidCallback;
+
+    *targetDataDirectorySpec = *context->targetDataDirectorySpec;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetTargetName(CWPluginContext context, char *name, short maxLength) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+
+    if (context->apiVersion >= 8)
+        return context->callbacks->cbGetTargetName(context, name, maxLength);
+    else
+        return cwErrRequestFailed;
+}
+
+CW_CALLBACK CWGetProjectFileCount(CWPluginContext context, SInt32 *count) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (count == NULL)
+        return cwErrInvalidParameter;
+
+    *count = context->numFiles;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetOutputFileDirectory(CWPluginContext context, CWFileSpec *outputFileDirectory) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (outputFileDirectory == NULL)
+        return cwErrInvalidParameter;
+
+    *outputFileDirectory = context->outputFileDirectory;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetOverlay1GroupsCount(CWPluginContext context, SInt32 *count) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (count == NULL)
+        return cwErrInvalidParameter;
+
+    *count = context->numOverlayGroups;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetFileInfo(CWPluginContext context, SInt32 whichfile, Boolean checkFileLocation, CWProjectFileInfo *fileinfo) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (fileinfo == NULL)
+        return cwErrInvalidParameter;
+
+    return context->callbacks->cbGetFileInfo(context, whichfile, checkFileLocation, fileinfo);
+}
+
+CW_CALLBACK CWFindAndLoadFile(CWPluginContext context, const char *filename, CWFileInfo *fileinfo) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (filename == NULL)
+        return cwErrInvalidParameter;
+    if (fileinfo == NULL)
+        return cwErrInvalidParameter;
+
+    return context->callbacks->cbFindAndLoadFile(context, filename, fileinfo);
+}
+
+static CWResult EnsureCachedAccessPaths(CWPluginContext context) {
+    if (!context->accessPathList) {
+        CWResult res = context->callbacks->cbCacheAccessPathList(context);
+        if (res)
+            return res;
+        if (!context->accessPathList)
+            return cwErrRequestFailed;
+    }
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetAccessPathListInfo(CWPluginContext context, CWAccessPathListInfo *pathListInfo) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (pathListInfo == NULL)
+        return cwErrInvalidParameter;
+    if (context->apiVersion < 10)
+        return cwErrInvalidCallback;
+    CWResult res = EnsureCachedAccessPaths(context);
+    if (res)
+        return res;
+    pathListInfo->systemPathCount = context->accessPathList->systemPathCount;
+    pathListInfo->userPathCount = context->accessPathList->userPathCount;
+    pathListInfo->alwaysSearchUserPaths = context->accessPathList->alwaysSearchUserPaths;
+    pathListInfo->convertPaths = context->accessPathList->convertPaths;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetAccessPathInfo(CWPluginContext context, CWAccessPathType pathType, SInt32 whichPath, CWAccessPathInfo *pathInfo) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (pathInfo == NULL)
+        return cwErrInvalidParameter;
+    if (context->apiVersion < 10)
+        return cwErrInvalidCallback;
+    CWResult res = EnsureCachedAccessPaths(context);
+    if (res)
+        return res;
+
+    IDEAccessPath *paths;
+    SInt32 count;
+    switch (pathType) {
+        case cwSystemPath:
+            paths = context->accessPathList->systemPaths;
+            count = context->accessPathList->systemPathCount;
+            break;
+        case cwUserPath:
+            paths = context->accessPathList->userPaths;
+            count = context->accessPathList->userPathCount;
+            break;
+        default:
+            return cwErrInvalidParameter;
+    }
+
+    if (whichPath < 0 || whichPath >= count)
+        return cwErrInvalidParameter;
+
+    IDEAccessPath *path = &paths[whichPath];
+    pathInfo->pathSpec = path->pathSpec;
+    pathInfo->recursive = path->recursive;
+    pathInfo->subdirectoryCount = path->subdirectoryCount;
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetAccessPathSubdirectory(CWPluginContext context, CWAccessPathType pathType, SInt32 whichPath,
+                                     SInt32 whichSubdirectory, CWFileSpec *subdirectory) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (subdirectory == NULL)
+        return cwErrInvalidParameter;
+    if (context->apiVersion < 10)
+        return cwErrInvalidCallback;
+    CWResult res = EnsureCachedAccessPaths(context);
+    if (res)
+        return res;
+
+    IDEAccessPath *paths;
+    SInt32 count;
+    switch (pathType) {
+        case cwSystemPath:
+            paths = context->accessPathList->systemPaths;
+            count = context->accessPathList->systemPathCount;
+            break;
+        case cwUserPath:
+            paths = context->accessPathList->userPaths;
+            count = context->accessPathList->userPathCount;
+            break;
+        default:
+            return cwErrInvalidParameter;
+    }
+
+    if (whichPath < 0 || whichPath >= count)
+        return cwErrInvalidParameter;
+
+    IDEAccessPath *path = &paths[whichPath];
+    if (whichSubdirectory < 0 || whichSubdirectory >= path->subdirectoryCount)
+        return cwErrInvalidParameter;
+
+    *subdirectory = path->subdirectories[whichSubdirectory];
+    return cwNoErr;
+}
+
+CW_CALLBACK CWGetFileText(CWPluginContext context, const CWFileSpec *filespec, const char **text, SInt32 *textLength,
+                       short *filedatatype) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (!filespec)
+        return cwErrInvalidParameter;
+    if (!text)
+        return cwErrInvalidParameter;
+    if (!textLength)
+        return cwErrInvalidParameter;
+    if (!filedatatype)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbGetFileText(context, filespec, text, textLength, filedatatype);
+}
+
+CW_CALLBACK CWReleaseFileText(CWPluginContext context, const char *text) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+
+    if (text)
+        return context->callbacks->cbReleaseFileText(context, text);
+    else
+        return cwNoErr;
+}
+
+CW_CALLBACK CWGetSegmentInfo(CWPluginContext context, SInt32 whichsegment, CWProjectSegmentInfo *segmentinfo) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (!segmentinfo)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbGetSegmentInfo(context, whichsegment, segmentinfo);
+}
+
+CW_CALLBACK CWGetOverlay1GroupInfo(CWPluginContext context, SInt32 whichgroup, CWOverlay1GroupInfo *groupinfo) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (!groupinfo)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbGetOverlay1GroupInfo(context, whichgroup, groupinfo);
+}
+
+CW_CALLBACK
+CWGetOverlay1Info(CWPluginContext context, SInt32 whichgroup, SInt32 whichoverlay, CWOverlay1Info *overlayinfo) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (!overlayinfo)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbGetOverlay1Info(context, whichgroup, whichoverlay, overlayinfo);
+}
+
+CW_CALLBACK CWGetOverlay1FileInfo(CWPluginContext context, SInt32 whichgroup, SInt32 whichoverlay, SInt32 whichoverlayfile,
+                               CWOverlay1FileInfo *fileinfo) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (!fileinfo)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbGetOverlay1FileInfo(context, whichgroup, whichoverlay, whichoverlayfile, fileinfo);
+}
+
+CW_CALLBACK CWReportMessage(CWPluginContext context, const CWMessageRef *msgRef, const char *line1, const char *line2,
+                         short errorlevel, SInt32 errorNumber) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbReportMessage(context, msgRef, line1, line2, errorlevel, errorNumber);
+}
+
+CW_CALLBACK CWAlert(CWPluginContext context, const char *msg1, const char *msg2, const char *msg3, const char *msg4) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbAlert(context, msg1, msg2, msg3, msg4);
+}
+
+CW_CALLBACK CWShowStatus(CWPluginContext context, const char *line1, const char *line2) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbShowStatus(context, line1, line2);
+}
+
+CW_CALLBACK CWUserBreak(CWPluginContext context) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbUserBreak(context);
+}
+
+CW_CALLBACK CWGetNamedPreferences(CWPluginContext context, const char *prefsname, CWMemHandle *prefsdata) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (!prefsname)
+        return cwErrInvalidParameter;
+    if (!prefsdata)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbGetNamedPreferences(context, prefsname, prefsdata);
+}
+
+CW_CALLBACK CWStorePluginData(CWPluginContext context, SInt32 whichfile, CWDataType type, CWMemHandle prefsdata) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbStorePluginData(context, whichfile, type, prefsdata);
+}
+
+CW_CALLBACK CWGetPluginData(CWPluginContext context, SInt32 whichfile, CWDataType type, CWMemHandle *prefsdata) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbGetPluginData(context, whichfile, type, prefsdata);
+}
+
+CW_CALLBACK CWSetModDate(CWPluginContext context, const CWFileSpec *filespec, CWFileTime *moddate, Boolean isGenerated) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (!filespec)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbSetModDate(context, filespec, moddate, isGenerated);
+}
+
+CW_CALLBACK CWAddProjectEntry(CWPluginContext context, const CWFileSpec *fileSpec, Boolean isGenerated,
+                           const CWNewProjectEntryInfo *projectEntryInfo, SInt32 *whichfile) {
+    if (IsVCSContext(context) || !ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (!fileSpec)
+        return cwErrInvalidParameter;
+    if (context->apiVersion < 8)
+        return cwErrRequestFailed;
+    return context->callbacks->cbAddProjectEntry(context, fileSpec, isGenerated, projectEntryInfo, whichfile);
+}
+
+CW_CALLBACK CWCreateNewTextDocument(CWPluginContext context, const CWNewTextDocumentInfo *docinfo) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (!docinfo)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbCreateNewTextDocument(context, docinfo);
+}
+
+CW_CALLBACK CWAllocateMemory(CWPluginContext context, SInt32 size, Boolean isPermanent, void **ptr) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    if (!ptr)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbAllocateMemory(context, size, isPermanent, ptr);
+}
+
+CW_CALLBACK CWFreeMemory(CWPluginContext context, void *ptr, Boolean isPermanent) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    if (!ptr)
+        return cwNoErr;
+    return context->callbacks->cbFreeMemory(context, ptr, isPermanent);
+}
+
+CW_CALLBACK CWAllocMemHandle(CWPluginContext context, SInt32 size, Boolean useTempMemory, CWMemHandle *handle) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    if (!handle)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbAllocMemHandle(context, size, useTempMemory, handle);
+}
+
+CW_CALLBACK CWFreeMemHandle(CWPluginContext context, CWMemHandle handle) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbFreeMemHandle(context, handle);
+}
+
+CW_CALLBACK CWGetMemHandleSize(CWPluginContext context, CWMemHandle handle, SInt32 *size) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    if (!size)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbGetMemHandleSize(context, handle, size);
+}
+
+CW_CALLBACK CWResizeMemHandle(CWPluginContext context, CWMemHandle handle, SInt32 newSize) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbResizeMemHandle(context, handle, newSize);
+}
+
+CW_CALLBACK CWLockMemHandle(CWPluginContext context, CWMemHandle handle, Boolean moveHi, void **ptr) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    if (!ptr)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbLockMemHandle(context, handle, moveHi, ptr);
+}
+
+CW_CALLBACK CWUnlockMemHandle(CWPluginContext context, CWMemHandle handle) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbUnlockMemHandle(context, handle);
+}
+
+CW_CALLBACK CWDonePluginRequest(CWPluginContext, CWResult resultCode) {
+    return resultCode;
+}
+
+CW_CALLBACK CWPreDialog(CWPluginContext context) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbPreDialog(context);
+}
+
+CW_CALLBACK CWPostDialog(CWPluginContext context) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbPostDialog(context);
+}
+
+CW_CALLBACK CWPreFileAction(CWPluginContext context, const CWFileSpec *theFile) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbPreFileAction(context, theFile);
+}
+
+CW_CALLBACK CWPostFileAction(CWPluginContext context, const CWFileSpec *theFile) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbPostFileAction(context, theFile);
+}
+
+CW_CALLBACK CWCheckoutLicense(CWPluginContext context, const char *featureName, const char *licenseVersion, SInt32 flags, void *reserved, SInt32 *cookie) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbCheckoutLicense(context, featureName, licenseVersion, flags, reserved, cookie);
+}
+
+CW_CALLBACK CWCheckinLicense(CWPluginContext context, SInt32 cookie) {
+    if (!ValidateContext(context) && !ValidateInitTermContext(context))
+        return cwErrInvalidParameter;
+    return context->callbacks->cbCheckinLicense(context, cookie);
+}
+
+CW_CALLBACK CWResolveRelativePath(CWPluginContext context, const CWRelativePath *relativePath, CWFileSpec *fileSpec, Boolean create) {
+    if (!ValidateContext(context))
+        return cwErrInvalidParameter;
+    if (relativePath == NULL)
+        return cwErrInvalidParameter;
+    if (fileSpec == NULL)
+        return cwErrInvalidParameter;
+    return context->callbacks->cbResolveRelativePath(context, relativePath, fileSpec, create);
+}
+
+CW_CALLBACK CWMacOSErrToCWResult(CWPluginContext context, OSErr err) {
+    return OSErrtoCWResult(err);
+}
+
+CWResult OSErrtoCWResult(OSErr err) {
+    switch (err) {
+        case noErr: return cwNoErr;
+        case userCanceledErr: return cwErrUserCanceled;
+        case paramErr: return cwErrInvalidParameter;
+        case memFullErr: return cwErrOutOfMemory;
+        case fnfErr: return cwErrFileNotFound;
+        default: return cwErrRequestFailed;
+    }
+}
+

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