MWCC/UCLTMain.c

#include "UCWInterface.h"

static short CLT_dummymain() {
    return 0;
}

static short CLT_GetDropInFlags(const DropInFlags **flags, long *flagsSize) {
    static const DropInFlags sFlags = {
            kCurrentDropInFlagsVersion,
            CWFOURCHAR('c','l','d','r'),
            7,
            0,
            0,
            12
    };
    *flags = &sFlags;
    *flagsSize = sizeof(sFlags);
    return 0;
}

static short CLT_GetDropInName(const char **dropInName) {
    static const char *sDropInName = "Command-Line Driver";
    *dropInName = sDropInName;
    return 0;
}

static short CLT_GetDisplayName(const char **displayName) {
    static const char *sDisplayName = "Command-Line Driver";
    *displayName = sDisplayName;
    return 0;
}

static short CLT_GetPanelList(const CWPanelList **panelList) {
    static const char *sPanelNames[4];
    static CWPanelList sPanelList = {
            kCurrentCWPanelListVersion,
            4,
            sPanelNames
    };

    sPanelNames[0] = "CmdLine Panel";
    if (clState.plugintype == CWDROPINCOMPILERTYPE) {
        sPanelNames[1] = "CmdLine Compiler Panel";
        sPanelNames[2] = "CmdLine Linker Panel";
        sPanelList.count = 3;
    } else {
        sPanelNames[1] = "CmdLine Linker Panel";
        sPanelList.count = 2;
    }
    *panelList = &sPanelList;
    return 0;
}

static short CLT_GetTargetList(const CWTargetList **targetList) {
    static CWDataType sCPU = CWFOURCHAR('*','*','*','*');
    static CWDataType sOS = CWFOURCHAR('*','*','*','*');
    static CWTargetList sTargetList = {
            kCurrentCWTargetListVersion,
            1,
            &sCPU,
            1,
            &sOS
    };
    *targetList = &sTargetList;
    return 0;
}

static short CLT_GetVersionInfo(const VersionInfo **versioninfo) {
    static const VersionInfo vi = {
            3, 0, 0, 0
    };
    *versioninfo = &vi;
    return 0;
}

static short CLT_GetFileTypeMappings(const OSFileTypeMappingList **mappingList) {
    static const OSFileTypeMapping ftmes[2] = {
            {CWFOURCHAR('B','r','w','s'), "DubL", 4, 0, 0},
            {CWFOURCHAR('M','M','P','r'), "looc", 4, 0, 0}
    };
    static const OSFileTypeMappingList ftml = {
            2,
            ftmes
    };
    *mappingList = &ftml;
    return 0;
}

static BasePluginCallbacks clcb = {
        CLT_dummymain,
        CLT_GetDropInFlags,
        CLT_GetDisplayName,
        CLT_GetDropInName,
        CLT_GetPanelList,
        0,
        0,
        CLT_GetVersionInfo,
        CLT_GetFileTypeMappings
};

static int RegisterStaticCmdLinePlugin() {
    return RegisterStaticPlugin(&clcb);
}

const char *STR12000[100]; // TODO do me later

static int RegisterCmdLineResources() {
    return RegisterResource("Command-line strings", 12000, &STR12000);
}

static int special_debug(unsigned char flag, char *) {
    if (flag) {
        SetupDebuggingTraps();
        return 1;
    } else {
        return 0;
    }
}

static int special_plugin_debug(unsigned char flag, char *) {
    if (flag) {
        clState.pluginDebug = 1;
        return 1;
    } else {
        return clState.pluginDebug;
    }
}

static int special_stdout_base(unsigned char flag, char *) {
    if (flag) {
        return 1;
    } else {
        return clState.stdoutBase != 0;
    }
}

struct SpecialOption {
    const char *name;
    char **location;
    int (*callback)(unsigned char a, char *b);
};
static struct SpecialOption special_options[3] = {
        {"", 0, special_debug},
        {"--plugin-debug", 0, special_plugin_debug},
        {"--stdout", /*TODO clState*/ 0, special_stdout_base}
};

void Main_PreParse(int *pArgc, char ***pArgv) {
    int i;
    struct SpecialOption *opt;

    if (*pArgc > 1) {
    restart:
        for (i = 0, opt = &special_options[0]; i < 3; i++, opt++) {
            if (!strcmp(opt->name, (*pArgv)[1])) {
                if (opt->location) {
                    *opt->location = (*pArgv)[2];
                    opt->callback(1, *opt->location);
                    (*pArgv)[1] = (*pArgv)[0];
                    (*pArgc)--;
                    (*pArgv)++;

                    (*pArgv)[1] = (*pArgv)[0];
                    (*pArgc)--;
                    (*pArgv)++;
                } else {
                    opt->callback(1, 0);
                    (*pArgv)[1] = (*pArgv)[0];
                    (*pArgc)--;
                    (*pArgv)++;
                }
                break;
            }
        }

        if ((*pArgc) > 1 && i < 3)
            goto restart;
    }
}

void Main_PassSpecialArgs(void *unk1, void *unk2) {
    int i;
    struct SpecialOption *opt;

    for (i = 0; i < 3; i++) {
        opt = &special_options[i];
        if (opt->callback(0, 0)) {
            AppendArgumentList(unk1, unk2, opt->name);
            if (opt->location)
                AppendArgumentList(unk1, unk2, (*opt->location) ? *opt->location : "");
        }
    }
}

static int MainInitialized;
void *gProj;
PCmdLine optsCmdLine;
PCmdLineEnvir optsEnvir;
PCmdLineCompiler optsCompiler;
PCmdLineLinker optsLinker;

int Main_Initialize(int argc, const char **argv) {
    static char secret[8];
    char buf[256];

    OS_InitProgram(&argc, &argv);
    memset(&clState, 0, sizeof(CLState));
    special_options[0].name = secret;
    secret[7] = 0;
    secret[4] = 'b';
    secret[1] = '-';
    secret[5] = 'u';
    secret[2] = 'd';
    secret[0] = '-';
    secret[3] = 'e';
    secret[6] = 'g';

    Main_PreParse(&argc, &argv);
    clState.argc = argc;
    clState.argv = argv;
    // TODO more shite

    MainInitialized = 1;
    return 0;
}

int Main_Terminate(int code) {
    if (MainInitialized) {
        Plugins_Term();
        License_Terminate();
        Proj_Terminate(gProj);
        IO_Terminate();
        MainInitialized = 0;
    }
    return code;
}

static int Main_ParseCommandLine() {
    // TODO: clState, Plugins, gTarg, ...
}

static int Main_SetupParamBlock() {
    // TODO: OS, PrefPanes, clState, ...
    PrefPanelsChangedCallback(0);
}

static int Main_ResolveProject() {
    // TODO: Various project things
}

static int UpdatePCmdLineFromVersion(const PCmdLine *oldVer, PCmdLine *newVer) {
    static unsigned char warned;
    short ver = oldVer->version;
    *newVer = *oldVer;

    // TODO: clState
    return 0;
}

static int UpdatePCmdLineEnvirFromVersion(const PCmdLineEnvir *oldVer, PCmdLineEnvir *newVer) {
    static unsigned char warned;
    short ver = oldVer->version;
    *newVer = *oldVer;

    // TODO: clState
    return 0;
}

static int UpdatePCmdLineCompilerFromVersion(const PCmdLineCompiler *oldVer, PCmdLineCompiler *newVer) {
    static unsigned char warned;
    short ver = oldVer->version;
    *newVer = *oldVer;

    // TODO: clState
    return 0;
}

static int UpdatePCmdLineLinkerFromVersion(const PCmdLineLinker *oldVer, PCmdLineLinker *newVer) {
    static unsigned char warned;
    short ver = oldVer->version;
    *newVer = *oldVer;

    // TODO: clState
    return 0;
}

static int UpdatePrefPanels(const char *name) {
    PrefPanel *panel;
    Handle handle;

    if (!name || !ustrcmp(name, "CmdLine Panel")) {
        if ((panel = Prefs_FindPanel("CmdLine Panel")) && (handle = PrefPanel_GetHandle(panel))) {
            if (name) {
                if (!UpdatePCmdLineFromVersion((PCmdLine *) *handle, &optsCmdLine))
                    return 0;
            }
        } else {
            CLReportError(91, "CmdLine Panel");
            return 0;
        }
    }

    if (!name || !ustrcmp(name, "CmdLine Environment")) {
        if ((panel = Prefs_FindPanel("CmdLine Environment")) && (handle = PrefPanel_GetHandle(panel))) {
            if (name) {
                if (!UpdatePCmdLineEnvirFromVersion((PCmdLineEnvir *) *handle, &optsEnvir))
                    return 0;
            }
        } else {
            CLReportError(91, "CmdLine Environment");
            return 0;
        }
    }

    if (!name || !ustrcmp(name, "CmdLine Compiler Panel")) {
        if ((panel = Prefs_FindPanel("CmdLine Compiler Panel")) && (handle = PrefPanel_GetHandle(panel))) {
            if (name) {
                if (!UpdatePCmdLineCompilerFromVersion((PCmdLineCompiler *) *handle, &optsCompiler))
                    return 0;
            }
        } else {
            CLReportError(91, "CmdLine Compiler Panel");
            return 0;
        }
    }

    if (!name || !ustrcmp(name, "CmdLine Linker Panel")) {
        if ((panel = Prefs_FindPanel("CmdLine Linker Panel")) && (handle = PrefPanel_GetHandle(panel))) {
            if (name) {
                if (!UpdatePCmdLineLinkerFromVersion((PCmdLineLinker *) *handle, &optsLinker))
                    return 0;
            }
        } else {
            CLReportError(91, "CmdLine Linker Panel");
            return 0;
        }
    }

    return 1;
}

static int SetupCmdLinePrefPanels() {
    int result;

    PrefPanelsChangedCallback = UpdatePrefPanels;
    result = Prefs_AddPanel(
            PrefPanel_New("CmdLine Environment", &optsEnvir, sizeof(PCmdLineEnvir))
    );
    result |= (
            Prefs_AddPanel(PrefPanel_New("CmdLine Panel", 0, sizeof(PCmdLine)))
            && Prefs_AddPanel(PrefPanel_New("CmdLine Compiler Panel", 0, sizeof(PCmdLineCompiler)))
            && Prefs_AddPanel(PrefPanel_New("CmdLine Linker Panel", 0, sizeof(PCmdLineLinker)))
    );

    return result;
}

static int Main_SetupContext() {
    // TODO Target, Plugins, clState
    return 1;
}

jmp_buf exit_program;

int Main_Driver() {
    volatile int result;

    result = setjmp(exit_program);
    if (!result) {
        if (!SetupCmdLinePrefPanels())
            CLFatalError("Could not initialize preferences");

        Main_SetupContext();
        if (!(result = Main_ParseCommandLine())) {
            if (!(result = Main_SetupParamBlock()))
                result = Main_ResolveProject();
        }
    } else {
        result = 1;
    }

    return result;
}