path: root/UCLTMain.c

#include "UCWInterface.h"

static short CLT_dummymain(void *context) {
    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);
}

// TODO do me later - this comes from CmdLine/Project/Resources/CLErrors.r
const char *STR12000[100];

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

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

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

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

struct SpecialOption {
    const char *optname;
    char **argp;
    int (*func)(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) {
    struct SpecialOption *so;
    int idx;

    if (*pArgc > 1) {
    restart:
        for (idx = 0, so = &special_options[0]; idx < 3; idx++, so++) {
            if (!strcmp(so->optname, (*pArgv)[1])) {
                if (so->argp) {
                    *so->argp = (*pArgv)[2];
                    so->func(1, *so->argp);
                    (*pArgv)[1] = (*pArgv)[0];
                    (*pArgc)--;
                    (*pArgv)++;

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

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

void Main_PassSpecialArgs(void *unk1, void *unk2) {
    struct SpecialOption *so;
    int idx;

    for (idx = 0; idx < 3; idx++) {
        so = &special_options[idx];
        if (so->func(0, 0)) {
            AppendArgumentList(unk1, unk2, so->optname);
            if (so->argp)
                AppendArgumentList(unk1, unk2, (*so->argp) ? *so->argp : "");
        }
    }
}

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 exename[256];

    OS_InitProgram(&argc, &argv);
    memset(&clState, 0, sizeof(CLState));
    special_options[0].optname = 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 exitcode) {
    if (MainInitialized) {
        Plugins_Term();
        License_Terminate();
        Proj_Terminate(gProj);
        IO_Terminate();
        MainInitialized = 0;
    }
    return exitcode;
}

static int Main_ParseCommandLine() {
    // TODO: clState, Plugins, gTarg, ...
    long vislang;
    int x, y;
    CWCommandLineArgs myargs;
}

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

static int Main_ResolveProject() {
    // TODO: Various project things
    int err;
    long startTime, endTime;
}

static int UpdatePCmdLineFromVersion(const PCmdLine *given, PCmdLine *target) {
    static unsigned char warned;
    short version = given->version;
    *target = *given;

    // TODO: clState
    return 0;
}

static int UpdatePCmdLineEnvirFromVersion(const PCmdLineEnvir *given, PCmdLineEnvir *target) {
    static unsigned char warned;
    short version = given->version;
    *target = *given;

    // TODO: clState
    return 0;
}

static int UpdatePCmdLineCompilerFromVersion(const PCmdLineCompiler *given, PCmdLineCompiler *target) {
    static unsigned char warned;
    short version = given->version;
    *target = *given;

    // TODO: clState
    return 0;
}

static int UpdatePCmdLineLinkerFromVersion(const PCmdLineLinker *given, PCmdLineLinker *target) {
    static unsigned char warned;
    short version = given->version;
    *target = *given;

    // TODO: clState
    return 0;
}

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

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

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

    if (!name || !ustrcmp(name, "CmdLine Compiler Panel")) {
        if ((panel = Prefs_FindPanel("CmdLine Compiler Panel")) && (h = PrefPanel_GetHandle(panel))) {
            if (name) {
                if (!UpdatePCmdLineCompilerFromVersion((PCmdLineCompiler *) *h, &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")) && (h = PrefPanel_GetHandle(panel))) {
            if (name) {
                if (!UpdatePCmdLineLinkerFromVersion((PCmdLineLinker *) *h, &optsLinker))
                    return 0;
            }
        } else {
            CLReportError(91, "CmdLine Linker Panel");
            return 0;
        }
    }

    return 1;
}

static int SetupCmdLinePrefPanels() {
    int ret;

    PrefPanelsChangedCallback = UpdatePrefPanels;
    ret = Prefs_AddPanel(
            PrefPanel_New("CmdLine Environment", &optsEnvir, sizeof(PCmdLineEnvir))
    );
    ret |= (
            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 ret;
}

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