let's commit all this before my VM blows up and nukes my work

147 files changed, 19477 insertions, 1796 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 810b938..33718d6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -43,7 +43,6 @@ add_executable(mwcc
         command_line/CmdLine/Src/CLLicenses.c
         command_line/CmdLine/Src/CLLoadAndCache.c
         command_line/CmdLine/Src/CLMain.c
-        command_line/CmdLine/Src/CLPluginAPI.c
         command_line/CmdLine/Src/CLPrefs.c
         command_line/CmdLine/Src/CLTarg.c
         command_line/CmdLine/Src/CLToolExec.c
@@ -52,4 +51,27 @@ add_executable(mwcc
         unsorted/uContext1.cpp
         unsorted/uContextCL.cpp
         unsorted/uContextParser.cpp
-        unsorted/uContextSecret.cpp unsorted/StaticParserGlue.c unsorted/ParserHelpers.c unsorted/ToolHelpers.c unsorted/ParserHelpers-cc.c unsorted/ToolHelpers-cc.c unsorted/IO.c unsorted/Projects.c unsorted/Targets.c unsorted/ParserErrors.c)
+        unsorted/uContextSecret.cpp
+        unsorted/StaticParserGlue.c
+        unsorted/ParserHelpers.c
+        unsorted/ToolHelpers.c
+        unsorted/ParserHelpers-cc.c
+        unsorted/ToolHelpers-cc.c
+        unsorted/IO.c
+        unsorted/Projects.c
+        unsorted/Targets.c
+        unsorted/ParserErrors.c
+        unsorted/Utils.c
+        compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Static/cc-mach-ppc-mw.c
+        compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/cc-mach-ppc.c
+        compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/libimp-mach-ppc.c
+        command_line/C++_Parser/Src/Library/WarningHelpers.c
+        unsorted/uLibImporter.c
+        command_line/CmdLine/Src/CLPluginRequests.cpp
+        unsorted/uCOS.c
+        command_line/CmdLine/Src/uFileTypeMappings.c
+        compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-cc.c
+        unsorted/Arguments.c
+        unsorted/Help.c
+        unsorted/Option.c
+        unsorted/Parameter.c unsorted/TargetOptimizer-ppc-mach.c unsorted/OptimizerHelpers.c compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/TargetWarningHelpers-ppc-cc.c)
diff --git a/CompilerTools.c b/CompilerTools.c
index daba8df..d2ff19d 100644
--- a/CompilerTools.c
+++ b/CompilerTools.c
@@ -192,10 +192,12 @@ void RemoveGListData(GList *list, long size) {
 
 char GetGListByte(GList *list) {
     unsigned char *p;
+    char r;
 
     p = (unsigned char *) (*list->data + list->size);
     list->size++;
-    return p[0];
+    r = p[0];
+    return r;
 }
 
 short GetGListWord(GList *list) {
@@ -266,10 +268,9 @@ static short PHash(const unsigned char *str) {
     unsigned char work;
     const unsigned char *p;
 
-    result = str[0];
-    result &= 0xFF;
+    result = str[0] & 0xFF;
     p = &str[1];
-    if (str[0]) {
+    if (str[0] & 0xFF) {
         counter = result;
         work = 0;
         while (counter > 0) {
@@ -287,21 +288,34 @@ static short PHash(const unsigned char *str) {
 
 short CHash(const char *str) {
     /* not matching :( */
+    unsigned char len;
     short result; // orig r4
     unsigned char work; // orig r5
     short counter; // orig r3
 
+    // counter,result,work -> r3=work, r4=counter, r5=result
+    // result,counter,work -> r3=work, r4=result, r5=counter
+    // work,result,counter -> r3=work, r4=result, r5=counter
+    // work,counter,result -> r3=work, r4=counter, r5=result
+    // counter,work,result -> r3=work, r4=counter, r5=result
+    // result,work,counter -> r3=work, r4=result, r5=counter
+
     // i am: r4 = result, r5 = counter, r3 = work
 
-    if (result = strlen(str) & 0xFF) {
-        counter = result;
+    len = strlen(str);
+    result = len;
+    if (len) {
+        counter = len;
         work = 0;
         while (counter > 0) {
             work = (work >> 3) | (work << 5);
-            work = work + *(str++);
+            work = work + *str;
+            //work = *(str++) + (unsigned char) ((work >> 3) | (work << 5));
             counter--;
+            str++;
         }
-        result = (result << 8) | work;
+        result = result << 8;
+        result = result | work;
     }
 
     return result & 0x7FF;
diff --git a/command_line/C++_Parser/Src/Library/WarningHelpers.c b/command_line/C++_Parser/Src/Library/WarningHelpers.c
new file mode 100644
index 0000000..35a6fa8
--- /dev/null
+++ b/command_line/C++_Parser/Src/Library/WarningHelpers.c
@@ -0,0 +1,84 @@
+#include "parser.h"
+
+int SetWarningFlags(const char *opt, void *str, const char *, int flags) {
+    // this is very similar to ToolHelper
+    // might also fail to match
+    unsigned char *ptr;
+    Boolean set;
+    Boolean no;
+    UInt16 flag;
+
+    ptr = (unsigned char *) str;
+    no = (Boolean) ((flags & PARAMPARSEFLAGS_8) >> 3);
+    set = (Boolean) (no ^ 1);
+
+    while (*ptr) {
+        if (*ptr == '+') {
+            set = !no;
+        } else if (*ptr == '-') {
+            set = no;
+        } else if (*ptr == '|') {
+            set = (Boolean) (no ^ 1);
+        } else {
+            flag = (ptr[0] << 8) | ptr[1];
+
+            if (set)
+                pCmdLine.noWarnings = 0;
+
+            switch (flag) {
+                case 'Nw':
+                    pCmdLine.noWarnings = set;
+                    break;
+                case 'Aw':
+                    TargetSetWarningFlags(flag, set);
+                    break;
+                case 'Cw':
+                    pCmdLine.noCmdLineWarnings = !set;
+                    break;
+                case 'We':
+                    pCmdLine.warningsAreErrors = set;
+                    TargetSetWarningFlags(flag, set);
+                    break;
+                default:
+                    if (!TargetSetWarningFlags(flag, set))
+                        CLPFatalError("Bad warning settings in %s (%c%c)\n", str, ptr[0], ptr[1]);
+            }
+
+            ++ptr;
+        }
+
+        ++ptr;
+    }
+
+    Parser_StorePanels(parseopts.context);
+
+    return 1;
+}
+
+int DisplayWarningOptions() {
+    Handle h;
+
+    h = NewHandle(0);
+    if (!h)
+        exit(-23);
+
+    HPrintF(h, "Command-line warning options:\n");
+
+    if (pCmdLine.noCmdLineWarnings)
+        HPrintF(h, "\t- no command-line warnings\n");
+    else
+        HPrintF(h, "\t- command-line warnings\n");
+
+    if (pCmdLine.warningsAreErrors)
+        HPrintF(h, "\t- warnings are errors\n");
+    else
+        HPrintF(h, "\t- warnings are not errors\n");
+
+    if (pCmdLine.noWarnings)
+        HPrintF(h, "\t- no warnings at all\n");
+
+    TargetDisplayWarningOptions(h);
+    ShowTextHandle(NULL, h);
+    DisposeHandle(h);
+    return 1;
+}
diff --git a/command_line/CmdLine/Src/CLBrowser.c b/command_line/CmdLine/Src/CLBrowser.c
index e69de29..826d395 100644
--- a/command_line/CmdLine/Src/CLBrowser.c
+++ b/command_line/CmdLine/Src/CLBrowser.c
@@ -0,0 +1,217 @@
+#include "cmdline.h"
+
+typedef struct {
+    UInt16 fileID;
+    char *filepath;
+} S43;
+
+typedef struct {
+    UInt16 fileID;
+    char unused[12];
+    UInt16 filename_length;
+    char filepath[1];
+} S49;
+
+typedef struct {
+    char magic_word[4];
+    char version;
+    char big_endian;
+    char padding[16];
+    UInt16 file_data_count;
+    UInt32 browse_data_offset;
+    UInt32 browse_data_length;
+    UInt32 file_data_offset;
+    UInt32 file_data_length;
+} T53;
+
+static void GetBrowseTableInfoAndLock(OSHandle *browsetable, S43 **scan, SInt32 *num, SInt32 *size) {
+    UInt32 tsize;
+
+    OS_GetHandleSize(browsetable, &tsize);
+    if (scan)
+        *scan = OS_LockHandle(browsetable);
+    if (num)
+        *num = tsize / sizeof(S43);
+    if (size)
+        *size = tsize;
+}
+
+int Browser_Initialize(OSHandle *browsetableptr) {
+    int err = OS_NewHandle(0, browsetableptr);
+    if (err) {
+        CLReportOSError(63, err, "allocate", "browse file table");
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+static int Destroy(OSHandle *browsetable) {
+    S43 *scan;
+    SInt32 num;
+
+    GetBrowseTableInfoAndLock(browsetable, &scan, &num, NULL);
+    while (num--) {
+        xfree(scan->filepath);
+        scan++;
+    }
+    OS_UnlockHandle(browsetable);
+    return 1;
+}
+
+int Browser_Terminate(OSHandle *browsetableptr) {
+    if (!Destroy(browsetableptr)) {
+        return 0;
+    } else {
+        OS_FreeHandle(browsetableptr);
+        return 1;
+    }
+}
+
+int Browser_SearchFile(OSHandle *browsetable, const char *fullpath, SInt16 *ID) {
+    S43 *scan;
+    SInt32 cnt;
+    SInt32 idx;
+    SInt32 size;
+    Boolean found = 0;
+
+#line 114
+    OPTION_ASSERT(OS_IsFullPath(fullpath));
+    OPTION_ASSERT(browsetable!=NULL);
+
+    GetBrowseTableInfoAndLock(browsetable, &scan, &cnt, &size);
+    for (idx = 0; idx < cnt; idx++) {
+        if (OS_EqualPath(fullpath, scan->filepath)) {
+            found = 1;
+            break;
+        }
+        scan++;
+    }
+
+    if (found)
+        *ID = scan->fileID;
+    else
+        *ID = 0;
+
+    OS_UnlockHandle(browsetable);
+    return found;
+}
+
+int Browser_SearchAndAddFile(OSHandle *browsetable, const char *fullpath, SInt16 *ID) {
+    S43 *scan;
+    SInt32 cnt;
+    SInt32 size;
+    char *pathptr;
+
+    if (!Browser_SearchFile(browsetable, fullpath, ID)) {
+        pathptr = xstrdup(fullpath);
+        GetBrowseTableInfoAndLock(browsetable, &scan, &cnt, &size);
+        OS_UnlockHandle(browsetable);
+        if (OS_ResizeHandle(browsetable, sizeof(S43) * (cnt + 1))) {
+            fprintf(stderr, "\n*** Out of memory\n");
+            exit(-23);
+        }
+
+        scan = (S43 *) (((char *) OS_LockHandle(browsetable)) + size);
+        scan->filepath = pathptr;
+        scan->fileID = cnt + 1;
+        OS_UnlockHandle(browsetable);
+
+        *ID = scan->fileID;
+        return -1;
+    } else {
+        return 1;
+    }
+}
+
+static SInt32 CalcDiskSpaceRequirements(S43 *mem, int num) {
+    SInt32 space = 0;
+    while (num--) {
+        space += 0x10;
+        space += (strlen(mem->filepath) + 7) & ~7;
+        mem++;
+    }
+    return space;
+}
+
+static int ConvertMemToDisk(S43 *mem, S49 *disk, int num) {
+    int slen;
+    int blen;
+
+    while (num--) {
+        disk->fileID = mem->fileID;
+        memset(disk->unused, 0, sizeof(disk->unused));
+        slen = strlen(mem->filepath);
+        blen = (slen + 7) & ~7;
+        disk->filename_length = slen;
+        memset(disk->filepath, 0,  blen);
+        strncpy(disk->filepath, mem->filepath, slen);
+        disk = (S49 *) (((unsigned char *) disk) + 0x10 + blen);
+        mem++;
+    }
+
+    return 1;
+}
+
+int Browser_PackBrowseFile(Handle browsedata, OSHandle *browsetable, OSHandle *browsefileptr) {
+    OSHandle h;
+    char *ptr;
+    T53 header;
+    S43 *scan;
+    SInt32 entries;
+    UInt32 datasize;
+    UInt32 tableoffs;
+    UInt32 tablesize;
+    UInt32 totalsize;
+    SInt32 a_long = 1;
+    int err;
+    void *bptr;
+
+#line 253
+    OPTION_ASSERT(browsedata!=NULL);
+    OPTION_ASSERT(browsetable!=NULL);
+
+    datasize = GetHandleSize(browsedata);
+    tableoffs = (datasize + sizeof(header) + 7) & ~7;
+
+    GetBrowseTableInfoAndLock(browsetable, &scan, &entries, NULL);
+    tablesize = CalcDiskSpaceRequirements(scan, entries);
+    OS_UnlockHandle(browsetable);
+
+    totalsize = tablesize + tableoffs;
+
+    memcpy(header.magic_word, "DubL", 4);
+    header.version = 1;
+    header.big_endian = *((char *) &a_long) == 0;
+    memset(header.padding, 0, sizeof(header.padding));
+
+    header.browse_data_offset = sizeof(header);
+    header.browse_data_length = datasize;
+    header.file_data_offset = tableoffs;
+    header.file_data_length = tablesize;
+    header.file_data_count = entries;
+
+    err = OS_NewHandle(totalsize, &h);
+    *browsefileptr = h;
+    if (err) {
+        fprintf(stderr, "\n*** Out of memory\n");
+        exit(-23);
+    }
+
+    ptr = OS_LockHandle(&h);
+    memcpy(ptr, &header, sizeof(header));
+
+    HLock(browsedata);
+    memcpy(&ptr[sizeof(header)], *browsedata, datasize);
+    // an 'add' for this is swapped around and i cannot fucking figure out why
+    memset(&ptr[sizeof(header) + datasize], 0, tableoffs - sizeof(header) - datasize);
+    HUnlock(browsedata);
+
+    GetBrowseTableInfoAndLock(browsetable, &scan, &entries, NULL);
+    ConvertMemToDisk(scan, bptr = ptr + tableoffs, entries);
+    memset((char *) bptr + tablesize, 0, totalsize - tableoffs - tablesize);
+    OS_UnlockHandle(browsetable);
+    OS_UnlockHandle(&h);
+    return 1;
+}
+
diff --git a/command_line/CmdLine/Src/CLDependencies.c b/command_line/CmdLine/Src/CLDependencies.c
index e69de29..8c4c13b 100644
--- a/command_line/CmdLine/Src/CLDependencies.c
+++ b/command_line/CmdLine/Src/CLDependencies.c
@@ -0,0 +1,407 @@
+#include "cmdline.h"
+
+extern char STSbuf[256];
+
+static Path *specialAccessPath;
+SInt16 *CLT_filesp;
+CPrepFileInfoStack *CLT_filestack;
+
+// forward decl
+static Boolean FindFileInPaths(Paths *paths, const char *filename, Path **thepath, OSSpec *spec);
+static void SetSpecialAccessPathFromIncludeStackTOS();
+
+Boolean Incls_Initialize(Incls *incls, Target *targ) {
+    specialAccessPath = NULL;
+    incls->targ = targ;
+    incls->maxincls = 0;
+    incls->numincls = 0;
+    incls->bufpos = 0;
+    incls->buflen = 0;
+    incls->buffer = NULL;
+    incls->files = NULL;
+    incls->allPaths = xmalloc(NULL, sizeof(Paths));
+    Paths_Initialize(incls->allPaths);
+    return 1;
+}
+
+void Incls_Terminate(Incls *incls) {
+    if (incls->buffer)
+        xfree(incls->buffer);
+    if (incls->files)
+        xfree(incls->files);
+    Paths_Terminate(incls->allPaths);
+    xfree(incls->allPaths);
+}
+
+static Boolean IsSysIncl(Incls *incls, SInt32 idx) {
+    InclFile *i = &incls->files[idx];
+    return i->syspath;
+}
+
+static void MakeInclFileSpec(Incls *incls, SInt32 idx, OSSpec *spec) {
+    InclFile *f = &incls->files[idx];
+    OS_MakeSpecWithPath(
+            f->globalpath->spec,
+            &incls->buffer[f->filenameoffs],
+            0,
+            spec);
+}
+
+static Boolean QuickFindFileInIncls(Incls *incls, Boolean fullsearch, const char *filename, OSSpec *spec, SInt32 *index, InclFile **f) {
+    int idx;
+    for (idx = 0; idx < incls->numincls; idx++) {
+        *f = &incls->files[idx];
+        if (OS_EqualPath(&incls->buffer[(*f)->filenameoffs], filename)) {
+            if (fullsearch || (*f)->syspath) {
+                MakeInclFileSpec(incls, idx, spec);
+                *index = idx;
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+static Boolean SameIncl(Incls *incls, SInt32 a, SInt32 b) {
+    InclFile *ia;
+    InclFile *ib;
+    if (a == b)
+        return 1;
+    ia = &incls->files[a];
+    ib = &incls->files[b];
+    return ia->globalpath == ib->globalpath && OS_EqualPath(&incls->buffer[ia->filenameoffs], &incls->buffer[ib->filenameoffs]);
+}
+
+static Path *FindOrAddGlobalInclPath(Paths *paths, OSPathSpec *spec) {
+    Path *path = Paths_FindPathSpec(paths, spec);
+    if (!path) {
+        path = Path_New(spec);
+        Paths_AddPath(paths, path);
+    }
+    return path;
+}
+
+static Boolean _FindFileInPath(Path *path, const char *filename, Path **thepath, OSSpec *spec) {
+    if (!OS_MakeSpecWithPath(path->spec, filename, 0, spec) && OS_IsFile(spec)) {
+        *thepath = path;
+        return 1;
+    }
+
+    if (path->recursive && FindFileInPaths(path->recursive, filename, thepath, spec))
+        return 1;
+
+    return 0;
+}
+
+static Boolean FindFileInPaths(Paths *paths, const char *filename, Path **thepath, OSSpec *spec) {
+    UInt16 idx;
+    Path *path;
+
+    for (idx = 0; idx < Paths_Count(paths); idx++) {
+        path = Paths_GetPath(paths, idx);
+#line 175
+        OPTION_ASSERT(path);
+        if (_FindFileInPath(path, filename, thepath, spec))
+            return 1;
+    }
+
+    return 0;
+}
+
+static void AddFileToIncls(Incls *incls, char *infilename, Boolean syspath, Path *accesspath, Path *globalpath, Path *specialpath, SInt32 *index) {
+    InclFile *f;
+    int fnlen;
+    char *filename;
+    OSSpec spec;
+
+    if (!accesspath && !globalpath)
+        filename = OS_GetFileNamePtr(infilename);
+    else
+        filename = infilename;
+    fnlen = strlen(filename) + 1;
+
+    if (incls->numincls >= incls->maxincls) {
+        incls->maxincls += 16;
+        incls->files = xrealloc("include list", incls->files, sizeof(InclFile) * incls->maxincls);
+    }
+
+    f = &incls->files[incls->numincls];
+    f->filenameoffs = incls->bufpos;
+    f->syspath = syspath;
+    f->accesspath = accesspath;
+    if (globalpath) {
+        f->globalpath = globalpath;
+    } else if (accesspath) {
+        f->globalpath = FindOrAddGlobalInclPath(incls->allPaths, accesspath->spec);
+    } else {
+        OS_MakeFileSpec(infilename, &spec);
+        f->globalpath = FindOrAddGlobalInclPath(incls->allPaths, &spec.path);
+    }
+    f->specialpath = Deps_GetSpecialAccessPath();
+
+    if (incls->bufpos + fnlen > incls->buflen) {
+        incls->buflen += 1024;
+        incls->buffer = xrealloc("include list", incls->buffer, incls->buflen);
+    }
+    strcpy(&incls->buffer[incls->bufpos], filename);
+    incls->bufpos += fnlen;
+    *index = incls->numincls++;
+}
+
+Boolean Incls_FindFileInPaths(Incls *incls, char *filename, Boolean fullsearch, OSSpec *spec, SInt32 *inclidx) {
+    Boolean found;
+    InclFile *incl;
+    Boolean foundglobal;
+    Path *globalpath;
+    Path *accesspath;
+    Path *specialpath;
+    Boolean userpath;
+    char rel_path[256];
+
+    found = 0;
+    if (optsCompiler.includeSearch == 3 && fullsearch)
+        SetSpecialAccessPathFromIncludeStackTOS();
+    *inclidx = -1;
+
+    foundglobal = QuickFindFileInIncls(incls, fullsearch, filename, spec, inclidx, &incl);
+    if (foundglobal) {
+        if (incl->specialpath == specialAccessPath && incl->syspath && !fullsearch)
+            found = 1;
+        else if (!incl->accesspath)
+            foundglobal = 0;
+    }
+
+    if (!found) {
+        accesspath = globalpath = NULL;
+        userpath = fullsearch;
+        if (OS_IsFullPath(filename)) {
+            found = !OS_MakeFileSpec(filename, spec) && !OS_Status(spec);
+            accesspath = globalpath = specialpath = NULL;
+        } else {
+            specialpath = Deps_GetSpecialAccessPath();
+            globalpath = specialpath;
+            if (specialpath) {
+                found = _FindFileInPath(specialpath, filename, &globalpath, spec);
+                accesspath = NULL;
+            }
+            if (!found && foundglobal && incl->syspath && !fullsearch) {
+                globalpath = incl->globalpath;
+                accesspath = incl->accesspath;
+                specialpath = NULL;
+                MakeInclFileSpec(incls, *inclidx, spec);
+                found = 1;
+            }
+            if (!found && fullsearch) {
+                userpath = 1;
+                globalpath = NULL;
+                found = FindFileInPaths(&incls->targ->userPaths, filename, &accesspath, spec);
+            }
+            if (!found) {
+                userpath = 0;
+                globalpath = NULL;
+                found = FindFileInPaths(&incls->targ->sysPaths, filename, &accesspath, spec);
+            }
+            if (!found) {
+                specialpath = Deps_GetSpecialAccessPath();
+                globalpath = specialpath;
+                if (!found && MakeFrameworkPath(rel_path, filename, specialpath)) {
+                    filename = rel_path;
+                    found = FindFileInPaths(&FrameworkPaths, filename, &globalpath, spec);
+                }
+            }
+        }
+
+        if (found && *inclidx < 0)
+            AddFileToIncls(incls, filename, !userpath, accesspath, globalpath, specialpath, inclidx);
+    }
+
+    return found;
+}
+
+Boolean Deps_Initialize(Deps *deps, Incls *incls) {
+    deps->numDeps = 0;
+    deps->maxDeps = 0;
+    deps->list = NULL;
+    deps->incls = incls;
+    return 1;
+}
+
+void Deps_Terminate(Deps *deps) {
+    if (deps->list)
+        xfree(deps->list);
+}
+
+int Deps_ChangeSpecialAccessPath(OSSpec *srcfss, Boolean initialize) {
+    static OSSpec *currentsrcfss;
+    OSPathSpec pathspec;
+    OSPathSpec *pathspecptr;
+
+    if (initialize && srcfss)
+        currentsrcfss = srcfss;
+
+    switch (optsCompiler.includeSearch) {
+        case IncludeSearch_Type2:
+            specialAccessPath = NULL;
+            return 1;
+        case IncludeSearch_Type0:
+            if (!initialize)
+                return 1;
+            OS_GetCWD(&pathspec);
+            pathspecptr = &pathspec;
+            break;
+        case IncludeSearch_Type1:
+            if (!initialize)
+                return 1;
+        case IncludeSearch_Type3:
+            if (srcfss) {
+                pathspecptr = &srcfss->path;
+            } else if (currentsrcfss) {
+                pathspecptr = &currentsrcfss->path;
+            } else {
+                OS_GetCWD(&pathspec);
+                pathspecptr = &pathspec;
+            }
+            break;
+        default:
+#line 468
+            DO_INTERNAL_ERROR("Unhandled include file search type (%d)\n", optsCompiler.includeSearch);
+    }
+
+    specialAccessPath = FindOrAddGlobalInclPath(gTarg->incls.allPaths, pathspecptr);
+    if (optsCmdLine.verbose > 2)
+        CLReport(105, OS_PathSpecToString(pathspecptr, STSbuf, sizeof(STSbuf)));
+    return 1;
+}
+
+Path *Deps_GetSpecialAccessPath() {
+    return specialAccessPath;
+}
+
+static void SetSpecialAccessPathFromIncludeStackTOS() {
+    // does not match, some registers are in the wrong order
+    OSSpec spec;
+    SInt16 index;
+    char *fnameptr;
+    VFile *vf;
+
+    if (optsCompiler.includeSearch == IncludeSearch_Type3 && CLT_filesp && CLT_filestack) {
+        if (*CLT_filesp >= 0) {
+            index = *CLT_filesp;
+            while (index) {
+                if (!(*CLT_filestack)[index])
+                    break;
+                OS_FSSpec_To_OSSpec(&(*CLT_filestack)[index--]->textfile, &spec);
+                fnameptr = OS_GetFileNamePtr(OS_NameSpecToString(&spec.name, STSbuf, sizeof(STSbuf)));
+                vf = VFiles_Find(gTarg->virtualFiles, fnameptr);
+                if (!vf) {
+                    if (!specialAccessPath || !OS_EqualPathSpec(&spec.path, specialAccessPath->spec)) {
+                        Deps_ChangeSpecialAccessPath(&spec, 0);
+                        return;
+                    }
+                    return;
+                }
+            }
+        }
+        Deps_ChangeSpecialAccessPath(NULL, 0);
+    }
+}
+
+static Boolean FindDepFile(Deps *deps, SInt32 incl) {
+    int idx;
+
+    for (idx = 0; idx < deps->numDeps; idx++) {
+        if (SameIncl(&gTarg->incls, deps->list[idx], incl))
+            return 1;
+    }
+
+    return 0;
+}
+
+static void AddDepFile(Deps *deps, SInt32 incl, SInt16 dependencyType) {
+    if (deps->numDeps >= deps->maxDeps) {
+        deps->maxDeps += 16;
+        deps->list = xrealloc("dependency list", deps->list, sizeof(SInt32) * deps->maxDeps);
+    }
+    deps->list[deps->numDeps++] = incl;
+}
+
+void Deps_AddDependency(Deps *deps, SInt32 incl, OSSpec *spec, Boolean unk, SInt16 dependencyType, Boolean *alreadyincluded) {
+    Boolean included;
+
+    if (incl < 0) {
+        AddFileToIncls(
+                &gTarg->incls,
+                OS_SpecToString(spec, STSbuf, sizeof(STSbuf)),
+                0,
+                NULL, NULL, NULL,
+                &incl);
+    }
+
+    included = FindDepFile(deps, incl);
+    if (!included) {
+        if (!(optsCompiler.depsOnlyUserFiles ? IsSysIncl(deps->incls, incl) : 0))
+            AddDepFile(deps, incl, dependencyType);
+    }
+
+    if (alreadyincluded)
+        *alreadyincluded = included;
+}
+
+static char *EscapeName(Boolean spaces, char *escbuf, char *path) {
+    char *ret;
+
+    if (!spaces)
+        return path;
+
+    ret = escbuf;
+    while (*path) {
+        if (*path == ' ')
+            *(escbuf++) = '\\';
+        *(escbuf++) = *(path++);
+    }
+    *escbuf = 0;
+    return ret;
+}
+
+void Deps_ListDependencies(Incls *incls, File *file, OSHandle *h) {
+    Boolean spaces;
+    int idx;
+    char linebuf[512];
+    char outfilename[256];
+    int totdeps;
+    char path[256];
+    char escbuf[320];
+    OSSpec spec;
+
+#define LIST_DEP(format, name, ...) \
+do {                                \
+sprintf(linebuf, format, spaces ? "" : "", EscapeName(spaces, escbuf, (name)), spaces ? "" : "", __VA_ARGS__); \
+if (OS_AppendHandle(h, linebuf, strlen(linebuf))) goto memFail; \
+} while (0)
+
+    if (!OS_NewHandle(0, h)) {
+        totdeps = file->deps.numDeps;
+        OS_SpecToStringRelative(&file->outfss, NULL, outfilename, sizeof(outfilename));
+        if (outfilename[0]) {
+            spaces = strchr(outfilename, ' ') != NULL;
+            LIST_DEP("%s%s%s%s ", outfilename, ":");
+            spaces = strchr(file->srcfilename, ' ') != NULL;
+            LIST_DEP("%s%s%s %s\n", file->srcfilename, totdeps ? "\\" : "");
+        } else {
+            spaces = strchr(file->srcfilename, ' ') != NULL;
+            LIST_DEP("%s%s%s%s %s\n", file->srcfilename, ":", totdeps ? "\\" : "");
+        }
+
+        for (idx = 0; idx < file->deps.numDeps; idx++) {
+            totdeps--;
+            MakeInclFileSpec(incls, file->deps.list[idx], &spec);
+            OS_SpecToString(&spec, path, sizeof(path));
+            spaces = strchr(path, ' ') != NULL;
+            LIST_DEP("\t%s%s%s %s\n", path, totdeps ? "\\" : "");
+        }
+    } else {
+    memFail:
+        fprintf(stderr, "\n*** Out of memory\n");
+        exit(-23);
+    }
+}
diff --git a/command_line/CmdLine/Src/CLFileOps.c b/command_line/CmdLine/Src/CLFileOps.c
index e69de29..14c9dc6 100644
--- a/command_line/CmdLine/Src/CLFileOps.c
+++ b/command_line/CmdLine/Src/CLFileOps.c
@@ -0,0 +1,803 @@
+#include "cmdline.h"
+
+extern char STSbuf[256];
+
+static int OutputTextData(File *file, SInt16 stage, OSType maccreator, OSType mactype) {
+    int ret = 0;
+    SInt32 size;
+
+    if (file->textdata) {
+        size = GetHandleSize(file->textdata);
+        if (stage != CmdLineStageMask_Dp || optsCmdLine.toDisk & CmdLineStageMask_Dp) {
+            if (!(file->writeToDisk & stage)) {
+                ret = ShowHandle(file->textdata, size, 0);
+            } else {
+                if (optsCmdLine.verbose)
+                    CLReport(15, OS_SpecToStringRelative(&file->outfss, NULL, STSbuf, sizeof(STSbuf)));
+                ret = WriteHandleToFile(&file->outfss, file->textdata, size, maccreator, mactype);
+                file->wroteToDisk |= stage;
+            }
+        } else {
+            if (optsCompiler.outMakefile[0]) {
+                ret = AppendHandleToFile(&clState.makefileSpec, file->textdata, size, maccreator, mactype);
+            } else {
+                ret = ShowHandle(file->textdata, size, 0);
+            }
+        }
+
+        DisposeHandle(file->textdata);
+        file->textdata = NULL;
+    }
+
+    return ret;
+}
+
+static int fstrcat(char *file, const char *add, SInt32 length) {
+    if (strlen(file) + strlen(add) >= length) {
+        return 0;
+    } else {
+        strcat(file, add);
+        return 1;
+    }
+}
+
+static void extstrcat(char *file, const char *ext) {
+    if (!fstrcat(file, ext, 64))
+        strcpy(file + 63 - strlen(ext), ext);
+}
+
+int GetOutputFile(File *file, SInt16 stage) {
+    int err;
+    char tempoutfilename[256];
+    char *targetoutfilename;
+    Boolean specifiedName;
+    const char *ext;
+    const CWObjectFlags *cof;
+    char tmpname[256];
+    char *env;
+    char *extptr;
+    char *fnptr;
+    char text[64];
+    char *inname;
+    OSPathSpec tmppath;
+
+    if (optsCmdLine.toDisk & stage)
+        file->writeToDisk |= stage;
+
+    if (file->outfileowner == stage) {
+        targetoutfilename = file->outfilename;
+        specifiedName = file->outfilename[0] && !(file->tempOnDisk & stage);
+        if (specifiedName) {
+            file->writeToDisk |= stage;
+            file->tempOnDisk &= ~stage;
+        }
+    } else {
+        targetoutfilename = tempoutfilename;
+        specifiedName = 0;
+    }
+
+    if (!(stage & (optsCmdLine.toDisk | file->writeToDisk | file->tempOnDisk))) {
+        if ((stage == CmdLineStageMask_Cg) && (optsCmdLine.stages & CmdLineStageMask_Ds) && (optsCmdLine.state == OptsCmdLineState_2) && optsCompiler.keepObjects)
+            file->writeToDisk |= stage;
+        else
+            file->tempOnDisk |= stage;
+    }
+
+    if (!specifiedName && (stage & (optsCmdLine.toDisk | file->writeToDisk | file->tempOnDisk))) {
+        cof = Plugin_CL_GetObjectFlags(file->compiler);
+        if (stage == CmdLineStageMask_Pp) {
+            ext = optsCompiler.ppFileExt[0] ? optsCompiler.ppFileExt : cof->ppFileExt;
+        } else if (stage == CmdLineStageMask_Ds) {
+            ext = optsCompiler.disFileExt[0] ? optsCompiler.disFileExt : cof->disFileExt;
+        } else if (stage == CmdLineStageMask_Dp) {
+            ext = optsCompiler.depFileExt[0] ? optsCompiler.depFileExt : cof->depFileExt;
+        } else if (stage == CmdLineStageMask_Cg) {
+            ext = optsCompiler.objFileExt[0] ? optsCompiler.objFileExt : cof->objFileExt;
+            if (!(file->objectflags & 0x80000000) && !specifiedName)
+                ext = NULL;
+        } else {
+            ext = NULL;
+        }
+
+        if (ext && ext[0]) {
+            if (ext[0] != '.') {
+                snprintf(text, sizeof(text), ".%s", ext);
+            } else {
+                strncpy(text, ext, sizeof(text) - 1);
+                text[sizeof(text) - 1] = 0;
+            }
+            if ((file->tempOnDisk & stage) && !(optsCmdLine.stages & CmdLineStageMask_Dp)) {
+                env = getenv("TEMP");
+                if (!env || !env[0] || OS_MakePathSpec(NULL, env, &tmppath))
+                    env = getenv("TMP");
+                if (!env || !env[0] || OS_MakePathSpec(NULL, env, &tmppath))
+                    env = getenv("TMPDIR");
+                if (!env || !env[0] || OS_MakePathSpec(NULL, env, &tmppath))
+                    env = "/tmp";
+                if (!env || !env[0] || OS_MakePathSpec(NULL, env, &tmppath))
+                    env = ".";
+                snprintf(tmpname, sizeof(tmpname), "%s%c%s", env, OS_PATHSEP, OS_GetFileNamePtr(file->srcfilename));
+                inname = tmpname;
+            } else if (!optsCompiler.relPathInOutputDir) {
+                inname = OS_GetFileNamePtr(file->srcfilename);
+            } else {
+                inname = file->srcfilename;
+            }
+
+            fnptr = OS_GetFileNamePtr(inname);
+            extptr = strrchr(fnptr, '.');
+            if (!extptr || ext[0] == '.')
+                extptr = fnptr + strlen(fnptr);
+
+            if (extptr - fnptr + strlen(text) >= sizeof(text))
+                extptr = &fnptr[sizeof(text) - 1] - strlen(text);
+
+            snprintf(targetoutfilename, 256, "%.*s%s", extptr - inname, inname, text);
+        } else {
+            *targetoutfilename = 0;
+            file->writeToDisk &= ~stage;
+            file->tempOnDisk &= ~stage;
+        }
+    }
+
+    if (stage & (file->writeToDisk | file->tempOnDisk)) {
+        err = OS_MakeSpecWithPath(&gTarg->outputDirectory, targetoutfilename, !optsCompiler.relPathInOutputDir, &file->outfss);
+        if (!err) {
+            if (OS_EqualSpec(&file->srcfss, &file->outfss)) {
+                if (specifiedName) {
+                    CLReportError(102, targetoutfilename);
+                    file->writeToDisk &= ~stage;
+                    file->tempOnDisk &= ~stage;
+                    return 0;
+                }
+                file->writeToDisk &= ~stage;
+                file->tempOnDisk &= ~stage;
+            }
+        } else {
+            CLReportOSError(9, err, targetoutfilename, OS_PathSpecToString(&gTarg->outputDirectory, STSbuf, sizeof(STSbuf)));
+        }
+        return err == 0;
+    }
+
+    return 1;
+}
+
+static int SyntaxCheckFile(File *file) {
+    return SendCompilerRequest(file->compiler, file, 0) != 0;
+}
+
+static int PreprocessFile(File *file) {
+    const CWObjectFlags *cof;
+
+    if (!(file->dropinflags & kCanpreprocess)) {
+        CLReportWarning(53, Plugin_GetDropInName(file->compiler), file->srcfilename);
+        return 1;
+    }
+
+    if (!SendCompilerRequest(file->compiler, file, 1))
+        return 0;
+
+    if (!GetOutputFile(file, CmdLineStageMask_Pp))
+        return 0;
+
+    if (file->textdata) {
+        cof = Plugin_CL_GetObjectFlags(file->compiler);
+        return OutputTextData(
+                file, CmdLineStageMask_Pp,
+                optsCompiler.ppFileCreator ? optsCompiler.ppFileCreator : cof->ppFileCreator,
+                optsCompiler.ppFileType ? optsCompiler.ppFileType : cof->ppFileType);
+    }
+
+    CLReportError(96, "preprocessing", file->srcfilename);
+    return 0;
+}
+
+static int DependencyMapFile(File *file, Boolean compileifnecessary) {
+    OSHandle mf;
+    const CWObjectFlags *cof;
+
+    cof = Plugin_CL_GetObjectFlags(file->compiler);
+    if (!(optsCmdLine.stages & (CmdLineStageMask_Pp | CmdLineStageMask_Cg)) && compileifnecessary) {
+        if (!SendCompilerRequest(file->compiler, file, CmdLineStageMask_Dp))
+            return 0;
+    }
+
+    if (!GetOutputFile(file, CmdLineStageMask_Cg))
+        return 0;
+
+    Deps_ListDependencies(&gTarg->incls, file, &mf);
+    file->textdata = OS_CreateMacHandle(&mf);
+
+    if (!GetOutputFile(file, CmdLineStageMask_Dp))
+        return 0;
+
+    if (OutputTextData(
+            file, CmdLineStageMask_Dp,
+            optsCompiler.depFileCreator ? optsCompiler.depFileCreator : cof->depFileCreator,
+            optsCompiler.depFileType ? optsCompiler.depFileType : cof->depFileType)) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+static int RecordBrowseInfo(File *file) {
+    const CWObjectFlags *cof;
+
+    if (!file->recordbrowseinfo)
+        return 1;
+
+    if (!file->browsedata) {
+        CLReportError(101, Plugin_GetDropInName(file->compiler), OS_SpecToStringRelative(&file->srcfss, NULL, STSbuf, sizeof(STSbuf)));
+        return 0;
+    }
+
+    if ((optsCmdLine.toDisk & CmdLineStageMask_Cg) && optsCompiler.browserEnabled) {
+        cof = Plugin_CL_GetObjectFlags(file->compiler);
+        if (!WriteBrowseData(file, optsCompiler.brsFileCreator ? optsCompiler.brsFileCreator : cof->brsFileCreator, optsCompiler.brsFileType ? optsCompiler.brsFileType : cof->brsFileType))
+            return 0;
+    }
+
+    return 1;
+}
+
+static int RecordObjectData(File *file) {
+    const CWObjectFlags *cof = Plugin_CL_GetObjectFlags(file->compiler);
+
+    if (!file->objectdata)
+        return 1;
+
+    if (!WriteObjectFile(file, optsCompiler.objFileCreator ? optsCompiler.objFileCreator : cof->objFileCreator, optsCompiler.objFileType ? optsCompiler.objFileType : cof->objFileType))
+        return 0;
+
+    return 1;
+}
+
+int StoreObjectFile(File *file) {
+    if (file->wroteToDisk & CmdLineStageMask_Cg)
+        return 1;
+
+    if (!file->objectdata && !file->browsedata)
+        return 1;
+
+    if (GetOutputFile(file, CmdLineStageMask_Cg)) {
+        if (!((file->writeToDisk | file->tempOnDisk) & CmdLineStageMask_Cg))
+            return 1;
+
+        if (!RecordBrowseInfo(file) || !RecordObjectData(file))
+            return 0;
+
+        file->wroteToDisk |= CmdLineStageMask_Cg;
+        return 1;
+    }
+
+    return 0;
+}
+
+static int CompileFile(File *file) {
+    int ret = 1;
+
+    if (!(file->dropinflags & kCanprecompile) && ((optsCompiler.forcePrecompile == 1) || (file->mappingflags & kPrecompile))) {
+        CLReportWarning(54, Plugin_GetDropInName(file->compiler), file->srcfilename);
+        return 1;
+    }
+
+    if (optsCompiler.browserEnabled) {
+        SInt16 id;
+        int ret;
+        char fullpath[256];
+        memset(file->browseoptions, 1, sizeof(file->browseoptions));
+        OS_SpecToString(&file->srcfss, fullpath, sizeof(fullpath));
+        ret = Browser_SearchAndAddFile(&clState.browseTableHandle, fullpath, &id);
+        if (!ret)
+            return 0;
+        file->recordbrowseinfo = ret < 0;
+        file->browseFileID = id;
+        if (optsCmdLine.verbose > 1)
+            CLReport(22, file->srcfilename, file->browseFileID);
+    } else {
+        memset(file->browseoptions, 0, sizeof(file->browseoptions));
+        file->recordbrowseinfo = 0;
+        file->recordbrowseinfo = 0;
+        file->browseFileID = 0;
+    }
+
+    if (!SendCompilerRequest(file->compiler, file, 2)) {
+        ret = 0;
+    } else {
+        if ((!file->hasobjectcode || !file->objectdata) && (file->dropinflags & kGeneratescode) && (file->objectUsage & 2)) {
+            CLReportError(96, "compiling", file->srcfilename);
+            ret = 0;
+        } else if (optsCmdLine.state == OptsCmdLineState_2 && !StoreObjectFile(file)) {
+            ret = 0;
+        }
+    }
+
+    return ret;
+}
+
+static int DisassembleWithLinker(File *file, Plugin *linker, SInt32 linkerDropinFlags) {
+    char filename[256];
+    int ret;
+
+    if (file->writeToDisk & CmdLineStageMask_Ds) {
+        OS_SpecToString(&file->outfss, filename, sizeof(filename));
+        ret = ExecuteLinker(linker, linkerDropinFlags, file, (optsCmdLine.toDisk & CmdLineStageMask_Ds) ? NULL : filename, NULL);
+        file->wroteToDisk |= CmdLineStageMask_Ds;
+        return ret;
+    }
+
+    return ExecuteLinker(linker, linkerDropinFlags, file, NULL, NULL);
+}
+
+static int DisassembleFile(File *file) {
+    Plugin *disasm;
+
+    if (!file->hasobjectcode && !file->hasresources) {
+        CLReportError(56, file->srcfilename);
+        return 0;
+    }
+
+    if (!GetOutputFile(file, CmdLineStageMask_Ds))
+        return 0;
+
+    if (file->dropinflags & kCandisassemble) {
+        if (!SendDisassemblerRequest(file->compiler, file))
+            return 0;
+
+        if (file->textdata) {
+            const CWObjectFlags *cof = Plugin_CL_GetObjectFlags(file->compiler);
+            return OutputTextData(
+                    file, CmdLineStageMask_Ds,
+                    optsCompiler.disFileCreator ? optsCompiler.disFileCreator : cof->disFileCreator,
+                    optsCompiler.disFileType ? optsCompiler.disFileType : cof->disFileType);
+        }
+        CLReportError(96, "disassembling", file->srcfilename);
+        return 0;
+
+    } else {
+        if ((gTarg->linkerDropinFlags & dropInExecutableTool) && !(gTarg->linkerDropinFlags & cantDisassemble))
+            return DisassembleWithLinker(file, gTarg->linker, gTarg->linkerDropinFlags);
+        if ((gTarg->preLinkerDropinFlags & dropInExecutableTool) && !(gTarg->preLinkerDropinFlags & cantDisassemble))
+            return DisassembleWithLinker(file, gTarg->preLinker, gTarg->preLinkerDropinFlags);
+
+        if (gTarg->linker && !(gTarg->linkerDropinFlags & cantDisassemble)) {
+            if (SendDisassemblerRequest(gTarg->linker, file)) {
+                if (file->textdata && GetHandleSize(file->textdata) > 0) {
+                    const CWObjectFlags *cof = Plugin_CL_GetObjectFlags(file->compiler);
+                    return OutputTextData(
+                            file, CmdLineStageMask_Ds,
+                            optsCompiler.disFileCreator ? optsCompiler.disFileCreator : cof->disFileCreator,
+                            optsCompiler.disFileType ? optsCompiler.disFileType : cof->disFileType);
+                }
+                CLReportError(96, "disassembling", file->srcfilename);
+            }
+            return 0;
+        }
+        if (gTarg->preLinker && !(gTarg->preLinkerDropinFlags & cantDisassemble)) {
+            if (SendDisassemblerRequest(gTarg->preLinker, file)) {
+                if (file->textdata && GetHandleSize(file->textdata) > 0) {
+                    const CWObjectFlags *cof = Plugin_CL_GetObjectFlags(file->compiler);
+                    return OutputTextData(
+                            file, CmdLineStageMask_Ds,
+                            optsCompiler.disFileCreator ? optsCompiler.disFileCreator : cof->disFileCreator,
+                            optsCompiler.disFileType ? optsCompiler.disFileType : cof->disFileType);
+                }
+                CLReportError(96, "disassembling", file->srcfilename);
+            }
+            return 0;
+        }
+
+        if (gTarg->linker)
+            CLReportError(58, Plugin_GetDropInName(gTarg->linker), Plugin_GetDropInName(file->compiler), file->srcfilename);
+        else
+            CLReportError(57, Plugin_GetDropInName(file->compiler), file->srcfilename);
+
+        return 0;
+    }
+}
+
+static int CompileEntry(File *file, Boolean *compiled) {
+    UInt32 beginWork;
+    UInt32 endWork;
+    struct BuildInfo *tinfo = &gTarg->info;
+
+    *compiled = 0;
+
+    if (optsCmdLine.dryRun) {
+        *compiled = 1;
+        return 1;
+    }
+
+    if (!(file->sourceUsage & 1)) {
+        if (file->mappingflags & kRsrcfile)
+            *compiled = 1;
+        return 1;
+    }
+
+#line 835
+    OPTION_ASSERT(file->compiler);
+
+    *compiled = 1;
+    beginWork = OS_GetMilliseconds();
+    Browser_Initialize(&clState.browseTableHandle);
+    Deps_ChangeSpecialAccessPath(&file->srcfss, 1);
+
+    if ((optsCmdLine.stages == 0) && !SyntaxCheckFile(file))
+        return 0;
+    if ((optsCmdLine.stages & CmdLineStageMask_Pp) && !PreprocessFile(file))
+        return 0;
+    if ((optsCmdLine.stages & (CmdLineStageMask_Cg | CmdLineStageMask_Ds)) && !CompileFile(file))
+        return 0;
+    if ((optsCmdLine.stages & CmdLineStageMask_Dp) && !DependencyMapFile(file, 1))
+        return 0;
+    if ((optsCmdLine.stages & CmdLineStageMask_Ds) && !DisassembleFile(file))
+        return 0;
+
+    if (optsCmdLine.verbose && (optsCmdLine.stages & CmdLineStageMask_Cg)) {
+        const char *cun;
+        const char *dun;
+        const char *uun;
+        CLReport(25, file->compiledlines);
+        tinfo->linesCompiled += file->compiledlines;
+        cun = dun = uun = "bytes";
+        CLReport(26, file->codesize, cun, file->idatasize, dun, file->udatasize, uun);
+    }
+    tinfo->codeSize += file->codesize;
+    tinfo->iDataSize += file->idatasize;
+    tinfo->uDataSize += file->udatasize;
+
+    Browser_Terminate(&clState.browseTableHandle);
+    endWork = OS_GetMilliseconds();
+
+    if (optsCmdLine.timeWorking) {
+        if (optsCmdLine.verbose)
+            CLReport(24, (endWork - beginWork) / 1000.0, "compile", "", "", "");
+        else
+            CLReport(24, (endWork - beginWork) / 1000.0, "compile", "'", file->srcfilename, "'");
+    }
+
+    return 1;
+}
+
+static void DumpFileAndPathInfo() {
+    int i;
+    int n;
+
+    CLReport(84, "Framework search paths ([d] = default, [r] = recursive)");
+    n = Paths_Count(&FrameworkPaths);
+    if (!n) {
+        CLReport(85, "(none)", "");
+    } else {
+        for (i = 0; i < n; i++) {
+            Path *path = Paths_GetPath(&FrameworkPaths, i);
+#line 961
+            OPTION_ASSERT(path != NULL);
+
+            CLReport(85,
+                     OS_PathSpecToString(path->spec, STSbuf, sizeof(STSbuf)),
+                     ((path->flags & 2) && path->recursive) ? " [d] [r]" : (path->flags & 2) ? " [d]" : path->recursive ? " [r]" : ""
+                     );
+
+            if (path->recursive && optsCmdLine.verbose > 2) {
+                UInt16 j;
+                for (j = 0; j < Paths_Count(path->recursive); j++) {
+                    Path *sub = Paths_GetPath(path->recursive, j);
+#line 976
+                    OPTION_ASSERT(sub);
+                    CLReport(85, "\t", OS_PathSpecToString(sub->spec, STSbuf, sizeof(STSbuf)));
+                }
+            }
+        }
+    }
+
+    n = Frameworks_GetCount();
+    if (Frameworks_GetCount()) {
+        CLReport(84, "Included frameworks");
+        for (i = 0; i < n; i++) {
+            char version[80];
+            Paths_FWInfo *info = Frameworks_GetInfo(i);
+#line 993
+            OPTION_ASSERT(info);
+
+            version[0] = 0;
+            strcpy(version, "\t(");
+            if (!info->version.s[0]) {
+                strcat(version, "Current)");
+            } else {
+                strncat(version, info->version.s, sizeof(version) - 4);
+                strcat(version, ")");
+            }
+            CLReport(85, info->name.s, version);
+        }
+    }
+
+    if (clState.plugintype == CWDROPINCOMPILERTYPE)
+        CLReport(84, "User include search paths ([d] = default, [r] = recursive)");
+    else
+        CLReport(84, "Library search paths ([d] = default, [r] = recursive)");
+
+    if (!Paths_Count(&gTarg->userPaths) && clState.plugintype == CWDROPINCOMPILERTYPE) {
+        CLReport(85, "(none)", "");
+    } else {
+        for (i = 0; i < Paths_Count(&gTarg->userPaths); i++) {
+            Path *path = Paths_GetPath(&gTarg->userPaths, i);
+#line 1024
+            OPTION_ASSERT(path != NULL);
+
+            CLReport(85,
+                     OS_PathSpecToString(path->spec, STSbuf, sizeof(STSbuf)),
+                     ((path->flags & 2) && path->recursive) ? " [d] [r]" : (path->flags & 2) ? " [d]" : path->recursive ? " [r]" : ""
+            );
+
+            if (path->recursive && optsCmdLine.verbose > 2) {
+                UInt16 j;
+                for (j = 0; j < Paths_Count(path->recursive); j++) {
+                    Path *sub = Paths_GetPath(path->recursive, j);
+#line 1039
+                    OPTION_ASSERT(sub);
+                    CLReport(85, "\t", OS_PathSpecToString(sub->spec, STSbuf, sizeof(STSbuf)));
+                }
+            }
+        }
+    }
+
+    if (clState.plugintype == CWDROPINCOMPILERTYPE)
+        CLReport(84, "System include search paths ([d] = default, [r] = recursive)");
+
+    if (!Paths_Count(&gTarg->sysPaths))
+        CLReport(85, "(none)", "");
+
+    for (i = 0; i < Paths_Count(&gTarg->sysPaths); i++) {
+        Path *path = Paths_GetPath(&gTarg->sysPaths, i);
+#line 1054
+        OPTION_ASSERT(path != NULL);
+
+        CLReport(85,
+                 OS_PathSpecToString(path->spec, STSbuf, sizeof(STSbuf)),
+                 ((path->flags & 2) && path->recursive) ? " [d] [r]" : (path->flags & 2) ? " [d]" : path->recursive ? " [r]" : ""
+        );
+
+        if (path->recursive && optsCmdLine.verbose > 2) {
+            UInt16 j;
+            for (j = 0; j < Paths_Count(path->recursive); j++) {
+                Path *sub = Paths_GetPath(path->recursive, j);
+#line 1069
+                OPTION_ASSERT(sub);
+                CLReport(85, "\t", OS_PathSpecToString(sub->spec, STSbuf, sizeof(STSbuf)));
+            }
+        }
+    }
+
+    if (clState.plugintype == CWDROPINCOMPILERTYPE)
+        CLReport(84, "Files in project (relative to CWD)");
+    else
+        CLReport(84, "Link order for project (relative to CWD)");
+
+    for (i = 0; i < Files_Count(&gTarg->files); i++) {
+        File *file = Files_GetFile(&gTarg->files, i);
+        if (!VFiles_Find(gTarg->virtualFiles, file->srcfilename))
+            CLReport(85, OS_SpecToStringRelative(&file->srcfss, NULL, STSbuf, sizeof(STSbuf)), "");
+        else
+            CLReport(85, file->srcfilename, "\t(virtual file)");
+    }
+}
+
+int CompileFilesInProject() {
+    struct BuildInfo *tinfo;
+    SInt32 index;
+    SInt32 startTime;
+    SInt32 endTime;
+    int ignored;
+    int compiled;
+    Boolean failed;
+
+    failed = 0;
+    startTime = OS_GetMilliseconds();
+    InitializeIncludeCache();
+    if (optsCmdLine.verbose > 1)
+        DumpFileAndPathInfo();
+
+    if (!SendTargetInfoRequest(gTarg, gTarg->linker, gTarg->linkerDropinFlags))
+        return Result_Failed;
+
+    ignored = 0;
+    compiled = 0;
+    for (index = 0; index < Files_Count(&gTarg->files); index++) {
+        int ret;
+        File *file;
+        Boolean wascompiled;
+
+        file = Files_GetFile(&gTarg->files, index);
+        if (!file->outfileowner)
+            file->outfileowner = CmdLineStageMask_Cg;
+        ret = CompileEntry(file, &wascompiled);
+        if (ret) {
+            if (wascompiled)
+                compiled++;
+            if (!wascompiled)
+                ignored++;
+            if (CheckForUserBreak())
+                return Result_Cancelled;
+        }
+
+        if (!ret) {
+            if (optsCompiler.noFail) {
+                failed = 1;
+                clState.countWarnings = 0;
+                clState.countErrors = 0;
+                clState.withholdWarnings = 0;
+                clState.withholdErrors = 0;
+            } else {
+                return CheckForUserBreak() ? Result_Cancelled : Result_Failed;
+            }
+        }
+    }
+
+    if (optsCmdLine.stages & CmdLineStageMask_Dp) {
+        for (index = 0; index < Files_Count(&gTarg->pchs); index++) {
+            int ret;
+            File *file;
+
+            file = Files_GetFile(&gTarg->pchs, index);
+            ret = DependencyMapFile(file, 0);
+            if (!ret) {
+                if (optsCompiler.noFail) {
+                    failed = 1;
+                    clState.countWarnings = 0;
+                    clState.countErrors = 0;
+                    clState.withholdWarnings = 0;
+                    clState.withholdErrors = 0;
+                } else {
+                    return CheckForUserBreak() ? Result_Cancelled : Result_Failed;
+                }
+            }
+        }
+    }
+
+    CleanupIncludeCache();
+
+    tinfo = &gTarg->info;
+    if (optsCmdLine.verbose && compiled > 1) {
+        const char *cun;
+        const char *dun;
+        const char *uun;
+        cun = dun = uun = "bytes";
+        CLReport(27, tinfo->codeSize, cun, tinfo->iDataSize, dun, tinfo->uDataSize, uun);
+    }
+
+    endTime = OS_GetMilliseconds();
+
+    if (optsCmdLine.timeWorking)
+        CLReport(24, (endTime - startTime) / 1000.0, "compile", "", "", "project");
+
+    if (ignored > 0 && compiled == 0 && (gTarg->preLinker || gTarg->linker))
+        CLReportError(29);
+
+    if (failed)
+        return Result_Failed;
+    return CheckForUserBreak() ? Result_Cancelled : Result_Success;
+}
+
+static int PostLinkFilesInProject() {
+    SInt32 index;
+    SInt32 startTime;
+    SInt32 endTime;
+    File *file;
+    FSSpec fss;
+
+    startTime = OS_GetMilliseconds();
+    for (index = 0; index < Files_Count(&gTarg->files); index++) {
+        file = Files_GetFile(&gTarg->files, index);
+        OS_OSSpec_To_FSSpec(&file->srcfss, &fss);
+        gTarg->targetinfo->outfile = fss;
+        gTarg->targetinfo->runfile = fss;
+        gTarg->targetinfo->symfile = fss;
+
+        if (!SendLinkerRequest(gTarg->postLinker, gTarg->postLinkerDropinFlags, gTarg->targetinfo)) {
+            return CheckForUserBreak() ? Result_Cancelled : Result_Failed;
+        } else {
+            if (CheckForUserBreak())
+                return Result_Cancelled;
+        }
+    }
+    endTime = OS_GetMilliseconds();
+
+    if (optsCmdLine.timeWorking)
+        CLReport(24, (endTime - startTime) / 1000.0, "compile", "", "", "project");
+
+    return CheckForUserBreak() ? Result_Cancelled : Result_Success;
+}
+
+int LinkProject() {
+    SInt32 startTime;
+    SInt32 endTime;
+
+    startTime = OS_GetMilliseconds();
+    if (!SendTargetInfoRequest(gTarg, gTarg->linker, gTarg->linkerDropinFlags))
+        return Result_Failed;
+    if (!SetupTemporaries())
+        return Result_Failed;
+
+    if (gTarg->preLinker && optsLinker.callPreLinker && optsCmdLine.state == OptsCmdLineState_3) {
+        SInt32 subStart;
+        SInt32 subEnd;
+
+        subStart = OS_GetMilliseconds();
+        if (gTarg->preLinkerDropinFlags & dropInExecutableTool) {
+            if (!ExecuteLinker(gTarg->preLinker, gTarg->preLinkerDropinFlags, NULL, NULL, NULL))
+                return Result_Failed;
+        } else if (!optsCmdLine.dryRun) {
+            if (!SendLinkerRequest(gTarg->preLinker, gTarg->preLinkerDropinFlags, gTarg->targetinfo))
+                return CheckForUserBreak() ? Result_Cancelled : Result_Failed;
+        }
+        subEnd = OS_GetMilliseconds();
+
+        if (optsCmdLine.timeWorking)
+            CLReport(24, (subEnd - subStart) / 1000.0, "prelink project", "", "", "");
+    }
+
+    if (gTarg->linker && optsLinker.callLinker && optsCmdLine.state == OptsCmdLineState_3) {
+        SInt32 subStart;
+        SInt32 subEnd;
+
+        subStart = OS_GetMilliseconds();
+        if (gTarg->linkerDropinFlags & dropInExecutableTool) {
+            if (!ExecuteLinker(gTarg->linker, gTarg->linkerDropinFlags, NULL, NULL, NULL))
+                return Result_Failed;
+        } else if (!optsCmdLine.dryRun) {
+            if (!SendLinkerRequest(gTarg->linker, gTarg->linkerDropinFlags, gTarg->targetinfo))
+                return CheckForUserBreak() ? Result_Cancelled : Result_Failed;
+        }
+        subEnd = OS_GetMilliseconds();
+
+        if (optsCmdLine.timeWorking)
+            CLReport(24, (subEnd - subStart) / 1000.0, "link project", "", "", "");
+    }
+
+    if (gTarg->postLinker && optsLinker.callPostLinker && optsCmdLine.state == OptsCmdLineState_3) {
+        SInt32 subStart;
+        SInt32 subEnd;
+        FSSpec fss;
+        OSSpec outfile;
+
+        subStart = OS_GetMilliseconds();
+        if (gTarg->postLinkerDropinFlags & dropInExecutableTool) {
+            if (!ExecuteLinker(gTarg->postLinker, gTarg->postLinkerDropinFlags, NULL, NULL, NULL))
+                return Result_Failed;
+        } else if (!optsCmdLine.dryRun) {
+            if (!SendTargetInfoRequest(gTarg, gTarg->linker, gTarg->linkerDropinFlags))
+                return Result_Failed;
+            if (gTarg->targetinfo->outputType == linkOutputFile)
+                fss = gTarg->targetinfo->outfile;
+            if (gTarg->targetinfo->outputType != linkOutputNone) {
+                if (!SendLinkerRequest(gTarg->postLinker, gTarg->postLinkerDropinFlags, gTarg->targetinfo))
+                    return CheckForUserBreak() ? Result_Cancelled : Result_Failed;
+                if (!SendTargetInfoRequest(gTarg, gTarg->postLinker, gTarg->postLinkerDropinFlags))
+                    return Result_Failed;
+            }
+        }
+        subEnd = OS_GetMilliseconds();
+
+        if (optsCmdLine.timeWorking)
+            CLReport(24, (subEnd - subStart) / 1000.0, "postlink project", "", "", "");
+
+        if (!optsLinker.keepLinkerOutput && gTarg->targetinfo->outputType == linkOutputFile) {
+            if (optsCmdLine.verbose > 1) {
+                OS_FSSpec_To_OSSpec(&fss, &outfile);
+                CLReport(19, OS_SpecToString(&outfile, STSbuf, sizeof(STSbuf)));
+            }
+            FSpDelete(&fss);
+        }
+    }
+
+    if (!DeleteTemporaries())
+        return Result_Failed;
+
+    endTime = OS_GetMilliseconds();
+
+    if (optsCmdLine.timeWorking)
+        CLReport(24, (endTime - startTime) / 1000.0, "finish link stage", "", "", "");
+
+    return Result_Success;
+}
diff --git a/command_line/CmdLine/Src/CLIncludeFileCache.c b/command_line/CmdLine/Src/CLIncludeFileCache.c
index e69de29..d479f36 100644
--- a/command_line/CmdLine/Src/CLIncludeFileCache.c
+++ b/command_line/CmdLine/Src/CLIncludeFileCache.c
@@ -0,0 +1,159 @@
+#include "cmdline.h"
+
+typedef struct CacheEntry {
+    struct CacheEntry *next;
+    struct CacheEntry *prev;
+    int locked;
+    int precompiled;
+    Handle text;
+    OSSpec spec;
+    UInt32 size;
+    UInt32 when;
+} CacheEntry;
+
+enum {
+    CACHE_SIZE = 0x800000
+};
+
+static CacheEntry *cachelist;
+static CacheEntry *freelist;
+static UInt32 availablecache;
+
+static CacheEntry *makecacheentry() {
+    CacheEntry *c = freelist;
+    if (c) {
+        freelist = c->next;
+        return c;
+    } else {
+        return xmalloc("include file cache", sizeof(CacheEntry));
+    }
+}
+
+static void insertcacheentry(CacheEntry *c) {
+    if (cachelist)
+        cachelist->prev = c;
+    c->next = cachelist;
+    c->prev = NULL;
+    cachelist = c;
+}
+
+static void deletecacheentry(CacheEntry *c) {
+    if (c->next)
+        c->next->prev = c->prev;
+    if (c->prev)
+        c->prev->next = c->next;
+    else
+        cachelist = c->next;
+}
+
+void InitializeIncludeCache() {
+    freelist = NULL;
+    cachelist = NULL;
+    availablecache = CACHE_SIZE;
+}
+
+void CleanupIncludeCache() {
+    CacheEntry *c;
+    CacheEntry *c1;
+
+    for (c = cachelist; c; c = c1) {
+        c1 = c->next;
+        if (c->text)
+            DisposeHandle(c->text);
+        xfree(c);
+    }
+
+    for (c = freelist; c; c = c1) {
+        c1 = c->next;
+        xfree(c);
+    }
+
+    InitializeIncludeCache();
+}
+
+void CacheIncludeFile(OSSpec *spec, Handle text, Boolean precompiled) {
+    UInt32 size;
+    CacheEntry *c;
+    CacheEntry *lru;
+
+    size = GetHandleSize(text);
+    if (precompiled) {
+        lru = NULL;
+        for (c = cachelist; c; c = c->next) {
+            if (c->precompiled) {
+                lru = c;
+                break;
+            }
+        }
+        if (lru) {
+            DisposeHandle(lru->text);
+            lru->text = NULL;
+            deletecacheentry(lru);
+            lru->next = freelist;
+            freelist = lru;
+        }
+    } else {
+        if ((SInt32) size > (SInt32) CACHE_SIZE) {
+            return;
+        } else {
+            while (size > availablecache) {
+                lru = NULL;
+                for (c = cachelist; c; c = c->next) {
+                    if (!c->locked && !c->precompiled && (lru == NULL || c->when < lru->when))
+                        lru = c;
+                }
+
+                if (lru) {
+                    DisposeHandle(lru->text);
+                    lru->text = NULL;
+                    availablecache += lru->size;
+                    deletecacheentry(lru);
+                    lru->next = freelist;
+                    freelist = lru;
+                } else {
+                    return;
+                }
+            }
+        }
+    }
+
+    c = makecacheentry();
+    c->locked = 1;
+    c->precompiled = precompiled;
+    c->spec = *spec;
+    c->text = text;
+    c->size = size;
+    c->when = OS_GetMilliseconds();
+    insertcacheentry(c);
+
+    if (!precompiled)
+        availablecache -= size;
+}
+
+Handle CachedIncludeFile(OSSpec *spec, Boolean *precompiled) {
+    CacheEntry *c;
+
+    for (c = cachelist; c; c = c->next) {
+        if (OS_EqualSpec(&c->spec, spec)) {
+            c->when = OS_GetMilliseconds();
+            *precompiled = c->precompiled;
+            c->locked++;
+            return c->text;
+        }
+    }
+
+    return NULL;
+}
+
+void FreeIncludeFile(Handle text) {
+    CacheEntry *c;
+
+    for (c = cachelist; c; c = c->next) {
+        if (c->text == text) {
+            c->locked--;
+            return;
+        }
+    }
+
+    DisposeHandle(text);
+}
diff --git a/command_line/CmdLine/Src/CLLicenses.c b/command_line/CmdLine/Src/CLLicenses.c
index e69de29..f264e6c 100644
--- a/command_line/CmdLine/Src/CLLicenses.c
+++ b/command_line/CmdLine/Src/CLLicenses.c
@@ -0,0 +1,23 @@
+#include "cmdline.h"
+
+void License_Initialize() {
+}
+
+void License_Terminate() {
+}
+
+SInt32 License_Checkout() {
+    return 0xD0AD0A;
+}
+
+void License_Refresh() {
+
+}
+
+void License_Checkin() {
+
+}
+
+void License_AutoCheckin() {
+
+}
diff --git a/command_line/CmdLine/Src/CLLoadAndCache.c b/command_line/CmdLine/Src/CLLoadAndCache.c
index e69de29..efc3f63 100644
--- a/command_line/CmdLine/Src/CLLoadAndCache.c
+++ b/command_line/CmdLine/Src/CLLoadAndCache.c
@@ -0,0 +1,85 @@
+#include "cmdline.h"
+
+short FixTextHandle(Handle txt) {
+    char *tptr;
+    UInt32 tlen;
+    char *scan;
+
+    HLock(txt);
+    tptr = *txt;
+    tlen = GetHandleSize(txt);
+
+    scan = tptr;
+    while (scan < (tptr + tlen)) {
+        if (scan[0] == '\r') {
+            if (scan[1] == '\n')
+                scan += 2;
+            else
+                scan += 1;
+        } else if (scan[0] == '\n') {
+            scan[0] = '\r';
+            scan++;
+        } else {
+            scan++;
+        }
+    }
+
+    HUnlock(txt);
+    return 0;
+}
+
+int LoadAndCacheFile(OSSpec *spec, Handle *texthandle, Boolean *precomp) {
+    Handle h;
+    int err;
+    OSType mactype;
+    int refnum;
+    UInt32 ltxtlen;
+
+    if ((*texthandle = CachedIncludeFile(spec, precomp)))
+        return 0;
+
+    *precomp = !OS_GetMacFileType(spec, &mactype) && mactype != CWFOURCHAR('T','E','X','T');
+    *texthandle = NULL;
+
+    err = OS_Open(spec, OSReadOnly, &refnum);
+    if (err)
+        return err;
+    err = OS_GetSize(refnum, &ltxtlen);
+    if (err)
+        return err;
+
+    h = NewHandle(ltxtlen + 1);
+    if (!h) {
+        fprintf(stderr, "\n*** Out of memory\n");
+        exit(-23);
+    }
+
+    HLock(h);
+    err = OS_Read(refnum, *h, &ltxtlen);
+    if (err) {
+        DisposeHandle(h);
+        OS_Close(refnum);
+        return err;
+    }
+
+    OS_Close(refnum);
+    (*h)[ltxtlen] = 0;
+    HUnlock(h);
+
+    if (!*precomp)
+        FixTextHandle(h);
+
+    CacheIncludeFile(spec, h, *precomp);
+    *texthandle = h;
+    return 0;
+}
+
+void CopyFileText(Handle src, char **text, SInt32 *textsize) {
+    *textsize = GetHandleSize(src);
+    *text = xmalloc(NULL, *textsize);
+
+    HLock(src);
+    memcpy(*text, *src, *textsize);
+    *textsize -= 1;
+    HUnlock(src);
+}
diff --git a/command_line/CmdLine/Src/CLMain.c b/command_line/CmdLine/Src/CLMain.c
index f8247c4..6e041ad 100644
--- a/command_line/CmdLine/Src/CLMain.c
+++ b/command_line/CmdLine/Src/CLMain.c
@@ -1,10 +1,10 @@
-#include "mwcc_decomp.h"
+#include "cmdline.h"
 
 jmp_buf exit_program;
 int numPlugins;
 CLPluginInfo *pluginInfo;
 int numPanels;
-char **panelNames;
+const char **panelNames;
 CWCommandLineArgs *panel_args;
 CWCommandLineArgs *plugin_args;
 Project mainProj;
@@ -18,14 +18,14 @@ char cmdline_build_date[32];
 char cmdline_build_time[32];
 Project *gProj = &mainProj;
 
-static SInt16 CLT_dummymain(void *context) {
+static CWPLUGIN_ENTRY(CLT_dummymain)(CWPluginContext) {
     return 0;
 }
 
-static SInt16 CLT_GetDropInFlags(const DropInFlags **flags, SInt32 *flagsSize) {
+static CWPLUGIN_ENTRY(CLT_GetDropInFlags)(const DropInFlags **flags, SInt32 *flagsSize) {
     static const DropInFlags sFlags = {
             kCurrentDropInFlagsVersion,
-            CWFOURCHAR('c','l','d','r'),
+            CWDROPINDRIVERTYPE,
             7,
             0,
             0,
@@ -36,19 +36,19 @@ static SInt16 CLT_GetDropInFlags(const DropInFlags **flags, SInt32 *flagsSize) {
     return 0;
 }
 
-static SInt16 CLT_GetDropInName(const char **dropinName) {
+static CWPLUGIN_ENTRY(CLT_GetDropInName)(const char **dropinName) {
     static const char *sDropInName = "Command-Line Driver";
     *dropinName = sDropInName;
     return 0;
 }
 
-static SInt16 CLT_GetDisplayName(const char **displayName) {
+static CWPLUGIN_ENTRY(CLT_GetDisplayName)(const char **displayName) {
     static const char *sDisplayName = "Command-Line Driver";
     *displayName = sDisplayName;
     return 0;
 }
 
-static SInt16 CLT_GetPanelList(const CWPanelList **panelList) {
+static CWPLUGIN_ENTRY(CLT_GetPanelList)(const CWPanelList **panelList) {
     static const char *sPanelNames[4];
     static CWPanelList sPanelList = {
             kCurrentCWPanelListVersion,
@@ -70,7 +70,7 @@ static SInt16 CLT_GetPanelList(const CWPanelList **panelList) {
     return 0;
 }
 
-static SInt16 CLT_GetTargetList(const CWTargetList **targetList) {
+static CWPLUGIN_ENTRY(CLT_GetTargetList)(const CWTargetList **targetList) {
     static FourCharCode sCPU = targetCPUAny;
     static FourCharCode sOS = targetOSAny;
     static CWTargetList sTargetList = {
@@ -84,7 +84,7 @@ static SInt16 CLT_GetTargetList(const CWTargetList **targetList) {
     return 0;
 }
 
-static SInt16 CLT_GetVersionInfo(const VersionInfo **versioninfo) {
+static CWPLUGIN_ENTRY(CLT_GetVersionInfo)(const VersionInfo **versioninfo) {
     static const VersionInfo vi = {
             3, 0, 0, 0
     };
@@ -92,7 +92,7 @@ static SInt16 CLT_GetVersionInfo(const VersionInfo **versioninfo) {
     return 0;
 }
 
-static SInt16 CLT_GetFileTypeMappings(const OSFileTypeMappingList **mappinglist) {
+static CWPLUGIN_ENTRY(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}
@@ -278,12 +278,6 @@ int Main_Terminate(int exitcode) {
     return exitcode;
 }
 
-enum {
-    ResultCode_0 = 0,
-    ResultCode_1 = 1,
-    ResultCode_2 = 2
-};
-
 static int Main_ParseCommandLine() {
     Plugin *parser;
     CWCommandLineArgs myargs;
@@ -308,7 +302,7 @@ static int Main_ParseCommandLine() {
     myargs.envp = 0;
 
     if (!SendParserRequest(parser, gTarg, &myargs, gTarg->cpu, gTarg->os, numPlugins, pluginInfo, numPanels, panelNames, plugin_args, panel_args, cmdline_build_date, cmdline_build_time, Plugin_GetToolVersionInfo())) {
-        return CheckForUserBreak() ? ResultCode_2 : ResultCode_1;
+        return CheckForUserBreak() ? Result_Cancelled : Result_Failed;
     }
 
     if (clState.pluginDebug) {
@@ -340,7 +334,7 @@ static int Main_ParseCommandLine() {
         }
     }
 
-    return ResultCode_0;
+    return Result_Success;
 }
 
 static int Main_SetupParamBlock() {
@@ -622,7 +616,7 @@ static int Main_SetupContext() {
             CLFatalError("The linker plugin was not found!");
     }
 
-    gTarg->linkmodel = 0;
+    gTarg->linkmodel = LinkModel0;
     Framework_GetEnvInfo();
 
     return 1;
diff --git a/command_line/CmdLine/Src/CLPluginRequests.cpp b/command_line/CmdLine/Src/CLPluginRequests.cpp
new file mode 100644
index 0000000..9de50ba
--- /dev/null
+++ b/command_line/CmdLine/Src/CLPluginRequests.cpp
@@ -0,0 +1,348 @@
+#include "cmdline.h"
+#include "plugin_internal.h"
+
+extern "C" {
+static CWResult CallPlugin(Plugin *plugin) {
+    return Plugin_Call(plugin, plugin->context);
+}
+}
+
+static void SetupPluginContext(Plugin *plugin, CWResult request) {
+    OSSpec spec;
+    shellContextType *sc;
+    OSPathSpec cwd;
+
+    sc = static_cast<shellContextType *>(plugin->context->shellContext);
+    sc->plugin = plugin;
+    sc->systemAccessPathsChanged = 1;
+    sc->userAccessPathsChanged = 1;
+    plugin->context->request = request;
+    plugin->context->apiVersion = 12;
+    plugin->context->pluginStorage = NULL;
+
+    OS_MakeFileSpec("Project.mcp", &spec);
+    OS_OSSpec_To_FSSpec(&spec, &plugin->context->projectFile);
+    if (gTarg) {
+        OS_MakeSpecWithPath(&gTarg->outputDirectory, NULL, 0, &spec);
+        OS_OSSpec_To_FSSpec(&spec, &plugin->context->outputFileDirectory);
+    } else {
+        OS_GetCWD(&cwd);
+        OS_MakeSpecWithPath(&cwd, NULL, 0, &spec);
+        OS_OSSpec_To_FSSpec(&spec, &plugin->context->outputFileDirectory);
+    }
+
+    plugin->context->shellSignature = CWFOURCHAR('C','W','I','E');
+    plugin->context->pluginType = Plugin_GetDropInFlags(plugin)->dropintype;
+
+    if (gTarg)
+        plugin->context->numFiles = Files_Count(&gTarg->files);
+    else
+        plugin->context->numFiles = 0;
+
+    if (gTarg)
+        plugin->context->numOverlayGroups = Overlays_CountGroups(&gTarg->linkage.overlays);
+    else
+        plugin->context->numOverlayGroups = 0;
+
+    plugin->context->pluginOSError = noErr;
+    plugin->context->callbackOSError = noErr;
+    plugin->context->accessPathList = NULL;
+}
+
+static void DestroyPluginContext(CWPluginContext context) {
+}
+
+Boolean SendParserRequest(
+        Plugin *plugin,
+        Target *target,
+        CWCommandLineArgs *args,
+        OSType cpu,
+        OSType os,
+        int numPlugins,
+        CLPluginInfo *pluginInfo,
+        int numPanels,
+        const char **panelNames,
+        CWCommandLineArgs *plugin_args,
+        CWCommandLineArgs *panel_args,
+        const char *build_date,
+        const char *build_time,
+        const ToolVersionInfo *build_tool
+) {
+    int result;
+    CWParserContext *pc;
+
+    SetupPluginContext(plugin, 1);
+
+    pc = static_cast<CWParserContext *>(plugin->context);
+    pc->build_date = build_date;
+    pc->build_time = build_time;
+    pc->build_tool = build_tool;
+    pc->args = args;
+    pc->cpu = cpu;
+    pc->os = os;
+    pc->numPlugins = numPlugins;
+    pc->plugins = pluginInfo;
+    pc->numPanels = numPanels;
+    pc->panelNames = panelNames;
+    pc->plugin_args = plugin_args;
+    pc->panel_args = panel_args;
+
+    if (CallPlugin(plugin) != cwNoErr)
+        return 0;
+    if (!SendTargetInfoRequest(target, target->linker, target->linkerDropinFlags))
+        return 0;
+
+    target->linkmodel =
+            (target->targetinfo->linkType == exelinkageSegmented) ? LinkModel1 :
+            (target->targetinfo->linkType == exelinkageOverlay1) ? LinkModel2 :
+            LinkModel0;
+
+    if (!Plugin_VerifyPanels(plugin))
+        return 0;
+
+    SetupPluginContext(plugin, 2);
+    pc->args = args;
+    pc->cpu = cpu;
+    pc->os = os;
+    pc->numPlugins = numPlugins;
+    pc->plugins = pluginInfo;
+    pc->numPanels = numPanels;
+    pc->panelNames = panelNames;
+    pc->plugin_args = plugin_args;
+    pc->panel_args = panel_args;
+
+    result = CallPlugin(plugin);
+    return (result == cwNoErr);
+}
+
+Boolean SendCompilerRequest(Plugin *plugin, File *file, SInt16 stage) {
+    CWResult result;
+    CWCompilerLinkerContext *cc;
+    Boolean precompiling;
+    SInt16 type;
+    OSType mactype;
+    const char *pn;
+    int v;
+
+    if (stage & CmdLineStageMask_Cg) {
+        if (optsCompiler.forcePrecompile == 1)
+            precompiling = 1;
+        else if (optsCompiler.forcePrecompile == 2)
+            precompiling = 0;
+        else
+            precompiling = !!(file->mappingflags & kPrecompile);
+    } else {
+        precompiling = 0;
+    }
+
+    if (optsCmdLine.verbose) {
+        pn = Plugin_GetDropInName(plugin);
+        v = optsCmdLine.verbose > 1;
+        if (stage & CmdLineStageMask_Pp) {
+            CLReport(CLStr34 + v, file->srcfilename, pn);
+        } else if (stage & CmdLineStageMask_Cg) {
+            if (precompiling)
+                CLReport(CLStr32 + v, file->srcfilename, pn);
+            else
+                CLReport(CLStr30 + v, file->srcfilename, pn);
+        } else if (stage & CmdLineStageMask_Dp) {
+            CLReport(CLStr36 + v, file->srcfilename, pn);
+        } else if (stage & CmdLineStageMask_Ds) {
+            CLReport(CLStr46 + v, file->srcfilename, pn);
+        } else if (!stage) {
+            CLReport(CLStr48 + v, file->srcfilename, pn);
+        }
+    }
+
+    if (!Plugin_VerifyPanels(plugin))
+        return 0;
+
+    SetupPluginContext(plugin, reqCompile);
+    cc = static_cast<CWCompilerLinkerContext *>(plugin->context);
+    *cc->targetinfo = *gTarg->targetinfo;
+
+    OS_OSSpec_To_FSSpec(&file->srcfss, &cc->sourcefile);
+    if (!OS_GetMacFileType(&file->srcfss, &mactype) && mactype == CWFOURCHAR('T','E','X','T')) {
+        if (UCBGetFileText(cc, &cc->sourcefile, &cc->sourcetext, &cc->sourcetextsize, &type) != cwNoErr)
+            return 0;
+    } else {
+        cc->sourcetext = NULL;
+        cc->sourcetextsize = 0;
+    }
+
+    cc->whichfile = file->filenum;
+    cc->debuginfo = optsCmdLine.debugInfo;
+    cc->recordbrowseinfo = file->recordbrowseinfo;
+    cc->fileID = file->browseFileID;
+    memcpy(&cc->browseoptions, file->browseoptions, sizeof(cc->browseoptions));
+
+    if (stage & (CmdLineStageMask_Pp | CmdLineStageMask_Dp)) {
+        if (stage & CmdLineStageMask_Pp)
+            cc->preprocess = 1;
+        else
+            cc->preprocess = 2;
+    } else {
+        cc->preprocess = 0;
+    }
+
+    if ((stage & CmdLineStageMask_Cg) && precompiling) {
+        cc->precompile = 1;
+        cc->autoprecompile = 1;
+    } else {
+        cc->precompile = 0;
+        cc->autoprecompile = 0;
+    }
+
+    if (!(stage & (CmdLineStageMask_Pp | CmdLineStageMask_Cg | CmdLineStageMask_Dp))) {
+        cc->preprocess = 2;
+        cc->precompile = 2;
+    }
+
+    result = CallPlugin(plugin);
+
+    if (cc->sourcetext) {
+        UCBReleaseFileText(cc, cc->sourcetext);
+        cc->sourcetext = NULL;
+        cc->sourcetextsize = 0;
+    }
+
+    return (result == cwNoErr);
+}
+
+Boolean SendTargetInfoRequest(Target *targ, Plugin *linker, SInt32 dropinflags) {
+    CWResult result;
+    CWCompilerLinkerContext *cc;
+    OSSpec spec;
+    FSSpec fss;
+
+    if (linker && !(dropinflags & dropInExecutableTool)) {
+        if (optsCmdLine.verbose > 1)
+            CLReport(CLStr50, Plugin_GetDropInName(linker));
+#line 298
+        OPTION_ASSERT(Plugin_GetPluginType(linker) == CWDROPINLINKERTYPE);
+
+        if (!Plugin_VerifyPanels(linker))
+            return 0;
+
+        SetupPluginContext(linker, reqTargetInfo);
+        cc = static_cast<CWCompilerLinkerContext *>(linker->context);
+        *cc->targetinfo = *targ->targetinfo;
+        result = CallPlugin(linker);
+        *targ->targetinfo = *cc->targetinfo;
+    } else {
+        OS_MakeFileSpec("(unknown file)", &spec);
+        OS_OSSpec_To_FSSpec(&spec, &fss);
+        targ->targetinfo->outputType = linkOutputFile;
+        targ->targetinfo->outfile = fss;
+        targ->targetinfo->symfile = fss;
+        targ->targetinfo->runfile = fss;
+        targ->targetinfo->linkType = exelinkageFlat;
+        targ->targetinfo->canRun = 0;
+        targ->targetinfo->canDebug = 0;
+        targ->targetinfo->targetCPU = targ->cpu;
+        targ->targetinfo->targetOS = targ->os;
+        targ->targetinfo->outfileCreator = CWFOURCHAR('C','W','I','E');
+        targ->targetinfo->outfileType = CWFOURCHAR('A','P','P','L');
+        targ->targetinfo->debuggerCreator = CWFOURCHAR('M','W','D','B');
+        targ->targetinfo->runHelperCreator = CWFOURCHAR('?','?','?','?');
+        result = cwNoErr;
+    }
+
+    return (result == cwNoErr);
+}
+
+Boolean SendLinkerRequest(Plugin *plugin, SInt32 dropinflags, CWTargetInfo *targetInfo) {
+    CWResult result;
+    CWCompilerLinkerContext *cc;
+    const char *nm;
+    int v;
+
+    if (optsCmdLine.verbose) {
+        nm = Plugin_GetDropInName(plugin);
+        v = optsCmdLine.verbose > 1;
+        if (dropinflags & isPostLinker)
+            CLReport(CLStr44 + v, nm);
+        else if (dropinflags & isPreLinker)
+            CLReport(CLStr42 + v, nm);
+        else
+            CLReport(CLStr40 + v, nm);
+    }
+
+    if (!Plugin_VerifyPanels(plugin))
+        return 0;
+
+    SetupPluginContext(plugin, reqLink);
+    cc = static_cast<CWCompilerLinkerContext *>(plugin->context);
+    *cc->targetinfo = *targetInfo;
+    result = CallPlugin(plugin);
+    *targetInfo = *cc->targetinfo;
+
+    return (result == cwNoErr);
+}
+
+Boolean SendDisassemblerRequest(Plugin *linker, File *file) {
+    CWResult result;
+    Plugin *plugin;
+
+    if (linker == NULL)
+        plugin = file->compiler;
+    else
+        plugin = linker;
+
+    if (optsCmdLine.verbose)
+        CLReport((optsCmdLine.verbose > 1) + CLStr46, file->srcfilename, Plugin_GetDropInName(linker));
+
+    if (!Plugin_VerifyPanels(plugin))
+        return 0;
+
+    if (!linker) {
+        SetupPluginContext(plugin, reqCompDisassemble);
+        static_cast<CWCompilerLinkerContext *>(plugin->context)->whichfile = file->filenum;
+        result = CallPlugin(plugin);
+    } else {
+        SetupPluginContext(plugin, reqDisassemble);
+        static_cast<CWCompilerLinkerContext *>(plugin->context)->whichfile = file->filenum;
+        result = CallPlugin(plugin);
+    }
+
+    return (result == cwNoErr);
+}
+
+Boolean SendInitOrTermRequest(Plugin *plugin, Boolean reqIsInitialize) {
+    CWResult result;
+    OSType ty;
+
+    result = cwErrRequestFailed;
+
+    if (plugin) {
+        if (clState.pluginDebug)
+            CLReport(reqIsInitialize ? CLStr51 : CLStr52, Plugin_GetDropInName(plugin));
+
+        if (reqIsInitialize) {
+            ty = Plugin_GetDropInFlags(plugin)->dropintype;
+            if (ty == CWDROPINDRIVERTYPE) {
+                plugin->context = new CWPluginPrivateContext(ty);
+            } else if (ty == CWDROPINPARSERTYPE) {
+                plugin->context = new CWParserContext();
+            } else if (ty == CWDROPINCOMPILERTYPE || ty == CWDROPINLINKERTYPE) {
+                plugin->context = new CWCompilerLinkerContext();
+            } else {
+                plugin->context = NULL;
+            }
+
+            plugin->context->shellContext = new shellContextType;
+        }
+
+        if (plugin->context) {
+            SetupPluginContext(plugin, reqIsInitialize ? reqInitialize : reqTerminate);
+            result = CallPlugin(plugin);
+        } else {
+            result = cwNoErr;
+        }
+
+        if (!reqIsInitialize)
+            License_AutoCheckin();
+    }
+
+    return (result == cwNoErr);
+}
diff --git a/command_line/CmdLine/Src/CLPrefs.c b/command_line/CmdLine/Src/CLPrefs.c
index e69de29..7aaa28a 100644
--- a/command_line/CmdLine/Src/CLPrefs.c
+++ b/command_line/CmdLine/Src/CLPrefs.c
@@ -0,0 +1,123 @@
+#include "cmdline.h"
+
+struct PrefPanel {
+    char *name;
+    Handle data;
+    Handle workHandle;
+    PrefPanel *next;
+};
+
+static PrefPanel *panellist;
+
+PrefPanel *PrefPanel_New(const char *name, void *initdata, SInt32 initdatasize) {
+    PrefPanel *pnl;
+    pnl = xmalloc(NULL, sizeof(PrefPanel));
+    if (!pnl)
+        return pnl;
+
+    pnl->name = xstrdup(name);
+    pnl->data = NewHandle(initdatasize);
+    if (!pnl->data) {
+        fprintf(stderr, "\n*** Out of memory\n");
+        exit(-23);
+    }
+
+    pnl->workHandle = NULL;
+
+    HLock(pnl->data);
+    if (initdata)
+        memcpy(*pnl->data, initdata, initdatasize);
+    else
+        memset(*pnl->data, 0, initdatasize);
+    HUnlock(pnl->data);
+
+    pnl->next = NULL;
+    return pnl;
+}
+
+Handle PrefPanel_GetHandle(PrefPanel *panel) {
+    UInt32 len = GetHandleSize(panel->data);
+    if (!panel->workHandle || !*panel->workHandle)
+        panel->workHandle = NewHandle(len);
+    else
+        SetHandleSize(panel->workHandle, len);
+
+#line 60
+    OPTION_ASSERT(MemError()==noErr);
+
+    HLock(panel->data);
+    HLock(panel->workHandle);
+    memcpy(*panel->workHandle, *panel->data, len);
+    HUnlock(panel->workHandle);
+    HUnlock(panel->data);
+    return panel->workHandle;
+}
+
+int PrefPanel_PutHandle(PrefPanel *panel, Handle data) {
+    UInt32 len = GetHandleSize(data);
+    if (data != panel->workHandle) {
+        if (!panel->workHandle)
+            panel->workHandle = NewHandle(len);
+        else
+            SetHandleSize(panel->workHandle, len);
+        if (MemError() != noErr)
+            return 0;
+
+        HLock(panel->workHandle);
+        HLock(data);
+        memcpy(*panel->workHandle, *data, len);
+        HUnlock(data);
+        HUnlock(panel->workHandle);
+    }
+
+    HLock(panel->data);
+    HLock(panel->workHandle);
+    memcpy(*panel->data, *panel->workHandle, len);
+    HUnlock(panel->workHandle);
+    HUnlock(panel->data);
+    return 1;
+}
+
+void Prefs_Initialize() {
+    panellist = NULL;
+}
+
+void Prefs_Terminate() {
+    PrefPanel *scan;
+    PrefPanel *next;
+
+    for (scan = panellist; scan; scan = next) {
+        xfree(scan->name);
+        DisposeHandle(scan->data);
+        next = scan->next;
+        xfree(scan);
+    }
+}
+
+Boolean Prefs_AddPanel(PrefPanel *panel) {
+    PrefPanel **scan;
+
+    for (scan = &panellist; *scan; scan = &(*scan)->next) {
+        if (!strcmp((*scan)->name, panel->name)) {
+            CLReportError(90, panel->name);
+            return 0;
+        }
+    }
+
+    if (clState.pluginDebug)
+        CLPrint("Defining/adding pref panel '%s'\n", panel->name);
+
+    *scan = panel;
+    return 1;
+}
+
+PrefPanel *Prefs_FindPanel(const char *name) {
+    PrefPanel *scan;
+
+    for (scan = panellist; scan; scan = scan->next) {
+        if (!ustrcmp(scan->name, name))
+            break;
+    }
+
+    return scan;
+}
diff --git a/command_line/CmdLine/Src/CLTarg.c b/command_line/CmdLine/Src/CLTarg.c
index e69de29..a3f4389 100644
--- a/command_line/CmdLine/Src/CLTarg.c
+++ b/command_line/CmdLine/Src/CLTarg.c
@@ -0,0 +1,55 @@
+#include "cmdline.h"
+
+Target *Target_New(const char *name, OSType cpu, OSType os, OSType lang) {
+    Target *targ;
+
+    targ = xcalloc("target", sizeof(Target));
+
+    strncpy(targ->targetName, name, sizeof(targ->targetName));
+    targ->targetinfo = xcalloc("target info", sizeof(CWTargetInfo));
+    targ->cpu = cpu;
+    targ->os = os;
+    targ->lang = lang;
+
+    OS_GetCWD(&targ->outputDirectory);
+
+#line 25
+    OPTION_ASSERT(Segments_Initialize(&targ->linkage.segs));
+#line 28
+    OPTION_ASSERT(Overlays_Initialize(&targ->linkage.overlays));
+#line 35
+    OPTION_ASSERT(Files_Initialize(&targ->files) && Files_Initialize(&targ->pchs) && VFiles_Initialize(&targ->virtualFiles) &&
+                          Paths_Initialize(&targ->sysPaths) && Paths_Initialize(&targ->userPaths) && Incls_Initialize(&targ->incls, targ));
+
+    return targ;
+}
+
+void Target_Free(Target *targ) {
+    Segments_Terminate(&targ->linkage.segs);
+    Overlays_Terminate(&targ->linkage.overlays);
+    Paths_Terminate(&targ->sysPaths);
+    Paths_Terminate(&targ->userPaths);
+    Files_Terminate(&targ->files);
+    Files_Terminate(&targ->pchs);
+    VFiles_Terminate(&targ->virtualFiles);
+    Incls_Terminate(&targ->incls);
+    xfree(targ);
+}
+
+void Targets_Term(Target *list) {
+    Target *scan;
+    Target *next;
+
+    for (scan = list; scan; scan = next) {
+        next = scan->next;
+        Target_Free(scan);
+    }
+}
+
+void Target_Add(Target **list, Target *targ) {
+    Target **scan;
+
+    for (scan = list; *scan; scan = &(*scan)->next) {}
+
+    *scan = targ;
+}
diff --git a/command_line/CmdLine/Src/CLToolExec.c b/command_line/CmdLine/Src/CLToolExec.c
index e69de29..80e3a7c 100644
--- a/command_line/CmdLine/Src/CLToolExec.c
+++ b/command_line/CmdLine/Src/CLToolExec.c
@@ -0,0 +1,243 @@
+#include "cmdline.h"
+
+extern char STSbuf[256];
+extern PCmdLine pCmdLine;
+
+void AppendArgumentList(int *argc, char ***argv, const char *str) {
+    *argv = xrealloc("command-line arguments", *argv, sizeof(char *) * (*argc + 2));
+    (*argv)[(*argc)++] = xstrdup(str);
+}
+
+static int CopyArgumentList(int argc, char **argv, int *Argc, char ***Argv) {
+    int x;
+    int y;
+
+    y = Argc ? *Argc : 0;
+    *Argv = xrealloc("command-line arguments", *Argv, sizeof(char *) * (y + argc + 1));
+
+    if (argv) {
+        for (x = 0; x < argc; x++) {
+            (*Argv)[y++] = xstrdup(argv[x]);
+        }
+    }
+    (*Argv)[y] = NULL;
+    if (Argc)
+        *Argc = y;
+
+    return 1;
+}
+
+static int FreeArgumentList(char **argv) {
+    char **scan;
+    for (scan = argv; *scan; scan++)
+        xfree(*scan);
+    xfree(argv);
+    return 1;
+}
+
+static int SetupLinkerCommandLine(SInt32 dropinflags, File *file, CWCommandLineArgs *args) {
+    CWCommandLineArgs *baseargs;
+    int x;
+    SInt32 idx;
+    OSSpec spec;
+
+    for (x = 0; x < numPlugins; x++) {
+        if (pluginInfo[x].plugintype == CWDROPINLINKERTYPE && ((dropinflags & (isPostLinker | isPreLinker)) == (pluginInfo[x].dropinflags & (isPostLinker | isPreLinker))))
+            break;
+    }
+
+#line 89
+    OPTION_ASSERT(x < numPlugins);
+
+    args->argc = 1;
+    args->argv = xmalloc("command-line arguments", 2 * sizeof(char *));
+    Main_PassSpecialArgs(&args->argc, &args->argv);
+
+    baseargs = &plugin_args[x];
+    CopyArgumentList(baseargs->argc - 1, baseargs->argv + 1, &args->argc, &args->argv);
+
+    x = 0;
+    if (baseargs->envp) {
+        while (baseargs->envp[x])
+            x++;
+    }
+    args->envp = NULL;
+    CopyArgumentList(x, baseargs->envp, NULL, &args->envp);
+
+    if (!file && !(dropinflags & isPostLinker)) {
+        for (idx = 0; idx < Files_Count(&gTarg->files); idx++) {
+            file = Files_GetFile(&gTarg->files, idx);
+            if (file->sourceUsage & CmdLineStageMask_Cg) {
+                AppendArgumentList(&args->argc, &args->argv, file->srcfilename);
+            }
+            if (file->objectUsage & CmdLineStageMask_Cg) {
+                if (GetOutputFile(file, CmdLineStageMask_Cg) != 0 && StoreObjectFile(file))
+                    AppendArgumentList(&args->argc, &args->argv, OS_SpecToString(&file->outfss, STSbuf, sizeof(STSbuf)));
+                else
+                    return 0;
+            }
+        }
+    } else if (file) {
+        args->argv = xrealloc("command-line arguments", args->argv, sizeof(char *) * (args->argc + 1));
+        if (file->sourceUsage & CmdLineStageMask_Cg) {
+            AppendArgumentList(&args->argc, &args->argv, file->srcfilename);
+        }
+        if (file->objectUsage & CmdLineStageMask_Cg) {
+            if (GetOutputFile(file, CmdLineStageMask_Cg) != 0 && StoreObjectFile(file)) {
+                AppendArgumentList(&args->argc, &args->argv, OS_SpecToString(&file->outfss, STSbuf, sizeof(STSbuf)));
+            }
+        }
+        if ((pCmdLine.toDisk & CmdLineStageMask_Ds) && (file->objectUsage & CmdLineStageMask_Pp) && file->outfilename[0] && GetOutputFile(file, CmdLineStageMask_Ds)) {
+            AppendArgumentList(&args->argc, &args->argv, "-o");
+            AppendArgumentList(&args->argc, &args->argv, OS_SpecToString(&file->outfss, STSbuf, sizeof(STSbuf)));
+        }
+    } else if (dropinflags & isPostLinker) {
+        OS_FSSpec_To_OSSpec(&gTarg->targetinfo->outfile, &spec);
+        AppendArgumentList(&args->argc, &args->argv, OS_SpecToString(&spec, STSbuf, sizeof(STSbuf)));
+    }
+
+    args->argv[args->argc] = NULL;
+    return 1;
+}
+
+int SetupTemporaries() {
+    SInt32 idx;
+    File *file;
+
+    for (idx = 0; idx < Files_Count(&gTarg->files); idx++) {
+        file = Files_GetFile(&gTarg->files, idx);
+        if ((file->objectUsage & CmdLineStageMask_Cg) && !(optsCmdLine.toDisk & CmdLineStageMask_Cg) && !(file->writeToDisk & CmdLineStageMask_Cg)) {
+            if (!optsCompiler.keepObjects)
+                file->tempOnDisk |= CmdLineStageMask_Cg;
+            else
+                file->writeToDisk |= CmdLineStageMask_Cg;
+        }
+    }
+
+    return 1;
+}
+
+int DeleteTemporaries() {
+    SInt32 idx;
+    File *file;
+
+    for (idx = 0; idx < Files_Count(&gTarg->files); idx++) {
+        file = Files_GetFile(&gTarg->files, idx);
+        if ((file->objectUsage & CmdLineStageMask_Cg) && (file->tempOnDisk & CmdLineStageMask_Cg) && (file->wroteToDisk & CmdLineStageMask_Cg)) {
+            GetOutputFile(file, CmdLineStageMask_Cg);
+            if (optsCmdLine.verbose > 1)
+                CLReport(19, OS_SpecToString(&file->outfss, STSbuf, sizeof(STSbuf)));
+            OS_Delete(&file->outfss);
+            file->tempOnDisk &= ~CmdLineStageMask_Cg;
+            file->wroteToDisk &= ~CmdLineStageMask_Cg;
+        }
+    }
+
+    return 1;
+}
+
+int ExecuteLinker(Plugin *plugin, SInt32 dropinflags, File *file, char *stdoutfile, char *stderrfile) {
+    char cname[64];
+    const char *linkername;
+    OSSpec linkerspec;
+    CWCommandLineArgs args;
+    int exitcode;
+    int execerr;
+    const char *linkertype;
+    int ret;
+    char *ptr;
+    char *ptr2;
+    int x;
+
+    // TODO rename this flag to isExecutableTool
+#line 269
+    OPTION_ASSERT(dropinflags & dropInExecutableTool);
+
+    args.argc = 0;
+    args.argv = args.envp = NULL;
+
+    if (dropinflags & isPreLinker)
+        linkertype = "pre-linker";
+    else if (dropinflags & isPostLinker)
+        linkertype = "post-linker";
+    else
+        linkertype = "linker";
+
+    linkername = Plugin_GetDropInName(plugin);
+    if (!(dropinflags & (isPreLinker | isPostLinker)) && optsCompiler.linkerName[0])
+        linkername = optsCompiler.linkerName;
+
+    if (OS_FindProgram(linkername, &linkerspec)) {
+        strcpy(cname, clState.programName);
+
+        for (ptr = cname; *ptr; ptr++)
+            *ptr = tolower(*ptr);
+
+        if ((ptr = strstr(cname, "cc")) || (ptr = strstr(cname, "pas")) || (ptr = strstr(cname, "asm"))) {
+            if (ptr[0] != 'c') {
+                memmove(ptr + 2, ptr + 3, strlen(ptr) - 3);
+                ptr[strlen(ptr) - 1] = 0;
+            }
+            ptr[0] = 'l';
+            ptr[1] = 'd';
+        } else {
+            if ((ptr = strstr(cname, "mwc"))) {
+                // this ptr2 seems redundant, but it's needed to generate the same code
+                ptr2 = ptr + 2;
+                memmove(ptr2 + 3, ptr2, strlen(ptr2));
+                memcpy(ptr + 2, "Link", 4);
+            }
+        }
+
+        if (!OS_FindProgram(cname, &linkerspec)) {
+            ptr = cname;
+            if (optsCompiler.linkerName[0]) {
+                CLReportWarning(66, linkertype, optsCompiler.linkerName);
+                CLReport(65, ptr, clState.programName);
+            } else if (optsCmdLine.verbose) {
+                CLReport(65, ptr, clState.programName);
+            }
+        } else {
+            CLReportError(66, linkertype, linkername);
+            return 0;
+        }
+    }
+
+    ret = 1;
+    SetupLinkerCommandLine(dropinflags, file, &args);
+    args.argv[0] = xstrdup(OS_SpecToString(&linkerspec, STSbuf, sizeof(STSbuf)));
+    args.argv[args.argc] = 0;
+
+    if (optsCmdLine.verbose || optsCmdLine.dryRun) {
+        CLPrint("\nCommand line:\n");
+        for (x = 0; x < args.argc && args.argv[x]; x++) {
+            if (strchr(args.argv[x], ' '))
+                CLPrint("\"%s\" ", args.argv[x]);
+            else
+                CLPrint("%s ", args.argv[x]);
+        }
+        CLPrint("\n\n");
+    }
+
+    fflush(stdout);
+    fflush(stderr);
+
+    if (optsCmdLine.verbose)
+        CLReport(67, linkertype, OS_SpecToString(&linkerspec, STSbuf, sizeof(STSbuf)));
+
+    if (!optsCmdLine.dryRun) {
+        execerr = OS_Execute(&linkerspec, args.argv, args.envp, stdoutfile, stderrfile, &exitcode);
+        if (execerr) {
+            CLReportError(68, linkertype, args.argv[0], OS_GetErrText(execerr));
+            ret = 0;
+        } else if (exitcode) {
+            CLReportError(69 /*nice*/, linkertype, args.argv[0], exitcode);
+            ret = 0;
+        }
+    }
+
+    FreeArgumentList(args.argv);
+    FreeArgumentList(args.envp);
+
+    return ret;
+}
diff --git a/command_line/CmdLine/Src/CLWriteObjectFile.c b/command_line/CmdLine/Src/CLWriteObjectFile.c
index e69de29..6e92114 100644
--- a/command_line/CmdLine/Src/CLWriteObjectFile.c
+++ b/command_line/CmdLine/Src/CLWriteObjectFile.c
@@ -0,0 +1,44 @@
+#include "cmdline.h"
+
+extern char STSbuf[256];
+
+int WriteObjectFile(File *file, OSType maccreator, OSType mactype) {
+    FSSpec srcfss;
+    FSSpec outfss;
+
+#line 22
+    OPTION_ASSERT(file->objectdata && file->compiler);
+
+    OS_OSSpec_To_FSSpec(&file->outfss, &outfss);
+    OS_OSSpec_To_FSSpec(&file->srcfss, &srcfss);
+
+    if (optsCmdLine.verbose) {
+        CLReport(16,
+                 (file->tempOnDisk & CmdLineStageMask_Cg) ? "temporary " : "",
+                 OS_SpecToStringRelative(&file->outfss, NULL, STSbuf, sizeof(STSbuf)));
+    }
+
+    if (!Plugin_CL_WriteObjectFile(file->compiler, &srcfss, &outfss, maccreator, mactype, file->objectdata))
+        return 0;
+    else
+        return 1;
+}
+
+int WriteBrowseData(File *file, OSType maccreator, OSType mactype) {
+    OSHandle browsehandle;
+    OSSpec outfss;
+    const CWObjectFlags *cof;
+
+    cof = Plugin_CL_GetObjectFlags(file->compiler);
+    outfss = file->outfss;
+
+    OS_NameSpecSetExtension(&outfss.name, optsCompiler.brsFileExt[0] ? optsCompiler.brsFileExt : cof->brsFileExt);
+    if (optsCmdLine.verbose) {
+        CLReport(17, OS_SpecToStringRelative(&outfss, NULL, STSbuf, sizeof(STSbuf)));
+    }
+
+    if (!Browser_PackBrowseFile(file->browsedata, &clState.browseTableHandle, &browsehandle))
+        return 0;
+
+    return WriteBinaryHandleToFile(&outfss, maccreator, mactype, &browsehandle) != 0;
+}
diff --git a/command_line/CmdLine/Src/Callbacks/CLCompilerLinkerDropin_V10.cpp b/command_line/CmdLine/Src/Callbacks/CLCompilerLinkerDropin_V10.cpp
index 5861e94..070bc07 100644
--- a/command_line/CmdLine/Src/Callbacks/CLCompilerLinkerDropin_V10.cpp
+++ b/command_line/CmdLine/Src/Callbacks/CLCompilerLinkerDropin_V10.cpp
@@ -1,27 +1,636 @@
-/**
- P   1F458 | _UCBCachePrecompiledHeader
- P   1F4F8 | _UCBLoadObjectData
- P   1F5BC | _UCBStoreObjectData
- P   1F860 | _UCBFreeObjectData
- P   1F90C | _UCBDisplayLines
- P   1F980 | _UCBBeginSubCompile
- P   1F9F0 | _UCBEndSubCompile
- P   1FA60 | _UCBGetPrecompiledHeaderSpec
- P   1FD38 | _UCBGetResourceFile
- P   1FDA8 | _UCBPutResourceFile
-     1FE18 | _UnitNameToSBMName__FP6OSSpecP4File
- P   1FEA0 | _UCBLookUpUnit
- P   20544 | _UCBSBMfiles
- P   20594 | _UCBStoreUnit
- P   20848 | _UCBReleaseUnit
- P   208C8 | _UCBUnitNameToFileName
- P   20978 | _UCBOSAlert
- P   20A50 | _UCBOSErrorMessage
- P   20B38 | _UCBGetModifiedFiles
- P   20BBC | _UCBGetSuggestedObjectFileSpec
- P   20C78 | _UCBGetStoredObjectFileSpec
- P   20D4C | _UCBGetFrameworkCount
- P   20DB0 | _UCBGetFrameworkInfo
- P   20E48 | ___ct__23CWCompilerLinkerContextFv
- P   20FEC | ___dt__23CWCompilerLinkerContextFv
-*/
+#include "cmdline.h"
+#include "plugin_internal.h"
+
+extern char STSbuf[256];
+
+CWResult UCBCachePrecompiledHeader(CWPluginContext context, const CWFileSpec *filespec, CWMemHandle pchhandle) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBCachePrecompiledHeader");
+
+    OSSpec spec;
+    Handle handle;
+    OS_FSSpec_To_OSSpec(filespec, &spec);
+    UCBSecretDetachHandle(context, pchhandle, &handle);
+    CacheIncludeFile(&spec, handle, 1);
+    return cwNoErr;
+}
+
+CWResult UCBLoadObjectData(CWPluginContext context, SInt32 whichfile, CWMemHandle *objectdata) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBLoadObjectData");
+
+    File *file = Files_GetFile(&gTarg->files, whichfile);
+    if (!file)
+        return cwErrUnknownFile;
+
+    if (file->objectdata) {
+        UCBSecretAttachHandle(context, file->objectdata, objectdata);
+        return cwNoErr;
+    } else {
+        return cwErrRequestFailed;
+    }
+}
+
+CWResult UCBStoreObjectData(CWPluginContext context, SInt32 whichfile, CWObjectData *object) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBStoreObjectData");
+
+    if (CheckForUserBreak())
+        return cwErrUserCanceled;
+
+    File *filedata = Files_GetFile(&gTarg->files, whichfile);
+    if (!filedata)
+        return cwErrUnknownFile;
+
+    if (!object->objectfile) {
+        Handle objecthand;
+        Handle browsehand;
+        UCBSecretDetachHandle(context, object->objectdata, &objecthand);
+        UCBSecretDetachHandle(context, object->browsedata, &browsehand);
+        filedata->objectdata = objecthand;
+        filedata->browsedata = browsehand;
+        UCBSecretAttachHandle(context, objecthand, &object->objectdata);
+        UCBSecretAttachHandle(context, browsehand, &object->browsedata);
+    } else {
+        if (filedata->outfileowner && filedata->outfileowner != CmdLineStageMask_Cg) {
+#line 240
+            DO_INTERNAL_ERROR("Cannot store object file spec for '%s'\n", filedata->srcfilename);
+        }
+        OS_FSSpec_To_OSSpec(object->objectfile, &filedata->outfss);
+        filedata->wroteToDisk |= CmdLineStageMask_Cg;
+    }
+
+    filedata->codesize = object->codesize;
+    filedata->udatasize = object->udatasize;
+    filedata->idatasize = object->idatasize;
+    filedata->compiledlines = object->compiledlines;
+    if (filedata->dropinflags & kGeneratesrsrcs)
+        filedata->hasresources = 1;
+    else
+        filedata->hasobjectcode = 1;
+    filedata->recompileDependents = object->dependencyCount && object->interfaceChanged;
+    OS_GetTime(&filedata->outmoddate);
+    if (object->reserved1)
+        filedata->filetype = object->reserved1;
+
+    if (object->reserved2) {
+        char *newname = reinterpret_cast<char *>(object->reserved2);
+        CWFileInfo fi;
+        if (OS_MakeSpec(newname, &filedata->srcfss, NULL) || OS_Status(&filedata->srcfss)) {
+            fi.fullsearch = 1;
+            fi.dependencyType = cwNoDependency;
+            fi.isdependentoffile = -1;
+            fi.suppressload = 1;
+            if (UCBFindAndLoadFile(context, newname, &fi) == cwNoErr) {
+                OS_FSSpec_To_OSSpec(&fi.filespec, &filedata->srcfss);
+            } else {
+                char *fnptr = OS_GetFileNamePtr(newname);
+                if (fnptr != newname) {
+                    fi.fullsearch = 1;
+                    fi.dependencyType = cwNoDependency;
+                    fi.isdependentoffile = -1;
+                    fi.suppressload = 1;
+                    if (UCBFindAndLoadFile(context, fnptr, &fi) == cwNoErr) {
+                        OS_FSSpec_To_OSSpec(&fi.filespec, &filedata->srcfss);
+                    }
+                }
+            }
+        }
+    }
+
+    return cwNoErr;
+}
+
+CWResult UCBFreeObjectData(CWPluginContext context, SInt32 whichfile, CWMemHandle objectdata) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBFreeObjectData");
+
+    File *file = Files_GetFile(&gTarg->files, whichfile);
+    if (!file)
+        return cwErrUnknownFile;
+
+    if (file->objectdata) {
+        DisposeHandle(file->objectdata);
+        file->objectdata = NULL;
+        return cwNoErr;
+    } else {
+        return cwErrInvalidParameter;
+    }
+}
+
+CWResult UCBDisplayLines(CWPluginContext context, SInt32 nlines) {
+    ShowWorking(12);
+
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBDisplayLines");
+
+    if (CheckForUserBreak())
+        return cwErrUserCanceled;
+    else
+        return cwNoErr;
+}
+
+CWResult UCBBeginSubCompile(CWPluginContext context, SInt32 whichfile, CWPluginContext *subContext) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBBeginSubCompile");
+
+#line 372
+    DO_INTERNAL_ERROR("UCBBeginSubCompile not implemented");
+    return cwErrRequestFailed;
+}
+
+CWResult UCBEndSubCompile(CWPluginContext subContext) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBEndSubCompile");
+
+#line 384
+    DO_INTERNAL_ERROR("UCBEndSubCompile not implemented");
+    return cwErrRequestFailed;
+}
+
+CWResult UCBGetPrecompiledHeaderSpec(CWPluginContext context, CWFileSpec *pchspec, const char *intarget) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetPrecompiledHeaderSpec");
+
+    CWCompilerLinkerContext *c;
+    int err;
+    OSSpec outfss;
+    File *file;
+    const CWObjectFlags *cof;
+    char target[256];
+
+    if (context->pluginType == CWDROPINCOMPILERTYPE || context->pluginType == CWDROPINLINKERTYPE)
+        c = static_cast<CWCompilerLinkerContext *>(context);
+    else
+        return cwErrInvalidCallback;
+
+    file = Files_GetFile(&gTarg->files, c->whichfile);
+#line 420
+    OPTION_ASSERT(file != NULL);
+
+    cof = Plugin_CL_GetObjectFlags(file->compiler);
+    if (!file->outfilename[0]) {
+        if (intarget) {
+            if (optsCompiler.canonicalIncludes)
+                strcpy(target, intarget);
+            else if (OS_CanonPath(intarget, target) != noErr)
+                return cwErrInvalidParameter;
+
+            err = OS_MakeSpecWithPath(&file->srcfss.path, target, 0, &outfss);
+            if (err) {
+                CLReportOSError(CLStr97, err, target);
+                return cwErrRequestFailed;
+            }
+
+            if (!file->outfileowner || file->outfileowner == CmdLineStageMask_Cg) {
+                file->outfileowner = CmdLineStageMask_Cg;
+                OS_SpecToStringRelative(&outfss, NULL, file->outfilename, sizeof(file->outfilename));
+            }
+
+            if (optsCmdLine.verbose)
+                CLReport(CLStr16, "precompiled ", OS_SpecToStringRelative(&outfss, NULL, STSbuf, sizeof(STSbuf)));
+        } else {
+            OS_MakeSpecWithPath(&gTarg->outputDirectory, file->srcfilename, optsCompiler.relPathInOutputDir == 0, &outfss);
+            OS_NameSpecSetExtension(&outfss.name, optsCompiler.pchFileExt[0] ? optsCompiler.pchFileExt : cof->pchFileExt);
+
+            if (!file->outfileowner || file->outfileowner == CmdLineStageMask_Cg) {
+                file->outfileowner = CmdLineStageMask_Cg;
+                OS_NameSpecToString(&outfss.name, file->outfilename, sizeof(file->outfilename));
+            }
+
+            CLReport(CLStr59, OS_SpecToStringRelative(&outfss, NULL, STSbuf, sizeof(STSbuf)));
+        }
+
+        OS_OSSpec_To_FSSpec(&outfss, pchspec);
+    } else {
+        err = OS_MakeSpecWithPath(&gTarg->outputDirectory, file->outfilename, 0, &outfss);
+        if (err) {
+            CLReportOSError(CLStr97, err, file->outfilename);
+            return cwErrRequestFailed;
+        }
+
+        OS_OSSpec_To_FSSpec(&outfss, pchspec);
+
+        if (intarget)
+            CLReport(CLStr60, OS_SpecToStringRelative(&outfss, NULL, STSbuf, sizeof(STSbuf)), intarget);
+    }
+
+    return cwNoErr;
+}
+
+CWResult UCBGetResourceFile(CWPluginContext context, CWFileSpec *filespec) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetResourceFile");
+
+#line 514
+    DO_INTERNAL_ERROR("UCBGetResourceFile not implemented");
+    return cwErrRequestFailed;
+}
+
+CWResult UCBPutResourceFile(CWPluginContext context, const char *prompt, const char *name, CWFileSpec *filespec) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBPutResourceFile");
+
+#line 529
+    DO_INTERNAL_ERROR("UCBPutResourceFile not implemented");
+    return cwErrRequestFailed;
+}
+
+static int UnitNameToSBMName(OSSpec *spec, File *srcfile) {
+    const CWObjectFlags *cof;
+    int err;
+
+    cof = Plugin_CL_GetObjectFlags(srcfile->compiler);
+    err = OS_NameSpecChangeExtension(
+            &spec->name,
+            cof->pchFileExt ? cof->pchFileExt : ".sbm",
+            cof->pchFileExt ? (cof->pchFileExt[0] == '.') : 0
+            );
+    return err;
+}
+
+CWResult UCBLookUpUnit(CWPluginContext context, const char *name, Boolean isdependency, const void **unitdata, SInt32 *unitdatalength) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBLookUpUnit");
+
+    CWFileInfo includeinfo;
+    OSSpec unitspec;
+    OSSpec sbmspec;
+    time_t unittime;
+    UInt32 unitmactime;
+    char sbmpath[256];
+    int err;
+    CWCompilerLinkerContext *c;
+    File *srcfile;
+    File *sbmfile;
+
+    if (context->pluginType == CWDROPINCOMPILERTYPE || context->pluginType == CWDROPINLINKERTYPE)
+        c = static_cast<CWCompilerLinkerContext *>(context);
+    else
+        return cwErrInvalidCallback;
+
+    srcfile = Files_GetFile(&gTarg->files, c->whichfile);
+#line 591
+    OPTION_ASSERT(srcfile != NULL);
+
+    *unitdata = NULL;
+    *unitdatalength = 0;
+
+    if (optsCompiler.sbmState == OptsCompilerSbmState_1 || optsCompiler.sbmState == OptsCompilerSbmState_3) {
+        if (clState.pluginDebug)
+            CLPrint("UCBLookUpUnit:  sbmState == sbmRebuild or sbmClean; failing\n");
+        return cwErrSBMNotFound;
+    }
+
+    includeinfo.fullsearch = 1;
+    includeinfo.dependencyType = isdependency ? cwNormalDependency : cwNoDependency;
+    includeinfo.isdependentoffile = -1;
+    includeinfo.suppressload = 1;
+    if (UCBFindAndLoadFile(context, name, &includeinfo) != cwNoErr) {
+        if (clState.pluginDebug)
+            CLPrint("UCBLookUpUnit:  could not find source '%s'; failing\n", name);
+        return cwErrFileNotFound;
+    }
+
+    OS_FSSpec_To_OSSpec(&includeinfo.filespec, &unitspec);
+    sbmspec = unitspec;
+    err = UnitNameToSBMName(&sbmspec, srcfile);
+    if (err) {
+        if (clState.pluginDebug)
+            CLPrint("UCBLookUpUnit:  could not make precompiled unit spec for '%s' (%s)\n", name, OS_GetErrText(err));
+        return cwErrRequestFailed;
+    }
+
+    if (optsCompiler.sbmPath[0]) {
+        sbmspec.path = clState.sbmPathSpec;
+        OS_SpecToString(&sbmspec, sbmpath, sizeof(sbmpath));
+        if (clState.pluginDebug)
+            CLPrint("UCBLookUpUnit:  Only looking at '%s'\n", sbmpath);
+    } else {
+        OS_NameSpecToString(&sbmspec.name, sbmpath, sizeof(sbmpath));
+        if (clState.pluginDebug)
+            CLPrint("UCBLookUpUnit:  searching paths for '%s'\n", sbmpath);
+    }
+
+    includeinfo.fullsearch = 1;
+    includeinfo.dependencyType = isdependency ? cwNormalDependency : cwNoDependency;
+    includeinfo.isdependentoffile = -1;
+    includeinfo.suppressload = 0;
+    if (UCBFindAndLoadFile(context, sbmpath, &includeinfo) != cwNoErr || !includeinfo.filedata) {
+        if (clState.pluginDebug)
+            CLPrint("UCBLookUpUnit:  could not find or load precompiled unit file '%s'; failing\n", sbmpath);
+        return cwErrFileNotFound;
+    }
+
+    OS_FSSpec_To_OSSpec(&includeinfo.filespec, &sbmspec);
+    if (includeinfo.filedatatype != cwFileTypePrecompiledHeader) {
+        CLPrint("UCBLookUpUnit:  file '%s' does not appear to be precompiled\n", OS_SpecToString(&sbmspec, STSbuf, sizeof(STSbuf)));
+        UCBReleaseFileText(context, includeinfo.filedata);
+        return cwErrRequestFailed;
+    }
+
+    OS_GetFileTime(&unitspec, NULL, &unittime);
+    OS_TimeToMac(unittime, &unitmactime);
+    if (unitmactime != *reinterpret_cast<const UInt32 *>(includeinfo.filedata)) {
+        if (clState.pluginDebug)
+            CLPrint(
+                    "UCBLookUpUnit:  file '%s' does not have internal timestamp that matches source unit's timestamp (0x%8x != 0x%8x)\n",
+                    OS_SpecToString(&sbmspec, STSbuf, sizeof(STSbuf)),
+                    unitmactime,
+                    *reinterpret_cast<const UInt32 *>(includeinfo.filedata));
+        UCBReleaseFileText(context, includeinfo.filedata);
+        return cwErrRequestFailed;
+    }
+
+    sbmfile = Files_FindFile(&gTarg->pchs, &sbmspec);
+    if (!sbmfile) {
+        sbmfile = File_New();
+        sbmfile->srcfss = unitspec;
+        OS_SpecToString(&sbmfile->srcfss, sbmfile->srcfilename, sizeof(sbmfile->srcfilename));
+        sbmfile->outfss = sbmspec;
+        OS_SpecToString(&sbmfile->outfss, sbmfile->outfilename, sizeof(sbmfile->outfilename));
+        sbmfile->compiler = srcfile->compiler;
+        sbmfile->outfileowner = CmdLineStageMask_Cg;
+        sbmfile->writeToDisk = srcfile->writeToDisk;
+        sbmfile->dropinflags = srcfile->dropinflags;
+        sbmfile->objectflags = srcfile->objectflags;
+        sbmfile->mappingflags = srcfile->mappingflags;
+        Deps_Initialize(&sbmfile->deps, &gTarg->incls);
+        if (!Files_AddFile(&gTarg->pchs, sbmfile))
+            return cwErrRequestFailed;
+    }
+
+    if (clState.pluginDebug)
+        CLPrint("UCBLookUpUnit:  success for '%s'\n", name);
+
+    if (optsCmdLine.verbose)
+        CLReport(CLStr62, "unit symbol table", OS_SpecToStringRelative(&sbmspec, NULL, STSbuf, sizeof(STSbuf)));
+
+    *unitdata = includeinfo.filedata;
+    *unitdatalength = includeinfo.filedatalength;
+    return cwNoErr;
+}
+
+CWResult UCBSBMfiles(CWPluginContext context, short libref) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBSBMfiles");
+    return cwNoErr;
+}
+
+CWResult UCBStoreUnit(CWPluginContext context, const char *inunitname, CWMemHandle unitdata, CWDependencyTag dependencytag) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBStoreUnit");
+
+    char unitname[256];
+    OSSpec sbmspec;
+    int err;
+    Handle h;
+    OSHandle unithand;
+    OSFileHandle fhand;
+    CWCompilerLinkerContext *c;
+    File *srcfile;
+
+    if (optsCompiler.canonicalIncludes) {
+        strcpy(unitname, inunitname);
+    } else if (OS_CanonPath(inunitname, unitname)) {
+        return cwErrInvalidParameter;
+    }
+
+    if (optsCompiler.sbmState == OptsCompilerSbmState_0 || optsCompiler.sbmState == OptsCompilerSbmState_1) {
+        if (context->pluginType == CWDROPINCOMPILERTYPE || context->pluginType == CWDROPINLINKERTYPE)
+            c = static_cast<CWCompilerLinkerContext *>(context);
+        else
+            return cwErrInvalidCallback;
+
+        srcfile = Files_GetFile(&gTarg->files, c->whichfile);
+#line 791
+        OPTION_ASSERT(srcfile != NULL);
+
+        if (optsCompiler.sbmPath[0]) {
+            err = OS_MakeSpecWithPath(&clState.sbmPathSpec, unitname, 1, &sbmspec);
+            if (err) {
+                if (clState.pluginDebug)
+                    CLPrint("UCBStoreUnit:  '%s' is a bad unit name (%s)\n", unitname, OS_GetErrText(err));
+                return cwErrInvalidParameter;
+            }
+        } else {
+            err = OS_MakeFileSpec(unitname, &sbmspec);
+            if (err) {
+                if (clState.pluginDebug)
+                    CLPrint("UCBStoreUnit:  '%s' is a bad filename (%s)\n", unitname, OS_GetErrText(err));
+                return cwErrInvalidParameter;
+            }
+        }
+
+        err = UnitNameToSBMName(&sbmspec, srcfile);
+        if (err) {
+            if (clState.pluginDebug)
+                CLPrint("UCBStoreUnit:  could not make precompiled unit form of '%s' (%s)\n", unitname, OS_GetErrText(err));
+            return cwErrInvalidParameter;
+        }
+
+        if (optsCmdLine.verbose)
+            CLReport(CLStr61, "unit symbol table", OS_SpecToStringRelative(&sbmspec, NULL, STSbuf, sizeof(STSbuf)));
+
+        UCBSecretDetachHandle(context, unitdata, &h);
+        OS_DestroyMacHandle(h, &unithand);
+        err = OS_NewFileHandle(&sbmspec, &unithand, 1, &fhand);
+        if (err || (err = OS_FreeFileHandle(&fhand))) {
+            CLReportOSError(CLStr18, err, "precompiled unit", OS_SpecToStringRelative(&sbmspec, NULL, STSbuf, sizeof(STSbuf)));
+            return cwErrRequestFailed;
+        }
+    }
+
+    return cwNoErr;
+}
+
+CWResult UCBReleaseUnit(CWPluginContext context, void *unitdata) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBReleaseUnit");
+
+    if (!unitdata)
+        return cwErrRequestFailed;
+    return UCBReleaseFileText(context, static_cast<const char *>(unitdata));
+}
+
+CWResult UCBUnitNameToFileName(CWPluginContext context, const char *unitname, char *filename) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBUnitNameToFileName");
+
+    strcpy(filename, unitname);
+    if (!OS_EqualPath(filename + strlen(filename) - 2, ".p"))
+        strcat(filename, ".p");
+    return cwNoErr;
+}
+
+CWResult UCBOSAlert(CWPluginContext context, const char *message, OSErr errorcode) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBOSAlert");
+    if (CheckForUserBreak())
+        return cwErrUserCanceled;
+
+    char errormessage[256];
+    GetSysErrText(errorcode, errormessage);
+    CLStyledMessageDispatch(
+            static_cast<shellContextType *>(context->shellContext)->plugin,
+            NULL,
+            errorcode,
+            CLStyledMessageDispatch_Type4,
+            "%\n(%)\n",
+            message ? message : "",
+            errormessage
+    );
+    return cwNoErr;
+}
+
+CWResult UCBOSErrorMessage(CWPluginContext context, const char *message, OSErr errorcode) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBOSErrorMessage");
+    if (!errorcode)
+        return cwNoErr;
+    if (CheckForUserBreak())
+        return cwErrUserCanceled;
+
+    char errormessage[256];
+    GetSysErrText(errorcode, errormessage);
+    CLStyledMessageDispatch(
+            static_cast<shellContextType *>(context->shellContext)->plugin,
+            NULL,
+            errorcode,
+            CLStyledMessageDispatch_Type4,
+            "%\n%\n",
+            message ? message : "",
+            errormessage
+            );
+    return cwNoErr;
+}
+
+CWResult UCBGetModifiedFiles(CWPluginContext context, SInt32 *modifiedFileCount, const SInt32 **modifiedFiles) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetModifiedFiles");
+
+    *modifiedFileCount = 0;
+#line 949
+    DO_INTERNAL_ERROR("CWGetModifiedFiles not implemented!\n");
+    return cwNoErr;
+}
+
+CWResult UCBGetSuggestedObjectFileSpec(CWPluginContext context, SInt32 whichfile, CWFileSpec *fileSpec) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetSuggestedObjectFileSpec");
+
+    File *file;
+    if (!(file = Files_GetFile(&gTarg->files, whichfile)))
+        return cwErrUnknownFile;
+
+    if (!GetOutputFile(file, CmdLineStageMask_Cg))
+        return cwErrRequestFailed;
+
+    OS_OSSpec_To_FSSpec(&file->outfss, fileSpec);
+    return cwNoErr;
+}
+
+CWResult UCBGetStoredObjectFileSpec(CWPluginContext context, SInt32 whichfile, CWFileSpec *fileSpec) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetStoredObjectFileSpec");
+
+    File *file;
+    if (!(file = Files_GetFile(&gTarg->files, whichfile)))
+        return cwErrUnknownFile;
+    if (file->outfileowner != CmdLineStageMask_Cg) {
+#line 993
+        DO_INTERNAL_ERROR("Lost stored object file spec for '%s'\n", file->srcfilename);
+        return cwErrRequestFailed;
+    } else {
+        OS_OSSpec_To_FSSpec(&file->outfss, fileSpec);
+        return cwNoErr;
+    }
+}
+
+CWResult UCBGetFrameworkCount(CWPluginContext context, SInt32 *frameworkCount) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetFrameworkCount");
+
+    *frameworkCount = Frameworks_GetCount();
+    return cwNoErr;
+}
+
+CWResult UCBGetFrameworkInfo(CWPluginContext context, SInt32 whichFramework, CWFrameworkInfo *frameworkInfo) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetFrameworkCount");
+
+    Paths_FWInfo *info;
+    if ((info = Frameworks_GetInfo(whichFramework))) {
+        OS_OSSpec_To_FSSpec(&info->fileSpec, &frameworkInfo->fileSpec);
+        strncpy(frameworkInfo->version, info->version.s, sizeof(frameworkInfo->version));
+        return cwNoErr;
+    }
+
+    return cwErrFileNotFound;
+}
+
+CWCompilerLinkerCallbacks sCompilerLinkerCallbacks = {
+        UCBCachePrecompiledHeader,
+        UCBLoadObjectData,
+        UCBStoreObjectData,
+        UCBFreeObjectData,
+        UCBDisplayLines,
+        UCBBeginSubCompile,
+        UCBEndSubCompile,
+        UCBGetPrecompiledHeaderSpec,
+        UCBGetResourceFile,
+        UCBPutResourceFile,
+        UCBLookUpUnit,
+        UCBSBMfiles,
+        UCBStoreUnit,
+        UCBReleaseUnit,
+        UCBUnitNameToFileName,
+        UCBOSErrorMessage,
+        UCBOSAlert,
+        UCBGetModifiedFiles,
+        UCBGetSuggestedObjectFileSpec,
+        UCBGetStoredObjectFileSpec,
+        NULL,
+        UCBGetFrameworkCount,
+        UCBGetFrameworkInfo
+};
+
+CWCompilerLinkerContext::CWCompilerLinkerContext()
+        :
+        CWPluginPrivateContext(clState.plugintype, sizeof(CWCompilerLinkerContext)) {
+    targetinfo = static_cast<CWTargetInfo *>(xmalloc("context", sizeof(CWTargetInfo)));
+    memset(targetinfo, 0, sizeof(CWTargetInfo));
+
+    if (gTarg) {
+        targetinfo->targetCPU = gTarg->cpu;
+        targetinfo->targetOS = gTarg->os;
+    } else {
+        targetinfo->targetOS = targetOSAny;
+        targetinfo->targetCPU = targetCPUAny;
+    }
+
+    whichfile = 0;
+    memset(&sourcefile, 0, sizeof(sourcefile));
+    sourcetext = NULL;
+    sourcetextsize = 0;
+
+    preprocess = 0;
+    autoprecompile = 0;
+    precompile = 0;
+    cachingPCH = 0;
+    debuginfo = 0;
+    fileID = 0;
+    memset(&browseoptions, 0, sizeof(browseoptions));
+    reserved = NULL;
+    sequenceID = 0;
+    parentPB = NULL;
+    targetStorage = NULL;
+    texthandle = NULL;
+    memset(&targetinfo_V7, 0, sizeof(targetinfo_V7));
+
+    callbacks = &sCompilerLinkerCallbacks;
+}
+
+CWCompilerLinkerContext::~CWCompilerLinkerContext() {
+    xfree(targetinfo);
+}
diff --git a/command_line/CmdLine/Src/Callbacks/CLDropinCallbacks_V10.cpp b/command_line/CmdLine/Src/Callbacks/CLDropinCallbacks_V10.cpp
index cf6f1f7..ed02965 100644
--- a/command_line/CmdLine/Src/Callbacks/CLDropinCallbacks_V10.cpp
+++ b/command_line/CmdLine/Src/Callbacks/CLDropinCallbacks_V10.cpp
@@ -1,48 +1,1305 @@
-/*
-     1B9C8 | _ANSI_To_Mac_GMT_Time__FlPUl
-     1BA88 | _Mac_To_ANSI_Time__FUlPl
- P   1BCA4 | _UCBGetFileInfo
-     1BEA8 | _FindAndLoad_VirtualFile__FP22CWPluginPrivateContextPCcP10CWFileInfoP6OSSpecPUc
-     1BF98 | _FindAndLoad_AccessPathFile__FP22CWPluginPrivateContextPCcP10CWFileInfoP6OSSpecPUc
-     1C108 | _FindAndLoad_MissingFile__FP22CWPluginPrivateContextPCcP10CWFileInfoP6OSSpecPUc
- P   1C278 | _UCBFindAndLoadFile
- P   1C50C | _UCBGetFileText
- P   1C6BC | _UCBReleaseFileText
- P   1C754 | _UCBGetSegmentInfo
- P   1C814 | _UCBGetOverlay1GroupInfo
- P   1C8F0 | _UCBGetOverlay1FileInfo
- P   1C9A0 | _UCBGetOverlay1Info
- P   1CA74 | _UCBReportMessage
- P   1CCDC | _UCBAlert
- P   1CEB4 | _UCBShowStatus
- P   1D00C | _UCBUserBreak
- P   1D078 | _UCBGetNamedPreferences
- P   1D13C | _UCBStorePluginData
- P   1D1AC | _UCBGetPluginData
- P   1D21C | _UCBSetModDate
- P   1D35C | _UCBAddProjectEntry
- P   1DB20 | _UCBCreateNewTextDocument
- P   1DE74 | _UCBAllocateMemory
- P   1DF00 | _UCBFreeMemory
- P   1DF74 | _UCBAllocMemHandle
- P   1E00C | _UCBFreeMemHandle
- P   1E08C | _UCBGetMemHandleSize
- P   1E11C | _UCBResizeMemHandle
- P   1E1C0 | _UCBLockMemHandle
- P   1E238 | _UCBUnlockMemHandle
- P   1E29C | _UCBGetTargetName
- P   1E320 | _UCBPreDialog
- P   1E370 | _UCBPostDialog
- P   1E3C0 | _UCBPreFileAction
- P   1E430 | _UCBPostFileAction
- P   1E4A0 | _UCBCacheAccessPathList
- P   1E7A8 | _UCBSecretAttachHandle
- P   1E814 | _UCBSecretDetachHandle
- P   1E8A0 | _UCBSecretPeekHandle
- P   1E92C | _UCBCheckoutLicense
- P   1E998 | _UCBCheckinLicense
- P   1E9E8 | _UCBResolveRelativePath
- P   1EA28 | _UCBMacOSErrToCWResult
- P   1EA88 | ___ct__22CWPluginPrivateContextFll
- P   1EB10 | ___dt__22CWPluginPrivateContextFv
- */
+#include "cmdline.h"
+#include "plugin_internal.h"
+
+extern char STSbuf[256];
+
+static void ANSI_To_Mac_GMT_Time(time_t sectm, UInt32 *secs) {
+    struct tm *tmrec;
+    int years;
+    int ydays;
+
+    tmrec = localtime(&sectm);
+    years = tmrec->tm_year - 4;
+
+    ydays =
+            (years * 365) +
+            ((years + 3) / 4) -
+            ((years + 4) / 100) +
+            ((years - 296) / 400);
+
+    *secs =
+            ((ydays + tmrec->tm_yday) * 86400)
+            + (tmrec->tm_hour * 3600)
+            + (tmrec->tm_min * 60)
+            + (tmrec->tm_sec);
+}
+
+static void Mac_To_ANSI_Time(UInt32 secs, time_t *sectm) {
+    static int monthdays[12] = {
+            31, 28, 31, 30,
+            31, 30, 31, 31,
+            30, 31, 30, 31
+    };
+    struct tm tmrec;
+    int month;
+
+    memset(&tmrec, 0, sizeof(tmrec));
+    tmrec.tm_sec = secs % 60; // line 1523
+    tmrec.tm_min = (secs / 60) % 60; // line 1524
+    tmrec.tm_hour = (secs / 3600) % 24; // line 1525
+    tmrec.tm_yday = (secs / 86400) % 365;
+    tmrec.tm_year = (secs / 31536000) + 4; // line 1533
+    tmrec.tm_yday -=
+            ((((secs / 31536000) + 3) / 4)
+             -
+             (((secs / 31536000) + 4) / 100)
+             +
+             ((SInt32)((secs / 31536000) - 296) / 400))
+            ;
+
+    if ((tmrec.tm_year % 4) && ((tmrec.tm_year % 100) || !(tmrec.tm_year % 400))) {
+        monthdays[1] = 28;
+    } else {
+        monthdays[1] = 29;
+    }
+
+    for (month = 0; tmrec.tm_yday >= monthdays[month]; month++) {
+        tmrec.tm_yday -= monthdays[month];
+    }
+    tmrec.tm_mon = month;
+    tmrec.tm_mday = tmrec.tm_yday + 1;
+
+    *sectm = mktime(&tmrec);
+    if (month >= 4 && month < 10)
+        *sectm += 3600;
+}
+
+CWResult UCBGetFileInfo(CWPluginContext context, SInt32 whichfile, Boolean checkFileLocation, CWProjectFileInfo *fileinfo) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetFileInfo");
+
+    File *file;
+    SInt16 id;
+    int ret;
+    char fullpath[256];
+    time_t tmptime;
+
+    file = Files_GetFile(&gTarg->files, whichfile);
+    if (!file)
+        return cwErrUnknownFile;
+
+    memset(fileinfo, 0, sizeof(CWProjectFileInfo));
+    OS_OSSpec_To_FSSpec(&file->srcfss, &fileinfo->filespec);
+    OS_TimeToMac(file->srcmoddate, &fileinfo->moddate);
+    Mac_To_ANSI_Time(fileinfo->moddate, &tmptime);
+    ANSI_To_Mac_GMT_Time(tmptime, &fileinfo->moddate);
+
+    fileinfo->segment = file->segnum;
+    fileinfo->hasobjectcode = file->hasobjectcode;
+    fileinfo->hasresources = file->hasresources;
+    fileinfo->isresourcefile = file->isresourcefile;
+    fileinfo->weakimport = file->weakimport;
+    fileinfo->initbefore = file->initbefore;
+    fileinfo->mergeintooutput = file->mergeintooutput;
+    fileinfo->reserved = 0;
+    fileinfo->gendebug = file->gendebug;
+    OS_TimeToMac(file->outmoddate, &fileinfo->objmoddate);
+
+    if (file->compiler) {
+        strncpy(fileinfo->dropinname, Plugin_GetDropInName(file->compiler), 31);
+        fileinfo->dropinname[31] = 0;
+    } else {
+        fileinfo->dropinname[0] = 0;
+    }
+
+    fileinfo->fileID = file->browseFileID;
+    fileinfo->recordbrowseinfo = file->recordbrowseinfo;
+    fileinfo->filetype = file->filetype;
+    fileinfo->filecreator = file->filecreator;
+
+    if (optsCompiler.browserEnabled) {
+        ret = Browser_SearchFile(&clState.browseTableHandle, OS_SpecToString(&file->srcfss, fullpath, sizeof(fullpath)), &id);
+        if (ret) {
+            fileinfo->recordbrowseinfo = 1;
+            fileinfo->fileID = id;
+        } else {
+            fileinfo->recordbrowseinfo = 0;
+            fileinfo->fileID = id;
+        }
+    } else {
+        fileinfo->recordbrowseinfo = 0;
+        fileinfo->fileID = 0;
+    }
+    fileinfo->unitdatadependencytag = 0;
+    fileinfo->hasunitdata = 0;
+    return cwNoErr;
+}
+
+static Boolean FindAndLoad_VirtualFile(CWPluginContext context, const char *filename, CWFileInfo *fileinfo, OSSpec *spec, Boolean *loaded) {
+    VFile *vf;
+    char *fnameptr;
+
+    fnameptr = OS_GetFileNamePtr(const_cast<char *>(filename));
+    vf = VFiles_Find(gTarg->virtualFiles, fnameptr);
+    if (vf) {
+        if (!fileinfo->suppressload) {
+            CopyFileText(vf->data, const_cast<char **>(&fileinfo->filedata), &fileinfo->filedatalength);
+            *loaded = 1;
+        }
+        fileinfo->filedatatype = cwFileTypeText;
+        fileinfo->fileID = 0;
+        fileinfo->alreadyincluded = 0;
+        fileinfo->recordbrowseinfo = 0;
+        fileinfo->filespec.parID = 0;
+        fileinfo->filespec.vRefNum = 0;
+        c2pstrcpy(fileinfo->filespec.name, fnameptr);
+        OS_MakeFileSpec(fnameptr, spec);
+        if (optsCompiler.printHeaderNames)
+            CLPrint("%s\n", fnameptr);
+        return 1;
+    }
+
+    return 0;
+}
+
+static Boolean FindAndLoad_AccessPathFile(CWPluginContext context, const char *filename, CWFileInfo *fileinfo, OSSpec *spec, Boolean *loaded) {
+    SInt32 incl;
+    shellContextType *sc;
+    File *depfile;
+    SInt16 id;
+    int ret;
+    char fullpath[256];
+
+    if (Incls_FindFileInPaths(&gTarg->incls, const_cast<char *>(filename), fileinfo->fullsearch || optsCompiler.noSysPath, spec, &incl)) {
+        if (context->pluginType == CWDROPINCOMPILERTYPE) {
+            depfile = Files_GetFile(
+                    &gTarg->files,
+                    (fileinfo->isdependentoffile < 0) ? static_cast<CWCompilerLinkerContext *>(context)->whichfile : fileinfo->isdependentoffile);
+            if (depfile)
+                Deps_AddDependency(&depfile->deps, incl, NULL, 0, fileinfo->dependencyType, &fileinfo->alreadyincluded);
+
+            if (optsCompiler.browserEnabled) {
+                ret = Browser_SearchAndAddFile(&clState.browseTableHandle, OS_SpecToString(spec, fullpath, sizeof(fullpath)), &id);
+                if (ret == 0) {
+                    return 2;
+                } else if (ret < 0) {
+                    fileinfo->recordbrowseinfo = 1;
+                    fileinfo->fileID = id;
+                } else {
+                    fileinfo->recordbrowseinfo = 0;
+                    fileinfo->fileID = id;
+                }
+            } else {
+                fileinfo->recordbrowseinfo = 0;
+                fileinfo->fileID = 0;
+            }
+        }
+
+        OS_OSSpec_To_FSSpec(spec, &fileinfo->filespec);
+        return 1;
+    }
+
+    return 0;
+}
+
+static Boolean FindAndLoad_MissingFile(CWPluginContext context, const char *filename, CWFileInfo *fileinfo, OSSpec *spec, Boolean *loaded) {
+    File *file;
+    CWCompilerLinkerContext *c;
+
+    if (optsCompiler.ignoreMissingFiles) {
+        if (context->pluginType == CWDROPINCOMPILERTYPE || context->pluginType == CWDROPINLINKERTYPE)
+            c = static_cast<CWCompilerLinkerContext *>(context);
+        else
+            return 0;
+
+        file = Files_GetFile(&gTarg->files, c->whichfile);
+#line 486
+        OPTION_ASSERT(file != NULL);
+
+        OS_MakeSpecWithPath(&file->srcfss.path, filename, 1, spec);
+        Deps_AddDependency(&file->deps, -1, spec, !fileinfo->fullsearch && !optsCompiler.noSysPath, fileinfo->dependencyType, &fileinfo->alreadyincluded);
+
+        fileinfo->fileID = 0;
+        fileinfo->recordbrowseinfo = 0;
+        if (!fileinfo->suppressload) {
+            fileinfo->filedata = xstrdup("");
+            fileinfo->filedatalength = 0;
+            fileinfo->filedatatype = cwFileTypeText;
+            *loaded = 1;
+        } else {
+            fileinfo->filedata = NULL;
+            fileinfo->filedatalength = 0;
+            fileinfo->filedatatype = cwFileTypeUnknown;
+        }
+
+        OS_OSSpec_To_FSSpec(spec, &fileinfo->filespec);
+        return 1;
+    }
+
+    return 0;
+}
+
+CWResult UCBFindAndLoadFile(CWPluginContext context, const char *infilename, CWFileInfo *fileinfo) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBFindAndLoadFile");
+
+    OSSpec spec;
+    Boolean loaded;
+    char filename[256];
+    char browseinfo[64];
+
+    ShowWorking(8);
+    if (CheckForUserBreak())
+        return cwErrUserCanceled;
+
+    if (optsCompiler.canonicalIncludes)
+        strcpy(filename, infilename);
+    else if (OS_CanonPath(infilename, filename))
+        return cwErrInvalidParameter;
+
+    loaded = 0;
+    if (!FindAndLoad_VirtualFile(context, filename, fileinfo, &spec, &loaded) && !FindAndLoad_AccessPathFile(context, filename, fileinfo, &spec, &loaded) && !FindAndLoad_MissingFile(context, filename, fileinfo, &spec, &loaded)) {
+        return cwErrFileNotFound;
+    }
+
+    if (optsCompiler.printHeaderNames)
+        CLPrint("%s\n", OS_SpecToStringRelative(&spec, NULL, STSbuf, sizeof(STSbuf)));
+
+    if (context->pluginType == CWDROPINCOMPILERTYPE) {
+        if (optsCmdLine.verbose > 2) {
+            sprintf(browseinfo, " (browse fileID %d)", fileinfo->fileID);
+            CLReport(
+                    CLStr21,
+                    fileinfo->alreadyincluded ? "Included" : "Including",
+                    OS_SpecToString(&spec, STSbuf, sizeof(STSbuf)),
+                    fileinfo->recordbrowseinfo ? browseinfo : "");
+        } else if (optsCmdLine.verbose > 1 && !fileinfo->alreadyincluded) {
+            CLReport(
+                    CLStr21,
+                    "Including",
+                    OS_SpecToString(&spec, STSbuf, sizeof(STSbuf)),
+                    "");
+        }
+    } else {
+        fileinfo->fileID = 0;
+        fileinfo->recordbrowseinfo = 0;
+        fileinfo->alreadyincluded = 0;
+    }
+
+    if (!loaded) {
+        if (!fileinfo->suppressload) {
+            return UCBGetFileText(context, &fileinfo->filespec, &fileinfo->filedata, &fileinfo->filedatalength, &fileinfo->filedatatype);
+        } else {
+            fileinfo->filedata = NULL;
+            fileinfo->filedatalength = 0;
+            fileinfo->filedatatype = cwFileTypeUnknown;
+            return cwNoErr;
+        }
+    } else {
+        return cwNoErr;
+    }
+}
+
+CWResult UCBGetFileText(CWPluginContext context, const CWFileSpec *filespec, const char **text, SInt32 *textLength, short *filedatatype) {
+    int err;
+    Handle texthandle = NULL;
+    Boolean precomp;
+    OSSpec spec;
+    VFile *vf;
+    char filename[64];
+
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetFileText");
+
+    OS_FSSpec_To_OSSpec(filespec, &spec);
+    err = LoadAndCacheFile(&spec, &texthandle, &precomp);
+    if (err) {
+        p2cstrcpy(filename, filespec->name);
+        if (filespec->vRefNum || filespec->parID || !(vf = VFiles_Find(gTarg->virtualFiles, filename))) {
+            CLReportOSError(CLStr93, err, OS_SpecToString(&spec, STSbuf, sizeof(STSbuf)));
+            return cwErrFileNotFound;
+        }
+        CopyFileText(vf->data, const_cast<char **>(text), textLength);
+        *filedatatype = cwFileTypeText;
+        int err = OS_MakeFileSpec(filename, &spec);
+    } else {
+        if (texthandle) {
+            if (!precomp) {
+                CopyFileText(texthandle, const_cast<char **>(text), textLength);
+                FreeIncludeFile(texthandle);
+            } else {
+                HLock(texthandle);
+                *text = *texthandle;
+                *textLength = GetHandleSize(texthandle);
+            }
+        }
+
+        if (texthandle) {
+            if (!precomp)
+                *filedatatype = cwFileTypeText;
+            else
+                *filedatatype = cwFileTypePrecompiledHeader;
+        } else {
+            *filedatatype = cwFileTypeUnknown;
+        }
+    }
+
+    return cwNoErr;
+}
+
+CWResult UCBReleaseFileText(CWPluginContext context, const char *text) {
+    short callbackResult = 0;
+    CWCompilerLinkerContext *cc = static_cast<CWCompilerLinkerContext *>(context);
+
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBReleaseFileText");
+
+    if (text) {
+        if (text != cc->sourcetext)
+            xfree((void *) text);
+    } else {
+        callbackResult = cwErrInvalidParameter;
+    }
+
+    return callbackResult;
+}
+
+CWResult UCBGetSegmentInfo(CWPluginContext context, SInt32 whichsegment, CWProjectSegmentInfo *segmentinfo) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetSegmentInfo");
+
+    if (gTarg->linkmodel != LinkModel1)
+        return cwErrInvalidCallback;
+
+    Segment *seg = Segments_GetSegment(&gTarg->linkage.segs, whichsegment);
+    if (!seg)
+        return cwErrUnknownSegment;
+
+    strcpy(segmentinfo->name, seg->name);
+    segmentinfo->attributes = seg->attrs;
+    return cwNoErr;
+}
+
+CWResult UCBGetOverlay1GroupInfo(CWPluginContext context, SInt32 whichgroup, CWOverlay1GroupInfo *groupinfo) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetOverlay1GroupInfo");
+
+    OvlGroup *grp = Overlays_GetOvlGroup(&gTarg->linkage.overlays, whichgroup);
+    if (gTarg->linkmodel != LinkModel2)
+        return cwErrInvalidCallback;
+
+    if (grp) {
+        strcpy(groupinfo->name, grp->name);
+        groupinfo->address.lo = grp->addr.lo;
+        groupinfo->address.hi = grp->addr.hi;
+        groupinfo->numoverlays = OvlGroup_CountOverlays(grp);
+        return cwNoErr;
+    } else {
+        return cwErrInvalidParameter;
+    }
+}
+
+CWResult UCBGetOverlay1FileInfo(CWPluginContext context, SInt32 whichgroup, SInt32 whichoverlay, SInt32 whichoverlayfile, CWOverlay1FileInfo *fileinfo) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetOverlay1FileInfo");
+
+    if (gTarg->linkmodel != LinkModel2)
+        return cwErrInvalidCallback;
+
+    SInt32 filenum = Overlays_GetFileInOverlay(&gTarg->linkage.overlays, whichgroup, whichoverlay, whichoverlayfile);
+    if (filenum >= 0) {
+        fileinfo->whichfile = filenum;
+        return cwNoErr;
+    } else {
+        return cwErrInvalidParameter;
+    }
+}
+
+CWResult UCBGetOverlay1Info(CWPluginContext context, SInt32 whichgroup, SInt32 whichoverlay, CWOverlay1Info *overlayinfo) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetOverlay1Info");
+
+    if (gTarg->linkmodel != LinkModel2)
+        return cwErrInvalidCallback;
+
+    Overlay *oly = Overlays_GetOverlayInGroup(&gTarg->linkage.overlays, whichgroup, whichoverlay);
+    if (oly) {
+        strcpy(overlayinfo->name, oly->name);
+        overlayinfo->numfiles = Overlay_CountFiles(oly);
+        return cwNoErr;
+    } else {
+        return cwErrInvalidParameter;
+    }
+}
+
+CWResult UCBReportMessage(CWPluginContext context, const CWMessageRef *msgRef, const char *line1, const char *line2, short errorlevel, SInt32 errorNumber) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBReportMessage");
+
+    short msgType;
+    int eeol;
+    const char *eeptr;
+    char *tptr;
+    MessageRef ref;
+    CWCompilerLinkerContext *clx;
+
+    static const char *fmts[2][2][2] = {
+            "%\n", "%",
+            "%\n", "%",
+            "%\n%\n", "%%\n",
+            "%\n%", "%%"
+    };
+
+    if (line1 == NULL) {
+        line1 = "";
+        eeol = 0;
+    } else {
+        eeptr = line1 + strlen(line1) - 1;
+        eeol = *eeptr == '\r' || *eeptr == '\n';
+    }
+
+    if (CheckForUserBreak())
+        return cwErrUserCanceled;
+
+    if (errorlevel == messagetypeError)
+        msgType = CLStyledMessageDispatch_Type3;
+    else if (errorlevel == messagetypeWarning)
+        msgType = CLStyledMessageDispatch_Type2;
+    else
+        msgType = CLStyledMessageDispatch_Type1;
+
+    clx = static_cast<CWCompilerLinkerContext *>(context);
+
+    if (!msgRef) {
+        if (line2 && line2[0]) {
+            eeptr = line2 + strlen(line2) - 1;
+            int eeol2 = *eeptr == '\r' || *eeptr == '\n';
+            CLStyledMessageDispatch(
+                    static_cast<shellContextType *>(clx->shellContext)->plugin,
+                    NULL,
+                    errorNumber,
+                    msgType,
+                    fmts[1][eeol2][eeol],
+                    line1,
+                    line2
+                    );
+        } else {
+            CLStyledMessageDispatch(
+                    static_cast<shellContextType *>(clx->shellContext)->plugin,
+                    NULL,
+                    errorNumber,
+                    msgType,
+                    fmts[0][0][eeol],
+                    line1
+            );
+        }
+    } else {
+        OS_FSSpec_To_OSSpec(&clx->sourcefile, &ref.sourcefile);
+        OS_FSSpec_To_OSSpec(&msgRef->sourcefile, &ref.errorfile);
+        ref.sourceline = const_cast<char *>(line2);
+        ref.linenumber = msgRef->linenumber;
+
+        ref.tokenoffset = msgRef->tokenoffset;
+        ref.tokenlength = msgRef->tokenlength;
+        ref.selectionoffset = msgRef->selectionoffset;
+        ref.selectionlength = msgRef->selectionlength;
+
+        if (ref.tokenoffset < 0)
+            ref.tokenoffset = 0;
+        if (ref.tokenlength < 0)
+            ref.tokenlength = 0;
+        if (ref.selectionoffset < 0)
+            ref.selectionoffset = 0;
+        if (ref.selectionlength < 0)
+            ref.selectionlength = 0;
+
+        CLStyledMessageDispatch(
+                static_cast<shellContextType *>(clx->shellContext)->plugin,
+                &ref,
+                errorNumber,
+                msgType,
+                fmts[0][0][eeol],
+                line1
+        );
+    }
+
+    return cwNoErr;
+}
+
+CWResult UCBAlert(CWPluginContext context, const char *msg1, const char *msg2, const char *msg3, const char *msg4) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBAlert");
+
+    if (CheckForUserBreak())
+        return cwErrUserCanceled;
+
+    if (msg4) {
+        CLStyledMessageDispatch(
+                static_cast<shellContextType *>(context->shellContext)->plugin,
+                NULL,
+                0,
+                CLStyledMessageDispatch_Type4,
+                "%\n%\n%\n%\n",
+                msg1 ? msg1 : "",
+                msg2 ? msg2 : "",
+                msg3 ? msg3 : "",
+                msg4
+                );
+    } else if (msg3) {
+        CLStyledMessageDispatch(
+                static_cast<shellContextType *>(context->shellContext)->plugin,
+                NULL,
+                0,
+                CLStyledMessageDispatch_Type4,
+                "%\n%\n%\n",
+                msg1 ? msg1 : "",
+                msg2 ? msg2 : "",
+                msg3
+        );
+    } else if (msg2) {
+        CLStyledMessageDispatch(
+                static_cast<shellContextType *>(context->shellContext)->plugin,
+                NULL,
+                0,
+                CLStyledMessageDispatch_Type4,
+                "%\n%\n",
+                msg1 ? msg1 : "",
+                msg2
+        );
+    } else {
+        CLStyledMessageDispatch(
+                static_cast<shellContextType *>(context->shellContext)->plugin,
+                NULL,
+                0,
+                CLStyledMessageDispatch_Type4,
+                "%\n",
+                msg1 ? msg1 : ""
+        );
+    }
+
+    return cwNoErr;
+}
+
+CWResult UCBShowStatus(CWPluginContext context, const char *line1, const char *line2) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBShowStatus");
+
+    if (CheckForUserBreak())
+        return cwErrUserCanceled;
+
+    if (optsCmdLine.verbose > 1) {
+        if ((!line1 || !*line1) && (!line2 || !*line2))
+            return cwNoErr;
+
+        if (line2 && *line2) {
+            CLStyledMessageDispatch(
+                    static_cast<shellContextType *>(context->shellContext)->plugin,
+                    NULL,
+                    0,
+                    CLStyledMessageDispatch_Type5,
+                    "%\n%\n",
+                    line1 ? line1 : "",
+                    line2 ? line2 : ""
+            );
+        } else {
+            CLStyledMessageDispatch(
+                    static_cast<shellContextType *>(context->shellContext)->plugin,
+                    NULL,
+                    0,
+                    CLStyledMessageDispatch_Type5,
+                    "%\n",
+                    line1 ? line1 : ""
+            );
+        }
+    }
+
+    return cwNoErr;
+}
+
+CWResult UCBUserBreak(CWPluginContext context) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBUserBreak");
+
+    ShowWorking(8);
+    if (CheckForUserBreak())
+        return cwErrUserCanceled;
+    else
+        return cwNoErr;
+}
+
+CWResult UCBGetNamedPreferences(CWPluginContext context, const char *prefsname, CWMemHandle *prefsdata) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetNamedPreferences");
+
+    PrefPanel *pnl = Prefs_FindPanel(prefsname);
+    if (pnl) {
+        if (optsCmdLine.verbose > 2)
+            CLReport(83, prefsname);
+        UCBSecretAttachHandle(context, PrefPanel_GetHandle(pnl), prefsdata);
+        return cwNoErr;
+    } else {
+        CLReportError(91, prefsname);
+        *prefsdata = NULL;
+        return cwErrRequestFailed;
+    }
+}
+
+CWResult UCBStorePluginData(CWPluginContext context, SInt32 whichfile, CWDataType type, CWMemHandle prefsdata) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBStorePluginData");
+
+#line 1267
+    DO_INTERNAL_ERROR("UCBStorePluginData not implemented");
+    return cwErrRequestFailed;
+}
+
+CWResult UCBGetPluginData(CWPluginContext context, SInt32 whichfile, CWDataType type, CWMemHandle *prefsdata) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetPluginData");
+
+#line 1286
+    DO_INTERNAL_ERROR("UCBGetPluginData not implemented");
+    return cwErrRequestFailed;
+}
+
+CWResult UCBSetModDate(CWPluginContext context, const CWFileSpec *filespec, CWFileTime *moddate, Boolean isGenerated) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBSetModDate");
+
+    OSSpec spec;
+    time_t mdtm;
+    int err;
+    SInt32 idx;
+    File *file;
+
+    OS_FSSpec_To_OSSpec(filespec, &spec);
+    if (!moddate || !*moddate)
+        OS_GetTime(&mdtm);
+    else
+        OS_MacToTime(*moddate, &mdtm);
+
+    for (idx = 0; idx < Files_Count(&gTarg->files); idx++) {
+        file = Files_GetFile(&gTarg->files, idx);
+        if (OS_EqualSpec(&file->srcfss, &spec))
+            file->srcmoddate = mdtm;
+        else if (OS_EqualSpec(&file->outfss, &spec))
+            file->outmoddate = mdtm;
+    }
+
+    err = OS_SetFileTime(&spec, NULL, &mdtm);
+    if (err == 0)
+        return cwNoErr;
+    else
+        return cwErrRequestFailed;
+}
+
+CWResult UCBAddProjectEntry(CWPluginContext context, const CWFileSpec *fileSpec, Boolean isGenerated, const CWNewProjectEntryInfo *entry, SInt32 *whichfile) {
+    // two registers are awkwardly swapped here...
+    File *file;
+    OSSpec fss;
+    UInt32 filetype;
+    Plugin *plugin;
+    char *extptr;
+    char ext[16];
+    UInt32 flags;
+    char filename[256];
+    const DropInFlags *df;
+    OvlGroup *ovg;
+    Overlay *oly;
+    SInt32 idx;
+
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBAddProjectEntry");
+
+    OS_FSSpec_To_OSSpec(fileSpec, &fss);
+    if (OS_IsDir(&fss))
+        return cwErrInvalidParameter;
+
+    OS_NameSpecToString(&fss.name, filename, sizeof(filename));
+    if (gTarg->linker && !(gTarg->linkerDropinFlags & (linkAllowDupFileNames | dropInExecutableTool))) {
+        if (Files_FindFile(&gTarg->files, &fss)) {
+            if (optsCmdLine.verbose > 1)
+                CLReportWarning(CLStr106, filename);
+            return cwNoErr;
+        }
+    }
+
+    extptr = filename + strlen(filename) - 1;
+    while (extptr > filename && *extptr != '.')
+        --extptr;
+    if (extptr <= filename)
+        extptr = ".";
+    strncpy(ext, extptr, sizeof(ext) - 1);
+    ext[sizeof(ext) - 1] = 0;
+
+    OS_SpecToStringRelative(&fss, NULL, filename, sizeof(filename));
+    if (optsCmdLine.verbose > 2)
+        CLReport(CLStr77, " to project", filename);
+
+    if (OS_GetMacFileType(&fss, &filetype))
+        filetype = CWFOURCHAR('T','E','X','T');
+
+    plugin = Plugins_GetPluginForFile(NULL, CWDROPINANYTYPE, targetCPUAny, targetOSAny, filetype, ext, Lang_Any);
+    if (plugin && gTarg->linker && !Plugin_CL_MatchesTarget(plugin, gTarg->cpu, gTarg->os, 0))
+        CLReportError(CLStr76, filename);
+
+    if (!plugin)
+        plugin = Plugins_CL_MatchTarget(NULL, gTarg->cpu, gTarg->os, clState.plugintype, clState.language);
+
+    if (plugin) {
+        if (!Plugin_CL_GetCompilerMapping(plugin, filetype, ext, &flags)) {
+            flags = 0;
+            if (!isGenerated && !optsCompiler.compileIgnored && optsCompiler.forcePrecompile != 1) {
+                CLReportWarning(
+                        CLStr73,
+                        "file", filename,
+                        (clState.plugintype == CWDROPINCOMPILERTYPE) ? "treating as source text" : "passing unknown file to linker"
+                );
+            }
+            if (isGenerated)
+                flags = kIgnored;
+        } else if (!isGenerated && (flags & kIgnored) && !optsCompiler.compileIgnored) {
+            if ((!optsCmdLine.stages || (optsCmdLine.stages & (CmdLineStageMask_Cg | CmdLineStageMask_Ds))) && (optsCompiler.forcePrecompile != 1))
+                CLReportWarning(CLStr28, filename);
+            else
+                flags &= ~kIgnored;
+        }
+
+        if (optsCompiler.compileIgnored && !isGenerated)
+            flags &= ~kIgnored;
+
+        if (clState.pluginDebug) {
+            CLPrint("Using plugin '%s' for '%s'\n", Plugin_GetDropInName(plugin), filename);
+            CLPrint(
+                    "[flags: %s, %s, %s, %s]\n",
+                    (flags & kPrecompile) ? "precompile" : "don't precompile",
+                    (flags & kLaunchable) ? "launchable" : "not launchable",
+                    (flags & kRsrcfile) ? "resource file" : "not resource file",
+                    (flags & kIgnored) ? "ignored" : "used"
+                    );
+        }
+    } else {
+        CLReportError(CLStr74, filename);
+        flags = kIgnored;
+    }
+
+    file = File_New();
+    if (!file)
+        return cwErrOutOfMemory;
+
+    Deps_Initialize(&file->deps, &gTarg->incls);
+
+    file->segnum = (entry->segment == -1) ? (Segments_Count(&gTarg->linkage.segs) - 1) : entry->segment;
+
+    strcpy(file->srcfilename, filename);
+    file->srcfss = fss;
+
+    OS_GetFileTime(&file->srcfss, NULL, &file->srcmoddate);
+    OS_GetTime(&file->outmoddate);
+
+    file->outfilename[0] = 0;
+    memset(&file->outfss, 0, sizeof(file->outfss));
+
+    file->outfileowner = 0;
+    file->tempOnDisk = 0;
+    file->wroteToDisk = 0;
+    file->writeToDisk = 0;
+
+    if (plugin && Plugin_GetPluginType(plugin) != CWDROPINCOMPILERTYPE)
+        file->compiler = NULL;
+    else
+        file->compiler = plugin;
+
+    file->filetype = filetype;
+    file->mappingflags = flags;
+
+    if (file->compiler) {
+        df = Plugin_GetDropInFlags(file->compiler);
+        file->dropinflags = df->dropinflags;
+    } else {
+        file->dropinflags = 0;
+    }
+
+    file->weakimport = entry->weakimport;
+    file->initbefore = entry->initbefore;
+    file->mergeintooutput = entry->mergeintooutput;
+    file->isresourcefile = (flags & kRsrcfile) != 0;
+
+    if (file->compiler)
+        file->objectflags = Plugin_CL_GetObjectFlags(file->compiler)->flags;
+    else
+        file->objectflags = 0;
+
+    file->sourceUsage = 0;
+    if (!(file->mappingflags & kIgnored)) {
+        if (file->compiler) {
+            file->sourceUsage |= CmdLineStageMask_Pp;
+            if (!(file->objectflags & 0x80000000))
+                file->sourceUsage |= CmdLineStageMask_Cg;
+        } else if (plugin) {
+            file->sourceUsage |= CmdLineStageMask_Cg;
+        }
+    }
+
+    if (file->isresourcefile)
+        file->sourceUsage |= CmdLineStageMask_Cg;
+
+    file->objectUsage = file->sourceUsage & CmdLineStageMask_Pp;
+    if ((file->sourceUsage & CmdLineStageMask_Pp) && !(file->mappingflags & kPrecompile) && (optsCompiler.forcePrecompile != 1) && (file->objectflags & 0x80000000))
+        file->objectUsage |= CmdLineStageMask_Cg;
+
+    *whichfile = 0;
+    if ((entry->position != -1) ? (Files_AddFile(&gTarg->files, file) == 0) : (Files_InsertFile(&gTarg->files, file, entry->position) == 0))
+        return cwErrRequestFailed;
+    *whichfile = file->filenum;
+    context->numFiles++;
+
+    if (gTarg->linkmodel == LinkModel2) {
+        ovg = Overlays_GetOvlGroup(
+                &gTarg->linkage.overlays,
+                (entry->overlayGroup == -1) ? (Overlays_CountGroups(&gTarg->linkage.overlays) - 1) : entry->overlayGroup);
+        if (ovg) {
+            oly = OvlGroup_GetOverlay(
+                    ovg,
+                    (entry->overlay == -1) ? (OvlGroup_CountOverlays(ovg) - 1) : entry->overlay);
+            if (oly) {
+                if (!Overlay_AddFile(oly, file->filenum, &idx))
+                    return cwErrRequestFailed;
+            } else {
+                return cwErrRequestFailed;
+            }
+        } else {
+            return cwErrRequestFailed;
+        }
+    }
+
+    return cwNoErr;
+}
+
+CWResult UCBCreateNewTextDocument(CWPluginContext context, const CWNewTextDocumentInfo *docinfo) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBCreateNewTextDocument");
+
+    if (context->pluginType == CWDROPINCOMPILERTYPE || context->pluginType == CWDROPINLINKERTYPE) {
+        if (!docinfo->documentname) {
+            CWCompilerLinkerContext *clcontext = static_cast<CWCompilerLinkerContext *>(context);
+            File *file = Files_GetFile(&gTarg->files, clcontext->whichfile);
+            if (!file)
+                return cwErrUnknownFile;
+
+            if (file->textdata) {
+                if (!ShowHandle(file->textdata, GetHandleSize(file->textdata), 1))
+                    return cwErrRequestFailed;
+                DisposeHandle(file->textdata);
+            }
+
+            UCBSecretDetachHandle(context, docinfo->text, &file->textdata);
+            OS_GetTime(&file->outmoddate);
+            return cwNoErr;
+        } else {
+            Handle texth;
+            UCBSecretDetachHandle(context, docinfo->text, &texth);
+            UInt32 size = GetHandleSize(texth);
+            if (strcmp(docinfo->documentname, ">stdout") || clState.stdout_base) {
+                FILE *stdfile;
+                if (!strcmp(docinfo->documentname, ">stdout")) {
+                    stdfile = clState.stdout_written ? fopen(clState.stdout_base, "at") : fopen(clState.stdout_base, "wt");
+                    clState.stdout_written = 1;
+                } else {
+                    stdfile = fopen(docinfo->documentname, "wt");
+                }
+
+                if (stdfile) {
+                    HLock(texth);
+                    fwrite(*texth, size, 1, stdfile);
+                    fclose(stdfile);
+                    HUnlock(texth);
+                    return cwNoErr;
+                }
+            }
+
+            if (!ShowHandle(texth, size, 0))
+                return cwErrRequestFailed;
+            else
+                return cwNoErr;
+        }
+    } else if (context->pluginType == CWDROPINPARSERTYPE) {
+        Str255 filename;
+        VFile *vf;
+        Handle texth;
+        FSSpec fss;
+        CWNewProjectEntryInfo entry;
+        SInt32 pos;
+
+        UCBSecretDetachHandle(context, docinfo->text, &texth);
+
+        if (docinfo->markDirty) {
+            if (!docinfo->documentname)
+                return cwErrInvalidParameter;
+
+            vf = VFile_New(docinfo->documentname, texth);
+            if (!vf)
+                return cwErrOutOfMemory;
+            if (!VFiles_Add(&gTarg->virtualFiles, vf))
+                return cwErrRequestFailed;
+
+            entry.overlay = -1;
+            entry.overlayGroup = -1;
+            entry.segment = -1;
+            entry.position = -1;
+            entry.groupPath = NULL;
+            entry.initbefore = 0;
+            entry.weakimport = 0;
+            entry.mergeintooutput = 0;
+            c2pstrcpy(filename, docinfo->documentname);
+            FSMakeFSSpec(0, 0, filename, &fss);
+            return UCBAddProjectEntry(context, &fss, 1, &entry, &pos);
+        } else {
+            if (ShowHandle(texth, GetHandleSize(texth), docinfo->documentname != NULL))
+                return cwNoErr;
+            else
+                return cwErrRequestFailed;
+        }
+    } else {
+#line 1755
+        DO_INTERNAL_ERROR("Cannot deal with unexpected document");
+        return cwErrInvalidCallback;
+    }
+}
+
+CWResult UCBAllocateMemory(CWPluginContext context, SInt32 size, Boolean isPermanent, void **ptr) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBAllocateMemory");
+
+    *ptr = xmalloc(NULL, size);
+    return (*ptr == NULL) ? cwErrRequestFailed : cwNoErr;
+}
+
+CWResult UCBFreeMemory(CWPluginContext context, void *ptr, Boolean isPermanent) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBFreeMemory");
+
+    if (ptr) {
+        xfree(ptr);
+        return cwNoErr;
+    } else {
+        return cwErrRequestFailed;
+    }
+}
+
+CWResult UCBAllocMemHandle(CWPluginContext context, SInt32 size, Boolean useTempMemory, CWMemHandle *memhandle) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBAllocMemHandle");
+
+    Handle handle = NewHandle(size);
+    if (!handle)
+        return cwErrOutOfMemory;
+
+    UCBSecretAttachHandle(context, handle, memhandle);
+    return cwNoErr;
+}
+
+CWResult UCBFreeMemHandle(CWPluginContext context, CWMemHandle memhandle) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBFreeMemHandle");
+
+    Handle handle;
+    UCBSecretDetachHandle(context, memhandle, &handle);
+    DisposeHandle(handle);
+    return cwNoErr;
+}
+
+CWResult UCBGetMemHandleSize(CWPluginContext context, CWMemHandle memhandle, SInt32 *size) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBGetMemHandleSize");
+
+    Handle handle;
+    UCBSecretDetachHandle(context, memhandle, &handle);
+    *size = GetHandleSize(handle);
+    return cwNoErr;
+}
+
+CWResult UCBResizeMemHandle(CWPluginContext context, CWMemHandle memhandle, SInt32 newSize) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBResizeMemHandle");
+
+    Handle handle;
+    UCBSecretDetachHandle(context, memhandle, &handle);
+    SetHandleSize(handle, newSize);
+    return (MemError() == noErr) ? cwNoErr : cwErrOutOfMemory;
+}
+
+CWResult UCBLockMemHandle(CWPluginContext context, CWMemHandle handle, Boolean moveHi, void **ptr) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBLockMemHandle");
+
+    HLock(reinterpret_cast<Handle>(handle));
+    *ptr = *reinterpret_cast<Handle>(handle);
+    return cwNoErr;
+}
+
+CWResult UCBUnlockMemHandle(CWPluginContext context, CWMemHandle handle) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBUnlockMemHandle");
+
+    HUnlock(reinterpret_cast<Handle>(handle));
+    return cwNoErr;
+}
+
+CWResult UCBGetTargetName(CWPluginContext context, char *name, short maxLength) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBGetTargetName");
+
+    strncpy(name, "command-line target", maxLength);
+    return cwNoErr;
+}
+
+CWResult UCBPreDialog(CWPluginContext context) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBPreDialog");
+
+    return cwNoErr;
+}
+
+CWResult UCBPostDialog(CWPluginContext context) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBPostDialog");
+
+    return cwNoErr;
+}
+
+CWResult UCBPreFileAction(CWPluginContext context, const CWFileSpec *theFile) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBPreFileAction");
+
+#line 1963
+    DO_INTERNAL_ERROR("UCBPreFileAction not implemented");
+    return cwErrRequestFailed;
+}
+
+CWResult UCBPostFileAction(CWPluginContext context, const CWFileSpec *theFile) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBPostFileAction");
+
+#line 1977
+    DO_INTERNAL_ERROR("UCBPostFileAction not implemented");
+    return cwErrRequestFailed;
+}
+
+CWResult UCBCacheAccessPathList(CWPluginContext context) {
+    IDEAccessPathList *apl;
+    shellContextType *sc;
+    int x;
+
+    sc = static_cast<shellContextType *>(context->shellContext);
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBCacheAccessPathList");
+
+    apl = context->accessPathList;
+    if (!apl)
+        apl = context->accessPathList = static_cast<IDEAccessPathList *>(calloc(sizeof(IDEAccessPathList), 1));
+
+    if (sc->userAccessPathsChanged || !apl->userPaths) {
+        OSSpec spec;
+        Path *path;
+        IDEAccessPath *ap;
+
+        apl->userPathCount = Paths_Count(&gTarg->userPaths);
+        apl->userPaths = static_cast<IDEAccessPath *>(xrealloc("access paths", apl->userPaths, sizeof(IDEAccessPath) * apl->userPathCount));
+
+        for (x = 0; x < apl->userPathCount; x++) {
+            ap = &apl->userPaths[x];
+            path = Paths_GetPath(&gTarg->userPaths, x);
+#line 2010
+            OPTION_ASSERT(path);
+
+            OS_MakeSpecWithPath(path->spec, NULL, 0, &spec);
+            OS_OSSpec_To_FSSpec(&spec, &ap->pathSpec);
+            ap->recursive = path->recursive != 0;
+            if (path->recursive) {
+                ap->subdirectoryCount = Paths_CountRecurse(path->recursive);
+                if (ap->subdirectories)
+                    xfree(ap->subdirectories);
+                ap->subdirectories = static_cast<FSSpec *>(xmalloc(NULL, sizeof(FSSpec) * ap->subdirectoryCount));
+                Paths_CopyRecurseFSS(ap->subdirectories, path->recursive, ap->subdirectoryCount);
+            } else {
+                ap->subdirectoryCount = 0;
+                ap->subdirectories = NULL;
+            }
+        }
+
+        sc->userAccessPathsChanged = 0;
+    }
+
+    if (sc->systemAccessPathsChanged || !apl->systemPaths) {
+        OSSpec spec;
+        Path *path;
+        IDEAccessPath *ap;
+
+        apl->systemPathCount = Paths_Count(&gTarg->sysPaths);
+        apl->systemPaths = static_cast<IDEAccessPath *>(xrealloc("access paths", apl->systemPaths, sizeof(IDEAccessPath) * apl->systemPathCount));
+
+        for (x = 0; x < apl->systemPathCount; x++) {
+            ap = &apl->systemPaths[x];
+            path = Paths_GetPath(&gTarg->sysPaths, x);
+#line 2044
+            OPTION_ASSERT(path);
+
+            OS_MakeSpecWithPath(path->spec, NULL, 0, &spec);
+            OS_OSSpec_To_FSSpec(&spec, &ap->pathSpec);
+            ap->recursive = path->recursive != 0;
+            if (path->recursive) {
+                ap->subdirectoryCount = Paths_CountRecurse(path->recursive);
+                if (ap->subdirectories)
+                    xfree(ap->subdirectories);
+                ap->subdirectories = static_cast<FSSpec *>(xmalloc(NULL, sizeof(FSSpec) * ap->subdirectoryCount));
+                Paths_CopyRecurseFSS(ap->subdirectories, path->recursive, ap->subdirectoryCount);
+            } else {
+                ap->subdirectoryCount = 0;
+                ap->subdirectories = NULL;
+            }
+        }
+
+        sc->systemAccessPathsChanged = 0;
+    }
+
+    return cwNoErr;
+}
+
+CWResult UCBSecretAttachHandle(CWPluginContext context, Handle handle, CWMemHandle *memHandle) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBSecretAttachHandle");
+
+    *memHandle = reinterpret_cast<CWMemHandle>(handle);
+    return cwNoErr;
+}
+
+CWResult UCBSecretDetachHandle(CWPluginContext context, CWMemHandle memHandle, Handle *handle) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBSecretDetachHandle");
+
+    if (!memHandle || !handle) {
+        *handle = NULL;
+        return cwErrInvalidParameter;
+    } else {
+        *handle = reinterpret_cast<Handle>(memHandle);
+        return cwNoErr;
+    }
+}
+
+CWResult UCBSecretPeekHandle(CWPluginContext context, CWMemHandle memHandle, Handle *handle) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBSecretPeekHandle");
+
+    if (!memHandle || !handle) {
+        *handle = NULL;
+        return cwErrInvalidParameter;
+    } else {
+        *handle = reinterpret_cast<Handle>(memHandle);
+        return cwNoErr;
+    }
+}
+
+CWResult UCBCheckoutLicense(CWPluginContext context, const char *a, const char *b, SInt32 c, void *d, SInt32 *cookiePtr) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBCheckoutLicense");
+
+    if (cookiePtr)
+        *cookiePtr = 0xD0A;
+
+    return cwErrInvalidCallback;
+}
+
+CWResult UCBCheckinLicense(CWPluginContext context, SInt32 cookie) {
+    if (optsCmdLine.verbose > 3)
+        CLPrint("Callback: %s\n", "UCBCheckinLicense");
+
+    return cwErrInvalidCallback;
+}
+
+CWResult UCBResolveRelativePath(CWPluginContext context, const CWRelativePath *relativePath, CWFileSpec *fileSpec, Boolean create) {
+#line 2255
+    DO_INTERNAL_ERROR("UCBResolveRelativePath not implemented");
+    return cwErrRequestFailed;
+}
+
+CWResult UCBMacOSErrToCWResult(CWPluginContext context, OSErr err) {
+    if (optsCmdLine.verbose > 4)
+        CLPrint("Callback: %s\n", "UCBMacOSErrToCWResult");
+
+    return OSErrtoCWResult(err);
+}
+
+CW_BasePluginCallbacks sBasePluginCallbacks = {
+        UCBGetFileInfo,
+        UCBFindAndLoadFile,
+        UCBGetFileText,
+        UCBReleaseFileText,
+        UCBGetSegmentInfo,
+        UCBGetOverlay1GroupInfo,
+        UCBGetOverlay1Info,
+        UCBGetOverlay1FileInfo,
+        UCBReportMessage,
+        UCBAlert,
+        UCBShowStatus,
+        UCBUserBreak,
+        UCBGetNamedPreferences,
+        UCBStorePluginData,
+        UCBGetPluginData,
+        UCBSetModDate,
+        UCBAddProjectEntry,
+        UCBCreateNewTextDocument,
+        UCBAllocateMemory,
+        UCBFreeMemory,
+        UCBAllocMemHandle,
+        UCBFreeMemHandle,
+        UCBGetMemHandleSize,
+        UCBResizeMemHandle,
+        UCBLockMemHandle,
+        UCBUnlockMemHandle,
+        reinterpret_cast<void *>(UCBSecretAttachHandle),
+        reinterpret_cast<void *>(UCBSecretDetachHandle),
+        reinterpret_cast<void *>(UCBSecretPeekHandle),
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        UCBGetTargetName,
+        UCBCacheAccessPathList,
+        UCBPreDialog,
+        UCBPostDialog,
+        UCBPreFileAction,
+        UCBPostFileAction,
+        UCBCheckoutLicense,
+        UCBCheckinLicense,
+        UCBResolveRelativePath
+};
+
+static CWIDEInfo sIDEInfo = {
+        3, 3, 0, 0, 10
+};
+
+CWPluginPrivateContext::CWPluginPrivateContext(SInt32 thePluginType, SInt32 totalSize) {
+    if (totalSize <= 0)
+        totalSize = sizeof(CWPluginPrivateContext);
+    memset(this, 0, totalSize);
+
+    shellSignature = CWFOURCHAR('C','W','I','E');
+    pluginType = thePluginType;
+    shellInfo = &sIDEInfo;
+    callbacks = &sBasePluginCallbacks;
+}
+
+CWPluginPrivateContext::~CWPluginPrivateContext() {
+    int x;
+
+    if (accessPathList) {
+        if (accessPathList->userPathCount) {
+            for (x = 0; x < accessPathList->userPathCount; x++) {
+                if (accessPathList->userPaths[x].subdirectories)
+                    xfree(accessPathList->userPaths[x].subdirectories);
+            }
+        }
+        if (accessPathList->systemPathCount) {
+            for (x = 0; x < accessPathList->systemPathCount; x++) {
+                if (accessPathList->systemPaths[x].subdirectories)
+                    xfree(accessPathList->systemPaths[x].subdirectories);
+            }
+        }
+        xfree(accessPathList->userPaths);
+        xfree(accessPathList->systemPaths);
+        xfree(accessPathList);
+        accessPathList = NULL;
+    }
+}
diff --git a/command_line/CmdLine/Src/Callbacks/CLParserCallbacks_v1.cpp b/command_line/CmdLine/Src/Callbacks/CLParserCallbacks_v1.cpp
index 5dbd4d8..19b7dab 100644
--- a/command_line/CmdLine/Src/Callbacks/CLParserCallbacks_v1.cpp
+++ b/command_line/CmdLine/Src/Callbacks/CLParserCallbacks_v1.cpp
@@ -1,13 +1,220 @@
-/*
- P    9C50 | _UCBParserAddAccessPath
- P    9DE4 | _UCBParserSwapAccessPaths
- P    9E90 | _UCBParserSetNamedPreferences
- P    9F50 | _UCBParserSetFileOutputName
- P    A03C | _UCBParserSetOutputFileDirectory
- P    A110 | _UCBParserAddOverlay1Group
- P    A1EC | _UCBParserAddOverlay1
- P    A2D0 | _UCBParserAddSegment
- P    A364 | _UCBParserSetSegment
- P    A400 | ___ct__15CWParserContextFv
- P    A480 | ___dt__15CWParserContextFv
- */
\ No newline at end of file
+#include "cmdline.h"
+#include "plugin_internal.h"
+
+extern char STSbuf[256];
+
+CWResult UCBParserAddAccessPath(CWPluginContext context, const CWNewAccessPathInfo *api) {
+    OSSpec oss;
+    Paths *paths;
+    Path *path;
+    int err;
+
+    if ((err = OS_FSSpec_To_OSSpec(&api->pathSpec, &oss))) {
+        context->callbackOSError = OS_MacError(err);
+        return cwErrInvalidParameter;
+    }
+
+    if (optsCmdLine.verbose > 2)
+        CLReport(CLStr77, " search path", OS_PathSpecToString(&oss.path, STSbuf, sizeof(STSbuf)));
+
+    if ((api->type & cwAccessPathTypeFlag1) == 0)
+        paths = &gTarg->sysPaths;
+    else
+        paths = &gTarg->userPaths;
+    path = Path_New(&oss.path);
+
+    path->flags = api->type & cwAccessPathTypeFlag2;
+    if ((api->position >= 0) ? (Paths_InsertPath(paths, api->position, path) == 0) : (Paths_AddPath(paths, path) == 0))
+        return cwErrRequestFailed;
+
+    if (api->recursive) {
+        Paths_GatherRecurse(path);
+        if (CheckForUserBreak())
+            return cwErrUserCanceled;
+    }
+
+    if (!(api->type & cwAccessPathTypeFlag1))
+        static_cast<shellContextType *>(context->shellContext)->systemAccessPathsChanged = 1;
+    else
+        static_cast<shellContextType *>(context->shellContext)->userAccessPathsChanged = 1;
+
+    return cwNoErr;
+}
+
+CWResult UCBParserSwapAccessPaths(CWPluginContext context) {
+    Path *tmp;
+    UInt16 idx;
+
+    for (idx = 0; idx < Paths_Count(&gTarg->sysPaths); idx++) {
+        tmp = Paths_GetPath(&gTarg->sysPaths, idx);
+        if (!(tmp->flags & cwAccessPathTypeFlag2)) {
+            Paths_AddPath(&gTarg->userPaths, tmp);
+            Paths_RemovePath(&gTarg->sysPaths, idx);
+            idx--;
+        }
+    }
+
+    return cwNoErr;
+}
+
+int (*PrefPanelsChangedCallback)(const char *);
+
+CWResult UCBParserSetNamedPreferences(CWPluginContext context, const char *panelName, Handle paneldata) {
+    PrefPanel *panel;
+
+    panel = Prefs_FindPanel(panelName);
+    if (!panel) {
+        panel = PrefPanel_New(panelName, *paneldata, GetHandleSize(paneldata));
+        if (!panel || !Prefs_AddPanel(panel))
+            return cwErrRequestFailed;
+    } else {
+        if (!PrefPanel_PutHandle(panel, paneldata))
+            return cwErrRequestFailed;
+    }
+
+    if (PrefPanelsChangedCallback)
+        PrefPanelsChangedCallback(panelName);
+
+    return cwNoErr;
+}
+
+CWResult UCBParserSetFileOutputName(CWPluginContext context, SInt32 position, short which, const char *outfilename) {
+    if (position < 0)
+        return cwErrInvalidParameter;
+
+    File *file = Files_GetFile(&gTarg->files, position);
+    if (!file)
+        return cwErrUnknownFile;
+
+    if (file->outfileowner)
+        CLReportError(CLStr103, file->srcfilename, file->outfilename);
+
+    strcpy(file->outfilename, outfilename);
+    if (which == 1)
+        file->outfileowner = CmdLineStageMask_Cg;
+    else if (which == 2)
+        file->outfileowner = CmdLineStageMask_Pp;
+    else if (which == 3)
+        file->outfileowner = CmdLineStageMask_Ds;
+    else
+        return cwErrInvalidParameter;
+
+    return cwNoErr;
+}
+
+CWResult UCBParserSetOutputFileDirectory(CWPluginContext context, const CWFileSpec *idefss) {
+    OSSpec fss;
+    int err;
+
+    if ((err = OS_FSSpec_To_OSSpec(idefss, &fss))) {
+        context->callbackOSError = OS_MacError(err);
+        return cwErrInvalidParameter;
+    }
+
+    gTarg->outputDirectory = fss.path;
+    context->outputFileDirectory = *idefss;
+
+    return cwNoErr;
+}
+
+CWResult UCBParserAddOverlay1Group(CWPluginContext context, const char *name, const CWAddr64 *addr, SInt32 *newGroupNumber) {
+    if (gTarg->linkmodel != LinkModel2)
+        return cwErrInvalidCallback;
+
+    OvlGroup *grp;
+    OvlAddr oaddr;
+    oaddr.hi = addr->hi;
+    oaddr.lo = addr->lo;
+
+    grp = OvlGroup_New(name, oaddr);
+    if (!grp)
+        return cwErrRequestFailed;
+    if (!Overlays_AddOvlGroup(&gTarg->linkage.overlays, grp, newGroupNumber))
+        return cwErrRequestFailed;
+
+    ++context->numOverlayGroups;
+    if (optsCmdLine.verbose > 2)
+        CLReport(CLStr79, name, oaddr.hi, oaddr.lo);
+
+    return cwNoErr;
+}
+
+CWResult UCBParserAddOverlay1(CWPluginContext context, const char *name, SInt32 groupNumber, SInt32 *newOverlayNumber) {
+    if (gTarg->linkmodel != LinkModel2)
+        return cwErrInvalidCallback;
+
+    OvlGroup *grp;
+    Overlay *ovl;
+
+    grp = Overlays_GetOvlGroup(&gTarg->linkage.overlays, groupNumber);
+    if (!grp)
+        return cwErrRequestFailed;
+    ovl = Overlay_New(name);
+    if (!ovl)
+        return cwErrOutOfMemory;
+    if (!OvlGroup_AddOverlay(grp, ovl, newOverlayNumber))
+        return cwErrOutOfMemory;
+
+    if (optsCmdLine.verbose > 2)
+        CLReport(CLStr78, name, grp->name);
+
+    return cwNoErr;
+}
+
+CWResult UCBParserAddSegment(CWPluginContext context, const char *name, short attrs, SInt32 *newSegmentNumber) {
+    if (gTarg->linkmodel != LinkModel1)
+        return cwErrInvalidCallback;
+
+    Segment *seg;
+    UInt16 index;
+
+    seg = Segment_New(name, attrs);
+    if (!Segments_AddSegment(&gTarg->linkage.segs, seg, &index))
+        return cwErrRequestFailed;
+
+    *newSegmentNumber = index;
+    return cwNoErr;
+}
+
+CWResult UCBParserSetSegment(CWPluginContext context, SInt32 segmentNumber, const char *name, short attrs) {
+    if (gTarg->linkmodel != LinkModel1)
+        return cwErrInvalidCallback;
+
+    Segment *seg = Segments_GetSegment(&gTarg->linkage.segs, segmentNumber);
+    if (!seg)
+        return cwErrUnknownSegment;
+
+    strncpy(seg->name, name, sizeof(seg->name));
+    seg->name[sizeof(seg->name) - 1] = 0;
+    seg->attrs = attrs;
+
+    return cwNoErr;
+}
+
+static CWParserCallbacks parser_cb = {
+        UCBParserAddAccessPath,
+        UCBParserSwapAccessPaths,
+        UCBParserSetNamedPreferences,
+        UCBParserSetFileOutputName,
+        UCBParserSetOutputFileDirectory,
+        UCBParserAddOverlay1Group,
+        UCBParserAddOverlay1,
+        UCBParserAddSegment,
+        UCBParserSetSegment
+};
+
+CWParserContext::CWParserContext() : CWPluginPrivateContext(CWDROPINPARSERTYPE, -1) {
+    args = NULL;
+    os = 0;
+    cpu = 0;
+    numPlugins = 0;
+    plugins = NULL;
+    numPanels = 0;
+    panelNames = NULL;
+    panel_args = NULL;
+    plugin_args = NULL;
+    callbacks = &parser_cb;
+}
+
+CWParserContext::~CWParserContext() {
+}
diff --git a/command_line/CmdLine/Src/Clients/CLStaticMain.c b/command_line/CmdLine/Src/Clients/CLStaticMain.c
index cecab30..871dcef 100644
--- a/command_line/CmdLine/Src/Clients/CLStaticMain.c
+++ b/command_line/CmdLine/Src/Clients/CLStaticMain.c
@@ -1,6 +1,21 @@
-#include "mwcc_decomp.h"
+#include "cmdline.h"
 
-int main(int argc, const char **argv) {
+extern const char *CMDLINE_BUILD_TIME;
+extern const char *CMDLINE_BUILD_DATE;
+
+// Glue functions
+extern int RegisterStaticParserPlugins();
+extern int RegisterStaticParserResources();
+
+extern void GetStaticTarget(OSType *cpu, OSType *os);
+extern void GetStaticPluginType(OSType *language, OSType *plugintype);
+extern void GetStaticParserPluginType(OSType *style);
+extern int RegisterStaticTargetResources();
+extern int RegisterStaticTargetPlugins();
+
+extern int RegisterStaticParserToolInfo();
+
+int main(int argc, char **argv) {
     OSType cpu;
     OSType os;
     OSType lang;
diff --git a/command_line/CmdLine/Src/Clients/ClientGlue.c b/command_line/CmdLine/Src/Clients/ClientGlue.c
index a1b40b1..6bc0508 100644
--- a/command_line/CmdLine/Src/Clients/ClientGlue.c
+++ b/command_line/CmdLine/Src/Clients/ClientGlue.c
@@ -1,4 +1,4 @@
-#include "mwcc_decomp.h"
+#include "cmdline.h"
 
 int RegisterResource(const char *name, SInt16 rsrcid, const char **list) {
     Handle h;
@@ -42,7 +42,7 @@ void SetPluginType(OSType lang, OSType type) {
     clState.plugintype = type;
 }
 
-int CmdLine_Initialize(int argc, const char **argv, const char *builddate, const char *buildtime) {
+int CmdLine_Initialize(int argc, char **argv, const char *builddate, const char *buildtime) {
     strncpy(cmdline_build_date, builddate, sizeof(cmdline_build_date));
     strncpy(cmdline_build_time, buildtime, sizeof(cmdline_build_time));
     return Main_Initialize(argc, argv);
diff --git a/command_line/CmdLine/Src/Envir/CLErrors.c b/command_line/CmdLine/Src/Envir/CLErrors.c
index 76ff06f..591e30d 100644
--- a/command_line/CmdLine/Src/Envir/CLErrors.c
+++ b/command_line/CmdLine/Src/Envir/CLErrors.c
@@ -1,37 +1,114 @@
-#include "mwcc_decomp.h"
-
-static void CLGetErrorString(SInt16 errid, char *buffer) {
+#include "cmdline.h"
 
+static char *CLGetErrorString(SInt16 errid, char *buffer) {
+    getindstring(buffer, 12000, errid);
+    strcat(buffer, "\n");
+    return buffer;
 }
 
 static void CLMessageReporter(int flags, SInt16 errid, va_list va) {
-
+    static char stmsg[256];
+    static char stbuf[256];
+    char *ptr;
+
+    CLGetErrorString(errid, stmsg);
+    ptr = mvprintf(stbuf, sizeof(stbuf), stmsg, va);
+
+    CLStyledMessageDispatch(
+            NULL,
+            NULL,
+            0,
+            (flags == messagetypeError) ? CLStyledMessageDispatch_Type3 : (flags == messagetypeWarning) ? CLStyledMessageDispatch_Type2 : CLStyledMessageDispatch_Type5,
+            "%",
+            ptr);
+
+    if (ptr != stbuf)
+        free(ptr);
 }
 
 void CLReportError(SInt16 errid, ...) {
-
+    va_list va;
+    va_start(va, errid);
+    CLMessageReporter(messagetypeError, errid, va);
+    va_end(va);
 }
 
 void CLReportWarning(SInt16 errid, ...) {
-
+    va_list va;
+    va_start(va, errid);
+    CLMessageReporter(messagetypeWarning, errid, va);
+    va_end(va);
 }
 
 void CLReport(SInt16 errid, ...) {
-
+    va_list va;
+    va_start(va, errid);
+    CLMessageReporter(messagetypeInfo, errid, va);
+    va_end(va);
 }
 
 void CLReportOSError(SInt16 errid, int err, ...) {
+    char *txt;
+    const char *oserr;
+    char mybuf[256];
+    char myerr[256];
+    va_list va;
+
+    va_start(va, err);
+    txt = mvprintf(mybuf, sizeof(mybuf), CLGetErrorString(errid, myerr), va);
+    va_end(va);
 
+    oserr = OS_GetErrText(err);
+    CLReportError(99, txt, oserr, err);
+
+    if (txt != mybuf)
+        free(txt);
 }
 
 void CLReportCError(SInt16 errid, int err_no, ...) {
+    char *txt;
+    const char *serr;
+    char mybuf[256];
+    char myerr[256];
+    va_list va;
+
+    va_start(va, err_no);
+    txt = mvprintf(mybuf, sizeof(mybuf), CLGetErrorString(errid, myerr), va);
+    va_end(va);
+
+    serr = strerror(err_no);
+    CLReportError(100, txt, serr, err_no);
 
+    if (txt != mybuf)
+        free(txt);
 }
 
 void CLInternalError(const char *file, int line, const char *format, ...) {
+    char mybuf[256];
+    char *txt;
+    va_list va;
 
+    va_start(va, format);
+    txt = mvprintf(mybuf, sizeof(mybuf), format, va);
+    va_end(va);
+    CLPrintErr("INTERNAL ERROR [%s:%d]:\n%s\n", file, line, txt);
+
+    if (txt != mybuf)
+        free(txt);
 }
 
 void CLFatalError(const char *format, ...) {
+    char mybuf[256];
+    char *txt;
+    va_list va;
+
+    va_start(va, format);
+    txt = mvprintf(mybuf, sizeof(mybuf), format, va);
+    va_end(va);
+    CLPrintErr("FATAL ERROR:\n%s\n", txt);
+
+    if (txt != mybuf)
+        free(txt);
 
+    exit(-123);
 }
diff --git a/command_line/CmdLine/Src/Envir/CLIO.c b/command_line/CmdLine/Src/Envir/CLIO.c
index e832de5..70ba9ae 100644
--- a/command_line/CmdLine/Src/Envir/CLIO.c
+++ b/command_line/CmdLine/Src/Envir/CLIO.c
@@ -1,79 +1,251 @@
-#include "mwcc_decomp.h"
+#include "cmdline.h"
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <util.h>
+
+extern char STSbuf[256];
+
+static int ioLineNum;
+static Boolean printedAnything;
+static char arrowBuf[256];
+static Boolean newErr;
+static Boolean newSrc;
+static Boolean srcIsErr;
+static OSSpec errSpec;
+static OSSpec srcSpec;
+static Boolean validErr;
+static Boolean validSrc;
+static SInt32 lastPrintingPlugin;
+static Boolean ioInHelp;
+static Boolean ioPiping;
 
 static void catchinterrupt() {
-
+    clState.userBreak = 1;
 }
 
 static void SetupConsoleInfo() {
-
+    struct winsize ws;
+    struct stat st;
+
+    signal(SIGINT, catchinterrupt);
+    ioPiping = 0;
+
+    fstat(stdout->_file, &st);
+    if (st.st_mode & 0x1000)
+        ioPiping = 1;
+    fstat(stderr->_file, &st);
+    if (st.st_mode & 0x1000)
+        ioPiping = 1;
+
+    if (ioPiping) {
+        ws.ws_row = 0;
+        ws.ws_col = 80;
+    } else if (ioctl(stdout->_file, TIOCGWINSZ, &ws) < 0) {
+        ioPiping = 1;
+        ws.ws_row = 0;
+        ws.ws_col = 80;
+    }
+
+    optsEnvir.rows = ws.ws_row;
+    optsEnvir.cols = ws.ws_col;
+    if (optsEnvir.cols > 256)
+        optsEnvir.cols = 256;
 }
 
 static void Crash() {
-
+    *((unsigned char *) NULL) = 0;
 }
 
 void SetupDebuggingTraps() {
-
+    signal(SIGABRT, Crash);
 }
 
 Boolean IO_Initialize() {
+    ioPiping = 0;
+    ioInHelp = 0;
+    ioLineNum = 0;
+    SetupConsoleInfo();
 
+    if (ioPiping) {
+        setvbuf(stdout, NULL, 0, 1024);
+        setvbuf(stderr, NULL, 0, 1024);
+    } else {
+        setvbuf(stdout, NULL, 1, 1024);
+        setvbuf(stderr, NULL, 1, 1024);
+    }
+
+    InitWorking();
+    return 1;
 }
 
 Boolean IO_Terminate() {
-
+    if (ioInHelp)
+        IO_HelpTerminate();
+    TermWorking();
+    return 1;
 }
 
 Boolean IO_HelpInitialize() {
-
+    ioInHelp = 1;
+    return 1;
 }
 
 Boolean IO_HelpTerminate() {
+    ioInHelp = 0;
+    return 1;
+}
+
+static Boolean SendHandleToFile(FILE *file, Handle text, SInt32 size) {
+    Boolean ret;
+    char *ptr;
+    char *lineEnd;
+    char *end;
 
-}
+    if (file != stdout && file != stderr)
+        setvbuf(file, NULL, 0, 1024);
 
-static Boolean SendHandleToFile(FILE *file, OSHandle *text) {
+    HLock(text);
+    ptr = *text;
+    if (size && ptr[size - 1] == 0)
+        size--;
 
+    if (size <= 0) {
+        ret = 1;
+    } else {
+        end = ptr + size;
+        while (ptr < end) {
+            lineEnd = ptr;
+            while (lineEnd < end && *lineEnd != '\n' && *lineEnd != '\r')
+                lineEnd++;
+
+            if (lineEnd - ptr) {
+                if (fwrite(ptr, lineEnd - ptr, 1, file) != 1) {
+                    CLReportCError(10, errno);
+                    ret = 0;
+                    goto fail;
+                }
+            }
+
+            if (CheckForUserBreak()) {
+                ret = 1;
+                goto fail;
+            }
+
+            // I have a hunch that this "\n" might be a define
+            if (fwrite("\n", strlen("\n"), 1, file) != 1) {
+                CLReportCError(10, errno);
+                ret = 0;
+                goto fail;
+            }
+
+            if (lineEnd < end && *(lineEnd++) == '\r' && *lineEnd == '\n')
+                ++lineEnd;
+            ptr = lineEnd;
+        }
+        ret = 1;
+    }
+
+fail:
+    HUnlock(text);
+    fflush(file);
+
+    if (file != stdout && file != stderr)
+        setvbuf(file, NULL, 2, 1024);
+
+    return ret;
 }
 
-void FixHandleForIDE(OSHandle *text) {
+void FixHandleForIDE(Handle text, UInt32 size) {
+    char *ptr;
 
+    HLock(text);
+    for (ptr = *text; ptr < (*text + size); ptr++) {
+        if (*ptr == '\r')
+            *ptr = '\n';
+    }
+    HUnlock(text);
 }
 
-Boolean ShowHandle(OSHandle *text, Boolean decorate) {
+Boolean ShowHandle(Handle text, UInt32 size, Boolean decorate) {
+    static const char *border = "===============\n";
+
+    if (decorate)
+        fprintf(stdout, border);
+    if (!SendHandleToFile(stdout, text, size))
+        return 0;
+    if (decorate)
+        fprintf(stdout, border);
+    fflush(stdout);
 
+    return 1;
 }
 
-Boolean WriteHandleToFile(OSSpec *spec, OSHandle *text, CWDataType creator, CWDataType type) {
+Boolean WriteHandleToFile(OSSpec *spec, Handle text, UInt32 size, OSType creator, OSType type) {
+    FILE *file;
+    char path[256];
 
+    OS_SpecToString(spec, path, sizeof(path));
+    file = fopen(path, "w+b");
+    if (!file) {
+        CLReportCError(8, errno, path);
+        return 0;
+    }
+
+    SendHandleToFile(file, text, size);
+    fclose(file);
+
+    OS_SetMacFileCreatorAndType(spec, creator, type);
+    return 1;
 }
 
 Boolean WriteBinaryHandleToFile(OSSpec *spec, CWDataType maccreator, CWDataType mactype, OSHandle *text) {
+    int err;
+    OSFileHandle file;
 
+    if ((err = OS_NewFileHandle(spec, text, 1, &file)) || (err = OS_FreeFileHandle(&file)) || (err = OS_SetMacFileCreatorAndType(spec, maccreator, mactype))) {
+        CLReportOSError(8, err, OS_SpecToString(spec, STSbuf, sizeof(STSbuf)));
+        return 0;
+    }
+
+    return 1;
 }
 
-Boolean AppendHandleToFile(OSSpec *spec, OSHandle *text, CWDataType maccreator, CWDataType mactype) {
+Boolean AppendHandleToFile(OSSpec *spec, Handle text, UInt32 size, CWDataType maccreator, CWDataType mactype) {
+    FILE *file;
+    char path[256];
 
-}
+    OS_SpecToString(spec, path, sizeof(path));
+    file = fopen(path, "a+b");
+    if (!file) {
+        CLReportCError(8, errno, path);
+        return 0;
+    }
 
-void InitWorking() {
+    SendHandleToFile(file, text, size);
+    fclose(file);
 
+    OS_SetMacFileCreatorAndType(spec, maccreator, mactype);
+    return 1;
 }
 
-void ShowWorking() {
+void InitWorking() {
+}
 
+void ShowWorking(int x) {
 }
 
 void TermWorking() {
-
 }
 
 static void ProgressFunction(const char *functionname) {
-
+    if (optsCmdLine.verbose)
+        CLReport(7, functionname);
 }
 
 Boolean CheckForUserBreak() {
-
+    ShowWorking(4);
+    return clState.userBreak;
 }
 
 typedef struct {
@@ -81,90 +253,650 @@ typedef struct {
     int pos;
     int maxlen;
     SInt16 col;
-    Boolean origina;
+    Boolean original;
     char *newline;
 } UnkCLIOStruct;
 
+// unknown names for these inlines
+inline void appendText(UnkCLIOStruct *f, const char *str) {
+    int len = strlen(str);
+
+    if (f->pos + len >= f->maxlen) {
+        f->maxlen = f->maxlen * 2 + len;
+        if (f->original) {
+            char *oldbuf;
+            oldbuf = f->buffer;
+            f->buffer = xmalloc("message buffer", f->maxlen);
+            memcpy(f->buffer, oldbuf, f->pos);
+        } else {
+            f->buffer = xrealloc("message buffer", f->original ? NULL : f->buffer, f->maxlen);
+        }
+        f->original = 0;
+    }
+
+    memcpy(f->buffer + f->pos, str, len);
+    f->pos += len;
+    f->col += len;
+}
+inline void appendChar(UnkCLIOStruct *f, char c) {
+    if (f->pos >= f->maxlen) {
+        f->maxlen *= 2;
+        if (f->original) {
+            char *oldbuf = f->buffer;
+            f->buffer = xmalloc("message buffer", f->maxlen);
+            memcpy(f->buffer, oldbuf, f->pos);
+        } else {
+            f->buffer = xrealloc("message buffer", f->buffer, f->maxlen);
+        }
+        f->original = 0;
+    }
+
+    f->buffer[f->pos++] = c;
+    f->col++;
+}
+
 static void StartLine(UnkCLIOStruct *f) {
+    f->col = 0;
+    if (!optsEnvir.underIDE && f->newline)
+        appendText(f, f->newline);
+}
 
+inline void newLine(UnkCLIOStruct *f) {
+    if (f->newline)
+        appendChar(f, '\n');
+    else
+        appendChar(f, ' ');
+    StartLine(f);
 }
 
 static void WrapText(UnkCLIOStruct *f) {
-
+    int wrapped;
+    char wrapbuf[256];
+    char c;
+
+    wrapped = 0;
+    if (optsCmdLine.noWrapOutput)
+        return;
+    if (!f->newline)
+        return;
+    if (strlen(f->newline) > optsEnvir.cols / 2)
+        return;
+
+    while (wrapped < (optsEnvir.cols - 1) && f->col > strlen(f->newline)) {
+        c = f->buffer[f->pos - 1];
+        if (c == ' ') break;
+        if (c == '/') break;
+        if (c == '-') break;
+        wrapbuf[wrapped] = c;
+        f->pos = f->pos - 1;
+        f->col = f->col - 1;
+        wrapped++;
+    }
+
+    if (f->col <= strlen(f->newline)) {
+        while (f->col < (optsEnvir.cols - 1) && wrapped > 0) {
+            appendChar(f, wrapbuf[--wrapped]);
+        }
+    }
+
+    newLine(f);
+    while (wrapped > 0 && f->maxlen > 0) {
+        appendChar(f, wrapbuf[--wrapped]);
+    }
 }
 
 static char *IO_VFormatText(char *buffer, SInt32 size, char *newline, const char *format, va_list ap) {
-
+    UnkCLIOStruct f;
+    char *arg;
+
+    f.buffer = buffer;
+    f.pos = 0;
+    f.maxlen = size;
+    f.col = 0;
+    f.original = 1;
+    f.newline = newline;
+    StartLine(&f);
+
+    while (*format && f.maxlen > 0) {
+        if (*format == '%') {
+            arg = va_arg(ap, char *);
+            while (*arg && f.maxlen > 0) {
+                if (*arg == '\r' || *arg == '\n') {
+                    newLine(&f);
+                    arg++;
+                } else if (*arg == '\t') {
+                    if (f.maxlen > 0) {
+                        do {
+                            appendChar(&f, ' ');
+                        } while (f.col & 7);
+                    }
+                    arg++;
+                } else {
+                    appendChar(&f, *(arg++));
+                    if (!optsCmdLine.noWrapOutput && f.newline && f.col >= optsEnvir.cols - 1)
+                        WrapText(&f);
+                }
+            }
+            format++;
+        } else if (*format == '\r' || *format == '\n') {
+            format++;
+            newLine(&f);
+        } else {
+            appendChar(&f, *(format++));
+            if (!optsCmdLine.noWrapOutput && f.col >= optsEnvir.cols - 1)
+                WrapText(&f);
+        }
+    }
+
+    if (f.newline) {
+        if (f.col == strlen(f.newline)) {
+            f.pos -= f.col;
+            f.col = 0;
+        }
+    }
+
+    appendChar(&f, 0);
+
+    return f.buffer;
 }
 
 char *IO_FormatText(char *buffer, SInt32 size, char *newline, const char *format, ...) {
-
-}
-
-void CLPrintDispatch(SInt16 msgtype, const char *message, FILE *out, char *ptr, char *nptr) {
-
+    va_list ap;
+    char *ret;
+
+    va_start(ap, format);
+    ret = IO_VFormatText(buffer, size, newline, format, ap);
+    va_end(ap);
+
+    return ret;
+}
+
+// TODO unify me with the one in the header
+enum {
+    Msg_Note = 1,
+    Msg_Warning = 2,
+    Msg_Error = 3,
+    Msg_Alert = 4,
+    Msg_Status = 5
+};
+void CLPrintDispatch(int unk, SInt16 msgtype, const char *message) {
+    FILE *out;
+    const char *ptr;
+    const char *nptr;
+
+    if (optsCmdLine.stderr2stdout == 1 || msgtype == Msg_Note || msgtype == Msg_Status) {
+        out = stdout;
+    } else if (msgtype == Msg_Warning || msgtype == Msg_Error || msgtype == Msg_Alert) {
+        out = stderr;
+    } else {
+#line 847
+        OPTION_ASSERT(0);
+    }
+
+    if (!printedAnything && !ioPiping) {
+        printedAnything = 1;
+        ioLineNum = 0;
+    }
+
+    ptr = message;
+    while (*ptr) {
+        nptr = ptr;
+        while (*nptr && *nptr != '\n' && *nptr != '\r')
+            ++nptr;
+
+        if (nptr - ptr) {
+            if (fwrite(ptr, nptr - ptr, 1, out) != 1)
+                clState.userBreak = 1;
+        }
+
+        if (*nptr) {
+            ioLineNum++;
+            fwrite("\n", strlen("\n"), 1, out);
+            if (*nptr == '\r')
+                nptr++;
+            if (*nptr == '\n')
+                nptr++;
+            if (nptr[0] && !nptr[1] && (nptr[0] == '\n' || nptr[0] == '\r'))
+                nptr++;
+        }
+
+        ptr = nptr;
+    }
+
+    if (out == stdout && optsCmdLine.verbose > 1)
+        fflush(out);
 }
 
 static void GetFileInfo(MessageRef *ref) {
-
+    if (ref) {
+        srcIsErr = OS_EqualSpec(&ref->sourcefile, &ref->errorfile);
+        if (!validSrc || !OS_EqualSpec(&ref->sourcefile, &srcSpec)) {
+            newSrc = 1;
+            srcSpec = ref->sourcefile;
+            validSrc = 1;
+        } else {
+            newSrc = 0;
+        }
+        if (!validErr || !OS_EqualSpec(&ref->errorfile, &errSpec)) {
+            newErr = 1;
+            errSpec = ref->errorfile;
+            validErr = 1;
+        } else {
+            newErr = 0;
+        }
+    }
 }
 
 static char *Arrows(MessageRef *ref) {
-
+    int start;
+    int len;
+
+    arrowBuf[0] = 0;
+    start = ref->tokenoffset;
+    start %= optsEnvir.cols;
+    if (start >= 0 && start < sizeof(arrowBuf)) {
+        len = ref->tokenlength;
+        if (len + start > sizeof(arrowBuf))
+            len = sizeof(arrowBuf) - start;
+        if (len == 0)
+            len = 1;
+        memset(arrowBuf, ' ', start);
+        memset(arrowBuf + start, '^', len);
+        arrowBuf[start + len] = 0;
+    }
+
+    return arrowBuf;
 }
 
 static Boolean IsLikelyAnImporter(Plugin *plugin) {
+    if (Plugin_CL_GetObjectFlags(plugin)->flags & 0x80000000)
+        return 0;
 
+    return plugin != Plugins_CL_MatchTarget(NULL, gTarg->cpu, gTarg->os, clState.plugintype, clState.language);
 }
 
 static char *GuessTool(Plugin *plugin) {
-
+    if (plugin) {
+        DropInFlags *df = Plugin_GetDropInFlags(plugin);
+        switch (df->dropintype) {
+            case CWDROPINDRIVERTYPE: return "Driver";
+            case CWDROPINPARSERTYPE: return "Usage";
+            case CWDROPINCOMPILERTYPE:
+                if (df->edit_language == Lang_C_CPP || df->edit_language == Lang_Pascal)
+                    return "Compiler";
+                else if (df->edit_language == CWFOURCHAR('A','s','m',' '))
+                    return "Assembler";
+                else if (IsLikelyAnImporter(plugin))
+                    return "Importer";
+                else
+                    return "Compiler";
+            case CWDROPINLINKERTYPE:
+                return "Linker";
+        }
+    }
+    return "Driver";
 }
 
 static char *GuessDoing(Plugin *plugin) {
-
-}
-
-static void styledMessage_MPW(Plugin *plugin, MessageRef *ref, SInt16 msgType, const char *format, va_list va) {
-
-}
-
-static void styledMessage_Default(Plugin *plugin, MessageRef *ref, SInt16 msgType, const char *format, va_list va) {
-
-}
-
-static void styledMessage_Terse(Plugin *plugin, MessageRef *ref, SInt16 msgType, const char *format, va_list va) {
-
-}
-
-static void styledMessage_IDE(Plugin *plugin, MessageRef *ref, SInt16 msgType, const char *format, va_list va) {
-
-}
-
-static void styledMessage_Parseable(Plugin *plugin, MessageRef *ref, SInt16 msgType, const char *format, va_list va) {
-
-}
-
-void CLPrintType(SInt16 msgtype, ...) {
-
+    if (plugin) {
+        DropInFlags *df = Plugin_GetDropInFlags(plugin);
+        switch (df->dropintype) {
+            case CWDROPINPARSERTYPE: return "parsing";
+            case CWDROPINCOMPILERTYPE: return "compiling";
+            case CWDROPINLINKERTYPE: return "linking";
+        }
+    }
+    return "processing";
+}
+
+static const char *msgnames[6] = {
+        "",
+        "Note",
+        "Warning",
+        "Error",
+        "Alert",
+        "Status"
+};
+
+static const char *msgnames_gcc[6] = {
+        "",
+        " note",
+        " warning",
+        "",
+        " alert",
+        " status"
+};
+
+static void styledMessage_MPW(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, va_list va) {
+    char msgBuf[256];
+    char *msgPtr;
+
+    msgPtr = IO_VFormatText(msgBuf, sizeof(msgBuf), "#   ", format, va);
+    if (msgType != Msg_Status)
+        CLPrintType(msgType, "### %s %s %s:\n", clState.programName, GuessTool(plugin), msgnames[msgType]);
+
+    if (ref) {
+        CLPrintType(msgType, "#\t%s\n", ref->sourceline);
+        CLPrintType(msgType, "#\t%s\n", Arrows(ref));
+    }
+
+    CLPrintDispatch(0, msgType, msgPtr);
+
+    if (ref) {
+        CLPrintType(msgType, "#----------------------------------------------------------\n");
+        CLPrintType(msgType, "    File \"%s\"; Line %d\n", OS_SpecToString(&ref->errorfile, STSbuf, sizeof(STSbuf)), ref->linenumber);
+        GetFileInfo(ref);
+        if (!srcIsErr)
+            CLPrintType(msgType, "#\twhile %s \"%s\"\n", GuessDoing(plugin), OS_SpecToString(&ref->sourcefile, STSbuf, sizeof(STSbuf)));
+        CLPrintType(msgType, "#----------------------------------------------------------\n");
+    }
+
+    if (msgPtr != msgBuf)
+        free(msgPtr);
+}
+
+static void styledMessage_Default(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, va_list va) {
+    char lineBuf[320];
+    char msgBuf[256];
+    char *msgPtr;
+    char *ptr;
+
+    msgPtr = IO_VFormatText(msgBuf, sizeof(msgBuf), "#   ", format, va);
+    if (ref) {
+        CLPrintType(msgType, "### %s %s:\n", clState.programName, GuessTool(plugin));
+    } else if (msgType != Msg_Status) {
+        CLPrintType(msgType, "### %s %s %s:\n", clState.programName, GuessTool(plugin), msgnames[msgType]);
+    }
+
+    if (ref) {
+        GetFileInfo(ref);
+        if (newErr || (newSrc && srcIsErr)) {
+            if (srcIsErr) {
+                sprintf(lineBuf, "#%8s: %s\n", "File", OS_SpecToStringRelative(&errSpec, NULL, STSbuf, sizeof(STSbuf)));
+            } else {
+                sprintf(lineBuf, "#%8s: %s\n", "In", OS_SpecToStringRelative(&errSpec, NULL, STSbuf, sizeof(STSbuf)));
+            }
+            CLPrintDispatch(0, msgType, lineBuf);
+        }
+        if (newSrc && !srcIsErr) {
+            sprintf(lineBuf, "# %7s: %s\n", "From", OS_SpecToStringRelative(&srcSpec, NULL, STSbuf, sizeof(STSbuf)));
+            CLPrintDispatch(0, msgType, lineBuf);
+        }
+        if (newErr || newSrc) {
+            ptr = &lineBuf[2];
+            while (*ptr && *ptr != '\n')
+                *(ptr++) = '-';
+            *ptr = 0;
+            if (ptr - lineBuf >= optsEnvir.cols - 1)
+                lineBuf[optsEnvir.cols - 1] = 0;
+            strcat(lineBuf, "\n");
+            CLPrintDispatch(0, msgType, lineBuf);
+        }
+        CLPrintType(msgType, "#%8d: %s\n", ref->linenumber, ref->sourceline);
+        CLPrintType(msgType, "#%8s: %s\n", msgnames[msgType], Arrows(ref));
+    }
+
+    CLPrintDispatch(0, msgType, msgPtr);
+    if (msgPtr != msgBuf)
+        free(msgPtr);
+}
+
+static void styledMessage_Terse(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, va_list va) {
+    char *msg;
+    char *ptr;
+    char msgBuf[256];
+    char *msgPtr;
+    char header[256];
+    char *headPtr;
+    char errBuf[256];
+    char *errPtr;
+
+    if (ref) {
+        if (msgnames_gcc[msgType][0]) {
+            headPtr = mprintf(
+                    header, sizeof(header),
+                    "%s:%d:%s: ",
+                    OS_SpecToStringRelative(&ref->errorfile, NULL, STSbuf, sizeof(STSbuf)),
+                    ref->linenumber,
+                    msgnames_gcc[msgType]
+            );
+        } else {
+            headPtr = mprintf(
+                    header, sizeof(header),
+                    "%s:%d: ",
+                    OS_SpecToStringRelative(&ref->errorfile, NULL, STSbuf, sizeof(STSbuf)),
+                    ref->linenumber
+            );
+        }
+    } else if (msgType != Msg_Status) {
+        headPtr = mprintf(header, sizeof(header), "%s: ", clState.programName);
+    } else {
+        header[0] = 0;
+        headPtr = header;
+    }
+
+    msgPtr = IO_VFormatText(msgBuf, sizeof(msgBuf), headPtr, format, va);
+    if ((strstr(msgPtr, "#warning") || strstr(msgPtr, "#error")) && ref->sourceline[0]) {
+        errPtr = IO_FormatText(errBuf, sizeof(errBuf), headPtr, "%", ref->sourceline);
+    } else {
+        errPtr = 0;
+    }
+
+    if (headPtr != header)
+        free(headPtr);
+
+    msg = msgPtr;
+    while (*msg) {
+        ptr = msg;
+        while (*ptr && *ptr != '\n')
+            ptr++;
+
+        CLPrintType(msgType, "%.*s\n", ptr - msg, msg);
+        if (errPtr) {
+            CLPrintType(msgType, "%s\n", errPtr);
+            if (errPtr != errBuf)
+                free(errPtr);
+            errPtr = NULL;
+        }
+
+        if (*ptr)
+            msg = ptr + 1;
+        else
+            msg = ptr;
+    }
+
+    if (msgPtr != msgBuf)
+        free(msgPtr);
+}
+
+static void styledMessage_IDE(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, va_list va) {
+    char msgBuf[256];
+    char *msgPtr;
+    SInt16 oldCols;
+
+    oldCols = optsEnvir.cols;
+    msgPtr = IO_VFormatText(msgBuf, sizeof(msgBuf), "           ", format, va);
+    optsEnvir.cols = oldCols;
+
+    CLPrintType(msgType, "%8s : %s\n", msgnames[msgType], msgPtr + 11);
+    if (msgPtr != msgBuf)
+        free(msgPtr);
+
+    if (ref) {
+        msgPtr = IO_FormatText(msgBuf, sizeof(msgBuf), "\t", "%", ref->sourceline);
+        CLPrintType(msgType, "%s line %d%s\n", OS_SpecToStringRelative(&ref->errorfile, NULL, STSbuf, sizeof(STSbuf)), ref->linenumber, msgPtr);
+        if (msgPtr != msgBuf)
+            free(msgPtr);
+    }
+}
+
+static void styledMessage_Parseable(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, va_list va) {
+    char msgBuf[256];
+    char *msgPtr;
+
+    CLPrintType(msgType, "%s|%s|%s\n", clState.programName, GuessTool(plugin), msgnames[msgType]);
+    if (ref) {
+        CLPrintType(
+                msgType,
+                "(%s|%d|%d|%d|%d|%d)\n",
+                OS_SpecToString(&ref->errorfile, STSbuf, sizeof(STSbuf)),
+                ref->linenumber,
+                ref->tokenoffset,
+                ref->tokenlength,
+                ref->selectionoffset,
+                ref->selectionlength
+                );
+        CLPrintType(msgType, "=%s\n", ref->sourceline);
+    }
+
+    msgPtr = IO_VFormatText(msgBuf, sizeof(msgBuf), ">", format, va);
+    CLPrintType(msgType, "%s\n", msgPtr);
+    if (msgPtr != msgBuf)
+        free(msgPtr);
+}
+
+void CLPrintType(SInt16 msgtype, const char *format, ...) {
+    char printbuffer[256];
+    char *ptr;
+    va_list va;
+
+    va_start(va, format);
+    ptr = mvprintf(printbuffer, sizeof(printbuffer), format, va);
+    va_end(va);
+    CLPrintDispatch(0, msgtype, ptr);
+    if (ptr != printbuffer)
+        free(ptr);
 }
 
 void CLPrint(const char *format, ...) {
+    char printbuffer[256];
+    char *ptr;
+    va_list va;
 
+    va_start(va, format);
+    ptr = mvprintf(printbuffer, sizeof(printbuffer), format, va);
+    va_end(va);
+    CLPrintDispatch(0, Msg_Note, ptr);
+    if (ptr != printbuffer)
+        free(ptr);
 }
 
 void CLPrintWarning(const char *format, ...) {
+    char printbuffer[256];
+    char *ptr;
+    va_list va;
 
+    va_start(va, format);
+    ptr = mvprintf(printbuffer, sizeof(printbuffer), format, va);
+    va_end(va);
+    CLPrintDispatch(0, Msg_Warning, ptr);
+    if (ptr != printbuffer)
+        free(ptr);
 }
 
 void CLPrintErr(const char *format, ...) {
+    char printbuffer[256];
+    char *ptr;
+    va_list va;
 
+    va_start(va, format);
+    ptr = mvprintf(printbuffer, sizeof(printbuffer), format, va);
+    va_end(va);
+    CLPrintDispatch(0, Msg_Error, ptr);
+    if (ptr != printbuffer)
+        free(ptr);
 }
 
 static void FixupMessageRef(MessageRef *ref) {
-
-}
-
-SInt16 CLStyledMessageDispatch(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType) {
-
+    char *bol;
+    char *eol;
+    int len;
+    int scan;
+
+    if (ref->sourceline && *ref->sourceline) {
+        bol = ref->sourceline + ref->tokenoffset;
+        eol = ref->sourceline + ref->tokenoffset + ref->tokenlength - 1;
+        if (eol < bol)
+            eol = bol;
+        while (bol > ref->sourceline && bol[-1] != '\r')
+            bol--;
+        while (*eol && *eol != '\r' && *eol != '\n')
+            eol++;
+
+        len = eol - bol;
+        ref->sourceline = xmalloc("text buffer", len + 1);
+        strncpy(ref->sourceline, bol, len);
+        ref->sourceline[len] = 0;
+
+        for (scan = 0; scan < len; scan++) {
+            if (ref->sourceline[scan] < ' ' || ref->sourceline[scan] >= 127)
+                ref->sourceline[scan] = ' ';
+        }
+    } else {
+        ref->sourceline = 0;
+    }
+}
+
+SInt16 CLStyledMessageDispatch(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, ...) {
+    va_list va;
+    MessageRef myref;
+    UInt32 ptype;
+
+    if (msgType == Msg_Warning) {
+        ptype = plugin ? Plugin_GetPluginType(plugin) : CWDROPINDRIVERTYPE;
+        if (optsCmdLine.noWarnings)
+            return 0;
+        if ((ptype == CWDROPINDRIVERTYPE || ptype == CWDROPINPARSERTYPE) && optsCmdLine.noCmdLineWarnings)
+            return 0;
+        if (optsCmdLine.warningsAreErrors)
+            msgType = Msg_Error;
+    }
+
+    if (msgType == Msg_Error && clState.withholdErrors)
+        return 0;
+    if (msgType == Msg_Warning && clState.withholdWarnings)
+        return 0;
+
+    if (ref) {
+        myref = *ref;
+        FixupMessageRef(&myref);
+    }
+
+    va_start(va, format);
+    if (optsCmdLine.msgStyle == 2) {
+        styledMessage_MPW(plugin, ref ? &myref : 0, errorNumber, msgType, format, va);
+    } else if (optsCmdLine.msgStyle == 1) {
+        styledMessage_Terse(plugin, ref ? &myref : 0, errorNumber, msgType, format, va);
+    } else if (optsCmdLine.msgStyle == 3) {
+        styledMessage_IDE(plugin, ref ? &myref : 0, errorNumber, msgType, format, va);
+    } else if (optsCmdLine.msgStyle == 4) {
+        styledMessage_Parseable(plugin, ref ? &myref : 0, errorNumber, msgType, format, va);
+    } else {
+        styledMessage_Default(plugin, ref ? &myref : 0, errorNumber, msgType, format, va);
+    }
+    va_end(va);
+
+    if (ref && myref.sourceline)
+        xfree(myref.sourceline);
+
+    if (msgType == Msg_Error && optsCmdLine.maxErrors) {
+        if (++clState.countErrors >= optsCmdLine.maxErrors) {
+            clState.withholdErrors = 1;
+            if (!optsCompiler.noFail) {
+                CLReport(70);
+                clState.userBreak = 1;
+            } else {
+                CLReport(71);
+            }
+        }
+    }
+
+    if (msgType == Msg_Warning && optsCmdLine.maxWarnings) {
+        if (++clState.countWarnings >= optsCmdLine.maxWarnings) {
+            clState.withholdWarnings = 1;
+            CLReport(72);
+        }
+    }
+
+    return msgType;
 }
diff --git a/command_line/CmdLine/Src/MacEmul/ErrMgr.c b/command_line/CmdLine/Src/MacEmul/ErrMgr.c
index 5fc621d..5ea1fe6 100644
--- a/command_line/CmdLine/Src/MacEmul/ErrMgr.c
+++ b/command_line/CmdLine/Src/MacEmul/ErrMgr.c
@@ -1,4 +1,4 @@
-#include "mwcc_decomp.h"
+#include "cmdline.h"
 
 static const char *getsyserr(SInt16 msgNbr) {
     switch (msgNbr) {
diff --git a/command_line/CmdLine/Src/MacEmul/Files.c b/command_line/CmdLine/Src/MacEmul/Files.c
index 9a9cb60..a613b4a 100644
--- a/command_line/CmdLine/Src/MacEmul/Files.c
+++ b/command_line/CmdLine/Src/MacEmul/Files.c
@@ -1,4 +1,4 @@
-#include "mwcc_decomp.h"
+#include "cmdline.h"
 
 typedef struct MacFileInfo {
     UInt32 ioFlCrDat;
diff --git a/command_line/CmdLine/Src/MacEmul/LowMem.c b/command_line/CmdLine/Src/MacEmul/LowMem.c
index 7fab079..cd31194 100644
--- a/command_line/CmdLine/Src/MacEmul/LowMem.c
+++ b/command_line/CmdLine/Src/MacEmul/LowMem.c
@@ -1,4 +1,4 @@
-#include "mwcc_decomp.h"
+#include "cmdline.h"
 
 static OSErr memErr;
 
diff --git a/command_line/CmdLine/Src/MacEmul/Memory.c b/command_line/CmdLine/Src/MacEmul/Memory.c
index 0aa5d24..e201343 100644
--- a/command_line/CmdLine/Src/MacEmul/Memory.c
+++ b/command_line/CmdLine/Src/MacEmul/Memory.c
@@ -1,4 +1,4 @@
-#include "mwcc_decomp.h"
+#include "cmdline.h"
 
 static OSErr memError;
 
diff --git a/command_line/CmdLine/Src/MacEmul/ResourceStrings.c b/command_line/CmdLine/Src/MacEmul/ResourceStrings.c
index 9f8f333..4b6bc22 100644
--- a/command_line/CmdLine/Src/MacEmul/ResourceStrings.c
+++ b/command_line/CmdLine/Src/MacEmul/ResourceStrings.c
@@ -1,9 +1,9 @@
-#include "mwcc_decomp.h"
+#include "cmdline.h"
 
 typedef struct {
     const char *name;
     SInt16 rsrcid;
-    Handle strings;
+    const char **strings;
 } Res;
 
 static Res rlist[16];
@@ -12,7 +12,7 @@ void Res_Initialize() {
     memset(rlist, 0, sizeof(rlist));
 }
 
-int Res_AddResource(const char *name, SInt16 rsrcid, Handle strings) {
+int Res_AddResource(const char *name, SInt16 rsrcid, const char **strings) {
     int scan;
 
     for (scan = 0; scan < 16 && rlist[scan].rsrcid; scan++) {
diff --git a/command_line/CmdLine/Src/MacEmul/Resources.c b/command_line/CmdLine/Src/MacEmul/Resources.c
index 796ed43..ef2aab0 100644
--- a/command_line/CmdLine/Src/MacEmul/Resources.c
+++ b/command_line/CmdLine/Src/MacEmul/Resources.c
@@ -1,4 +1,4 @@
-#include "mwcc_decomp.h"
+#include "cmdline.h"
 
 // Fork Attributes
 enum {
@@ -284,6 +284,7 @@ memcpy(buf, ((unsigned char *) file_data) + __offs, (count));   \
 } while(0)
 
 static void ReadResourceFork(SInt16 ref, SInt8 permission, void *file_data, SInt32 file_size) {
+    // this function has various awkwardly swapped registers
     MemRsrcMap *rm;
     Ty70 thdr;
     Ty70 *dhdr;
@@ -316,27 +317,29 @@ static void ReadResourceFork(SInt16 ref, SInt8 permission, void *file_data, SInt
 
     cnt = sizeof(Ty70);
     RF_READ(&thdr, 0, cnt, mapFail);
+    dhdr = &thdr;
 
     ref_offs = cnt;
     cnt = ((thdr.map_offs < thdr.data_offs) ? thdr.map_offs : thdr.data_offs) - sizeof(Ty70);
     if (cnt > sizeof(MemRsrcSysData))
         cnt = sizeof(MemRsrcSysData);
     RF_READ(&tsys, ref_offs, cnt, mapFail);
+    dsys = &tsys;
 
-    msize = thdr.map_len;
+    msize = dhdr->map_len;
     buffer = malloc(msize);
     if (!buffer)
         goto memFail;
 
-    ref_offs = thdr.map_offs;
+    ref_offs = dhdr->map_offs;
     RF_READ(buffer, ref_offs, msize, mapFail);
 
     if (
-            (thdr.map_offs > file_size)
-            || ((thdr.map_offs + thdr.map_len) > file_size)
-            || (thdr.data_offs > file_size)
-            || ((thdr.data_offs + thdr.data_len) > file_size)
-            || ((thdr.map_offs < thdr.data_offs) ? ((thdr.map_offs + thdr.map_len) != thdr.data_offs) : ((thdr.data_offs + thdr.data_len) != thdr.map_offs))
+            (dhdr->map_offs > file_size)
+            || ((dhdr->map_offs + dhdr->map_len) > file_size)
+            || (dhdr->data_offs > file_size)
+            || ((dhdr->data_offs + dhdr->data_len) > file_size)
+            || ((dhdr->map_offs < dhdr->data_offs) ? ((dhdr->map_offs + dhdr->map_len) > dhdr->data_offs) : ((dhdr->data_offs + dhdr->data_len) > dhdr->map_offs))
             )
         goto mapFail;
 
@@ -344,13 +347,13 @@ static void ReadResourceFork(SInt16 ref, SInt8 permission, void *file_data, SInt
     if (!rm)
         goto memFail;
 
-    rm->sys_data = tsys;
+    rm->sys_data = *dsys;
 
     dmap = (Ty73 *) buffer;
-    if ((dmap->typelist_offs + thdr.map_offs) > file_size)
+    if ((dmap->typelist_offs + dhdr->map_offs) > file_size)
         goto freeAndMapFail;
     dtyp = (Ty75 *) (((unsigned char *) buffer) + dmap->typelist_offs + 2);
-    if ((dmap->namelist_offs + thdr.map_offs) > file_size)
+    if ((dmap->namelist_offs + dhdr->map_offs) > file_size)
         goto freeAndMapFail;
     dnam = (Ty80 *) (((unsigned char *) buffer) + dmap->namelist_offs);
     if (dmap->types_idx != 0xFFFF) {
@@ -359,21 +362,21 @@ static void ReadResourceFork(SInt16 ref, SInt8 permission, void *file_data, SInt
             if (!mtyp)
                 goto freeAndReturn;
 
-            if ((thdr.map_offs + dmap->typelist_offs + dtyp[cnt].ref_list_offs) > file_size)
+            if ((dmap->typelist_offs + dtyp[cnt].ref_list_offs + dhdr->map_offs) > file_size)
                 goto freeAndMapFail;
 
             drle = (Ty77 *) (((unsigned char *) dtyp) + dtyp[cnt].ref_list_offs - 2);
             if (dtyp[cnt].rsrc_idx != 0xFFFF) {
                 for (rcnt = 0; rcnt <= dtyp[cnt].rsrc_idx; rcnt++) {
                     ref_offs = (drle[rcnt].data_offs[0] << 16) | (drle[rcnt].data_offs[1] << 8) | drle[rcnt].data_offs[2];
-                    offs = thdr.data_offs + ref_offs;
+                    offs = ref_offs + dhdr->data_offs;
                     if (offs > file_size)
                         goto freeAndMapFail;
                     esize = 4;
                     RF_READ(&tent, offs, esize, freeAndMapFail);
 
                     offs += esize;
-                    if ((thdr.data_offs + ref_offs + tent.len) > file_size)
+                    if ((tent.len + ref_offs + dhdr->data_offs) > file_size)
                         goto freeAndMapFail;
 
                     hand = NewHandle(tent.len);
@@ -385,7 +388,7 @@ static void ReadResourceFork(SInt16 ref, SInt8 permission, void *file_data, SInt
                     HUnlock(hand);
 
                     if (drle[rcnt].name_offs != 0xFFFF) {
-                        nameptr = (StringPtr) (dnam + drle[rcnt].name_offs);
+                        nameptr = (StringPtr) dnam + drle[rcnt].name_offs;
                         name = malloc(nameptr[0] + 1);
                         memcpy(name, nameptr, nameptr[0] + 1);
                     } else {
@@ -1250,14 +1253,14 @@ void HCreateResFile(SInt16 vRefNum, SInt32 dirID, ConstStringPtr fileName) {
     }
 }
 
-OSErr FSpOpenResFile(const FSSpec *fss, SInt8 permission) {
+OSErr FSpOpenResFile(const FSSpec *spec, SInt8 permission) {
     SInt16 ref;
     SInt32 size;
 
     if (permission != fsRdPerm)
-        FSpCreate(fss, 'CWIE', 'TEXT', -1);
+        FSpCreate(spec, 'CWIE', 'TEXT', -1);
 
-    resError = FSpOpenRF(fss, (permission == fsWrPerm) ? fsRdWrPerm : permission, &ref);
+    resError = FSpOpenRF(spec, (permission == fsWrPerm) ? fsRdWrPerm : permission, &ref);
     if (!resError) {
         GetEOF(ref, &size);
         if (size == 0 && permission != fsRdPerm)
diff --git a/command_line/CmdLine/Src/MacEmul/TextUtils.c b/command_line/CmdLine/Src/MacEmul/TextUtils.c
index a23ac7e..7971074 100644
--- a/command_line/CmdLine/Src/MacEmul/TextUtils.c
+++ b/command_line/CmdLine/Src/MacEmul/TextUtils.c
@@ -1,4 +1,4 @@
-#include "mwcc_decomp.h"
+#include "cmdline.h"
 
 StringPtr c2pstr(char *s) {
     unsigned int l;
diff --git a/command_line/CmdLine/Src/OSLib/MacFileTypes.c b/command_line/CmdLine/Src/OSLib/MacFileTypes.c
index 05a2ae9..5ebb4d6 100644
--- a/command_line/CmdLine/Src/OSLib/MacFileTypes.c
+++ b/command_line/CmdLine/Src/OSLib/MacFileTypes.c
@@ -4,7 +4,7 @@ static OSFileTypeMappings *defaultList;
 static OSFileTypeMappings **fmList = &defaultList;
 int (*__OS_ExtendedGetMacFileTypeHook)(const OSSpec *, OSType *);
 
-void OS_AddFileTypeMappingList(OSFileTypeMappings **list, OSFileTypeMappingList *entry) {
+void OS_AddFileTypeMappingList(OSFileTypeMappings **list, const OSFileTypeMappingList *entry) {
     OSFileTypeMappings **scan;
 
     if (!list)
@@ -27,7 +27,7 @@ void OS_UseFileTypeMappings(OSFileTypeMappings *list) {
 
 void OS_MacType_To_OSType(OSType mactype, uOSTypePair *type) {
     OSFileTypeMappings *list;
-    OSFileTypeMappingList *scan;
+    const OSFileTypeMappingList *scan;
     int idx;
 
     for (list = *fmList; list; list = list->next) {
@@ -51,7 +51,7 @@ int OS_SetMacFileType(const OSSpec *spec, OSType mactype) {
 
 Boolean OS_GetMacFileTypeMagic(const char *buffer, int count, OSType *mactype) {
     OSFileTypeMappings *list;
-    OSFileTypeMappingList *scan;
+    const OSFileTypeMappingList *scan;
     int idx;
 
     *mactype = 0;
diff --git a/command_line/CmdLine/Src/OSLib/Posix.c b/command_line/CmdLine/Src/OSLib/Posix.c
index e3f8a03..d416b9b 100644
--- a/command_line/CmdLine/Src/OSLib/Posix.c
+++ b/command_line/CmdLine/Src/OSLib/Posix.c
@@ -408,14 +408,14 @@ int OS_EqualPath(const char *a, const char *b) {
     return !strcmp(a, b);
 }
 
-int OS_CanonPath(char *src, char *dst) {
+int OS_CanonPath(const char *src, char *dst) {
     int idx;
 
     if (strlen(src) > 255)
         return ENAMETOOLONG;
 
     if (!dst)
-        dst = src;
+        dst = (char *) src;
 
     for (idx = 0; src[idx]; idx++) {
         if (src[idx] == '\\')
@@ -956,6 +956,6 @@ int OS_LoadMacResourceFork(const OSSpec *spec, void **file_data, SInt32 *file_le
     return ENOENT;
 }
 
-int OS_IsMultiByte(const char *str, int offset) {
+Boolean OS_IsMultiByte(const char *str, int offset) {
     return 0;
 }
diff --git a/command_line/CmdLine/Src/Plugins/CLPlugins.c b/command_line/CmdLine/Src/Plugins/CLPlugins.c
index e69de29..5f31f45 100644
--- a/command_line/CmdLine/Src/Plugins/CLPlugins.c
+++ b/command_line/CmdLine/Src/Plugins/CLPlugins.c
@@ -0,0 +1,981 @@
+#include "cmdline.h"
+
+static Plugin *pluginlist;
+static ToolVersionInfo toolVersionInfo;
+static VersionInfo toolVersion;
+static Boolean useToolVersion;
+
+static void GetToolVersionInfo() {
+    useToolVersion = 0;
+}
+
+const ToolVersionInfo *Plugin_GetToolVersionInfo() {
+    return useToolVersion ? &toolVersionInfo : 0;
+}
+
+static const char *Plugin_GetDisplayName(Plugin *pl) {
+    const char *name;
+#line 251
+    OPTION_ASSERT(pl);
+
+    if (pl->cb->GetDisplayName && pl->cb->GetDisplayName(&name) == 0)
+        return name;
+    else
+        return "(no name found)";
+}
+
+const char *Plugin_GetDropInName(Plugin *pl) {
+    const char *name;
+#line 263
+    OPTION_ASSERT(pl);
+
+    if (pl->cb->GetDropInName && pl->cb->GetDropInName(&name) == 0)
+        return name;
+    else
+        return "(no name found)";
+}
+
+const VersionInfo *Plugin_GetVersionInfo(Plugin *pl) {
+    static const VersionInfo fakeversion = {0, 0, 0, 0};
+    const VersionInfo *vi;
+#line 276
+    OPTION_ASSERT(pl);
+
+    if (pl->cb->GetVersionInfo && pl->cb->GetVersionInfo(&vi) == 0)
+        return vi;
+    else
+        return &fakeversion;
+}
+
+char *Plugin_GetVersionInfoASCII(Plugin *pl) {
+    const VersionInfo *vi;
+    char *buffer;
+    char vernum[16];
+    char *bptr;
+
+    if (!pl && useToolVersion) {
+        vi = &toolVersion;
+    } else if (!pl) {
+        return NULL;
+    } else {
+        vi = Plugin_GetVersionInfo(pl);
+    }
+
+    buffer = xmalloc("version info", 64);
+    if (vi->major | vi->minor | vi->patch | vi->build != 0) {
+        bptr = vernum;
+        bptr += sprintf(bptr, "%u", vi->major);
+        bptr += sprintf(bptr, ".%u", vi->minor);
+        if (vi->patch)
+            bptr += sprintf(bptr, ".%u", vi->patch);
+        if (vi->build)
+            bptr += sprintf(bptr, " build %u", vi->build);
+        sprintf(buffer, "Version %s", vernum);
+        return buffer;
+    } else {
+        return NULL;
+    }
+}
+
+DropInFlags *Plugin_GetDropInFlags(Plugin *pl) {
+    static DropInFlags retdf;
+    const DropInFlags *df;
+    SInt32 dfsize;
+
+#line 329
+    OPTION_ASSERT(pl);
+
+    if (pl->cb->GetDropInFlags && pl->cb->GetDropInFlags(&df, &dfsize) == 0) {
+        memset(&retdf, 0, sizeof(retdf));
+        memcpy(&retdf, df, dfsize);
+        return &retdf;
+    } else {
+        return NULL;
+    }
+}
+
+OSType Plugin_GetPluginType(Plugin *pl) {
+    DropInFlags *df;
+
+#line 345
+    OPTION_ASSERT(pl);
+
+    df = Plugin_GetDropInFlags(pl);
+    if (df)
+        return df->dropintype;
+    else
+        return CWFOURCHAR('N','O','N','E');
+}
+
+const CWTargetList *Plugin_CL_GetTargetList(Plugin *pl) {
+    static const CWTargetList faketl = {
+            kCurrentCWTargetListVersion,
+            0, NULL,
+            0, NULL
+    };
+    const CWTargetList *tl;
+
+#line 358
+    OPTION_ASSERT(pl);
+    OPTION_ASSERT(pl->cl_cb != NULL);
+
+    if (pl->cl_cb->GetTargetList && pl->cl_cb->GetTargetList(&tl) == 0)
+        return tl;
+    else
+        return &faketl;
+}
+
+const CWPanelList *Plugin_GetPanelList(Plugin *pl) {
+    static CWPanelList fakepnl = {
+            kCurrentCWPanelListVersion, 0, NULL
+    };
+    const CWPanelList *pnl;
+
+#line 381
+    OPTION_ASSERT(pl);
+
+    if (pl->cb->GetPanelList && pl->cb->GetPanelList(&pnl) == 0)
+        return pnl;
+    else
+        return &fakepnl;
+}
+
+const CWExtMapList *Plugin_CL_GetExtMapList(Plugin *pl) {
+    static CWExtMapList fakeel = {
+            kCurrentCWExtMapListVersion,
+            0, NULL
+    };
+    const CWExtMapList *el;
+
+#line 401
+    OPTION_ASSERT(pl);
+    OPTION_ASSERT(pl->cl_cb != NULL);
+
+    if (pl->cl_cb->GetDefaultMappingList && pl->cl_cb->GetDefaultMappingList(&el) == 0)
+        return el;
+    else
+        return &fakeel;
+}
+
+const OSFileTypeMappingList *Plugin_GetFileTypeMappingList(Plugin *pl) {
+    const OSFileTypeMappingList *ftml;
+
+#line 422
+    OPTION_ASSERT(pl);
+
+    if (pl->cb->GetFileTypeMappings && pl->cb->GetFileTypeMappings(&ftml) == 0)
+        return ftml;
+    else
+        return NULL;
+}
+
+const CWObjectFlags *Plugin_CL_GetObjectFlags(Plugin *pl) {
+    static CWObjectFlags fake = {
+            2, 0,
+            "", "", "", "", "", "",
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+    const CWObjectFlags *cof;
+
+#line 434
+    OPTION_ASSERT(pl);
+    OPTION_ASSERT(pl->cl_cb != NULL);
+
+    if (pl->cl_cb->GetObjectFlags && pl->cl_cb->GetObjectFlags(&cof) == 0)
+        return cof;
+    else if (Plugin_GetDropInFlags(pl)->dropintype == CWDROPINCOMPILERTYPE)
+        return NULL;
+    else
+        return &fake;
+}
+
+Boolean Plugin_MatchesName(Plugin *pl, const char *name) {
+    const char *pname = Plugin_GetDropInName(pl);
+    return !strcmp(pname, name);
+}
+
+Boolean Plugin_CL_MatchesTarget(Plugin *pl, OSType cpu, OSType os, Boolean exact) {
+    const CWTargetList *tl;
+    int idx;
+    int ix;
+
+    tl = Plugin_CL_GetTargetList(pl);
+
+    for (idx = 0; idx < tl->cpuCount; idx++) {
+        if (cpu == targetCPUAny || cpu == tl->cpus[idx] || (tl->cpus[idx] == targetCPUAny && !exact)) {
+            for (ix = 0; ix < tl->osCount; ix++) {
+                if (os == targetOSAny || os == tl->oss[ix] || (tl->oss[ix] == targetOSAny && !exact))
+                    return 1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+Boolean Plugins_CL_HaveMatchingTargets(Plugin *p1, Plugin *p2, Boolean exact) {
+    // does not match, annoyingly
+    const CWTargetList *t1;
+    const CWTargetList *t2;
+    int ic1;
+    int ic2;
+    int io1;
+    int io2;
+
+    t1 = Plugin_CL_GetTargetList(p1);
+    t2 = Plugin_CL_GetTargetList(p2);
+
+    for (ic1 = 0; ic1 < t1->cpuCount; ic1++) {
+        for (ic2 = 0; ic2 < t2->cpuCount; ic2++) {
+            if ((t2->cpus[ic2] == targetCPUAny && !exact) || (t1->cpus[ic1] == t2->cpus[ic2]) || (t1->cpus[ic1] == targetCPUAny && !exact)) {
+                for (io1 = 0; io1 < t1->osCount; io1++) {
+                    for (io2 = 0; io2 < t2->osCount; io2++) {
+                        if ((t2->oss[io2] == targetOSAny && !exact) || (t1->oss[io1] == t2->oss[io2]) || (t1->oss[io1] == targetOSAny && !exact)) {
+                            return 1;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+static Boolean CL_MatchesExtMapping(CWExtensionMapping *map, OSType type, const char *ext, Boolean exact) {
+    if (exact && type && map->type && type == map->type)
+        return 1;
+
+    if (
+            (((!map->extension[0] && !exact) || (!ext[0] && !exact)) && map->type == type)
+            ||
+            (((!map->type && !exact) || (!type && !exact)) && !ustrcmp(map->extension, ext))
+            ||
+            (!ustrcmp(map->extension, ext) && map->type == type)
+            ) {
+        return 1;
+    }
+
+    return 0;
+}
+
+Boolean Plugin_CL_MatchesFileType(Plugin *pl, OSType type, const char *extension, Boolean exact) {
+    const CWExtMapList *el;
+    int idx;
+
+    el = Plugin_CL_GetExtMapList(pl);
+
+    for (idx = 0; idx < el->nMappings; idx++) {
+        if (CL_MatchesExtMapping(&el->mappings[idx], type, extension, exact))
+            return 1;
+    }
+
+    return 0;
+}
+
+Boolean Plugin_MatchesType(Plugin *pl, OSType type, OSType lang, Boolean exact) {
+    const DropInFlags *df;
+
+    df = Plugin_GetDropInFlags(pl);
+    if (df->dropintype == type || type == CWDROPINANYTYPE) {
+        if (df->edit_language == lang || lang == Lang_Any || (df->edit_language == Lang_Any && !exact))
+            return 1;
+    }
+
+    return 0;
+}
+
+Boolean Plugin_Pr_MatchesPlugin(Plugin *pl, CLPluginInfo *pluginfo, OSType cpu, OSType os) {
+    Boolean isSupported;
+
+#line 566
+    OPTION_ASSERT(pl->pr_cb != NULL);
+
+    if (pl->pr_cb->SupportsPlugin && pl->pr_cb->SupportsPlugin(pluginfo, cpu, os, &isSupported) == 0)
+        return isSupported;
+    else
+        return 0;
+}
+
+Boolean Plugin_Pr_MatchesPanels(Plugin *pl, int numPanels, const char **panelNames) {
+    Boolean isSupported;
+
+#line 578
+    OPTION_ASSERT(pl->pr_cb != NULL);
+
+    if (pl->pr_cb->SupportsPanels && pl->pr_cb->SupportsPanels(numPanels, panelNames, &isSupported) == 0)
+        return isSupported;
+    else
+        return 0;
+}
+
+Boolean Plugin_CL_WriteObjectFile(Plugin *pl, FSSpec *srcfss, FSSpec *outfss, OSType creator, OSType type, Handle data) {
+    OSSpec outoss;
+
+#line 590
+    OPTION_ASSERT(pl->cl_cb != NULL);
+    OPTION_ASSERT(data != NULL && srcfss != NULL && outfss != NULL);
+
+    if (pl->cl_cb->WriteObjectFile) {
+        return pl->cl_cb->WriteObjectFile(srcfss, outfss, creator, type, data) == 0;
+    }
+
+    OS_FSSpec_To_OSSpec(outfss, &outoss);
+    return WriteBinaryHandleToFile(&outoss, creator, type, OS_PeekMacHandle(data));
+}
+
+Boolean Plugin_CL_GetCompilerMapping(Plugin *pl, OSType type, const char *ext, UInt32 *flags) {
+    const CWExtMapList *el;
+    int idx;
+    int pick;
+
+    el = Plugin_CL_GetExtMapList(pl);
+    pick = -1;
+    for (idx = 0; idx < el->nMappings; idx++) {
+        if (CL_MatchesExtMapping(&el->mappings[idx], type, ext, 0)) {
+            pick = idx;
+            if (CL_MatchesExtMapping(&el->mappings[idx], type, ext, 1))
+                break;
+        }
+    }
+
+    if (pick < 0) {
+        *flags = 0;
+        return 0;
+    } else {
+        *flags = el->mappings[pick].flags;
+        return 1;
+    }
+}
+
+static Boolean SupportedPlugin(Plugin *pl, const char **reason) {
+    static const SInt32 DropInFlagsSize[3] = {0, 0x10, 0x12};
+    const DropInFlags *df;
+    const CWObjectFlags *cof;
+    SInt32 dfsize;
+
+    *reason = "";
+    if (pl->cb->GetDropInFlags == NULL) {
+        *reason = "GetDropInFlags callback not found";
+        return 0;
+    }
+    if (pl->cb->GetDropInFlags(&df, &dfsize)) {
+        *reason = "GetDropInFlags callback failed";
+        return 0;
+    }
+    if (df->dropintype != CWDROPINCOMPILERTYPE && df->dropintype != CWDROPINLINKERTYPE && df->dropintype != CWDROPINPARSERTYPE && df->dropintype != CWDROPINDRIVERTYPE) {
+        *reason = "The plugin type is not supported by this driver";
+        return 0;
+    }
+    if (df->earliestCompatibleAPIVersion > 11) {
+        *reason = "The plugin's earliest compatible API version is too new for this driver";
+        return 0;
+    }
+    if (df->earliestCompatibleAPIVersion > 1 && df->newestAPIVersion < 11 && clState.pluginDebug) {
+        CLPrintErr("%s's newest compatible API version is probably too old for this driver\n", Plugin_GetDropInName(pl));
+    }
+    if (dfsize != DropInFlagsSize[df->rsrcversion]) {
+        *reason = "The plugin's DropInFlags has an unexpected size";
+        return 0;
+    }
+    if (!(df->dropinflags & dropInExecutableTool) && !pl->cb->main) {
+        *reason = "The plugin has no entry point";
+        return 0;
+    }
+    if ((df->dropinflags & dropInExecutableTool) && pl->cb->main) {
+        *reason = "The executable tool stub has an entry point";
+        return 0;
+    }
+
+    if (pl->cl_cb) {
+        if (pl->cl_cb->GetObjectFlags == NULL && df->dropintype == CWDROPINCOMPILERTYPE) {
+            *reason = "GetObjectFlags callback not found in compiler plugin";
+            return 0;
+        }
+
+        cof = Plugin_CL_GetObjectFlags(pl);
+        if (cof->version < 2 || cof->flags & 0x7FFFFFFF) {
+            *reason = "The object flags data is out-of-date or invalid";
+            return 0;
+        }
+    }
+
+    return 1;
+}
+
+static Boolean VerifyPanels(Plugin *pl) {
+    const CWPanelList *pls;
+    Boolean failed;
+    int idx;
+
+    failed = 0;
+
+    if (pl->cb->GetPanelList && pl->cb->GetPanelList(&pls) == 0) {
+        for (idx = 0; idx < pls->count; idx++) {
+            if (Prefs_FindPanel(pls->names[idx]) == NULL) {
+                CLReportError(91, pls->names[idx]);
+                failed = 1;
+            }
+        }
+    }
+
+    return !failed;
+}
+
+Plugin *Plugin_New(const BasePluginCallbacks *cb, const CompilerLinkerPluginCallbacks *cl_cb, const ParserPluginCallbacks *pr_cb) {
+    Plugin *p;
+
+    p = xmalloc(NULL, sizeof(Plugin));
+    if (!p)
+        return NULL;
+    if (!cb)
+        return NULL;
+
+    p->cb = xmalloc(NULL, sizeof(BasePluginCallbacks));
+    if (!p->cb)
+        return NULL;
+    *p->cb = *cb;
+
+    if (cl_cb) {
+        p->cl_cb = xmalloc(NULL, sizeof(CompilerLinkerPluginCallbacks));
+        if (!p->cl_cb)
+            return NULL;
+        *p->cl_cb = *cl_cb;
+    } else {
+        p->cl_cb = NULL;
+    }
+
+    if (pr_cb) {
+        p->pr_cb = xmalloc(NULL, sizeof(ParserPluginCallbacks));
+        if (!p->pr_cb)
+            return NULL;
+        *p->pr_cb = *pr_cb;
+    } else {
+        p->pr_cb = NULL;
+    }
+
+    p->context = NULL;
+    p->next = NULL;
+    return p;
+}
+
+void Plugin_Free(Plugin *pl) {
+    if (pl) {
+        if (pl->cb)
+            xfree(pl->cb);
+        if (pl->cl_cb)
+            xfree(pl->cl_cb);
+        if (pl->pr_cb)
+            xfree(pl->pr_cb);
+        xfree(pl);
+    }
+}
+
+Boolean Plugin_VerifyPanels(Plugin *pl) {
+    if (!VerifyPanels(pl)) {
+        CLReportError(92, Plugin_GetDropInName(pl));
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+void Plugins_Init() {
+    pluginlist = NULL;
+    GetToolVersionInfo();
+}
+
+void Plugins_Term() {
+    Plugin *scan;
+    Plugin *next;
+
+    scan = pluginlist;
+    while (scan) {
+        next = scan->next;
+        SendInitOrTermRequest(scan, 0);
+        Plugin_Free(scan);
+        scan = next;
+    }
+
+    if (toolVersionInfo.company)
+        xfree(toolVersionInfo.company);
+    if (toolVersionInfo.product)
+        xfree(toolVersionInfo.product);
+    if (toolVersionInfo.tool)
+        xfree(toolVersionInfo.tool);
+    if (toolVersionInfo.copyright)
+        xfree(toolVersionInfo.copyright);
+    if (toolVersionInfo.version)
+        xfree(toolVersionInfo.version);
+}
+
+int Plugins_Add(Plugin *pl) {
+    Plugin **scan;
+    const char *dropinname;
+    const DropInFlags *df;
+    const CWTargetList *tl;
+    const CWExtMapList *el;
+    const CWPanelList *pnl;
+    const char *failreason;
+    CWDataType vislang;
+    SInt16 step;
+
+    dropinname = Plugin_GetDropInName(pl);
+    pl->cached_ascii_version = Plugin_GetVersionInfoASCII(pl);
+
+    if (!SupportedPlugin(pl, &failreason)) {
+        CLReportError(88, dropinname, pl->cached_ascii_version, failreason);
+        return 0;
+    }
+
+    scan = &pluginlist;
+    while (*scan) {
+        if (Plugin_MatchesName(*scan, dropinname)) {
+            CLReportError(89, dropinname);
+            return 0;
+        }
+        scan = &(*scan)->next;
+    }
+
+    *scan = pl;
+
+    df = Plugin_GetDropInFlags(pl);
+    if (!(df->dropinflags & dropInExecutableTool) && !SendInitOrTermRequest(pl, 1)) {
+        CLReportError(3, dropinname);
+        return 0;
+    }
+
+    if (df->dropintype == CWDROPINCOMPILERTYPE && df->dropinflags & 0x17C000)
+        CLReportError(4, "compiler", dropinname);
+    if (df->dropintype == CWDROPINLINKERTYPE && df->dropinflags & 0x5FE4000)
+        CLReportError(4, "linker", dropinname);
+
+    if (clState.pluginDebug) {
+        vislang = df->edit_language ? df->edit_language : CWFOURCHAR('-','-','-','-');
+        CLPrint("Added plugin '%s', version '%s'\n", dropinname, pl->cached_ascii_version);
+        CLPrint("Type: '%c%c%c%c';  Lang: '%c%c%c%c';  API range: %d-%d\n",
+                (df->dropintype & 0xFF000000) >> 24,
+                (df->dropintype & 0x00FF0000) >> 16,
+                (df->dropintype & 0x0000FF00) >> 8,
+                (df->dropintype & 0x000000FF),
+                (vislang & 0xFF000000) >> 24,
+                (vislang & 0x00FF0000) >> 16,
+                (vislang & 0x0000FF00) >> 8,
+                (vislang & 0x000000FF),
+                df->earliestCompatibleAPIVersion,
+                df->newestAPIVersion
+                );
+
+        if (pl->cl_cb) {
+            tl = Plugin_CL_GetTargetList(pl);
+            CLPrint("Target CPUs: ");
+            for (step = 0; step < tl->cpuCount; step++) {
+                CLPrint("'%c%c%c%c', ",
+                        (tl->cpus[step] & 0xFF000000) >> 24,
+                        (tl->cpus[step] & 0x00FF0000) >> 16,
+                        (tl->cpus[step] & 0x0000FF00) >> 8,
+                        (tl->cpus[step] & 0x000000FF)
+                );
+            }
+            CLPrint("\nTarget OSes: ");
+            for (step = 0; step < tl->osCount; step++) {
+                CLPrint("'%c%c%c%c', ",
+                        (tl->oss[step] & 0xFF000000) >> 24,
+                        (tl->oss[step] & 0x00FF0000) >> 16,
+                        (tl->oss[step] & 0x0000FF00) >> 8,
+                        (tl->oss[step] & 0x000000FF)
+                );
+            }
+            CLPrint("\n");
+
+            el = Plugin_CL_GetExtMapList(pl);
+            CLPrint("File mappings:\n");
+            for (step = 0; step < el->nMappings; step++) {
+                if (el->mappings[step].type) {
+                    CLPrint("\tFile type: '%c%c%c%c'  Extension: '%s'\n",
+                            (el->mappings[step].type & 0xFF000000) >> 24,
+                            (el->mappings[step].type & 0x00FF0000) >> 16,
+                            (el->mappings[step].type & 0x0000FF00) >> 8,
+                            (el->mappings[step].type & 0x000000FF),
+                            el->mappings[step].extension
+                    );
+                } else {
+                    CLPrint("\tFile type: <none>  Extension: '%s'\n",
+                            el->mappings[step].extension
+                    );
+                }
+            }
+        }
+
+        pnl = Plugin_GetPanelList(pl);
+        CLPrint("Pref panels needed:\n");
+        for (step = 0; step < pnl->count; step++) {
+            CLPrint("\t'%s'\n", pnl->names[step]);
+        }
+
+        CLPrint("Dropin flags:\n");
+        if (df->dropinflags & dropInExecutableTool) CLPrint("\texecutable tool,\n");
+        if (df->dropintype == CWDROPINCOMPILERTYPE) {
+            if (df->dropinflags & kGeneratescode) CLPrint("\tgenerates code,\n");
+            if (df->dropinflags & kGeneratesrsrcs) CLPrint("\tgenerates resources, \n");
+            if (df->dropinflags & kCanpreprocess) CLPrint("\tcan preprocess, \n");
+            if (df->dropinflags & kCanprecompile) CLPrint("\tcan precompile, \n");
+            if (df->dropinflags & kIspascal) CLPrint("\tis Pascal, \n");
+            if (df->dropinflags & kCanimport) CLPrint("\tcan import, \n");
+            if (df->dropinflags & kCandisassemble) CLPrint("\tcan disassemble, \n");
+            if (df->dropinflags & kCompAllowDupFileNames) CLPrint("\tallow duplicate filenames, \n");
+            if (df->dropinflags & kCompMultiTargAware) CLPrint("\tallow multiple targets, \n");
+            if (df->dropinflags & kCompUsesTargetStorage) CLPrint("\tuses target storage, \n");
+            if (df->dropinflags & kCompEmitsOwnBrSymbols) CLPrint("\temits own browser symbols, \n");
+            if (df->dropinflags & kCompAlwaysReload) CLPrint("\tshould be always reloaded, \n");
+            if (df->dropinflags & kCompRequiresProjectBuildStartedMsg) CLPrint("\trequires project build started msg, \n");
+            if (df->dropinflags & kCompRequiresTargetBuildStartedMsg) CLPrint("\trequires target build started msg, \n");
+            if (df->dropinflags & kCompRequiresSubProjectBuildStartedMsg) CLPrint("\trequires subproject build started msg, \n");
+            if (df->dropinflags & kCompRequiresFileListBuildStartedMsg) CLPrint("\trequires file list build started msg, \n");
+        }
+
+        if (df->dropintype == CWDROPINLINKERTYPE) {
+            if (df->dropinflags & cantDisassemble) CLPrint("\tcan't disassemble, \n");
+            if (df->dropinflags & isPostLinker) CLPrint("\tis a post-linker, \n");
+            if (df->dropinflags & linkAllowDupFileNames) CLPrint("\tallow duplicate filenames, \n");
+            if (df->dropinflags & linkMultiTargAware) CLPrint("\tallow multiple targets, \n");
+            if (df->dropinflags & isPreLinker) CLPrint("\tis a pre-linker, \n");
+            if (df->dropinflags & linkerUsesTargetStorage) CLPrint("\tuses target storage, \n");
+            if (df->dropinflags & linkerUnmangles) CLPrint("\tsupports unmangling, \n");
+            if (df->dropinflags & magicCapLinker) CLPrint("\tis Magic Cap linker, \n");
+            if (df->dropinflags & linkAlwaysReload) CLPrint("\tshould be always reloaded, \n");
+            if (df->dropinflags & linkRequiresProjectBuildStartedMsg) CLPrint("\trequires project build started msg, \n");
+            if (df->dropinflags & linkRequiresTargetBuildStartedMsg) CLPrint("\trequires target build started msg, \n");
+            if (df->dropinflags & linkRequiresSubProjectBuildStartedMsg) CLPrint("\trequires subproject build started msg, \n");
+            if (df->dropinflags & linkRequiresFileListBuildStartedMsg) CLPrint("\trequires file list build started msg, \n");
+            if (df->dropinflags & linkRequiresTargetLinkStartedMsg) CLPrint("\trequires target link started msg, \n");
+            if (df->dropinflags & linkerWantsPreRunRequest) CLPrint("\twants pre-run request, \n");
+        }
+
+        CLPrint("\n");
+    }
+
+    return 1;
+}
+
+Plugin *Plugins_MatchName(Plugin *list, const char *name) {
+    Plugin *scan;
+
+    scan = list ? list : pluginlist;
+    while (scan) {
+        if (Plugin_MatchesName(scan, name))
+            break;
+        scan = scan->next;
+    }
+
+    return scan;
+}
+
+Plugin *Plugins_CL_MatchTarget(Plugin *list, OSType cpu, OSType os, OSType type, OSType lang) {
+    Plugin *scan;
+    Plugin *pick;
+
+    scan = list ? list : pluginlist;
+    pick = NULL;
+    while (scan) {
+        if (scan->cl_cb) {
+            if (Plugin_CL_MatchesTarget(scan, cpu, os, 0) && Plugin_MatchesType(scan, type, lang, 0)) {
+                pick = scan;
+                if (Plugin_CL_MatchesTarget(scan, cpu, os, 1) && Plugin_MatchesType(scan, type, lang, 1))
+                    break;
+            }
+        }
+        scan = scan->next;
+    }
+
+    return pick;
+}
+
+Plugin *Plugins_CL_MatchFileType(Plugin *list, OSType type, const char *ext, Boolean exact) {
+    Plugin *scan;
+
+    scan = list ? list : pluginlist;
+    while (scan) {
+        if (Plugin_CL_MatchesFileType(scan, type, ext, exact))
+            break;
+        scan = scan->next;
+    }
+
+    return scan;
+}
+
+Plugin *Plugins_GetPluginForFile(Plugin *list, OSType plugintype, OSType cpu, OSType os, OSType type, const char *ext, OSType lang) {
+    Plugin *scan;
+    Plugin *pick;
+
+    scan = list ? list : pluginlist;
+    pick = NULL;
+    while (scan) {
+        if (Plugin_MatchesType(scan, plugintype, lang, 1) && scan->cl_cb) {
+            if (Plugin_CL_MatchesTarget(scan, cpu, os, 0) && Plugin_CL_MatchesFileType(scan, type, ext, 0)) {
+                pick = scan;
+                if (Plugin_CL_MatchesTarget(scan, cpu, os, 1) && Plugin_CL_MatchesFileType(scan, type, ext, 1))
+                    break;
+            }
+        }
+        scan = scan->next;
+    }
+
+    return pick;
+}
+
+Plugin *Plugins_GetLinker(Plugin *list, OSType cpu, OSType os) {
+    Plugin *scan;
+    Plugin *pick;
+
+    scan = list ? list : pluginlist;
+    pick = NULL;
+    while (scan) {
+        if (Plugin_MatchesType(scan, CWDROPINLINKERTYPE, Lang_Any, 1)) {
+            if (!(Plugin_GetDropInFlags(scan)->dropinflags & (isPreLinker | isPostLinker))) {
+                if (Plugin_CL_MatchesTarget(scan, cpu, os, 0)) {
+                    pick = scan;
+                    if (Plugin_CL_MatchesTarget(scan, cpu, os, 1))
+                        break;
+                }
+            }
+        }
+        scan = scan->next;
+    }
+
+    return pick;
+}
+
+Plugin *Plugins_GetPreLinker(Plugin *list, OSType cpu, OSType os) {
+    Plugin *scan;
+    Plugin *pick;
+
+    scan = list ? list : pluginlist;
+    pick = NULL;
+    while (scan) {
+        if (Plugin_MatchesType(scan, CWDROPINLINKERTYPE, Lang_Any, 1)) {
+            if (Plugin_GetDropInFlags(scan)->dropinflags & isPreLinker) {
+                if (Plugin_CL_MatchesTarget(scan, cpu, os, 0)) {
+                    pick = scan;
+                    if (Plugin_CL_MatchesTarget(scan, cpu, os, 1))
+                        break;
+                }
+            }
+        }
+        scan = scan->next;
+    }
+
+    return pick;
+}
+
+Plugin *Plugins_GetPostLinker(Plugin *list, OSType cpu, OSType os) {
+    Plugin *scan;
+    Plugin *pick;
+
+    scan = list ? list : pluginlist;
+    pick = NULL;
+    while (scan) {
+        if (Plugin_MatchesType(scan, CWDROPINLINKERTYPE, Lang_Any, 1)) {
+            if (Plugin_GetDropInFlags(scan)->dropinflags & isPostLinker) {
+                if (Plugin_CL_MatchesTarget(scan, cpu, os, 0)) {
+                    pick = scan;
+                    if (Plugin_CL_MatchesTarget(scan, cpu, os, 1))
+                        break;
+                }
+            }
+        }
+        scan = scan->next;
+    }
+
+    return pick;
+}
+
+Plugin *Plugins_GetParserForPlugin(Plugin *list, OSType style, int numPlugins, CLPluginInfo *plugins, OSType cpu, OSType os, int numPanels, const char **panelNames) {
+    Plugin *scan;
+    Plugin *pick;
+    Boolean allpanels;
+    Boolean hasplugintype;
+    Boolean *supports;
+
+    scan = list ? list : pluginlist;
+    pick = NULL;
+    supports = alloca(numPanels);
+
+    while (scan) {
+        if (Plugin_MatchesType(scan, CWDROPINPARSERTYPE, style, 1)) {
+            int idx;
+            int pnl;
+            hasplugintype = 0;
+            for (idx = 0; idx < numPlugins; idx++) {
+                if (plugins[idx].plugintype != CWDROPINPARSERTYPE && plugins[idx].plugintype != CWDROPINDRIVERTYPE && !plugins[idx].storeCommandLine) {
+                    if (Plugin_Pr_MatchesPlugin(scan, &plugins[idx], cpu, os))
+                        hasplugintype = 1;
+                }
+            }
+
+            if (hasplugintype) {
+                pick = scan;
+                allpanels = 1;
+                for (pnl = 0; pnl < numPanels; pnl++) {
+                    allpanels &= (supports[pnl] = Plugin_Pr_MatchesPanels(scan, 1, &panelNames[pnl]));
+                }
+
+                if (allpanels)
+                    break;
+            }
+        }
+        scan = scan->next;
+    }
+
+    if (pick && !allpanels) {
+        int idx;
+        CLReport(5);
+
+        for (idx = 0; idx < numPanels; idx++) {
+            if (!supports[idx])
+                CLReport(6, panelNames[idx]);
+        }
+    }
+
+    return pick;
+}
+
+Plugin *Plugins_GetCompilerForLinker(Plugin *list, Plugin *linker, OSType type, const char *ext, OSType edit) {
+    Plugin *scan;
+    Plugin *pick;
+
+    scan = list ? list : pluginlist;
+    pick = NULL;
+
+    while (scan) {
+        if (Plugin_MatchesType(scan, CWDROPINCOMPILERTYPE, edit, 1)) {
+            if (Plugin_CL_MatchesFileType(scan, type, ext, 0) && Plugins_CL_HaveMatchingTargets(scan, linker, 0)) {
+                pick = scan;
+                if (Plugin_CL_MatchesFileType(scan, type, ext, 1) && Plugins_CL_HaveMatchingTargets(scan, linker, 1))
+                    break;
+            }
+        }
+        scan = scan->next;
+    }
+
+    return pick;
+}
+
+int Plugins_GetPluginList(Plugin *list, int *numPlugins, CLPluginInfo **pluginInfo) {
+    Plugin *scan;
+    int idx;
+    const DropInFlags *df;
+    const VersionInfo *vi;
+
+    scan = list ? list : pluginlist;
+    idx = 0;
+    while (scan) {
+        scan = scan->next;
+        idx++;
+    }
+
+    *numPlugins = idx;
+    *pluginInfo = xmalloc(NULL, sizeof(CLPluginInfo) * idx);
+    if (!*pluginInfo)
+        return 0;
+
+    scan = list ? list : pluginlist;
+    idx = 0;
+    while (scan) {
+        df = Plugin_GetDropInFlags(scan);
+        vi = Plugin_GetVersionInfo(scan);
+#line 1270
+        OPTION_ASSERT(df != NULL);
+        OPTION_ASSERT(vi != NULL);
+        (*pluginInfo)[idx].plugintype = df->dropintype;
+        (*pluginInfo)[idx].language = df->edit_language;
+        (*pluginInfo)[idx].dropinflags = df->dropinflags;
+        (*pluginInfo)[idx].version = scan->cached_ascii_version;
+        (*pluginInfo)[idx].storeCommandLine = df->dropinflags & 1;
+        scan = scan->next;
+        idx++;
+    }
+
+    return 1;
+}
+
+int Plugins_GetPrefPanelUnion(Plugin *list, int *numPanels, const char ***panelNames) {
+    Plugin *scan;
+    int tempNum;
+    int idx;
+    const char **tempPanels;
+
+    scan = list ? list : pluginlist;
+
+    tempNum = 0;
+    while (scan) {
+        const CWPanelList *pl;
+        pl = Plugin_GetPanelList(scan);
+        tempNum += pl->count;
+        scan = scan->next;
+    }
+
+    tempPanels = xmalloc("plugin preference union", sizeof(const char *) * tempNum);
+
+    idx = 0;
+    scan = list ? list : pluginlist;
+    while (scan) {
+        const CWPanelList *pl;
+        int step;
+
+        pl = Plugin_GetPanelList(scan);
+        for (step = 0; step < pl->count; step++) {
+            int cmp;
+            for (cmp = 0; cmp < idx; cmp++) {
+                if (!ustrcmp(tempPanels[cmp], pl->names[step]))
+                    break;
+            }
+
+            if (cmp >= idx)
+                tempPanels[idx++] = pl->names[step];
+        }
+
+        scan = scan->next;
+    }
+
+    *panelNames = xmalloc(NULL, idx * sizeof(const char *));
+    if (!*panelNames)
+        return 0;
+
+    *panelNames = xrealloc("plugin preference union", tempPanels, idx * sizeof(const char *));
+    *numPanels = idx;
+    return 1;
+}
+
+int Plugin_AddFileTypeMappings(Plugin *pl, OSFileTypeMappings **mlist) {
+    const OSFileTypeMappingList *ftml;
+
+    ftml = Plugin_GetFileTypeMappingList(pl);
+    if (!ftml) {
+        return 1;
+    } else {
+        AddFileTypeMappingList(NULL, ftml);
+        return 1;
+    }
+}
+
+int Plugins_AddFileTypeMappingsForTarget(Plugin *list, OSFileTypeMappings **mlist, OSType cpu, OSType os) {
+    if (!list)
+        list = pluginlist;
+
+    while (list) {
+        if (!list->cl_cb || Plugin_CL_MatchesTarget(list, cpu, os, 0))
+            Plugin_AddFileTypeMappings(list, mlist);
+        list = list->next;
+    }
+
+    return 1;
+}
+
+SInt16 Plugin_Call(Plugin *pl, void *context) {
+    if (pl->cb->main)
+        return pl->cb->main(context);
+    else
+        return cwErrRequestFailed;
+}
+
diff --git a/command_line/CmdLine/Src/Project/CLAccessPaths.c b/command_line/CmdLine/Src/Project/CLAccessPaths.c
index e69de29..1ffcd1d 100644
--- a/command_line/CmdLine/Src/Project/CLAccessPaths.c
+++ b/command_line/CmdLine/Src/Project/CLAccessPaths.c
@@ -0,0 +1,525 @@
+#include "cmdline.h"
+
+// TODO check where this should be!
+Paths FrameworkPaths;
+Frameworks FrameworkInfo;
+
+Path *Path_Init(const OSPathSpec *dir, Path *path) {
+    path->spec = xmalloc(NULL, sizeof(OSPathSpec));
+    *path->spec = *dir;
+    path->recursive = NULL;
+    path->dirlist = NULL;
+    path->flags = 0;
+    return path;
+}
+
+Path *Path_New(const OSPathSpec *dir) {
+    Path *path;
+    path = xmalloc(NULL, sizeof(Path));
+    return Path_Init(dir, path);
+}
+
+void Path_Free(Path *path) {
+    if (path) {
+        if (path->spec)
+            xfree(path->spec);
+        if (path->recursive) {
+            Paths_Terminate(path->recursive);
+            xfree(path->recursive);
+        }
+        xfree(path);
+    }
+}
+
+Boolean Paths_Initialize(Paths *paths) {
+#line 52
+    OPTION_ASSERT(paths != NULL);
+
+    memset(paths, 0, sizeof(Paths));
+    paths->pathsArray = NULL;
+    return 1;
+}
+
+Boolean Paths_Terminate(Paths *paths) {
+    UInt16 index;
+
+#line 63
+    OPTION_ASSERT(paths != NULL);
+
+    if (paths->pathsArray) {
+        for (index = 0; index < paths->pathsCount; index++)
+            Path_Free(paths->pathsArray[index]);
+        xfree(paths->pathsArray);
+    }
+
+    paths->pathsArray = NULL;
+    return 1;
+}
+
+static Boolean Paths_GrowPaths(Paths *paths, UInt16 *index) {
+    Path **newArray;
+
+#line 84
+    OPTION_ASSERT(paths != NULL);
+
+    if (paths->pathsCount >= paths->arraySize) {
+        paths->arraySize += 20;
+        newArray = xrealloc("access paths", paths->pathsArray, sizeof(Path *) * paths->arraySize);
+        paths->pathsArray = newArray;
+    }
+
+    *index = paths->pathsCount++;
+    return 1;
+}
+
+Boolean Paths_AddPath(Paths *paths, Path *path) {
+    UInt16 ni;
+
+    if (Paths_GrowPaths(paths, &ni)) {
+        paths->pathsArray[ni] = path;
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+Boolean Paths_InsertPath(Paths *paths, UInt16 index, Path *path) {
+    UInt16 ni;
+
+    if (Paths_GrowPaths(paths, &ni)) {
+        if (index > ni) {
+            index = (ni != 0) ? (ni - 1) : 0;
+        }
+        memmove(&paths->pathsArray[index + 1], &paths->pathsArray[index], sizeof(Path *) * (paths->pathsCount - index));
+        paths->pathsArray[index] = path;
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+Boolean Paths_RemovePath(Paths *paths, UInt16 index) {
+    if (index >= paths->pathsCount)
+        return 0;
+
+    memmove(&paths->pathsArray[index], &paths->pathsArray[index + 1], sizeof(Path *) * (paths->pathsCount - index - 1));
+    paths->pathsCount--;
+    return 1;
+}
+
+Boolean Paths_DeletePath(Paths *paths, UInt16 index) {
+    if (index >= paths->pathsCount)
+        return 0;
+
+    Path_Free(paths->pathsArray[index]);
+    return Paths_RemovePath(paths, index);
+}
+
+Path *Paths_GetPath(Paths *paths, UInt16 pathnum) {
+#line 151
+    OPTION_ASSERT(paths != NULL);
+
+    if (pathnum < paths->pathsCount)
+        return paths->pathsArray[pathnum];
+    else
+        return NULL;
+}
+
+UInt16 Paths_Count(const Paths *paths) {
+#line 161
+    OPTION_ASSERT(paths != NULL);
+
+    return paths->pathsCount;
+}
+
+Boolean Paths_FindPath(const Paths *paths, const Path *path) {
+    UInt16 idx;
+
+#line 169
+    OPTION_ASSERT(paths != NULL);
+
+    for (idx = 0; idx < paths->pathsCount; idx++) {
+        if (paths->pathsArray[idx] == path)
+            return 1;
+    }
+
+    return 0;
+}
+
+Path *Paths_FindPathSpec(const Paths *paths, const OSPathSpec *dir) {
+    UInt16 idx;
+    Path *path;
+
+#line 182
+    OPTION_ASSERT(paths != NULL);
+
+    for (idx = 0; idx < paths->pathsCount; idx++) {
+        path = paths->pathsArray[idx];
+        if (OS_EqualPathSpec(path->spec, dir))
+            return path;
+    }
+
+    return NULL;
+}
+
+static Boolean GatherRecurse(Paths *list, Path *path) {
+    int err;
+    OSOpenedDir rf;
+    OSSpec ent;
+    int count;
+    char filename[64];
+    Boolean isfile;
+    char *nptr;
+    char *eptr;
+    UInt16 added;
+    Path *nw;
+
+    count = 0;
+    if (CheckForUserBreak())
+        return 1;
+
+    err = OS_OpenDir(path->spec, &rf);
+    while (!err) {
+        err = OS_ReadDir(&rf, &ent, filename, &isfile);
+        if (!err) {
+            if (!isfile) {
+                nw = Path_New(&ent.path);
+                nptr = OS_GetFileNamePtr(filename);
+                eptr = nptr + strlen(nptr) - 1;
+                if (eptr[0] == OS_PATHSEP)
+                    eptr--;
+                if (eptr > nptr && *nptr == '(' && *eptr == ')')
+                    continue;
+
+                if (!Paths_AddPath(list, nw))
+                    break;
+                added = Paths_Count(list) - 1;
+                if (!GatherRecurse(list, nw))
+                    Paths_DeletePath(list, added);
+            } else {
+                if (!(++count % 50) && CheckForUserBreak())
+                    return 0;
+            }
+        }
+    }
+    OS_CloseDir(&rf);
+    return count > 0;
+}
+
+Boolean Paths_GatherRecurse(Path *path) {
+    path->recursive = xcalloc(NULL, sizeof(Paths));
+    GatherRecurse(path->recursive, path);
+    return Paths_Count(path->recursive) != 0;
+}
+
+int Paths_CountRecurse(Paths *paths) {
+    UInt16 idx;
+    int mine;
+    Path *path;
+
+    mine = Paths_Count(paths);
+    for (idx = 0; idx < mine; idx++) {
+        path = Paths_GetPath(paths, idx);
+#line 336
+        OPTION_ASSERT(path);
+
+        if (path->recursive)
+            mine += Paths_CountRecurse(path->recursive);
+    }
+
+    return mine;
+}
+
+static void CopyRecurseFSS(FSSpec **list, Paths *paths, UInt16 *count) {
+    UInt16 idx;
+    OSSpec spec;
+    Path *path;
+
+    for (idx = 0; idx < Paths_Count(paths); idx++) {
+        path = Paths_GetPath(paths, idx);
+#line 353
+        OPTION_ASSERT(path && *count > 0);
+        OS_MakeSpecWithPath(path->spec, NULL, 0, &spec);
+#line 355
+        OPTION_ASSERT(OS_OSSpec_To_FSSpec(&spec, *list));
+        (*list)++;
+        (*count)--;
+        if (path->recursive)
+            CopyRecurseFSS(list, path->recursive, count);
+    }
+}
+
+void Paths_CopyRecurseFSS(FSSpec *list, Paths *paths, UInt16 count) {
+    CopyRecurseFSS(&list, paths, &count);
+#line 367
+    OPTION_ASSERT(count == 0);
+}
+
+static Boolean Frameworks_Initialize(Frameworks *fws) {
+#line 405
+    OPTION_ASSERT(fws != NULL);
+
+    memset(fws, 0, sizeof(Frameworks));
+    fws->fwsArray = NULL;
+    return 1;
+}
+
+static Boolean Frameworks_Grow(Frameworks *fws, UInt16 *index) {
+    Paths_FWInfo **newArray;
+
+#line 418
+    OPTION_ASSERT(fws != NULL);
+
+    if (fws->fwsCount >= fws->arraySize) {
+        fws->arraySize += 20;
+        newArray = xrealloc("access frameworks", fws->fwsArray, sizeof(Paths_FWInfo *) * fws->arraySize);
+        fws->fwsArray = newArray;
+    }
+
+    *index = fws->fwsCount++;
+    return 1;
+}
+
+static Boolean Frameworks_Add(Frameworks *fws, Paths_FWInfo *info) {
+    UInt16 ni;
+
+    if (Frameworks_Grow(fws, &ni)) {
+        fws->fwsArray[ni] = info;
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+static Paths_FWInfo *Framework_Init(OSSpec *dir, const char *name, const char *version, Paths_FWInfo *info, Path *p, Boolean hidden) {
+    info->fileSpec = *dir;
+    if (version && version[0])
+        strncpy(info->version.s, version, sizeof(info->version.s));
+    else
+        info->version.s[0] = 0;
+    strncpy(info->name.s, name, sizeof(info->name.s));
+    info->path = p;
+    info->hidden = hidden;
+    return info;
+}
+
+static Paths_FWInfo *Framework_New(OSSpec *dir, const char *name, const char *version, Path *p, Boolean hidden) {
+    Paths_FWInfo *info;
+    info = xmalloc(NULL, sizeof(Paths_FWInfo));
+    return Framework_Init(dir, name, version, info, p, hidden);
+}
+
+static Boolean CheckForFileInFrameworkDir(char *out, const char *framework_path, OSPathSpec *osps, const char *fname) {
+    int err;
+    OSSpec oss;
+
+    sprintf(out, "%s/%s", framework_path, fname);
+    err = OS_MakeSpecWithPath(osps, out, 0, &oss);
+    if (err == 0 && OS_IsFile(&oss))
+        return 1;
+
+    sprintf(out, "%s/Headers/%s", framework_path, fname);
+    err = OS_MakeSpecWithPath(osps, out, 0, &oss);
+    if (err == 0 && OS_IsFile(&oss))
+        return 1;
+
+    sprintf(out, "%s/Resources/%s", framework_path, fname);
+    err = OS_MakeSpecWithPath(osps, out, 0, &oss);
+    if (err == 0 && OS_IsFile(&oss))
+        return 1;
+
+    sprintf(out, "%s/Resources/%s", framework_path, fname);
+    err = OS_MakeSpecWithPath(osps, out, 0, &oss);
+    if (err == 0 && OS_IsFile(&oss))
+        return 1;
+
+    return 0;
+}
+
+static Boolean CheckForFileInFramework(char *out, int i, const char *fname) {
+    Paths_FWInfo *info;
+    char framework_path[256];
+
+    info = Frameworks_GetInfo(i);
+    if (strlen(info->version.s))
+        sprintf(framework_path, "%s.framework/Versions/%s", info->name.s, info->version.s);
+    else
+        sprintf(framework_path, "%s.framework", info->name.s);
+
+    if (CheckForFileInFrameworkDir(out, framework_path, info->path->spec, fname))
+        return 1;
+    else
+        return 0;
+}
+
+Boolean MakeFrameworkPath(char *out, const char *filename, Path *globalpath) {
+    Paths_FWInfo *info;
+    int err;
+    char *end;
+    char *fname;
+    char framework_name[256];
+    char framework_path[256];
+    const char *s;
+    char *d;
+    int i;
+    int n;
+
+    n = Frameworks_GetCount();
+    end = strchr(filename, OS_PATHSEP);
+    if (!end) {
+        for (i = 0; i < n; i++) {
+            info = Frameworks_GetInfo(i);
+            if (!info->hidden && CheckForFileInFramework(out, i, filename))
+                return 1;
+        }
+        return 0;
+    }
+
+    fname = end + 1;
+    s = filename;
+    d = framework_name;
+    while (s < end)
+        *(d++) = *(s++);
+    *d = 0;
+
+    for (i = 0; i < n; i++) {
+        if (!strcmp(Frameworks_GetInfo(i)->name.s, framework_name)) {
+            return CheckForFileInFramework(out, i, fname) != 0;
+        }
+    }
+
+    if (globalpath) {
+        OSSpec oss;
+        sprintf(framework_path, "../Frameworks/%s.framework", framework_name);
+        err = OS_MakeSpecWithPath(globalpath->spec, framework_path, 0, &oss);
+        if (!err && OS_IsDir(&oss)) {
+            if (CheckForFileInFrameworkDir(out, framework_path, globalpath->spec, fname))
+                return 1;
+        }
+    }
+
+    n = Paths_Count(&FrameworkPaths);
+    sprintf(framework_path, "%s.framework", framework_name);
+    for (i = 0; i < n; i++) {
+        OSSpec oss;
+        Path *p;
+        p = Paths_GetPath(&FrameworkPaths, i);
+        err = OS_MakeSpecWithPath(p->spec, framework_path, 0, &oss);
+        if (!err && OS_IsDir(&oss)) {
+            if (CheckForFileInFrameworkDir(out, framework_path, p->spec, fname)) {
+                Frameworks_AddFramework(framework_name, NULL, 1);
+                return 1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+void Frameworks_AddPath(const OSPathSpec *oss) {
+    Paths_AddPath(&FrameworkPaths, Path_New(oss));
+}
+
+int Frameworks_AddFramework(const char *name, const char *version, Boolean hidden) {
+    char fullname[256];
+    int i;
+    Path *p;
+    int n_paths;
+    OSSpec oss;
+    int err;
+
+    sprintf(fullname, "%s.framework", name);
+    n_paths = Paths_Count(&FrameworkPaths);
+    for (i = 0; i < n_paths; i++) {
+        p = Paths_GetPath(&FrameworkPaths, i);
+        err = OS_MakeSpecWithPath(p->spec, fullname, 0, &oss);
+        if (!err && OS_IsDir(&oss)) {
+            if (Frameworks_Add(&FrameworkInfo, Framework_New(&oss, name, version, p, hidden))) {
+                if (version && strlen(version)) {
+                    sprintf(fullname, "Versions/%s/Frameworks", version);
+                    err = OS_MakeSpecWithPath(&oss.path, fullname, 0, &oss);
+                } else {
+                    err = OS_MakeSpecWithPath(&oss.path, "Frameworks", 0, &oss);
+                }
+                if (!err && OS_IsDir(&oss))
+                    Frameworks_AddPath(&oss.path);
+                return 1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+void Framework_GetEnvInfo() {
+    char path[256];
+    char *env;
+    char *ptr;
+    OSSpec spec;
+    char name[64];
+    char version[16];
+    int err;
+    Boolean is_file;
+
+#line 672
+    OPTION_ASSERT(Paths_Initialize(&FrameworkPaths) == 1);
+    OPTION_ASSERT(Frameworks_Initialize(&FrameworkInfo) == 1);
+
+    env = getenv("MWFrameworkPaths");
+    if (env) {
+        while (*env) {
+            ptr = path;
+            while (*env && *env != ':' && (ptr + 1) < &path[sizeof(path)])
+                *(ptr++) = *(env++);
+            *ptr = 0;
+            while (*env && *env == ':')
+                env++;
+
+            if (path[0]) {
+                if (strlen(path) >= sizeof(path)) {
+                    CLReportError(64, sizeof(path), path);
+                } else {
+                    err = OS_MakeSpec(path, &spec, &is_file);
+                    if (!is_file && !err) {
+                        Frameworks_AddPath(&spec.path);
+                    } else {
+                        CLReportError(23, path);
+                    }
+                }
+            }
+        }
+    }
+
+    env = getenv("MWFrameworkVersions");
+    if (env) {
+        while (*env) {
+            ptr = name;
+            while (*env && *env != ':' && (ptr + 1) < &name[sizeof(name)])
+                *(ptr++) = *(env++);
+            *ptr = 0;
+            while (*env && *env == ':')
+                env++;
+
+            ptr = version;
+            while (*env && *env != ',' && (ptr + 1) < &version[sizeof(version)])
+                *(ptr++) = *(env++);
+            *ptr = 0;
+            while (*env && *env == ',')
+                env++;
+
+            if (name[0])
+                Frameworks_AddFramework(name, version, 0);
+        }
+    }
+}
+
+int Frameworks_GetCount() {
+    return FrameworkInfo.fwsCount;
+}
+
+Paths_FWInfo *Frameworks_GetInfo(int which) {
+#line 762
+    OPTION_ASSERT(FrameworkInfo.fwsArray);
+    OPTION_ASSERT(FrameworkInfo.fwsCount > which);
+    return FrameworkInfo.fwsArray[which];
+}
diff --git a/command_line/CmdLine/Src/Project/CLFiles.c b/command_line/CmdLine/Src/Project/CLFiles.c
index e69de29..a13deaf 100644
--- a/command_line/CmdLine/Src/Project/CLFiles.c
+++ b/command_line/CmdLine/Src/Project/CLFiles.c
@@ -0,0 +1,165 @@
+#include "cmdline.h"
+
+File *File_New() {
+    File *file;
+    file = xmalloc(NULL, sizeof(File));
+    if (!file) {
+        return NULL;
+    } else {
+        memset(file, 0, sizeof(File));
+        return file;
+    }
+}
+
+void File_Free(File *file) {
+    if (file) {
+        if (file->textdata) {
+            DisposeHandle(file->textdata);
+            file->textdata = NULL;
+        }
+        if (file->objectdata) {
+            DisposeHandle(file->objectdata);
+            file->objectdata = NULL;
+        }
+        if (file->browsedata) {
+            DisposeHandle(file->browsedata);
+            file->browsedata = NULL;
+        }
+        xfree(file);
+    }
+}
+
+Boolean Files_Initialize(Files *this) {
+#line 47
+    OPTION_ASSERT(this != NULL);
+    return 1;
+}
+
+Boolean Files_Terminate(Files *this) {
+    File *file;
+    File *next;
+
+#line 56
+    OPTION_ASSERT(this != NULL);
+
+    for (file = this->fileList; file; file = next) {
+        next = file->next;
+        File_Free(file);
+    }
+
+    return 1;
+}
+
+Boolean Files_AddFile(Files *this, File *file) {
+    return Files_InsertFile(this, file, this->fileCount);
+}
+
+Boolean Files_InsertFile(Files *this, File *file, SInt32 position) {
+    File **scan;
+
+#line 80
+    OPTION_ASSERT(this != NULL);
+    OPTION_ASSERT(file != NULL);
+
+    if (position < 0)
+        position = 0;
+    else if (position > this->fileCount)
+        position = this->fileCount;
+
+    scan = &this->fileList;
+    while (position > 0) {
+        scan = &(*scan)->next;
+        position--;
+    }
+
+    file->filenum = this->fileCount++;
+    file->next = *scan;
+    *scan = file;
+    return 1;
+}
+
+File *Files_GetFile(Files *this, SInt32 filenum) {
+    File *file;
+
+#line 104
+    OPTION_ASSERT(this != NULL);
+    OPTION_ASSERT(filenum >= 0);
+
+    file = this->fileList;
+    while (file && file->filenum != filenum)
+        file = file->next;
+    return file;
+}
+
+File *Files_FindFile(Files *this, OSSpec *spec) {
+    File *file;
+
+    file = this->fileList;
+    while (file && !OS_EqualSpec(&file->srcfss, spec))
+        file = file->next;
+    return file;
+}
+
+int Files_Count(Files *this) {
+#line 127
+    OPTION_ASSERT(this != NULL);
+
+    return this->fileCount;
+}
+
+Boolean VFiles_Initialize(VFile **list) {
+    *list = NULL;
+    return 1;
+}
+
+void VFiles_Terminate(VFile **list) {
+    VFile *next;
+
+    while (*list) {
+        next = (*list)->next;
+        DisposeHandle((*list)->data);
+        xfree(*list);
+        list = &next;
+    }
+
+    *list = NULL;
+}
+
+VFile *VFile_New(const char *name, Handle data) {
+    VFile *vf;
+
+    vf = xmalloc(NULL, sizeof(VFile));
+    if (!vf)
+        return NULL;
+
+    strncpy(vf->displayName, name, sizeof(vf->displayName));
+    vf->displayName[sizeof(vf->displayName) - 1] = 0;
+
+    vf->data = NewHandle(0);
+    if (!vf->data || HandAndHand(data, vf->data)) {
+        xfree(vf);
+        return NULL;
+    }
+
+    FixTextHandle(vf->data);
+    vf->next = NULL;
+    return vf;
+}
+
+Boolean VFiles_Add(VFile **list, VFile *entry) {
+    VFile **scan = list;
+    while (*scan)
+        scan = &(*scan)->next;
+    *scan = entry;
+    return 1;
+}
+
+VFile *VFiles_Find(VFile *list, const char *name) {
+    VFile *scan = list;
+    while (scan) {
+        if (!strcmp(scan->displayName, name))
+            break;
+        scan = scan->next;
+    }
+    return scan;
+}
diff --git a/command_line/CmdLine/Src/Project/CLOverlays.c b/command_line/CmdLine/Src/Project/CLOverlays.c
index e69de29..3437366 100644
--- a/command_line/CmdLine/Src/Project/CLOverlays.c
+++ b/command_line/CmdLine/Src/Project/CLOverlays.c
@@ -0,0 +1,296 @@
+#include "cmdline.h"
+
+Boolean Overlays_Initialize(Overlays *this) {
+    OvlGroup *grp;
+    Overlay *ovl;
+    OvlAddr addr;
+    SInt32 idx;
+
+#line 24
+    OPTION_ASSERT(this);
+
+    this->groups = NULL;
+    this->lastgrp = NULL;
+    this->grpcnt = 0;
+    addr.hi = 0;
+    addr.lo = 0;
+
+    grp = OvlGroup_New("main_application", addr);
+    if (!grp)
+        return 0;
+
+    ovl = Overlay_New("MAIN");
+    if (!ovl)
+        return 0;
+
+    OvlGroup_AddOverlay(grp, ovl, &idx);
+#line 42
+    OPTION_ASSERT(idx==0);
+
+    Overlays_AddOvlGroup(this, grp, &idx);
+#line 45
+    OPTION_ASSERT(idx==0);
+
+    return 1;
+}
+
+Boolean Overlays_Terminate(Overlays *this) {
+    OvlGroup *grp;
+    OvlGroup *nxtgrp;
+
+#line 54
+    OPTION_ASSERT(this);
+
+    for (grp = this->groups; grp; grp = nxtgrp) {
+        nxtgrp = grp->next;
+        OvlGroup_Delete(grp);
+        xfree(grp);
+    }
+
+    this->groups = NULL;
+    return 1;
+}
+
+Boolean Overlays_AddOvlGroup(Overlays *this, OvlGroup *grp, SInt32 *grpnum) {
+#line 70
+    OPTION_ASSERT(this);
+    OPTION_ASSERT(grp);
+
+    if (this->groups == NULL)
+        this->groups = grp;
+    else
+        this->lastgrp->next = grp;
+    this->lastgrp = grp;
+
+    if (grpnum)
+        *grpnum = this->grpcnt;
+    this->grpcnt++;
+
+    return 1;
+}
+
+OvlGroup *Overlays_GetOvlGroup(Overlays *this, SInt32 grpnum) {
+    OvlGroup *grp;
+    SInt32 cnt = 0;
+
+#line 93
+    OPTION_ASSERT(this);
+
+    grp = this->groups;
+    while (grp && cnt < grpnum) {
+        grp = grp->next;
+        cnt++;
+    }
+
+    if (cnt == grpnum)
+        return grp;
+    else
+        return NULL;
+}
+
+SInt32 Overlays_CountGroups(Overlays *this) {
+    OvlGroup *scan;
+    int num = 0;
+
+#line 112
+    OPTION_ASSERT(this);
+
+    scan = this->groups;
+    while (scan) {
+        scan = scan->next;
+        num++;
+    }
+
+    return num;
+}
+
+Boolean Overlays_AddFileToOverlay(Overlays *this, SInt32 grpnum, SInt32 ovlnum, SInt32 filenum) {
+    Overlay *oly;
+
+#line 130
+    OPTION_ASSERT(this);
+
+    oly = Overlays_GetOverlayInGroup(this, grpnum, ovlnum);
+    if (oly)
+        return Overlay_AddFile(oly, filenum, NULL);
+    else
+        return 0;
+}
+
+Overlay *Overlays_GetOverlayInGroup(Overlays *this, SInt32 grpnum, SInt32 ovlnum) {
+    OvlGroup *grp;
+
+#line 144
+    OPTION_ASSERT(this);
+
+    grp = Overlays_GetOvlGroup(this, grpnum);
+    if (grp)
+        return OvlGroup_GetOverlay(grp, ovlnum);
+    else
+        return NULL;
+}
+
+SInt32 Overlays_GetFileInOverlay(Overlays *this, SInt32 grpnum, SInt32 ovlnum, SInt32 filnum) {
+    Overlay *oly;
+
+#line 160
+    OPTION_ASSERT(this);
+
+    oly = Overlays_GetOverlayInGroup(this, grpnum, ovlnum);
+    if (oly)
+        return Overlay_GetFile(oly, filnum);
+    else
+        return -1;
+}
+
+OvlGroup *OvlGroup_New(const char *name, OvlAddr addr) {
+    OvlGroup *grp;
+
+#line 175
+    OPTION_ASSERT(name);
+
+    grp = xmalloc(NULL, sizeof(OvlGroup));
+    if (grp) {
+        strncpy(grp->name, name, sizeof(grp->name));
+        grp->name[sizeof(grp->name) - 1] = 0;
+        grp->addr = addr;
+        grp->lastoly = NULL;
+        grp->olys = NULL;
+        grp->olycnt = 0;
+        grp->next = NULL;
+    } else {
+#line 188
+        DO_INTERNAL_ERROR("Could not allocate %s", "overlay group");
+    }
+    return grp;
+}
+
+void OvlGroup_Delete(OvlGroup *grp) {
+    Overlay *scan;
+    Overlay *next;
+
+#line 197
+    OPTION_ASSERT(grp);
+
+    for (scan = grp->olys; scan; scan = next) {
+        next = scan->next;
+        Overlay_Delete(scan);
+        xfree(scan);
+    }
+
+    grp->olys = NULL;
+}
+
+Boolean OvlGroup_AddOverlay(OvlGroup *this, Overlay *oly, SInt32 *olynum) {
+#line 211
+    OPTION_ASSERT(this);
+    OPTION_ASSERT(oly);
+
+    if (!this->lastoly)
+        this->olys = oly;
+    else
+        this->lastoly->next = oly;
+    this->lastoly = oly;
+
+    if (olynum)
+        *olynum = this->olycnt;
+    this->olycnt++;
+
+    return 1;
+}
+
+Overlay *OvlGroup_GetOverlay(OvlGroup *this, SInt32 olynum) {
+    Overlay *oly;
+    SInt32 cnt = 0;
+
+#line 234
+    OPTION_ASSERT(this);
+
+    oly = this->olys;
+    while (oly && cnt < olynum) {
+        oly = oly->next;
+        cnt++;
+    }
+
+    if (cnt == olynum)
+        return oly;
+    else
+        return NULL;
+}
+
+SInt32 OvlGroup_CountOverlays(OvlGroup *this) {
+    Overlay *scan;
+    int num = 0;
+
+#line 254
+    OPTION_ASSERT(this);
+
+    scan = this->olys;
+    while (scan) {
+        scan = scan->next;
+        num++;
+    }
+
+    return num;
+}
+
+Overlay *Overlay_New(const char *name) {
+    Overlay *oly;
+
+    oly = xmalloc(NULL, sizeof(Overlay));
+    if (oly) {
+        strncpy(oly->name, name, sizeof(oly->name));
+        oly->name[sizeof(oly->name) - 1] = 0;
+        oly->list = NULL;
+        oly->max = 0;
+        oly->cnt = 0;
+        oly->next = NULL;
+    } else {
+#line 281
+        DO_INTERNAL_ERROR("Could not allocate %s", "overlay");
+    }
+    return oly;
+}
+
+void Overlay_Delete(Overlay *oly) {
+#line 288
+    OPTION_ASSERT(oly);
+
+    if (oly->list)
+        xfree(oly->list);
+    oly->list = NULL;
+}
+
+Boolean Overlay_AddFile(Overlay *oly, SInt32 filenum, SInt32 *filnum) {
+#line 296
+    OPTION_ASSERT(oly);
+
+    if (oly->cnt >= oly->max) {
+        oly->max += 16;
+        oly->list = xrealloc("overlay file list", oly->list, sizeof(SInt32) * oly->max);
+    }
+    oly->list[oly->cnt] = filenum;
+
+    if (filnum)
+        *filnum = oly->cnt;
+    oly->cnt++;
+
+    return 1;
+}
+
+SInt32 Overlay_GetFile(Overlay *oly, SInt32 filnum) {
+#line 314
+    OPTION_ASSERT(oly);
+
+    if (filnum < oly->cnt)
+        return oly->list[filnum];
+    else
+        return -1;
+}
+
+SInt32 Overlay_CountFiles(Overlay *oly) {
+#line 323
+    OPTION_ASSERT(oly);
+
+    return oly->cnt;
+}
diff --git a/command_line/CmdLine/Src/Project/CLProj.c b/command_line/CmdLine/Src/Project/CLProj.c
index e69de29..83b2ce1 100644
--- a/command_line/CmdLine/Src/Project/CLProj.c
+++ b/command_line/CmdLine/Src/Project/CLProj.c
@@ -0,0 +1,16 @@
+#include "cmdline.h"
+
+Boolean Proj_Initialize(Project *this) {
+    this->targets = NULL;
+    OS_GetCWD(&this->projectDirectory.path);
+    OS_MakeNameSpec("", &this->projectDirectory.name);
+    return 1;
+}
+
+Boolean Proj_Terminate(Project *this) {
+#line 25
+    OPTION_ASSERT(this != NULL);
+
+    Targets_Term(this->targets);
+    return 1;
+}
diff --git a/command_line/CmdLine/Src/Project/CLSegs.c b/command_line/CmdLine/Src/Project/CLSegs.c
index e69de29..a0e006c 100644
--- a/command_line/CmdLine/Src/Project/CLSegs.c
+++ b/command_line/CmdLine/Src/Project/CLSegs.c
@@ -0,0 +1,123 @@
+#include "cmdline.h"
+
+Segment *Segment_New(const char *name, UInt16 attrs) {
+    Segment *seg = xmalloc(NULL, sizeof(Segment));
+    strncpy(seg->name, name, sizeof(seg->name));
+    seg->name[sizeof(seg->name) - 1] = 0;
+    seg->attrs = attrs;
+    return seg;
+}
+
+void Segment_Free(Segment *seg) {
+    if (seg)
+        xfree(seg);
+}
+
+Boolean Segments_Initialize(Segments *segs) {
+    Segment *jump;
+    Segment *main;
+    UInt16 idx;
+
+#line 36
+    OPTION_ASSERT(segs != NULL);
+
+    memset(segs, 0, sizeof(Segments));
+    segs->segsArray = NULL;
+
+    jump = Segment_New("Jump Table", 0x28);
+    Segments_AddSegment(segs, jump, &idx);
+#line 44
+    OPTION_ASSERT(idx==0);
+
+    main = Segment_New("Main", 0xFFFF);
+    Segments_AddSegment(segs, main, &idx);
+#line 49
+    OPTION_ASSERT(idx==1);
+
+    return 1;
+}
+
+Boolean Segments_Terminate(Segments *segs) {
+    UInt16 index;
+
+#line 57
+    OPTION_ASSERT(segs != NULL);
+
+    if (segs->segsArray) {
+        for (index = 0; index < segs->segsCount; index++)
+            Segment_Free(segs->segsArray[index]);
+        xfree(segs->segsArray);
+    }
+    segs->segsArray = NULL;
+
+    return 1;
+}
+
+static Boolean Segments_GrowSegments(Segments *segs, UInt16 *index) {
+    Segment **newArray;
+
+#line 78
+    OPTION_ASSERT(segs != NULL);
+
+    if (segs->segsCount >= segs->arraySize) {
+        segs->arraySize += 20;
+        newArray = xrealloc("segments", segs->segsArray, sizeof(Segment *) * segs->arraySize);
+        segs->segsArray = newArray;
+    }
+
+    *index = segs->segsCount++;
+    return 1;
+}
+
+Boolean Segments_AddSegment(Segments *segs, Segment *seg, UInt16 *index) {
+    UInt16 ni;
+
+    if (Segments_GrowSegments(segs, &ni)) {
+        segs->segsArray[ni] = seg;
+        *index = ni;
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+Boolean Segments_InsertSegment(Segments *segs, UInt16 index, Segment *seg) {
+    UInt16 ni;
+
+    if (Segments_GrowSegments(segs, &ni)) {
+        if (index > ni)
+            index = ni - 1;
+        memmove(&segs->segsArray[index + 1], &segs->segsArray[index], sizeof(Segment *) * (segs->segsCount - index));
+        segs->segsArray[index] = seg;
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+Boolean Segments_DeleteSegment(Segments *segs, UInt16 index) {
+    if (index >= segs->segsCount)
+        return 0;
+
+    Segment_Free(segs->segsArray[index]);
+    memmove(&segs->segsArray[index], &segs->segsArray[index + 1], sizeof(Segment *) * (segs->segsCount - index));
+    segs->segsCount--;
+    return 1;
+}
+
+Segment *Segments_GetSegment(Segments *segs, UInt16 segnum) {
+#line 137
+    OPTION_ASSERT(segs != NULL);
+
+    if (segnum < segs->segsCount)
+        return segs->segsArray[segnum];
+    else
+        return NULL;
+}
+
+UInt16 Segments_Count(const Segments *segs) {
+#line 147
+    OPTION_ASSERT(segs != NULL);
+
+    return segs->segsCount;
+}
diff --git a/command_line/CmdLine/Src/uFileTypeMappings.c b/command_line/CmdLine/Src/uFileTypeMappings.c
new file mode 100644
index 0000000..56aaea5
--- /dev/null
+++ b/command_line/CmdLine/Src/uFileTypeMappings.c
@@ -0,0 +1,31 @@
+#include "cmdline.h"
+
+// I don't actually have a name for this file, annoyingly enough
+
+void AddFileTypeMappingList(OSFileTypeMappings **list, const OSFileTypeMappingList *entry) {
+    OS_AddFileTypeMappingList(list, entry);
+}
+
+void UseFileTypeMappings(OSFileTypeMappings *list) {
+    OS_UseFileTypeMappings(list);
+}
+
+OSErr SetMacFileType(const FSSpec *spec, OSType mactype) {
+    OSSpec ospec;
+    OSErr err;
+
+    err = OS_FSSpec_To_OSSpec(spec, &ospec);
+    if (err)
+        return err;
+    return OS_SetMacFileType(&ospec, mactype);
+}
+
+OSErr GetMacFileType(const FSSpec *spec, OSType *mactype) {
+    OSSpec ospec;
+    OSErr err;
+
+    err = OS_FSSpec_To_OSSpec(spec, &ospec);
+    if (err)
+        return err;
+    return OS_GetMacFileType(&ospec, mactype);
+}
diff --git a/command_line/CmdLine/Src/CLPluginAPI.c b/compiler_and_linker/BackEnd/PowerPC/Disassembler/InstPPC.c
index e69de29..e69de29 100644
--- a/command_line/CmdLine/Src/CLPluginAPI.c
+++ b/compiler_and_linker/BackEnd/PowerPC/Disassembler/InstPPC.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/dumpmacho.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/dumpmacho.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/dumpmacho.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/4byte_literals.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/4byte_literals.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/4byte_literals.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/8byte_literals.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/8byte_literals.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/8byte_literals.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/coalesced_sections.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/coalesced_sections.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/coalesced_sections.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/cstring_literals.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/cstring_literals.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/cstring_literals.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/dylibs.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/dylibs.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/dylibs.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/fvmlibs.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/fvmlibs.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/fvmlibs.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/generic_reloc.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/generic_reloc.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/generic_reloc.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/hppa_reloc.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/hppa_reloc.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/hppa_reloc.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/i860_reloc.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/i860_reloc.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/i860_reloc.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/indirect_sections.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/indirect_sections.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/indirect_sections.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/layout.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/layout.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/layout.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/ld.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/ld.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/ld.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/literal_pointers.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/literal_pointers.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/literal_pointers.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/m68k_reloc.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/m68k_reloc.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/m68k_reloc.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/mod_sections.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/mod_sections.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/mod_sections.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/objects.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/objects.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/objects.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/pass1.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/pass1.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/pass1.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/pass2.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/pass2.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/pass2.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/ppc_reloc.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/ppc_reloc.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/ppc_reloc.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/sections.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/sections.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/sections.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/sparc_reloc.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/sparc_reloc.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/sparc_reloc.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/specs.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/specs.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/specs.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/symbols.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/symbols.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/ld/symbols.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/arch.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/arch.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/arch.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/best_arch.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/best_arch.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/best_arch.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/bytesex.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/bytesex.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/bytesex.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/get_arch_from_host.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/get_arch_from_host.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/get_arch_from_host.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/get_toc_byte_sex.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/get_toc_byte_sex.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/get_toc_byte_sex.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/guess_short_name.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/guess_short_name.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/guess_short_name.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/hppa.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/hppa.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/hppa.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/ofile.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/ofile.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/ofile.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/reloc.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/reloc.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/reloc.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/seg_addr_table.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/seg_addr_table.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/seg_addr_table.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/set_arch_flag_name.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/set_arch_flag_name.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/set_arch_flag_name.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/swap_headers.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/swap_headers.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/swap_headers.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/version_number.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/version_number.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/libstuff/version_number.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/misc/libtool.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/misc/libtool.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/misc/libtool.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/mwerks_allocate.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/mwerks_allocate.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/mwerks_allocate.c
diff --git a/compiler_and_linker/BackEnd/PowerPC/MachLinker/mwerks_execute.c b/compiler_and_linker/BackEnd/PowerPC/MachLinker/mwerks_execute.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/BackEnd/PowerPC/MachLinker/mwerks_execute.c
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsBackEnd.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsBackEnd.opt
new file mode 100644
index 0000000..1f06ca4
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsBackEnd.opt
@@ -0,0 +1,786 @@
+/* forward declare */ extern OptionList alignPPC_conflicts;
+/* forward declare */ extern OptionList tbtables_conflicts;
+
+/* BackEnd */
+SET_T optlstBackEnd882 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pBackEnd.structalignment
+};
+Option alignPPC_883 = {
+	/*     names = */ "power|powerpc",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd882,
+	/*       sub = */ 0,
+	/* conflicts = */ &alignPPC_conflicts,
+	/*      help = */ "PowerPC alignment"
+};
+SET_T optlstBackEnd879 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pBackEnd.structalignment
+};
+Option alignPPC_880 = {
+	/*     names = */ "mac68k",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd879,
+	/*       sub = */ 0,
+	/* conflicts = */ &alignPPC_conflicts,
+	/*      help = */ "Macintosh 680x0 alignment"
+};
+SET_T optlstBackEnd876 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.structalignment
+};
+Option alignPPC_877 = {
+	/*     names = */ "mac68k4byte",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd876,
+	/*       sub = */ 0,
+	/* conflicts = */ &alignPPC_conflicts,
+	/*      help = */ "Mac 680x0 4-byte alignment"
+};
+GENERIC_T optlstBackEnd873 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddStringToDefines,
+	/*        arg = */ (void *) "#pragma align_array_members on\n",
+	/*       help = */ 0
+};
+Option optlstBackEnd_874 = {
+	/*     names = */ "array|arraymembers",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd873,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "align members of arrays"
+};
+Option *optlstBackEnd_884_list[] = {
+	&alignPPC_883,
+	&alignPPC_880,
+	&alignPPC_877,
+	&optlstBackEnd_874,
+	0
+};
+OptionList optlstBackEnd_884 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstBackEnd_884_list
+};
+Option optlstBackEnd_885 = {
+	/*     names = */ "align",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstBackEnd_884,
+	/* conflicts = */ 0,
+	/*      help = */ "specify structure/array alignment options"
+};
+ONOFF_T optlstBackEnd887 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pBackEnd.common
+};
+Option optlstBackEnd_888 = {
+	/*     names = */ "common",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd887,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "common variables"
+};
+SET_T optlstBackEnd891 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.dynamic
+};
+Option optlstBackEnd_892 = {
+	/*     names = */ "dynamic",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd891,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "dynamic addressing mode"
+};
+ONOFF_T optlstBackEnd894 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pBackEnd.fpcontract
+};
+Option optlstBackEnd_895 = {
+	/*     names = */ "fp_contract",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd894,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "generate fused multiply-add instructions"
+};
+ONOFF_T optlstBackEnd897 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pBackEnd.implicit_templates
+};
+Option optlstBackEnd_898 = {
+	/*     names = */ "imp_templates",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd897,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "implicit templates"
+};
+ONOFF_T optlstBackEnd900 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pBackEnd.pic
+};
+Option optlstBackEnd_901 = {
+	/*     names = */ "pic",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd900,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "generate position independent code"
+};
+/* forward declare */ extern OptionList optlstBackEnd_932_conflicts;
+SET_T optlstBackEnd930 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pBackEnd.processor
+};
+Option optlstBackEnd_932_931 = {
+	/*     names = */ "generic||ppc|power|powerc",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd930,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_932_conflicts,
+	/*      help = */ "generic PowerPC"
+};
+SET_T optlstBackEnd927 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.processor
+};
+Option optlstBackEnd_932_928 = {
+	/*     names = */ "601",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd927,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_932_conflicts,
+	/*      help = */ "PPC 601"
+};
+SET_T optlstBackEnd924 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pBackEnd.processor
+};
+Option optlstBackEnd_932_925 = {
+	/*     names = */ "603",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd924,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_932_conflicts,
+	/*      help = */ "PPC 603"
+};
+SET_T optlstBackEnd921 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x3,
+	/*        num = */ (char *) &pBackEnd.processor
+};
+Option optlstBackEnd_932_922 = {
+	/*     names = */ "603e",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd921,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_932_conflicts,
+	/*      help = */ "PPC 603e"
+};
+SET_T optlstBackEnd918 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x4,
+	/*        num = */ (char *) &pBackEnd.processor
+};
+Option optlstBackEnd_932_919 = {
+	/*     names = */ "604",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd918,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_932_conflicts,
+	/*      help = */ "PPC 604"
+};
+SET_T optlstBackEnd915 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x5,
+	/*        num = */ (char *) &pBackEnd.processor
+};
+Option optlstBackEnd_932_916 = {
+	/*     names = */ "604e",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd915,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_932_conflicts,
+	/*      help = */ "PPC 604e"
+};
+SET_T optlstBackEnd912 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x6,
+	/*        num = */ (char *) &pBackEnd.processor
+};
+Option optlstBackEnd_932_913 = {
+	/*     names = */ "750",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd912,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_932_conflicts,
+	/*      help = */ "PPC 750"
+};
+SET_T optlstBackEnd909 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x7,
+	/*        num = */ (char *) &pBackEnd.processor
+};
+Option optlstBackEnd_932_910 = {
+	/*     names = */ "7400",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd909,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_932_conflicts,
+	/*      help = */ "PPC 7400 (AltiVec)"
+};
+SET_T optlstBackEnd906 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x8,
+	/*        num = */ (char *) &pBackEnd.processor
+};
+Option optlstBackEnd_932_907 = {
+	/*     names = */ "7450",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd906,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_932_conflicts,
+	/*      help = */ "PPC 7450 (AltiVec)"
+};
+SET_T optlstBackEnd903 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x7,
+	/*        num = */ (char *) &pBackEnd.processor
+};
+Option optlstBackEnd_932_904 = {
+	/*     names = */ "altivec",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd903,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_932_conflicts,
+	/*      help = */ "Altivec"
+};
+Option *optlstBackEnd_932_list[] = {
+	&optlstBackEnd_932_931,
+	&optlstBackEnd_932_928,
+	&optlstBackEnd_932_925,
+	&optlstBackEnd_932_922,
+	&optlstBackEnd_932_919,
+	&optlstBackEnd_932_916,
+	&optlstBackEnd_932_913,
+	&optlstBackEnd_932_910,
+	&optlstBackEnd_932_907,
+	&optlstBackEnd_932_904,
+	0
+};
+OptionList optlstBackEnd_932 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstBackEnd_932_list
+};
+OptionList optlstBackEnd_932_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstBackEnd_932_list
+};
+Option optlstBackEnd_933 = {
+	/*     names = */ "proc|processor||scheduling|target",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstBackEnd_932,
+	/* conflicts = */ 0,
+	/*      help = */ "specify target processor; currently used only for scheduling"
+};
+ONOFF_T optlstBackEnd935 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pBackEnd.profiler
+};
+Option optlstBackEnd_936 = {
+	/*     names = */ "profile",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd935,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "enable calls to profiler"
+};
+SET_T optlstBackEnd939 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.readonlystrings
+};
+Option optlstBackEnd_940 = {
+	/*     names = */ "rostr|readonlystrings",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd939,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "make string constants read-only"
+};
+/* forward declare */ extern OptionList optlstBackEnd_950_conflicts;
+SET_T optlstBackEnd948 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pBackEnd.tracebacktables
+};
+Option optlstBackEnd_950_949 = {
+	/*     names = */ "none",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd948,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_950_conflicts,
+	/*      help = */ "don't generate traceback tables"
+};
+SET_T optlstBackEnd945 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.tracebacktables
+};
+Option optlstBackEnd_950_946 = {
+	/*     names = */ "inline",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd945,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_950_conflicts,
+	/*      help = */ "generate inline traceback tables"
+};
+SET_T optlstBackEnd942 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pBackEnd.tracebacktables
+};
+Option optlstBackEnd_950_943 = {
+	/*     names = */ "outofline",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd942,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstBackEnd_950_conflicts,
+	/*      help = */ "generate out-of-line traceback tables"
+};
+Option *optlstBackEnd_950_list[] = {
+	&optlstBackEnd_950_949,
+	&optlstBackEnd_950_946,
+	&optlstBackEnd_950_943,
+	0
+};
+OptionList optlstBackEnd_950 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstBackEnd_950_list
+};
+OptionList optlstBackEnd_950_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstBackEnd_950_list
+};
+Option tbtables_951 = {
+	/*     names = */ "tbtable",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS | OTF_HAS_CONFLICTS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstBackEnd_950,
+	/* conflicts = */ &tbtables_conflicts,
+	/*      help = */ "specify traceback tables generation"
+};
+Option optlstBackEnd_964 = {
+	/*     names = */ "on",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ 0,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "turn on support for vector types / codegen"
+};
+SET_T optlstBackEnd962 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pBackEnd.altivec
+};
+Option optlstBackEnd_963 = {
+	/*     names = */ "off",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd962,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "turn off vectorization"
+};
+SET_T optlstBackEnd958 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.vrsave
+};
+Option optlstBackEnd_959 = {
+	/*     names = */ "vrsave",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd958,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "use VRSAVE prologue/epilogue code"
+};
+SET_T optlstBackEnd954 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.autovectorize
+};
+Option optlstBackEnd_955 = {
+	/*     names = */ "auto",
+	/*     avail = */ OTF_SECRET | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd954,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "auto-vectorize"
+};
+Option *optlstBackEnd_965_list[] = {
+	&optlstBackEnd_964,
+	&optlstBackEnd_963,
+	&optlstBackEnd_959,
+	&optlstBackEnd_955,
+	0
+};
+OptionList optlstBackEnd_965 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstBackEnd_965_list
+};
+SET_T optlstBackEnd968 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.altivec
+};
+Option optlstBackEnd_969 = {
+	/*     names = */ "vector",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ (PARAM_T *) &optlstBackEnd968,
+	/*       sub = */ &optlstBackEnd_965,
+	/* conflicts = */ 0,
+	/*      help = */ "specify Altivec options"
+};
+SET_T optlstBackEnd972 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pBackEnd.dynamic
+};
+Option optlstBackEnd_973 = {
+	/*     names = */ "static",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd972,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "static addressing mode"
+};
+SET_T optlstBackEnd976 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.altivec
+};
+Option optlstBackEnd_977 = {
+	/*     names = */ "faltivec",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd976,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "turn on support for vector types / codegen"
+};
+SET_T optlstBackEnd980 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pBackEnd.altivec
+};
+Option optlstBackEnd_981 = {
+	/*     names = */ "fno-altivec",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd980,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "turn off support for vector types / codegen"
+};
+SET_T optlstBackEnd984 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.common
+};
+Option optlstBackEnd_985 = {
+	/*     names = */ "fcommon",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd984,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "allow common variable definitions"
+};
+SET_T optlstBackEnd988 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pBackEnd.common
+};
+Option optlstBackEnd_989 = {
+	/*     names = */ "fno-common",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd988,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "dont allow common variable definitions"
+};
+SET_T optlstBackEnd992 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.pic
+};
+Option optlstBackEnd_993 = {
+	/*     names = */ "fpic",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd992,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "generate position independent code"
+};
+SET_T optlstBackEnd996 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pBackEnd.pic
+};
+Option optlstBackEnd_997 = {
+	/*     names = */ "fno-pic",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd996,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "dont generate position independent code"
+};
+SET_T optlstBackEnd1000 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pBackEnd.readonlystrings
+};
+Option optlstBackEnd_1001 = {
+	/*     names = */ "fwritable-strings",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd1000,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "string constants are writable"
+};
+SET_T optlstBackEnd1004 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.implicit_templates
+};
+Option optlstBackEnd_1005 = {
+	/*     names = */ "fimplicit-templates",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd1004,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "implicit templates"
+};
+SET_T optlstBackEnd1008 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pBackEnd.implicit_templates
+};
+Option optlstBackEnd_1009 = {
+	/*     names = */ "fno-implicit-templates",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstBackEnd1008,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "no implicit templates"
+};
+Option *optlstBackEnd_1010_list[] = {
+	&optlstBackEnd_885,
+	&optlstBackEnd_888,
+	&optlstBackEnd_892,
+	&optlstBackEnd_895,
+	&optlstBackEnd_898,
+	&optlstBackEnd_901,
+	&optlstBackEnd_933,
+	&optlstBackEnd_936,
+	&optlstBackEnd_940,
+	&tbtables_951,
+	&optlstBackEnd_969,
+	&optlstBackEnd_973,
+	&optlstBackEnd_977,
+	&optlstBackEnd_981,
+	&optlstBackEnd_985,
+	&optlstBackEnd_989,
+	&optlstBackEnd_993,
+	&optlstBackEnd_997,
+	&optlstBackEnd_1001,
+	&optlstBackEnd_1005,
+	&optlstBackEnd_1009,
+	0
+};
+OptionList optlstBackEnd = {
+	/*  help = */ "Mach-O PowerPC CodeGen Options\n",
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstBackEnd_1010_list
+};
+Option *alignPPC_000_list[] = {
+	&alignPPC_883,
+	&alignPPC_880,
+	&alignPPC_877,
+	0
+};
+OptionList alignPPC_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ 0,
+	/*  list = */ alignPPC_000_list
+};
+Option *tbtables_001_list[] = {
+	&tbtables_951,
+	0
+};
+OptionList tbtables_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ 0,
+	/*  list = */ tbtables_001_list
+};
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsCmdLine.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsCmdLine.opt
new file mode 100644
index 0000000..dfdd158
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsCmdLine.opt
@@ -0,0 +1,809 @@
+/* forward declare */ extern OptionList helpAllNormal_conflicts;
+/* forward declare */ extern OptionList helpkey_conflicts;
+/* forward declare */ extern OptionList helpTool_conflicts;
+
+/* CmdLine */
+MASK_T optlstCmdLine070 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x4000,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+Option optlstCmdLine_071 = {
+	/*     names = */ "usage",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine070,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show usage information"
+};
+MASK_T optlstCmdLine066 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x100,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+Option optlstCmdLine_067 = {
+	/*     names = */ "spaces",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine066,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "insert blank lines between options in printout"
+};
+MASK_T optlstCmdLine062 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x6A,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+Option helpAllNormal_063 = {
+	/*     names = */ "all",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine062,
+	/*       sub = */ 0,
+	/* conflicts = */ &helpAllNormal_conflicts,
+	/*      help = */ "show all standard options"
+};
+MASK_T optlstCmdLine058 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x80,
+	/*    andmask = */ 0xE,
+	/*        num = */ &parseopts.helpFlags
+};
+Option helpAllNormal_059 = {
+	/*     names = */ "normal",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine058,
+	/*       sub = */ 0,
+	/* conflicts = */ &helpAllNormal_conflicts,
+	/*      help = */ "show only standard options"
+};
+MASK_T optlstCmdLine055 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x4,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+Option optlstCmdLine_056 = {
+	/*     names = */ "obsolete",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine055,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show obsolete options"
+};
+MASK_T optlstCmdLine051 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x2,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+Option optlstCmdLine_052 = {
+	/*     names = */ "ignored",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine051,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show ignored options"
+};
+MASK_T optlstCmdLine047 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x8,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+Option optlstCmdLine_048 = {
+	/*     names = */ "deprecated",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine047,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show deprecated options"
+};
+MASK_T optlstCmdLine043 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x20,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+Option optlstCmdLine_044 = {
+	/*     names = */ "meaningless",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine043,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show options meaningless for this target"
+};
+MASK_T optlstCmdLine039 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x40,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+Option optlstCmdLine_040 = {
+	/*     names = */ "compatible",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine039,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show compatibility options"
+};
+MASK_T optlstCmdLine035 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x10,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+Option optlstCmdLine_036 = {
+	/*     names = */ "secret",
+	/*     avail = */ OTF_GLOBAL | OTF_SECRET | OTF_HIDE_DEFAULT | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine035,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ 0
+};
+MASK_T optlstCmdLine029 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x1,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+STRING_T optlstCmdLine031 = {
+	/*      which = */ PARAMWHICH_String,
+	/*      flags = */ 0x00,
+	/*     myname = */ "name",
+	/*       next = */ (PARAM_T *) &optlstCmdLine029,
+	/*     maxlen = */ 64,
+	/*    pstring = */ 0,
+	/*        str = */ parseopts.helpKey
+};
+Option helpkey_032 = {
+	/*     names = */ "opt|option",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine031,
+	/*       sub = */ 0,
+	/* conflicts = */ &helpkey_conflicts,
+	/*      help = */ "show help for a given option"
+};
+STRING_T optlstCmdLine025 = {
+	/*      which = */ PARAMWHICH_String,
+	/*      flags = */ 0x00,
+	/*     myname = */ "keyword",
+	/*       next = */ 0,
+	/*     maxlen = */ 64,
+	/*    pstring = */ 0,
+	/*        str = */ parseopts.helpKey
+};
+Option helpkey_026 = {
+	/*     names = */ "search",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine025,
+	/*       sub = */ 0,
+	/* conflicts = */ &helpkey_conflicts,
+	/*      help = */ "show help for an option whose name or help contains 'keyword' (case-sensitive)"
+};
+MASK_T optlstCmdLine020 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x8000,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+STRING_T optlstCmdLine022 = {
+	/*      which = */ PARAMWHICH_String,
+	/*      flags = */ 0x00,
+	/*     myname = */ "keyword",
+	/*       next = */ (PARAM_T *) &optlstCmdLine020,
+	/*     maxlen = */ 64,
+	/*    pstring = */ 0,
+	/*        str = */ parseopts.helpKey
+};
+Option helpkey_023 = {
+	/*     names = */ "group",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine022,
+	/*       sub = */ 0,
+	/* conflicts = */ &helpkey_conflicts,
+	/*      help = */ "show help for groups whose names contain 'keyword' (case-sensitive)"
+};
+MASK_T optlstCmdLine011 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0xC00,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+Option helpTool_012 = {
+	/*     names = */ "all",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine011,
+	/*       sub = */ 0,
+	/* conflicts = */ &helpTool_conflicts,
+	/*      help = */ "show all options available in this tool"
+};
+MASK_T optlstCmdLine007 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x400,
+	/*    andmask = */ 0x800,
+	/*        num = */ &parseopts.helpFlags
+};
+Option helpTool_008 = {
+	/*     names = */ "this",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine007,
+	/*       sub = */ 0,
+	/* conflicts = */ &helpTool_conflicts,
+	/*      help = */ "show options executed by this tool"
+};
+MASK_T optlstCmdLine004 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x800,
+	/*    andmask = */ 0x400,
+	/*        num = */ &parseopts.helpFlags
+};
+Option helpTool_005 = {
+	/*     names = */ "other|skipped",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine004,
+	/*       sub = */ 0,
+	/* conflicts = */ &helpTool_conflicts,
+	/*      help = */ "show options passed to another tool"
+};
+MASK_T optlstCmdLine001 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0xC00,
+	/*    andmask = */ 0x200,
+	/*        num = */ &parseopts.helpFlags
+};
+Option helpTool_002 = {
+	/*     names = */ "both",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine001,
+	/*       sub = */ 0,
+	/* conflicts = */ &helpTool_conflicts,
+	/*      help = */ "show options used in all tools"
+};
+Option *optlstCmdLine_013_list[] = {
+	&helpTool_012,
+	&helpTool_008,
+	&helpTool_005,
+	&helpTool_002,
+	0
+};
+OptionList optlstCmdLine_013 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstCmdLine_013_list
+};
+MASK_T optlstCmdLine016 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x200,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+Option optlstCmdLine_017 = {
+	/*     names = */ "tool",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine016,
+	/*       sub = */ &optlstCmdLine_013,
+	/* conflicts = */ 0,
+	/*      help = */ "categorize groups of options by tool"
+};
+Option *optlstCmdLine_072_list[] = {
+	&optlstCmdLine_071,
+	&optlstCmdLine_067,
+	&helpAllNormal_063,
+	&helpAllNormal_059,
+	&optlstCmdLine_056,
+	&optlstCmdLine_052,
+	&optlstCmdLine_048,
+	&optlstCmdLine_044,
+	&optlstCmdLine_040,
+	&optlstCmdLine_036,
+	&helpkey_032,
+	&helpkey_026,
+	&helpkey_023,
+	&optlstCmdLine_017,
+	0
+};
+OptionList optlstCmdLine_072 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstCmdLine_072_list
+};
+MASK_T optlstCmdLine075 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*     ormask = */ 0x680,
+	/*    andmask = */ 0x0,
+	/*        num = */ &parseopts.helpFlags
+};
+SET_T optlstCmdLine078 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLine075,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &parseopts.hadAnyOutput
+};
+SET_T optlstCmdLine081 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLine078,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &parseopts.showHelp
+};
+Option optlstCmdLine_082 = {
+	/*     names = */ "help||-help",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_ONLY_ONCE | OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS | OTF_SUB_OPTIONS_OPTIONAL,
+	/*     param = */ (PARAM_T *) &optlstCmdLine081,
+	/*       sub = */ &optlstCmdLine_072,
+	/* conflicts = */ 0,
+	/*      help = */ "display help"
+};
+SET_T optlstCmdLine085 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &parseopts.hadAnyOutput
+};
+GENERIC_T optlstCmdLine087 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLine085,
+	/*      parse = */ &Opt_PrintVersion,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLine_088 = {
+	/*     names = */ "version",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine087,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show version, configuration, and build date"
+};
+SET_T optlstCmdLine091 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLine.timeWorking
+};
+Option optlstCmdLine_092 = {
+	/*     names = */ "timing",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine091,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "collect timing statistics"
+};
+GENERIC_T optlstCmdLine094 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_PrintVersion,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+SET_T optlstCmdLine096 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLine094,
+	/*       size = */ 2,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLine.verbose
+};
+Option optlstCmdLine_progress = {
+	/*     names = */ "progress",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine096,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show progress and version"
+};
+GENERIC_T optlstCmdLine099 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_PrintVersion,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+GENERIC_T optlstCmdLine101 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLine099,
+	/*      parse = */ &Opt_IncreaseVerbosity,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLine_102 = {
+	/*     names = */ "v|verbose",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine101,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "verbose information; cumulative; implies ~~progress"
+};
+SET_T optlstCmdLine105 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &parseopts.alwaysUsePaths
+};
+Option optlstCmdLine_106 = {
+	/*     names = */ "search",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine105,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "search access paths for source files specified on the command line; may specify object code and libraries as well; this option provides the IDE's 'access paths' functionality"
+};
+SET_T optlstCmdLine109 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLine.showLines
+};
+Option optlstCmdLine_110 = {
+	/*     names = */ "lines",
+	/*     avail = */ OTF_GLOBAL | OTF_SECRET | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine109,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show line count"
+};
+SET_T optlstCmdLine113 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pCmdLine.noWrapOutput
+};
+Option optlstCmdLine_114 = {
+	/*     names = */ "wraplines",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine113,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "word wrap messages"
+};
+NUM_T optlstCmdLine116 = {
+	/*      which = */ PARAMWHICH_Number,
+	/*      flags = */ 0x00,
+	/*     myname = */ "max",
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*        fit = */ 0,
+	/*         lo = */ 0,
+	/*         hi = */ 0,
+	/*        num = */ &pCmdLine.maxErrors
+};
+Option optlstCmdLine_117 = {
+	/*     names = */ "maxerrors",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine116,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "specify maximum number of errors to print, zero means no maximum"
+};
+NUM_T optlstCmdLine119 = {
+	/*      which = */ PARAMWHICH_Number,
+	/*      flags = */ 0x00,
+	/*     myname = */ "max",
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*        fit = */ 0,
+	/*         lo = */ 0,
+	/*         hi = */ 0,
+	/*        num = */ &pCmdLine.maxWarnings
+};
+Option optlstCmdLine_120 = {
+	/*     names = */ "maxwarnings",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine119,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "specify maximum number of warnings to print, zero means no maximum"
+};
+/* forward declare */ extern OptionList optlstCmdLine_136_conflicts;
+SET_T optlstCmdLine134 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.msgStyle
+};
+Option optlstCmdLine_136_135 = {
+	/*     names = */ "mpw",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine134,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstCmdLine_136_conflicts,
+	/*      help = */ "use MPW message style"
+};
+SET_T optlstCmdLine131 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pCmdLine.msgStyle
+};
+Option optlstCmdLine_136_132 = {
+	/*     names = */ "std",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine131,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstCmdLine_136_conflicts,
+	/*      help = */ "use standard message style"
+};
+SET_T optlstCmdLine128 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLine.msgStyle
+};
+Option optlstCmdLine_136_129 = {
+	/*     names = */ "gcc",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine128,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstCmdLine_136_conflicts,
+	/*      help = */ "use GCC-like message style"
+};
+SET_T optlstCmdLine125 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x3,
+	/*        num = */ (char *) &pCmdLine.msgStyle
+};
+Option optlstCmdLine_136_126 = {
+	/*     names = */ "IDE",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine125,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstCmdLine_136_conflicts,
+	/*      help = */ "use CW IDE-like message style"
+};
+SET_T optlstCmdLine122 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x4,
+	/*        num = */ (char *) &pCmdLine.msgStyle
+};
+Option optlstCmdLine_136_123 = {
+	/*     names = */ "parseable",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLine122,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstCmdLine_136_conflicts,
+	/*      help = */ "use context-free machine-parseable message style"
+};
+Option *optlstCmdLine_136_list[] = {
+	&optlstCmdLine_136_135,
+	&optlstCmdLine_136_132,
+	&optlstCmdLine_136_129,
+	&optlstCmdLine_136_126,
+	&optlstCmdLine_136_123,
+	0
+};
+OptionList optlstCmdLine_136 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER | LISTFLAGS_LINKER | LISTFLAGS_DISASSEMBLER,
+	/*  list = */ optlstCmdLine_136_list
+};
+OptionList optlstCmdLine_136_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER | LISTFLAGS_LINKER | LISTFLAGS_DISASSEMBLER,
+	/*  list = */ optlstCmdLine_136_list
+};
+Option optlstCmdLine_137 = {
+	/*     names = */ "msgstyle",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstCmdLine_136,
+	/* conflicts = */ 0,
+	/*      help = */ "set error/warning message style"
+};
+GENERIC_T optlstCmdLine139 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SavePrefs,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+SET_T optlstCmdLine142 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLine139,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pCmdLine.stderr2stdout
+};
+Option optlstCmdLine_143 = {
+	/*     names = */ "stderr",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine142,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "use separate stderr and stdout streams; if using ~~nostderr, stderr goes to stdout"
+};
+GENERIC_T optlstCmdLine145 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_FindAndAddFile,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLine_146 = {
+	/*     names = */ "",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLine145,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ 0
+};
+Option *optlstCmdLine_147_list[] = {
+	&optlstCmdLine_082,
+	&optlstCmdLine_088,
+	&optlstCmdLine_092,
+	&optlstCmdLine_progress,
+	&optlstCmdLine_102,
+	&optlstCmdLine_106,
+	&optlstCmdLine_110,
+	&optlstCmdLine_114,
+	&optlstCmdLine_117,
+	&optlstCmdLine_120,
+	&optlstCmdLine_137,
+	&optlstCmdLine_143,
+	&optlstCmdLine_146,
+	0
+};
+OptionList optlstCmdLine = {
+	/*  help = */ "General Command-Line Options\n\tAll the options are passed to the linker unless otherwise noted.\b\tPlease see '~~help usage' for details about the meaning of this help.\b",
+	/* flags = */ LISTFLAGS_COMPILER | LISTFLAGS_LINKER | LISTFLAGS_DISASSEMBLER,
+	/*  list = */ optlstCmdLine_147_list
+};
+Option *helpAllNormal_000_list[] = {
+	&helpAllNormal_063,
+	&helpAllNormal_059,
+	0
+};
+OptionList helpAllNormal_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ 0,
+	/*  list = */ helpAllNormal_000_list
+};
+Option *helpkey_001_list[] = {
+	&helpkey_032,
+	&helpkey_026,
+	&helpkey_023,
+	0
+};
+OptionList helpkey_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ 0,
+	/*  list = */ helpkey_001_list
+};
+Option *helpTool_002_list[] = {
+	&helpTool_012,
+	&helpTool_008,
+	&helpTool_005,
+	&helpTool_002,
+	0
+};
+OptionList helpTool_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ 0,
+	/*  list = */ helpTool_002_list
+};
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsCmdLineCompiler.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsCmdLineCompiler.opt
new file mode 100644
index 0000000..8f5b7c0
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsCmdLineCompiler.opt
@@ -0,0 +1,1028 @@
+/* forward declare */ extern OptionList precompile_conflicts;
+
+/* CmdLineCompiler */
+SET_T optlstCmdLineCompiler150 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLineCompiler.browserEnabled
+};
+Option optlstCmdLineCompiler_151 = {
+	/*     names = */ "browse",
+	/*     avail = */ OTF_GLOBAL | OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler150,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "record browse information to file named <output file>.b"
+};
+SET_T optlstCmdLineCompiler153 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_154 = {
+	/*     names = */ "c",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler153,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "compile only, do not link"
+};
+GENERIC_T optlstCmdLineCompiler156 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "Cg",
+	/*       help = */ 0
+};
+Option optlstCmdLineCompiler_157 = {
+	/*     names = */ "codegen",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler156,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "generate object code"
+};
+SET_T optlstCmdLineCompiler160 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pCmdLineCompiler.canonicalIncludes
+};
+Option optlstCmdLineCompiler_161 = {
+	/*     names = */ "convertpaths",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler160,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "interpret #include filepaths specified for a foreign operating system; i.e., <sys/stat.h> or <sys\\stat.h>; when enabled, '/' and '\\' will separate directories and cannot be used in filenames"
+};
+/* forward declare */ extern OptionList optlstCmdLineCompiler_174_conflicts;
+SET_T optlstCmdLineCompiler172 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pCmdLineCompiler.includeSearch
+};
+Option optlstCmdLineCompiler_174_173 = {
+	/*     names = */ "proj",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler172,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstCmdLineCompiler_174_conflicts,
+	/*      help = */ "begin search in current working directory"
+};
+SET_T optlstCmdLineCompiler169 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLineCompiler.includeSearch
+};
+Option optlstCmdLineCompiler_174_170 = {
+	/*     names = */ "source",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler169,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstCmdLineCompiler_174_conflicts,
+	/*      help = */ "begin search in directory of source file"
+};
+SET_T optlstCmdLineCompiler166 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLineCompiler.includeSearch
+};
+Option optlstCmdLineCompiler_174_167 = {
+	/*     names = */ "explicit",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler166,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstCmdLineCompiler_174_conflicts,
+	/*      help = */ "no implicit directory; only search '~~I' or '~~ir' paths"
+};
+SET_T optlstCmdLineCompiler163 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x3,
+	/*        num = */ (char *) &pCmdLineCompiler.includeSearch
+};
+Option optlstCmdLineCompiler_174_164 = {
+	/*     names = */ "include",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler163,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstCmdLineCompiler_174_conflicts,
+	/*      help = */ "begin search in directory of referencing file"
+};
+Option *optlstCmdLineCompiler_174_list[] = {
+	&optlstCmdLineCompiler_174_173,
+	&optlstCmdLineCompiler_174_170,
+	&optlstCmdLineCompiler_174_167,
+	&optlstCmdLineCompiler_174_164,
+	0
+};
+OptionList optlstCmdLineCompiler_174 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstCmdLineCompiler_174_list
+};
+OptionList optlstCmdLineCompiler_174_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstCmdLineCompiler_174_list
+};
+Option optlstCmdLineCompiler_175 = {
+	/*     names = */ "cwd",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstCmdLineCompiler_174,
+	/* conflicts = */ 0,
+	/*      help = */ "specify #include searching semantics:  before searching any access paths, the path specified by this option will be searched"
+};
+SETTING_T optlstCmdLineCompiler176 = {
+	/*      which = */ PARAMWHICH_Setting,
+	/*      flags = */ 0x06,
+	/*     myname = */ "name",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_DefineSymbol,
+	/*  valuename = */ "value"
+};
+Option optlstCmdLineCompiler_177 = {
+	/*     names = */ "D|d|define",
+	/*     avail = */ OTF_STICKY | OTF_CASED | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler176,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "define symbol 'name' to 'value' if specified, else '1'"
+};
+SET_T optlstCmdLineCompiler180 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &useDefaultIncludes
+};
+Option optlstCmdLineCompiler_181 = {
+	/*     names = */ "defaults",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler180,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as '~~[no]stdinc'"
+};
+GENERIC_T optlstCmdLineCompiler183 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "Ds",
+	/*       help = */ 0
+};
+SET_T optlstCmdLineCompiler185 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler183,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_186 = {
+	/*     names = */ "dis|disassemble",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler185,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "disassemble files to stdout"
+};
+GENERIC_T optlstCmdLineCompiler188 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "Pp",
+	/*       help = */ 0
+};
+SET_T optlstCmdLineCompiler190 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler188,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_191 = {
+	/*     names = */ "E",
+	/*     avail = */ OTF_GLOBAL | OTF_CASED | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler190,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "preprocess source files"
+};
+GENERIC_T optlstCmdLineCompiler193 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddStringToDefines,
+	/*        arg = */ (void *) "#pragma simple_prepdump on\n",
+	/*       help = */ 0
+};
+GENERIC_T optlstCmdLineCompiler195 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler193,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "Pp",
+	/*       help = */ 0
+};
+SET_T optlstCmdLineCompiler197 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler195,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_198 = {
+	/*     names = */ "EP",
+	/*     avail = */ OTF_GLOBAL | OTF_CASED | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler197,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "preprocess and strip out #line directives"
+};
+STRING_T optlstCmdLineCompiler200 = {
+	/*      which = */ PARAMWHICH_String,
+	/*      flags = */ 0x00,
+	/*     myname = */ "extension",
+	/*       next = */ 0,
+	/*     maxlen = */ 15,
+	/*    pstring = */ 0,
+	/*        str = */ pCmdLineCompiler.objFileExt
+};
+Option optlstCmdLineCompiler_201 = {
+	/*     names = */ "ext",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler200,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "specify extension for generated object files; with a leading period ('.'), appends extension; without, replaces source file's extension"
+};
+GENERIC_T optlstCmdLineCompiler203 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "path",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddFrameworkPath,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLineCompiler_204 = {
+	/*     names = */ "F",
+	/*     avail = */ OTF_GLOBAL | OTF_CASED | OTF_TOOL_COMPILER | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler203,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "append access path to current framework access paths list"
+};
+GENERIC_T optlstCmdLineCompiler206 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "path",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddFramework,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLineCompiler_207 = {
+	/*     names = */ "framework",
+	/*     avail = */ OTF_GLOBAL | OTF_CASED | OTF_TOOL_COMPILER | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler206,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "append framework to the frameworks list"
+};
+SET_T optlstCmdLineCompiler210 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLineCompiler.compileIgnored
+};
+Option optlstCmdLineCompiler_211 = {
+	/*     names = */ "force_compile",
+	/*     avail = */ OTF_GLOBAL | OTF_SECRET | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler210,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "force compilation of unrecognized files"
+};
+SET_T optlstCmdLineCompiler213 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x3,
+	/*        num = */ (char *) &pCmdLineCompiler.includeSearch
+};
+SET_T optlstCmdLineCompiler216 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler213,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &dashIMinusMovesPaths
+};
+SET_T optlstCmdLineCompiler219 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler216,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &namingSysPaths
+};
+Option optlstCmdLineCompiler_220 = {
+	/*     names = */ "gccinc|gccincludes",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler219,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "adopt GCC #include semantics:  add '~~I' paths to system list if '~~I-' is not specified, and search directory of referencing file first for #includes (same as '~~cwd include')"
+};
+SET_T optlstCmdLineCompiler222 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLineCompiler.includeSearch
+};
+SET_T optlstCmdLineCompiler225 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler222,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &usedDashIMinus
+};
+SET_T optlstCmdLineCompiler228 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler225,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &namingSysPaths
+};
+GENERIC_T optlstCmdLineCompiler230 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler228,
+	/*      parse = */ &Opt_MaybeMoveAccessPaths,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLineCompiler_231 = {
+	/*     names = */ "i-|I-",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler230,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "change target for '~~I' access paths to the system list; implies '~~cwd explicit'; while compiling, user paths then system paths are searched when using '#include \"...\"; only system paths are searched with '#include <...>'"
+};
+GENERIC_T optlstCmdLineCompiler233 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "path",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddAccessPath,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLineCompiler_234 = {
+	/*     names = */ "I|i",
+	/*     avail = */ OTF_GLOBAL | OTF_STICKY | OTF_CASED | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler233,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "append access path to current #include list(see '~~gccincludes' and '~~I-')"
+};
+GENERIC_T optlstCmdLineCompiler236 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "file",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddPrefixFile,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLineCompiler_237 = {
+	/*     names = */ "include",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler236,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "prefix text file or precompiled header onto all source files"
+};
+GENERIC_T optlstCmdLineCompiler239 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "path",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddAccessPath,
+	/*        arg = */ (void *) "",
+	/*       help = */ 0
+};
+Option optlstCmdLineCompiler_240 = {
+	/*     names = */ "ir",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler239,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "append a recursive access path to current #include list"
+};
+SET_T optlstCmdLineCompiler243 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLineCompiler.keepObjects
+};
+Option optlstCmdLineCompiler_244 = {
+	/*     names = */ "keepobj|keepobjects",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler243,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "keep object files generated after invoking linker; if disabled, intermediate object files are temporary and deleted after link stage; objects are always kept when compiling"
+};
+STRING_T optlstCmdLineCompiler246 = {
+	/*      which = */ PARAMWHICH_String,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*     maxlen = */ 64,
+	/*    pstring = */ 0,
+	/*        str = */ pCmdLineCompiler.linkerName
+};
+Option optlstCmdLineCompiler_247 = {
+	/*     names = */ "linkername",
+	/*     avail = */ OTF_GLOBAL | OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler246,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "give name of alternate linker"
+};
+GENERIC_T optlstCmdLineCompiler249 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "Dp",
+	/*       help = */ 0
+};
+SET_T optlstCmdLineCompiler251 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler249,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_252 = {
+	/*     names = */ "M",
+	/*     avail = */ OTF_GLOBAL | OTF_CASED | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler251,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "scan source files for dependencies and emit Makefile, do not generate object code"
+};
+GENERIC_T optlstCmdLineCompiler254 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "Dp",
+	/*       help = */ 0
+};
+SET_T optlstCmdLineCompiler257 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler254,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLineCompiler.depsOnlyUserFiles
+};
+SET_T optlstCmdLineCompiler259 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler257,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_260 = {
+	/*     names = */ "MM",
+	/*     avail = */ OTF_GLOBAL | OTF_CASED | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler259,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "like ~~M, but do not list system include files"
+};
+GENERIC_T optlstCmdLineCompiler262 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "DpCg",
+	/*       help = */ 0
+};
+MASK_T optlstCmdLineCompiler265 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler262,
+	/*       size = */ 2,
+	/*     ormask = */ 0xA,
+	/*    andmask = */ 0x0,
+	/*        num = */ &pCmdLine.toDisk
+};
+SET_T optlstCmdLineCompiler267 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler265,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_268 = {
+	/*     names = */ "MD",
+	/*     avail = */ OTF_GLOBAL | OTF_CASED | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler267,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "like ~~M, but write dependency map to a file and generate object code"
+};
+GENERIC_T optlstCmdLineCompiler270 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "DpCg",
+	/*       help = */ 0
+};
+SET_T optlstCmdLineCompiler273 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler270,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLineCompiler.depsOnlyUserFiles
+};
+MASK_T optlstCmdLineCompiler276 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler273,
+	/*       size = */ 2,
+	/*     ormask = */ 0xA,
+	/*    andmask = */ 0x0,
+	/*        num = */ &pCmdLine.toDisk
+};
+SET_T optlstCmdLineCompiler278 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler276,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_279 = {
+	/*     names = */ "MMD",
+	/*     avail = */ OTF_GLOBAL | OTF_CASED | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler278,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "like ~~MD, but do not list system include files"
+};
+GENERIC_T optlstCmdLineCompiler281 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "Dp",
+	/*       help = */ 0
+};
+SET_T optlstCmdLineCompiler283 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler281,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_284 = {
+	/*     names = */ "make",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler283,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "scan source files for dependencies and emit Makefile, do not generate object code"
+};
+SET_T optlstCmdLineCompiler287 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLineCompiler.noFail
+};
+Option optlstCmdLineCompiler_288 = {
+	/*     names = */ "nofail",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler287,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "continue working after errors in earlier files"
+};
+SET_T optlstCmdLineCompiler290 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_291 = {
+	/*     names = */ "nolink",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler290,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "compile only, do not link"
+};
+GENERIC_T optlstCmdLineCompiler293 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SavePrefs,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+SET_T optlstCmdLineCompiler295 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler293,
+	/*       size = */ 1,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLineCompiler.forcePrecompile
+};
+Option precompile_296 = {
+	/*     names = */ "noprecompile",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler295,
+	/*       sub = */ 0,
+	/* conflicts = */ &precompile_conflicts,
+	/*      help = */ "do not precompile any files based on the filename extension"
+};
+SET_T optlstCmdLineCompiler299 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLineCompiler.noSysPath
+};
+Option optlstCmdLineCompiler_300 = {
+	/*     names = */ "nosyspath",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler299,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "treat #include <...> like #include \"...\"; always search both user and system path lists"
+};
+GENERIC_T optlstCmdLineCompiler302 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "file|dir",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_HandleOutputName,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLineCompiler_303 = {
+	/*     names = */ "o",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler302,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "specify output filename or directory for object file(s) or text output, or output filename for linker if called"
+};
+GENERIC_T optlstCmdLineCompiler305 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "Pp",
+	/*       help = */ 0
+};
+MASK_T optlstCmdLineCompiler308 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler305,
+	/*       size = */ 2,
+	/*     ormask = */ 0x1,
+	/*    andmask = */ 0x0,
+	/*        num = */ &pCmdLine.toDisk
+};
+SET_T optlstCmdLineCompiler310 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler308,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_311 = {
+	/*     names = */ "P",
+	/*     avail = */ OTF_GLOBAL | OTF_CASED | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler310,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "preprocess and send output to file; do not generate code"
+};
+GENERIC_T optlstCmdLineCompiler313 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SavePrefs,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+SET_T optlstCmdLineCompiler315 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler313,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLineCompiler.forcePrecompile
+};
+GENERIC_T optlstCmdLineCompiler317 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "file|dir",
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler315,
+	/*      parse = */ &Opt_HandleOutputName,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+SET_T optlstCmdLineCompiler319 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler317,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option precompile_320 = {
+	/*     names = */ "precompile",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler319,
+	/*       sub = */ 0,
+	/* conflicts = */ &precompile_conflicts,
+	/*      help = */ "generate precompiled header from source; write header to 'file' if specified, or put header in 'dir'; if argument is \"\", write header to source-specified location; if neither is defined, header filename is derived from source filename; note: the driver can tell whether to precompile a file based on its extension; '~~precompile file source' then is the same as '~~c ~~o file source'"
+};
+GENERIC_T optlstCmdLineCompiler322 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "Pp",
+	/*       help = */ 0
+};
+SET_T optlstCmdLineCompiler324 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler322,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_325 = {
+	/*     names = */ "preprocess",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler324,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "preprocess source files"
+};
+GENERIC_T optlstCmdLineCompiler327 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "file",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddPrefixFile,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLineCompiler_328 = {
+	/*     names = */ "prefix",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler327,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "prefix text file or precompiled header onto all source files"
+};
+GENERIC_T optlstCmdLineCompiler330 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "Ds",
+	/*       help = */ 0
+};
+MASK_T optlstCmdLineCompiler333 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler330,
+	/*       size = */ 2,
+	/*     ormask = */ 0x4,
+	/*    andmask = */ 0x0,
+	/*        num = */ &pCmdLine.toDisk
+};
+SET_T optlstCmdLineCompiler335 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineCompiler333,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineCompiler_336 = {
+	/*     names = */ "S",
+	/*     avail = */ OTF_GLOBAL | OTF_CASED | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler335,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "disassemble and send output to file"
+};
+SET_T optlstCmdLineCompiler339 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &useDefaultIncludes
+};
+Option optlstCmdLineCompiler_340 = {
+	/*     names = */ "stdinc",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler339,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "use standard system include paths (specified by the environment variable {MWCIncludes}); added after all system '~~I' paths"
+};
+GENERIC_T optlstCmdLineCompiler342 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "name",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_UndefineSymbol,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLineCompiler_343 = {
+	/*     names = */ "U|u|undefine",
+	/*     avail = */ OTF_STICKY | OTF_CASED | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineCompiler342,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "undefine symbol 'name'"
+};
+Option *optlstCmdLineCompiler_344_list[] = {
+	&optlstCmdLineCompiler_151,
+	&optlstCmdLineCompiler_154,
+	&optlstCmdLineCompiler_157,
+	&optlstCmdLineCompiler_161,
+	&optlstCmdLineCompiler_175,
+	&optlstCmdLineCompiler_177,
+	&optlstCmdLineCompiler_181,
+	&optlstCmdLineCompiler_186,
+	&optlstCmdLineCompiler_191,
+	&optlstCmdLineCompiler_198,
+	&optlstCmdLineCompiler_201,
+	&optlstCmdLineCompiler_204,
+	&optlstCmdLineCompiler_207,
+	&optlstCmdLineCompiler_211,
+	&optlstCmdLineCompiler_220,
+	&optlstCmdLineCompiler_231,
+	&optlstCmdLineCompiler_234,
+	&optlstCmdLineCompiler_237,
+	&optlstCmdLineCompiler_240,
+	&optlstCmdLineCompiler_244,
+	&optlstCmdLineCompiler_247,
+	&optlstCmdLineCompiler_252,
+	&optlstCmdLineCompiler_260,
+	&optlstCmdLineCompiler_268,
+	&optlstCmdLineCompiler_279,
+	&optlstCmdLineCompiler_284,
+	&optlstCmdLineCompiler_288,
+	&optlstCmdLineCompiler_291,
+	&precompile_296,
+	&optlstCmdLineCompiler_300,
+	&optlstCmdLineCompiler_303,
+	&optlstCmdLineCompiler_311,
+	&precompile_320,
+	&optlstCmdLineCompiler_325,
+	&optlstCmdLineCompiler_328,
+	&optlstCmdLineCompiler_336,
+	&optlstCmdLineCompiler_340,
+	&optlstCmdLineCompiler_343,
+	0
+};
+OptionList optlstCmdLineCompiler = {
+	/*  help = */ "Preprocessing, Precompiling, and Input File Control Options\n",
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstCmdLineCompiler_344_list
+};
+Option *precompile_000_list[] = {
+	&precompile_296,
+	&precompile_320,
+	0
+};
+OptionList precompile_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ 0,
+	/*  list = */ precompile_000_list
+};
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsCmdLineLinker.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsCmdLineLinker.opt
new file mode 100644
index 0000000..6f26341
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsCmdLineLinker.opt
@@ -0,0 +1,199 @@
+/* CmdLineLinker */
+GENERIC_T optlstCmdLineLinker346 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "Ds",
+	/*       help = */ 0
+};
+SET_T optlstCmdLineLinker349 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineLinker346,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ 0
+};
+SET_T optlstCmdLineLinker351 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineLinker349,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineLinker_352 = {
+	/*     names = */ "dis|disassemble",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineLinker351,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "disassemble object code and do not link; implies '~~nostdlib'"
+};
+GENERIC_T optlstCmdLineLinker354 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "path",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_DummyLinkerRoutine,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLineLinker_355 = {
+	/*     names = */ "L|l",
+	/*     avail = */ OTF_GLOBAL | OTF_STICKY | OTF_CASED | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineLinker354,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "add library search path; default is to search current working directory and then system directories (see '~~defaults'); search paths have global scope over the command line and are searched in the order given"
+};
+GENERIC_T optlstCmdLineLinker357 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "path",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_DummyLinkerRoutine,
+	/*        arg = */ (void *) 1,
+	/*       help = */ 0
+};
+Option optlstCmdLineLinker_358 = {
+	/*     names = */ "lr",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineLinker357,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "like '~~l', but add recursive library search path"
+};
+GENERIC_T optlstCmdLineLinker360 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "file",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_DummyLinkerRoutine,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstCmdLineLinker_361 = {
+	/*     names = */ "l",
+	/*     avail = */ OTF_STICKY | OTF_CASED | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineLinker360,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "add a library by searching access paths for file named lib<file>.<ext> where <ext> is a typical library extension; added before system libraries (see '~~defaults')"
+};
+SET_T optlstCmdLineLinker364 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ 0
+};
+Option optlstCmdLineLinker_365 = {
+	/*     names = */ "defaults",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineLinker364,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as ~~[no]stdlib"
+};
+SET_T optlstCmdLineLinker368 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLineCompiler.noFail
+};
+Option optlstCmdLineLinker_369 = {
+	/*     names = */ "nofail",
+	/*     avail = */ OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineLinker368,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "continue importing or disassembling after errors in earlier files"
+};
+SET_T optlstCmdLineLinker372 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ 0
+};
+Option optlstCmdLineLinker_373 = {
+	/*     names = */ "stdlib",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineLinker372,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "use system library access paths (specified by {MWLibraries}) and add system libraries (specified by {MWLibraryFiles})"
+};
+GENERIC_T optlstCmdLineLinker375 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_SetStage,
+	/*        arg = */ (void *) "Ds",
+	/*       help = */ 0
+};
+MASK_T optlstCmdLineLinker378 = {
+	/*      which = */ PARAMWHICH_Mask,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineLinker375,
+	/*       size = */ 2,
+	/*     ormask = */ 0x4,
+	/*    andmask = */ 0x0,
+	/*        num = */ &pCmdLine.toDisk
+};
+SET_T optlstCmdLineLinker381 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineLinker378,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ 0
+};
+SET_T optlstCmdLineLinker383 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstCmdLineLinker381,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pCmdLine.state
+};
+Option optlstCmdLineLinker_384 = {
+	/*     names = */ "S",
+	/*     avail = */ OTF_GLOBAL | OTF_CASED | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstCmdLineLinker383,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "disassemble and send output to file; do not link; implies '~~nostdlib'"
+};
+Option *optlstCmdLineLinker_385_list[] = {
+	&optlstCmdLineLinker_352,
+	&optlstCmdLineLinker_355,
+	&optlstCmdLineLinker_358,
+	&optlstCmdLineLinker_361,
+	&optlstCmdLineLinker_365,
+	&optlstCmdLineLinker_369,
+	&optlstCmdLineLinker_373,
+	&optlstCmdLineLinker_384,
+	0
+};
+OptionList optlstCmdLineLinker = {
+	/*  help = */ "Command-Line Linker Options\n",
+	/* flags = */ LISTFLAGS_LINKER,
+	/*  list = */ optlstCmdLineLinker_385_list
+};
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsDebugging.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsDebugging.opt
new file mode 100644
index 0000000..6b488ba
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsDebugging.opt
@@ -0,0 +1,80 @@
+/* Debugging */
+SET_T optlstDebugging388 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLine.debugInfo
+};
+Option optlstDebugging_389 = {
+	/*     names = */ "g",
+	/*     avail = */ OTF_GLOBAL | OTF_CASED | OTF_TOOL_COMPILER | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstDebugging388,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "generate debugging information; same as '~~sym on'"
+};
+SET_T optlstDebugging396 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pCmdLine.debugInfo
+};
+Option optlstDebugging_397 = {
+	/*     names = */ "off",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstDebugging396,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "do not generate debugging information"
+};
+SET_T optlstDebugging392 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCmdLine.debugInfo
+};
+Option optlstDebugging_393 = {
+	/*     names = */ "on",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_TOOL_COMPILER | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstDebugging392,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "turn on debugging information"
+};
+Option *optlstDebugging_398_list[] = {
+	&optlstDebugging_397,
+	&optlstDebugging_393,
+	0
+};
+OptionList optlstDebugging_398 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_ALLOW_UNKNOWNS | LISTFLAGS_COMPILER | LISTFLAGS_LINKER,
+	/*  list = */ optlstDebugging_398_list
+};
+Option optlstDebugging_399 = {
+	/*     names = */ "sym",
+	/*     avail = */ OTF_GLOBAL | OTF_HIDE_DEFAULT | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstDebugging_398,
+	/* conflicts = */ 0,
+	/*      help = */ "specify debugging options"
+};
+Option *optlstDebugging_400_list[] = {
+	&optlstDebugging_389,
+	&optlstDebugging_399,
+	0
+};
+OptionList optlstDebugging = {
+	/*  help = */ "Debugging Control Options\n",
+	/* flags = */ LISTFLAGS_COMPILER | LISTFLAGS_LINKER,
+	/*  list = */ optlstDebugging_400_list
+};
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsDumper.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsDumper.opt
new file mode 100644
index 0000000..88c6e90
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsDumper.opt
@@ -0,0 +1,368 @@
+/* Dumper */
+SET_T optlstDumper1187 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pDisassembler.shownames
+};
+SET_T optlstDumper1190 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1187,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pDisassembler.showsym
+};
+SET_T optlstDumper1193 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1190,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pDisassembler.showexceptions
+};
+SET_T optlstDumper1196 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1193,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pDisassembler.showdata
+};
+SET_T optlstDumper1199 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1196,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pDisassembler.nohex
+};
+SET_T optlstDumper1202 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1199,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pDisassembler.mix
+};
+SET_T optlstDumper1205 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1202,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pDisassembler.extended
+};
+SET_T optlstDumper1208 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1205,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pDisassembler.showcode
+};
+Option optlstDumper_1209 = {
+	/*     names = */ "only|none",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstDumper1208,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "as in '~~show none' or, e.g.,\r'~~show only,code,data'"
+};
+SET_T optlstDumper1162 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.shownames
+};
+SET_T optlstDumper1165 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1162,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.showsym
+};
+SET_T optlstDumper1168 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1165,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.showexceptions
+};
+SET_T optlstDumper1171 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1168,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.showdata
+};
+SET_T optlstDumper1174 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1171,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.nohex
+};
+SET_T optlstDumper1177 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1174,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.mix
+};
+SET_T optlstDumper1180 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1177,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.extended
+};
+SET_T optlstDumper1183 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1180,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.showcode
+};
+Option optlstDumper_1184 = {
+	/*     names = */ "all",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstDumper1183,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show everything"
+};
+SET_T optlstDumper1158 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.showcode
+};
+Option optlstDumper_1159 = {
+	/*     names = */ "code|text",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstDumper1158,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show disassembly of code sections"
+};
+SET_T optlstDumper1151 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.showcode
+};
+SET_T optlstDumper1154 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1151,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.extended
+};
+Option optlstDumper_1155 = {
+	/*     names = */ "extended",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstDumper1154,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show extended mnemonics"
+};
+SET_T optlstDumper1144 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.showcode
+};
+SET_T optlstDumper1147 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1144,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.mix
+};
+Option optlstDumper_1148 = {
+	/*     names = */ "mix",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstDumper1147,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "mix code and assembly; requires that modules were compiled with '~~sym on'"
+};
+SET_T optlstDumper1137 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.showcode
+};
+SET_T optlstDumper1140 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1137,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pDisassembler.nohex
+};
+Option optlstDumper_1141 = {
+	/*     names = */ "hex",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstDumper1140,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show addresses and opcodes"
+};
+SET_T optlstDumper1133 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.showdata
+};
+Option optlstDumper_1134 = {
+	/*     names = */ "data",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstDumper1133,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show data modules"
+};
+SET_T optlstDumper1126 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.showdata
+};
+SET_T optlstDumper1129 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstDumper1126,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.showexceptions
+};
+Option optlstDumper_1130 = {
+	/*     names = */ "exceptions",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstDumper1129,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show exception tables"
+};
+SET_T optlstDumper1122 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.showsym
+};
+Option optlstDumper_1123 = {
+	/*     names = */ "sym",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstDumper1122,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show SYM info"
+};
+SET_T optlstDumper1118 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pDisassembler.shownames
+};
+Option optlstDumper_1119 = {
+	/*     names = */ "names",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstDumper1118,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "show symbol and string tables"
+};
+Option *optlstDumper_1210_list[] = {
+	&optlstDumper_1209,
+	&optlstDumper_1184,
+	&optlstDumper_1159,
+	&optlstDumper_1155,
+	&optlstDumper_1148,
+	&optlstDumper_1141,
+	&optlstDumper_1134,
+	&optlstDumper_1130,
+	&optlstDumper_1123,
+	&optlstDumper_1119,
+	0
+};
+OptionList optlstDumper_1210 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_LINKER | LISTFLAGS_DISASSEMBLER,
+	/*  list = */ optlstDumper_1210_list
+};
+Option optlstDumper_1211 = {
+	/*     names = */ "show",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstDumper_1210,
+	/* conflicts = */ 0,
+	/*      help = */ "specify disassembly options"
+};
+Option *optlstDumper_1212_list[] = {
+	&optlstDumper_1211,
+	0
+};
+OptionList optlstDumper = {
+	/*  help = */ "Mach-O PowerPC Disassembler Options\n",
+	/* flags = */ LISTFLAGS_LINKER | LISTFLAGS_DISASSEMBLER,
+	/*  list = */ optlstDumper_1212_list
+};
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsFrontEndC.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsFrontEndC.opt
new file mode 100644
index 0000000..7e3c179
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsFrontEndC.opt
@@ -0,0 +1,1208 @@
+/* FrontEndC */
+/* forward declare */ extern OptionList optlstFrontEndC_431_conflicts;
+SET_T optlstFrontEndC423 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.ansistrict
+};
+SET_T optlstFrontEndC426 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC423,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.enumsalwaysint
+};
+SET_T optlstFrontEndC429 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC426,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.onlystdkeywords
+};
+Option optlstFrontEndC_431_430 = {
+	/*     names = */ "off",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC429,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_431_conflicts,
+	/*      help = */ "same as '~~stdkeywords on', '~~enum min', and '~~strict off'"
+};
+SET_T optlstFrontEndC413 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.ansistrict
+};
+SET_T optlstFrontEndC416 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC413,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.enumsalwaysint
+};
+SET_T optlstFrontEndC419 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC416,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.onlystdkeywords
+};
+Option optlstFrontEndC_431_420 = {
+	/*     names = */ "on|relaxed",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC419,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_431_conflicts,
+	/*      help = */ "same as '~~stdkeywords off', '~~enum min', and '~~strict on'"
+};
+SET_T optlstFrontEndC403 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.ansistrict
+};
+SET_T optlstFrontEndC406 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC403,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.enumsalwaysint
+};
+SET_T optlstFrontEndC409 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC406,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.onlystdkeywords
+};
+Option optlstFrontEndC_431_410 = {
+	/*     names = */ "strict",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC409,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_431_conflicts,
+	/*      help = */ "same as '~~stdkeywords off', '~~enum int', and '~~strict on'"
+};
+Option *optlstFrontEndC_431_list[] = {
+	&optlstFrontEndC_431_430,
+	&optlstFrontEndC_431_420,
+	&optlstFrontEndC_431_410,
+	0
+};
+OptionList optlstFrontEndC_431 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstFrontEndC_431_list
+};
+OptionList optlstFrontEndC_431_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstFrontEndC_431_list
+};
+Option optlstFrontEndC_432 = {
+	/*     names = */ "ansi",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstFrontEndC_431,
+	/* conflicts = */ 0,
+	/*      help = */ "specify ANSI conformance options, overriding the given settings"
+};
+OFFON_T optlstFrontEndC434 = {
+	/*      which = */ PARAMWHICH_OffOn,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pFrontEndC.onlystdkeywords
+};
+Option optlstFrontEndC_435 = {
+	/*     names = */ "appleext",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC434,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "allow nonstandard keywords"
+};
+ONOFF_T optlstFrontEndC437 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pFrontEndC.arm
+};
+Option optlstFrontEndC_438 = {
+	/*     names = */ "ARM",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC437,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "check code for ARM (Annotated C++ Reference Manual) conformance"
+};
+ONOFF_T optlstFrontEndC440 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pFrontEndC.booltruefalse
+};
+Option optlstFrontEndC_441 = {
+	/*     names = */ "bool",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC440,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "enable C++ 'bool' type, 'true' and 'false' constants"
+};
+ONOFF_T optlstFrontEndC443 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pFrontEndC.enableexceptions
+};
+Option optlstFrontEndC_444 = {
+	/*     names = */ "Cpp_exceptions",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC443,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "enable or disable true C++ exceptions"
+};
+/* forward declare */ extern OptionList optlstFrontEndC_454_conflicts;
+SET_T optlstFrontEndC452 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.unsignedchars
+};
+Option optlstFrontEndC_454_453 = {
+	/*     names = */ "signed",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC452,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_454_conflicts,
+	/*      help = */ "chars are signed"
+};
+SET_T optlstFrontEndC448 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.unsignedchars
+};
+Option optlstFrontEndC_454_449 = {
+	/*     names = */ "unsigned",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC448,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_454_conflicts,
+	/*      help = */ "chars are unsigned"
+};
+Option optlstFrontEndC_454_445 = {
+	/*     names = */ "unsignedx",
+	/*     avail = */ OTF_IGNORED | OTF_HIDE_DEFAULT | OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ 0,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_454_conflicts,
+	/*      help = */ 0
+};
+Option *optlstFrontEndC_454_list[] = {
+	&optlstFrontEndC_454_453,
+	&optlstFrontEndC_454_449,
+	&optlstFrontEndC_454_445,
+	0
+};
+OptionList optlstFrontEndC_454 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstFrontEndC_454_list
+};
+OptionList optlstFrontEndC_454_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstFrontEndC_454_list
+};
+Option optlstFrontEndC_455 = {
+	/*     names = */ "char",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstFrontEndC_454,
+	/* conflicts = */ 0,
+	/*      help = */ "set sign of 'char'"
+};
+/* forward declare */ extern OptionList optlstFrontEndC_483_conflicts;
+GENERIC_T optlstFrontEndC478 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddStringToDefines,
+	/*        arg = */ (void *) "#pragma cplusplus off\n",
+	/*       help = */ 0
+};
+SET_T optlstFrontEndC481 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC478,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.cplusplus
+};
+Option optlstFrontEndC_483_482 = {
+	/*     names = */ "c|ansic",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC481,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_483_conflicts,
+	/*      help = */ "treat source as C always"
+};
+SET_T optlstFrontEndC475 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.cplusplus
+};
+Option optlstFrontEndC_483_476 = {
+	/*     names = */ "cplus|cplusplus|c++",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC475,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_483_conflicts,
+	/*      help = */ "treat source as C++ always"
+};
+GENERIC_T optlstFrontEndC468 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddStringToDefines,
+	/*        arg = */ (void *) "#pragma ignore_oldstyle on\n",
+	/*       help = */ 0
+};
+SET_T optlstFrontEndC471 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC468,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.cplusplus
+};
+Option optlstFrontEndC_483_472 = {
+	/*     names = */ "krc",
+	/*     avail = */ OTF_SUBSTITUTED | OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC471,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_483_conflicts,
+	/*      help = */ "'dialect c' and 'proto ignoreoldstyle'\r(CodeWarrior has minimal support for K&R C)"
+};
+SET_T optlstFrontEndC462 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.cplusplus
+};
+SET_T optlstFrontEndC465 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC462,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.ecplusplus
+};
+Option optlstFrontEndC_483_466 = {
+	/*     names = */ "ecplusplus|ec++",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC465,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_483_conflicts,
+	/*      help = */ "generate warnings for use of C++ features outside Embedded C++ subset (implies 'dialect cplus')"
+};
+SET_T optlstFrontEndC458 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.objective_c
+};
+Option optlstFrontEndC_483_459 = {
+	/*     names = */ "objective-c|objc",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC458,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_483_conflicts,
+	/*      help = */ "allow Objective C extensions"
+};
+Option *optlstFrontEndC_483_list[] = {
+	&optlstFrontEndC_483_482,
+	&optlstFrontEndC_483_476,
+	&optlstFrontEndC_483_472,
+	&optlstFrontEndC_483_466,
+	&optlstFrontEndC_483_459,
+	0
+};
+OptionList optlstFrontEndC_483 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstFrontEndC_483_list
+};
+OptionList optlstFrontEndC_483_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstFrontEndC_483_list
+};
+Option optlstFrontEndC_484 = {
+	/*     names = */ "dialect|lang",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstFrontEndC_483,
+	/* conflicts = */ 0,
+	/*      help = */ "specify source language"
+};
+/* forward declare */ extern OptionList optlstFrontEndC_493_conflicts;
+SET_T optlstFrontEndC491 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.enumsalwaysint
+};
+Option optlstFrontEndC_493_492 = {
+	/*     names = */ "min",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC491,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_493_conflicts,
+	/*      help = */ "use minimum sized enums"
+};
+SET_T optlstFrontEndC487 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.enumsalwaysint
+};
+Option optlstFrontEndC_493_488 = {
+	/*     names = */ "int",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC487,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstFrontEndC_493_conflicts,
+	/*      help = */ "use int-sized enums"
+};
+Option *optlstFrontEndC_493_list[] = {
+	&optlstFrontEndC_493_492,
+	&optlstFrontEndC_493_488,
+	0
+};
+OptionList optlstFrontEndC_493 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstFrontEndC_493_list
+};
+OptionList optlstFrontEndC_493_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_COMPILER,
+	/*  list = */ optlstFrontEndC_493_list
+};
+Option optlstFrontEndC_494 = {
+	/*     names = */ "enum",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstFrontEndC_493,
+	/* conflicts = */ 0,
+	/*      help = */ "specify word size for enumeration types"
+};
+SET_T optlstFrontEndC537 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.alwaysinline
+};
+SET_T optlstFrontEndC539 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC537,
+	/*       size = */ 2,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.inlinelevel
+};
+Option optlstFrontEndC_540 = {
+	/*     names = */ "all|on|smart",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC539,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "turn on inlining"
+};
+SET_T optlstFrontEndC528 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.alwaysinline
+};
+SET_T optlstFrontEndC530 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC528,
+	/*       size = */ 2,
+	/*      value = */ 0xFFFFFFFF,
+	/*        num = */ (char *) &pFrontEndC.inlinelevel
+};
+SET_T optlstFrontEndC533 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC530,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.dontinline
+};
+Option optlstFrontEndC_534 = {
+	/*     names = */ "none|off",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC533,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "turn off inlining"
+};
+SET_T optlstFrontEndC521 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.autoinline
+};
+SET_T optlstFrontEndC524 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC521,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.dontinline
+};
+Option optlstFrontEndC_525 = {
+	/*     names = */ "auto",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC524,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "auto-inline small functions (without 'inline' explicitly specified)"
+};
+SET_T optlstFrontEndC517 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.autoinline
+};
+Option optlstFrontEndC_518 = {
+	/*     names = */ "noauto",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC517,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "do not auto-inline"
+};
+SET_T optlstFrontEndC510 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.alwaysinline
+};
+SET_T optlstFrontEndC513 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC510,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.dontinline
+};
+Option optlstFrontEndC_514 = {
+	/*     names = */ "always",
+	/*     avail = */ OTF_SECRET | OTF_WARNING | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC513,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "always inlining 'inline' functions is currently unstable"
+};
+SET_T optlstFrontEndC503 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.defer_codegen
+};
+SET_T optlstFrontEndC506 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC503,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.dontinline
+};
+Option optlstFrontEndC_507 = {
+	/*     names = */ "deferred",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC506,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "defer inlining until end of compilation unit; this allows inlining of functions in both directions"
+};
+Option optlstFrontEndC_500 = {
+	/*     names = */ "static",
+	/*     avail = */ OTF_OBSOLETE | OTF_HIDE_DEFAULT | OTF_TOOL_COMPILER,
+	/*     param = */ 0,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "unreferenced inline functions are removed from object code"
+};
+NUM_T optlstFrontEndC495 = {
+	/*      which = */ PARAMWHICH_Number,
+	/*      flags = */ 0x00,
+	/*     myname = */ "n",
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*        fit = */ 1,
+	/*         lo = */ 0,
+	/*         hi = */ 8,
+	/*        num = */ &pFrontEndC.inlinelevel
+};
+SET_T optlstFrontEndC498 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC495,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.dontinline
+};
+Option optlstFrontEndC_499 = {
+	/*     names = */ "l|level|depth",
+	/*     avail = */ OTF_CASED | OTF_HIDE_DEFAULT | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC498,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "inline functions up to 'n' levels deep; level 0 is the same as '~~inline off'"
+};
+Option *optlstFrontEndC_541_list[] = {
+	&optlstFrontEndC_540,
+	&optlstFrontEndC_534,
+	&optlstFrontEndC_525,
+	&optlstFrontEndC_518,
+	&optlstFrontEndC_514,
+	&optlstFrontEndC_507,
+	&optlstFrontEndC_500,
+	&optlstFrontEndC_499,
+	0
+};
+OptionList optlstFrontEndC_541 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstFrontEndC_541_list
+};
+SET_T optlstFrontEndC544 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.dontinline
+};
+Option optlstFrontEndC_545 = {
+	/*     names = */ "inline",
+	/*     avail = */ OTF_HIDE_DEFAULT | OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC544,
+	/*       sub = */ &optlstFrontEndC_541,
+	/* conflicts = */ 0,
+	/*      help = */ "specify inline options"
+};
+SET_T optlstFrontEndC548 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.multibyteaware
+};
+Option optlstFrontEndC_549 = {
+	/*     names = */ "multibyte|multibyteaware",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC548,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "enable multi-byte character encodings for source text, comments, and strings"
+};
+GENERIC_T optlstFrontEndC551 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddStringToDefines,
+	/*        arg = */ (void *) "#pragma once off\n",
+	/*       help = */ 0
+};
+Option optlstFrontEndC_552 = {
+	/*     names = */ "notonce",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC551,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "allow header files to be processed more than once; default"
+};
+GENERIC_T optlstFrontEndC554 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddStringToDefines,
+	/*        arg = */ (void *) "#pragma once on\n",
+	/*       help = */ 0
+};
+Option optlstFrontEndC_555 = {
+	/*     names = */ "once",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC554,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "prevent header files from being processed more than once"
+};
+GENERIC_T optlstFrontEndC557 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddStringToDefines,
+	/*        arg = */ (void *) "\n",
+	/*       help = */ 0
+};
+GENERIC_T optlstFrontEndC559 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "...",
+	/*       next = */ (PARAM_T *) &optlstFrontEndC557,
+	/*      parse = */ &Opt_AddStringToDefines,
+	/*        arg = */ (void *) "#pragma ",
+	/*       help = */ 0
+};
+Option optlstFrontEndC_560 = {
+	/*     names = */ "pragma",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC559,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "define a pragma for the compiler such as \"#pragma ...\""
+};
+SET_T optlstFrontEndC570 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.checkprotos
+};
+Option optlstFrontEndC_571 = {
+	/*     names = */ "strict",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC570,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "require prototypes"
+};
+SET_T optlstFrontEndC566 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.checkprotos
+};
+Option optlstFrontEndC_567 = {
+	/*     names = */ "auto|lax",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC566,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "don't require prototypes"
+};
+GENERIC_T optlstFrontEndC562 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &Opt_AddStringToDefines,
+	/*        arg = */ (void *) "#pragma ignore_oldstyle on\n",
+	/*       help = */ 0
+};
+Option optlstFrontEndC_563 = {
+	/*     names = */ "ignoreoldstyle",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC562,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "allow old-style K&R declarations"
+};
+Option *optlstFrontEndC_572_list[] = {
+	&optlstFrontEndC_571,
+	&optlstFrontEndC_567,
+	&optlstFrontEndC_563,
+	0
+};
+OptionList optlstFrontEndC_572 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstFrontEndC_572_list
+};
+Option optlstFrontEndC_573 = {
+	/*     names = */ "proto",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstFrontEndC_572,
+	/* conflicts = */ 0,
+	/*      help = */ "specify prototype parsing options"
+};
+SET_T optlstFrontEndC576 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.checkprotos
+};
+Option optlstFrontEndC_577 = {
+	/*     names = */ "r|requireprotos|fstrict-prototype",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC576,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "require prototypes"
+};
+ONOFF_T optlstFrontEndC582 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pFrontEndC.useRTTI
+};
+SET_T optlstFrontEndC580 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.useRTTI
+};
+IFARG_T optlstFrontEndC584 = {
+	/*      which = */ PARAMWHICH_IfArg,
+	/*      flags = */ 0x02,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       parg = */ (PARAM_T *) &optlstFrontEndC582,
+	/*      helpa = */ "enable or disable RTTI",
+	/*      pnone = */ (PARAM_T *) &optlstFrontEndC580,
+	/*      helpn = */ "enable RTTI"
+};
+Option optlstFrontEndC_585 = {
+	/*     names = */ "RTTI",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC584,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "specify run-time typing information options"
+};
+SET_T optlstFrontEndC588 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.mpwpointerstyle
+};
+Option optlstFrontEndC_589 = {
+	/*     names = */ "relax_pointers",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC588,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "relax pointer type-checking rules"
+};
+SET_T optlstFrontEndC592 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.direct_to_som
+};
+Option optlstFrontEndC_593 = {
+	/*     names = */ "som",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC592,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "enable Apple's Direct-to-SOM implementation"
+};
+SET_T optlstFrontEndC596 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.direct_to_som
+};
+SET_T optlstFrontEndC599 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstFrontEndC596,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.som_env_check
+};
+Option optlstFrontEndC_600 = {
+	/*     names = */ "som_env_check",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC599,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "enables automatic SOM environment and new allocation checking; implies ~~som"
+};
+ONOFF_T optlstFrontEndC602 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pFrontEndC.onlystdkeywords
+};
+Option optlstFrontEndC_603 = {
+	/*     names = */ "stdkeywords",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC602,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "allow only standard keywords"
+};
+SET_T optlstFrontEndC618 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.dontreusestrings
+};
+Option optlstFrontEndC_619 = {
+	/*     names = */ "reuse",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC618,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "reuse strings; equivalent strings are the same object"
+};
+SET_T optlstFrontEndC614 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.dontreusestrings
+};
+Option optlstFrontEndC_615 = {
+	/*     names = */ "dontreuse",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC614,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "don't reuse strings; equivalent strings are distinct objects"
+};
+SET_T optlstFrontEndC610 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.poolstrings
+};
+Option optlstFrontEndC_611 = {
+	/*     names = */ "pool|poolstrings",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC610,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "pool strings into a single data object"
+};
+SET_T optlstFrontEndC606 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pBackEnd.readonlystrings
+};
+Option optlstFrontEndC_607 = {
+	/*     names = */ "readonly|ro",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC606,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "make all string constants read-only"
+};
+Option *optlstFrontEndC_620_list[] = {
+	&optlstFrontEndC_619,
+	&optlstFrontEndC_615,
+	&optlstFrontEndC_611,
+	&optlstFrontEndC_607,
+	0
+};
+OptionList optlstFrontEndC_620 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstFrontEndC_620_list
+};
+Option optlstFrontEndC_621 = {
+	/*     names = */ "str|strings",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstFrontEndC_620,
+	/* conflicts = */ 0,
+	/*      help = */ "specify string constant options"
+};
+ONOFF_T optlstFrontEndC623 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pFrontEndC.ansistrict
+};
+Option optlstFrontEndC_624 = {
+	/*     names = */ "strict",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC623,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "specify ANSI strictness checking"
+};
+ONOFF_T optlstFrontEndC626 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pFrontEndC.trigraphs
+};
+Option optlstFrontEndC_627 = {
+	/*     names = */ "trigraphs",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC626,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "enable recognition of trigraphs"
+};
+ONOFF_T optlstFrontEndC629 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pFrontEndC.wchar_type
+};
+Option optlstFrontEndC_630 = {
+	/*     names = */ "wchar_t",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC629,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "enable wchar_t as a built-in C++ type"
+};
+SET_T optlstFrontEndC633 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.enableexceptions
+};
+Option optlstFrontEndC_634 = {
+	/*     names = */ "fhandle-exceptions",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC633,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "enable true C++ exceptions"
+};
+SET_T optlstFrontEndC637 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.enableexceptions
+};
+Option optlstFrontEndC_638 = {
+	/*     names = */ "fno-handle-exceptions",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC637,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "disable true C++ exceptions"
+};
+SET_T optlstFrontEndC641 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.unsignedchars
+};
+Option optlstFrontEndC_642 = {
+	/*     names = */ "funsigned-char",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC641,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "unspecified chars as unsigned"
+};
+SET_T optlstFrontEndC645 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pFrontEndC.checkprotos
+};
+Option optlstFrontEndC_646 = {
+	/*     names = */ "fno-strict-prototype",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC645,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "don't require prototypes"
+};
+SET_T optlstFrontEndC649 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pFrontEndC.objective_c
+};
+Option optlstFrontEndC_650 = {
+	/*     names = */ "fobjc",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstFrontEndC649,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "allow Objective C extensions"
+};
+Option *optlstFrontEndC_651_list[] = {
+	&optlstFrontEndC_432,
+	&optlstFrontEndC_435,
+	&optlstFrontEndC_438,
+	&optlstFrontEndC_441,
+	&optlstFrontEndC_444,
+	&optlstFrontEndC_455,
+	&optlstFrontEndC_484,
+	&optlstFrontEndC_494,
+	&optlstFrontEndC_545,
+	&optlstFrontEndC_549,
+	&optlstFrontEndC_552,
+	&optlstFrontEndC_555,
+	&optlstFrontEndC_560,
+	&optlstFrontEndC_573,
+	&optlstFrontEndC_577,
+	&optlstFrontEndC_585,
+	&optlstFrontEndC_589,
+	&optlstFrontEndC_593,
+	&optlstFrontEndC_600,
+	&optlstFrontEndC_603,
+	&optlstFrontEndC_621,
+	&optlstFrontEndC_624,
+	&optlstFrontEndC_627,
+	&optlstFrontEndC_630,
+	&optlstFrontEndC_634,
+	&optlstFrontEndC_638,
+	&optlstFrontEndC_642,
+	&optlstFrontEndC_646,
+	&optlstFrontEndC_650,
+	0
+};
+OptionList optlstFrontEndC = {
+	/*  help = */ "C/C++ Support Options\n",
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstFrontEndC_651_list
+};
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsLinker.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsLinker.opt
new file mode 100644
index 0000000..1e1279a
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsLinker.opt
@@ -0,0 +1,321 @@
+/* Linker */
+STRING_T optlstLinker1061 = {
+	/*      which = */ PARAMWHICH_String,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*     maxlen = */ 64,
+	/*    pstring = */ 0,
+	/*        str = */ pLinker.mainname
+};
+SET_T optlstLinker1064 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstLinker1061,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ 0
+};
+Option optlstLinker_1065 = {
+	/*     names = */ "m|main",
+	/*     avail = */ OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstLinker1064,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "set main entry point for application, executable, orshared library"
+};
+FILEPATH_T optlstLinker1070 = {
+	/*      which = */ PARAMWHICH_FilePath,
+	/*      flags = */ 0x00,
+	/*     myname = */ "filename",
+	/*       next = */ 0,
+	/*     fflags = */ 1,
+	/* defaultstr = */ 0,
+	/*   filename = */ pCLTExtras.mapfilename,
+	/*     maxlen = */ 255
+};
+SET_T optlstLinker1068 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCLTExtras.gPrintMapToStdOutput
+};
+IFARG_T optlstLinker1072 = {
+	/*      which = */ PARAMWHICH_IfArg,
+	/*      flags = */ 0x12,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       parg = */ (PARAM_T *) &optlstLinker1070,
+	/*      helpa = */ "write map to 'filename'",
+	/*      pnone = */ (PARAM_T *) &optlstLinker1068,
+	/*      helpn = */ "write map to stdout"
+};
+SET_T optlstLinker1075 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstLinker1072,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pLinker.linkmap
+};
+Option optlstLinker_1076 = {
+	/*     names = */ "map",
+	/*     avail = */ OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstLinker1075,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "generate link map"
+};
+SET_T optlstLinker1079 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pLinker.multisymerror
+};
+Option optlstLinker_1080 = {
+	/*     names = */ "multisymerr",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstLinker1079,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "generate errors for multiply defined symbols"
+};
+GENERIC_T optlstLinker1082 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x00,
+	/*     myname = */ "file",
+	/*       next = */ 0,
+	/*      parse = */ &Opt_DummyLinkerRoutine,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstLinker_1083 = {
+	/*     names = */ "o",
+	/*     avail = */ OTF_ONLY_ONCE | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstLinker1082,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "specify output filename"
+};
+ONOFF_T optlstLinker1085 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pLinker.use_objectivec_semantics
+};
+Option optlstLinker_1086 = {
+	/*     names = */ "objc",
+	/*     avail = */ OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstLinker1085,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "use objective C semantics"
+};
+/* forward declare */ extern OptionList optlstLinker_1096_conflicts;
+SET_T optlstLinker1094 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pLinker.readonlyrelocs
+};
+Option optlstLinker_1096_1095 = {
+	/*     names = */ "errors",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstLinker1094,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstLinker_1096_conflicts,
+	/*      help = */ "as errors"
+};
+SET_T optlstLinker1091 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pLinker.readonlyrelocs
+};
+Option optlstLinker_1096_1092 = {
+	/*     names = */ "warnings",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstLinker1091,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstLinker_1096_conflicts,
+	/*      help = */ "as warnings"
+};
+SET_T optlstLinker1088 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pLinker.readonlyrelocs
+};
+Option optlstLinker_1096_1089 = {
+	/*     names = */ "supressed",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstLinker1088,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstLinker_1096_conflicts,
+	/*      help = */ "supressed"
+};
+Option *optlstLinker_1096_list[] = {
+	&optlstLinker_1096_1095,
+	&optlstLinker_1096_1092,
+	&optlstLinker_1096_1089,
+	0
+};
+OptionList optlstLinker_1096 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_LINKER,
+	/*  list = */ optlstLinker_1096_list
+};
+OptionList optlstLinker_1096_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_LINKER,
+	/*  list = */ optlstLinker_1096_list
+};
+Option optlstLinker_1097 = {
+	/*     names = */ "roreloc|readonlyrelocs",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstLinker_1096,
+	/* conflicts = */ 0,
+	/*      help = */ "treat read only relocations"
+};
+/* forward declare */ extern OptionList optlstLinker_1107_conflicts;
+SET_T optlstLinker1105 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pLinker.undefinedsymbols
+};
+Option optlstLinker_1107_1106 = {
+	/*     names = */ "errors",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstLinker1105,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstLinker_1107_conflicts,
+	/*      help = */ "as errors"
+};
+SET_T optlstLinker1102 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pLinker.undefinedsymbols
+};
+Option optlstLinker_1107_1103 = {
+	/*     names = */ "warnings",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstLinker1102,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstLinker_1107_conflicts,
+	/*      help = */ "as warnings"
+};
+SET_T optlstLinker1099 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 1,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pLinker.undefinedsymbols
+};
+Option optlstLinker_1107_1100 = {
+	/*     names = */ "supressed",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstLinker1099,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstLinker_1107_conflicts,
+	/*      help = */ "supressed"
+};
+Option *optlstLinker_1107_list[] = {
+	&optlstLinker_1107_1106,
+	&optlstLinker_1107_1103,
+	&optlstLinker_1107_1100,
+	0
+};
+OptionList optlstLinker_1107 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_LINKER,
+	/*  list = */ optlstLinker_1107_list
+};
+OptionList optlstLinker_1107_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_LINKER,
+	/*  list = */ optlstLinker_1107_list
+};
+Option optlstLinker_1108 = {
+	/*     names = */ "undefsym",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstLinker_1107,
+	/* conflicts = */ 0,
+	/*      help = */ "treat undefined symbols"
+};
+ONOFF_T optlstLinker1110 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pLinker.whatfileloaded
+};
+Option optlstLinker_1111 = {
+	/*     names = */ "whatfile",
+	/*     avail = */ OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstLinker1110,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "report what files are loaded"
+};
+ONOFF_T optlstLinker1113 = {
+	/*      which = */ PARAMWHICH_OnOff,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*        var = */ &pLinker.whyfileloaded
+};
+Option optlstLinker_1114 = {
+	/*     names = */ "whyfile",
+	/*     avail = */ OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstLinker1113,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "report why files are loaded"
+};
+Option *optlstLinker_1115_list[] = {
+	&optlstLinker_1065,
+	&optlstLinker_1076,
+	&optlstLinker_1080,
+	&optlstLinker_1083,
+	&optlstLinker_1086,
+	&optlstLinker_1097,
+	&optlstLinker_1108,
+	&optlstLinker_1111,
+	&optlstLinker_1114,
+	0
+};
+OptionList optlstLinker = {
+	/*  help = */ "Mach-O PowerPC Linker Options\n",
+	/* flags = */ LISTFLAGS_LINKER,
+	/*  list = */ optlstLinker_1115_list
+};
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsOptimizer.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsOptimizer.opt
new file mode 100644
index 0000000..177a79e
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsOptimizer.opt
@@ -0,0 +1,765 @@
+/* Optimizer */
+GENERIC_T optlstOptimizer748 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G2Pe",
+	/*       help = */ 0
+};
+Option optlstOptimizer_749 = {
+	/*     names = */ "O",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer748,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as '~~O2'"
+};
+GENERIC_T optlstOptimizer769 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G0",
+	/*       help = */ 0
+};
+Option optlstOptimizer_770 = {
+	/*     names = */ "0",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer769,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as '~~opt l0'"
+};
+GENERIC_T optlstOptimizer766 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G1",
+	/*       help = */ 0
+};
+Option optlstOptimizer_767 = {
+	/*     names = */ "1",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer766,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as '~~opt l1'"
+};
+GENERIC_T optlstOptimizer763 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G2Pe",
+	/*       help = */ 0
+};
+Option optlstOptimizer_764 = {
+	/*     names = */ "2",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer763,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as '~~opt l2, peephole'"
+};
+GENERIC_T optlstOptimizer760 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G3Pe",
+	/*       help = */ 0
+};
+Option optlstOptimizer_761 = {
+	/*     names = */ "3",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer760,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as '~~opt l3, peephole'"
+};
+GENERIC_T optlstOptimizer757 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G4ShPe",
+	/*       help = */ 0
+};
+Option optlstOptimizer_758 = {
+	/*     names = */ "4||5|6|7",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer757,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as '~~opt l4, peephole, schedule'"
+};
+GENERIC_T optlstOptimizer754 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Gp",
+	/*       help = */ 0
+};
+Option optlstOptimizer_755 = {
+	/*     names = */ "p",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer754,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as '~~opt speed'"
+};
+GENERIC_T optlstOptimizer751 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Gs",
+	/*       help = */ 0
+};
+Option optlstOptimizer_752 = {
+	/*     names = */ "s",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer751,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as '~~opt space'"
+};
+Option *optlstOptimizer_771_list[] = {
+	&optlstOptimizer_770,
+	&optlstOptimizer_767,
+	&optlstOptimizer_764,
+	&optlstOptimizer_761,
+	&optlstOptimizer_758,
+	&optlstOptimizer_755,
+	&optlstOptimizer_752,
+	0
+};
+OptionList optlstOptimizer_771 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstOptimizer_771_list
+};
+Option optlstOptimizer_772 = {
+	/*     names = */ "O",
+	/*     avail = */ OTF_STICKY | OTF_CASED | OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstOptimizer_771,
+	/* conflicts = */ 0,
+	/*      help = */ "control optimization; you may combine options as in '~~O4,p'"
+};
+GENERIC_T optlstOptimizer867 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G0Sn-Pe",
+	/*       help = */ 0
+};
+Option optlstOptimizer_868 = {
+	/*     names = */ "off|none",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer867,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "suppress all optimizations"
+};
+GENERIC_T optlstOptimizer864 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G2Pe",
+	/*       help = */ 0
+};
+Option optlstOptimizer_865 = {
+	/*     names = */ "on",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer864,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as '~~opt l2, peephole'"
+};
+GENERIC_T optlstOptimizer861 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G4GpShPe",
+	/*       help = */ 0
+};
+Option optlstOptimizer_862 = {
+	/*     names = */ "all|full",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer861,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as '~~opt l4, speed, peephole, schedule'"
+};
+GENERIC_T optlstOptimizer858 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Gs",
+	/*       help = */ 0
+};
+Option optlstOptimizer_859 = {
+	/*     names = */ "space|size",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer858,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "optimize for space"
+};
+GENERIC_T optlstOptimizer855 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Gp",
+	/*       help = */ 0
+};
+Option optlstOptimizer_856 = {
+	/*     names = */ "speed",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer855,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "optimize for speed"
+};
+GENERIC_T optlstOptimizer850 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetPragmaOptimizationsToUnspecified,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+NUM_T optlstOptimizer852 = {
+	/*      which = */ PARAMWHICH_Number,
+	/*      flags = */ 0x00,
+	/*     myname = */ "num",
+	/*       next = */ (PARAM_T *) &optlstOptimizer850,
+	/*       size = */ 1,
+	/*        fit = */ 0,
+	/*         lo = */ 0,
+	/*         hi = */ 4,
+	/*        num = */ &pGlobalOptimizer.optimizationlevel
+};
+Option optlstOptimizer_853 = {
+	/*     names = */ "l|level",
+	/*     avail = */ OTF_ONLY_ONCE | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer852,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "set optimization level:\rlevel 0: global register allocation only for temporary values\rlevel 1: adds dead code elimination\rlevel 2: adds common subexpression elimination and copy propagation\rlevel 3: adds loop transformations, strength reducation, and loop-invariant code motion\rlevel 4: adds repeated common subexpression elimination and loop-invariant code motion"
+};
+GENERIC_T optlstOptimizer847 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G0",
+	/*       help = */ 0
+};
+Option optlstOptimizer_848 = {
+	/*     names = */ "l0",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer847,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "level 0: global register allocation only for temporary values"
+};
+GENERIC_T optlstOptimizer844 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G1",
+	/*       help = */ 0
+};
+Option optlstOptimizer_845 = {
+	/*     names = */ "l1",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer844,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "level 1: adds dead code elimination"
+};
+GENERIC_T optlstOptimizer841 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G2",
+	/*       help = */ 0
+};
+Option optlstOptimizer_842 = {
+	/*     names = */ "l2",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer841,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "level 2: adds common subexpression elimination and copy propagation"
+};
+GENERIC_T optlstOptimizer838 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G3",
+	/*       help = */ 0
+};
+Option optlstOptimizer_839 = {
+	/*     names = */ "l3",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer838,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "level 3: adds loop transformations, strength reducation, and loop-invariant code motion"
+};
+GENERIC_T optlstOptimizer835 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G4",
+	/*       help = */ 0
+};
+Option optlstOptimizer_836 = {
+	/*     names = */ "l4",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer835,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "level 4: adds repeated common subexpression elimination and loop-invariant code motion"
+};
+GENERIC_T optlstOptimizer832 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Cs",
+	/*       help = */ 0
+};
+Option optlstOptimizer_833 = {
+	/*     names = */ "cse|commonsubs",
+	/*     avail = */ OTF_COMPATIBILITY | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer832,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "common subexpression elimination"
+};
+GENERIC_T optlstOptimizer829 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Dc",
+	/*       help = */ 0
+};
+Option optlstOptimizer_830 = {
+	/*     names = */ "deadcode",
+	/*     avail = */ OTF_COMPATIBILITY | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer829,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "removal of dead code"
+};
+GENERIC_T optlstOptimizer826 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Ds",
+	/*       help = */ 0
+};
+Option optlstOptimizer_827 = {
+	/*     names = */ "deadstore",
+	/*     avail = */ OTF_COMPATIBILITY | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer826,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "removal of dead assignments"
+};
+GENERIC_T optlstOptimizer823 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Lt",
+	/*       help = */ 0
+};
+Option optlstOptimizer_824 = {
+	/*     names = */ "lifetimes",
+	/*     avail = */ OTF_COMPATIBILITY | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer823,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "computation of variable lifetimes"
+};
+GENERIC_T optlstOptimizer820 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Li",
+	/*       help = */ 0
+};
+Option optlstOptimizer_821 = {
+	/*     names = */ "loop|loopinvariants",
+	/*     avail = */ OTF_COMPATIBILITY | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer820,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "removal of loop invariants"
+};
+GENERIC_T optlstOptimizer817 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Pr",
+	/*       help = */ 0
+};
+Option optlstOptimizer_818 = {
+	/*     names = */ "prop|propagation",
+	/*     avail = */ OTF_COMPATIBILITY | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer817,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "propagation of constant and copy assignments"
+};
+GENERIC_T optlstOptimizer814 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Sr",
+	/*       help = */ 0
+};
+Option optlstOptimizer_815 = {
+	/*     names = */ "strength",
+	/*     avail = */ OTF_COMPATIBILITY | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer814,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "strength reduction; reducing multiplication by an index variable into addition"
+};
+Option optlstOptimizer_812 = {
+	/*     names = */ "global",
+	/*     avail = */ OTF_IGNORED | OTF_HIDE_DEFAULT | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ 0,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "global optimization is controlled through '-opt level=X'"
+};
+GENERIC_T optlstOptimizer810 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Pe",
+	/*       help = */ 0
+};
+Option optlstOptimizer_811 = {
+	/*     names = */ "peep|peephole",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer810,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "peephole optimization"
+};
+GENERIC_T optlstOptimizer807 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Rc",
+	/*       help = */ 0
+};
+Option optlstOptimizer_808 = {
+	/*     names = */ "color",
+	/*     avail = */ OTF_COMPATIBILITY | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer807,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "register coloring"
+};
+GENERIC_T optlstOptimizer804 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "Sh",
+	/*       help = */ 0
+};
+Option optlstOptimizer_805 = {
+	/*     names = */ "schedule",
+	/*     avail = */ OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer804,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "schedule instructions (see '~~proc')"
+};
+GENERIC_T optlstOptimizer801 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "S1",
+	/*       help = */ 0
+};
+Option optlstOptimizer_802 = {
+	/*     names = */ "schedule601",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer801,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "-opt schedule, -proc 601"
+};
+GENERIC_T optlstOptimizer798 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "S3",
+	/*       help = */ 0
+};
+Option optlstOptimizer_799 = {
+	/*     names = */ "schedule603",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer798,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "-opt schedule, -proc 603"
+};
+GENERIC_T optlstOptimizer795 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "S#",
+	/*       help = */ 0
+};
+Option optlstOptimizer_796 = {
+	/*     names = */ "schedule603e",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer795,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "-opt schedule, -proc 603e"
+};
+GENERIC_T optlstOptimizer792 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "S4",
+	/*       help = */ 0
+};
+Option optlstOptimizer_793 = {
+	/*     names = */ "schedule604",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer792,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "-opt schedule, -proc 604"
+};
+GENERIC_T optlstOptimizer789 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "S$",
+	/*       help = */ 0
+};
+Option optlstOptimizer_790 = {
+	/*     names = */ "schedule604e",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer789,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "-opt schedule, -proc 604e"
+};
+GENERIC_T optlstOptimizer786 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "S7",
+	/*       help = */ 0
+};
+Option optlstOptimizer_787 = {
+	/*     names = */ "schedule750",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer786,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "-opt schedule, -proc 750"
+};
+GENERIC_T optlstOptimizer783 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "SA",
+	/*       help = */ 0
+};
+Option optlstOptimizer_784 = {
+	/*     names = */ "schedulealtivec",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer783,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "-opt schedule, -proc altivec"
+};
+GENERIC_T optlstOptimizer780 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G1PeS1",
+	/*       help = */ 0
+};
+Option optlstOptimizer_781 = {
+	/*     names = */ "inter|local|unroll",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer780,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "opt level=1, peep, schedule=601"
+};
+GENERIC_T optlstOptimizer777 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetOptFlags,
+	/*        arg = */ (void *) "G2PeS1",
+	/*       help = */ 0
+};
+Option optlstOptimizer_778 = {
+	/*     names = */ "rep",
+	/*     avail = */ OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer777,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "opt level=2, peep, schedule=601"
+};
+GENERIC_T optlstOptimizer774 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &DisplayOptimizationOptions,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstOptimizer_775 = {
+	/*     names = */ "display|dump",
+	/*     avail = */ OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstOptimizer774,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "display list of active optimizations"
+};
+Option *optlstOptimizer_869_list[] = {
+	&optlstOptimizer_868,
+	&optlstOptimizer_865,
+	&optlstOptimizer_862,
+	&optlstOptimizer_859,
+	&optlstOptimizer_856,
+	&optlstOptimizer_853,
+	&optlstOptimizer_848,
+	&optlstOptimizer_845,
+	&optlstOptimizer_842,
+	&optlstOptimizer_839,
+	&optlstOptimizer_836,
+	&optlstOptimizer_833,
+	&optlstOptimizer_830,
+	&optlstOptimizer_827,
+	&optlstOptimizer_824,
+	&optlstOptimizer_821,
+	&optlstOptimizer_818,
+	&optlstOptimizer_815,
+	&optlstOptimizer_812,
+	&optlstOptimizer_811,
+	&optlstOptimizer_808,
+	&optlstOptimizer_805,
+	&optlstOptimizer_802,
+	&optlstOptimizer_799,
+	&optlstOptimizer_796,
+	&optlstOptimizer_793,
+	&optlstOptimizer_790,
+	&optlstOptimizer_787,
+	&optlstOptimizer_784,
+	&optlstOptimizer_781,
+	&optlstOptimizer_778,
+	&optlstOptimizer_775,
+	0
+};
+OptionList optlstOptimizer_869 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_ALLOW_UNKNOWNS | LISTFLAGS_COMPILER,
+	/*  list = */ optlstOptimizer_869_list
+};
+Option optlstOptimizer_870 = {
+	/*     names = */ "opt",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstOptimizer_869,
+	/* conflicts = */ 0,
+	/*      help = */ "specify optimization options"
+};
+Option *optlstOptimizer_871_list[] = {
+	&optlstOptimizer_749,
+	&optlstOptimizer_772,
+	&optlstOptimizer_870,
+	0
+};
+OptionList optlstOptimizer = {
+	/*  help = */ "Optimizer Options\n\tNote that all options besides '-opt off|on|all|space|speed|level=...' (marked with 'compatibility') are for backwards compatibility or special needs only; other optimization options may be superceded by use of '~~opt level=xxx'.\b",
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstOptimizer_871_list
+};
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsProject.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsProject.opt
new file mode 100644
index 0000000..095ddb9
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsProject.opt
@@ -0,0 +1,320 @@
+/* forward declare */ extern OptionList projtype_conflicts;
+
+/* Project */
+SET_T optlstProject1012 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pProject.type
+};
+Option projtype_1013 = {
+	/*     names = */ "app|application",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstProject1012,
+	/*       sub = */ 0,
+	/* conflicts = */ &projtype_conflicts,
+	/*      help = */ "generate an application bundle; same as '~~xm a'"
+};
+SET_T optlstProject1015 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pProject.type
+};
+Option projtype_1016 = {
+	/*     names = */ "exe|executable",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstProject1015,
+	/*       sub = */ 0,
+	/* conflicts = */ &projtype_conflicts,
+	/*      help = */ "generate an excutable; same as '~~xm e'"
+};
+SET_T optlstProject1018 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x4,
+	/*        num = */ (char *) &pProject.type
+};
+Option projtype_1019 = {
+	/*     names = */ "lib|library",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstProject1018,
+	/*       sub = */ 0,
+	/* conflicts = */ &projtype_conflicts,
+	/*      help = */ "generate a static library; same as '~~xm l'"
+};
+SET_T optlstProject1021 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x3,
+	/*        num = */ (char *) &pProject.type
+};
+Option projtype_1022 = {
+	/*     names = */ "obj|object",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstProject1021,
+	/*       sub = */ 0,
+	/* conflicts = */ &projtype_conflicts,
+	/*      help = */ "generate an object; same as '~~xm o'"
+};
+SET_T optlstProject1024 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pProject.type
+};
+Option projtype_1025 = {
+	/*     names = */ "shared|sharedlibrary||shlib",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstProject1024,
+	/*       sub = */ 0,
+	/* conflicts = */ &projtype_conflicts,
+	/*      help = */ "generate a shared library; same as '~~xm s'"
+};
+/* forward declare */ extern OptionList optlstProject_1041_conflicts;
+SET_T optlstProject1039 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x0,
+	/*        num = */ (char *) &pProject.type
+};
+Option optlstProject_1041_1040 = {
+	/*     names = */ "a|application",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstProject1039,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstProject_1041_conflicts,
+	/*      help = */ "application bundle"
+};
+SET_T optlstProject1036 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pProject.type
+};
+Option optlstProject_1041_1037 = {
+	/*     names = */ "e|executable",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstProject1036,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstProject_1041_conflicts,
+	/*      help = */ "executable"
+};
+SET_T optlstProject1033 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x4,
+	/*        num = */ (char *) &pProject.type
+};
+Option optlstProject_1041_1034 = {
+	/*     names = */ "l|library",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstProject1033,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstProject_1041_conflicts,
+	/*      help = */ "static library"
+};
+SET_T optlstProject1030 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x3,
+	/*        num = */ (char *) &pProject.type
+};
+Option optlstProject_1041_1031 = {
+	/*     names = */ "o|object",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstProject1030,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstProject_1041_conflicts,
+	/*      help = */ "object"
+};
+SET_T optlstProject1027 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 2,
+	/*      value = */ 0x2,
+	/*        num = */ (char *) &pProject.type
+};
+Option optlstProject_1041_1028 = {
+	/*     names = */ "s|sharedlibrary",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_CONFLICTS,
+	/*     param = */ (PARAM_T *) &optlstProject1027,
+	/*       sub = */ 0,
+	/* conflicts = */ &optlstProject_1041_conflicts,
+	/*      help = */ "shared library"
+};
+Option *optlstProject_1041_list[] = {
+	&optlstProject_1041_1040,
+	&optlstProject_1041_1037,
+	&optlstProject_1041_1034,
+	&optlstProject_1041_1031,
+	&optlstProject_1041_1028,
+	0
+};
+OptionList optlstProject_1041 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_LINKER,
+	/*  list = */ optlstProject_1041_list
+};
+OptionList optlstProject_1041_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_EXCLUSIVE | LISTFLAGS_LINKER,
+	/*  list = */ optlstProject_1041_list
+};
+Option projtype_1042 = {
+	/*     names = */ "xm",
+	/*     avail = */ OTF_TOOL_LINKER | OTF_HAS_SUB_OPTIONS | OTF_HAS_CONFLICTS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstProject_1041,
+	/* conflicts = */ &projtype_conflicts,
+	/*      help = */ "specify project type"
+};
+FTYPE_T optlstProject1043 = {
+	/*      which = */ PARAMWHICH_FTypeCreator,
+	/*      flags = */ 0x00,
+	/*     myname = */ "creator",
+	/*       next = */ 0,
+	/*         fc = */ &pProject.filecreator,
+	/*  iscreator = */ 30
+};
+SET_T optlstProject1046 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstProject1043,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCLTExtras.userSetCreator
+};
+Option optlstProject_1047 = {
+	/*     names = */ "fc",
+	/*     avail = */ OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstProject1046,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "specify output file creator; not used with static libs and MPW tools"
+};
+FTYPE_T optlstProject1048 = {
+	/*      which = */ PARAMWHICH_FTypeCreator,
+	/*      flags = */ 0x00,
+	/*     myname = */ "type",
+	/*       next = */ 0,
+	/*         fc = */ &pProject.filetype,
+	/*  iscreator = */ 156
+};
+SET_T optlstProject1051 = {
+	/*      which = */ PARAMWHICH_Set,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ (PARAM_T *) &optlstProject1048,
+	/*       size = */ 1,
+	/*      value = */ 0x1,
+	/*        num = */ (char *) &pCLTExtras.userSetType
+};
+Option optlstProject_1052 = {
+	/*     names = */ "ft",
+	/*     avail = */ OTF_ONLY_ONCE | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstProject1051,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "specify output file type; not used with static libs and MPW tools"
+};
+NUM_T optlstProject1054 = {
+	/*      which = */ PARAMWHICH_Number,
+	/*      flags = */ 0x00,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*        fit = */ 0,
+	/*         lo = */ 0,
+	/*         hi = */ 0,
+	/*        num = */ &pProject.stackaddress
+};
+Option optlstProject_1055 = {
+	/*     names = */ "stackaddr",
+	/*     avail = */ OTF_HIDE_DEFAULT | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstProject1054,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "specify stack address; default is 0"
+};
+NUM_T optlstProject1057 = {
+	/*      which = */ PARAMWHICH_Number,
+	/*      flags = */ 0x00,
+	/*     myname = */ "kB",
+	/*       next = */ 0,
+	/*       size = */ 4,
+	/*        fit = */ 0,
+	/*         lo = */ 0,
+	/*         hi = */ 0,
+	/*        num = */ &pProject.stacksize
+};
+Option optlstProject_1058 = {
+	/*     names = */ "stacksize",
+	/*     avail = */ OTF_HIDE_DEFAULT | OTF_TOOL_LINKER,
+	/*     param = */ (PARAM_T *) &optlstProject1057,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "specify stack size in kilobytes default is kDefaultStackSize (i.e., determined by loader)"
+};
+Option *optlstProject_1059_list[] = {
+	&projtype_1013,
+	&projtype_1016,
+	&projtype_1019,
+	&projtype_1022,
+	&projtype_1025,
+	&projtype_1042,
+	&optlstProject_1047,
+	&optlstProject_1052,
+	&optlstProject_1055,
+	&optlstProject_1058,
+	0
+};
+OptionList optlstProject = {
+	/*  help = */ "Mach-O PowerPC Project Options\n",
+	/* flags = */ LISTFLAGS_LINKER,
+	/*  list = */ optlstProject_1059_list
+};
+Option *projtype_000_list[] = {
+	&projtype_1013,
+	&projtype_1016,
+	&projtype_1019,
+	&projtype_1022,
+	&projtype_1025,
+	&projtype_1042,
+	0
+};
+OptionList projtype_conflicts = {
+	/*  help = */ 0,
+	/* flags = */ 0,
+	/*  list = */ projtype_000_list
+};
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsWarningC.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsWarningC.opt
new file mode 100644
index 0000000..ff8b345
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsWarningC.opt
@@ -0,0 +1,583 @@
+/* WarningC */
+GENERIC_T optlstWarningC659 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "IpEdPuUvUaEcPdHvIcNiCw",
+	/*       help = */ 0
+};
+Option optlstWarningC_660 = {
+	/*     names = */ "1",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC659,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as ~~w on"
+};
+GENERIC_T optlstWarningC656 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "IpEdPuUvUaEcPdHvIcNiCpLaScCw",
+	/*       help = */ 0
+};
+Option optlstWarningC_657 = {
+	/*     names = */ "2",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC656,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as ~~w all"
+};
+GENERIC_T optlstWarningC653 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "IpEdPuUvUaEcPdHvIcNiCw-UvUa",
+	/*       help = */ 0
+};
+Option optlstWarningC_654 = {
+	/*     names = */ "3",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC653,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as ~~w on,nounused"
+};
+Option *optlstWarningC_661_list[] = {
+	&optlstWarningC_660,
+	&optlstWarningC_657,
+	&optlstWarningC_654,
+	0
+};
+OptionList optlstWarningC_661 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_COMPILER,
+	/*  list = */ optlstWarningC_661_list
+};
+Option optlstWarningC_662 = {
+	/*     names = */ "w",
+	/*     avail = */ OTF_GLOBAL | OTF_STICKY | OTF_CASED | OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstWarningC_661,
+	/* conflicts = */ 0,
+	/*      help = */ "compatibility warning options"
+};
+GENERIC_T optlstWarningC727 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "Cw",
+	/*       help = */ 0
+};
+Option optlstWarningC_728 = {
+	/*     names = */ "options|cmdline",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstWarningC727,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "command-line parser warnings"
+};
+GENERIC_T optlstWarningC724 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "-IpEdPuUvUaEcPdHvIcNiCpLaScWeCw|Nw",
+	/*       help = */ 0
+};
+Option optlstWarningC_725 = {
+	/*     names = */ "off",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstWarningC724,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "turn off all warnings"
+};
+GENERIC_T optlstWarningC721 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "IpEdPuUvUaEcPdHvIcNiCw",
+	/*       help = */ 0
+};
+Option optlstWarningC_722 = {
+	/*     names = */ "on",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstWarningC721,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "turn on most warnings, except 'largeargs' and 'structclass'"
+};
+GENERIC_T optlstWarningC718 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "IpEdPuUvUaEcPdHvIcNiCw",
+	/*       help = */ 0
+};
+Option optlstWarningC_719 = {
+	/*     names = */ "conformance|usage",
+	/*     avail = */ OTF_GLOBAL | OTF_SECRET | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC718,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as '-w on'"
+};
+GENERIC_T optlstWarningC715 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "IpEdPuUvUaEcPdHvIcNiCpLaScCw",
+	/*       help = */ 0
+};
+Option optlstWarningC_716 = {
+	/*     names = */ "all|full",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC715,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "turn on all warnings, require prototypes"
+};
+GENERIC_T optlstWarningC712 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "We",
+	/*       help = */ 0
+};
+Option optlstWarningC_713 = {
+	/*     names = */ "err|error|iserr|iserror",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstWarningC712,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "warnings are errors"
+};
+GENERIC_T optlstWarningC709 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "Ip",
+	/*       help = */ 0
+};
+Option optlstWarningC_710 = {
+	/*     names = */ "pragmas|illpragmas",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC709,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "illegal #pragmas"
+};
+GENERIC_T optlstWarningC706 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "Ed",
+	/*       help = */ 0
+};
+Option optlstWarningC_707 = {
+	/*     names = */ "empty|emptydecl",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC706,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "empty declarations"
+};
+GENERIC_T optlstWarningC703 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "Pu",
+	/*       help = */ 0
+};
+Option optlstWarningC_704 = {
+	/*     names = */ "possible|unwanted",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC703,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "possible unwanted effects"
+};
+GENERIC_T optlstWarningC700 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "UaUv",
+	/*       help = */ 0
+};
+Option optlstWarningC_701 = {
+	/*     names = */ "unused",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC700,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "unused arguments and variables"
+};
+GENERIC_T optlstWarningC697 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "Ua",
+	/*       help = */ 0
+};
+Option optlstWarningC_698 = {
+	/*     names = */ "unusedarg",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC697,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "unused arguments"
+};
+GENERIC_T optlstWarningC694 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "Uv",
+	/*       help = */ 0
+};
+Option optlstWarningC_695 = {
+	/*     names = */ "unusedvar",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC694,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "unused variables"
+};
+GENERIC_T optlstWarningC691 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "UaUv",
+	/*       help = */ 0
+};
+Option optlstWarningC_692 = {
+	/*     names = */ "unused",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC691,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as ~~w [no]unusedarg,[no]unusedvar"
+};
+GENERIC_T optlstWarningC688 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "Ec",
+	/*       help = */ 0
+};
+Option optlstWarningC_689 = {
+	/*     names = */ "extracomma|comma",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC688,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "extra commas"
+};
+GENERIC_T optlstWarningC685 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "Pd",
+	/*       help = */ 0
+};
+Option optlstWarningC_686 = {
+	/*     names = */ "pedantic|extended",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC685,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "pedantic error checking"
+};
+GENERIC_T optlstWarningC682 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "Hv",
+	/*       help = */ 0
+};
+Option optlstWarningC_683 = {
+	/*     names = */ "hidevirtual|hidden|hiddenvirtual",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC682,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "hidden virtual functions"
+};
+GENERIC_T optlstWarningC679 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "Ic",
+	/*       help = */ 0
+};
+Option optlstWarningC_680 = {
+	/*     names = */ "implicit|implicitconv",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC679,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "implicit arithmetic conversions"
+};
+GENERIC_T optlstWarningC676 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "Ni",
+	/*       help = */ 0
+};
+Option optlstWarningC_677 = {
+	/*     names = */ "notinlined",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC676,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "'inline' functions not inlined"
+};
+GENERIC_T optlstWarningC673 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "La",
+	/*       help = */ 0
+};
+Option optlstWarningC_674 = {
+	/*     names = */ "largeargs",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC673,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "passing large arguments to unprototyped functions"
+};
+GENERIC_T optlstWarningC670 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "Sc",
+	/*       help = */ 0
+};
+Option optlstWarningC_671 = {
+	/*     names = */ "structclass",
+	/*     avail = */ OTF_GLOBAL | OTF_SLFLAGS_8 | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC670,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "inconsistent use of 'class' and 'struct'"
+};
+GENERIC_T optlstWarningC667 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "-IpEdPuUvUaEcPdHvIcNiCpLaScCw|Nw",
+	/*       help = */ 0
+};
+Option optlstWarningC_668 = {
+	/*     names = */ "",
+	/*     avail = */ OTF_GLOBAL | OTF_WARNING | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC667,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "Option 'w' deprecated, use 'w off' instead;\r'w' not passed to linker;\rparse error will occur if a non-option follows"
+};
+GENERIC_T optlstWarningC664 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &DisplayWarningOptions,
+	/*        arg = */ (void *) 0,
+	/*       help = */ 0
+};
+Option optlstWarningC_665 = {
+	/*     names = */ "display|dump",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER,
+	/*     param = */ (PARAM_T *) &optlstWarningC664,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "display list of active warnings"
+};
+Option *optlstWarningC_729_list[] = {
+	&optlstWarningC_728,
+	&optlstWarningC_725,
+	&optlstWarningC_722,
+	&optlstWarningC_719,
+	&optlstWarningC_716,
+	&optlstWarningC_713,
+	&optlstWarningC_710,
+	&optlstWarningC_707,
+	&optlstWarningC_704,
+	&optlstWarningC_701,
+	&optlstWarningC_698,
+	&optlstWarningC_695,
+	&optlstWarningC_692,
+	&optlstWarningC_689,
+	&optlstWarningC_686,
+	&optlstWarningC_683,
+	&optlstWarningC_680,
+	&optlstWarningC_677,
+	&optlstWarningC_674,
+	&optlstWarningC_671,
+	&optlstWarningC_668,
+	&optlstWarningC_665,
+	0
+};
+OptionList optlstWarningC_729 = {
+	/*  help = */ 0,
+	/* flags = */ LISTFLAGS_ALLOW_UNKNOWNS | LISTFLAGS_COMPILER,
+	/*  list = */ optlstWarningC_729_list
+};
+Option optlstWarningC_730 = {
+	/*     names = */ "w|warnings",
+	/*     avail = */ OTF_GLOBAL | OTF_TOOL_COMPILER | OTF_HAS_SUB_OPTIONS,
+	/*     param = */ 0,
+	/*       sub = */ &optlstWarningC_729,
+	/* conflicts = */ 0,
+	/*      help = */ "warning options"
+};
+GENERIC_T optlstWarningC732 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "IpPuHvEd",
+	/*       help = */ 0
+};
+Option optlstWarningC_733 = {
+	/*     names = */ "Wmost",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstWarningC732,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "turn on pragmas, emptydecl, possible, hidevirtual"
+};
+GENERIC_T optlstWarningC735 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "IpEdPuUvUaEcPdHvIcNiCpLaSc",
+	/*       help = */ 0
+};
+Option optlstWarningC_736 = {
+	/*     names = */ "Wall",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstWarningC735,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as -w all"
+};
+GENERIC_T optlstWarningC738 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "We",
+	/*       help = */ 0
+};
+Option optlstWarningC_739 = {
+	/*     names = */ "Werror",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstWarningC738,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as -w iserror"
+};
+GENERIC_T optlstWarningC741 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "UaUv",
+	/*       help = */ 0
+};
+Option optlstWarningC_742 = {
+	/*     names = */ "Wunused",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstWarningC741,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "same as -w unusedarg,unusedvar"
+};
+GENERIC_T optlstWarningC744 = {
+	/*      which = */ PARAMWHICH_Generic,
+	/*      flags = */ 0x01,
+	/*     myname = */ 0,
+	/*       next = */ 0,
+	/*      parse = */ &SetWarningFlags,
+	/*        arg = */ (void *) "-UaUv",
+	/*       help = */ 0
+};
+Option optlstWarningC_745 = {
+	/*     names = */ "Wno-unused",
+	/*     avail = */ OTF_TOOL_COMPILER | OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER,
+	/*     param = */ (PARAM_T *) &optlstWarningC744,
+	/*       sub = */ 0,
+	/* conflicts = */ 0,
+	/*      help = */ "turns off -w unusedarg,unusedvar"
+};
+Option *optlstWarningC_746_list[] = {
+	&optlstWarningC_662,
+	&optlstWarningC_730,
+	&optlstWarningC_733,
+	&optlstWarningC_736,
+	&optlstWarningC_739,
+	&optlstWarningC_742,
+	&optlstWarningC_745,
+	0
+};
+OptionList optlstWarningC = {
+	/*  help = */ "Warning Options\n",
+	/* flags = */ LISTFLAGS_COMPILER | LISTFLAGS_LINKER | LISTFLAGS_DISASSEMBLER,
+	/*  list = */ optlstWarningC_746_list
+};
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsCmdLine.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsCmdLine.opt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsCmdLine.opt
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsCmdLineLinker.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsCmdLineLinker.opt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsCmdLineLinker.opt
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsDebugging.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsDebugging.opt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsDebugging.opt
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsDumper.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsDumper.opt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsDumper.opt
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsLinker.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsLinker.opt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsLinker.opt
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsProject.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsProject.opt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsProject.opt
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsWarning.opt b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsWarning.opt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-ld/OptsWarning.opt
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-cc.c b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-cc.c
new file mode 100644
index 0000000..7e741c3
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-cc.c
@@ -0,0 +1,137 @@
+#include "cmdline.h"
+#include "parser.h"
+
+#include "compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-common.h"
+
+static Boolean useDefaultIncludes = 1;
+static Boolean useDefaultLibraries = 1;
+
+#include "compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsCmdLine.opt"
+#include "compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsCmdLineCompiler.opt"
+#include "compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsCmdLineLinker.opt"
+#include "compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsFrontEndC.opt"
+#include "compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsDebugging.opt"
+#include "compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsOptimizer.opt"
+#include "compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsWarningC.opt"
+#include "compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsBackEnd.opt"
+#include "compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsProject.opt"
+#include "compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsLinker.opt"
+#include "compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/OptsDumper.opt"
+
+char *prefs[] = {
+        "PPC CodeGen Mach-O",
+        "PPC Mach-O Linker",
+        "PPC Mach-O Target",
+        "PPC Disassembler",
+        "PPC Global Optimizer",
+        "C/C++ Compiler",
+        "C/C++ Warnings",
+        "CmdLine Panel",
+        "CmdLine Compiler Panel",
+        "CmdLine Linker Panel"
+};
+
+OptionList *optLists[] = {
+        &optlstCmdLine,
+        &optlstCmdLineCompiler,
+        &optlstFrontEndC,
+        &optlstBackEnd,
+        &optlstOptimizer,
+        &optlstDebugging,
+        &optlstWarningC,
+        &optlstProject,
+        &optlstCmdLineLinker,
+        &optlstLinker,
+        &optlstDumper
+};
+
+static PrefDataPanel stPrefPanels[] = {
+        "PPC CodeGen Mach-O", &pBackEnd, sizeof(pBackEnd),
+        "PPC Mach-O Linker", &pLinker, sizeof(pLinker),
+        "PPC Mach-O Target", &pProject, sizeof(pProject),
+        "PPC Disassembler", &pDisassembler, sizeof(pDisassembler),
+        "PPC Global Optimizer", &pGlobalOptimizer, sizeof(pGlobalOptimizer),
+        "C/C++ Compiler", &pFrontEndC, sizeof(pFrontEndC),
+        "C/C++ Warnings", &pWarningC, sizeof(pWarningC),
+        "CmdLine Panel", &pCmdLine, sizeof(pCmdLine),
+        "CmdLine Compiler Panel", &pCmdLineCompiler, sizeof(pCmdLineCompiler),
+        "CmdLine Linker Panel", &pCmdLineLinker, sizeof(pCmdLineLinker)
+};
+
+static int PreParse() {
+    setLinkerOutputFilename = 0;
+    linkerOutputFilename[0] = 0;
+    definesHandle = NULL;
+    useDefaultIncludes = 1;
+    schedule_ppc_default = 0;
+    return 1;
+}
+
+static int MidParse() {
+    const char *match;
+    const char *env;
+
+    if (!pCmdLine.state)
+        pCmdLine.state = OptsCmdLineState_2;
+
+    if (parseopts.possibleFiles > 0 && useDefaultIncludes) {
+        if ((env = GetEnvVar("MWCMachPPCIncludes", 1, &match))) {
+            // FIXME can probably get rid of this cast later
+            if (!AddAccessPathList(env, ':', ',', 1, (char *) match, 1, -1, 0))
+                return 0;
+        }
+    }
+
+    return 1;
+}
+
+static int PostParse() {
+    if (!SetupPragmas(irPragmas) || !SetupPragmas(warningPragmas))
+        return 0;
+
+    if (definesHandle) {
+        static const char *name = "(command-line defines)";
+        if (pCmdLine.verbose)
+            ShowTextHandle(name, definesHandle);
+        AddVirtualFile(name, &definesHandle);
+        c2pstrcpy(pFrontEndC.oldprefixname, name);
+    } else {
+        pFrontEndC.oldprefixname[0] = 0;
+    }
+
+    FinishCompilerTool();
+    if (!ValidateToolState(1))
+        return 0;
+
+    if (linkerOutputFilename[0]) {
+        Arg_AddToToolArgs(&linkargs, ATK_ARG_END, NULL);
+        Arg_AddToToolArgs(&linkargs, ATK_ARG, "-o");
+        Arg_AddToToolArgs(&linkargs, ATK_ARG_END, NULL);
+        Arg_AddToToolArgs(&linkargs, ATK_ARG, linkerOutputFilename);
+        Arg_AddToToolArgs(&linkargs, ATK_ARG_END, NULL);
+    }
+
+    return 1;
+}
+
+static ParserTool parser = {
+        CWDROPINCOMPILERTYPE,
+        Lang_C_CPP,
+        targetCPUPowerPC,
+        CWFOURCHAR('R','h','a','p'),
+        10,
+        prefs,
+        "Metrowerks C/C++ Compiler for Mach-O/PPC",
+        "1993-2000",
+        11,
+        optLists,
+        10,
+        stPrefPanels,
+        &PreParse,
+        &MidParse,
+        &PostParse
+};
+
+int RegisterStaticParserToolInfo() {
+    return SetParserToolInfo(&parser);
+}
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-common.h b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-common.h
new file mode 100644
index 0000000..a56768d
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-common.h
@@ -0,0 +1,147 @@
+PCmdLine pCmdLine = {
+        0x1002,
+        3,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        2
+};
+PCmdLineCompiler pCmdLineCompiler = {
+        0x1005,
+        0,
+        0,
+        0,
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        "",
+        0,
+        0,
+        0,
+        0,
+        "",
+        0,
+        1
+};
+PCmdLineLinker pCmdLineLinker = {
+        0x1001,
+        1,
+        1
+};
+PFrontEndC pFrontEndC = { // compiler only?
+        0xC,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        "",
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        1
+};
+PWarningC pWarningC = { // compiler only?
+        4
+};
+PGlobalOptimizer pGlobalOptimizer = { // compiler only?
+        1,
+        2
+};
+PBackEnd pBackEnd = {
+        1,
+        2,
+        0,
+        0,
+        1,
+        0,
+        1,
+        1,
+        1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        1,
+        1,
+        0,
+        1
+};
+PDisassembler pDisassembler = {
+        1,
+        1,
+        1,
+        0,
+        0,
+        1,
+        1,
+        0,
+        1
+};
+PMachOLinker pLinker = {
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        2
+};
+PMachOProject pProject = {
+        1,
+        1,
+        "",
+        CWFOURCHAR('?','?','?','?'),
+        CWFOURCHAR('M','E','X','E'),
+        0x40
+};
+PCLTExtras pCLTExtras = {
+        1
+};
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-ld.c b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-ld.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-ld.c
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/TargetWarningHelpers-ppc-cc.c b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/TargetWarningHelpers-ppc-cc.c
new file mode 100644
index 0000000..31b718f
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/TargetWarningHelpers-ppc-cc.c
@@ -0,0 +1,84 @@
+#include "parser.h"
+
+// I'm making assumptions about the name of this file
+// based on TargetWarningHelpers-ppc-ld.c existing in the linker
+
+PExtraWarningC pExtraWarningC = {0};
+Pragma warningPragmas[] = {
+        &pExtraWarningC.warn_largeargs, "warn_largeargs", 0,
+        &pExtraWarningC.warn_padding, "warn_padding", 0,
+        &pExtraWarningC.warn_resultnotused, "warn_resultnotused", 0,
+        &pExtraWarningC.warn_ptr_int_conv, "warn_ptr_int_conv", 0,
+        &pExtraWarningC.warn_no_side_effect, "warn_no_side_effect", 0,
+        0, 0, 0
+};
+
+int TargetSetWarningFlags(short val, Boolean set) {
+    switch (val) {
+        case 'Ip': pWarningC.warn_illpragma = set; break;
+        case 'Ed': pWarningC.warn_emptydecl = set; break;
+        case 'Pu': pWarningC.warn_possunwant = set; break;
+        case 'Uv': pWarningC.warn_unusedvar = set; break;
+        case 'Ua': pWarningC.warn_unusedarg = set; break;
+        case 'Ec': pWarningC.warn_extracomma = set; break;
+        case 'Pe': pWarningC.pedantic = set; break;
+        case 'Hv': pWarningC.warn_hidevirtual = set; break;
+        case 'Ic': pWarningC.warn_implicitconv = set; break;
+        case 'Ni': pWarningC.warn_notinlined = set; break;
+        case 'Sc': pWarningC.warn_structclass = set; break;
+        case 'Pa': pExtraWarningC.warn_padding = set ? 1 : 2; break;
+        case 'Nu': pExtraWarningC.warn_resultnotused = set ? 1 : 2; break;
+        case 'Se': pExtraWarningC.warn_no_side_effect = set ? 1 : 2; break;
+        case 'PI': pExtraWarningC.warn_ptr_int_conv = set ? 1 : 2; break;
+        case 'La': pExtraWarningC.warn_largeargs = set ? 1 : 2; break;
+        case 'We': pWarningC.warningerrors = set; break;
+        case 'Cp': pFrontEndC.checkprotos = set; break;
+        default: return 0;
+    }
+
+    return 1;
+}
+
+void TargetDisplayWarningOptions(Handle txt) {
+    HPrintF(txt, "C language warning options:\n");
+
+    if (pWarningC.warn_illpragma)
+        HPrintF(txt, "\t- illegal pragmas\n");
+    if (pWarningC.warn_emptydecl)
+        HPrintF(txt, "\t- empty declarations\n");
+    if (pWarningC.warn_possunwant)
+        HPrintF(txt, "\t- possible unwanted effects\n");
+    if (pWarningC.warn_unusedvar)
+        HPrintF(txt, "\t- unused variables\n");
+    if (pWarningC.warn_unusedarg)
+        HPrintF(txt, "\t- unused arguments\n");
+    if (pWarningC.warn_extracomma)
+        HPrintF(txt, "\t- extra commas\n");
+    if (pWarningC.pedantic)
+        HPrintF(txt, "\t- pedantic\n");
+    if (pWarningC.warn_hidevirtual)
+        HPrintF(txt, "\t- hidden virtual functions\n");
+    if (pWarningC.warn_implicitconv)
+        HPrintF(txt, "\t- implicit conversions\n");
+    if (pWarningC.warn_notinlined)
+        HPrintF(txt, "\t- 'inline' not performed\n");
+    if (pWarningC.warn_structclass)
+        HPrintF(txt, "\t- struct/class conflict\n");
+    if (pExtraWarningC.warn_largeargs)
+        HPrintF(txt, "\t- large args passed to unprototyped functions\n");
+    if (pExtraWarningC.warn_padding)
+        HPrintF(txt, "\t- padding added between struct members\n");
+    if (pExtraWarningC.warn_resultnotused)
+        HPrintF(txt, "\t- result of non-void function call not used\n");
+    if (pExtraWarningC.warn_no_side_effect)
+        HPrintF(txt, "\t- use of expressions as statements without side effects\n");
+    if (pExtraWarningC.warn_ptr_int_conv)
+        HPrintF(txt, "\t- implicit integer/pointer conversions\n");
+    if (pFrontEndC.checkprotos)
+        HPrintF(txt, "\t- checking prototypes\n");
+
+    if (pWarningC.warningerrors)
+        HPrintF(txt, "\t- warnings are errors\n");
+    else
+        HPrintF(txt, "\t- warnings are not errors\n");
+}
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/TargetWarningHelpers-ppc-ld.c b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/TargetWarningHelpers-ppc-ld.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/TargetWarningHelpers-ppc-ld.c
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/cc-mach-ppc.c b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/cc-mach-ppc.c
new file mode 100644
index 0000000..fc6206c
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/cc-mach-ppc.c
@@ -0,0 +1,582 @@
+#include "cmdline.h"
+
+extern CWPLUGIN_ENTRY(MWC_main)(CWPluginContext context);
+
+CWPLUGIN_ENTRY (CWPlugin_GetDropInFlags)(const DropInFlags **flags, SInt32 *flagsSize) {
+    static const DropInFlags sFlags = {
+            kCurrentDropInFlagsVersion,
+            CWDROPINCOMPILERTYPE,
+            DROPINCOMPILERLINKERAPIVERSION_8,
+            kGeneratescode | kCanpreprocess | kCanprecompile | kCompAllowDupFileNames,
+            Lang_C_CPP,
+            DROPINCOMPILERLINKERAPIVERSION_12
+    };
+
+    *flags = &sFlags;
+    *flagsSize = sizeof(sFlags);
+    return 0;
+}
+
+CWPLUGIN_ENTRY (CWPlugin_GetTargetList)(const CWTargetList **targetList) {
+    static CWDataType sCPU[1] = {targetCPUPowerPC};
+    static CWDataType sOS[1] = {CWFOURCHAR('R','h','a','p')};
+    static CWTargetList sTargetList = {
+            kCurrentCWTargetListVersion,
+            1,
+            sCPU,
+            1,
+            sOS
+    };
+
+    *targetList = &sTargetList;
+    return 0;
+}
+
+CWPLUGIN_ENTRY (CWPlugin_GetDropInName)(const char **dropinName) {
+    static const char *sDropInName = "MW C/C++ Mach-O PPC";
+    *dropinName = sDropInName;
+    return 0;
+}
+
+CWPLUGIN_ENTRY (CWPlugin_GetDisplayName)(const char **displayName) {
+    static const char *sDisplayName = "Mach-O PPC";
+    *displayName = sDisplayName;
+    return 0;
+}
+
+CWPLUGIN_ENTRY (CWPlugin_GetDefaultMappingList)(const CWExtMapList **defaultMappingList) {
+    static CWExtensionMapping sExtension[10] = {
+            CWFOURCHAR('T','E','X','T'), ".c", 0,
+            CWFOURCHAR('T','E','X','T'), ".c++", 0,
+            CWFOURCHAR('T','E','X','T'), ".cc", 0,
+            CWFOURCHAR('T','E','X','T'), ".cp", 0,
+            CWFOURCHAR('T','E','X','T'), ".cpp", 0,
+            CWFOURCHAR('T','E','X','T'), ".h", kIgnored,
+            CWFOURCHAR('T','E','X','T'), ".h++", kIgnored,
+            CWFOURCHAR('T','E','X','T'), ".hpp", kIgnored,
+            CWFOURCHAR('T','E','X','T'), ".pch", kPrecompile,
+            CWFOURCHAR('T','E','X','T'), ".pch++", kPrecompile
+    };
+    static CWExtMapList sExtensionMapList = {
+            kCurrentCWExtMapListVersion,
+            10,
+            sExtension
+    };
+
+    *defaultMappingList = &sExtensionMapList;
+    return 0;
+}
+
+CWPLUGIN_ENTRY (CWPlugin_GetPanelList)(const CWPanelList **panelList) {
+    static const char *sPanelNames[4] = {
+            "C/C++ Compiler",
+            "C/C++ Warnings",
+            "PPC Global Optimizer",
+            "PPC CodeGen Mach-O"
+    };
+    static CWPanelList sPanelList = {
+            kCurrentCWPanelListVersion,
+            4,
+            sPanelNames
+    };
+
+    *panelList = &sPanelList;
+    return 0;
+}
+
+static CWPLUGIN_ENTRY (CmdLine_GetObjectFlags)(const CWObjectFlags **objectFlags) {
+    static const CWObjectFlags sFlags = {
+            2,
+            0x80000000,
+            ".o",
+            ".b",
+            ".i",
+            ".s",
+            ".d",
+            "mch",
+            CWFOURCHAR('C','W','I','E'), CWFOURCHAR('M','P','L','F'),
+            CWFOURCHAR('C','W','I','E'), CWFOURCHAR('B','R','W','S'),
+            CWFOURCHAR('C','W','I','E'), CWFOURCHAR('T','E','X','T'),
+            CWFOURCHAR('C','W','I','E'), CWFOURCHAR('T','E','X','T'),
+            CWFOURCHAR('C','W','I','E'), CWFOURCHAR('T','E','X','T')
+    };
+
+    *objectFlags = &sFlags;
+    return 0;
+}
+
+static CWPLUGIN_ENTRY (CWPlugin_GetVersionInfo)(const VersionInfo **versionInfo) {
+    static const VersionInfo vi = {
+            2, 4, 5, 0
+    };
+
+    *versionInfo = &vi;
+    return 0;
+}
+
+static CWPLUGIN_ENTRY (CWPlugin_GetFileTypeMappings)(const OSFileTypeMappingList **mappings) {
+    static const OSFileTypeMapping ftmes[2] = {
+            CWFOURCHAR('M','M','C','H'), "\xBE\xEF\xFA\xCE", 4, 0, NULL,
+            CWFOURCHAR('M','M','C','H'), "\xCE\xFA\xEF\xBE", 4, 0, NULL
+    };
+    static const OSFileTypeMappingList ftml = {
+            2, ftmes
+    };
+
+    *mappings = &ftml;
+    return 0;
+}
+
+static BasePluginCallbacks plugin_cb = {
+        MWC_main,
+        CWPlugin_GetDropInFlags,
+        CWPlugin_GetDisplayName,
+        CWPlugin_GetDropInName,
+        CWPlugin_GetPanelList,
+        NULL,
+        NULL,
+        CWPlugin_GetVersionInfo,
+        CWPlugin_GetFileTypeMappings
+};
+
+static CompilerLinkerPluginCallbacks plugin_cl_cb = {
+        CWPlugin_GetTargetList,
+        CWPlugin_GetDefaultMappingList,
+        NULL,
+        NULL,
+        CmdLine_GetObjectFlags,
+        NULL
+};
+
+static CWPLUGIN_ENTRY (Linker_GetDropInFlags)(const DropInFlags **flags, SInt32 *flagsSize) {
+    static const DropInFlags sFlags = {
+            kCurrentDropInFlagsVersion,
+            CWDROPINLINKERTYPE,
+            DROPINCOMPILERLINKERAPIVERSION_8,
+            1,
+            CWFOURCHAR('*','*','*','*'),
+            DROPINCOMPILERLINKERAPIVERSION_12
+    };
+
+    *flags = &sFlags;
+    *flagsSize = sizeof(sFlags);
+    return 0;
+}
+
+static CWPLUGIN_ENTRY (Linker_GetDropInName)(const char **dropinName) {
+    *dropinName = "Mach-O PPC Linker";
+    return 0;
+}
+
+static CWPLUGIN_ENTRY (Linker_GetDisplayName)(const char **displayName) {
+    *displayName = "Linker Tool Stub";
+    return 0;
+}
+
+static CWPLUGIN_ENTRY (Linker_GetPanelList)(const CWPanelList **panelList) {
+    static const char *sPanelNames[3] = {
+            "PPC Mach-O Linker",
+            "PPC Mach-O Target",
+            "PPC Disassembler"
+    };
+    static CWPanelList sPanelList = {
+            kCurrentCWPanelListVersion,
+            3,
+            sPanelNames
+    };
+
+    *panelList = &sPanelList;
+    return 0;
+}
+
+static CWPLUGIN_ENTRY (Linker_GetTargetList)(const CWTargetList **targetList) {
+    static CWDataType sCPU[1] = {targetCPUPowerPC};
+    static CWDataType sOS[1] = {CWFOURCHAR('R','h','a','p')};
+    static CWTargetList sTargetList = {
+            kCurrentCWTargetListVersion,
+            1,
+            sCPU,
+            1,
+            sOS
+    };
+
+    *targetList = &sTargetList;
+    return 0;
+}
+
+static CWPLUGIN_ENTRY (Linker_GetDefaultMappingList)(const CWExtMapList **defaultMappingList) {
+    static CWExtensionMapping sExtension[8] = {
+            CWFOURCHAR('A','P','P','L'), "", kLaunchable | kRsrcfile,
+            CWFOURCHAR('A','p','p','l'), "", kLaunchable | kRsrcfile,
+            CWFOURCHAR('M','W','C','D'), "", kLaunchable | kRsrcfile,
+            CWFOURCHAR('R','S','R','C'), "", kLaunchable | kRsrcfile,
+            CWFOURCHAR('r','s','r','c'), "", kLaunchable | kRsrcfile,
+            CWFOURCHAR('d','o','c','u'), "", kLaunchable | kRsrcfile,
+            0, ".rsrc", kLaunchable | kRsrcfile,
+            0, ".doc", kLaunchable | kIgnored
+    };
+    static CWExtMapList sExtensionMapList = {
+            kCurrentCWExtMapListVersion,
+            8,
+            sExtension
+    };
+
+    *defaultMappingList = &sExtensionMapList;
+    return 0;
+}
+
+static BasePluginCallbacks lk_cb = {
+        NULL,
+        Linker_GetDropInFlags,
+        Linker_GetDisplayName,
+        Linker_GetDropInName,
+        Linker_GetPanelList,
+        NULL,
+        NULL,
+        CWPlugin_GetVersionInfo,
+        NULL
+};
+
+static CompilerLinkerPluginCallbacks lk_cl_cb = {
+        Linker_GetTargetList,
+        Linker_GetDefaultMappingList,
+        NULL,
+        NULL,
+        NULL,
+        NULL
+};
+
+int RegisterStaticCompilerPlugin() {
+    return RegisterStaticCompilerLinkerPlugin(&plugin_cb, &plugin_cl_cb) && RegisterStaticCompilerLinkerPlugin(&lk_cb, &lk_cl_cb);
+}
+
+// This is going to be in some .r file, but I'm not sure which
+static const char *STR10000[] = {
+        "illegal character constant",
+        "illegal string constant",
+        "unexpected end of file",
+        "unterminated comment",
+        "undefined preprocessor directive",
+        "illegal token",
+        "string too long",
+        "identifier expected",
+        "macro '%u' redefined",
+        "illegal argument list",
+        "too many macro arguments",
+        "macro(s) too complex",
+        "unexpected end of line",
+        "end of line expected",
+        "'(' expected",
+        "')' expected",
+        "',' expected",
+        "preprocessor syntax error",
+        "preceding #if is missing",
+        "unterminated #if / macro",
+        "unexpected token",
+        "declaration syntax error",
+        "identifier '%u' redeclared",
+        "';' expected",
+        "illegal constant expression",
+        "']' expected",
+        "illegal use of 'void'",
+        "illegal function definition",
+        "illegal function return type",
+        "illegal array definition",
+        "'}' expected",
+        "illegal struct/union/enum/class definition",
+        "struct/union/enum/class tag '%u' redefined",
+        "struct/union/class member '%u' redefined",
+        "declarator expected",
+        "'{' expected",
+        "illegal use of incomplete struct/union/class '%t'",
+        "struct/union/class size exceeds 32K",
+        "illegal bitfield declaration",
+        "division by 0",
+        "undefined identifier '%u'",
+        "expression syntax error",
+        "not an lvalue",
+        "illegal operation",
+        "illegal operand",
+        "data type is incomplete",
+        "illegal type",
+        "too many initializers",
+        "pointer/array required",
+        "not a struct/union/class",
+        "'%u' is not a struct/union/class member",
+        "the file '%u' cannot be opened",
+        "illegal instruction for this processor",
+        "illegal operands for this processor",
+        "number is out of range",
+        "illegal addressing mode",
+        "illegal data size",
+        "illegal register list",
+        "branch out of range",
+        "undefined label '%u'",
+        "reference to label '%u' is out of range",
+        "call of non-function",
+        "function call does not match prototype",
+        "illegal use of register variable",
+        "illegal type cast",
+        "function already has a stackframe",
+        "function has no initialized stackframe",
+        "value is not stored in register",
+        "function nesting too complex",
+        "illegal use of keyword",
+        "':' expected",
+        "label '%u' redefined",
+        "case constant defined more than once",
+        "default label defined more than once",
+        "illegal initialization",
+        "illegal use of inline function",
+        "illegal type qualifier(s)",
+        "illegal storage class",
+        "function has no prototype",
+        "illegal assignment to constant",
+        "illegal use of precompiled header",
+        "illegal data in precompiled header",
+        "variable / argument '%u' is not used in function",
+        "illegal use of direct parameters",
+        "return value expected",
+        "variable '%u' is not initialized before being used",
+        "illegal #pragma",
+        "illegal access to protected/private member",
+        "ambiguous access to class/struct/union member",
+        "illegal use of 'this'",
+        "unimplemented C++ feature",
+        "illegal use of 'HandleObject'",
+        "illegal access qualifier",
+        "illegal 'operator' declaration",
+        "illegal use of abstract class ('%o')",
+        "illegal use of pure function",
+        "illegal '&' reference",
+        "illegal function overloading",
+        "illegal operator overloading",
+        "ambiguous access to overloaded function ",
+        "illegal access/using declaration",
+        "illegal 'friend' declaration",
+        "illegal 'inline' function definition",
+        "class has no default constructor",
+        "illegal operator",
+        "illegal default argument(s)",
+        "possible unwanted ';'",
+        "possible unwanted assignment",
+        "possible unwanted compare",
+        "illegal implicit conversion from '%t' to",
+        "'%t'",
+        "local data >32k",
+        "illegal jump past initializer",
+        "illegal ctor initializer",
+        "cannot construct %t's base class '%t'",
+        "cannot construct %t's direct member '%u'",
+        "#if nesting overflow",
+        "illegal empty declaration",
+        "illegal implicit enum conversion from '%t' to",
+        "'%t'",
+        "illegal use of #pragma parameter",
+        "virtual functions cannot be pascal functions",
+        "illegal implicit const/volatile pointer conversion from '%t' to",
+        "'%t'",
+        "illegal use of non-static member",
+        "illegal precompiled header version",
+        "illegal precompiled header compiler flags or target",
+        "'const' or '&' variable needs initializer",
+        "'%o' hides inherited virtual function '%o'",
+        "pascal function cannot be overloaded",
+        "derived function differs from virtual base function in return type only",
+        "non-const '&' reference initialized to temporary",
+        "illegal template declaration",
+        "'<' expected",
+        "'>' expected",
+        "illegal template argument(s)",
+        "cannot instantiate '%o'",
+        "template redefined",
+        "template parameter mismatch",
+        "cannot pass const/volatile data object to non-const/volatile member function",
+        "preceding '#pragma push' is missing",
+        "illegal explicit template instantiation",
+        "illegal X::X(X) copy constructor",
+        "function defined 'inline' after being called",
+        "illegal constructor/destructor declaration",
+        "'catch' expected",
+        "#include nesting overflow",
+        "cannot convert",
+        "'%t' to",
+        "'%t'",
+        "type mismatch",
+        "'%t' and",
+        "'%t'",
+        "class type expected",
+        "illegal explicit conversion from '%t' to",
+        "'%t'",
+        "function call '*' does not match",
+        "identifier '%u' redeclared",
+        "was declared as: '%t'",
+        "now declared as: '%t'",
+        "cannot throw class with ambiguous base class ('%u')",
+        "class '%t': '%o' has more than one final overrider:",
+        "'%o'",
+        "and '%o'",
+        "exception handling option is disabled",
+        "cannot delete pointer to const",
+        "cannot destroy const object",
+        "const member '%u' is not initialized",
+        "'&' reference member '%u' is not initialized",
+        "RTTI option is disabled",
+        "constness casted away",
+        "illegal const/volatile '&' reference initialization",
+        "inconsistent linkage: 'extern' object redeclared as 'static'",
+        "unknown assembler instruction mnemonic",
+        "local data > 224 bytes",
+        "'%u' could not be assigned to a register",
+        "illegal exception specification",
+        "exception specification list mismatch",
+        "the parameter(s) of the '%n' function must be immediate value(s)",
+        "SOM classes can only inherit from other SOM based classes",
+        "SOM classes inhertiance must be virtual",
+        "SOM class data members must be private",
+        "illegal SOM function overload '%o'",
+        "no static members allowed in SOM classes",
+        "no parameters allowed in SOM class constructors",
+        "illegal SOM function parameters or return type",
+        "SOM runtime function '%u' not defined (should be defined in somobj.hh)",
+        "SOM runtime function '%u' has unexpected type",
+        "'%u' is not a SOM class",
+        "illegal use of #pragma outside of SOM class definition",
+        "introduced method '%o' is not specified in release order list",
+        "SOM class access qualification only allowed to direct parent or own class",
+        "SOM class must have one non-inline member function",
+        "SOM type '%u' undefined",
+        "new SOM callstyle method '%o' must have explicit 'Environment *' parameter",
+        "functions cannot return SOM classes",
+        "functions cannot have SOM class arguments",
+        "assignment is not supported for SOM classes",
+        "sizeof() is not supported for SOM classes",
+        "SOM classes	cannot be class members",
+        "global SOM class objects are not supported",
+        "SOM class arrays are not supported",
+        "'pointer to member' is not supported for SOM classes",
+        "SOM class has no release order list",
+        "'%u' is not an Objective-C class",
+        "method '%m' redeclared",
+        "undefined method '%m'",
+        "class '%u' redeclared",
+        "class '%u' redefined",
+        "Objective-C type '%u' is undefined (should be defined in objc.h)",
+        "Objective-C type '%u' has unexpected type",
+        "method '%m' not defined",
+        "method '%m' redefined",
+        "illegal use of 'self'",
+        "illegal use of 'super'",
+        "illegal message receiver",
+        "receiver cannot handle this message",
+        "ambiguous message selector",
+        "used: '%m'",
+        "also had: '%m'",
+        "unknown message selector",
+        "illegal use of Objective-C object",
+        "protocol '%u' redefined",
+        "protocol '%u' is undefined",
+        "protocol '%u' is already in protocol list",
+        "category '%u' redefined",
+        "category '%u' is undefined",
+        "illegal use of '%u'",
+        "template too complex or recursive",
+        "illegal return value in void/constructor/destructor function",
+        "assigning a non-int numeric value to an unprototyped function",
+        "implicit arithmetic conversion from '%t' to '%t'",
+        "preprocessor #error directive",
+        "ambiguous access to name found '%u' and '%u'",
+        "illegal namespace",
+        "illegal use of namespace name",
+        "illegal name overloading",
+        "instance variable list does not match @interface",
+        "protocol list does not match @interface",
+        "super class does not match @interface",
+        "function result is a pointer/reference to an automatic variable",
+        "cannot allocate initialized objects in the scratchpad",
+        "illegal class member access",
+        "data object '%o' redefined",
+        "illegal access to local variable from other function",
+        "illegal implicit member pointer conversion",
+        "typename redefined",
+        "object '%o' redefined",
+        "'main' not defined as external 'int main()' function",
+        "illegal explicit template specialization",
+        "name has not been declared in namespace/class",
+        "preprocessor #warning directive",
+        "illegal use of asm inline function",
+        "illegal use of C++ feature in EC++",
+        "illegal use template argument dependent type 'T::%u'",
+        "illegal use of alloca() in function argument",
+        "inline function call '%o' not inlined",
+        "inconsistent use of 'class' and 'struct' keywords",
+        "illegal partial specialization",
+        "illegal partial specialization argument list",
+        "ambiguous use of partial specialization",
+        "local classes shall not have member templates",
+        "illegal template argument dependent expression",
+        "implicit 'int' is no longer supported in C++",
+        "%i pad byte(s) inserted after data member '%u'",
+        "pure function '%o' is not virtual",
+        "illegal virtual function '%o' in 'union'",
+        "cannot pass 'void' or 'function' parameter",
+        "illegal static const member '%u' initialization",
+        "'typename' is missing in template argument dependent qualified type",
+        "more than one expression in non-class type conversion",
+        "template non-type argument objects shall have external linkage",
+        "illegal inline assembly operand: %u",
+        "illegal or unsupported __attribute__",
+        "cannot create object file '%f'",
+        "error writing to object file '%f'",
+        "printf-family format string doesn't match arguments",
+        "scanf-family format string doesn't match arguments",
+        "__alignof__() is not supported for SOM classes",
+        "illegal macro argument name '%u'",
+        "case has an empty range of values",
+        "'long long' switch() is not supported",
+        "'long long' case range is not supported",
+        "expression has no side effect",
+        "result of function call is not used",
+        "illegal non-type template argument",
+        "illegal use of abstract class ('%t')",
+        "illegal use of 'template' prefix",
+        "template parameter/argument list mismatch",
+        "cannot find matching deallocation function for '%t'",
+        "illegal operand '%t'",
+        "illegal operands '%t' %u '%t'",
+        "illegal use of default template-argument",
+        "illegal UUID syntax",
+        "__uuidof() is not supported for SOM classes",
+        "illegal access from '%t' to protected/private member '%o'",
+        "integral type is not large enough to hold pointer",
+        "unknown x86 assembler instruction mnemonic",
+        "illegal use of const/volatile function qualifier sequence",
+        "illegal optimization level for this limited version of CodeWarrior",
+        "no UUID defined for type '%t'",
+        "using implicit copy assigment for class with const or reference member ('%t')",
+        "unimplemented assembler instruction/directive",
+        "override of dllimport function '%u' only has application scope",
+        "illegal combination of operands in inline statement at line %i",
+        "illegal operand in inline statement at line %i",
+        "function call '*' is ambiguous",
+        NULL
+};
+
+static const char *STR10100[] = {
+        "### Error: Compilation aborted at end of file ###",
+        "Save precompiled header as...",
+        "### Error while creating precompiled headerfile (OSErr %ld) ###",
+        "### Error while writing precompiled headerfile (OSErr %ld) ### ",
+        "internal compiler error: File: '%s' Line: %ld",
+        "ran out of registers--turn on Global Optimization for this function",
+        "### Error: Out of memory ###",
+        "### User break detected ###",
+        "### Error: Cannot open main file ###",
+        "Analyzing symbol table...",
+        "Writing precompiled header file...",
+        NULL
+};
+
+int RegisterCompilerResources() {
+    return RegisterResource("Compiler Errors", 10000, STR10000) && RegisterResource("Compiler Strings", 10100, STR10100);
+}
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/ld-mach-ppc.c b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/ld-mach-ppc.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/ld-mach-ppc.c
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/libimp-mach-ppc.c b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/libimp-mach-ppc.c
new file mode 100644
index 0000000..b62d413
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/libimp-mach-ppc.c
@@ -0,0 +1,146 @@
+#include "cmdline.h"
+
+// this exists elsewhere
+extern CWPLUGIN_ENTRY(PPCLibImport_main)(CWPluginContext context);
+
+CWPLUGIN_ENTRY (PPCLibImport_GetDropInFlags)(const DropInFlags **flags, SInt32 *flagsSize) {
+    static const DropInFlags sFlags = {
+            kCurrentDropInFlagsVersion,
+            CWDROPINCOMPILERTYPE,
+            DROPINCOMPILERLINKERAPIVERSION_8,
+            kGeneratescode | kCanpreprocess | kCanprecompile | kCompAllowDupFileNames | kCompMultiTargAware,
+            Lang_MISC,
+            DROPINCOMPILERLINKERAPIVERSION_12
+    };
+
+    *flags = &sFlags;
+    *flagsSize = sizeof(sFlags);
+    return 0;
+}
+
+CWPLUGIN_ENTRY (PPCLibImport_GetTargetList)(const CWTargetList **targetList) {
+    static CWDataType sCPU[1] = {targetCPUPowerPC};
+    static CWDataType sOS[1] = {CWFOURCHAR('R','h','a','p')};
+    static CWTargetList sTargetList = {
+            kCurrentCWTargetListVersion,
+            1,
+            sCPU,
+            1,
+            sOS
+    };
+
+    *targetList = &sTargetList;
+    return 0;
+}
+
+CWPLUGIN_ENTRY (PPCLibImport_GetDropInName)(const char **dropinName) {
+    static const char *sDropInName = "Lib Import Mach-O";
+    *dropinName = sDropInName;
+    return 0;
+}
+
+CWPLUGIN_ENTRY (PPCLibImport_GetDisplayName)(const char **displayName) {
+    static const char *sDisplayName = "Lib Import Mach-O";
+    *displayName = sDisplayName;
+    return 0;
+}
+
+CWPLUGIN_ENTRY (PPCLibImport_GetDefaultMappingList)(const CWExtMapList **defaultMappingList) {
+    static CWExtensionMapping sExtension[10] = {
+            CWFOURCHAR('M','P','L','F'), "", 0,
+            CWFOURCHAR('M','L','I','B'), "", 0
+    };
+    static CWExtMapList sExtensionMapList = {
+            kCurrentCWExtMapListVersion,
+            2,
+            sExtension
+    };
+
+    *defaultMappingList = &sExtensionMapList;
+    return 0;
+}
+
+CWPLUGIN_ENTRY (PPCLibImport_GetPanelList)(const CWPanelList **panelList) {
+    static CWPanelList sPanelList = {
+            kCurrentCWPanelListVersion,
+            0,
+            NULL
+    };
+
+    *panelList = &sPanelList;
+    return 0;
+}
+
+static CWPLUGIN_ENTRY (PPCLibImport_GetVersionInfo)(const VersionInfo **versionInfo) {
+    static const VersionInfo vi = {
+            2, 4, 5, 0
+    };
+
+    *versionInfo = &vi;
+    return 0;
+}
+
+static CWPLUGIN_ENTRY (PPCLibImport_GetFileTypeMappings)(const OSFileTypeMappingList **mappings) {
+    static const OSFileTypeMapping ftmes[2] = {
+            CWFOURCHAR('M','P','L','F'), "!arch\n", 8, 0, NULL,
+            CWFOURCHAR('M','L','I','B'), "\xFE\xED\xFA\xCE", 4, 0, NULL
+    };
+    static const OSFileTypeMappingList ftml = {
+            2, ftmes
+    };
+
+    *mappings = &ftml;
+    return 0;
+}
+
+static CWPLUGIN_ENTRY (PPCLibImport_GetObjectFlags)(const CWObjectFlags **objectFlags) {
+    static const CWObjectFlags sFlags = {
+            2,
+            0,
+            NULL,
+            NULL,
+            NULL,
+            ".s",
+            ".d",
+            "mch",
+            0, 0,
+            0, 0,
+            0, 0,
+            CWFOURCHAR('C','W','I','E'), CWFOURCHAR('T','E','X','T'),
+            0, 0
+    };
+
+    *objectFlags = &sFlags;
+    return 0;
+}
+
+static BasePluginCallbacks machlibimport_cb = {
+        PPCLibImport_main,
+        PPCLibImport_GetDropInFlags,
+        PPCLibImport_GetDisplayName,
+        PPCLibImport_GetDropInName,
+        PPCLibImport_GetPanelList,
+        NULL,
+        NULL,
+        PPCLibImport_GetVersionInfo,
+        PPCLibImport_GetFileTypeMappings
+};
+
+static CompilerLinkerPluginCallbacks machlibimport_cl_cb = {
+        PPCLibImport_GetTargetList,
+        PPCLibImport_GetDefaultMappingList,
+        NULL,
+        NULL,
+        PPCLibImport_GetObjectFlags,
+        NULL
+};
+
+int RegisterStaticLibImporterPlugin() {
+    return RegisterStaticCompilerLinkerPlugin(&machlibimport_cb, &machlibimport_cl_cb);
+}
+
+#include "compiler_and_linker/Plugin_Tools/MacOS_PPC/Lib_Importer_Mach/Resources/Errors.r"
+
+int RegisterLibImporterResources() {
+    return RegisterResource("Mach-O Lib Importer Errors", 911, STR911);
+}
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Static/cc-mach-ppc-mw.c b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Static/cc-mach-ppc-mw.c
new file mode 100644
index 0000000..25a9f49
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Static/cc-mach-ppc-mw.c
@@ -0,0 +1,31 @@
+#include "cmdline.h"
+
+// cc-mach-ppc.c
+extern int RegisterStaticCompilerPlugin();
+extern int RegisterCompilerResources();
+// libimp-mach-ppc.c
+extern int RegisterStaticLibImporterPlugin();
+extern int RegisterLibImporterResources();
+
+void GetStaticTarget(OSType *cpu, OSType *os) {
+    *cpu = targetCPUPowerPC;
+    *os = CWFOURCHAR('R','h','a','p');
+}
+
+void GetStaticPluginType(OSType *language, OSType *plugintype) {
+    *language = Lang_C_CPP;
+    *plugintype = CWDROPINCOMPILERTYPE;
+}
+
+void GetStaticParserPluginType(OSType *style) {
+    *style = CWFOURCHAR('S','e','e','p');
+}
+
+int RegisterStaticTargetPlugins() {
+    return RegisterStaticCompilerPlugin() && RegisterStaticLibImporterPlugin();
+}
+
+int RegisterStaticTargetResources() {
+    OS_UseMacResourceForkInfo(1);
+    return RegisterCompilerResources() && RegisterLibImporterResources();
+}
diff --git a/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Static/ld-mach-ppc-mw.c b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Static/ld-mach-ppc-mw.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Static/ld-mach-ppc-mw.c
diff --git a/compiler_and_linker/Plugin_Tools/MacOS_PPC/Linker_MacOS_MachPPC/Resources/MachOLinkErrors.r b/compiler_and_linker/Plugin_Tools/MacOS_PPC/Linker_MacOS_MachPPC/Resources/MachOLinkErrors.r
new file mode 100644
index 0000000..3a7eb93
--- /dev/null
+++ b/compiler_and_linker/Plugin_Tools/MacOS_PPC/Linker_MacOS_MachPPC/Resources/MachOLinkErrors.r
@@ -0,0 +1 @@
+// STR11001
\ No newline at end of file
diff --git a/includes/cmdline.h b/includes/cmdline.h
new file mode 100644
index 0000000..2861794
--- /dev/null
+++ b/includes/cmdline.h
@@ -0,0 +1,749 @@
+#pragma once
+
+#include "cw_common.h"
+#include "pref_structs.h"
+
+enum {
+    CLStr1 = 1,
+    CLStr2 = 2,
+    CLStr3 = 3,
+    CLStr4 = 4,
+    CLStr5 = 5,
+    CLStr6 = 6,
+    CLStr7 = 7,
+    CLStr8 = 8,
+    CLStr9 = 9,
+    CLStr10 = 10,
+    CLStr11 = 11,
+    CLStr12 = 12,
+    CLStr13 = 13,
+    CLStr14 = 14,
+    CLStr15 = 15,
+    CLStr16 = 16,
+    CLStr17 = 17,
+    CLStr18 = 18,
+    CLStr19 = 19,
+    CLStr20 = 20,
+    CLStr21 = 21,
+    CLStr22 = 22,
+    CLStr23 = 23,
+    CLStr24 = 24,
+    CLStr25 = 25,
+    CLStr26 = 26,
+    CLStr27 = 27,
+    CLStr28 = 28,
+    CLStr29 = 29,
+    CLStr30 = 30,
+    CLStr31 = 31,
+    CLStr32 = 32,
+    CLStr33 = 33,
+    CLStr34 = 34,
+    CLStr35 = 35,
+    CLStr36 = 36,
+    CLStr37 = 37,
+    CLStr38 = 38,
+    CLStr39 = 39,
+    CLStr40 = 40,
+    CLStr41 = 41,
+    CLStr42 = 42,
+    CLStr43 = 43,
+    CLStr44 = 44,
+    CLStr45 = 45,
+    CLStr46 = 46,
+    CLStr47 = 47,
+    CLStr48 = 48,
+    CLStr49 = 49,
+    CLStr50 = 50,
+    CLStr51 = 51,
+    CLStr52 = 52,
+    CLStr53 = 53,
+    CLStr54 = 54,
+    CLStr55 = 55,
+    CLStr56 = 56,
+    CLStr57 = 57,
+    CLStr58 = 58,
+    CLStr59 = 59,
+    CLStr60 = 60,
+    CLStr61 = 61,
+    CLStr62 = 62,
+    CLStr63 = 63,
+    CLStr64 = 64,
+    CLStr65 = 65,
+    CLStr66 = 66,
+    CLStr67 = 67,
+    CLStr68 = 68,
+    CLStr69 = 69,
+    CLStr70 = 70,
+    CLStr71 = 71,
+    CLStr72 = 72,
+    CLStr73 = 73,
+    CLStr74 = 74,
+    CLStr75 = 75,
+    CLStr76 = 76,
+    CLStr77 = 77,
+    CLStr78 = 78,
+    CLStr79 = 79,
+    CLStr80 = 80,
+    CLStr81 = 81,
+    CLStr82 = 82,
+    CLStr83 = 83,
+    CLStr84 = 84,
+    CLStr85 = 85,
+    CLStr86 = 86,
+    CLStr87 = 87,
+    CLStr88 = 88,
+    CLStr89 = 89,
+    CLStr90 = 90,
+    CLStr91 = 91,
+    CLStr92 = 92,
+    CLStr93 = 93,
+    CLStr94 = 94,
+    CLStr95 = 95,
+    CLStr96 = 96,
+    CLStr97 = 97,
+    CLStr98 = 98,
+    CLStr99 = 99,
+    CLStr100 = 100,
+    CLStr101 = 101,
+    CLStr102 = 102,
+    CLStr103 = 103,
+    CLStr104 = 104,
+    CLStr105 = 105,
+    CLStr106 = 106,
+    CLStr107 = 107,
+    CLStr108 = 108,
+    CLStr109 = 109,
+    CLStr110 = 110,
+    CLStr111 = 111,
+    CLStr112 = 112
+};
+
+#define DO_INTERNAL_ERROR(...) CLInternalError(__FILE__, __LINE__, __VA_ARGS__)
+
+#ifdef	__MWERKS__
+#pragma options align=mac68k
+#endif
+// TODO fixme
+typedef struct CPrepFileInfo {
+    FSSpec textfile;
+    void *nameNode;
+    SInt32 fileModDate;
+    char *textbuffer;
+    SInt32 textlength;
+    SInt32 linenumber;
+    SInt32 pos;
+    Boolean hasprepline;
+    SInt16 fileID;
+    Boolean recordbrowseinfo;
+    void *unk;
+} CPrepFileInfo;
+typedef CPrepFileInfo *CPrepFileInfoStack[];
+#ifdef	__MWERKS__
+#pragma options align=reset
+#endif
+
+enum {
+    OptsCmdLineState_0 = 0,
+    OptsCmdLineState_1 = 1,
+    OptsCmdLineState_2 = 2,
+    OptsCmdLineState_3 = 3
+};
+enum {
+    OptsCompilerSbmState_0 = 0,
+    OptsCompilerSbmState_1 = 1, // sbmRebuild?
+    OptsCompilerSbmState_2 = 2,
+    OptsCompilerSbmState_3 = 3 // sbmClean?
+};
+enum {
+    CmdLineStage_Cg = 1,
+    CmdLineStage_Pp = 2,
+    CmdLineStage_Ds = 3
+};
+enum {
+    CmdLineStageMask_Pp = 1,
+    CmdLineStageMask_Cg = 2,
+    CmdLineStageMask_Ds = 4,
+    CmdLineStageMask_Dp = 8
+};
+
+// Result codes used by various things in CLMain and CLFileOps
+enum {
+    Result_Success = 0,
+    Result_Failed = 1,
+    Result_Cancelled = 2
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct MessageRef {
+    OSSpec sourcefile;
+    OSSpec errorfile;
+    char *sourceline;
+    SInt32 linenumber;
+    SInt32 tokenoffset;
+    SInt16 tokenlength;
+    SInt32 selectionoffset;
+    SInt16 selectionlength;
+} MessageRef;
+
+typedef struct Paths {
+    struct Path **pathsArray;
+    UInt16 arraySize;
+    UInt16 pathsCount;
+} Paths;
+
+typedef struct Frameworks {
+    struct Paths_FWInfo **fwsArray;
+    UInt16 arraySize;
+    UInt16 fwsCount;
+} Frameworks;
+
+typedef struct Path {
+    OSPathSpec *spec;
+    Paths *recursive;
+    char *dirlist;
+    SInt16 flags;
+} Path;
+
+typedef struct Paths_FWInfo {
+    OSSpec fileSpec;
+    OSPathSpec version;
+    OSPathSpec name;
+    Path *path;
+    Boolean hidden;
+} Paths_FWInfo;
+
+typedef struct InclFile {
+    SInt32 filenameoffs;
+    Path *accesspath;
+    Path *globalpath;
+    Path *specialpath;
+    Boolean syspath;
+} InclFile;
+
+typedef struct Incls {
+    struct Target *targ;
+    SInt32 numincls;
+    SInt32 maxincls;
+    InclFile *files;
+    SInt32 buflen;
+    SInt32 bufpos;
+    char *buffer;
+    Paths *allPaths;
+} Incls;
+
+typedef struct Deps {
+    int numDeps;
+    int maxDeps;
+    SInt32 *list;
+    Incls *incls;
+} Deps;
+
+typedef struct OvlAddr {
+    UInt32 lo, hi;
+} OvlAddr;
+
+typedef struct Overlay {
+    char name[256];
+    SInt32 *list;
+    SInt32 cnt;
+    SInt32 max;
+    struct Overlay *next;
+} Overlay;
+
+typedef struct OvlGroup {
+    char name[256];
+    OvlAddr addr;
+    Overlay *olys;
+    Overlay *lastoly;
+    int olycnt;
+    struct OvlGroup *next;
+} OvlGroup;
+
+typedef struct Overlays {
+    OvlGroup *groups;
+    OvlGroup *lastgrp;
+    SInt32 grpcnt;
+} Overlays;
+
+typedef struct Segment {
+    char name[32];
+    UInt16 attrs;
+} Segment;
+
+typedef struct Segments {
+    Segment **segsArray;
+    UInt16 arraySize;
+    UInt16 segsCount;
+} Segments;
+typedef struct File {
+    struct File *next;
+    SInt32 filenum;
+    UInt16 segnum;
+    time_t srcmoddate;
+    time_t outmoddate;
+    char srcfilename[256];
+    char outfilename[256];
+    SInt16 outfileowner;
+    OSSpec srcfss;
+    OSSpec outfss;
+    SInt16 writeToDisk;
+    SInt16 wroteToDisk;
+    SInt16 tempOnDisk;
+    struct Plugin *compiler;
+    SInt32 dropinflags;
+    SInt32 objectflags;
+    SInt32 mappingflags;
+    SInt16 sourceUsage;
+    SInt16 objectUsage;
+    Handle textdata;
+    Handle objectdata;
+    Handle browsedata;
+    SInt32 codesize;
+    SInt32 udatasize;
+    SInt32 idatasize;
+    SInt32 compiledlines;
+    Boolean recompileDependents;
+    Boolean gendebug;
+    Boolean hasobjectcode;
+    Boolean hasresources;
+    Boolean isresourcefile;
+    Boolean weakimport;
+    Boolean initbefore;
+    Boolean mergeintooutput;
+    Deps deps;
+    Boolean recordbrowseinfo;
+    SInt16 browseFileID;
+    char browseoptions[32];
+    OSType filetype;
+    OSType filecreator;
+} File;
+
+typedef struct Files {
+    File *fileList;
+    SInt32 fileCount;
+} Files;
+
+typedef struct VFile {
+    char displayName[32];
+    Handle data;
+    struct VFile *next;
+} VFile;
+
+enum {
+    LinkModel0 = 0,
+    LinkModel1 = 1,
+    LinkModel2 = 2
+};
+
+typedef struct Target {
+    struct BuildInfo {
+        UInt32 linesCompiled;
+        UInt32 codeSize;
+        UInt32 iDataSize;
+        UInt32 uDataSize;
+    } info;
+    CWTargetInfo *targetinfo;
+    struct {
+        Segments segs;
+        Overlays overlays;
+    } linkage;
+    SInt32 linkmodel;
+    Files files;
+    Files pchs;
+    Incls incls;
+    Paths sysPaths;
+    Paths userPaths;
+    OSType lang;
+    OSType cpu;
+    OSType os;
+    char targetName[64];
+    struct Plugin *preLinker;
+    struct Plugin *linker;
+    struct Plugin *postLinker;
+    UInt32 preLinkerDropinFlags;
+    UInt32 linkerDropinFlags;
+    UInt32 postLinkerDropinFlags;
+    OSPathSpec outputDirectory;
+    VFile *virtualFiles;
+    struct Target *next;
+} Target;
+
+typedef struct Project {
+    Target *targets;
+    OSSpec projectDirectory;
+} Project;
+
+enum {
+    CLStyledMessageDispatch_Type0 = 0,
+    CLStyledMessageDispatch_Type1 = 1,
+    CLStyledMessageDispatch_Type2 = 2,
+    CLStyledMessageDispatch_Type3 = 3,
+    CLStyledMessageDispatch_Type4 = 4,
+    CLStyledMessageDispatch_Type5 = 5
+};
+
+enum {
+    IncludeSearch_Type0 = 0,
+    IncludeSearch_Type1 = 1,
+    IncludeSearch_Type2 = 2,
+    IncludeSearch_Type3 = 3,
+    IncludeSearch_Type4 = 4
+};
+
+typedef struct PrefPanel PrefPanel;
+
+typedef struct Plugin {
+    BasePluginCallbacks *cb;
+    CompilerLinkerPluginCallbacks *cl_cb;
+    ParserPluginCallbacks *pr_cb;
+    CWPluginContext context;
+    char *cached_ascii_version;
+    struct Plugin *next;
+} Plugin;
+
+/********************************/
+/* State */
+typedef struct {
+    int argc;
+    char **argv;
+    OSType cpu;
+    OSType os;
+    OSType plugintype;
+    OSType language;
+    OSType parserstyle;
+    OSSpec programSpec;
+    const char *programName;
+    SInt16 countWarnings;
+    SInt16 countErrors;
+    Boolean pluginDebug;
+    Boolean userBreak;
+    Boolean withholdWarnings;
+    Boolean withholdErrors;
+    OSSpec makefileSpec;
+    OSPathSpec sbmPathSpec;
+    OSHandle browseTableHandle;
+    char *stdout_base;
+    Boolean stdout_written;
+} CLState; // assumed name
+
+extern char cmdline_build_time[32];
+extern char cmdline_build_date[32];
+extern CLState clState;
+extern PCmdLineLinker optsLinker;
+extern PCmdLineCompiler optsCompiler;
+extern PCmdLineEnvir optsEnvir;
+extern PCmdLine optsCmdLine;
+extern Target *gTarg;
+extern Project mainProj;
+extern CWCommandLineArgs *plugin_args;
+extern CWCommandLineArgs *panel_args;
+extern const char **panelNames;
+extern int numPanels;
+extern CLPluginInfo *pluginInfo;
+extern int numPlugins;
+extern jmp_buf exit_program;
+
+/********************************/
+/* Callbacks/CLParserCallbacks_V1.cpp */
+extern int (*PrefPanelsChangedCallback)(const char *);
+
+/********************************/
+/* Clients/ClientGlue.c */
+extern int RegisterResource(const char *name, SInt16 rsrcid, const char **list);
+extern int RegisterStaticPlugin(const BasePluginCallbacks *callbacks);
+extern int RegisterStaticCompilerLinkerPlugin(const BasePluginCallbacks *callbacks, const CompilerLinkerPluginCallbacks *cl_callbacks);
+extern int RegisterStaticParserPlugin(const BasePluginCallbacks *cb, const ParserPluginCallbacks *pr_callbacks);
+extern void SetBuildTarget(OSType cpu, OSType os);
+extern void SetParserType(OSType plang);
+extern void SetPluginType(OSType lang, OSType type);
+extern int CmdLine_Initialize(int argc, char **argv, const char *builddate, const char *buildtime);
+extern int CmdLine_Driver();
+extern int CmdLine_Terminate(int exitcode);
+
+/********************************/
+/* Envir/CLErrors.c */
+extern void CLReportError(SInt16 errid, ...);
+extern void CLReportWarning(SInt16 errid, ...);
+extern void CLReport(SInt16 errid, ...);
+extern void CLReportOSError(SInt16 errid, int err, ...);
+extern void CLReportCError(SInt16 errid, int err_no, ...);
+extern void CLInternalError(const char *file, int line, const char *format, ...);
+extern void CLFatalError(const char *format, ...);
+
+/********************************/
+/* Envir/CLIO.c */
+extern void SetupDebuggingTraps();
+extern Boolean IO_Initialize();
+extern Boolean IO_Terminate();
+extern Boolean IO_HelpInitialize();
+extern Boolean IO_HelpTerminate();
+extern void FixHandleForIDE(Handle text, UInt32 size);
+extern Boolean ShowHandle(Handle text, UInt32 size, Boolean decorate);
+extern Boolean WriteHandleToFile(OSSpec *spec, Handle text, UInt32 size, OSType creator, OSType type);
+extern Boolean WriteBinaryHandleToFile(OSSpec *spec, OSType maccreator, OSType mactype, OSHandle *text);
+extern Boolean AppendHandleToFile(OSSpec *spec, Handle text, UInt32 size, OSType maccreator, OSType mactype);
+extern void InitWorking();
+extern void ShowWorking(int x);
+extern void TermWorking();
+extern Boolean CheckForUserBreak();
+extern char *IO_FormatText(char *buffer, SInt32 size, char *newline, const char *format, ...);
+extern void CLPrintDispatch(int unk, SInt16 msgtype, const char *message);
+extern void CLPrintType(SInt16 msgtype, const char *format, ...);
+extern void CLPrint(const char *format, ...);
+extern void CLPrintWarning(const char *format, ...);
+extern void CLPrintErr(const char *format, ...);
+extern SInt16 CLStyledMessageDispatch(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, ...);
+
+/********************************/
+/* Plugins/CLPlugins.c */
+extern const ToolVersionInfo *Plugin_GetToolVersionInfo();
+extern const char *Plugin_GetDropInName(Plugin *pl);
+extern const VersionInfo *Plugin_GetVersionInfo(Plugin *pl);
+extern char *Plugin_GetVersionInfoASCII(Plugin *pl);
+extern DropInFlags *Plugin_GetDropInFlags(Plugin *pl);
+extern OSType Plugin_GetPluginType(Plugin *pl);
+extern const CWTargetList *Plugin_CL_GetTargetList(Plugin *pl);
+extern const CWPanelList *Plugin_GetPanelList(Plugin *pl);
+extern const CWExtMapList *Plugin_CL_GetExtMapList(Plugin *pl);
+extern const OSFileTypeMappingList *Plugin_GetFileTypeMappingList(Plugin *pl);
+extern const CWObjectFlags *Plugin_CL_GetObjectFlags(Plugin *pl);
+extern Boolean Plugin_MatchesName(Plugin *pl, const char *name);
+extern Boolean Plugin_CL_MatchesTarget(Plugin *pl, OSType cpu, OSType os, Boolean exact);
+extern Boolean Plugins_CL_HaveMatchingTargets(Plugin *p1, Plugin *p2, Boolean exact);
+extern Boolean Plugin_CL_MatchesFileType(Plugin *pl, OSType type, const char *extension, Boolean exact);
+extern Boolean Plugin_MatchesType(Plugin *pl, OSType type, OSType lang, Boolean exact);
+extern Boolean Plugin_Pr_MatchesPlugin(Plugin *pl, CLPluginInfo *pluginfo, OSType cpu, OSType os);
+extern Boolean Plugin_Pr_MatchesPanels(Plugin *pl, int numPanels, const char **panelNames);
+extern Boolean Plugin_CL_WriteObjectFile(Plugin *pl, FSSpec *srcfss, FSSpec *outfss, OSType creator, OSType type, Handle data);
+extern Boolean Plugin_CL_GetCompilerMapping(Plugin *pl, OSType type, const char *ext, UInt32 *flags);
+extern Plugin *Plugin_New(const BasePluginCallbacks *cb, const CompilerLinkerPluginCallbacks *cl_cb, const ParserPluginCallbacks *pr_cb);
+extern void Plugin_Free(Plugin *pl);
+extern Boolean Plugin_VerifyPanels(Plugin *pl);
+extern void Plugins_Init();
+extern void Plugins_Term();
+extern int Plugins_Add(Plugin *pl);
+extern Plugin *Plugins_MatchName(Plugin *list, const char *name);
+extern Plugin *Plugins_CL_MatchTarget(Plugin *list, OSType cpu, OSType os, OSType type, OSType lang);
+extern Plugin *Plugins_CL_MatchFileType(Plugin *list, OSType type, const char *ext, Boolean exact);
+extern Plugin *Plugins_GetPluginForFile(Plugin *list, OSType plugintype, OSType cpu, OSType os, OSType type, const char *ext, OSType lang);
+extern Plugin *Plugins_GetLinker(Plugin *list, OSType cpu, OSType os);
+extern Plugin *Plugins_GetPreLinker(Plugin *list, OSType cpu, OSType os);
+extern Plugin *Plugins_GetPostLinker(Plugin *list, OSType cpu, OSType os);
+extern Plugin *Plugins_GetParserForPlugin(Plugin *list, OSType style, int numPlugins, CLPluginInfo *plugins, OSType cpu, OSType os, int numPanels, const char **panelNames);
+extern Plugin *Plugins_GetCompilerForLinker(Plugin *list, Plugin *linker, OSType type, const char *ext, OSType edit);
+extern int Plugins_GetPluginList(Plugin *list, int *numPlugins, CLPluginInfo **pluginInfo);
+extern int Plugins_GetPrefPanelUnion(Plugin *list, int *numPanels, const char ***panelNames);
+extern int Plugin_AddFileTypeMappings(Plugin *pl, OSFileTypeMappings **mlist);
+extern int Plugins_AddFileTypeMappingsForTarget(Plugin *list, OSFileTypeMappings **mlist, OSType cpu, OSType os);
+extern SInt16 Plugin_Call(Plugin *pl, void *context);
+
+/********************************/
+/* Project/CLAccessPaths.c */
+extern Path *Path_Init(const OSPathSpec *dir, Path *path);
+extern Path *Path_New(const OSPathSpec *dir);
+extern void Path_Free(Path *path);
+extern Boolean Paths_Initialize(Paths *paths);
+extern Boolean Paths_Terminate(Paths *paths);
+extern Boolean Paths_AddPath(Paths *paths, Path *path);
+extern Boolean Paths_InsertPath(Paths *paths, UInt16 index, Path *path);
+extern Boolean Paths_RemovePath(Paths *paths, UInt16 index);
+extern Boolean Paths_DeletePath(Paths *paths, UInt16 index);
+extern Path *Paths_GetPath(Paths *paths, UInt16 pathnum);
+extern UInt16 Paths_Count(const Paths *paths);
+extern Boolean Paths_FindPath(const Paths *paths, const Path *path);
+extern Path *Paths_FindPathSpec(const Paths *paths, const OSPathSpec *dir);
+extern Boolean Paths_GatherRecurse(Path *path);
+extern int Paths_CountRecurse(Paths *paths);
+extern void Paths_CopyRecurseFSS(FSSpec *list, Paths *paths, UInt16 count);
+extern Boolean MakeFrameworkPath(char *out, const char *filename, Path *globalpath);
+extern void Frameworks_AddPath(const OSPathSpec *oss);
+extern int Frameworks_AddFramework(const char *name, const char *version, Boolean hidden);
+extern void Framework_GetEnvInfo();
+extern int Frameworks_GetCount();
+extern Paths_FWInfo *Frameworks_GetInfo(int which);
+
+// Not sure if this is the right TU for this
+extern Paths FrameworkPaths;
+
+/********************************/
+/* Project/CLFiles.c */
+extern File *File_New();
+extern void File_Free(File *file);
+extern Boolean Files_Initialize(Files *);
+extern Boolean Files_Terminate(Files *);
+extern Boolean Files_AddFile(Files *, File *file);
+extern Boolean Files_InsertFile(Files *, File *file, SInt32 position);
+extern File *Files_GetFile(Files *, SInt32 filenum);
+extern File *Files_FindFile(Files *, OSSpec *spec);
+extern int Files_Count(Files *);
+extern Boolean VFiles_Initialize(VFile **list);
+extern void VFiles_Terminate(VFile **list);
+extern VFile *VFile_New(const char *name, Handle data);
+extern Boolean VFiles_Add(VFile **list, VFile *entry);
+extern VFile *VFiles_Find(VFile *list, const char *name);
+
+/********************************/
+/* Project/CLOverlays.c */
+extern Boolean Overlays_Initialize(Overlays *);
+extern Boolean Overlays_Terminate(Overlays *);
+extern Boolean Overlays_AddOvlGroup(Overlays *, OvlGroup *grp, SInt32 *grpnum);
+extern OvlGroup *Overlays_GetOvlGroup(Overlays *, SInt32 grpnum);
+extern SInt32 Overlays_CountGroups(Overlays *);
+extern Boolean Overlays_AddFileToOverlay(Overlays *, SInt32 grpnum, SInt32 ovlnum, SInt32 filenum);
+extern Overlay *Overlays_GetOverlayInGroup(Overlays *, SInt32 grpnum, SInt32 ovlnum);
+extern SInt32 Overlays_GetFileInOverlay(Overlays *, SInt32 grpnum, SInt32 ovlnum, SInt32 filnum);
+extern OvlGroup *OvlGroup_New(const char *name, OvlAddr addr);
+extern void OvlGroup_Delete(OvlGroup *grp);
+extern Boolean OvlGroup_AddOverlay(OvlGroup *, Overlay *oly, SInt32 *olynum);
+extern Overlay *OvlGroup_GetOverlay(OvlGroup *, SInt32 olynum);
+extern SInt32 OvlGroup_CountOverlays(OvlGroup *);
+extern Overlay *Overlay_New(const char *name);
+extern void Overlay_Delete(Overlay *oly);
+extern Boolean Overlay_AddFile(Overlay *oly, SInt32 filenum, SInt32 *filnum);
+extern SInt32 Overlay_GetFile(Overlay *oly, SInt32 filnum);
+extern SInt32 Overlay_CountFiles(Overlay *oly);
+
+/********************************/
+/* Project/CLProj.c */
+extern Boolean Proj_Initialize(Project *);
+extern Boolean Proj_Terminate(Project *);
+
+/********************************/
+/* Project/CLSegs.c */
+extern Segment *Segment_New(const char *name, UInt16 attrs);
+extern void Segment_Free(Segment *seg);
+extern Boolean Segments_Initialize(Segments *segs);
+extern Boolean Segments_Terminate(Segments *segs);
+extern Boolean Segments_AddSegment(Segments *segs, Segment *seg, UInt16 *index);
+extern Boolean Segments_InsertSegment(Segments *segs, UInt16 index, Segment *seg);
+extern Boolean Segments_DeleteSegment(Segments *segs, UInt16 index);
+extern Segment *Segments_GetSegment(Segments *segs, UInt16 segnum);
+extern UInt16 Segments_Count(const Segments *segs);
+
+/********************************/
+/* CLBrowser.c */
+extern int Browser_Initialize(OSHandle *browsetableptr);
+extern int Browser_Terminate(OSHandle *browsetableptr);
+extern int Browser_SearchFile(OSHandle *browsetable, const char *fullpath, SInt16 *ID);
+extern int Browser_SearchAndAddFile(OSHandle *browsetable, const char *fullpath, SInt16 *ID);
+extern int Browser_PackBrowseFile(Handle browsedata, OSHandle *browsetable, OSHandle *browsefileptr);
+
+/********************************/
+/* CLDependencies.c */
+extern SInt16 *CLT_filesp;
+extern CPrepFileInfoStack *CLT_filestack;
+
+extern Boolean Incls_Initialize(Incls *incls, Target *targ);
+extern void Incls_Terminate(Incls *incls);
+extern Boolean Incls_FindFileInPaths(Incls *incls, char *filename, Boolean fullsearch, OSSpec *spec, SInt32 *inclidx);
+extern Boolean Deps_Initialize(Deps *deps, Incls *incls);
+extern void Deps_Terminate(Deps *deps);
+extern int Deps_ChangeSpecialAccessPath(OSSpec *srcfss, Boolean initialize);
+extern Path *Deps_GetSpecialAccessPath();
+extern void Deps_AddDependency(Deps *deps, SInt32 incl, OSSpec *spec, Boolean unk, SInt16 dependencyType, Boolean *alreadyincluded);
+extern void Deps_ListDependencies(Incls *incls, File *file, OSHandle *h);
+
+/********************************/
+/* CLFileOps.c */
+extern int GetOutputFile(File *file, SInt16 stage);
+extern int StoreObjectFile(File *file);
+extern int CompileFilesInProject();
+extern int LinkProject();
+
+/********************************/
+/* CLIncludeFileCache.c */
+extern void InitializeIncludeCache();
+extern void CleanupIncludeCache();
+extern void CacheIncludeFile(OSSpec *spec, Handle text, Boolean precompiled);
+extern Handle CachedIncludeFile(OSSpec *spec, Boolean *precompiled);
+extern void FreeIncludeFile(Handle text);
+
+/********************************/
+/* CLLicenses.c */
+extern void License_Initialize();
+extern void License_Terminate();
+extern SInt32 License_Checkout();
+extern void License_Refresh();
+extern void License_Checkin();
+extern void License_AutoCheckin();
+
+/********************************/
+/* CLLoadAndCache.c */
+extern short FixTextHandle(Handle txt);
+extern int LoadAndCacheFile(OSSpec *spec, Handle *texthandle, Boolean *precomp);
+extern void CopyFileText(Handle src, char **text, SInt32 *textsize);
+
+/********************************/
+/* CLMain.c */
+extern void Main_PreParse(int *argc, char ***argv);
+extern void Main_PassSpecialArgs(int *argc, char ***argv);
+extern int Main_Initialize(int argc, char **argv);
+extern int Main_Terminate(int code);
+extern int Main_Driver();
+
+/********************************/
+/* CLPluginRequests.cpp */
+extern Boolean SendParserRequest(
+        Plugin *plugin,
+        Target *target,
+        CWCommandLineArgs *args,
+        OSType cpu,
+        OSType os,
+        int numPlugins,
+        CLPluginInfo *pluginInfo,
+        int numPanels,
+        const char **panelNames,
+        CWCommandLineArgs *plugin_args,
+        CWCommandLineArgs *panel_args,
+        const char *build_date,
+        const char *build_time,
+        const ToolVersionInfo *build_tool
+);
+extern Boolean SendCompilerRequest(Plugin *plugin, File *file, SInt16 stage);
+extern Boolean SendTargetInfoRequest(Target *targ, Plugin *linker, SInt32 dropinflags);
+extern Boolean SendLinkerRequest(Plugin *plugin, SInt32 dropinflags, CWTargetInfo *targetInfo);
+extern Boolean SendDisassemblerRequest(Plugin *linker, File *file);
+extern Boolean SendInitOrTermRequest(Plugin *plugin, Boolean reqIsInitialize);
+
+/********************************/
+/* CLPrefs.c */
+extern PrefPanel *PrefPanel_New(const char *name, void *initdata, SInt32 initdatasize);
+extern Handle PrefPanel_GetHandle(PrefPanel *panel);
+extern int PrefPanel_PutHandle(PrefPanel *panel, Handle data);
+extern void Prefs_Initialize();
+extern void Prefs_Terminate();
+extern Boolean Prefs_AddPanel(PrefPanel *panel);
+extern PrefPanel *Prefs_FindPanel(const char *name);
+
+/********************************/
+/* CLTarg.c */
+extern Target *Target_New(const char *name, OSType cpu, OSType os, OSType lang);
+extern void Target_Free(Target *targ);
+extern void Targets_Term(Target *list);
+extern void Target_Add(Target **list, Target *targ);
+
+/********************************/
+/* CLToolExec.c */
+extern void AppendArgumentList(int *argc, char ***argv, const char *str);
+extern int SetupTemporaries();
+extern int DeleteTemporaries();
+extern int ExecuteLinker(Plugin *plugin, SInt32 dropinflags, File *file, char *stdoutfile, char *stderrfile);
+
+/********************************/
+/* CLWriteObjectFile.c */
+extern int WriteObjectFile(File *file, OSType maccreator, OSType mactype);
+extern int WriteBrowseData(File *file, OSType maccreator, OSType mactype);
+
+/********************************/
+/* Unknown name - provisionally named uFileTypeMappings.c */
+extern void AddFileTypeMappingList(OSFileTypeMappings **list, const OSFileTypeMappingList *entry);
+extern void UseFileTypeMappings(OSFileTypeMappings *list);
+extern OSErr SetMacFileType(const FSSpec *spec, OSType mactype);
+extern OSErr GetMacFileType(const FSSpec *spec, OSType *mactype);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/includes/common.h b/includes/common.h
index 760be22..b1b5b61 100644
--- a/includes/common.h
+++ b/includes/common.h
@@ -24,6 +24,8 @@
 #define va_arg(a,b) (*(b *) (void *) ((a = (char *) (((((unsigned long)(a)) + ((__alignof__ (b) == 16) ? 15 : 3)) & ~((__alignof__ (b) == 16) ? 15 : 3)) + ((sizeof (b) + 3) & ~3))) - ((sizeof (b) + 3) & ~3)))
 #define va_end(a) ((void)0)
 
+#define alloca(x) __alloca(x)
+
 #else
 #include <stdarg.h>
 // expand this to nothing
@@ -34,13 +36,13 @@
 // MacTypes.h
 #ifdef __MWERKS__
 typedef unsigned char UInt8;
-typedef signed char SInt8;
+typedef char SInt8;
 typedef unsigned short UInt16;
-typedef signed short SInt16;
+typedef short SInt16;
 typedef unsigned long UInt32;
-typedef signed long SInt32;
+typedef long SInt32;
 typedef unsigned long long UInt64;
-typedef signed long long SInt64;
+typedef long long SInt64;
 
 typedef long Size;
 #else
diff --git a/includes/cos.h b/includes/cos.h
new file mode 100644
index 0000000..777b380
--- /dev/null
+++ b/includes/cos.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "common.h"
+
+extern Handle COS_NewHandle(SInt32 byteCount);
+extern Handle COS_NewOSHandle(SInt32 logicalSize);
+extern void COS_FreeHandle(Handle handle);
+extern Boolean COS_ResizeHandle(Handle handle, SInt32 newSize);
+extern SInt32 COS_GetHandleSize(Handle handle);
+extern void COS_LockHandle(Handle handle);
+extern void COS_LockHandleHi(Handle handle);
+extern void COS_UnlockHandle(Handle handle);
+extern int COS_GetHandleState(Handle handle);
+extern void COS_SetHandleState(Handle handle, int state);
+extern Boolean COS_IsLockedState(int state);
+extern char *COS_NewPtr(SInt32 byteCount);
+extern char *COS_NewPtrClear(SInt32 byteCount);
+extern void COS_FreePtr(char *ptr);
+extern void COS_AppendPtrToHandle(char *ptr1, Handle hand2, SInt32 size);
+extern OSErr COS_GetMemErr();
+extern SInt32 COS_GetTicks();
+extern SInt32 COS_GetTime();
+extern void COS_GetString(char *buffer, SInt16 strListID, SInt16 index);
+extern void COS_GetPString(StringPtr buffer, SInt16 strListID, SInt16 index);
+extern Boolean COS_IsMultiByte(const char *str, int offset);
+extern OSErr COS_FileNew(const FSSpec *spec, SInt16 *refNum, OSType creator, OSType fileType);
+extern OSErr COS_FileOpen(const FSSpec *spec, SInt16 *refNum);
+extern OSErr COS_FileGetType(const FSSpec *spec, OSType *fileType);
+extern OSErr COS_FileGetSize(SInt16 refNum, SInt32 *logEOF);
+extern OSErr COS_FileRead(SInt16 refNum, void *buffPtr, SInt32 count);
+extern OSErr COS_FileWrite(SInt16 refNum, const void *buffPtr, SInt32 count);
+extern OSErr COS_FileGetPos(SInt16 refNum, SInt32 *filePos);
+extern OSErr COS_FileSetPos(SInt16 refNum, SInt32 filePos);
+extern OSErr COS_FileClose(SInt16 refNum);
+extern void COS_FileSetFSSpec(FSSpec *spec, ConstStringPtr path);
+extern OSErr COS_FileMakeFSSpec(SInt16 vRefNum, SInt32 dirID, ConstStringPtr fileName, FSSpec *spec);
+extern OSErr COS_FileMakeFSSpecWithPath(const FSSpec *inputSpec, ConstStringPtr fileName, FSSpec *spec);
+extern OSErr COS_FileGetFileInfo(const FSSpec *spec, OSType *creator, OSType *fileType);
+extern void COS_FileGetFSSpecInfo(const FSSpec *spec, SInt16 *vRefNum, SInt32 *dirID, StringPtr fileName);
+extern void COS_FileGetPathName(char *buffer, const FSSpec *spec, SInt32 *mdDat);
+extern int COS_EqualFileSpec(const FSSpec *a, const FSSpec *b);
diff --git a/includes/cw_common.h b/includes/cw_common.h
new file mode 100644
index 0000000..bea498a
--- /dev/null
+++ b/includes/cw_common.h
@@ -0,0 +1,43 @@
+#pragma once
+
+/*
+ * Things that seem to be shared across different CodeWarrior modules
+ */
+
+#include "common.h"
+#include "oslib.h"
+#include "macemul.h"
+#include "plugin.h"
+
+typedef struct VersionInfo {
+    UInt16 major;
+    UInt16 minor;
+    UInt16 patch;
+    UInt16 build;
+} VersionInfo;
+
+typedef struct BasePluginCallbacks {
+    CWPLUGIN_ENTRY (*main)(CWPluginContext context);
+    CWPLUGIN_ENTRY (*GetDropInFlags)(const DropInFlags **flags, SInt32 *flagsSize);
+    CWPLUGIN_ENTRY (*GetDisplayName)(const char **displayName);
+    CWPLUGIN_ENTRY (*GetDropInName)(const char **dropInName);
+    CWPLUGIN_ENTRY (*GetPanelList)(const CWPanelList **panelList);
+    CWPLUGIN_ENTRY (*GetFamilyList)(const CWFamilyList **familyList);
+    CWPLUGIN_ENTRY (*GetHelpInfo)(const CWHelpInfo **helpInfo);
+    CWPLUGIN_ENTRY (*GetVersionInfo)(const VersionInfo **versionInfo);
+    CWPLUGIN_ENTRY (*GetFileTypeMappings)(const OSFileTypeMappingList **mappingList);
+} BasePluginCallbacks;
+
+typedef struct CompilerLinkerPluginCallbacks {
+    CWPLUGIN_ENTRY (*GetTargetList)(const struct CWTargetList **targetList);
+    CWPLUGIN_ENTRY (*GetDefaultMappingList)(const CWExtMapList **mappings);
+    CWPLUGIN_ENTRY (*Unmangle)();
+    CWPLUGIN_ENTRY (*BrSymbolEntryPoint)();
+    CWPLUGIN_ENTRY (*GetObjectFlags)(const CWObjectFlags **objectFlags);
+    CWPLUGIN_ENTRY (*WriteObjectFile)(const FSSpec *srcfss, const FSSpec *outfss, OSType creator, OSType type, Handle data);
+} CompilerLinkerPluginCallbacks;
+
+typedef struct ParserPluginCallbacks {
+    CWPLUGIN_ENTRY (*SupportsPlugin)(const CLPluginInfo *pluginfo, OSType cpu, OSType os, Boolean *isSupported);
+    CWPLUGIN_ENTRY (*SupportsPanels)(int numPanels, const char **panelNames, Boolean *isSupported);
+} ParserPluginCallbacks;
diff --git a/includes/macemul.h b/includes/macemul.h
index 4d0e502..dbc4765 100644
--- a/includes/macemul.h
+++ b/includes/macemul.h
@@ -110,7 +110,7 @@ extern OSErr InitResources();
 extern OSErr ResError();
 extern void FSpCreateResFile(const FSSpec *fss, OSType creator, OSType fileType, ScriptCode scriptTag);
 extern void HCreateResFile(SInt16 vRefNum, SInt32 dirID, ConstStringPtr fileName);
-extern OSErr FSpOpenResFile(const FSSpec *fss, SInt8 permission);
+extern OSErr FSpOpenResFile(const FSSpec *spec, SInt8 permission);
 extern SInt16 HOpenResFile(SInt16 vRefNum, SInt32 dirID, ConstStringPtr fileName, SInt8 permission);
 extern SInt16 CurResFile();
 extern void UseResFile(SInt16 refNum);
@@ -146,7 +146,7 @@ extern Boolean LMGetResLoad();
 /********************************/
 /* ResourceStrings */
 extern void Res_Initialize();
-extern int Res_AddResource(const char *name, SInt16 rsrcid, Handle strings);
+extern int Res_AddResource(const char *name, SInt16 rsrcid, const char **strings);
 extern const char *Res_GetResource(SInt16 rsrcid, SInt16 index);
 extern void Res_Cleanup();
 
diff --git a/includes/mwcc_decomp.h b/includes/mwcc_decomp.h
index c5fa000..a898422 100644
--- a/includes/mwcc_decomp.h
+++ b/includes/mwcc_decomp.h
@@ -10,861 +10,11 @@
 extern "C" {
 #endif
 
-#ifdef	__MWERKS__
-#pragma options align=mac68k
-#endif
-typedef struct CWObjectFlags {
-    SInt16 version;
-    SInt32 flags;
-    const char *objFileExt;
-    const char *brsFileExt;
-    const char *ppFileExt;
-    const char *disFileExt;
-    const char *depFileExt;
-    const char *pchFileExt;
-    OSType objFileCreator;
-    OSType objFileType;
-    OSType brsFileCreator;
-    OSType brsFileType;
-    OSType ppFileCreator;
-    OSType ppFileType;
-    OSType disFileCreator;
-    OSType disFileType;
-    OSType depFileCreator;
-    OSType depFileType;
-} CWObjectFlags;
-
-#ifdef	__MWERKS__
-#pragma options align=reset
-#endif
-
-
-// Pref panels
-#ifdef	__MWERKS__
-#pragma options align=mac68k
-#endif
-enum {
-    OptsCmdLineState_0 = 0,
-    OptsCmdLineState_1 = 1,
-    OptsCmdLineState_2 = 2,
-    OptsCmdLineState_3 = 3
-};
-enum {
-    CmdLineStage_Cg = 1,
-    CmdLineStage_Pp = 2,
-    CmdLineStage_Ds = 3
-};
-enum {
-    CmdLineStageMask_Pp = 1,
-    CmdLineStageMask_Cg = 2,
-    CmdLineStageMask_Ds = 4,
-    CmdLineStageMask_Dp = 8
-};
-typedef struct PCmdLine {
-    SInt16 version;
-    SInt16 state;
-    SInt16 stages;
-    SInt16 toDisk;
-    SInt16 outNameOwner;
-    Boolean dryRun;
-    Boolean debugInfo;
-    SInt16 verbose;
-    Boolean showLines;
-    Boolean timeWorking;
-    Boolean noWarnings;
-    Boolean warningsAreErrors;
-    UInt16 maxErrors;
-    UInt16 maxWarnings;
-    SInt16 msgStyle;
-    Boolean noWrapOutput;
-    Boolean stderr2stdout;
-    Boolean noCmdLineWarnings;
-} PCmdLine;
-typedef struct PCmdLineCompiler {
-    SInt16 version;
-    Boolean noSysPath;
-    Boolean noFail;
-    SInt16 includeSearch;
-    char linkerName[64];
-    char objFileExt[15];
-    char brsFileExt[15];
-    char ppFileExt[15];
-    char disFileExt[15];
-    char depFileExt[15];
-    char pchFileExt[15];
-    OSType objFileCreator;
-    OSType objFileType;
-    OSType brsFileCreator;
-    OSType brsFileType;
-    OSType ppFileCreator;
-    OSType ppFileType;
-    OSType disFileCreator;
-    OSType disFileType;
-    OSType depFileCreator;
-    OSType depFileType;
-    Boolean compileIgnored;
-    Boolean relPathInOutputDir;
-    Boolean browserEnabled;
-    Boolean depsOnlyUserFiles;
-    char outMakefile[256];
-    SInt8 forcePrecompile;
-    Boolean ignoreMissingFiles;
-    Boolean printHeaderNames;
-    SInt8 sbmState;
-    char sbmPath[256];
-    Boolean canonicalIncludes;
-    Boolean keepObjects;
-} PCmdLineCompiler;
-typedef struct PCmdLineLinker {
-    SInt16 version;
-    Boolean callPreLinker;
-    Boolean callPostLinker;
-    Boolean keepLinkerOutput;
-    Boolean callLinker;
-} PCmdLineLinker;
-typedef struct PCmdLineEnvir {
-    SInt16 version;
-    SInt16 cols;
-    SInt16 rows;
-    Boolean underIDE;
-} PCmdLineEnvir;
-typedef struct PBackEnd {
-    SInt16 version;
-    UInt8 structalignment;
-    UInt8 tracebacktables;
-    UInt8 processor;
-    UInt8 readonlystrings;
-    UInt8 profiler;
-    UInt8 fpcontract;
-    UInt8 schedule;
-    UInt8 peephole;
-    UInt8 processorspecific;
-    UInt8 altivec;
-    UInt8 vrsave;
-    UInt8 autovectorize;
-    UInt8 usebuiltins;
-    UInt8 pic;
-    UInt8 dynamic;
-    UInt8 common;
-    UInt8 implicit_templates;
-    UInt8 reserved[3];
-} PBackEnd;
-typedef struct PDisassembler {
-    SInt16 version;
-    Boolean showcode;
-    Boolean extended;
-    Boolean mix;
-    Boolean nohex;
-    Boolean showdata;
-    Boolean showexceptions;
-    Boolean showsym;
-    Boolean shownames;
-} PDisassembler;
-typedef struct PMachOLinker {
-    SInt16 version;
-    UInt8 linksym;
-    UInt8 symfullpath;
-    UInt8 suppresswarn;
-    UInt8 linkmap;
-    UInt8 multisymerror;
-    UInt8 whatfileloaded;
-    UInt8 whyfileloaded;
-    UInt8 use_objectivec_semantics;
-    SInt8 undefinedsymbols;
-    SInt8 readonlyrelocs;
-    SInt8 reserved_value1;
-    SInt8 reserved_value2;
-    SInt16 exports;
-    SInt16 reserved_short1;
-    UInt32 currentversion;
-    UInt32 compatibleversion;
-    SInt32 reserved_long1;
-    char mainname[64];
-    UInt8 prebind;
-    UInt8 dead_strip;
-    UInt8 twolevel_namespace;
-    UInt8 strip_debug_symbols;
-} PMachOLinker;
-typedef struct PMachOProject {
-    SInt16 version;
-    SInt16 type;
-    Str63 outfile;
-    OSType filecreator;
-    OSType filetype;
-    SInt32 stacksize;
-    SInt32 stackaddress;
-    SInt32 reserved1;
-    SInt32 reserved2;
-    SInt32 reserved3;
-    SInt32 reserved4;
-    SInt32 reserved5;
-    SInt32 reserved6;
-    SInt32 reserved7;
-    SInt32 reserved8;
-    SInt32 reserved9;
-    SInt32 reserved10;
-    SInt32 reserved11;
-    SInt32 reserved12;
-    SInt32 reserved13;
-    SInt32 reserved14;
-    SInt32 reserved15;
-    SInt32 reserved16;
-    SInt32 reserved17;
-    SInt32 reserved18;
-    SInt32 reserved19;
-    SInt32 reserved20;
-    UInt8 flatrsrc;
-    UInt8 filler1;
-    UInt8 filler2;
-    UInt8 filler3;
-    Str63 separateflatfile;
-    Str255 installpath;
-} PMachOProject;
-typedef struct {
-    SInt16 version;
-    Boolean userSetCreator;
-    Boolean userSetType;
-    Boolean gPrintMapToStdOutput;
-    Str255 mapfilename;
-    Str255 symfilename;
-} PCLTExtras;
-
-typedef struct VersionInfo {
-    UInt16 major;
-    UInt16 minor;
-    UInt16 patch;
-    UInt16 build;
-} VersionInfo;
-
-/*typedef struct CLPluginInfo {
-    OSType plugintype;
-    OSType language;
-    SInt32 dropinflags;
-    char *version;
-    Boolean storeCommandLine;
-} CLPluginInfo;
-
-typedef struct ToolVersionInfo {
-    char *company;
-    char *product;
-    char *tool;
-    char *copyright;
-    char *version;
-} ToolVersionInfo;*/
-#ifdef	__MWERKS__
-#pragma options align=reset
-#endif
-
-// may not actually be named this
-struct ParseOptsType {
-    struct CWPluginPrivateContext *context;
-    char helpKey[64];
-    SInt32 helpFlags;
-    UInt16 ioCols;
-    UInt16 ioRows;
-    CWCommandLineArgs *args;
-    const ToolVersionInfo *toolVersion;
-    int numPlugins;
-    const CLPluginInfo *plugins;
-    int numPanels;
-    const char **panelNames;
-    OSType cpu;
-    OSType os;
-    char lastoutputname[256];
-    SInt32 currentSegment;
-    SInt32 currentOverlayGroup;
-    SInt32 currentOverlay;
-    int possibleFiles;
-    int userSpecifiedFiles;
-    int unusedFiles;
-    Boolean hadAnyOutput;
-    Boolean hadErrors;
-    Boolean showHelp;
-    Boolean underIDE;
-    Boolean alwaysUsePaths;
-    Boolean noOptions;
-    Boolean printedVersion;
-    Boolean passingArgs;
-    Boolean disToFile;
-    Boolean ppToFile;
-    Boolean initBefore;
-    Boolean weakImport;
-    Boolean mergeIntoOutput;
-    Boolean success;
-    Boolean ignoreUnknown;
-    UInt8 unused[2];
-};
-
-typedef struct {
-    int argc;
-    char **argv;
-    OSType cpu;
-    OSType os;
-    OSType plugintype;
-    OSType language;
-    OSType parserstyle;
-    OSSpec programSpec;
-    const char *programName;
-    SInt16 countWarnings;
-    SInt16 countErrors;
-    Boolean pluginDebug;
-    Boolean userBreak;
-    Boolean withholdWarnings;
-    Boolean withholdErrors;
-    OSSpec makefileSpec;
-    OSPathSpec sbmPathSpec;
-    OSHandle browseTableHandle;
-    char *stdout_base;
-    int stdout_written;
-} CLState; // assumed name
-
-typedef struct BasePluginCallbacks {
-    SInt16 (*main)(CWPluginContext context);
-    SInt16 (*GetDropInFlags)(const DropInFlags **flags, SInt32 *flagsSize);
-    SInt16 (*GetDisplayName)(const char **displayName);
-    SInt16 (*GetDropInName)(const char **dropInName);
-    SInt16 (*GetPanelList)(const CWPanelList **panelList);
-    SInt16 (*GetFamilyList)(const CWFamilyList **familyList);
-    SInt16 (*GetHelpInfo)(const CWHelpInfo **helpInfo);
-    SInt16 (*GetVersionInfo)(const VersionInfo **versionInfo);
-    SInt16 (*GetFileTypeMappings)(const OSFileTypeMappingList **mappingList);
-} BasePluginCallbacks;
-
-typedef struct CompilerLinkerPluginCallbacks {
-    SInt16 (*GetTargetList)(const struct CWTargetList **targetList);
-    SInt16 (*GetDefaultMappingList)();
-    SInt16 (*Unmangle)();
-    SInt16 (*BrSymbolEntryPoint)();
-    SInt16 (*GetObjectFlags)();
-    SInt16 (*WriteObjectFile)();
-} CompilerLinkerPluginCallbacks;
-
-typedef struct ParserPluginCallbacks {
-    SInt16 (*SupportsPlugin)();
-    SInt16 (*SupportsPanels)();
-} ParserPluginCallbacks;
-
-typedef struct {
-    char *name;
-    void *ptr;
-    SInt32 size;
-} PrefDataPanel; // assumed name
-
-typedef struct {
-    OSType TYPE;
-    OSType LANG;
-    OSType CPU;
-    OSType OS;
-    int numPrefPanels;
-    char **prefPanels;
-    char *toolInfo;
-    char *copyright;
-    int numOptionLists;
-    struct OptionList **optionLists;
-    int numPrefDataPanels;
-    PrefDataPanel *prefDataPanels;
-    int (*PreParse)();
-    int (*MidParse)();
-    int (*PostParse)();
-} ParserTool; // assumed name
-
-// I think this is internally defined in its .c file
-// pro8 mwcc refers to it as =s0
-typedef struct PrefPanel {
-    char *name;
-    Handle data;
-    Handle workData;
-    struct PrefPanel *next;
-} PrefPanel;
-
-// CLAccessPaths
-typedef struct Paths {
-    struct Path **pathsArray;
-    UInt16 arraySize;
-    UInt16 pathsCount;
-} Paths;
-
-typedef struct Frameworks {
-    struct Paths_FWInfo **fwsArray;
-    UInt16 arraySize;
-    UInt16 fwsCount;
-} Frameworks;
-
-typedef struct Path {
-    OSPathSpec *spec;
-    Paths *recursive;
-    char *dirlist;
-    SInt16 flags;
-} Path;
-
-typedef struct Paths_FWInfo {
-    OSSpec fileSpec;
-    OSPathSpec version;
-    OSPathSpec name;
-    Path *path;
-    Boolean hidden;
-} Paths_FWInfo;
-
-// CLDependencies
-typedef struct InclFile {
-    SInt32 filenameoffs;
-    Path *accesspath;
-    Path *globalpath;
-    Path *specialpath;
-    Boolean syspath;
-} InclFile;
-
-typedef struct Incls {
-    struct Target *targ;
-    SInt32 numincls;
-    SInt32 maxincls;
-    InclFile *files;
-    SInt32 buflen;
-    SInt32 bufpos;
-    char *buffer;
-    Paths *allPaths;
-} Incls;
-
-typedef struct Deps {
-    int numDeps;
-    int maxDeps;
-    SInt32 *list;
-    Incls *incls;
-} Deps;
-
-// CLFiles
-typedef struct File {
-    struct File *next;
-    SInt32 filenum;
-    UInt16 segnum;
-    SInt32 srcmoddate;
-    SInt32 outmoddate;
-    char srcfilename[256];
-    char outfilename[256];
-    SInt16 outfileowner;
-    OSSpec srcfss;
-    OSSpec outfss;
-    SInt16 writeToDisk;
-    SInt16 wroteToDisk;
-    SInt16 tempOnDisk;
-    struct Plugin *compiler;
-    SInt32 dropinflags;
-    SInt32 objectflags;
-    SInt32 mappingflags;
-    SInt16 sourceUsage;
-    SInt16 objectUsage;
-    Handle textdata;
-    Handle objectdata;
-    Handle browsedata;
-    SInt32 codesize;
-    SInt32 udatasize;
-    SInt32 idatasize;
-    SInt32 compiledlines;
-    Boolean recompileDependents;
-    Boolean gendebug;
-    Boolean hasobjectcode;
-    Boolean hasresources;
-    Boolean isresourcefile;
-    Boolean weakimport;
-    Boolean initbefore;
-    Boolean mergeintooutput;
-    Deps deps;
-    Boolean recordbrowseinfo;
-    SInt16 browseFileID;
-    char browseoptions[32];
-    OSType filetype;
-    OSType filecreator;
-} File;
-
-typedef struct Files {
-    File *fileList;
-    SInt32 fileCount;
-} Files;
-
-typedef struct VFile {
-    char displayName[32];
-    Handle data;
-    struct VFile *next;
-} VFile;
-
-// CLOverlays
-typedef struct OvlAddr {
-    UInt32 lo, hi;
-} OvlAddr;
-
-typedef struct Overlay {
-    char name[256];
-    SInt32 *list;
-    SInt32 cnt;
-    SInt32 max;
-    struct Overlay *next;
-} Overlay;
-
-typedef struct OvlGroup {
-    char name[256];
-    OvlAddr addr;
-    Overlay *olys;
-    Overlay *lastoly;
-    int olycnt;
-    struct OvlGroup *next;
-} OvlGroup;
-
-typedef struct Overlays {
-    OvlGroup *groups;
-    OvlGroup *lastgrp;
-    SInt32 grpcnt;
-} Overlays;
-
-// CLSegs
-typedef struct Segment {
-    char name[32];
-    SInt16 attrs;
-} Segment;
-
-typedef struct Segments {
-    Segment **segsArray;
-    UInt16 arraySize;
-    UInt16 segsCount;
-} Segments;
-
-// CLTarg
-// Is this actually in Pro7? Not sure
-typedef struct CLTargetInfo {
-    OSType targetCPU;
-    OSType targetOS;
-    SInt16 outputType;
-    SInt16 linkType;
-    Boolean canRun;
-    Boolean canDebug;
-    OSSpec outfile;
-    OSSpec symfile;
-    OSSpec runfile;
-    OSSpec linkAgainstFile;
-} CLTargetInfo;
-/*typedef struct CWTargetInfo {
-    SInt16 outputType;
-    FSSpec outfile;
-    FSSpec symfile;
-    FSSpec runfile;
-    SInt16 linkType;
-    Boolean canRun;
-    Boolean canDebug;
-    OSType targetCPU;
-    OSType targetOS;
-    OSType outfileCreator;
-    OSType outfileType;
-    OSType debuggerCreator;
-    OSType runHelperCreator;
-    FSSpec linkAgainstFile;
-} CWTargetInfo;*/
-typedef struct Target {
-    struct BuildInfo {
-        UInt32 linesCompiled;
-        UInt32 codeSize;
-        UInt32 iDataSize;
-        UInt32 uDataSize;
-    } info;
-    CWTargetInfo *targetinfo;
-    struct {
-        Segments segs;
-        Overlays overlays;
-    } linkage;
-    SInt32 linkmodel;
-    Files files;
-    Files pchs;
-    Incls incls;
-    Paths sysPaths;
-    Paths userPaths;
-    OSType lang;
-    OSType cpu;
-    OSType os;
-    char targetName[64];
-    struct Plugin *preLinker;
-    struct Plugin *linker;
-    struct Plugin *postLinker;
-    UInt32 preLinkerDropinFlags;
-    UInt32 linkerDropinFlags;
-    UInt32 postLinkerDropinFlags;
-    OSPathSpec outputDirectory;
-    VFile *virtualFiles;
-    struct Target *next;
-} Target;
-
-typedef struct Plugin {
-    BasePluginCallbacks *cb;
-    CompilerLinkerPluginCallbacks *cl_cb;
-    ParserPluginCallbacks *pr_cb;
-    void *context;
-    char *cached_ascii_version;
-    struct Plugin *next;
-} Plugin;
-
-typedef struct Token {
-    int x0;
-    void *x4;
-} Token;
-
 /********************************/
 /* command_line/CmdLine/Src/Clients/CLStaticMain.c */
 extern int main(int argc, const char **argv);
 
 /********************************/
-/* command_line/CmdLine/Src/Clients/ClientGlue.c */
-extern int RegisterResource(const char *name, SInt16 rsrcid, const char **list);
-extern int RegisterStaticPlugin(const BasePluginCallbacks *callbacks);
-extern int RegisterStaticCompilerLinkerPlugin(const BasePluginCallbacks *callbacks, const CompilerLinkerPluginCallbacks *cl_callbacks);
-extern int RegisterStaticParserPlugin(const BasePluginCallbacks *cb, const ParserPluginCallbacks *pr_callbacks);
-extern void SetBuildTarget(OSType cpu, OSType os);
-extern void SetParserType(OSType plang);
-extern void SetPluginType(OSType lang, OSType type);
-extern int CmdLine_Initialize(int argc, const char **argv, const char *builddate, const char *buildtime);
-extern int CmdLine_Driver();
-extern int CmdLine_Terminate(int exitcode);
-
-/********************************/
-/* command_line/CmdLine/Src/CLMain.c */
-extern void Main_PreParse(int *argc, char ***argv);
-extern void Main_PassSpecialArgs(int *argc, char ***argv);
-extern int Main_Initialize(int argc, char **argv);
-extern int Main_Terminate(int code);
-extern int Main_Driver();
-
-/********************************/
-/* command_line/CmdLine/Src/Envir/CLErrors.c */
-extern void CLReportError(SInt16 errid, ...);
-extern void CLReportWarning(SInt16 errid, ...);
-extern void CLReport(SInt16 errid, ...);
-extern void CLReportOSError(SInt16 errid, int err, ...);
-extern void CLReportCError(SInt16 errid, int err_no, ...);
-extern void CLInternalError(const char *file, int line, const char *format, ...);
-extern void CLFatalError(const char *format, ...);
-
-/********************************/
-/* command_line/CmdLine/Src/Plugins/CLPlugins.c */
-//static void GetToolVersionInfo();
-extern const ToolVersionInfo *Plugin_GetToolVersionInfo();
-//static const char *Plugin_GetDisplayName(Plugin *pl);
-extern const char *Plugin_GetDropInName(Plugin *pl);
-extern VersionInfo *Plugin_GetVersionInfo(Plugin *pl);
-extern const char *Plugin_GetVersionInfoASCII(Plugin *pl);
-extern DropInFlags *Plugin_GetDropInFlags(Plugin *pl);
-extern OSType Plugin_GetPluginType(Plugin *pl);
-extern const CWTargetList *Plugin_CL_GetTargetList(Plugin *pl);
-extern const CWPanelList *Plugin_GetPanelList(Plugin *pl);
-extern const CWExtMapList *Plugin_CL_GetExtMapList(Plugin *pl);
-extern const OSFileTypeMappingList *Plugin_GetFileTypeMappingList(Plugin *pl);
-extern const CWObjectFlags *Plugin_CL_GetObjectFlags(Plugin *pl);
-extern Boolean Plugin_MatchesName(Plugin *pl, const char *name);
-extern Boolean Plugin_CL_MatchesTarget(Plugin *pl, OSType cpu, OSType os, Boolean exact);
-extern Boolean Plugins_CL_HaveMatchingTargets(Plugin *p1, Plugin *p2, Boolean exact);
-//static CL_MatchesExtMapping(CWExtensionMapping *map, OSType type, const char *ext, Boolean exact);
-extern Boolean Plugin_CL_MatchesFileType(Plugin *pl, OSType type, const char *extension, Boolean exact);
-extern Boolean Plugin_MatchesType(Plugin *pl, OSType type, OSType lang, Boolean exact);
-extern Boolean Plugin_Pr_MatchesPlugin(Plugin *pl, CLPluginInfo *pluginfo, OSType cpu, OSType os);
-extern Boolean Plugin_Pr_MatchesPanels(Plugin *pl, int numPanels, char **panelNames);
-extern Boolean Plugin_CL_WriteObjectFile(Plugin *pl, FSSpec *src, FSSpec *out, OSType creator, OSType type, OSHandle *data);
-extern Boolean Plugin_CL_GetCompilerMapping(Plugin *pl, OSType type, const char *ext, UInt32 *flags);
-//static Boolean SupportedPlugin(Plugin *pl, const char **reason);
-//static Boolean VerifyPanels(Plugin *pl);
-extern Plugin *Plugin_New(const BasePluginCallbacks *cb, const CompilerLinkerPluginCallbacks *cl_cb, const ParserPluginCallbacks *pr_cb);
-extern void Plugin_Free(Plugin *pl);
-extern int Plugin_VerifyPanels(Plugin *pl);
-extern void Plugins_Init();
-extern void Plugins_Term();
-extern int Plugins_Add(Plugin *pl);
-extern Plugin *Plugins_MatchName(Plugin *list, const char *name);
-extern Plugin *Plugins_CL_MatchTarget(Plugin *list, OSType cpu, OSType os, OSType type, OSType lang);
-extern Plugin *Plugins_CL_MatchFileType(Plugin *list, OSType type, const char *ext, Boolean exact);
-extern Plugin *Plugins_GetPluginForFile(Plugin *list, OSType plugintype, OSType cpu, OSType os, OSType type, const char *ext, OSType lang);
-extern Plugin *Plugins_GetLinker(Plugin *list, OSType cpu, OSType os);
-extern Plugin *Plugins_GetPreLinker(Plugin *list, OSType cpu, OSType os);
-extern Plugin *Plugins_GetPostLinker(Plugin *list, OSType cpu, OSType os);
-extern Plugin *Plugins_GetParserForPlugin(Plugin *list, OSType style, int numPlugins, CLPluginInfo *plugins, OSType cpu, OSType os, int numPanels, char **panelNames);
-extern Plugin *Plugins_GetCompilerForLinker(Plugin *list, Plugin *linker, OSType type, const char *ext, OSType edit);
-extern int Plugins_GetPluginList(Plugin *list, int *numPlugins, CLPluginInfo **pluginInfo);
-extern int Plugins_GetPrefPanelUnion(Plugin *list, int *numPanels, char ***panelNames);
-extern int Plugin_AddFileTypeMappings(Plugin *pl, OSFileTypeMappingList *ftml);
-extern int Plugins_AddFileTypeMappingsForTarget(Plugin *list, OSFileTypeMappings **mlist, OSType cpu, OSType os);
-extern SInt16 Plugin_Call(Plugin *pl, void *context);
-
-/********************************/
-/* command_line/CmdLine/Src/Callbacks/CLParserCallbacks_v1.cpp */
-// haha this is a C++ nightmare
-
-/********************************/
-/* command_line/CmdLine/Src/Envir/CLIO.c */
-typedef struct MessageRef {
-    OSSpec sourcefile;
-    OSSpec errorfile;
-    char *sourceline;
-    SInt32 linenumber;
-    SInt32 tokenoffset;
-    SInt16 tokenlength;
-    SInt32 selectionoffset;
-    SInt16 selectionlength;
-} MessageRef;
-
-extern void SetupDebuggingTraps();
-extern Boolean IO_Initialize();
-extern Boolean IO_Terminate();
-extern Boolean IO_HelpInitialize();
-extern Boolean IO_HelpTerminate();
-extern void FixHandleForIDE(OSHandle *text);
-extern Boolean ShowHandle(OSHandle *text, Boolean decorate);
-extern Boolean WriteHandleToFile(OSSpec *spec, OSHandle *text, OSType creator, OSType type);
-extern Boolean WriteBinaryHandleToFile(OSSpec *spec, OSType maccreator, OSType mactype, OSHandle *text);
-extern Boolean AppendHandleToFile(OSSpec *spec, OSHandle *text, OSType maccreator, OSType mactype);
-extern void InitWorking();
-extern void ShowWorking();
-extern void TermWorking();
-extern Boolean CheckForUserBreak();
-extern char *IO_FormatText(char *buffer, SInt32 size, char *newline, const char *format, ...);
-extern void CLPrintDispatch(SInt16 msgtype, const char *message, FILE *out, char *ptr, char *nptr);
-extern void CLPrintType(SInt16 msgtype, ...);
-extern void CLPrint(const char *format, ...);
-extern void CLPrintWarning(const char *format, ...);
-extern void CLPrintErr(const char *format, ...);
-extern SInt16 CLStyledMessageDispatch(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType);
-
-/********************************/
-/* command_line/CmdLine/Src/CLToolExec.c */
-extern void AppendArgumentList(int *argc, char ***argv, const char *str);
-// static int CopyArgumentList(int argc, const char **argv, int *Argc, const char ***Argv);
-// static int FreeArgumentList(const char **argv);
-// static int SetupLinkerCommandLine(SInt32 dropinflags, File *file, CWCommandLineArgs *args);
-extern int SetupTemporaries();
-extern int DeleteTemporaries();
-extern int ExecuteLinker(Plugin *plugin, SInt32 dropinflags, File *file, char *stdoutfile, char *stderrfile);
-
-/********************************/
-/* command_line/CmdLine/Src/Project/CLProj.c */
-typedef struct Project {
-    Target *targets;
-    OSSpec projectDirectory;
-} Project;
-#ifndef __cplusplus
-extern int Proj_Initialize(Project *this);
-extern int Proj_Terminate(Project *this);
-#endif
-
-/********************************/
-/* command_line/CmdLine/Src/CLLicenses.c */
-extern void License_Initialize();
-extern void License_Terminate();
-extern SInt32 License_Checkout();
-extern void License_Refresh();
-extern void License_Checkin();
-extern void License_AutoCheckin();
-
-/********************************/
-/* command_line/CmdLine/Src/CLPluginRequests.cpp */
-extern Boolean SendParserRequest(
-        Plugin *plugin,
-        Target *target,
-        CWCommandLineArgs *args,
-        OSType cpu,
-        OSType os,
-        int numPlugins,
-        CLPluginInfo *pluginInfo,
-        int numPanels,
-        char **panelNames,
-        CWCommandLineArgs *plugin_args,
-        CWCommandLineArgs *panel_args,
-        const char *build_date,
-        const char *build_time,
-        const ToolVersionInfo *build_tool
-        );
-extern Boolean SendCompilerRequest(Plugin *plugin, File *file, SInt16 stage);
-extern Boolean SendTargetInfoRequest(Target *targ, Plugin *linker, SInt32 dropinflags);
-extern Boolean SendLinkerRequest(Plugin *plugin, SInt32 dropinflags, CWTargetInfo *targetInfo);
-extern Boolean SendDisassemblerRequest(Plugin *linker, File *file);
-extern Boolean SendInitOrTermRequest(Plugin *plugin, Boolean reqIsInitialize);
-
-/********************************/
-/* command_line/CmdLine/Src/CLFileOps.c */
-// PRO8 ONLY ??? Boolean CanFlushObjectData(File *file);
-// PRO8 ONLY ??? void FlushObjectData(File *file);
-// PRO8 ONLY ??? Boolean RetrieveObjectData(File *file);
-// static int OutputTextData(File *file, SInt16 stage, OSType maccreator, OSType mactype);
-// static int fstrcat(const char *file, const char *add, SInt32 length);
-// static void extstrcat(char *file, const char *ext);
-extern int GetOutputFile(File *file, SInt16 stage);
-// static int SyntaxCheckFile(File *file);
-// static int PreprocessFile(File *file);
-// static int DependencyMapFile(File *file, Boolean compileifnecessary);
-// static int RecordBrowseInfo(File *file);
-// static int RecordObjectData(File *file);
-extern int StoreObjectFile(File *file);
-// static int CompileFile(File *file);
-// static int DisassembleWithLinker(File *file, Plugin *linker, SInt32 linkerDropinFlags);
-// static int DisassembleFile(File *file, Plugin *disasm);
-// static int CompileEntry(File *file, Boolean *compiled);
-// static void DumpFileAndPathInfo();
-extern int CompileFilesInProject();
-// static int PostLinkFilesInProject();
-extern int LinkProject();
-
-/********************************/
-/* command_line/CmdLine/Src/Project/CLPrefs.c */
-extern PrefPanel *PrefPanel_New(const char *name, void *initdata, SInt32 initdatasize);
-extern Handle PrefPanel_GetHandle(PrefPanel *panel);
-extern int PrefPanel_PutHandle(PrefPanel *panel, Handle handle);
-extern void Prefs_Initialize();
-extern void Prefs_Terminate();
-extern Boolean Prefs_AddPanel(PrefPanel *panel);
-extern PrefPanel *Prefs_FindPanel(const char *name);
-
-/********************************/
-/* command_line/CmdLine/Src/Project/CLTarg.c */
-extern Target *Target_New(const char *name, OSType cpu, OSType os, OSType lang);
-extern void Target_Free(Target *targ);
-extern void Targets_Term(Target *list);
-extern void Target_Add(Target **list, Target *targ);
-
-/********************************/
-/* command_line/CmdLine/Src/Project/CLAccessPaths.c */
-// 0,40=Path
-// 0,41=OSPathSpec
-// 0,43=Paths
-// 0,44=Path**
-// 0,45=Path*
-// 0,46=OSPathSpec*
-// 0,47=Paths*
-// 0,48=Path*
-extern Path *Path_Init(const OSPathSpec *dir, Path *path);
-extern Path *Path_New(const OSPathSpec *dir);
-extern void Path_Free(Path *path);
-extern Boolean Paths_Initialize(Paths *paths);
-extern Boolean Paths_Terminate(Paths *paths);
-//static Boolean Paths_GrowPaths(Paths *paths, UInt16 *index);
-extern Boolean Paths_AddPath(Paths *paths, Path *path);
-extern Boolean Paths_InsertPath(Paths *paths, UInt16 index, Path *path);
-extern Boolean Paths_RemovePath(Paths *paths, UInt16 index);
-extern Boolean Paths_DeletePath(Paths *paths, UInt16 index);
-extern Path *Paths_GetPath(Paths *paths, UInt16 pathnum);
-extern UInt16 Paths_Count(const Paths *paths);
-extern Boolean Paths_FindPath(const Paths *paths, const Path *path);
-extern Path *Paths_FindPathSpec(const Paths *paths, const OSPathSpec *dir);
-//static Boolean GatherRecurse(Paths *paths, Path *path);
-extern Boolean Paths_GatherRecurse(Paths *paths);
-extern int Paths_CountRecurse(Paths *paths);
-//static void CopyRecurseFSS(FSSpec **pFss, Paths *paths, UInt16 *pCount);
-extern void Paths_CopyRecurseFSS(FSSpec *fss, Paths *paths, UInt16 count);
-//static Boolean Frameworks_Initialize(Frameworks *fws);
-//static Boolean Frameworks_Grow(Frameworks *fws, UInt16 *index);
-//static Boolean Frameworks_Add(Frameworks *fws, Paths_FWInfo *info);
-//static Paths_FWInfo *Framework_Init(OSSpec *dir, const char *name, const char *version, Paths_FWInfo *info, Path *p, Boolean hidden);
-//static Paths_FWInfo *Framework_New(OSSpec *dir, const char *name, const char *version, Path *p, Boolean hidden);
-//static Boolean CheckForFileInFrameworkDir(char *out, const char *framework_path, OSPathSpec *osps, const char *fname);
-//static Boolean CheckForFileInFramework(char *out, int i, const char *fname);
-extern Boolean MakeFrameworkPath(char *out, const char *filename, OSPathSpec **globalpath);
-extern void Frameworks_AddPath(const OSPathSpec *oss);
-extern int Frameworks_AddFramework(const char *frameworkName, const char *version, Boolean flag);
-extern void Framework_GetEnvInfo();
-extern int Frameworks_GetCount();
-extern Paths_FWInfo *Frameworks_GetInfo(int which);
-
-/********************************/
 /* ??? */
 extern int AddFileTypeMappingList(void *a, void *b); // TODO sig
 extern void UseFileTypeMappings(void *a); // TODO sig
@@ -872,118 +22,6 @@ extern OSErr SetMacFileType(const FSSpec *fss, void *a); // TODO sig
 extern OSErr GetMacFileType(const FSSpec *fss, void *a); // TODO sig
 
 /********************************/
-/* command_line/CmdLine/Src/Project/CLFiles.c */
-#ifndef __cplusplus
-extern File *File_New();
-extern void File_Free(File *file);
-extern Boolean Files_Initialize(Files *this);
-extern Boolean Files_Terminate(Files *this);
-extern Boolean Files_AddFile(Files *this, File *file);
-extern Boolean Files_InsertFile(Files *this, File *file, SInt32 position);
-extern File *Files_GetFile(Files *this, SInt32 filenum);
-extern File *Files_FindFile(Files *this, OSSpec *spec);
-extern int Files_Count(Files *this);
-extern Boolean VFiles_Initialize(VFile **list);
-extern void VFiles_Terminate(VFile **list);
-extern VFile *VFile_New(const char *name, OSHandle *data);
-extern Boolean VFiles_Add(VFile **list, VFile *entry);
-extern VFile *VFiles_Find(VFile *list, const char *name);
-#endif
-
-/********************************/
-/* command_line/CmdLine/Src/Project/CLOverlays.c */
-#ifndef __cplusplus
-extern Boolean Overlays_Initialize(Overlays *this);
-extern Boolean Overlays_Terminate(Overlays *this);
-extern Boolean Overlays_AddOvlGroup(Overlays *this, OvlGroup *grp, SInt32 *grpnum);
-extern OvlGroup *Overlays_GetOvlGroup(Overlays *this, SInt32 grpnum);
-extern SInt32 Overlays_CountGroups(Overlays *this);
-extern Boolean Overlays_AddFileToOverlay(Overlays *this, SInt32 grpnum, SInt32 ovlnum, SInt32 filenum);
-extern Overlay *Overlays_GetOverlayInGroup(Overlays *this, SInt32 grpnum, SInt32 ovlnum);
-extern SInt32 Overlays_GetFileInOverlay(Overlays *this, SInt32 grpnum, SInt32 ovlnum, SInt32 filnum);
-extern OvlGroup *OvlGroup_New(const char *name, OvlAddr addr);
-extern void OvlGroup_Delete(OvlGroup *grp);
-extern Boolean OvlGroup_AddOverlay(OvlGroup *this, Overlay *oly, SInt32 *olynum);
-extern Overlay *OvlGroup_GetOverlay(OvlGroup *this, SInt32 olynum);
-extern SInt32 OvlGroup_CountOverlays(OvlGroup *this);
-extern Overlay *Overlay_New(const char *name);
-extern void Overlay_Delete(Overlay *oly);
-extern Boolean Overlay_AddFile(Overlay *oly, SInt32 filenum, SInt32 *filnum);
-extern SInt32 Overlay_GetFile(Overlay *oly, SInt32 filnul);
-extern SInt32 Overlay_CountFiles(Overlay *oly);
-#endif
-
-/********************************/
-/* command_line/CmdLine/Src/Project/CLSegs.c */
-extern Segment *Segment_New(const char *name, UInt16 attrs);
-extern void Segment_Free(Segment *seg);
-extern Boolean Segments_Initialize(Segments *segs);
-extern Boolean Segments_Terminate(Segments *segs);
-//static Boolean Segments_GrowSegments(Segments *segs, UInt16 *index);
-extern Boolean Segments_AddSegment(Segments *segs, Segment *seg, UInt16 *index);
-extern Boolean Segments_InsertSegment(Segments *segs, UInt16 index, Segment *seg);
-extern Boolean Segments_DeleteSegment(Segments *segs, UInt16 index);
-extern Segment *Segments_GetSegment(Segments *segs, UInt16 segnum);
-extern UInt16 Segments_Count(const Segments *segs);
-
-/********************************/
-/* CLDropinCallbacks_V10.cpp */
-// TODO
-
-/********************************/
-/* command_line/CmdLine/Src/Callbacks/CLCompilerLinkerDropin_V10.cpp */
-// TODO
-
-/********************************/
-/* command_line/CmdLine/Src/CLDependencies.c */
-extern Boolean Incls_Initialize(Incls *incls, Target *targ);
-extern void Incls_Terminate(Incls *incls);
-// static Boolean IsSysIncl(Incls *incls, SInt32 idx);
-// static void MakeInclFileSpec(Incls *incls, SInt32 idx, OSSpec *spec);
-// static Boolean QuickFindFileInIncls(Incls *incls, Boolean fullsearch, const char *filename, OSSpec *spec, SInt32 *index, InclFile **f);
-// static Boolean SameIncl(Incls *incls, SInt32 a, SInt32 b);
-// static Path *FindOrAddGlobalInclPath(Paths *paths, OSPathSpec *spec);
-// static Boolean _FindFileInPath(Path *path, const char *filename, Path **thepath, OSSpec *spec);
-// static Boolean FindFileInPaths(Paths *paths, const char *filename, Path **thepath, OSSpec *spec);
-// static void AddFileToIncls(Incls *incls, const char *infilename, Boolean syspath, Path *accesspath, Path *globalpath, SInt32 *index);
-extern Boolean Incls_FindFileInPaths(Incls *incls, const char *filename, Boolean fullsearch, OSSpec *spec, SInt32 *inclidx);
-extern Boolean Deps_Initialize(Deps *deps, Incls *incls);
-extern void Deps_Terminate(Deps *deps);
-extern int Deps_ChangeSpecialAccessPath(OSSpec *srcfss, Boolean initialize);
-extern Path *Deps_GetSpecialAccessPath();
-// static void SetSpecialAccessPathFromIncludeStackTOS();
-// static Boolean FindDepFile(Deps *deps, SInt32 incl);
-// static void AddDepFile(Deps *deps, SInt32 incl);
-extern void Deps_AddDependency(Deps *deps, SInt32 incl, OSSpec *spec, SInt16 dependencyType);
-// static char *EscapeName(Boolean spaces, char *escbuf, const char *path);
-extern void Deps_ListDependencies(Incls *incls, File *file, Handle h);
-
-/********************************/
-/* command_line/CmdLine/Src/CLWriteObjectFile.c */
-extern Boolean WriteObjectFile(File *file, OSType maccreator, OSType mactype);
-extern Boolean WriteBrowseData(File *file, OSType maccreator, OSType mactype);
-
-/********************************/
-/* command_line/CmdLine/Src/CLBrowser.c */
-// GetBrowseTableInfoAndLock
-extern int Browser_Initialize(OSHandle *browsetableptr);
-//static int Destroy(OSHandle *browsetable);
-extern int Browser_Terminate(OSHandle *browsetableptr);
-extern int Browser_SearchFile(OSHandle *browsetable, const char *fullpath, SInt16 *ID);
-extern int Browser_SearchAndAddFile(OSHandle *browsetable, const char *fullpath, SInt16 *ID);
-//static SInt32 CalcDiskSpaceRequirements(...); // needs table type
-//static int ConvertMemToDisk(...); // needs table type
-extern int Browser_PackBrowseFile(OSHandle *browsedata, OSHandle *browsetable, OSHandle *browsefileptr);
-
-/********************************/
-/* command_line/CmdLine/Src/CLIncludeFileCache.c */
-// TODO
-
-/********************************/
-/* ?? Error */
-extern char *GetSysErrText(SInt16 code, char *buffer);
-
-/********************************/
 /* Might be cc-mach-ppc-mw.c? */
 extern void GetStaticTarget(OSType *cpu, OSType *os);
 extern void GetStaticPluginType(OSType *language, OSType *plugintype);
@@ -997,21 +35,6 @@ extern int RegisterStaticParserToolInfo();
 
 /********************************/
 /* Might be cc-mach-ppc.c? */
-extern CW_PASCAL SInt16 CWPlugin_GetDropInFlags(const DropInFlags **flags, SInt32 *flagsSize);
-extern CW_PASCAL SInt16 CWPlugin_GetTargetList(const CWTargetList **targetList);
-extern CW_PASCAL SInt16 CWPlugin_GetDropInName(const char **dropinName);
-extern CW_PASCAL SInt16 CWPlugin_GetDisplayName(const char **displayName);
-extern CW_PASCAL SInt16 CWPlugin_GetDefaultMappingList(const CWExtMapList **defaultMappingList);
-extern CW_PASCAL SInt16 CWPlugin_GetPanelList(const CWPanelList **panelList);
-//_CmdLine_GetObjectFlags
-//_CWPlugin_GetVersionInfo
-//_CWPlugin_GetFileTypeMappings
-//_Linker_GetDropInFlags
-//_Linker_GetDropInName
-//_Linker_GetDisplayName
-//_Linker_GetPanelList
-//_Linker_GetTargetList
-//_Linker_GetDefaultMappingList
 extern int RegisterStaticCompilerPlugin();
 extern int RegisterCompilerResources();
 
@@ -1045,6 +68,7 @@ extern int DisplayWarningOptions();
 
 /********************************/
 /* CCompiler.c */
+extern CWPLUGIN_ENTRY(MWC_main)(CWPluginContext context);
 
 // LOTS OF STUFF
 
@@ -1054,242 +78,6 @@ extern int RegisterStaticParserPlugins();
 extern int RegisterStaticParserResources();
 
 /********************************/
-/* ParserFace.c */
-extern Handle Parser_FindPrefPanel(const char *name);
-extern SInt32 Parser_StorePanels(struct CWPluginPrivateContext *context);
-extern SInt16 CWParser_GetDropInFlags(const DropInFlags **flags, SInt32 *flagsSize);
-extern SInt16 CWParser_GetDropInName(const char **dropinName);
-extern SInt16 CWParser_GetDisplayName(const char **displayName);
-extern SInt16 CWParser_GetPanelList(const CWPanelList **panelList);
-extern SInt16 CWParser_GetTargetList(const CWTargetList **targetList);
-extern SInt16 CWParser_GetVersionInfo(const VersionInfo **versioninfo);
-extern SInt16 Parser_SupportsPlugin(struct CLPluginInfo *pluginfo, OSType cpu, OSType os, Boolean *isSupported);
-extern SInt16 Parser_SupportsPanels(int numPanels, const char **panelNames, Boolean *isSupported);
-extern SInt16 parser_main(struct CWPluginPrivateContext *context);
-
-extern const char *failedCallback;
-extern jmp_buf exit_plugin;
-extern struct ParseOptsType parseopts;
-
-/********************************/
-/* ParserHelpers.c */
-extern SInt16 lastStage;
-
-extern int FindFileInPath(const char *filename, OSSpec *fss);
-extern char *GetEnvVar(const char *name, Boolean warn, const char **match);
-extern int Opt_AddAccessPath(const char *opt, void *var, const char *arg);
-extern int Opt_AddFrameworkPath(const char *opt, void *var, const char *arg);
-extern int Opt_AddFramework(const char *opt, void *var, const char *arg);
-extern void ListParseMessage(void (*errprint)(const char *, va_list), const char *envvar, SInt16 id, ...);
-extern int AddAccessPathList(const char *list, char sep1, char sep2, int source, char *text, Boolean system, SInt32 position, Boolean recursive);
-extern int Opt_FindAndAddFile(const char *opt, void *var, const char *arg);
-extern int Opt_FindAndAddFileRef(const char *opt, void *var, const char *arg);
-extern int Opt_AddUnixLibraryFile(const char *opt, void *var, const char *arg);
-extern int AddFileList(const char *list, char sep1, char sep2, int source, char *text, SInt32 position);
-extern int IsFileInOutputDirectory(const OSSpec *file);
-extern void GetCFileNameInOutputDirectory(const char *input, char *name, int maxlen);
-extern void GetPFileNameInOutputDirectory(const char *input, unsigned char *name, int len);
-extern void AddStringLenToHandle(Handle *h, const char *str, int len);
-extern void AddStringToHandle(Handle *h, const char *str);
-extern int Opt_PrintVersion(const char *opt, void *var, const char *arg);
-extern void GetFirstSourceFilenameBase(char *buffer, char *defaul);
-extern int Opt_SavePrefs(const char *opt, void *var, const char *arg);
-extern int ParseNumber(const char *arg, Boolean emit_error, SInt32 *ret, const char **endptr);
-extern int Opt_MaybeMoveAccessPaths(const char *opt, void *var, const char *arg);
-
-/********************************/
-/* ToolHelpers.c */
-enum {
-    OutputOrdering0 = 0,
-    OutputOrdering1 = 1,
-    OutputOrdering2 = 2
-};
-extern SInt16 outputOrdering;
-extern Boolean setOutputDirectory;
-
-extern int Opt_HandleOutputName(const char *opt, void *, const char *filename);
-extern int ValidateToolState(Boolean mustHaveFiles);
-extern void ToolReportMessage(SInt16 errid, SInt16 type, va_list va);
-extern void ToolReportWarning(SInt16 id, ...);
-extern void ToolReportError(SInt16 id, ...);
-extern void ToolReportOSError(SInt16 id, int err, ...);
-extern void ToolReportInfo(SInt16 id, ...);
-extern int Opt_DoNotLink(const char *opt, void *var, const char *arg);
-extern int Opt_IncreaseVerbosity(const char *opt, void *var, const char *arg);
-extern int Opt_SetStage(const char *opt, void *str, const char *arg, int flags);
-extern int Opt_RedirectStream(const char *opt, void *file, const char *filename);
-
-/********************************/
-/* ParserHelpers-cc.c */
-extern Handle definesHandle;
-
-enum {
-    PRAGMA_FLAGS_0,
-    PRAGMA_FLAGS_1
-};
-enum {
-    PR_UNSET = 0, // this is the only one we know the name of (from asserts)
-    PR_ON = 1,
-    PR_OFF = 2,
-    PR_AUTO = 3,
-    PR_RESET = 4
-};
-
-typedef struct {
-    void *value;
-    const char *pragma;
-    int flags;
-} Pragma; // assumed name
-extern int Opt_AddStringToDefines(const char *opt, void *str, const char *param);
-extern int Opt_DefineSymbol(const char *var, const char *value);
-extern int Opt_UndefineSymbol(const char *opt, void *, const char *arg);
-extern int Opt_AddPrefixFile(const char *opt, void *handle, const char *filename);
-extern int Opt_PragmaTrueFalse(const char *, void *flag, const char *, int flags);
-extern int Opt_PragmaFalseTrue(const char *, void *flag, const char *, int flags);
-extern int Opt_PragmaOnOff(const char *, void *flag, const char *arg);
-extern int Opt_PragmaOffOn(const char *, void *flag, const char *arg);
-extern int SetupPragmas(const Pragma *pragmas);
-
-/********************************/
-/* ToolHelpers-cc.c */
-extern int Opt_DummyLinkerRoutine(const char *opt);
-extern int Opt_DummyLinkerSettingRoutine(const char *var, const char *val);
-extern void FinishCompilerTool();
-
-/********************************/
-/* IO.c */
-extern void ShowTextHandle(const char *description, Handle text);
-extern void ShowVersion(Boolean decorate);
-
-/********************************/
-/* Projects.c */
-extern int GetFileCount();
-extern void SetFileOutputName(SInt32 position, SInt16 which, char *outfilename);
-extern int AddFileToProject(OSSpec *oss, SInt16 which, char *outfilename, Boolean exists, SInt32 position);
-extern Boolean GetFileInfo(SInt32 position, OSSpec *spec, char *plugin);
-extern int AddAccessPath(OSPathSpec *oss, SInt16 type, SInt32 position, Boolean recursive);
-extern int MoveSystemPathsIntoUserList();
-extern void AddVirtualFile(const char *filename, Handle *text);
-extern void GetOutputFileDirectory(OSPathSpec *dir);
-extern void SetOutputFileDirectory(OSPathSpec *dir);
-extern void AddOverlayGroup(const char *name, CWAddr64 *addr, SInt32 *groupnum, SInt32 *overlaynum);
-extern void AddOverlay(SInt32 groupnum, const char *name, SInt32 *overlaynum);
-extern void AddSegment(const char *name, SInt16 attrs, SInt32 *segmentnum);
-extern void ChangeSegment(SInt32 segmentnum, const char *name, SInt16 attrs);
-extern int GetSegment(SInt32 segmentnum, char *name, SInt16 *attrs);
-
-/********************************/
-/* Targets.c */
-extern ParserTool *pTool;
-
-extern int SetParserToolInfo(ParserTool *tool);
-extern Boolean ParserToolMatchesPlugin(OSType type, OSType lang, OSType cpu, OSType os);
-extern Boolean ParserToolHandlesPanels(int numPanels, const char **panelNames);
-extern Boolean SetupParserToolOptions();
-
-/********************************/
-/* ParserErrors.c */
-extern void CLPReportError_V(const char *format, va_list ap);
-extern void CLPReportWarning_V(const char *format, va_list ap);
-extern void CLPReport_V(const char *format, va_list ap);
-extern void CLPStatus_V(const char *format, va_list ap);
-extern void CLPAlert_V(const char *format, va_list ap);
-extern void CLPOSAlert_V(const char *format, SInt32 err, va_list ap);
-extern char *CLPGetErrorString(SInt16 errid, char *buffer);
-extern void CLPReportError(SInt16 errid, ...);
-extern void CLPReportWarning(SInt16 errid, ...);
-extern void CLPReport(SInt16 errid, ...);
-extern void CLPAlert(SInt16 errid, ...);
-extern void CLPOSAlert(SInt16 errid, SInt16 err, ...);
-extern void CLPProgress(SInt16 errid, ...);
-extern void CLPStatus(SInt16 errid, ...);
-extern void CLPFatalError(const char *format, ...);
-
-extern char curopt[1024];
-
-/********************************/
-/* Utils.c */
-// something is weird with these parameters
-// they're supposed to be just "char"...
-#ifdef UNSIGNED_CHAR_FOR_MY_UTILS
-extern int my_tolower(unsigned char c);
-extern int my_isdigit(unsigned char c);
-extern int my_isalpha(unsigned char c);
-extern int my_isalnum(unsigned char c);
-extern int my_isxdigit(unsigned char c);
-#else
-extern int my_tolower(char c);
-extern int my_isdigit(char c);
-extern int my_isalpha(char c);
-extern int my_isalnum(char c);
-extern int my_isxdigit(char c);
-#endif
-extern char *Utils_SpellList(char *list, char *buffer, char opts);
-extern int Utils_CompareOptionString(const char *a, const char *b, int cased, int sticky);
-
-/********************************/
-/* */
-
-/********************************/
-/* */
-
-/********************************/
-/* ?? COS */
-// static COS_pstrcpy
-// static COS_pstrcat
-// static COS_pstrcharcat
-// static COS_pstrcmp
-extern Handle COS_NewHandle(SInt32 byteCount);
-extern Handle COS_NewOSHandle(SInt32 logicalSize);
-extern void COS_FreeHandle(Handle handle);
-extern Boolean COS_ResizeHandle(Handle handle, SInt32 newSize);
-extern SInt32 COS_GetHandleSize(Handle handle);
-extern void COS_LockHandle(Handle handle);
-extern void COS_LockHandleHi(Handle handle);
-extern void COS_UnlockHandle(Handle handle);
-extern int COS_GetHandleState(Handle handle);
-extern void COS_SetHandleState(Handle handle, int state);
-extern Boolean COS_IsLockedState(int state);
-extern char *COS_NewPtr(SInt32 byteCount);
-extern char *COS_NewPtrClear(SInt32 byteCount);
-extern void COS_FreePtr(char *ptr);
-extern void COS_AppendPtrToHandle(char *ptr1, Handle hand2, SInt32 size);
-extern OSErr COS_GetMemErr();
-extern SInt32 COS_GetTicks();
-extern SInt32 COS_GetTime();
-extern void COS_GetString(char *buffer, SInt16 strListID, SInt16 index);
-extern void COS_GetPString(unsigned char *buffer, SInt16 strListID, SInt16 index);
-extern Boolean COS_IsMultiByte(char *buffer, char *str);
-extern SInt16 COS_FileNew(const FSSpec *spec, SInt16 *refNum, OSType creator, OSType fileType);
-extern SInt16 COS_FileOpen(const FSSpec *spec, SInt16 *refNum);
-extern SInt16 COS_FileGetType(const FSSpec *spec, OSType *fileType);
-extern SInt16 COS_FileGetSize(SInt16 refNum, SInt32 *logEOF);
-extern SInt16 COS_FileRead(SInt16 refNum, void *buffPtr, SInt32 count);
-extern SInt16 COS_FileWrite(SInt16 refNum, const void *buffPtr, SInt32 count);
-extern SInt16 COS_FileGetPos(SInt16 refNum, SInt32 *filePos);
-extern SInt16 COS_FileSetPos(SInt16 refNum, SInt32 filePos);
-extern SInt16 COS_FileClose(SInt16 refNum);
-extern void COS_FileSetFSSpec(FSSpec *spec, unsigned char *path);
-extern SInt16 COS_FileMakeFSSpec(SInt16 vRefNum, SInt32 dirID, unsigned char *fileName, FSSpec *spec);
-extern SInt16 COS_FileMakeFSSpecWithPath(const FSSpec *inputSpec, unsigned char *fileName, FSSpec *spec);
-extern SInt16 COS_FileGetFileInfo(const FSSpec *spec, OSType *creator, OSType *fileType);
-extern void COS_FileGetFSSpecInfo(const FSSpec *spec, SInt16 *vRefNum, SInt32 *dirID, unsigned char *fileName);
-//static void COS_MakePath(SInt16 vRefNum, SInt32 dirID, char *path);
-extern void COS_FileGetPathName(char *buffer, const FSSpec *spec, SInt32 *mdDat);
-extern Boolean COS_EqualFileSpec(const FSSpec *a, const FSSpec *b);
-
-#include "option_system.h"
-
-
-// TODO sort me
-extern Project *gProj;
-extern PCmdLine optsCmdLine;
-extern PCmdLineEnvir optsEnvir;
-extern PCmdLineCompiler optsCompiler;
-extern PCmdLineLinker optsLinker;
-extern CLState clState;
-
-/********************************/
 /* CmdLineBuildDate.c */
 extern char CMDLINE_BUILD_DATE[];
 extern char CMDLINE_BUILD_TIME[];
@@ -1300,17 +88,6 @@ extern char CMDLINE_BUILD_TIME[];
 extern char cmdline_build_date[32];
 extern char cmdline_build_time[32];
 
-extern StringPtr pstrcpy(StringPtr dst, ConstStringPtr src);
-extern int (*PrefPanelsChangedCallback)(const char *);
-extern Boolean systemHandles;
-extern char *MAINOPTCHAR;
-extern char *SEPOPTSTR;
-extern char compat;
-extern anon0_50 linkargs;
-extern anon0_50 prelinkargs;
-extern anon0_50 postlinkargs;
-extern PCmdLine pCmdLine;
-extern PCmdLineCompiler pCmdLineCompiler;
 
 #ifdef __cplusplus
 }
diff --git a/includes/option_system.h b/includes/option_system.h
index 521213b..aa519e2 100644
--- a/includes/option_system.h
+++ b/includes/option_system.h
@@ -4,7 +4,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#ifdef    __MWERKS__
+#ifdef __MWERKS__
 #pragma options align=packed
 #endif
 enum {
@@ -171,7 +171,7 @@ enum {
 };
 enum {
     OTF_GLOBAL = 1,
-    OTF2 = 2,
+    OTF_STICKY = 2,
     OTF_CASED = 4,
     OTF_OBSOLETE = 8,
     OTF_SUBSTITUTED = 0x10,
@@ -182,16 +182,14 @@ enum {
     OTF_TOOL_MASK = OTF_TOOL_LINKER | OTF_TOOL_DISASSEMBLER | OTF_TOOL_COMPILER,
     OTF200 = 0x200,
     OTF400 = 0x400,
-    OTF700 = 0x700,
     OTF_IGNORED = 0x800,
-    OTFC00 = 0xC00,
     OTF_SECRET = 0x1000,
-    OTF2000 = 0x2000,
+    OTF_HIDE_DEFAULT = 0x2000,
     OTF_COMPATIBILITY = 0x4000,
-    OTF8000 = 0x8000,
-    OTF10000 = 0x10000,
-    OTF20000 = 0x20000,
-    OTF40000 = 0x40000,
+    OTF_HAS_SUB_OPTIONS = 0x8000,
+    OTF_SUB_OPTIONS_OPTIONAL = 0x10000,
+    OTF_ONLY_ONCE = 0x20000,
+    OTF_HAS_CONFLICTS = 0x40000,
     OTF_WARNING = 0x80000,
     OTF_SLFLAGS_8 = 0x100000,
     OTF_SLFLAGS_10 = 0x200000,
@@ -205,8 +203,8 @@ enum {
     OTF8000000 = 0x8000000,
     OTF10000000 = 0x10000000,
     OTF20000000 = 0x20000000,
-    OTF40000000 = 0x40000000,
-    OTF80000000 = 0x80000000
+    OTF_INTERNAL_SEEN_CONFLICTED = 0x40000000,
+    OTF_INTERNAL_ALREADY_SEEN = 0x80000000
 };
 
 enum {
@@ -260,7 +258,8 @@ enum {
 };
 enum {
     LISTFLAGS_NONE = 0,
-    LISTFLAGS_2 = 2,
+    LISTFLAGS_EXCLUSIVE = 1,
+    LISTFLAGS_ALLOW_UNKNOWNS = 2,
     LISTFLAGS_4 = 4,
     LISTFLAGS_COMPILER = 0x100,
     LISTFLAGS_LINKER = 0x200,
@@ -288,7 +287,7 @@ enum {
     PFLAGS_40 = 0x40,
     PFLAGS_80 = 0x80
 };
-#ifdef    __MWERKS__
+#ifdef __MWERKS__
 #pragma options align=reset
 #endif
 
@@ -299,12 +298,12 @@ typedef struct {
     char *text;
 } ArgToken;
 enum {
-    ATK_0,
-    ATK_1,
-    ATK_2,
-    ATK_3,
-    ATK_4,
-    ATK_5
+    ATK_END,
+    ATK_ARG_END,
+    ATK_ARG,
+    ATK_OPTION,
+    ATK_EQUALS,
+    ATK_COMMA
 };
 typedef struct {
     int argc;
@@ -312,6 +311,20 @@ typedef struct {
     char **argv;
 } anon0_50;
 
+extern char compat;
+extern char *MAINOPTCHAR;
+extern char *FIRSTARGCHAR;
+extern char *SEPOPTSTR;
+extern char SEPOPTCHAR;
+extern char SEP1;
+extern char SEP2;
+extern char SEP3;
+extern char RESPFILECHAR;
+extern char *RESPFILESTR;
+extern anon0_50 linkargs;
+extern anon0_50 prelinkargs;
+extern anon0_50 postlinkargs;
+
 extern void Arg_Init(int theargc, char **theargv);
 extern void Arg_Terminate();
 extern void Arg_Reset();
@@ -348,10 +361,9 @@ typedef struct {
     } e;
     SInt16 flags;
 } Opt48;
-//static void Option_PushList(OptionList *lst);
-//static void Option_PushOpt(Option *opt, const char *optname);
-//static void Option_PopOpt(const char *optname);
-//static void Option_PopList();
+
+extern char curopt[1024];
+
 extern void Args_InitStack();
 extern int Args_StackSize();
 extern void Args_Push(SInt16 flags, void *first, void *second);
@@ -361,23 +373,14 @@ extern void Args_AddToToolArgs(anon0_50 *ta);
 extern void Options_Init();
 extern OptionList *Options_GetOptions();
 extern void Options_SortOptions();
-//static void Options_AddOption(Option *opt);
 extern int Options_AddList(OptionList *optlst);
 extern int Options_AddLists(OptionList **optlst);
-//static void Options_Reset(OptionList *optlst);
-//static void Option_SpellList(char *buffer, OptionList *conflicts, int flags);
 extern int Option_ForTool(Option *opt, int which);
 extern int Option_ThisTool();
 extern int Option_ForThisTool(Option *opt);
 extern int Option_AlsoPassedToTool(Option *opt, int which);
 extern int Option_AlsoPassedFromThisTool(Option *opt);
-//static Boolean Option_ContinuesThisLevel(int level, ArgToken *tok);
-//static Boolean Option_IsEndingThisLevel(int level, ArgToken *tok);
-//static Boolean Option_IsEndingLevel(int level, ArgToken *tok);
 extern int Option_Parse(Option *opt, int oflags);
-//static int Option_MatchString(char *list, char *str, int flags, int *result);
-//static Option *Option_Lookup(OptionList *search, void *unk, int *flags);
-//static int Options_DoParse(OptionList *search, int flags);
 extern int Options_Parse(OptionList *options, int flags);
 extern int Option_ParseDefaultOption(OptionList *options);
 extern void Option_ParamError(SInt16 id, va_list ap);
@@ -392,6 +395,8 @@ extern int Options_DisplayHelp();
 
 /********************************/
 /* Parameter.c */
+extern char curparam[4096];
+
 extern void Param_DescHelp(PARAM_T *param, const char **desc, const char **help, const char **defaul);
 extern int Param_Compare(PARAM_T *param);
 extern int Params_Parse(PARAM_T *param, int flags);
@@ -400,8 +405,8 @@ extern void Param_Warning(SInt16 id, ...);
 
 /********************************/
 /* Help.c */
-extern int Help_Option(struct OptionList *lst, struct Option *opt, int subprint, const char *keyword);
-extern void Help_Options(struct OptionList *lst, int subprint, const char *keyword);
+extern int Help_Option(OptionList *lst, Option *opt, int subprint, const char *keyword);
+extern void Help_Options(OptionList *lst, int subprint, const char *keyword);
 extern void Help_Usage();
 extern void Help_Null();
 extern void Help_Init();
diff --git a/includes/oslib.h b/includes/oslib.h
index 22e8ddc..dfa3827 100644
--- a/includes/oslib.h
+++ b/includes/oslib.h
@@ -7,6 +7,8 @@
  * OS abstraction layer
  */
 
+#define OPTION_ASSERT(cond) do { if (!!(cond) == 0) { printf("%s:%u: failed assertion\n", __FILE__, __LINE__); abort(); } } while(0)
+
 typedef struct uOSTypePair {
     int perm;
 } uOSTypePair; // unknown name
@@ -73,13 +75,17 @@ typedef struct OSFileTypeMappingList {
 } OSFileTypeMappingList;
 
 typedef struct OSFileTypeMappings {
-    OSFileTypeMappingList *mappingList;
+    const OSFileTypeMappingList *mappingList;
     struct OSFileTypeMappings *next;
 } OSFileTypeMappings;
 #ifdef	__MWERKS__
 #pragma options align=reset
 #endif
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /********************************/
 /* Generic */
 extern int WildCardMatch(char *wild, char *name);
@@ -128,7 +134,7 @@ extern int OS_IsLegalPath(const char *path);
 extern int OS_IsFullPath(const char *path);
 extern char *OS_GetDirPtr(char *path);
 extern int OS_EqualPath(const char *a, const char *b);
-extern int OS_CanonPath(char *src, char *dst);
+extern int OS_CanonPath(const char *src, char *dst);
 extern int OS_MakeSpec(const char *path, OSSpec *spec, Boolean *isfile);
 extern int OS_MakeFileSpec(const char *path, OSSpec *spec);
 extern int OS_MakePathSpec(const char *vol, const char *dir, OSPathSpec *spec);
@@ -168,7 +174,7 @@ extern int OS_OpenLibrary(const char *a, void **lib);
 extern int OS_GetLibrarySymbol(void *a, void *b, void **sym);
 extern int OS_CloseLibrary(void *a);
 extern int OS_LoadMacResourceFork(const OSSpec *spec, void **file_data, SInt32 *file_len);
-extern int OS_IsMultiByte(const char *str, int offset);
+extern Boolean OS_IsMultiByte(const char *str, int offset);
 
 /********************************/
 /* FileHandles */
@@ -180,7 +186,7 @@ extern void OS_GetFileHandleSpec(const OSFileHandle *hand, OSSpec *spec);
 
 /********************************/
 /* MacFileTypes */
-extern void OS_AddFileTypeMappingList(OSFileTypeMappings **list, OSFileTypeMappingList *entry);
+extern void OS_AddFileTypeMappingList(OSFileTypeMappings **list, const OSFileTypeMappingList *entry);
 extern void OS_UseFileTypeMappings(OSFileTypeMappings *list);
 extern void OS_MacType_To_OSType(OSType mactype, uOSTypePair *type);
 extern int OS_SetMacFileType(const OSSpec *spec, OSType mactype);
@@ -226,3 +232,7 @@ extern void p2cstrcpy(char *dst, ConstStringPtr src);
 extern char *mvprintf(char *mybuf, unsigned int len, const char *format, va_list va);
 extern char *mprintf(char *mybuf, unsigned int len, const char *format, ...);
 extern int HPrintF(Handle text, const char *format, ...);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/includes/parser.h b/includes/parser.h
new file mode 100644
index 0000000..ae28fee
--- /dev/null
+++ b/includes/parser.h
@@ -0,0 +1,370 @@
+#pragma once
+
+#include "cw_common.h"
+#include "pref_structs.h"
+#include "option_system.h"
+
+enum {
+    PRAGMA_FLAGS_0,
+    PRAGMA_FLAGS_1
+};
+enum {
+    PR_UNSET = 0, // this is the only one we know the name of (from asserts)
+    PR_ON = 1,
+    PR_OFF = 2,
+    PR_AUTO = 3,
+    PR_RESET = 4
+};
+
+typedef struct {
+    void *value;
+    const char *pragma;
+    int flags;
+} Pragma; // assumed name
+
+enum {
+    CLPStr0 = 0,
+    CLPStr1 = 1,
+    CLPStr2 = 2,
+    CLPStr3 = 3,
+    CLPStr4 = 4,
+    CLPStr5 = 5,
+    CLPStr6 = 6,
+    CLPStr7 = 7,
+    CLPStr8 = 8,
+    CLPStr9 = 9,
+    CLPStr10 = 10,
+    CLPStr11 = 11,
+    CLPStr12 = 12,
+    CLPStr13 = 13,
+    CLPStr14 = 14,
+    CLPStr15 = 15,
+    CLPStr16 = 16,
+    CLPStr17 = 17,
+    CLPStr18 = 18,
+    CLPStr19_UnknownOptionX = 19,
+    CLPStr20_UnknownOptionX_ExpectedOneOfX = 20,
+    CLPStr21_OptionObsolete = 21,
+    CLPStr22_OptionObsoleteWithHelp = 22,
+    CLPStr23_OptionXSubstitutedWithX = 23,
+    CLPStr24_OptionDeprecated = 24,
+    CLPStr25_OptionDeprecatedWithHelp = 25,
+    CLPStr26_OptionIgnored = 26,
+    CLPStr27_OptionIgnoredWithText = 27,
+    CLPStr28_WarningText = 28,
+    CLPStr29_OptionHasNoEffect = 29,
+    CLPStr30_OptionShouldNotBeSpecifiedMultipleTimes = 30,
+    CLPStr31_OptionOverridesEffect = 31,
+    CLPStr32_OptionOverridesEffectWithHelp = 32,
+    CLPStr33_NoDefaultHandlerSetUpForX_Ignoring = 33,
+    CLPStr34_ArgumentsExpected = 34,
+    CLPStr35_TokenXNotExpected = 35,
+    CLPStr36_UnexpectedAdditionalArgumentX = 36,
+    CLPStr37 = 37,
+    CLPStr38_NoHelpAvailableForOptionX = 38,
+    CLPStr39 = 39,
+    CLPStr40 = 40,
+    CLPStr41 = 41,
+    CLPStr42 = 42,
+    CLPStr43 = 43,
+    CLPStr44 = 44,
+    CLPStr45 = 45,
+    CLPStr46 = 46,
+    CLPStr47 = 47,
+    CLPStr48 = 48,
+    CLPStr49 = 49,
+    CLPStr50 = 50,
+    CLPStr51 = 51,
+    CLPStr52 = 52,
+    CLPStr53 = 53,
+    CLPStr54 = 54,
+    CLPStr55 = 55,
+    CLPStr56 = 56,
+    CLPStr57 = 57,
+    CLPStr58 = 58,
+    CLPStr59 = 59,
+    CLPStr60 = 60,
+    CLPStr61 = 61,
+    CLPStr62 = 62,
+    CLPStr63 = 63,
+    CLPStr64 = 64,
+    CLPStr65 = 65,
+    CLPStr66 = 66,
+    CLPStr67 = 67,
+    CLPStr68 = 68,
+    CLPStr69 = 69,
+    CLPStr70 = 70,
+    CLPStr71 = 71,
+    CLPStr72 = 72,
+    CLPStr73 = 73,
+    CLPStr74 = 74,
+    CLPStr75 = 75,
+    CLPStr76 = 76,
+    CLPStr77 = 77,
+    CLPStr78 = 78
+};
+
+// State
+
+typedef struct {
+    char *name;
+    void *ptr;
+    SInt32 size;
+} PrefDataPanel; // assumed name
+
+typedef struct {
+    OSType TYPE;
+    OSType LANG;
+    OSType CPU;
+    OSType OS;
+    int numPrefPanels;
+    char **prefPanels;
+    char *toolInfo;
+    char *copyright;
+    int numOptionLists;
+    OptionList **optionLists;
+    int numPrefDataPanels;
+    PrefDataPanel *prefDataPanels;
+    int (*PreParse)();
+    int (*MidParse)();
+    int (*PostParse)();
+} ParserTool; // assumed name
+
+typedef struct {
+    struct CWPluginPrivateContext *context;
+    char helpKey[64];
+    SInt32 helpFlags;
+    UInt16 ioCols;
+    UInt16 ioRows;
+    CWCommandLineArgs *args;
+    const ToolVersionInfo *toolVersion;
+    int numPlugins;
+    const CLPluginInfo *plugins;
+    int numPanels;
+    const char **panelNames;
+    OSType cpu;
+    OSType os;
+    char lastoutputname[256];
+    SInt32 currentSegment;
+    SInt32 currentOverlayGroup;
+    SInt32 currentOverlay;
+    int possibleFiles;
+    int userSpecifiedFiles;
+    int unusedFiles;
+    Boolean hadAnyOutput;
+    Boolean hadErrors;
+    Boolean showHelp;
+    Boolean underIDE;
+    Boolean alwaysUsePaths;
+    Boolean noOptions;
+    Boolean printedVersion;
+    Boolean passingArgs;
+    Boolean disToFile;
+    Boolean ppToFile;
+    Boolean initBefore;
+    Boolean weakImport;
+    Boolean mergeIntoOutput;
+    Boolean success;
+    Boolean ignoreUnknown;
+    UInt8 unused[2];
+} ParseOptsType; // assumed name
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/********************************/
+/* IO.c */
+extern void ShowTextHandle(const char *description, Handle text);
+extern void ShowVersion(Boolean decorate);
+
+/********************************/
+/* OptimizerHelpers.c */
+extern Pragma irPragmas[];
+
+extern int SetPragmaOptimizationsToUnspecified(const char *opt, void *, const char *, int);
+extern int SetOptFlags(const char *opt, void *str, const char *, int flags);
+extern int DisplayOptimizationOptions();
+
+/********************************/
+/* ParserErrors.c */
+extern void CLPReportError_V(const char *format, va_list ap);
+extern void CLPReportWarning_V(const char *format, va_list ap);
+extern void CLPReport_V(const char *format, va_list ap);
+extern void CLPStatus_V(const char *format, va_list ap);
+extern void CLPAlert_V(const char *format, va_list ap);
+extern void CLPOSAlert_V(const char *format, SInt32 err, va_list ap);
+extern char *CLPGetErrorString(SInt16 errid, char *buffer);
+extern void CLPReportError(SInt16 errid, ...);
+extern void CLPReportWarning(SInt16 errid, ...);
+extern void CLPReport(SInt16 errid, ...);
+extern void CLPAlert(SInt16 errid, ...);
+extern void CLPOSAlert(SInt16 errid, SInt16 err, ...);
+extern void CLPProgress(SInt16 errid, ...);
+extern void CLPStatus(SInt16 errid, ...);
+extern void CLPFatalError(const char *format, ...);
+
+/********************************/
+/* ParserFace.c */
+extern const char *failedCallback;
+extern jmp_buf exit_plugin;
+extern ParseOptsType parseopts;
+
+extern Handle Parser_FindPrefPanel(const char *name);
+extern SInt32 Parser_StorePanels(struct CWPluginPrivateContext *context);
+extern CWPLUGIN_ENTRY (CWParser_GetDropInFlags)(const DropInFlags **flags, SInt32 *flagsSize);
+extern CWPLUGIN_ENTRY (CWParser_GetDropInName)(const char **dropinName);
+extern CWPLUGIN_ENTRY (CWParser_GetDisplayName)(const char **displayName);
+extern CWPLUGIN_ENTRY (CWParser_GetPanelList)(const CWPanelList **panelList);
+extern CWPLUGIN_ENTRY (CWParser_GetTargetList)(const CWTargetList **targetList);
+extern CWPLUGIN_ENTRY (CWParser_GetVersionInfo)(const VersionInfo **versioninfo);
+extern CWPLUGIN_ENTRY (Parser_SupportsPlugin)(const struct CLPluginInfo *pluginfo, OSType cpu, OSType os, Boolean *isSupported);
+extern CWPLUGIN_ENTRY (Parser_SupportsPanels)(int numPanels, const char **panelNames, Boolean *isSupported);
+extern CWPLUGIN_ENTRY (parser_main)(struct CWPluginPrivateContext *context);
+
+/********************************/
+/* ParserGlue-mach-ppc-c.c */
+extern PCmdLine pCmdLine;
+extern PCmdLineCompiler pCmdLineCompiler;
+extern PCmdLineLinker pCmdLineLinker;
+extern PFrontEndC pFrontEndC;
+extern PWarningC pWarningC;
+extern PGlobalOptimizer pGlobalOptimizer;
+extern PBackEnd pBackEnd;
+extern PDisassembler pDisassembler;
+extern PMachOLinker pLinker;
+extern PMachOProject pMachOProject;
+extern PCLTExtras pCLTExtras;
+
+/********************************/
+/* ParserHelpers.c */
+extern SInt16 lastStage;
+extern Boolean dashIMinusMovesPaths;
+extern Boolean usedDashIMinus;
+extern Boolean namingSysPaths;
+
+extern int FindFileInPath(const char *filename, OSSpec *fss);
+extern char *GetEnvVar(const char *name, Boolean warn, const char **match);
+extern int Opt_AddAccessPath(const char *opt, void *var, const char *arg, int flags);
+extern int Opt_AddFrameworkPath(const char *opt, void *var, const char *arg, int flags);
+extern int Opt_AddFramework(const char *opt, void *var, const char *arg, int flags);
+extern void ListParseMessage(void (*errprint)(const char *, va_list), const char *envvar, SInt16 id, ...);
+extern int AddAccessPathList(const char *list, char sep1, char sep2, int source, char *text, Boolean system, SInt32 position, Boolean recursive);
+extern int Opt_FindAndAddFile(const char *opt, void *var, const char *arg, int flags);
+extern int Opt_FindAndAddFileRef(const char *opt, void *var, const char *arg);
+extern int Opt_AddUnixLibraryFile(const char *opt, void *var, const char *arg);
+extern int AddFileList(const char *list, char sep1, char sep2, int source, char *text, SInt32 position);
+extern int IsFileInOutputDirectory(const OSSpec *file);
+extern void GetCFileNameInOutputDirectory(const char *input, char *name, int maxlen);
+extern void GetPFileNameInOutputDirectory(const char *input, unsigned char *name, int len);
+extern void AddStringLenToHandle(Handle *h, const char *str, int len);
+extern void AddStringToHandle(Handle *h, const char *str);
+extern int Opt_PrintVersion(const char *opt, void *var, const char *arg, int flags);
+extern void GetFirstSourceFilenameBase(char *buffer, char *defaul);
+extern int Opt_SavePrefs(const char *opt, void *var, const char *arg, int flags);
+extern int ParseNumber(const char *arg, Boolean emit_error, SInt32 *ret, const char **endptr);
+extern int Opt_MaybeMoveAccessPaths(const char *opt, void *var, const char *arg, int flags);
+
+/********************************/
+/* ParserHelpers-cc.c */
+extern Handle definesHandle;
+
+extern int Opt_AddStringToDefines(const char *opt, void *str, const char *param, int flags);
+extern int Opt_DefineSymbol(const char *var, const char *value);
+extern int Opt_UndefineSymbol(const char *opt, void *, const char *arg, int flags);
+extern int Opt_AddPrefixFile(const char *opt, void *handle, const char *filename, int flags);
+extern int Opt_PragmaTrueFalse(const char *, void *flag, const char *, int flags);
+extern int Opt_PragmaFalseTrue(const char *, void *flag, const char *, int flags);
+extern int Opt_PragmaOnOff(const char *, void *flag, const char *arg);
+extern int Opt_PragmaOffOn(const char *, void *flag, const char *arg);
+extern int SetupPragmas(const Pragma *pragmas);
+
+/********************************/
+/* Projects.c */
+extern int GetFileCount();
+extern void SetFileOutputName(SInt32 position, SInt16 which, char *outfilename);
+extern int AddFileToProject(OSSpec *oss, SInt16 which, char *outfilename, Boolean exists, SInt32 position);
+extern Boolean GetFileInfo(SInt32 position, OSSpec *spec, char *plugin);
+extern int AddAccessPath(OSPathSpec *oss, SInt16 type, SInt32 position, Boolean recursive);
+extern int MoveSystemPathsIntoUserList();
+extern void AddVirtualFile(const char *filename, Handle *text);
+extern void GetOutputFileDirectory(OSPathSpec *dir);
+extern void SetOutputFileDirectory(OSPathSpec *dir);
+extern void AddOverlayGroup(const char *name, CWAddr64 *addr, SInt32 *groupnum, SInt32 *overlaynum);
+extern void AddOverlay(SInt32 groupnum, const char *name, SInt32 *overlaynum);
+extern void AddSegment(const char *name, SInt16 attrs, SInt32 *segmentnum);
+extern void ChangeSegment(SInt32 segmentnum, const char *name, SInt16 attrs);
+extern int GetSegment(SInt32 segmentnum, char *name, SInt16 *attrs);
+
+/********************************/
+/* TargetOptimizer-ppc-mach.c */
+extern char schedule_ppc_default;
+
+extern int TargetSetOptFlags(short val, Boolean set);
+extern void TargetDisplayOptimizationOptions(Handle txt);
+extern void TargetSetPragmaOptimizationsToUnspecified();
+
+/********************************/
+/* TargetWarningHelpers-ppc-cc.c */
+extern Pragma warningPragmas[];
+
+extern int TargetSetWarningFlags(short val, Boolean set);
+extern void TargetDisplayWarningOptions(Handle txt);
+
+/********************************/
+/* Targets.c */
+extern ParserTool *pTool;
+
+extern int SetParserToolInfo(ParserTool *tool);
+extern Boolean ParserToolMatchesPlugin(OSType type, OSType lang, OSType cpu, OSType os);
+extern Boolean ParserToolHandlesPanels(int numPanels, const char **panelNames);
+extern Boolean SetupParserToolOptions();
+
+/********************************/
+/* ToolHelpers.c */
+enum {
+    OutputOrdering0 = 0,
+    OutputOrdering1 = 1,
+    OutputOrdering2 = 2
+};
+extern char linkerOutputFilename[256];
+extern Boolean setLinkerOutputFilename;
+extern Boolean setOutputDirectory;
+extern SInt16 outputOrdering;
+
+extern int Opt_HandleOutputName(const char *opt, void *, const char *filename, int flags);
+extern int ValidateToolState(Boolean mustHaveFiles);
+extern void ToolReportMessage(SInt16 errid, SInt16 type, va_list va);
+extern void ToolReportWarning(SInt16 id, ...);
+extern void ToolReportError(SInt16 id, ...);
+extern void ToolReportOSError(SInt16 id, int err, ...);
+extern void ToolReportInfo(SInt16 id, ...);
+extern int Opt_DoNotLink(const char *opt, void *var, const char *arg);
+extern int Opt_IncreaseVerbosity(const char *opt, void *var, const char *arg, int flags);
+extern int Opt_SetStage(const char *opt, void *str, const char *arg, int flags);
+extern int Opt_RedirectStream(const char *opt, void *file, const char *filename);
+
+/********************************/
+/* ToolHelpers-cc.c */
+extern int Opt_DummyLinkerRoutine(const char *opt, void *, const char *, int);
+extern int Opt_DummyLinkerSettingRoutine(const char *var, const char *val);
+extern void FinishCompilerTool();
+
+/********************************/
+/* Utils.c */
+extern int my_tolower(char c);
+extern int my_isdigit(char c);
+extern int my_isalpha(char c);
+extern int my_isalnum(char c);
+extern int my_isxdigit(char c);
+extern char *Utils_SpellList(char *list, char *buffer, char opts);
+extern int Utils_CompareOptionString(const char *a, const char *b, int cased, int sticky);
+
+/********************************/
+/* WarningHelpers.c */
+extern int SetWarningFlags(const char *opt, void *str, const char *, int flags);
+extern int DisplayWarningOptions();
+
+#ifdef __cplusplus
+extern "C" }
+#endif
diff --git a/includes/plugin.h b/includes/plugin.h
index 76b17cc..3341c82 100644
--- a/includes/plugin.h
+++ b/includes/plugin.h
@@ -16,7 +16,18 @@
 #endif
 
 enum {
-    CWDROPINPARSERTYPE = CWFOURCHAR('P','a','r','s')
+    CWDROPINPARSERTYPE = CWFOURCHAR('P','a','r','s'),
+    CWDROPINDRIVERTYPE = CWFOURCHAR('c','l','d','r'),
+    CWDROPINANYTYPE = CWFOURCHAR('*','*','*','*')
+};
+
+// Extra drop-in flags that aren't in the public plugin SDK headers
+enum {
+    dropInExecutableTool = 1
+};
+
+enum {
+    Lang_Any = CWFOURCHAR('*','*','*','*')
 };
 
 typedef struct IDEAccessPath {
@@ -36,6 +47,7 @@ typedef struct IDEAccessPathList {
 } IDEAccessPathList;
 
 enum {
+    cwAccessPathTypeFlag1 = 1,
     cwAccessPathTypeFlag2 = 2
 };
 typedef struct CWNewAccessPathInfo {
@@ -77,6 +89,27 @@ typedef struct ToolVersionInfo {
     char *version;
 } ToolVersionInfo;
 
+typedef struct CWObjectFlags {
+    SInt16 version;
+    SInt32 flags;
+    const char *objFileExt;
+    const char *brsFileExt;
+    const char *ppFileExt;
+    const char *disFileExt;
+    const char *depFileExt;
+    const char *pchFileExt;
+    OSType objFileCreator;
+    OSType objFileType;
+    OSType brsFileCreator;
+    OSType brsFileType;
+    OSType ppFileCreator;
+    OSType ppFileType;
+    OSType disFileCreator;
+    OSType disFileType;
+    OSType depFileCreator;
+    OSType depFileType;
+} CWObjectFlags;
+
 typedef struct CLPluginInfo {
     OSType plugintype;
     OSType language;
@@ -154,7 +187,7 @@ struct CWCompilerLinkerCallbacks {
 struct CWParserCallbacks {
     CWResult (*cbParserAddAccessPath)(CWPluginContext, const CWNewAccessPathInfo *);
     CWResult (*cbParserSwapAccessPaths)(CWPluginContext);
-    CWResult (*cbParserSetNamedPreferences)(CWPluginContext, const char *, CWMemHandle);
+    CWResult (*cbParserSetNamedPreferences)(CWPluginContext, const char *, Handle);
     CWResult (*cbParserSetFileOutputName)(CWPluginContext, SInt32, short, const char *);
     CWResult (*cbParserSetOutputFileDirectory)(CWPluginContext, const CWFileSpec *);
     CWResult (*cbParserAddOverlay1Group)(CWPluginContext, const char *, const CWAddr64 *, SInt32 *);
@@ -172,6 +205,10 @@ extern "C" {
 #endif
 CW_CALLBACK CWCheckoutLicense(CWPluginContext context, const char *a, const char *b, SInt32 c, void *d, SInt32 *cookiePtr);
 CW_CALLBACK CWCheckinLicense(CWPluginContext context, SInt32 cookie);
+
+CW_CALLBACK	CWOSErrorMessage(CWPluginContext context, const char *msg, OSErr errorcode);
+CW_CALLBACK	CWOSAlert(CWPluginContext context, const char* message, OSErr errorcode);
+
 CW_CALLBACK CWSecretAttachHandle(CWPluginContext context, Handle handle, CWMemHandle *memHandle);
 CW_CALLBACK CWSecretDetachHandle(CWPluginContext context, CWMemHandle memHandle, Handle *handle);
 CW_CALLBACK CWSecretPeekHandle(CWPluginContext context, CWMemHandle memHandle, Handle *handle);
@@ -187,7 +224,7 @@ CW_CALLBACK CWParserStoreCommandLineForPanel(CWPluginContext context, int index,
 CW_CALLBACK CWParserStoreCommandLineForPlugin(CWPluginContext context, int index, const CWCommandLineArgs *args);
 CW_CALLBACK CWParserAddAccessPath(CWPluginContext context, const CWNewAccessPathInfo *api);
 CW_CALLBACK CWParserSwapAccessPaths(CWPluginContext context);
-CW_CALLBACK CWParserSetNamedPreferences(CWPluginContext context, const char *panelName, CWMemHandle paneldata);
+CW_CALLBACK CWParserSetNamedPreferences(CWPluginContext context, const char *panelName, Handle paneldata);
 CW_CALLBACK CWParserSetFileOutputName(CWPluginContext context, SInt32 position, short which, const char *outfilename);
 CW_CALLBACK CWParserSetOutputFileDirectory(CWPluginContext context, const CWFileSpec *idefss);
 CW_CALLBACK CWParserAddOverlay1Group(CWPluginContext context, const char *name, const CWAddr64 *addr, SInt32 *newGroupNumber);
@@ -196,6 +233,86 @@ CW_CALLBACK CWParserAddSegment(CWPluginContext context, const char *name, short
 CW_CALLBACK CWParserSetSegment(CWPluginContext context, SInt32 segmentNumber, const char *name, short attrs);
 CW_CALLBACK CWParserCreateVirtualFile(CWPluginContext context, const char *name, CWMemHandle text);
 CW_CALLBACK CWParserDisplayTextHandle(CWPluginContext context, const char *name, CWMemHandle text);
+
+// CLDropinCallbacks
+extern CWResult UCBGetFileInfo(CWPluginContext context, SInt32 whichfile, Boolean checkFileLocation, CWProjectFileInfo *fileinfo);
+extern CWResult UCBFindAndLoadFile(CWPluginContext context, const char *filename, CWFileInfo *fileinfo);
+extern CWResult UCBGetFileText(CWPluginContext context, const CWFileSpec *filespec, const char **text, SInt32 *textLength, short *filedatatype);
+extern CWResult UCBReleaseFileText(CWPluginContext context, const char *text);
+extern CWResult UCBGetSegmentInfo(CWPluginContext context, SInt32 whichsegment, CWProjectSegmentInfo *segmentinfo);
+extern CWResult UCBGetOverlay1GroupInfo(CWPluginContext context, SInt32 whichgroup, CWOverlay1GroupInfo *groupinfo);
+extern CWResult UCBGetOverlay1FileInfo(CWPluginContext context, SInt32 whichgroup, SInt32 whichoverlay, SInt32 whichoverlayfile, CWOverlay1FileInfo *fileinfo);
+extern CWResult UCBGetOverlay1Info(CWPluginContext context, SInt32 whichgroup, SInt32 whichoverlay, CWOverlay1Info *overlayinfo);
+extern CWResult UCBReportMessage(CWPluginContext context, const CWMessageRef *msgRef, const char *line1, const char *line2, short errorlevel, SInt32 errorNumber);
+extern CWResult UCBAlert(CWPluginContext context, const char *msg1, const char *msg2, const char *msg3, const char *msg4);
+extern CWResult UCBShowStatus(CWPluginContext context, const char *line1, const char *line2);
+extern CWResult UCBUserBreak(CWPluginContext context);
+extern CWResult UCBGetNamedPreferences(CWPluginContext context, const char *prefsname, CWMemHandle *prefsdata);
+extern CWResult UCBStorePluginData(CWPluginContext context, SInt32 whichfile, CWDataType type, CWMemHandle prefsdata);
+extern CWResult UCBGetPluginData(CWPluginContext context, SInt32 whichfile, CWDataType type, CWMemHandle *prefsdata);
+extern CWResult UCBSetModDate(CWPluginContext context, const CWFileSpec *filespec, CWFileTime *moddate, Boolean isGenerated);
+extern CWResult UCBAddProjectEntry(CWPluginContext context, const CWFileSpec *fileSpec, Boolean isGenerated, const CWNewProjectEntryInfo *projectEntryInfo, SInt32 *whichfile);
+extern CWResult UCBCreateNewTextDocument(CWPluginContext context, const CWNewTextDocumentInfo *docinfo);
+extern CWResult UCBAllocateMemory(CWPluginContext context, SInt32 size, Boolean isPermanent, void **ptr);
+extern CWResult UCBFreeMemory(CWPluginContext context, void *ptr, Boolean isPermanent);
+extern CWResult UCBAllocMemHandle(CWPluginContext context, SInt32 size, Boolean useTempMemory, CWMemHandle *handle);
+extern CWResult UCBFreeMemHandle(CWPluginContext context, CWMemHandle handle);
+extern CWResult UCBGetMemHandleSize(CWPluginContext context, CWMemHandle handle, SInt32 *size);
+extern CWResult UCBResizeMemHandle(CWPluginContext context, CWMemHandle handle, SInt32 newSize);
+extern CWResult UCBLockMemHandle(CWPluginContext context, CWMemHandle handle, Boolean moveHi, void **ptr);
+extern CWResult UCBUnlockMemHandle(CWPluginContext context, CWMemHandle handle);
+extern CWResult UCBGetTargetName(CWPluginContext context, char *name, short maxLength);
+extern CWResult UCBPreDialog(CWPluginContext context);
+extern CWResult UCBPostDialog(CWPluginContext context);
+extern CWResult UCBPreFileAction(CWPluginContext context, const CWFileSpec *theFile);
+extern CWResult UCBPostFileAction(CWPluginContext context, const CWFileSpec *theFile);
+extern CWResult UCBCacheAccessPathList(CWPluginContext context);
+extern CWResult UCBSecretAttachHandle(CWPluginContext context, Handle handle, CWMemHandle *memHandle);
+extern CWResult UCBSecretDetachHandle(CWPluginContext context, CWMemHandle memHandle, Handle *handle);
+extern CWResult UCBSecretPeekHandle(CWPluginContext context, CWMemHandle memHandle, Handle *handle);
+extern CWResult UCBCheckoutLicense(CWPluginContext context, const char *a, const char *b, SInt32 c, void *d, SInt32 *cookiePtr);
+extern CWResult UCBCheckinLicense(CWPluginContext context, SInt32 cookie);
+extern CWResult UCBResolveRelativePath(CWPluginContext context, const CWRelativePath *relativePath, CWFileSpec *fileSpec, Boolean create);
+extern CWResult UCBMacOSErrToCWResult(CWPluginContext context, OSErr err);
+
+// CLCompilerLinkerDropin
+extern CWResult UCBCachePrecompiledHeader(CWPluginContext context, const CWFileSpec *filespec, CWMemHandle pchhandle);
+extern CWResult UCBLoadObjectData(CWPluginContext context, SInt32 whichfile, CWMemHandle *objectdata);
+extern CWResult UCBStoreObjectData(CWPluginContext context, SInt32 whichfile, CWObjectData *object);
+extern CWResult UCBFreeObjectData(CWPluginContext context, SInt32 whichfile, CWMemHandle objectdata);
+extern CWResult UCBDisplayLines(CWPluginContext context, SInt32 nlines);
+extern CWResult UCBBeginSubCompile(CWPluginContext context, SInt32 whichfile, CWPluginContext *subContext);
+extern CWResult UCBEndSubCompile(CWPluginContext subContext);
+extern CWResult UCBGetPrecompiledHeaderSpec(CWPluginContext context, CWFileSpec *pchspec, const char *target);
+extern CWResult UCBGetResourceFile(CWPluginContext context, CWFileSpec *filespec);
+extern CWResult UCBPutResourceFile(CWPluginContext context, const char *prompt, const char *name, CWFileSpec *filespec);
+extern CWResult UCBLookUpUnit(CWPluginContext context, const char *name, Boolean isdependency, const void **unitdata, SInt32 *unitdatalength);
+extern CWResult UCBSBMfiles(CWPluginContext context, short libref);
+extern CWResult UCBStoreUnit(CWPluginContext context, const char *unitname, CWMemHandle unitdata, CWDependencyTag dependencytag);
+extern CWResult UCBReleaseUnit(CWPluginContext context, void *unitdata);
+extern CWResult UCBUnitNameToFileName(CWPluginContext context, const char *unitname, char *filename);
+extern CWResult UCBOSAlert(CWPluginContext context, const char *message, OSErr errorcode);
+extern CWResult UCBOSErrorMessage(CWPluginContext context, const char *msg, OSErr errorcode);
+extern CWResult UCBGetModifiedFiles(CWPluginContext context, SInt32 *modifiedFileCount, const SInt32 **modifiedFiles);
+extern CWResult UCBGetSuggestedObjectFileSpec(CWPluginContext context, SInt32 whichfile, CWFileSpec *fileSpec);
+extern CWResult UCBGetStoredObjectFileSpec(CWPluginContext context, SInt32 whichfile, CWFileSpec *fileSpec);
+extern CWResult UCBGetFrameworkCount(CWPluginContext context, SInt32 *frameworkCount);
+extern CWResult UCBGetFrameworkInfo(CWPluginContext context, SInt32 whichFramework, CWFrameworkInfo *frameworkInfo);
+
+// CLParserCallbacks
+extern CWResult UCBParserAddAccessPath(CWPluginContext context, const CWNewAccessPathInfo *api);
+extern CWResult UCBParserSwapAccessPaths(CWPluginContext context);
+extern CWResult UCBParserSetNamedPreferences(CWPluginContext context, const char *panelName, Handle paneldata);
+extern CWResult UCBParserSetFileOutputName(CWPluginContext context, SInt32 position, short which, const char *outfilename);
+extern CWResult UCBParserSetOutputFileDirectory(CWPluginContext context, const CWFileSpec *idefss);
+extern CWResult UCBParserAddOverlay1Group(CWPluginContext context, const char *name, const CWAddr64 *addr, SInt32 *newGroupNumber);
+extern CWResult UCBParserAddOverlay1(CWPluginContext context, const char *name, SInt32 groupNumber, SInt32 *newOverlayNumber);
+extern CWResult UCBParserAddSegment(CWPluginContext context, const char *name, short attrs, SInt32 *newSegmentNumber);
+extern CWResult UCBParserSetSegment(CWPluginContext context, SInt32 segmentNumber, const char *name, short attrs);
+
 #ifdef __cplusplus
 }
 #endif
+
+// This one is intentionally outwith the extern "C" block as it's mangled
+extern CWResult OSErrtoCWResult(OSErr err);
\ No newline at end of file
diff --git a/includes/plugin_internal.h b/includes/plugin_internal.h
index be84406..fdf2bd0 100644
--- a/includes/plugin_internal.h
+++ b/includes/plugin_internal.h
@@ -5,7 +5,7 @@
 #pragma options align=mac68k
 #endif
 struct CWPluginPrivateContext {
-    CWPluginPrivateContext();
+    CWPluginPrivateContext(SInt32 thePluginType, SInt32 totalSize = 0);
     ~CWPluginPrivateContext();
 
     SInt32 request;
@@ -79,6 +79,13 @@ struct CWParserContext : CWPluginPrivateContext {
     CWCommandLineArgs *panel_args;
     CWParserCallbacks *callbacks;
 };
+
+struct Plugin;
+typedef struct shellContextType {
+    Plugin *plugin;
+    Boolean userAccessPathsChanged;
+    Boolean systemAccessPathsChanged;
+} shellContextType;
 #ifdef __MWERKS__
 #pragma options align=reset
 #endif
diff --git a/includes/pref_structs.h b/includes/pref_structs.h
new file mode 100644
index 0000000..b443bf7
--- /dev/null
+++ b/includes/pref_structs.h
@@ -0,0 +1,253 @@
+#pragma once
+#include "common.h"
+
+#ifdef	__MWERKS__
+#pragma options align=mac68k
+#endif
+
+typedef struct PCmdLine {
+    SInt16 version;
+    SInt16 state;
+    SInt16 stages;
+    SInt16 toDisk;
+    SInt16 outNameOwner;
+    Boolean dryRun;
+    Boolean debugInfo;
+    SInt16 verbose;
+    Boolean showLines;
+    Boolean timeWorking;
+    Boolean noWarnings;
+    Boolean warningsAreErrors;
+    UInt16 maxErrors;
+    UInt16 maxWarnings;
+    SInt16 msgStyle;
+    Boolean noWrapOutput;
+    Boolean stderr2stdout;
+    Boolean noCmdLineWarnings;
+} PCmdLine;
+
+typedef struct PCmdLineCompiler {
+    SInt16 version;
+    Boolean noSysPath;
+    Boolean noFail;
+    SInt16 includeSearch;
+    char linkerName[64];
+    char objFileExt[15];
+    char brsFileExt[15];
+    char ppFileExt[15];
+    char disFileExt[15];
+    char depFileExt[15];
+    char pchFileExt[15];
+    OSType objFileCreator;
+    OSType objFileType;
+    OSType brsFileCreator;
+    OSType brsFileType;
+    OSType ppFileCreator;
+    OSType ppFileType;
+    OSType disFileCreator;
+    OSType disFileType;
+    OSType depFileCreator;
+    OSType depFileType;
+    Boolean compileIgnored;
+    Boolean relPathInOutputDir;
+    Boolean browserEnabled;
+    Boolean depsOnlyUserFiles;
+    char outMakefile[256];
+    SInt8 forcePrecompile;
+    Boolean ignoreMissingFiles;
+    Boolean printHeaderNames;
+    SInt8 sbmState;
+    char sbmPath[256];
+    Boolean canonicalIncludes;
+    Boolean keepObjects;
+} PCmdLineCompiler;
+
+typedef struct PCmdLineLinker {
+    SInt16 version;
+    Boolean callPreLinker;
+    Boolean callPostLinker;
+    Boolean keepLinkerOutput;
+    Boolean callLinker;
+} PCmdLineLinker;
+
+typedef struct PBackEnd {
+    SInt16 version;
+    UInt8 structalignment;
+    UInt8 tracebacktables;
+    UInt8 processor;
+    UInt8 readonlystrings;
+    UInt8 profiler;
+    UInt8 fpcontract;
+    UInt8 schedule;
+    UInt8 peephole;
+    UInt8 processorspecific;
+    UInt8 altivec;
+    UInt8 vrsave;
+    UInt8 autovectorize;
+    UInt8 usebuiltins;
+    UInt8 pic;
+    UInt8 dynamic;
+    UInt8 common;
+    UInt8 implicit_templates;
+    UInt8 reserved[3];
+} PBackEnd;
+
+typedef struct PDisassembler {
+    SInt16 version;
+    Boolean showcode;
+    Boolean extended;
+    Boolean mix;
+    Boolean nohex;
+    Boolean showdata;
+    Boolean showexceptions;
+    Boolean showsym;
+    Boolean shownames;
+} PDisassembler;
+
+typedef struct PMachOLinker {
+    SInt16 version;
+    UInt8 linksym;
+    UInt8 symfullpath;
+    UInt8 suppresswarn;
+    UInt8 linkmap;
+    UInt8 multisymerror;
+    UInt8 whatfileloaded;
+    UInt8 whyfileloaded;
+    UInt8 use_objectivec_semantics;
+    SInt8 undefinedsymbols;
+    SInt8 readonlyrelocs;
+    SInt8 reserved_value1;
+    SInt8 reserved_value2;
+    SInt16 exports;
+    SInt16 reserved_short1;
+    UInt32 currentversion;
+    UInt32 compatibleversion;
+    SInt32 reserved_long1;
+    char mainname[64];
+    UInt8 prebind;
+    UInt8 dead_strip;
+    UInt8 twolevel_namespace;
+    UInt8 strip_debug_symbols;
+} PMachOLinker;
+
+typedef struct PMachOProject {
+    SInt16 version;
+    SInt16 type;
+    Str63 outfile;
+    OSType filecreator;
+    OSType filetype;
+    SInt32 stacksize;
+    SInt32 stackaddress;
+    SInt32 reserved1;
+    SInt32 reserved2;
+    SInt32 reserved3;
+    SInt32 reserved4;
+    SInt32 reserved5;
+    SInt32 reserved6;
+    SInt32 reserved7;
+    SInt32 reserved8;
+    SInt32 reserved9;
+    SInt32 reserved10;
+    SInt32 reserved11;
+    SInt32 reserved12;
+    SInt32 reserved13;
+    SInt32 reserved14;
+    SInt32 reserved15;
+    SInt32 reserved16;
+    SInt32 reserved17;
+    SInt32 reserved18;
+    SInt32 reserved19;
+    SInt32 reserved20;
+    UInt8 flatrsrc;
+    UInt8 filler1;
+    UInt8 filler2;
+    UInt8 filler3;
+    Str63 separateflatfile;
+    Str255 installpath;
+} PMachOProject;
+
+typedef struct {
+    SInt16 version;
+    Boolean userSetCreator;
+    Boolean userSetType;
+    Boolean gPrintMapToStdOutput;
+    Str255 mapfilename;
+    Str255 symfilename;
+} PCLTExtras;
+
+typedef struct PCmdLineEnvir {
+    SInt16 version;
+    SInt16 cols;
+    SInt16 rows;
+    Boolean underIDE;
+} PCmdLineEnvir;
+
+typedef struct PFrontEndC {
+    SInt16 version;
+    Boolean cplusplus;
+    Boolean checkprotos;
+    Boolean arm;
+    Boolean trigraphs;
+    Boolean onlystdkeywords;
+    Boolean enumsalwaysint;
+    Boolean mpwpointerstyle;
+    unsigned char oldprefixname[32];
+    Boolean ansistrict;
+    Boolean mpwcnewline;
+    Boolean wchar_type;
+    Boolean enableexceptions;
+    Boolean dontreusestrings;
+    Boolean poolstrings;
+    Boolean dontinline;
+    Boolean useRTTI;
+    Boolean multibyteaware;
+    Boolean unsignedchars;
+    Boolean autoinline;
+    Boolean booltruefalse;
+    Boolean direct_to_som;
+    Boolean som_env_check;
+    Boolean alwaysinline;
+    SInt16 inlinelevel;
+    Boolean ecplusplus;
+    Boolean objective_c;
+    Boolean defer_codegen;
+    Boolean templateparser;
+    Boolean c99;
+    Boolean bottomupinline;
+} PFrontEndC;
+
+typedef struct PWarningC {
+    SInt16 version;
+    Boolean warn_illpragma;
+    Boolean warn_emptydecl;
+    Boolean warn_possunwant;
+    Boolean warn_unusedvar;
+    Boolean warn_unusedarg;
+    Boolean warn_extracomma;
+    Boolean pedantic;
+    Boolean warningerrors;
+    Boolean warn_hidevirtual;
+    Boolean warn_implicitconv;
+    Boolean warn_notinlined;
+    Boolean warn_structclass;
+} PWarningC;
+
+typedef struct PGlobalOptimizer {
+    SInt16 version;
+    UInt8 optimizationlevel;
+    UInt8 optfor;
+    UInt8 reserved[8];
+} PGlobalOptimizer;
+
+// assumed name/symbols for this one
+typedef struct PExtraWarningC {
+    Boolean warn_largeargs;
+    Boolean warn_padding;
+    Boolean warn_resultnotused;
+    Boolean warn_ptr_int_conv;
+    Boolean warn_no_side_effect;
+} PExtraWarningC;
+
+#ifdef	__MWERKS__
+#pragma options align=reset
+#endif
diff --git a/notes b/notes
index 0a2c468..190d074 100644
--- a/notes
+++ b/notes
@@ -1,62 +1,65 @@
+~/bin/mwccppc -c -g -opt l=4,noschedule,speed -enum min -Iincludes -Isdk_hdrs -w all,nounused -wchar_t on -bool off -Cpp_exceptions off
+
 * - has issues
 
-DONE  CLStaticMain.c
-DONE  ClientGlue.c
-DONE  CLMain.c
-DONE* MacEmul/Resources.c
-STUB  Envir/CLErrors.c
-DONE* MacEmul/ResourceStrings.c
-----  Plugins/CLPlugins.c
-----  Callbacks/CLParserCallbacks_v1.cpp
-STUB  CLIO.c
-STUB  CLToolExec.c
-DONE  OSLib/Posix.c
-DONE  OSLib/StringExtras.c
-DONE  OSLib/Generic.c
-----  Project/CLProj.c
-----  CLLicenses.c
-DONE  OSLib/MemUtils.c
-----  CLPluginRequests.cpp
-DONE  MacEmul/LowMem.c
-----  CLFileOps.c
-----  CLPrefs.c
-----  CLTarg.c
-----  Project/CLAccessPaths.c
-DONE  OSLib/MacSpecs.c
-DONE  OSLib/StringUtils.c
-DONE  MacEmul/Memory.c
-DONE  MacEmul/File.c
-DONE  MacEmul/TextUtils.c
-----  ?? AddFileTypeMappingList, SetMacFileType, ...
-----  Project/CLFiles.c
-----  Project/CLOverlays.c
-----  Project/CLSegs.c
-----  Callbacks/CLDropinCallbacks_V10.cpp
-DONE  OSLib/MacFileTypes.c
-DONE  OSLib/FileHandles.c
-----  Callbacks/CLCompilerLinkerDropin_V10.cpp
-----  CLDependencies.c
-----  CLWriteObjectFile.c
-----  CLBrowser.c
-----  CLIncludeFileCache.c
-----  CLLoadAndCache.c
-DONE  MacEmul/ErrMgr.c
-----  ?? Counterpart of cc-macosx-ppc-mw.c
-      (Includes RegisterStaticTargetResources, GetStaticTarget, ...)
-----  ?? Counterpart of ParserGlue-macosx-ppc-cc.c
+[CL / command_line]
+DONE  command_line/CmdLine/Src/Clients/CLStaticMain.c
+DONE  command_line/CmdLine/Src/Clients/ClientGlue.c
+DONE  command_line/CmdLine/Src/CLMain.c
+DONE* command_line/CmdLine/Src/MacEmul/Resources.c
+DONE  command_line/CmdLine/Src/Envir/CLErrors.c
+DONE* command_line/CmdLine/Src/MacEmul/ResourceStrings.c
+DONE* command_line/CmdLine/Src/Plugins/CLPlugins.c
+DONE  command_line/CmdLine/Src/Callbacks/CLParserCallbacks_v1.cpp
+DONE  command_line/CmdLine/Src/Envir/CLIO.c
+DONE  command_line/CmdLine/Src/CLToolExec.c
+DONE  command_line/CmdLine/Src/OSLib/Posix.c
+DONE  command_line/CmdLine/Src/OSLib/StringExtras.c
+DONE  command_line/CmdLine/Src/OSLib/Generic.c
+DONE  command_line/CmdLine/Src/Project/CLProj.c
+DONE  command_line/CmdLine/Src/CLLicenses.c
+DONE  command_line/CmdLine/Src/OSLib/MemUtils.c
+DONE  command_line/CmdLine/Src/CLPluginRequests.cpp
+DONE  command_line/CmdLine/Src/MacEmul/LowMem.c
+DONE  command_line/CmdLine/Src/CLFileOps.c
+DONE  command_line/CmdLine/Src/CLPrefs.c
+DONE  command_line/CmdLine/Src/CLTarg.c
+DONE  command_line/CmdLine/Src/Project/CLAccessPaths.c
+DONE  command_line/CmdLine/Src/OSLib/MacSpecs.c
+DONE  command_line/CmdLine/Src/OSLib/StringUtils.c
+DONE  command_line/CmdLine/Src/MacEmul/Memory.c
+DONE  command_line/CmdLine/Src/MacEmul/Files.c
+DONE  command_line/CmdLine/Src/MacEmul/TextUtils.c
+DONE  ?? AddFileTypeMappingList, SetMacFileType, ...
+DONE  command_line/CmdLine/Src/Project/CLFiles.c
+DONE  command_line/CmdLine/Src/Project/CLOverlays.c
+DONE  command_line/CmdLine/Src/Project/CLSegs.c
+DONE* command_line/CmdLine/Src/Callbacks/CLDropinCallbacks_V10.cpp
+DONE  command_line/CmdLine/Src/OSLib/MacFileTypes.c
+DONE  command_line/CmdLine/Src/OSLib/FileHandles.c
+DONE  command_line/CmdLine/Src/Callbacks/CLCompilerLinkerDropin_V10.cpp
+DONE* command_line/CmdLine/Src/CLDependencies.c
+DONE  command_line/CmdLine/Src/CLWriteObjectFile.c
+DONE* command_line/CmdLine/Src/CLBrowser.c
+DONE  command_line/CmdLine/Src/CLIncludeFileCache.c
+DONE  command_line/CmdLine/Src/CLLoadAndCache.c
+DONE  command_line/CmdLine/Src/MacEmul/ErrMgr.c
+
+DONE  compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Static/cc-mach-ppc-mw.c
+----  compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-cc.c
       (Includes RegisterStaticParserToolInfo and all the option lists)
-----  ?? Counterpart of cc-macosx-ppc.c
+DONE  compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/cc-mach-ppc.o
       (Includes RegisterStaticCompilerPlugin, RegisterCompilerResources)
-----  ?? Counterpart of machimp-macosx-ppc.c
+DONE  compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/libimp-mach-ppc.c
       (Includes RegisterStaticLibImporterPlugin, RegisterLibImporterResources)
-----  TargetOptimizer-ppc-mach.c
+2CHK  TargetOptimizer-ppc-mach.c
 ----  OptimizerHelpers.c
 ----  ?? TargetSetWarningFlags, TargetDisplayWarningOptions
 ----  WarningHelpers.c
 
 ----  CCompiler.c
 ----  CParser.c
-----  CompilerTools.c
+----  compiler_and_linker/FrontEnd/Common/CompilerTools.c
 ----  CodeGenOptPPC.c
 ----  IrOptimizer.c
 ----  CodeGen.c
@@ -168,6 +171,8 @@ STUB  PCodeInfo.c
 ----  SpillCode.c
 ----  GCCInlineAsm.c
 ----  BitVectors.c
+
+[Parser]
 DONE  (debug) StaticParserGlue.c
 DONE  (debug) ParserFace.c
 DONE* (debug) ParserHelpers.c
@@ -180,13 +185,13 @@ DONE  (debug) Projects.c
 DONE  (debug) Targets.c
 DONE# (debug) Option.c
 DONE  (debug) ParserErrors.c
-----  (debug) Utils.c
+DONE* (debug) Utils.c
 DONE# (debug) Parameter.c
 DONE# (debug) Help.c
 DONE  uContext1.cpp
 DONE  uContextCL.cpp
 DONE  uContextSecret.cpp
-----  ?? COS
+DONE* ?? COS
 DONE  uContextParser.cpp
-----  ?? Something import-related
-----  Various MSL objects
\ No newline at end of file
+DONE  uLibImporter.c
+----  Various MSL objects
diff --git a/opt_decomp.py b/opt_decomp.py
new file mode 100644
index 0000000..a6e612b
--- /dev/null
+++ b/opt_decomp.py
@@ -0,0 +1,394 @@
+import json
+import sys
+
+def decode_avail(f):
+    flags = []
+    if (f & 0x1) != 0: flags.append('Global')
+    if (f & 0x2) != 0: flags.append('Sticky')
+    if (f & 0x4) != 0: flags.append('Cased')
+    if (f & 0x8) != 0: flags.append('Obsolete')
+    if (f & 0x10) != 0: flags.append('Substituted')
+    if (f & 0x20) != 0: flags.append('Deprecated')
+    if (f & 0x40) != 0: flags.append('Link')
+    if (f & 0x80) != 0: flags.append('Disasm')
+    if (f & 0x100) != 0: flags.append('Comp')
+    if (f & 0x200) != 0: flags.append('OF200')
+    if (f & 0x400) != 0: flags.append('OF400')
+    if (f & 0x800) != 0: flags.append('Ignored')
+    if (f & 0x1000) != 0: flags.append('Secret')
+    if (f & 0x2000) != 0: flags.append('HideDefault')
+    if (f & 0x4000) != 0: flags.append('Compat')
+    if (f & 0x8000) != 0: flags.append('Sub')
+    if (f & 0x10000) != 0: flags.append('SubsOptional')
+    if (f & 0x20000) != 0: flags.append('OnlyOnce')
+    if (f & 0x40000) != 0: flags.append('Conflicts')
+    if (f & 0x80000) != 0: flags.append('Warning')
+    if (f & 0x100000) != 0: flags.append('CanBeNegated')
+    if (f & 0x200000) != 0: flags.append('O_SLFlags10')
+    if (f & 0x400000) != 0: flags.append('O_SLFlags20')
+    if (f & 0x800000) != 0: flags.append('Meaningless')
+    if (f & 0x1000000) != 0: flags.append('OF1000000')
+    if (f & 0x2000000) != 0: flags.append('OF2000000')
+    if (f & 0x4000000) != 0: flags.append('OF4000000')
+    if (f & 0x8000000) != 0: flags.append('OF8000000')
+    if (f & 0x10000000) != 0: flags.append('OF10000000')
+    if (f & 0x20000000) != 0: flags.append('OF20000000')
+    return '|'.join(flags)
+def decode_paramflags(f):
+    flags = []
+    if (f & 0x1) != 0: flags.append('PF01')
+    if (f & 0x2) != 0: flags.append('PF02')
+    if (f & 0x4) != 0: flags.append('PF04')
+    if (f & 0x8) != 0: flags.append('PF08')
+    if (f & 0x10) != 0: flags.append('PF10')
+    if (f & 0x20) != 0: flags.append('PF20')
+    if (f & 0x40) != 0: flags.append('PF40')
+    if (f & 0x80) != 0: flags.append('PF80')
+    return '|'.join(flags)
+def decode_listflags(f):
+    flags = []
+    if (f & 0x1) != 0: flags.append('L_Exclusive')
+    if (f & 0x2) != 0: flags.append('L_AllowUnknowns')
+    if (f & 0x4) != 0: flags.append('LF4')
+    if (f & 0x8) != 0: flags.append('LF8')
+    if (f & 0x10) != 0: flags.append('LF10')
+    if (f & 0x20) != 0: flags.append('LF20')
+    if (f & 0x40) != 0: flags.append('LF40')
+    if (f & 0x80) != 0: flags.append('LF80')
+    if (f & 0x100) != 0: flags.append('L_Comp')
+    if (f & 0x200) != 0: flags.append('L_Link')
+    if (f & 0x400) != 0: flags.append('L_Disasm')
+    if (f & 0x800) != 0: flags.append('LF800')
+    if (f & 0x1000) != 0: flags.append('LF1000')
+    if (f & 0x2000) != 0: flags.append('LF2000')
+    if (f & 0x4000) != 0: flags.append('LF4000')
+    if (f & 0x8000) != 0: flags.append('LF8000')
+    if (f & 0x10000) != 0: flags.append('LF10000')
+    if (f & 0x20000) != 0: flags.append('LF20000')
+    if (f & 0x40000) != 0: flags.append('LF40000')
+    if (f & 0x80000) != 0: flags.append('LF80000')
+    if (f & 0x100000) != 0: flags.append('LF100000')
+    if (f & 0x200000) != 0: flags.append('LF200000')
+    if (f & 0x400000) != 0: flags.append('LF400000')
+    if (f & 0x800000) != 0: flags.append('LF800000')
+    if (f & 0x1000000) != 0: flags.append('LF1000000')
+    if (f & 0x2000000) != 0: flags.append('LF2000000')
+    if (f & 0x4000000) != 0: flags.append('LF4000000')
+    if (f & 0x8000000) != 0: flags.append('LF8000000')
+    if (f & 0x10000000) != 0: flags.append('LF10000000')
+    if (f & 0x20000000) != 0: flags.append('LF20000000')
+    if (f & 0x40000000) != 0: flags.append('LF40000000')
+    if (f & 0x80000000) != 0: flags.append('LF80000000')
+    return '|'.join(flags)
+
+navstack = []
+indent = ''
+def push_indent():
+    global indent
+    indent += '  '
+def pop_indent():
+    global indent
+    indent = indent[:-2]
+
+scan_objs = {}
+def register_scan_obj(name, what):
+    ckname = name.replace('_list', '')
+    if ckname[-1].isdigit():
+        last_non_digit = 0
+        for i,c in enumerate(ckname):
+            if not c.isdigit():
+                last_non_digit = i
+        idx = int(ckname[last_non_digit+1:])
+    else:
+        return
+
+    stk = ' / '.join(navstack)
+    if idx in scan_objs:
+        lst = scan_objs[idx]
+        for o in lst:
+            if o[1] == name:
+                return
+        lst.append((stk, name, what))
+    else:
+        scan_objs[idx] = [(stk, name, what)]
+
+def dump_param(p):
+    suff = ''
+    if 'myname' in p:
+        suff += ' +myname'
+    if 'help' in p:
+        suff += ' +help'
+    register_scan_obj(p['_name'], f"PF:{p['flags']:02X} T:{p['_type']}{suff}")
+    print(f"{indent}-{p['_name']:37} | {decode_paramflags(p['flags'])} ", end='')
+    if 'myname' in p:
+        print(f"<{p['myname']}> ", end='')
+    if p['_type'] == 'FTypeCreator':
+        print(f"FTypeCreator(fc={p['fc']} iscreator={p['iscreator']})")
+    elif p['_type'] == 'FilePath':
+        print(f"FilePath(flg={p['fflags']:02X} def={p['defaultstr']} fn={p['filename']} max={p['maxlen']})")
+    elif p['_type'] == 'Number':
+        print(f"Number(sz={p['size']} fit={p['fit']} lo={p['lo']:08X} hi={p['hi']:08X} num={p['num']})")
+    elif p['_type'] in ('String','Id','Sym'):
+        print(f"{p['_type']}(max={p['maxlen']} ps={p['pstring']} s={p['str']})")
+    elif p['_type'] == 'OnOff':
+        print(f"OnOff(var={p['var']})")
+    elif p['_type'] == 'OffOn':
+        print(f"OffOn(var={p['var']})")
+    elif p['_type'] == 'Mask':
+        print(f"Mask(sz={p['size']} or={p['ormask']:08X} and={p['andmask']:08X} num={p['num']})")
+    elif p['_type'] == 'Toggle':
+        print(f"Toggle(sz={p['size']} mask={p['mask']:08X} num={p['num']})")
+    elif p['_type'] == 'Set':
+        print(f"Set(sz={p['size']} v={p['value']} num={p['num']})")
+    elif p['_type'] == 'SetString':
+        print(f"SetString(v={p['value']} ps={p['pstring']} var={p['var']})")
+    elif p['_type'] == 'Generic':
+        v = p['var']
+        if isinstance(v, str):
+            v = v.replace('\n','').replace('\r','')
+        print(f"Generic(p={p['parse']} var={v})")
+    elif p['_type'] == 'IfArg':
+        print('IfArg')
+        push_indent()
+        print(f'{indent}TRUE:')
+        push_indent()
+        for i,s in enumerate(p['parg']):
+            navstack.append(f'ifArgParam{i}')
+            dump_param(s)
+            navstack.pop(-1)
+        pop_indent()
+        print(f'{indent}FALSE:')
+        push_indent()
+        for i,s in enumerate(p['pnone']):
+            navstack.append(f'ifArgNoneParam{i}')
+            dump_param(s)
+            navstack.pop(-1)
+        pop_indent()
+        pop_indent()
+    elif p['_type'] == 'Setting':
+        print(f"Setting(p={p['parse']} vn={p['valuename']})")
+    else:
+        print()
+
+def dump_opt(o):
+    navstack.append(o['names'])
+    trunchelp = o['help']
+    if trunchelp:
+        if len(trunchelp) > 35:
+            trunchelp = trunchelp[:20] + '...' + trunchelp[-5:]
+        trunchelp = trunchelp.replace('\r', ' ')
+        trunchelp = trunchelp.replace('\n', ' ')
+    avail = decode_avail(o['avail'])
+    register_scan_obj(o['_name'], 'OPTION ' + avail)
+    print(f"{indent}{o['_name']:40} | {avail} {o['names']:40} {trunchelp}")
+    if 'conflicts' in o:
+        conflicts = o['conflicts']
+        print(f"{indent}CONFLICTS: {conflicts['_name']} / {conflicts['_list_name']} / {decode_listflags(conflicts['flags'])}")
+        print(f"{indent}  {conflicts['list']}")
+        register_scan_obj(conflicts['_name'], f"CONFLICTS LIST")
+        register_scan_obj(conflicts['_list_name'], f"CONFLICTS LIST NAME")
+    push_indent()
+    for i,p in enumerate(o['param']):
+        navstack.append(f'param{i}')
+        dump_param(p)
+        navstack.pop(-1)
+    pop_indent()
+    if 'sub' in o:
+        sub = o['sub']
+        print(f"{indent}SUB {{ {sub['_name']} / {sub['_list_name']} / {decode_listflags(sub['flags'])}")
+        register_scan_obj(sub['_name'], f"SUB LIST")
+        register_scan_obj(sub['_list_name'], f"SUB LIST NAME")
+        push_indent()
+        for s in sub['list']:
+            dump_opt(s)
+        pop_indent()
+        print(f"{indent}}}")
+    navstack.pop(-1)
+
+def dump_optlst(ol):
+    register_scan_obj(ol['_name'], 'ROOT OBJECT')
+    register_scan_obj(ol['_list_name'], 'ROOT OBJECT LIST')
+    print(f"{indent}# FLAGS: {decode_listflags(ol['flags'])} - HELP: {repr(ol['help'])}")
+    for option in ol['list']:
+        dump_opt(option)
+
+with open(sys.argv[1], 'r') as f:
+    optlsts = json.load(f)
+
+for optlst in optlsts:
+    print(f"{indent}# --- {optlst['_name']} ---")
+    push_indent()
+    dump_optlst(optlst)
+    pop_indent()
+    print()
+
+lastseen = 0
+deltas = {}
+for i in range(1220):
+    if i in scan_objs:
+        delta = i - lastseen
+        for stk,name,what in scan_objs[i]:
+            print(f'{i:04d} {stk:60} | {name:30} | {what}')
+            deltas[name] = delta
+        lastseen = i
+    else:
+        print(f'{i:04d} -----')
+
+def nice_param(p):
+    # param names don't matter
+    np = {'_type': p['_type'], 'flags': p['flags']}
+    if 'myname' in p and p['myname']:
+        np['myname'] = p['myname']
+
+    delta = deltas[p['_name']]
+    if p['_name'] == '_optlstCmdLine099':
+        delta -= 1 # hack to account for the weird 'progress' one
+    if delta > 1:
+        np['_idskip'] = delta - 1
+
+    if p['_type'] == 'FTypeCreator':
+        np['target'] = p['fc']
+        np['is_creator'] = p['iscreator']
+    elif p['_type'] == 'FilePath':
+        np['fflags'] = p['fflags']
+        np['default'] = p['defaultstr']
+        np['target'] = p['filename']
+        np['max_length'] = p['maxlen']
+    elif p['_type'] == 'Number':
+        np['target'] = p['num']
+        np['minimum'] = p['lo']
+        np['maximum'] = p['hi']
+        np['byte_size'] = p['size']
+        np['fit'] = p['fit']
+    elif p['_type'] in ('String','Id','Sym'):
+        np['max_length'] = p['maxlen']
+        np['pascal'] = (p['pstring'] != 0)
+        np['target'] = p['str']
+    elif p['_type'] == 'OnOff':
+        np['target'] = p['var']
+    elif p['_type'] == 'OffOn':
+        np['target'] = p['var']
+    elif p['_type'] == 'Mask':
+        np['target'] = p['num']
+        np['byte_size'] = p['size']
+        np['or_mask'] = p['ormask']
+        np['and_mask'] = p['andmask']
+    elif p['_type'] == 'Toggle':
+        np['target'] = p['num']
+        np['byte_size'] = p['size']
+        np['mask'] = p['mask']
+    elif p['_type'] == 'Set':
+        np['target'] = p['num']
+        np['value'] = p['value']
+        np['byte_size'] = p['size']
+    elif p['_type'] == 'SetString':
+        np['target'] = p['var']
+        np['value'] = p['value']
+        np['pascal'] = (p['pstring'] != 0)
+    elif p['_type'] == 'Generic':
+        np['function'] = p['parse']
+        np['arg'] = p['var']
+        np['help'] = p['help']
+    elif p['_type'] == 'IfArg':
+        np['help_a'] = p['helpa']
+        np['help_n'] = p['helpn']
+        np['if_arg'] = [nice_param(sp) for sp in p['parg']]
+        np['if_no_arg'] = [nice_param(sp) for sp in p['pnone']]
+    elif p['_type'] == 'Setting':
+        np['function'] = p['parse']
+        np['value_name'] = p['valuename']
+    return np
+
+def nice_option(o, exclusive_parent=False):
+    no = {'names': o['names'], 'tools': [], 'params': [nice_param(p) for p in o['param']]}
+    if 'help' in o:
+        no['help'] = o['help']
+    if o['_name'] == '_optlstCmdLine_progress':
+        no['custom_name'] = 'progress' # lol hack
+    if (o['avail'] & 0x1) != 0: no['global'] = True
+    if (o['avail'] & 0x2) != 0: no['sticky'] = True
+    if (o['avail'] & 0x4) != 0: no['cased'] = True
+    if (o['avail'] & 0x8) != 0: no['obsolete'] = True
+    if (o['avail'] & 0x10) != 0: no['substituted'] = True
+    if (o['avail'] & 0x20) != 0: no['deprecated'] = True
+    if (o['avail'] & 0x100) != 0: no['tools'].append('compiler')
+    if (o['avail'] & 0x40) != 0: no['tools'].append('linker')
+    if (o['avail'] & 0x80) != 0: no['tools'].append('disassembler')
+    if (o['avail'] & 0x200) != 0: raise ValueError('fucked')
+    if (o['avail'] & 0x400) != 0: raise ValueError('fucked')
+    if (o['avail'] & 0x800) != 0: no['ignored'] = True
+    if (o['avail'] & 0x1000) != 0: no['secret'] = True
+    if (o['avail'] & 0x2000) != 0: no['hide_default'] = True
+    if (o['avail'] & 0x4000) != 0: no['compatibility'] = True
+    if (o['avail'] & 0x20000) != 0: no['only_once'] = True
+    if (o['avail'] & 0x80000) != 0: no['warning'] = True
+    if (o['avail'] & 0x100000) != 0: no['can_be_negated'] = True
+    if (o['avail'] & 0x200000) != 0: no['can_be_negated_2'] = True
+    if (o['avail'] & 0x400000) != 0: no['can_be_negated_3'] = True
+    if (o['avail'] & 0x800000) != 0: no['meaningless'] = True
+
+    if (o['avail'] & 0x8000) != 0:
+        subflags = o['sub']['flags']
+        obj_comp = (o['avail'] & 0x100) != 0
+        obj_link = (o['avail'] & 0x40) != 0
+        obj_disasm = (o['avail'] & 0x80) != 0
+        sublist_comp = (subflags & 0x100) != 0
+        sublist_link = (subflags & 0x200) != 0
+        sublist_disasm = (subflags & 0x400) != 0
+        assert(obj_comp == sublist_comp)
+        assert(obj_link == sublist_link)
+        assert(obj_disasm == sublist_disasm)
+
+        excl = False
+        if (o['avail'] & 0x10000) != 0:
+            no['sub_options_optional'] = True
+        if (subflags & 2) != 0:
+            no['sub_options_allow_unknowns'] = True
+        if (subflags & 1) != 0:
+            no['sub_options_exclusive'] = True
+            excl = True
+
+        assert('help' not in o['sub'])
+        no['sub_options'] = [nice_option(so, excl) for so in o['sub']['list']]
+    else:
+        assert('sub' not in o)
+
+    if exclusive_parent:
+        # conflicts flag should be set
+        assert((o['avail'] & 0x40000) == 0x40000)
+        assert('help' not in o['conflicts'])
+    else:
+        if (o['avail'] & 0x40000) == 0x40000:
+            no['conflict_group'] = o['conflicts']['_name'][1:].replace('_conflicts', '')
+
+    return no
+
+if len(sys.argv) > 2:
+    nice_optlsts_map = {}
+    for optlst in optlsts:
+        #print('---' + optlst['_name'])
+        root_list = {'name': optlst['_name'].replace('_optlst', ''), 'tools': [], 'help': optlst['help'], 'options': []}
+        if (optlst['flags'] & 0x100) != 0: root_list['tools'].append('compiler')
+        if (optlst['flags'] & 0x200) != 0: root_list['tools'].append('linker')
+        if (optlst['flags'] & 0x400) != 0: root_list['tools'].append('disassembler')
+        for opt in optlst['list']:
+            #print('+' + opt['names'])
+            root_list['options'].append(nice_option(opt))
+        nice_optlsts_map[root_list['name']] = root_list
+
+    nice_optlsts = [
+        nice_optlsts_map['CmdLine'],
+        nice_optlsts_map['CmdLineCompiler'],
+        nice_optlsts_map['CmdLineLinker'],
+        nice_optlsts_map['Debugging'],
+        nice_optlsts_map['FrontEndC'],
+        nice_optlsts_map['WarningC'],
+        nice_optlsts_map['Optimizer'],
+        nice_optlsts_map['BackEnd'],
+        nice_optlsts_map['Project'],
+        nice_optlsts_map['Linker'],
+        nice_optlsts_map['Dumper']
+    ]
+
+    with open(sys.argv[2], 'w') as f:
+        json.dump(nice_optlsts, f, indent=4)
diff --git a/opt_recomp.py b/opt_recomp.py
new file mode 100644
index 0000000..b7c46c4
--- /dev/null
+++ b/opt_recomp.py
@@ -0,0 +1,381 @@
+import json
+
+class OptionCompiler:
+    def __init__(self):
+        self.last_id = 0
+        self.debug_indent = ''
+        self.root_basename = ''
+        self.current_basename = ''
+        self.current_forward_decls = []
+        self.current_output = []
+        self.conflict_groups = {}
+
+    def debug_push(self):
+        self.debug_indent += '  '
+
+    def debug_pop(self):
+        self.debug_indent = self.debug_indent[:-2]
+
+    def get_new_id(self):
+        self.last_id += 1
+        return self.last_id
+
+    def skip_id(self):
+        self.last_id += 1
+
+    def add_root(self, root):
+        self.assign_all_ids(root)
+        print('-'*80)
+        self.assign_all_names(root)
+        print('-'*80)
+        self.current_forward_decls = []
+        self.current_output = []
+        self.conflict_groups = {}
+        self.emit_root(root)
+
+        filename = f"Opts{root['name']}.opt"
+        with open(f'compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Lib/mac-ppc-cc/{filename}', 'w') as f:
+            for line in self.current_forward_decls:
+                f.write(line)
+                f.write('\n')
+            if self.current_forward_decls:
+                f.write('\n')
+            for line in self.current_output:
+                f.write(line)
+                f.write('\n')
+
+    # Phase 1
+    def assign_all_ids(self, root):
+        for option in root['options']:
+            self.assign_id_to_option(option)
+        root['_list_id'] = self.get_new_id()
+
+    def assign_id_to_option(self, option):
+        print(f"{self.debug_indent}option {option['names']}")
+        self.debug_push()
+        if 'sub_options' in option:
+            for sub_option in reversed(option['sub_options']):
+                self.assign_id_to_option(sub_option)
+            option['_sub_list_id'] = self.get_new_id()
+            print(f"{self.debug_indent}{option['_sub_list_id']}: option sublist")
+        for param in reversed(option['params']):
+            self.assign_id_to_param(param)
+        option['_id'] = self.get_new_id()
+        print(f"{self.debug_indent}{option['_id']}: option ({option['names']})")
+        self.debug_pop()
+
+    def assign_id_to_param(self, param):
+        if param['_type'] == 'IfArg':
+            for sub_param in reversed(param['if_no_arg']):
+                self.assign_id_to_param(sub_param)
+            for sub_param in reversed(param['if_arg']):
+                self.assign_id_to_param(sub_param)
+
+        if '_idskip' in param:
+            self.last_id += param['_idskip']
+        param['_id'] = self.get_new_id()
+        print(f"{self.debug_indent}{param['_id']}: param {param['_type']}")
+
+    # Phase 2
+    def assign_all_names(self, root):
+        self.root_basename = f"optlst{root['name']}"
+        self.current_basename = f"optlst{root['name']}"
+        root['_name'] = self.current_basename
+        root['_list_name'] = f"{self.current_basename}_{root['_list_id']:03d}_list"
+        for option in root['options']:
+            self.assign_name_to_option(option)
+
+    def assign_name_to_option(self, option):
+        if 'conflict_group' in option:
+            option['_name'] = f"{option['conflict_group']}_{option['_id']:03d}"
+        elif 'custom_name' in option:
+            option['_name'] = f"{self.current_basename}_{option['custom_name']}"
+        else:
+            option['_name'] = f"{self.current_basename}_{option['_id']:03d}"
+        print(f"{self.debug_indent}{option['_name']} = {option['names']}")
+        self.debug_push()
+        for param in option['params']:
+            self.assign_name_to_param(param)
+        if 'sub_options' in option:
+            save_basename = self.current_basename
+            option['_sub_list_name'] = f"{self.current_basename}_{option['_sub_list_id']:03d}"
+            if 'sub_options_exclusive' in option and option['sub_options_exclusive']:
+                self.current_basename = option['_sub_list_name']
+            for sub_option in option['sub_options']:
+                self.assign_name_to_option(sub_option)
+            self.current_basename = save_basename
+        self.debug_pop()
+
+    def assign_name_to_param(self, param):
+        if param['_type'] == 'IfArg':
+            self.debug_push()
+            for sub_param in param['if_no_arg']:
+                self.assign_name_to_param(sub_param)
+            for sub_param in param['if_arg']:
+                self.assign_name_to_param(sub_param)
+            self.debug_pop()
+        param['_name'] = f"{self.root_basename}{param['_id']:03d}"
+        print(f"{self.debug_indent}{param['_name']} = {param['_type']}")
+
+    # Phase 3
+    def emit_root(self, root):
+        self.current_output.append(f"/* {root['name']} */")
+        for option in root['options']:
+            self.emit_option(option)
+
+        self.current_output.append(f"Option *{root['_list_name']}[] = {{")
+        for option in root['options']:
+            self.current_output.append(f"\t&{option['_name']},")
+        self.current_output.append('\t0')
+        self.current_output.append('};')
+
+        list_flags = build_list_flags(root)
+        self.current_output.append(f"OptionList {root['_name']} = {{")
+        self.current_output.append(f"\t/*  help = */ {json.dumps(root['help'])},")
+        self.current_output.append(f"\t/* flags = */ {list_flags},")
+        self.current_output.append(f"\t/*  list = */ {root['_list_name']}")
+        self.current_output.append('};')
+
+        for (i, (group, option_names)) in enumerate(self.conflict_groups.items()):
+            self.current_forward_decls.append(f'/* forward declare */ extern OptionList {group}_conflicts;')
+            self.current_output.append(f'Option *{group}_{i:03d}_list[] = {{')
+            for option_name in option_names:
+                self.current_output.append(f'\t&{option_name},')
+            self.current_output.append('\t0')
+            self.current_output.append('};')
+            self.current_output.append(f'OptionList {group}_conflicts = {{')
+            self.current_output.append(f'\t/*  help = */ 0,')
+            self.current_output.append(f'\t/* flags = */ 0,')
+            self.current_output.append(f'\t/*  list = */ {group}_{i:03d}_list')
+            self.current_output.append('};')
+
+    def emit_option(self, option, is_conflicted=None):
+        option_flags = build_option_flags(option, is_conflicted)
+
+        sub_name = '0'
+        if 'sub_options' in option:
+            sub_name = '&' + option['_sub_list_name']
+            sub_conflicts = None
+            if ('sub_options_exclusive' in option) and option['sub_options_exclusive']:
+                sub_conflicts = f"&{option['_sub_list_name']}_conflicts"
+                self.current_output.append(f"/* forward declare */ extern OptionList {option['_sub_list_name']}_conflicts;")
+
+            for sub_option in option['sub_options']:
+                self.emit_option(sub_option, sub_conflicts)
+
+            self.current_output.append(f"Option *{option['_sub_list_name']}_list[] = {{")
+            for sub_option in option['sub_options']:
+                self.current_output.append(f"\t&{sub_option['_name']},")
+            self.current_output.append('\t0')
+            self.current_output.append('};')
+
+            list_flags = build_list_flags(option)
+            self.current_output.append(f"OptionList {option['_sub_list_name']} = {{")
+            self.current_output.append(f"\t/*  help = */ 0,")
+            self.current_output.append(f"\t/* flags = */ {list_flags},")
+            self.current_output.append(f"\t/*  list = */ {option['_sub_list_name']}_list")
+            self.current_output.append('};')
+
+            if ('sub_options_exclusive' in option) and option['sub_options_exclusive']:
+                self.current_output.append(f"OptionList {option['_sub_list_name']}_conflicts = {{")
+                self.current_output.append(f"\t/*  help = */ 0,")
+                self.current_output.append(f"\t/* flags = */ {list_flags},")
+                self.current_output.append(f"\t/*  list = */ {option['_sub_list_name']}_list")
+                self.current_output.append('};')
+
+        if is_conflicted:
+            conflicts_name = is_conflicted
+        elif 'conflict_group' in option:
+            conflict_group = option['conflict_group']
+            conflicts_name = f'&{conflict_group}_conflicts'
+            if conflict_group in self.conflict_groups:
+                self.conflict_groups[conflict_group].append(option['_name'])
+            else:
+                self.conflict_groups[conflict_group] = [option['_name']]
+        else:
+            conflicts_name = '0'
+
+        last_param = self.emit_params(option['params'])
+        help_str = json.dumps(option['help']) if ('help' in option and option['help'] is not None) else '0'
+
+        self.current_output.append(f"Option {option['_name']} = {{")
+        self.current_output.append(f"\t/*     names = */ {json.dumps(option['names'])},")
+        self.current_output.append(f"\t/*     avail = */ {option_flags},")
+        self.current_output.append(f"\t/*     param = */ {last_param},")
+        self.current_output.append(f"\t/*       sub = */ {sub_name},")
+        self.current_output.append(f"\t/* conflicts = */ {conflicts_name},")
+        self.current_output.append(f"\t/*      help = */ {help_str}")
+        self.current_output.append('};')
+
+    def emit_params(self, params):
+        last_param = '0'
+
+        for param in reversed(params):
+            if param['_type'] == 'IfArg':
+                ia_last_parg = self.emit_params(param['if_arg'])
+                ia_last_pnone = self.emit_params(param['if_no_arg'])
+
+            myname_str = json.dumps(param['myname']) if 'myname' in param else '0'
+
+            self.current_output.append(f"{PARAM_TYPES[param['_type']]} {param['_name']} = {{")
+            self.current_output.append(f"\t/*      which = */ PARAMWHICH_{param['_type']},")
+            self.current_output.append(f"\t/*      flags = */ 0x{param['flags']:02X},")
+            self.current_output.append(f"\t/*     myname = */ {myname_str},")
+            self.current_output.append(f"\t/*       next = */ {last_param},")
+            if param['_type'] == 'FTypeCreator':
+                self.current_output.append(f"\t/*         fc = */ &{param['target']},")
+                self.current_output.append(f"\t/*  iscreator = */ {param['is_creator']}")
+            elif param['_type'] == 'FilePath':
+                self.current_output.append(f"\t/*     fflags = */ {param['fflags']},")
+                df = json.dumps(param['default']) if param['default'] is not None else '0'
+                self.current_output.append(f"\t/* defaultstr = */ {df},")
+                self.current_output.append(f"\t/*   filename = */ {param['target']},")
+                self.current_output.append(f"\t/*     maxlen = */ {param['max_length']}")
+            elif param['_type'] == 'Number':
+                self.current_output.append(f"\t/*       size = */ {param['byte_size']},")
+                self.current_output.append(f"\t/*        fit = */ {param['fit']},")
+                self.current_output.append(f"\t/*         lo = */ {param['minimum']},")
+                self.current_output.append(f"\t/*         hi = */ {param['maximum']},")
+                self.current_output.append(f"\t/*        num = */ &{param['target']}")
+            elif param['_type'] in ('String','Id','Sym'):
+                self.current_output.append(f"\t/*     maxlen = */ {param['max_length']},")
+                self.current_output.append(f"\t/*    pstring = */ {int(param['pascal'])},")
+                self.current_output.append(f"\t/*        str = */ {param['target']}")
+            elif param['_type'] in ('OnOff','OffOn'):
+                self.current_output.append(f"\t/*        var = */ &{param['target']}")
+            elif param['_type'] == 'Mask':
+                self.current_output.append(f"\t/*       size = */ {param['byte_size']},")
+                self.current_output.append(f"\t/*     ormask = */ 0x{param['or_mask']:X},")
+                self.current_output.append(f"\t/*    andmask = */ 0x{param['and_mask']:X},")
+                self.current_output.append(f"\t/*        num = */ &{param['target']}")
+            elif param['_type'] == 'Toggle':
+                self.current_output.append(f"\t/*       size = */ {param['byte_size']},")
+                self.current_output.append(f"\t/*       mask = */ 0x{param['mask']:X},")
+                self.current_output.append(f"\t/*        num = */ &{param['target']}")
+            elif param['_type'] == 'Set':
+                self.current_output.append(f"\t/*       size = */ {param['byte_size']},")
+                self.current_output.append(f"\t/*      value = */ 0x{param['value']:X},")
+                if param['target']:
+                    self.current_output.append(f"\t/*        num = */ (char *) &{param['target']}")
+                else:
+                    self.current_output.append(f"\t/*        num = */ 0")
+            elif param['_type'] == 'SetString':
+                self.current_output.append(f"\t/*      value = */ {json.dumps(param['value'])},")
+                self.current_output.append(f"\t/*    pstring = */ {int(param['pascal'])},")
+                self.current_output.append(f"\t/*        var = */ {param['target']}")
+            elif param['_type'] == 'Generic':
+                self.current_output.append(f"\t/*      parse = */ &{param['function']},")
+                self.current_output.append(f"\t/*        arg = */ (void *) {json.dumps(param['arg'])},")
+                help_str = json.dumps(param['help']) if ('help' in param and param['help'] is not None) else '0'
+                self.current_output.append(f"\t/*       help = */ {help_str}")
+            elif param['_type'] == 'IfArg':
+                self.current_output.append(f"\t/*       parg = */ {ia_last_parg},")
+                self.current_output.append(f"\t/*      helpa = */ {json.dumps(param['help_a'])},")
+                self.current_output.append(f"\t/*      pnone = */ {ia_last_pnone},")
+                self.current_output.append(f"\t/*      helpn = */ {json.dumps(param['help_n'])}")
+            elif param['_type'] == 'Setting':
+                self.current_output.append(f"\t/*      parse = */ &{param['function']},")
+                self.current_output.append(f"\t/*  valuename = */ {json.dumps(param['value_name'])}")
+            self.current_output.append('};')
+            last_param = '(PARAM_T *) &' + param['_name']
+
+        return last_param
+
+PARAM_TYPES = {
+    'FTypeCreator': 'FTYPE_T',
+    'FilePath': 'FILEPATH_T',
+    'Number': 'NUM_T',
+    'String': 'STRING_T',
+    'Id': 'STRING_T',
+    'Sym': 'STRING_T',
+    'OnOff': 'ONOFF_T',
+    'OffOn': 'OFFON_T',
+    'Mask': 'MASK_T',
+    'Toggle': 'TOGGLE_T',
+    'Set': 'SET_T',
+    'SetString': 'SETSTRING_T',
+    'Generic': 'GENERIC_T',
+    'IfArg': 'IFARG_T',
+    'Setting': 'SETTING_T'
+}
+
+def build_list_flags(what):
+    bits = []
+    if 'sub_options_exclusive' in what and what['sub_options_exclusive']:
+        bits.append('LISTFLAGS_EXCLUSIVE')
+    if 'sub_options_allow_unknowns' in what and what['sub_options_allow_unknowns']:
+        bits.append('LISTFLAGS_ALLOW_UNKNOWNS')
+    for tool in what['tools']:
+        if tool == 'compiler':
+            bits.append('LISTFLAGS_COMPILER')
+        elif tool == 'linker':
+            bits.append('LISTFLAGS_LINKER')
+        elif tool == 'disassembler':
+            bits.append('LISTFLAGS_DISASSEMBLER')
+    if bits:
+        return ' | '.join(bits)
+    else:
+        return '0'
+
+def build_option_flags(option, has_conflicts=False):
+    bits = []
+    if 'global' in option and option['global']:
+        bits.append('OTF_GLOBAL')
+    if 'sticky' in option and option['sticky']:
+        bits.append('OTF_STICKY')
+    if 'cased' in option and option['cased']:
+        bits.append('OTF_CASED')
+    if 'obsolete' in option and option['obsolete']:
+        bits.append('OTF_OBSOLETE')
+    if 'substituted' in option and option['substituted']:
+        bits.append('OTF_SUBSTITUTED')
+    if 'deprecated' in option and option['deprecated']:
+        bits.append('OTF_DEPRECATED')
+    if 'ignored' in option and option['ignored']:
+        bits.append('OTF_IGNORED')
+    if 'secret' in option and option['secret']:
+        bits.append('OTF_SECRET')
+    if 'hide_default' in option and option['hide_default']:
+        bits.append('OTF_HIDE_DEFAULT')
+    if 'compatibility' in option and option['compatibility']:
+        bits.append('OTF_COMPATIBILITY')
+    if 'only_once' in option and option['only_once']:
+        bits.append('OTF_ONLY_ONCE')
+    if 'warning' in option and option['warning']:
+        bits.append('OTF_WARNING')
+    if 'can_be_negated' in option and option['can_be_negated']:
+        bits.append('OTF_SLFLAGS_8')
+    if 'can_be_negated_2' in option and option['can_be_negated_2']:
+        bits.append('OTF_SLFLAGS_10')
+    if 'can_be_negated_3' in option and option['can_be_negated_3']:
+        bits.append('OTF_SLFLAGS_20')
+    if 'meaningless' in option and option['meaningless']:
+        bits.append('OTF_MEANINGLESS')
+
+    for tool in option['tools']:
+        if tool == 'compiler':
+            bits.append('OTF_TOOL_COMPILER')
+        elif tool == 'linker':
+            bits.append('OTF_TOOL_LINKER')
+        elif tool == 'disassembler':
+            bits.append('OTF_TOOL_DISASSEMBLER')
+
+    if 'sub_options' in option:
+        bits.append('OTF_HAS_SUB_OPTIONS')
+        if 'sub_options_optional' in option and option['sub_options_optional']:
+            bits.append('OTF_SUB_OPTIONS_OPTIONAL')
+
+    if 'conflict_group' in option or has_conflicts:
+        bits.append('OTF_HAS_CONFLICTS')
+
+    if bits:
+        return ' | '.join(bits)
+    else:
+        return '0'
+
+with open('../../nice_opts.json', 'r') as f:
+    roots = json.load(f)
+
+oc = OptionCompiler()
+for root in roots:
+    oc.add_root(root)
diff --git a/optdump.py b/optdump.py
new file mode 100644
index 0000000..b1bb42e
--- /dev/null
+++ b/optdump.py
@@ -0,0 +1,386 @@
+import json
+
+'''
+HOW TO GENERATE:
+
+
+'''
+
+def play_with_addr(ea):
+    if ea == 0:
+        return None
+
+    e = ida_name.get_name_expr(0, 0, ea, BADADDR)
+    e = e[13:-2]
+    return e
+
+class String:
+    name: str
+    value: str
+
+    @staticmethod
+    def from_ea(ea):
+        if ea == 0:
+            return None
+        else:
+            s = String()
+            s.name = get_name(ea)
+            v = get_bytes(ea, 1024)
+            v = v[:v.find(b'\0')]
+            s.value = v.decode('ascii')
+            return s
+
+    def encode(self):
+        if self.name.startswith('a'):
+            return self.value
+        else:
+            return dict(name=self.name, value=self.value)
+
+class Param:
+    name: str
+    flags: int
+    myname: String
+
+    @staticmethod
+    def from_ea(ea):
+        print('reading param %08x' % ea)
+        which = get_wide_byte(ea)
+        next_ea = get_wide_dword(ea + 6)
+        p = PARAM_CLASSES[which]()
+        p.populate_from_ea(ea)
+        return p, next_ea
+
+    def populate_from_ea(self, ea):
+        self.name = get_name(ea)
+        self.flags = get_wide_byte(ea + 1)
+        self.myname = String.from_ea(get_wide_dword(ea + 2))
+
+    def encode(self):
+        d = dict(_name=self.name, flags=self.flags)
+        if self.myname is not None:
+            d['myname'] = self.myname
+        return d
+
+    @staticmethod
+    def list_from_ea(ea):
+        lst = []
+        while ea != 0:
+            param, next_ea = Param.from_ea(ea)
+            lst.append(param)
+            ea = next_ea
+        return lst
+
+class FTypeCreatorParam(Param):
+    def populate_from_ea(self, ea):
+        super(FTypeCreatorParam, self).populate_from_ea(ea)
+        self.fc = play_with_addr(get_wide_dword(ea + 10))
+        self.iscreator = get_wide_byte(ea + 14)
+    def encode(self):
+        d = super(FTypeCreatorParam, self).encode()
+        d['_type'] = 'FTypeCreator'
+        d['fc'] = self.fc
+        d['iscreator'] = self.iscreator
+        return d
+
+class FilePathParam(Param):
+    def populate_from_ea(self, ea):
+        super(FilePathParam, self).populate_from_ea(ea)
+        self.fflags = get_wide_byte(ea + 10)
+        self.defaultstr = String.from_ea(get_wide_dword(ea + 11))
+        self.filename = play_with_addr(get_wide_dword(ea + 15))
+        self.maxlen = get_wide_dword(ea + 19)
+    def encode(self):
+        d = super(FilePathParam, self).encode()
+        d['_type'] = 'FilePath'
+        d['fflags'] = self.fflags
+        d['defaultstr'] = self.defaultstr
+        d['filename'] = self.filename
+        d['maxlen'] = self.maxlen
+        return d
+
+class NumberParam(Param):
+    def populate_from_ea(self, ea):
+        super(NumberParam, self).populate_from_ea(ea)
+        self.size = get_wide_byte(ea + 10)
+        self.fit = get_wide_byte(ea + 11)
+        self.lo = get_wide_dword(ea + 12)
+        self.hi = get_wide_dword(ea + 16)
+        self.num = play_with_addr(get_wide_dword(ea + 20))
+    def encode(self):
+        d = super(NumberParam, self).encode()
+        d['_type'] = 'Number'
+        d['size'] = self.size
+        d['fit'] = self.fit
+        d['lo'] = self.lo
+        d['hi'] = self.hi
+        d['num'] = self.num
+        return d
+
+class StringParam(Param):
+    def populate_from_ea(self, ea):
+        super(StringParam, self).populate_from_ea(ea)
+        self.maxlen = get_wide_word(ea + 10)
+        self.pstring = get_wide_byte(ea + 12)
+        self.str = play_with_addr(get_wide_dword(ea + 13))
+    def encode(self):
+        d = super(StringParam, self).encode()
+        d['_type'] = 'String'
+        d['maxlen'] = self.maxlen
+        d['pstring'] = self.pstring
+        d['str'] = self.str
+        return d
+
+class IdParam(StringParam):
+    def populate_from_ea(self, ea):
+        super(IdParam, self).populate_from_ea(ea)
+    def encode(self):
+        d = super(IdParam, self).encode()
+        d['_type'] = 'Id'
+        return d
+
+class SymParam(StringParam):
+    def populate_from_ea(self, ea):
+        super(SymParam, self).populate_from_ea(ea)
+    def encode(self):
+        d = super(SymParam, self).encode()
+        d['_type'] = 'Sym'
+        return d
+
+class OnOffParam(Param):
+    def populate_from_ea(self, ea):
+        super(OnOffParam, self).populate_from_ea(ea)
+        self.var = play_with_addr(get_wide_dword(ea + 10))
+    def encode(self):
+        d = super(OnOffParam, self).encode()
+        d['_type'] = 'OnOff'
+        d['var'] = self.var
+        return d
+
+class OffOnParam(Param):
+    def populate_from_ea(self, ea):
+        super(OffOnParam, self).populate_from_ea(ea)
+        self.var = play_with_addr(get_wide_dword(ea + 10))
+    def encode(self):
+        d = super(OffOnParam, self).encode()
+        d['_type'] = 'OffOn'
+        d['var'] = self.var
+        return d
+
+class MaskParam(Param):
+    def populate_from_ea(self, ea):
+        super(MaskParam, self).populate_from_ea(ea)
+        self.size = get_wide_byte(ea + 10)
+        self.ormask = get_wide_dword(ea + 11)
+        self.andmask = get_wide_dword(ea + 15)
+        self.num = play_with_addr(get_wide_dword(ea + 19))
+    def encode(self):
+        d = super(MaskParam, self).encode()
+        d['_type'] = 'Mask'
+        d['size'] = self.size
+        d['ormask'] = self.ormask
+        d['andmask'] = self.andmask
+        d['num'] = self.num
+        return d
+
+class ToggleParam(Param):
+    def populate_from_ea(self, ea):
+        super(ToggleParam, self).populate_from_ea(ea)
+        self.size = get_wide_byte(ea + 10)
+        self.mask = get_wide_dword(ea + 11)
+        self.num = play_with_addr(get_wide_dword(ea + 15))
+    def encode(self):
+        d = super(ToggleParam, self).encode()
+        d['_type'] = 'Toggle'
+        d['size'] = self.size
+        d['mask'] = self.mask
+        d['num'] = self.num
+        return d
+
+class SetParam(Param):
+    def populate_from_ea(self, ea):
+        super(SetParam, self).populate_from_ea(ea)
+        self.size = get_wide_byte(ea + 10)
+        self.value = get_wide_dword(ea + 11)
+        self.num = play_with_addr(get_wide_dword(ea + 15))
+    def encode(self):
+        d = super(SetParam, self).encode()
+        d['_type'] = 'Set'
+        d['size'] = self.size
+        d['value'] = self.value
+        d['num'] = self.num
+        return d
+
+class SetStringParam(Param):
+    def populate_from_ea(self, ea):
+        super(SetStringParam, self).populate_from_ea(ea)
+        self.value = get_wide_dword(ea + 10)
+        self.pstring = get_wide_byte(ea + 14)
+        self.var = play_with_addr(get_wide_dword(ea + 15))
+    def encode(self):
+        d = super(SetStringParam, self).encode()
+        d['_type'] = 'SetString'
+        d['value'] = self.value
+        d['pstring'] = self.pstring
+        d['var'] = self.var
+        return d
+
+class GenericParam(Param):
+    def populate_from_ea(self, ea):
+        super(GenericParam, self).populate_from_ea(ea)
+        self.parse = play_with_addr(get_wide_dword(ea + 10))
+        # self.var = play_with_addr(get_wide_dword(ea + 14))
+        var = get_wide_dword(ea + 14)
+        if get_name(var).startswith('a'):
+            self.var = String.from_ea(var)
+        else:
+            self.var = var
+        self.help = String.from_ea(get_wide_dword(ea + 18))
+    def encode(self):
+        d = super(GenericParam, self).encode()
+        d['_type'] = 'Generic'
+        d['parse'] = self.parse
+        d['var'] = self.var
+        d['help'] = self.help
+        return d
+
+class IfArgParam(Param):
+    def populate_from_ea(self, ea):
+        super(IfArgParam, self).populate_from_ea(ea)
+        self.parg = Param.list_from_ea(get_wide_dword(ea + 10))
+        self.helpa = String.from_ea(get_wide_dword(ea + 14))
+        self.pnone = Param.list_from_ea(get_wide_dword(ea + 18))
+        self.helpn = String.from_ea(get_wide_dword(ea + 22))
+    def encode(self):
+        d = super(IfArgParam, self).encode()
+        d['_type'] = 'IfArg'
+        d['parg'] = self.parg
+        d['helpa'] = self.helpa
+        d['pnone'] = self.pnone
+        d['helpn'] = self.helpn
+        return d
+
+class SettingParam(Param):
+    def populate_from_ea(self, ea):
+        super(SettingParam, self).populate_from_ea(ea)
+        self.parse = play_with_addr(get_wide_dword(ea + 10))
+        self.valuename = String.from_ea(get_wide_dword(ea + 14))
+    def encode(self):
+        d = super(SettingParam, self).encode()
+        d['_type'] = 'Setting'
+        d['parse'] = self.parse
+        d['valuename'] = self.valuename
+        return d
+
+PARAM_CLASSES = [
+    Param,
+    FTypeCreatorParam,
+    FilePathParam,
+    NumberParam,
+    StringParam,
+    IdParam,
+    SymParam,
+    OnOffParam,
+    OffOnParam,
+    MaskParam,
+    ToggleParam,
+    SetParam,
+    SetStringParam,
+    GenericParam,
+    IfArgParam,
+    SettingParam
+]
+
+class Option:
+    name: str
+    names: String
+    avail: int
+    sub: 'OptionList'
+    conflicts: 'OptionList'
+    help: String
+
+    @staticmethod
+    def from_ea(ea):
+        if ea == 0:
+            return None
+        else:
+            o = Option()
+            o.name = get_name(ea)
+            o.names = String.from_ea(get_wide_dword(ea))
+            o.avail = get_wide_dword(ea + 4)
+            o.param = Param.list_from_ea(get_wide_dword(ea + 8))
+            o.sub = OptionList.from_ea(get_wide_dword(ea + 12))
+            o.conflicts = OptionList.from_ea(get_wide_dword(ea + 16), shallow=True)
+            o.help = String.from_ea(get_wide_dword(ea + 20))
+            return o
+
+    @staticmethod
+    def read_list(list_ea, shallow=False):
+        lst = []
+        while True:
+            ea = get_wide_dword(list_ea)
+            if ea == 0:
+                break
+            if shallow:
+                lst.append(get_name(ea))
+            else:
+                lst.append(Option.from_ea(ea))
+            list_ea += 4
+        return lst
+
+    def encode(self):
+        d = dict(_name=self.name, names=self.names, avail=self.avail, param=self.param, help=self.help)
+        if self.sub is not None:
+            d['sub'] = self.sub
+        if self.conflicts is not None:
+            d['conflicts'] = self.conflicts
+        return d
+
+class OptionList:
+    @staticmethod
+    def from_ea(ea, shallow=False):
+        if ea == 0:
+            return None
+        else:
+            ol = OptionList()
+            ol.name = get_name(ea)
+            ol.help = String.from_ea(get_wide_dword(ea))
+            ol.flags = get_wide_dword(ea + 4)
+            list_ea = get_wide_dword(ea + 8)
+            if list_ea != 0:
+                ol.list_name = get_name(list_ea)
+                ol.list = Option.read_list(list_ea, shallow)
+            return ol
+
+    def dump(self):
+        print(f'OptionList({self.name})')
+
+    def encode(self):
+        d = dict(_name=self.name, flags=self.flags, _list_name=self.list_name, list=self.list)
+        if self.help is not None:
+            d['help'] = self.help
+        return d
+
+def get_optlist_eas():
+    ea = get_name_ea_simple('_optLists')
+    lists = []
+    while True:
+        list_ea = get_wide_dword(ea)
+        if list_ea == 0:
+            break
+        # list_name = get_name(list_ea)
+        lists.append(list_ea)
+        ea += 4
+    return lists
+
+optlists = []
+for ea in get_optlist_eas():
+    optlists.append(OptionList.from_ea(ea))
+
+def enc(obj):
+    if hasattr(obj, 'encode'):
+        return obj.encode()
+    else:
+        raise TypeError
+
+with open('/Users/ash/src/mwcc/opts.json', 'w') as f:
+    json.dump(optlists, f, sort_keys=True, indent=4, default=enc)
diff --git a/osx_build.sh b/osx_build.sh
new file mode 100755
index 0000000..7847f47
--- /dev/null
+++ b/osx_build.sh
@@ -0,0 +1,89 @@
+set -e
+export MWCIncludes=/usr/include
+
+#rm objs/*
+
+MWC_FLAGS="-c -g -opt l=4,noschedule,speed -enum min -Iincludes -Isdk_hdrs -w all,nounused -wchar_t on -bool off -Cpp_exceptions off"
+
+#~/bin/mwccppc $MWC_FLAGS -o objs/WarningHelpers.o command_line/C++_Parser/Src/Library/WarningHelpers.c
+#
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLCompilerLinkerDropin_V10.o command_line/CmdLine/Src/Callbacks/CLCompilerLinkerDropin_V10.cpp
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLDropinCallbacks_V10.o command_line/CmdLine/Src/Callbacks/CLDropinCallbacks_V10.cpp
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLParserCallbacks_V1.o command_line/CmdLine/Src/Callbacks/CLParserCallbacks_V1.cpp
+#
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLStaticMain.o command_line/CmdLine/Src/Clients/CLStaticMain.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/ClientGlue.o command_line/CmdLine/Src/Clients/ClientGlue.c
+#
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLErrors.o command_line/CmdLine/Src/Envir/CLErrors.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLIO.o command_line/CmdLine/Src/Envir/CLIO.c
+#
+#~/bin/mwccppc $MWC_FLAGS -o objs/ErrMgr.o command_line/CmdLine/Src/MacEmul/ErrMgr.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/Files.o command_line/CmdLine/Src/MacEmul/Files.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/LowMem.o command_line/CmdLine/Src/MacEmul/LowMem.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/Memory.o command_line/CmdLine/Src/MacEmul/Memory.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/Resources.o command_line/CmdLine/Src/MacEmul/Resources.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/ResourceStrings.o command_line/CmdLine/Src/MacEmul/ResourceStrings.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/TextUtils.o command_line/CmdLine/Src/MacEmul/TextUtils.c
+#
+#~/bin/mwccppc $MWC_FLAGS -o objs/FileHandles.o command_line/CmdLine/Src/OSLib/FileHandles.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/Generic.o command_line/CmdLine/Src/OSLib/Generic.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/MacFileTypes.o command_line/CmdLine/Src/OSLib/MacFileTypes.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/MacSpecs.o command_line/CmdLine/Src/OSLib/MacSpecs.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/MemUtils.o command_line/CmdLine/Src/OSLib/MemUtils.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/Posix.o command_line/CmdLine/Src/OSLib/Posix.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/StringExtras.o command_line/CmdLine/Src/OSLib/StringExtras.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/StringUtils.o command_line/CmdLine/Src/OSLib/StringUtils.c
+#
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLPlugins.o command_line/CmdLine/Src/Plugins/CLPlugins.c
+#
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLAccessPaths.o command_line/CmdLine/Src/Project/CLAccessPaths.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLFiles.o command_line/CmdLine/Src/Project/CLFiles.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLOverlays.o command_line/CmdLine/Src/Project/CLOverlays.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLProj.o command_line/CmdLine/Src/Project/CLProj.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLSegs.o command_line/CmdLine/Src/Project/CLSegs.c
+#
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLBrowser.o command_line/CmdLine/Src/CLBrowser.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLDependencies.o command_line/CmdLine/Src/CLDependencies.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLFileOps.o command_line/CmdLine/Src/CLFileOps.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLIncludeFileCache.o command_line/CmdLine/Src/CLIncludeFileCache.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLLicenses.o command_line/CmdLine/Src/CLLicenses.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLLoadAndCache.o command_line/CmdLine/Src/CLLoadAndCache.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLMain.o command_line/CmdLine/Src/CLMain.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLPluginRequests.o command_line/CmdLine/Src/CLPluginRequests.cpp
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLPrefs.o command_line/CmdLine/Src/CLPrefs.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLTarg.o command_line/CmdLine/Src/CLTarg.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLToolExec.o command_line/CmdLine/Src/CLToolExec.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/CLWriteObjectFile.o command_line/CmdLine/Src/CLWriteObjectFile.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/uFileTypeMappings.o command_line/CmdLine/Src/uFileTypeMappings.c
+#
+#~/bin/mwccppc $MWC_FLAGS -o objs/ParserGlue-mach-ppc-cc.o compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-cc.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/TargetWarningHelpers-ppc-cc.o compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/TargetWarningHelpers-ppc-cc.c
+#
+#~/bin/mwccppc $MWC_FLAGS -o objs/cc-mach-ppc.o compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/cc-mach-ppc.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/libimp-mach-ppc.o compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/libimp-mach-ppc.c
+#
+#~/bin/mwccppc $MWC_FLAGS -o objs/cc-mach-ppc-mw.o compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Static/cc-mach-ppc-mw.c
+#
+#~/bin/mwccppc $MWC_FLAGS -o objs/Arguments.o unsorted/Arguments.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/Help.o unsorted/Help.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/IO.o unsorted/IO.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/OptimizerHelpers.o unsorted/OptimizerHelpers.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/Option.o unsorted/Option.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/Parameter.o unsorted/Parameter.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/ParserErrors.o unsorted/ParserErrors.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/ParserFace.o unsorted/ParserFace.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/ParserHelpers.o unsorted/ParserHelpers.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/ParserHelpers-cc.o unsorted/ParserHelpers-cc.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/Projects.o unsorted/Projects.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/StaticParserGlue.o unsorted/StaticParserGlue.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/Targets.o unsorted/Targets.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/TargetOptimizer-ppc-mach.o unsorted/TargetOptimizer-ppc-mach.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/ToolHelpers.o unsorted/ToolHelpers.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/ToolHelpers-cc.o unsorted/ToolHelpers-cc.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/uContext1.o unsorted/uContext1.cpp
+#~/bin/mwccppc $MWC_FLAGS -o objs/uContextCL.o unsorted/uContextCL.cpp
+#~/bin/mwccppc $MWC_FLAGS -o objs/uContextParser.o unsorted/uContextParser.cpp
+#~/bin/mwccppc $MWC_FLAGS -o objs/uContextSecret.o unsorted/uContextSecret.cpp
+#~/bin/mwccppc $MWC_FLAGS -o objs/uCOS.o unsorted/uCOS.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/uLibImporter.o unsorted/uLibImporter.c
+#~/bin/mwccppc $MWC_FLAGS -o objs/Utils.o unsorted/Utils.c
diff --git a/sdk_hdrs/CompilerMapping.h b/sdk_hdrs/CompilerMapping.h
index 30ee355..c929a74 100755
--- a/sdk_hdrs/CompilerMapping.h
+++ b/sdk_hdrs/CompilerMapping.h
@@ -1 +1 @@
-/*
 *  CompilerMapping.h - File Type & Extension => Compiler Mapping for Metrowerks CodeWarriorª
 *
 *  Copyright © 1995 Metrowerks, Inc.  All rights reserved.
 *	
 */

#ifndef __COMPILERMAPPING_H__
#define __COMPILERMAPPING_H__

#ifdef __MWERKS__
#	pragma once
#endif

#ifndef __CWPLUGINS_H__
#include "CWPlugins.h"
#endif

#ifdef __MWERKS__
#pragma options align=mac68k
#endif

#ifdef	_MSC_VER
#pragma	pack(push,2)
#endif

#ifdef __cplusplus
	extern "C" {
#endif

#ifdef __cplusplus
	const CWDataType Lang_C_CPP		= CWFOURCHAR('c','+','+',' ');
	const CWDataType Lang_Pascal	= CWFOURCHAR('p','a','s','c');
	const CWDataType Lang_Rez		= CWFOURCHAR('r','e','z',' ');
	const CWDataType Lang_Java		= CWFOURCHAR('j','a','v','a');
	const CWDataType Lang_MISC		= CWFOURCHAR('\?','\?','\?','\?');
#else
	#define Lang_C_CPP			CWFOURCHAR('c','+','+',' ')
	#define Lang_Pascal			CWFOURCHAR('p','a','s','c')
	#define Lang_Rez			CWFOURCHAR('r','e','z',' ')
	#define Lang_Java			CWFOURCHAR('j','a','v','a')
	#define Lang_MISC			CWFOURCHAR('\?','\?','\?','\?')
#endif

/* Compiler flags, as used in member dropinflags of struct DropInFlags returned by compilers		*/
enum
{
	kGeneratescode   =  1L << 31,		/* this compiler generates code							*/
	kGeneratesrsrcs  =  1L << 30,		/* this compiler generates resources					*/
	kCanpreprocess   =  1L << 29,		/* this compiler can accept a Preprocess request		*/
	kCanprecompile   =  1L << 28,		/* this compiler can accept a Precompile request		*/
	kIspascal        =  1L << 27,		/* this is the pascal compiler							*/
	kCanimport       =  1L << 26,		/* this compiler needs the "Import Weak" popup			*/
	kCandisassemble  =  1L << 25,		/* this compiler can disassemble 						*/
	kPersistent      =  1L << 24,		/* keep the compiler resident except on context switches*/
    kCompAllowDupFileNames = 1L << 23,	/* allow multiple project files with the same name  	*/
    kCompMultiTargAware  =  1L << 22,	/* the compiler can be used with multiple targets		*/
	kIsMPAware		=  1L << 21,		/* the compiler can be run in an MP thread				*/
	kCompUsesTargetStorage = 1L << 20,	/* the compiler keeps storage per target				*/
	kCompEmitsOwnBrSymbols = 1L << 19,	/* browser info includes compiler-specific symbols		*/
	kCompAlwaysReload = 1L << 18,		/* always reload the compiler before request			*/
	kCompRequiresProjectBuildStartedMsg   = 1L << 17,  /*  Compiler listens for  project build started messages     */
	kCompRequiresTargetBuildStartedMsg = 1L << 16,     /*  Compiler listens for  target build started messages      */
	kCompRequiresSubProjectBuildStartedMsg = 1L << 15, /*  Compiler listens for  Sub project build started messages */
	kCompRequiresFileListBuildStartedMsg = 1L << 14,    /*  Compiler listens for  filelist build started messages    */  
	kCompReentrant = 1L << 13,			/* Compiler can use re-entrant DropIn and is re-entry safe */
	kCompSavesDbgPreprocess = 1 << 12,	/* Compiler will save preprocessed files for debugging needs */
	kCompRequiresTargetCompileStartedMsg = 1 << 11	/* Compiler listens for target compile started/ended messages */
	/* remaining flags are reserved for future use and should be zero-initialized				                    */
};

/* Compiler mapping flags, used in CompilerMapping.flags & CWExtensionMapping.flags		*/
typedef unsigned long CompilerMappingFlags;
enum
{
	kPrecompile = 1L << 31,		/* should this file type be Precompiled?				*/
	kLaunchable = 1L << 30,		/* can this file type be double-clicked on?				*/
	kRsrcfile   = 1L << 29,		/* does this file type contain resources for linking?	*/
	kIgnored    = 1L << 28		/* should files of this type be ignored during Make?	*/
	/* remaining flags are reserved for future use and should be zero-initialized		*/
};

/* Format of data in 'EMap' resource, or as returned by  a compiler's 							*/
/* GetExtensionMapping entry point																*/

typedef struct CWExtensionMapping {
	CWDataType		type;				/* MacOS file type, e.g. 'TEXT' or 0					*/
	char			extension[32];		/* file extension, e.g. .c/.cp/.pch or ""				*/
	CompilerMappingFlags flags;			/* see above											*/
	char			editlanguage[32];	/* edit language or "" to use default language for plugin */
} CWExtensionMapping;

#define kCurrentCWExtMapListVersion	2
#define kCurrentCWExtMapListResourceVersion 2

typedef struct CWExtMapList {
	short					version;
	short					nMappings;
	CWExtensionMapping*		mappings;
} CWExtMapList;

/* Format of data returned by GetTargetList entry point									*/

#define kCurrentCWTargetListVersion	1
#define kCurrentCWTargetListResourceVersion 1

typedef struct CWTypeList {
	short		count;
	CWDataType	items[1];
} CW_CPUList, CW_OSList;

typedef struct CWTargetList {
	short		version;
	short		cpuCount;
	CWDataType*	cpus;
	short		osCount;
	CWDataType*	oss;
} CWTargetList;

typedef struct CWTargetListResource {
	short		version;
	CW_CPUList	cpus;
	CW_OSList	oss;
} CWTargetListResource;


#ifdef __cplusplus
	}
#endif

#ifdef	_MSC_VER
#pragma	pack(pop,2)
#endif

#ifdef	__MWERKS__
#pragma options align=reset
#endif

#endif	/* __COMPILERMAPPING_H__ */
\ No newline at end of file
+/*
 *  CompilerMapping.h - File Type & Extension => Compiler Mapping for Metrowerks CodeWarrior�
 *
 *  Copyright � 1995 Metrowerks, Inc.  All rights reserved.
 *	
 */

#ifndef __COMPILERMAPPING_H__
#define __COMPILERMAPPING_H__

#ifdef __MWERKS__
#	pragma once
#endif

#ifndef __CWPLUGINS_H__
#include "CWPlugins.h"
#endif

#ifdef __MWERKS__
#pragma options align=mac68k
#endif

#ifdef	_MSC_VER
#pragma	pack(push,2)
#endif

#ifdef __cplusplus
	extern "C" {
#endif

#ifdef __cplusplus
	const CWDataType Lang_C_CPP		= CWFOURCHAR('c','+','+',' ');
	const CWDataType Lang_Pascal	= CWFOURCHAR('p','a','s','c');
	const CWDataType Lang_Rez		= CWFOURCHAR('r','e','z',' ');
	const CWDataType Lang_Java		= CWFOURCHAR('j','a','v','a');
	const CWDataType Lang_MISC		= CWFOURCHAR('\?','\?','\?','\?');
#else
	#define Lang_C_CPP			CWFOURCHAR('c','+','+',' ')
	#define Lang_Pascal			CWFOURCHAR('p','a','s','c')
	#define Lang_Rez			CWFOURCHAR('r','e','z',' ')
	#define Lang_Java			CWFOURCHAR('j','a','v','a')
	#define Lang_MISC			CWFOURCHAR('\?','\?','\?','\?')
#endif

/* Compiler flags, as used in member dropinflags of struct DropInFlags returned by compilers		*/
enum
{
	kGeneratescode   =  1L << 31,		/* this compiler generates code							*/
	kGeneratesrsrcs  =  1L << 30,		/* this compiler generates resources					*/
	kCanpreprocess   =  1L << 29,		/* this compiler can accept a Preprocess request		*/
	kCanprecompile   =  1L << 28,		/* this compiler can accept a Precompile request		*/
	kIspascal        =  1L << 27,		/* this is the pascal compiler							*/
	kCanimport       =  1L << 26,		/* this compiler needs the "Import Weak" popup			*/
	kCandisassemble  =  1L << 25,		/* this compiler can disassemble 						*/
	kPersistent      =  1L << 24,		/* keep the compiler resident except on context switches*/
    kCompAllowDupFileNames = 1L << 23,	/* allow multiple project files with the same name  	*/
    kCompMultiTargAware  =  1L << 22,	/* the compiler can be used with multiple targets		*/
	kIsMPAware		=  1L << 21,		/* the compiler can be run in an MP thread				*/
	kCompUsesTargetStorage = 1L << 20,	/* the compiler keeps storage per target				*/
	kCompEmitsOwnBrSymbols = 1L << 19,	/* browser info includes compiler-specific symbols		*/
	kCompAlwaysReload = 1L << 18,		/* always reload the compiler before request			*/
	kCompRequiresProjectBuildStartedMsg   = 1L << 17,  /*  Compiler listens for  project build started messages     */
	kCompRequiresTargetBuildStartedMsg = 1L << 16,     /*  Compiler listens for  target build started messages      */
	kCompRequiresSubProjectBuildStartedMsg = 1L << 15, /*  Compiler listens for  Sub project build started messages */
	kCompRequiresFileListBuildStartedMsg = 1L << 14,    /*  Compiler listens for  filelist build started messages    */  
	kCompReentrant = 1L << 13,			/* Compiler can use re-entrant DropIn and is re-entry safe */
	kCompSavesDbgPreprocess = 1 << 12,	/* Compiler will save preprocessed files for debugging needs */
	kCompRequiresTargetCompileStartedMsg = 1 << 11	/* Compiler listens for target compile started/ended messages */
	/* remaining flags are reserved for future use and should be zero-initialized				                    */
};

/* Compiler mapping flags, used in CompilerMapping.flags & CWExtensionMapping.flags		*/
typedef unsigned long CompilerMappingFlags;
enum
{
	kPrecompile = 1L << 31,		/* should this file type be Precompiled?				*/
	kLaunchable = 1L << 30,		/* can this file type be double-clicked on?				*/
	kRsrcfile   = 1L << 29,		/* does this file type contain resources for linking?	*/
	kIgnored    = 1L << 28		/* should files of this type be ignored during Make?	*/
	/* remaining flags are reserved for future use and should be zero-initialized		*/
};

/* Format of data in 'EMap' resource, or as returned by  a compiler's 							*/
/* GetExtensionMapping entry point																*/

typedef struct CWExtensionMapping {
	CWDataType		type;				/* MacOS file type, e.g. 'TEXT' or 0					*/
	char			extension[32];		/* file extension, e.g. .c/.cp/.pch or ""				*/
	CompilerMappingFlags flags;			/* see above											*/
} CWExtensionMapping;

#define kCurrentCWExtMapListVersion	1
#define kCurrentCWExtMapListResourceVersion 1

typedef struct CWExtMapList {
	short					version;
	short					nMappings;
	CWExtensionMapping*		mappings;
} CWExtMapList;

/* Format of data returned by GetTargetList entry point									*/

#define kCurrentCWTargetListVersion	1
#define kCurrentCWTargetListResourceVersion 1

typedef struct CWTypeList {
	short		count;
	CWDataType	items[1];
} CW_CPUList, CW_OSList;

typedef struct CWTargetList {
	short		version;
	short		cpuCount;
	CWDataType*	cpus;
	short		osCount;
	CWDataType*	oss;
} CWTargetList;

typedef struct CWTargetListResource {
	short		version;
	CW_CPUList	cpus;
	CW_OSList	oss;
} CWTargetListResource;


#ifdef __cplusplus
	}
#endif

#ifdef	_MSC_VER
#pragma	pack(pop,2)
#endif

#ifdef	__MWERKS__
#pragma options align=reset
#endif

#endif	/* __COMPILERMAPPING_H__ */
\ No newline at end of file
diff --git a/setup.sh b/setup.sh
index cdeab68..5c2db99 100644
--- a/setup.sh
+++ b/setup.sh
@@ -1,3 +1,10 @@
 #export MWCIncludes=/Applications/Metrowerks\ CodeWarrior\ 7.0/Metrowerks\ CodeWarrior/MacOS\ Support/Universal/Interfaces/CIncludes:/Applications/Metrowerks\ CodeWarrior\ 7.0/Metrowerks\ CodeWarrior/MSL/MSL_C/MSL_Common/Include
-export MWCIncludes=/usr/include
+export MWCIncludes=/usr/include:/Applications/Metrowerks\ CodeWarrior\ 7.0/Metrowerks\ CodeWarrior/MSL/MSL_C/MSL_Common/Include:/Applications/Metrowerks\ CodeWarrior\ 7.0/Metrowerks\ CodeWarrior/MSL/MSL_C/MSL_MacOS/Include:/Applications/Metrowerks\ CodeWarrior\ 7.0/Metrowerks\ CodeWarrior/MSL/MSL_C++/MSL_Common/Include
+export MWLibraries=libs:/Applications/Metrowerks\ CodeWarrior\ 7.0/Metrowerks\ CodeWarrior/MacOS\ X\ Support/Libraries/Runtime/Libs:/Applications/Metrowerks\ CodeWarrior\ 7.0/Metrowerks\ CodeWarrior/MSL/MSL_C++/MSL_MacOS/Lib/Mach-O:/usr/lib:/
+export MWLibraryFiles=MSL_Runtime_Mach-O.a:MSL_C++_Mach-O.a
+export MWFrameworkPaths=/System/Library/Frameworks
+export MWFrameworkVersions=System
 #export MWCIncludes=/Applications/Metrowerks\ CodeWarrior\ 7.0/Metrowerks\ CodeWarrior/MacOS\ X\ Support/MacHeaders\ Mach-O
+
+# the defaults break on Tiger haha
+export MWFrameworkVersions=""
diff --git a/Arguments.c b/unsorted/Arguments.c
index 324965a..c427a5a 100644
--- a/Arguments.c
+++ b/unsorted/Arguments.c
@@ -1,4 +1,4 @@
-#include "includes/mwcc_decomp.h"
+#include "parser.h"
 
 char compat;
 char *MAINOPTCHAR;
@@ -27,19 +27,6 @@ anon0_50 linkargs;
 anon0_50 prelinkargs;
 anon0_50 postlinkargs;
 
-// TODO move me
-/*extern int OS_MakeFileSpec(const char *name, struct OSSpec *spec);
-extern int OS_NewFileHandle(struct OSSpec *spec, int a, int b, OSFileHandle *fh);
-extern int OS_AppendHandle(struct OSHandle *h, const void *, long);
-extern int OS_LockFileHandle(OSFileHandle *fh, char **h, unsigned long *size);
-extern void OS_FreeFileHandle(OSFileHandle *fh);
-extern void CLPOSAlert(short code, short code2, ...);
-extern void CLPReportError(short code, ...);
-extern void CLPReportWarning(short code, ...);
-extern void CLPFatalError(const char *format, ...);
-extern int ustrncmp(const char *a, const char *b, int len);*/
-// TODO move me
-
 static void Arg_AddToken(short val, char *text);
 static void Arg_Setup(int argc, char **argv);
 static void Arg_SkipRespFileWS();
@@ -64,7 +51,7 @@ static void Arg_AddToken(short val, char *text) {
     else
         prev = 0;
 
-    if (prev && prev->val == ATK_2 && prev->text[0] == 0) {
+    if (prev && prev->val == ATK_ARG && prev->text[0] == 0) {
         pppprev = ppprev = pprev = 0;
         if (numargtoks > 3)
             pppprev = &argtoks[numargtoks - 4];
@@ -74,12 +61,12 @@ static void Arg_AddToken(short val, char *text) {
             pprev = &argtoks[numargtoks - 2];
 
         if (pprev) {
-            if ((int) val == ATK_1 && (pprev->val == ATK_5 || pprev->val == ATK_4) && (ppprev->val != ATK_2 || pppprev->val != ATK_3)) {
+            if ((int) val == ATK_ARG_END && (pprev->val == ATK_COMMA || pprev->val == ATK_EQUALS) && (ppprev->val != ATK_ARG || pppprev->val != ATK_OPTION)) {
                 if (parserDebug)
                     printf("Coalescing args with '%s'\n", Arg_GetTokenName(pprev));
                 val = pprev->val;
                 numargtoks -= 2;
-            } else if (pprev->val == ATK_1 && ((int) val == ATK_5 || (int) val == ATK_4)) {
+            } else if (pprev->val == ATK_ARG_END && ((int) val == ATK_COMMA || (int) val == ATK_EQUALS)) {
                 if (parserDebug)
                     printf("Coalescing args, removing '%s'\n", Arg_GetTokenName(pprev));
                 numargtoks -= 2;
@@ -142,7 +129,7 @@ static unsigned char Arg_OpenRespFile(const char *name) {
             || (err = OS_AppendHandle(&respfilehandle.hand, "", 1))
             || (err = OS_LockFileHandle(&respfilehandle, &respfile, &respfilesize))
             ) {
-        CLPOSAlert(74, (short) err, "response ", name);
+        CLPOSAlert(CLPStr74, (short) err, "response ", name);
         return 0;
     } else {
         respfilestart = respfile;
@@ -255,7 +242,7 @@ static void Arg_Parse() {
 
         if (arg[0] && arg[1] && strchr(MAINOPTCHAR, arg[0])) {
             if (isOpt)
-                Arg_AddToken(ATK_1, 0);
+                Arg_AddToken(ATK_ARG_END, 0);
             buffer[0] = arg[1];
             buffer[1] = 0;
             isOpt = 1;
@@ -279,19 +266,19 @@ static void Arg_Parse() {
                     ch &= 0x7F;
                 *(bufptr++) = ch;
                 if (bufptr >= &buffer[sizeof(buffer)]) {
-                    CLPReportError(2, argstart, argstart + strlen(argstart) - 15, sizeof(buffer));
+                    CLPReportError(CLPStr2, argstart, argstart + strlen(argstart) - 15, sizeof(buffer));
                 }
                 *bufptr = 0;
             } else {
                 if (isOpt) {
-                    Arg_AddToken(ATK_3, buffer);
-                    Arg_AddToken(ATK_2, buffer);
+                    Arg_AddToken(ATK_OPTION, buffer);
+                    Arg_AddToken(ATK_ARG, buffer);
                 } else {
-                    Arg_AddToken(ATK_2, buffer);
+                    Arg_AddToken(ATK_ARG, buffer);
                 }
 
                 Arg_AddToken(
-                        (unsigned char) ((ch == ',') ? ATK_5 : (((ch == '=') || (ch == SEP3)) ? ATK_4 : ATK_0)),
+                        (unsigned char) ((ch == ',') ? ATK_COMMA : (((ch == '=') || (ch == SEP3)) ? ATK_EQUALS : ATK_END)),
                         0
                 );
 
@@ -308,17 +295,17 @@ static void Arg_Parse() {
 
         // 1799C8
         if (isOpt && bufptr > &buffer[0]) {
-            Arg_AddToken(ATK_3, buffer + (isList && strchr(MAINOPTCHAR, buffer[0])));
-            Arg_AddToken(ATK_2, buffer + (isList && strchr(MAINOPTCHAR, buffer[0])) + 1);
+            Arg_AddToken(ATK_OPTION, buffer + (isList && strchr(MAINOPTCHAR, buffer[0])));
+            Arg_AddToken(ATK_ARG, buffer + (isList && strchr(MAINOPTCHAR, buffer[0])) + 1);
         } else {
-            Arg_AddToken(ATK_2, buffer);
-            Arg_AddToken(ATK_1, 0);
+            Arg_AddToken(ATK_ARG, buffer);
+            Arg_AddToken(ATK_ARG_END, 0);
         }
     }
 
     if (isOpt || isList)
-        Arg_AddToken(ATK_1, 0);
-    Arg_AddToken(ATK_0, 0);
+        Arg_AddToken(ATK_ARG_END, 0);
+    Arg_AddToken(ATK_END, 0);
 }
 
 enum {
@@ -423,12 +410,12 @@ void Arg_Stop(ArgToken *where) {
         cur = &argtoks[--numargtoks];
         if (cur->text)
             free(cur->text);
-        cur->val = ATK_0;
+        cur->val = ATK_END;
         cur->text = 0;
     }
 
-    argtoks[numargtoks++].val = ATK_1;
-    argtoks[numargtoks++].val = ATK_0;
+    argtoks[numargtoks++].val = ATK_ARG_END;
+    argtoks[numargtoks++].val = ATK_END;
     scantok = numargtoks - 2;
 }
 
@@ -449,7 +436,7 @@ int Arg_IsEmpty() {
     ArgToken *tok;
 
     tok = Arg_PeekToken();
-    return (tok == 0 || tok->val == ATK_0);
+    return (tok == 0 || tok->val == ATK_END);
 }
 
 ArgToken *Arg_GetToken() {
@@ -471,16 +458,16 @@ ArgToken *Arg_UndoToken() {
 }
 
 const char *Arg_GetTokenName(ArgToken *tok) {
-    if ((int) tok->val == ATK_2)
+    if ((int) tok->val == ATK_ARG)
         return tok->text;
 
     return
-            ((int) tok->val == ATK_3) ? "option" :
-            ((int) tok->val == ATK_5) ? "comma" :
-            (((int) compat == COMPAT_1 && (int) tok->val == ATK_4)) ? "colon or equals" :
-            (((int) compat != COMPAT_1 && (int) tok->val == ATK_4)) ? "equals" :
-            ((int) tok->val == ATK_1) ? "end of argument" :
-            ((int) tok->val == ATK_0) ? "end of command line" :
+            ((int) tok->val == ATK_OPTION) ? "option" :
+            ((int) tok->val == ATK_COMMA) ? "comma" :
+            (((int) compat == COMPAT_1 && (int) tok->val == ATK_EQUALS)) ? "colon or equals" :
+            (((int) compat != COMPAT_1 && (int) tok->val == ATK_EQUALS)) ? "equals" :
+            ((int) tok->val == ATK_ARG_END) ? "end of argument" :
+            ((int) tok->val == ATK_END) ? "end of command line" :
             "<error>";
 }
 
@@ -491,7 +478,7 @@ const char *Arg_GetTokenText(ArgToken *tok, char *buffer, int maxlen, unsigned c
 
     bptr = buffer;
     curlen = 0;
-    if (tok->val == ATK_2 || tok->val == ATK_3)
+    if (tok->val == ATK_ARG || tok->val == ATK_OPTION)
         ptr = tok->text;
     else
         ptr = Arg_GetTokenName(tok);
@@ -505,7 +492,7 @@ const char *Arg_GetTokenText(ArgToken *tok, char *buffer, int maxlen, unsigned c
     } else {
         bptr[-1] = 0;
         if (warn)
-            CLPReportWarning(56, buffer, ptr + strlen(ptr) - ((maxlen <= 32) ? maxlen : 32), maxlen);
+            CLPReportWarning(CLPStr56, buffer, ptr + strlen(ptr) - ((maxlen <= 32) ? maxlen : 32), maxlen);
     }
 
     return buffer;
@@ -550,23 +537,23 @@ void Arg_InitToolArgs(anon0_50 *ta) {
 
 void Arg_AddToToolArgs(anon0_50 *ta, short tokval, char *toktxt) {
     switch (tokval) {
-        case ATK_0:
+        case ATK_END:
             Arg_FinishToolArgs(ta);
             break;
-        case ATK_1:
+        case ATK_ARG_END:
             if (ta->argv && ta->argv[ta->argc])
                 Arg_GrowArgs(ta);
             break;
-        case ATK_2:
+        case ATK_ARG:
             Arg_GrowArg(ta, toktxt);
             break;
-        case ATK_3:
+        case ATK_OPTION:
             Arg_GrowArg(ta, "-");
             break;
-        case ATK_4:
+        case ATK_EQUALS:
             Arg_GrowArg(ta, "=");
             break;
-        case ATK_5:
+        case ATK_COMMA:
             Arg_GrowArg(ta, ",");
             break;
         default:
diff --git a/Help.c b/unsorted/Help.c
index aaa4e9f..ceeb278 100644
--- a/Help.c
+++ b/unsorted/Help.c
@@ -1,4 +1,5 @@
-#include "includes/mwcc_decomp.h"
+#include "parser.h"
+
 typedef struct _Side {
     short offset;
     short width;
@@ -8,12 +9,12 @@ typedef struct _Side {
     short indent;
     short vrow;
     short vcol;
-    unsigned char atEOL;
-    unsigned char impInd;
+    Boolean atEOL;
+    Boolean impInd;
 } Side;
 
 short helpExtras;
-unsigned char showedHelp;
+Boolean showedHelp;
 Side left;
 Side right;
 Side all;
@@ -217,7 +218,7 @@ int Help_Option(struct OptionList *lst, struct Option *opt, int subprint, const
     if (!(parseopts.helpFlags & HELPFLAGS_NORMAL) && !(opt->avail & OTF_ALL_HIDDEN_BY_DEFAULT))
         return 0;
 
-    if (opt->help || (opt->avail & OTF8000)) {
+    if (opt->help || (opt->avail & OTF_HAS_SUB_OPTIONS)) {
         allNoArgs = 1;
         lastparam = 0;
         if (parseopts.helpFlags & HELPFLAGS_SPACES)
@@ -239,7 +240,7 @@ int Help_Option(struct OptionList *lst, struct Option *opt, int subprint, const
                 slflags = slflags | SLFLAGS_20;
                 break;
         }
-        if (opt->avail & OTF2)
+        if (opt->avail & OTF_STICKY)
             slflags = slflags | SLFLAGS_40;
 
         Utils_SpellList(opt->names[0] ? opt->names : "...", pfbuf, slflags);
@@ -323,7 +324,7 @@ int Help_Option(struct OptionList *lst, struct Option *opt, int subprint, const
                                 Side_Print(&left, "[%s", (scan != firstparam) ? "," : subprint ? "=" : SEPOPTSTR);
                             }
                         } else {
-                            Side_Print(&left, (scan != firstparam) ? "," : subprint ? "=" : ((opt->avail & OTF2) && !strchr(opt->names, '|')) ? "" : SEPOPTSTR);
+                            Side_Print(&left, (scan != firstparam) ? "," : subprint ? "=" : ((opt->avail & OTF_STICKY) && !strchr(opt->names, '|')) ? "" : SEPOPTSTR);
                         }
                         Side_Print(&left, "%s", desc);
                         if (((scan->flags & PARAMFLAGS_3) == PARAMFLAGS_2) && scan->which != PARAMWHICH_Setting && scan->which != PARAMWHICH_IfArg) {
@@ -335,7 +336,7 @@ int Help_Option(struct OptionList *lst, struct Option *opt, int subprint, const
                             else
                                 Side_Print(&right, "; if parameter specified, %s", help);
                         }
-                        if (defaul && !(opt->avail & OTF2000)) {
+                        if (defaul && !(opt->avail & OTF_HIDE_DEFAULT)) {
                             if (firstparam == scan)
                                 Side_Print(&right, "; default is %s", defaul);
                             else
@@ -347,7 +348,7 @@ int Help_Option(struct OptionList *lst, struct Option *opt, int subprint, const
                 scan = scan->next;
             }
 
-            if (allNoArgs && !(opt->avail & OTF2000)) {
+            if (allNoArgs && !(opt->avail & OTF_HIDE_DEFAULT)) {
                 PARAM_T *scan = opt->param;
                 Boolean isdefault = scan ? 1 : 0;
                 while (scan && isdefault) {
@@ -363,15 +364,15 @@ int Help_Option(struct OptionList *lst, struct Option *opt, int subprint, const
         if (opt->avail & OTF_MEANINGLESS)
             Side_Print(&right, "; meaningless for this target");
 
-        if ((opt->avail & OTF8000) && opt->sub) {
+        if ((opt->avail & OTF_HAS_SUB_OPTIONS) && opt->sub) {
             if (!allNoArgs) {
                 Side_Print(
                         &left,
                         "%s",
-                        (opt->avail & OTF10000) ? ((lastparam->flags & PARAMFLAGS_8) ? "[=" : "[,") : ((lastparam->flags & PARAMFLAGS_8) ? "," : "=")
+                        (opt->avail & OTF_SUB_OPTIONS_OPTIONAL) ? ((lastparam->flags & PARAMFLAGS_8) ? "[=" : "[,") : ((lastparam->flags & PARAMFLAGS_8) ? "," : "=")
                         );
-            } else if (!(opt->avail & OTF2)) {
-                if (opt->avail & OTF10000) {
+            } else if (!(opt->avail & OTF_STICKY)) {
+                if (opt->avail & OTF_SUB_OPTIONS_OPTIONAL) {
                     if (SEPOPTSTR[0] == ' ')
                         Side_Print(&left, subprint ? "[=" : " [");
                     else
@@ -380,7 +381,7 @@ int Help_Option(struct OptionList *lst, struct Option *opt, int subprint, const
                     Side_Print(&left, "%c", subprint ? '=' : SEPOPTSTR[0]);
                 }
             } else {
-                if (opt->avail & OTF10000) {
+                if (opt->avail & OTF_SUB_OPTIONS_OPTIONAL) {
                     Side_Print(&left, subprint ? "[" : (SEPOPTSTR[0] == ' ') ? " [" : "[");
                 }
             }
@@ -390,7 +391,7 @@ int Help_Option(struct OptionList *lst, struct Option *opt, int subprint, const
                     "%s%s%s",
                     opt->sub->help ? opt->sub->help : "keyword",
                     (opt->sub->flags & PARAMFLAGS_1) ? "" : "[,...]",
-                    (opt->avail & OTF10000) ? "]" : ""
+                    (opt->avail & OTF_SUB_OPTIONS_OPTIONAL) ? "]" : ""
             );
 
             Side_Print(&left, "\t");
diff --git a/unsorted/IO.c b/unsorted/IO.c
index 7ef3cb1..36d809b 100644
--- a/unsorted/IO.c
+++ b/unsorted/IO.c
@@ -1,4 +1,4 @@
-#include "mwcc_decomp.h"
+#include "parser.h"
 
 void ShowTextHandle(const char *description, Handle text) {
     CWMemHandle mh;
@@ -32,8 +32,8 @@ void ShowVersion(Boolean decorate) {
     }
 
     for (x = 0; x < parseopts.numPlugins; x++) {
-        if (parseopts.plugins[x].plugintype == CWFOURCHAR('c','l','d','r')) continue;
-        if (parseopts.plugins[x].plugintype == CWFOURCHAR('P','a','r','s')) continue;
+        if (parseopts.plugins[x].plugintype == CWDROPINDRIVERTYPE) continue;
+        if (parseopts.plugins[x].plugintype == CWDROPINPARSERTYPE) continue;
 
         if (pTool->TYPE == parseopts.plugins[x].plugintype) {
             if (!vplugin && pTool->LANG == parseopts.plugins[x].language)
diff --git a/unsorted/OptimizerHelpers.c b/unsorted/OptimizerHelpers.c
new file mode 100644
index 0000000..8b4bf36
--- /dev/null
+++ b/unsorted/OptimizerHelpers.c
@@ -0,0 +1,166 @@
+#include "parser.h"
+
+Boolean setOldOptimizerOptions;
+
+typedef struct {
+    Boolean commonsubs;
+    Boolean loopinvariants;
+    Boolean propagation;
+    Boolean deadstore;
+    Boolean strengthreduction;
+    Boolean deadcode;
+    Boolean lifetimes;
+} PIROptimizer; // assumed name
+
+static PIROptimizer pIrOptimizer = {0};
+
+Pragma irPragmas[] = {
+        &pIrOptimizer.commonsubs, "opt_common_subs", 0,
+        &pIrOptimizer.loopinvariants, "opt_loop_invariants", 0,
+        &pIrOptimizer.propagation, "opt_propagation", 0,
+        &pIrOptimizer.deadstore, "opt_dead_assignments", 0,
+        &pIrOptimizer.deadcode, "opt_dead_code", 0,
+        &pIrOptimizer.strengthreduction, "opt_strength_reduction", 0,
+        &pIrOptimizer.lifetimes, "opt_lifetimes", 0,
+        0, 0, 0
+};
+
+int SetPragmaOptimizationsToUnspecified(const char *opt, void *, const char *, int) {
+    if (setOldOptimizerOptions)
+        Option_Warning(CLPStr62);
+
+    memset(&pIrOptimizer, 0, sizeof(pIrOptimizer));
+    TargetSetPragmaOptimizationsToUnspecified();
+    return 1;
+}
+
+int SetOptFlags(const char *opt, void *str, const char *, int flags) {
+    // this is very similar to ToolHelper
+    // might also fail to match
+    unsigned char *ptr;
+    Boolean set;
+    Boolean no;
+    UInt16 flag;
+
+    ptr = (unsigned char *) str;
+    no = (Boolean) ((flags & PARAMPARSEFLAGS_8) >> 3);
+    set = (Boolean) (no ^ 1);
+
+    while (*ptr) {
+        if (*ptr == '+') {
+            set = !no;
+        } else if (*ptr == '-') {
+            set = no;
+        } else if (*ptr == '|') {
+            set = (Boolean) (no ^ 1);
+        } else {
+            flag = (ptr[0] << 8) | ptr[1];
+
+            if ((flag >= 'G0' && flag <= 'G4') || (flag == 'Gs') || (flag == 'Gp'))
+                SetPragmaOptimizationsToUnspecified(opt, NULL, NULL, 0);
+
+            switch (flag) {
+                case 'Cs':
+                    pIrOptimizer.commonsubs = set ? 1 : 2;
+                    setOldOptimizerOptions = 1;
+                    break;
+                case 'Li':
+                    pIrOptimizer.loopinvariants = set ? 1 : 2;
+                    setOldOptimizerOptions = 1;
+                    break;
+                case 'Pr':
+                    pIrOptimizer.propagation = set ? 1 : 2;
+                    setOldOptimizerOptions = 1;
+                    break;
+                case 'Ds':
+                    pIrOptimizer.deadstore = set ? 1 : 2;
+                    setOldOptimizerOptions = 1;
+                    break;
+                case 'Sr':
+                    pIrOptimizer.strengthreduction = set ? 1 : 2;
+                    setOldOptimizerOptions = 1;
+                    break;
+                case 'Dc':
+                    pIrOptimizer.deadcode = set ? 1 : 2;
+                    setOldOptimizerOptions = 1;
+                    break;
+                case 'Lt':
+                    pIrOptimizer.lifetimes = set ? 1 : 2;
+                    setOldOptimizerOptions = 1;
+                    break;
+                case 'G0':
+                    pGlobalOptimizer.optimizationlevel = set ? 0 : 0;
+                    break;
+                case 'G1':
+                    pGlobalOptimizer.optimizationlevel = set ? 1 : 0;
+                    break;
+                case 'G2':
+                    pGlobalOptimizer.optimizationlevel = set ? 2 : 0;
+                    break;
+                case 'G3':
+                    pGlobalOptimizer.optimizationlevel = set ? 3 : 0;
+                    break;
+                case 'G4':
+                    pGlobalOptimizer.optimizationlevel = set ? 4 : 0;
+                    break;
+                case 'Gs':
+                    pGlobalOptimizer.optfor = set ? 1 : 0;
+                    break;
+                case 'Gp':
+                    pGlobalOptimizer.optfor = set ? 0 : 1;
+                    break;
+                default:
+                    if (!TargetSetOptFlags(flag, set))
+                        CLPFatalError("Bad optimizer settings in %s (%c%c)\n", str, ptr[0], ptr[1]);
+            }
+
+            ++ptr;
+        }
+
+        ++ptr;
+    }
+
+    return 1;
+}
+
+int DisplayOptimizationOptions() {
+    SInt32 oldsize;
+    Handle h;
+
+    h = NewHandle(0);
+    if (!h)
+        exit(-23);
+
+    HPrintF(h, "\t- global optimizer level %d\n", pGlobalOptimizer.optimizationlevel);
+    HPrintF(h, "\t- global optimize for %s\n", (pGlobalOptimizer.optfor == 0) ? "speed" : "size");
+
+    oldsize = GetHandleSize(h);
+    if (pIrOptimizer.commonsubs)
+        HPrintF(h, "\t- common subexpression elimination %s\n", (pIrOptimizer.commonsubs == 1) ? "on" : "off");
+    if (pIrOptimizer.loopinvariants)
+        HPrintF(h, "\t- loop invariants %s\n", (pIrOptimizer.loopinvariants == 1) ? "on" : "off");
+    if (pIrOptimizer.commonsubs)
+        HPrintF(h, "\t- constant propagation %s\n", (pIrOptimizer.propagation == 1) ? "on" : "off");
+    if (pIrOptimizer.deadstore)
+        HPrintF(h, "\t- dead store elimination %s\n", (pIrOptimizer.deadstore == 1) ? "on" : "off");
+    if (pIrOptimizer.deadcode)
+        HPrintF(h, "\t- dead code elimination %s\n", (pIrOptimizer.deadcode == 1) ? "on" : "off");
+    if (pIrOptimizer.strengthreduction)
+        HPrintF(h, "\t- strength reduction %s\n", (pIrOptimizer.strengthreduction == 1) ? "on" : "off");
+    if (pIrOptimizer.lifetimes)
+        HPrintF(h, "\t- variable lifetimes %s\n", (pIrOptimizer.lifetimes == 1) ? "on" : "off");
+
+    if (oldsize == GetHandleSize(h))
+        HPrintF(h, "\t- no extra global optimizations\n");
+
+    HPrintF(h, "Backend-specific optimizer options:\n");
+
+    oldsize = GetHandleSize(h);
+    TargetDisplayOptimizationOptions(h);
+    if (oldsize == GetHandleSize(h))
+        HPrintF(h, "\t- no extra backend-specific optimizations\n");
+
+    ShowTextHandle(NULL, h);
+    DisposeHandle(h);
+    return 1;
+}
diff --git a/Option.c b/unsorted/Option.c
index c7e8093..410c807 100644
--- a/Option.c
+++ b/unsorted/Option.c
@@ -1,19 +1,17 @@
-#include "includes/mwcc_decomp.h"
+#include "parser.h"
 
 #define MAXSTACK 8
 
-int oStackPtr;
-Opt48 oStack[8];
-char curopt[1024];
-int maxlegalset;
-int numlegalset;
-int numinternalset;
-static OptionList legalset;
-static OptionList internalset;
-int numoptionlists;
 static OptionList *optionlists[32];
-
-extern char curparam[1024]; // check me
+int numoptionlists;
+static OptionList internalset;
+static OptionList legalset;
+int numinternalset;
+int numlegalset;
+int maxlegalset;
+char curopt[1024];
+Opt48 oStack[8];
+int oStackPtr;
 
 enum {
     ARGFLAG_1 = 1,
@@ -55,8 +53,8 @@ static void Option_PushList(OptionList *lst) {
 static void Option_PushOpt(Option *opt, const char *optname) {
     char *cpy;
     short flags = ARGFLAG_2;
-    if (opt && (opt->avail & OTF2)) {
-        if (Utils_CompareOptionString(opt->names, optname, opt->avail & OTF_CASED, OTF2)) {
+    if (opt && (opt->avail & OTF_STICKY)) {
+        if (Utils_CompareOptionString(opt->names, optname, opt->avail & OTF_CASED, OTF_STICKY)) {
             flags |= ARGFLAG_80;
         }
     }
@@ -224,11 +222,11 @@ void Options_SortOptions() {
     if (numinternalset > 0) {
         legalset.list = (Option **) xrealloc("options", legalset.list, sizeof(Option *) * (numinternalset + 1));
         for (r = 0; r < numinternalset; r++) {
-            if (internalset.list[r]->avail & (OTF2 | OTF_CASED))
+            if (internalset.list[r]->avail & (OTF_STICKY | OTF_CASED))
                 legalset.list[numlegalset++] = internalset.list[r];
         }
         for (r = 0; r < numinternalset; r++) {
-            if (!(internalset.list[r]->avail & (OTF2 | OTF_CASED)))
+            if (!(internalset.list[r]->avail & (OTF_STICKY | OTF_CASED)))
                 legalset.list[numlegalset++] = internalset.list[r];
         }
         legalset.list[numlegalset] = 0;
@@ -282,7 +280,7 @@ static void Options_Reset(OptionList *optlst) {
     os = optlst->list;
     if (os) {
         for (; *os; os++) {
-            (*os)->avail &= ~(OTF80000000 | OTF40000000);
+            (*os)->avail &= ~(OTF_INTERNAL_ALREADY_SEEN | OTF_INTERNAL_SEEN_CONFLICTED);
         }
     }
 }
@@ -332,7 +330,7 @@ static void Option_SpellList(char *buffer, OptionList *conflicts, int flags) {
             total++;
             buffer += sprintf(buffer, "%s", tmp);
 
-            if ((*scan)->avail & OTF8000)
+            if ((*scan)->avail & OTF_HAS_SUB_OPTIONS)
                 buffer += sprintf(buffer, " ...");
         }
         scan++;
@@ -364,14 +362,14 @@ static Boolean Option_ContinuesThisLevel(int level, ArgToken *tok) {
     int ret; // not in stabs but i think this exists
 
     if (level == 1) {
-        return (tok->val == ATK_1) || (tok->val == ATK_3) || (tok->val == ATK_2);
+        return (tok->val == ATK_ARG_END) || (tok->val == ATK_OPTION) || (tok->val == ATK_ARG);
     } else if (level == 2) {
         tmp = Arg_UsedToken();
-        ret = (tok->val == ATK_5 && tmp->val != ATK_3) || (tok->val == ATK_2 && tmp->val != ATK_1);
+        ret = (tok->val == ATK_COMMA && tmp->val != ATK_OPTION) || (tok->val == ATK_ARG && tmp->val != ATK_ARG_END);
         Arg_UndoToken();
         return ret;
     } else if (level == 3) {
-        return (tok->val == ATK_4) || (tok->val == ATK_2);
+        return (tok->val == ATK_EQUALS) || (tok->val == ATK_ARG);
     } else {
         return 0;
     }
@@ -439,21 +437,21 @@ int Option_Parse(Option *opt, int oflags) {
 
     if (samelevel) {
         if (!(flags & PFLAGS_1)) {
-            if ((opt->avail & OTF80000000) && (opt->avail & OTF20000)) {
-                Option_Warning(30);
-            } else if (opt->avail & OTF40000) {
+            if ((opt->avail & OTF_INTERNAL_ALREADY_SEEN) && (opt->avail & OTF_ONLY_ONCE)) {
+                Option_Warning(CLPStr30_OptionShouldNotBeSpecifiedMultipleTimes);
+            } else if (opt->avail & OTF_HAS_CONFLICTS) {
                 cscan = opt->conflicts->list;
-                while (*cscan && (*cscan == opt || !((*cscan)->avail & OTF80000000))) {
+                while (*cscan && (*cscan == opt || !((*cscan)->avail & OTF_INTERNAL_ALREADY_SEEN))) {
                     ++cscan;
                 }
 
                 if (*cscan && *cscan != opt) {
-                    (*cscan)->avail &= ~OTF80000000;
+                    (*cscan)->avail &= ~OTF_INTERNAL_ALREADY_SEEN;
                     Option_SpellList(errstr, opt->conflicts, oflags);
                     if (opt->conflicts->help)
-                        Option_Warning(32, (*cscan)->names, errstr, opt->conflicts->help);
+                        Option_Warning(CLPStr32_OptionOverridesEffectWithHelp, (*cscan)->names, errstr, opt->conflicts->help);
                     else
-                        Option_Warning(31, (*cscan)->names, errstr);
+                        Option_Warning(CLPStr31_OptionOverridesEffect, (*cscan)->names, errstr);
                 }
             }
         }
@@ -463,48 +461,48 @@ int Option_Parse(Option *opt, int oflags) {
             if (!Option_ForThisTool(opt))
                 flags |= PFLAGS_1;
             if (!subparse)
-                Arg_AddToToolArgs(&linkargs, ATK_1, 0);
+                Arg_AddToToolArgs(&linkargs, ATK_ARG_END, 0);
             Args_AddToToolArgs(&linkargs);
         }
 
         if (!(flags & PFLAGS_1)) {
             if (opt->avail & OTF_OBSOLETE) {
                 if (opt->help)
-                    Option_Error(22, opt->help);
+                    Option_Error(CLPStr22_OptionObsoleteWithHelp, opt->help);
                 else
-                    Option_Error(21);
+                    Option_Error(CLPStr21_OptionObsolete);
                 flags |= PFLAGS_1;
             }
 
             if (opt->avail & OTF_IGNORED) {
                 if (!(opt->avail & (OTF_WARNING | OTF_MEANINGLESS))) {
                     if (opt->help)
-                        Option_Warning(27, opt->help);
+                        Option_Warning(CLPStr27_OptionIgnoredWithText, opt->help);
                     else
-                        Option_Warning(26);
+                        Option_Warning(CLPStr26_OptionIgnored);
                 }
                 flags |= PFLAGS_1;
             } else if (opt->avail & OTF_SUBSTITUTED) {
-                Option_Warning(23, curopt, opt->help);
+                Option_Warning(CLPStr23_OptionXSubstitutedWithX, curopt, opt->help);
             } else if (opt->avail & OTF_DEPRECATED) {
                 if (opt->help)
-                    Option_Warning(25, opt->help);
+                    Option_Warning(CLPStr25_OptionDeprecatedWithHelp, opt->help);
                 else
-                    Option_Warning(24);
+                    Option_Warning(CLPStr24_OptionDeprecated);
             }
 
             if (opt->avail & OTF_WARNING)
-                Option_Warning(28, opt->help);
+                Option_Warning(CLPStr28_WarningText, opt->help);
             if (opt->avail & OTF_MEANINGLESS)
-                Option_Warning(29);
+                Option_Warning(CLPStr29_OptionHasNoEffect);
         }
 
-        opt->avail |= OTF80000000;
-        if (opt->avail & OTF40000) {
+        opt->avail |= OTF_INTERNAL_ALREADY_SEEN;
+        if (opt->avail & OTF_HAS_CONFLICTS) {
             scan = opt->conflicts->list;
-            opt->avail |= OTF40000000;
+            opt->avail |= OTF_INTERNAL_SEEN_CONFLICTED;
             while (*scan) {
-                (*scan)->avail |= OTF40000000;
+                (*scan)->avail |= OTF_INTERNAL_SEEN_CONFLICTED;
                 scan++;
             }
         }
@@ -512,12 +510,12 @@ int Option_Parse(Option *opt, int oflags) {
         flags |= PFLAGS_1;
     }
 
-    goingtosubparse = opt->avail & OTF8000;
+    goingtosubparse = opt->avail & OTF_HAS_SUB_OPTIONS;
     if (opt->param) {
         ret = Params_Parse(opt->param, flags | (goingtosubparse ? PFLAGS_20 : 0));
     } else {
         tok = Arg_PeekToken();
-        if (tok && tok->val == ATK_4)
+        if (tok && tok->val == ATK_EQUALS)
             Arg_UsedToken();
     }
 
@@ -528,7 +526,7 @@ int Option_Parse(Option *opt, int oflags) {
                 | OFLAGS_2
                     | ((flags & PFLAGS_1) ? OFLAGS_40 : 0)
                       | (subparse ? OFLAGS_10 : 0)
-                      | ((opt->avail & OTF10000) ? OFLAGS_4 : 0)
+                      | ((opt->avail & OTF_SUB_OPTIONS_OPTIONAL) ? OFLAGS_4 : 0)
         );
     }
 
@@ -536,7 +534,7 @@ int Option_Parse(Option *opt, int oflags) {
         Option_PopOpt(curopt);
 
     if (Option_ThisTool() == OTF_TOOL_COMPILER && !subparse)
-        Arg_AddToToolArgs(&linkargs, ATK_1, 0);
+        Arg_AddToToolArgs(&linkargs, ATK_ARG_END, 0);
 
     return ret;
 }
@@ -610,7 +608,7 @@ static Option *Option_Lookup(OptionList *search, int unk, int *flags) {
     if (os) {
         while (*os) {
             names = (*os)->names;
-            if (((*os)->avail & OTF2) == OTF2) {
+            if (((*os)->avail & OTF_STICKY) == OTF_STICKY) {
                 while (*names && *names != '|')
                     ++names;
                 if (*names)
@@ -625,10 +623,10 @@ static Option *Option_Lookup(OptionList *search, int unk, int *flags) {
                     return *os;
             }
 
-            if ((*os)->avail & OTF2) {
+            if ((*os)->avail & OTF_STICKY) {
                 matched = Utils_CompareOptionString((*os)->names, curopt, (*os)->avail & OTF_CASED, 2);
                 if (matched)
-                    stickyflags |= OTF2;
+                    stickyflags |= OTF_STICKY;
             } else {
                 matched = 0;
             }
@@ -680,11 +678,11 @@ static int Options_DoParse(OptionList *search, int flags) {
     starttok = Arg_PeekToken(); // i think this is starttok
     while ((token_r18 = Arg_PeekToken())) {
         parsedany = 0;
-        isOpt = ((mystery_r31 == 1) && (token_r18->val == ATK_3)) || ((mystery_r31 == 2) && (token_r18->val == ATK_2) && (token_r18->text[0] || search->flags & LISTFLAGS_4)) || ((mystery_r31 == 3) && (token_r18->val == ATK_4));
+        isOpt = ((mystery_r31 == 1) && (token_r18->val == ATK_OPTION)) || ((mystery_r31 == 2) && (token_r18->val == ATK_ARG) && (token_r18->text[0] || search->flags & LISTFLAGS_4)) || ((mystery_r31 == 3) && (token_r18->val == ATK_EQUALS));
         // 950 17CFD4
         if ((mystery_r31 == 3) && isOpt) {
             token_r18 = Arg_UsedToken();
-            isOpt = token_r18 && (token_r18->val == ATK_2);
+            isOpt = token_r18 && (token_r18->val == ATK_ARG);
             flags &= ~OFLAGS_4;
         }
         // 957 17D00C
@@ -700,7 +698,7 @@ static int Options_DoParse(OptionList *search, int flags) {
                     opttok = token_r18;
                     if (!(matchflags & 2)) {
                         // 972
-                        if (token_r18->val == ATK_3)
+                        if (token_r18->val == ATK_OPTION)
                             Arg_UsedToken();
                         token_r18 = Arg_UsedToken();
                     } else {
@@ -717,7 +715,7 @@ static int Options_DoParse(OptionList *search, int flags) {
 
                         if (!token_r18->text || !token_r18->text[0]) {
                             Option_PushOpt(0, curopt);
-                            Option_ParamError(34, curopt);
+                            Option_ParamError(CLPStr34_ArgumentsExpected, curopt);
                             Option_PopOpt(0);
                             return 0;
                         }
@@ -739,7 +737,7 @@ static int Options_DoParse(OptionList *search, int flags) {
                     if (opt) {
                         if (opt->names[0])
                             token_r18 = Arg_UsedToken();
-                        if (token_r18->val == ATK_4)
+                        if (token_r18->val == ATK_EQUALS)
                             Arg_UsedToken();
                         haderrors = Option_Parse(opt, flags) == 0;
                         parsedany = 1;
@@ -760,32 +758,32 @@ static int Options_DoParse(OptionList *search, int flags) {
                         if ((flags & OFLAGS_4) && token_r18 == starttok)
                             return haderrors == 0;
                         // 1072
-                        if (search->flags & LISTFLAGS_2) {
+                        if (search->flags & LISTFLAGS_ALLOW_UNKNOWNS) {
                             if (!(flags & OFLAGS_1)) {
                                 Option_SpellList(curparam, search, flags);
-                                Option_Warning(20, token_r18->text, curparam);
+                                Option_Warning(CLPStr20_UnknownOptionX_ExpectedOneOfX, token_r18->text, curparam);
                             }
                             Arg_UsedToken();
                             parsedany = 1;
                         } else {
                             // 1090
                             Option_SpellList(curparam, search, flags);
-                            Option_Error(20, token_r18->text, curparam);
+                            Option_Error(CLPStr20_UnknownOptionX_ExpectedOneOfX, token_r18->text, curparam);
                             failed = 1;
                             haderrors++;
                         }
                     } else {
                         // 1099
-                        if ((search->flags & LISTFLAGS_2) || parseopts.ignoreUnknown) {
+                        if ((search->flags & LISTFLAGS_ALLOW_UNKNOWNS) || parseopts.ignoreUnknown) {
                             // 1101
                             if (!(flags & OFLAGS_1))
-                                Option_Warning(19, token_r18->text);
+                                Option_Warning(CLPStr19_UnknownOptionX, token_r18->text);
                             Arg_UsedToken();
                             Arg_GetToken();
                             parsedany = 1;
                         } else {
                             // 1115
-                            Option_Error(19, token_r18->text);
+                            Option_Error(CLPStr19_UnknownOptionX, token_r18->text);
                             failed = 1;
                             haderrors++;
                         }
@@ -803,14 +801,14 @@ static int Options_DoParse(OptionList *search, int flags) {
                     failed = 1;
                 parsedany++;
             } // else: goto 1229
-        } else if ((mystery_r31 == 1) && (token_r18->val == ATK_2)) {
+        } else if ((mystery_r31 == 1) && (token_r18->val == ATK_ARG)) {
             // 1142
             opttok = 0;
             curopt[0] = 0;
             opt = Option_Lookup(search, 0, &matchflags);
             strcpy(curopt, token_r18->text);
             if (!opt) {
-                Option_Warning(33, curopt);
+                Option_Warning(CLPStr33_NoDefaultHandlerSetUpForX_Ignoring, curopt);
                 failed = 1;
             } else {
                 if (!(flags & OFLAGS_1)) {
@@ -840,7 +838,7 @@ static int Options_DoParse(OptionList *search, int flags) {
             if (!opt) {
                 // 1205
                 if (!(flags & OFLAGS_4)) {
-                    Option_Error(34, saveopt);
+                    Option_Error(CLPStr34_ArgumentsExpected, saveopt);
                     failed = 1;
                     haderrors++;
                 } else {
@@ -863,7 +861,7 @@ static int Options_DoParse(OptionList *search, int flags) {
         tok = Arg_PeekToken();
         // 1231
         if (!failed) {
-            if (tok && (tok->val == ATK_2) && (matchflags & 2)) {
+            if (tok && (tok->val == ATK_ARG) && (matchflags & 2)) {
                 // 1235
                 ArgToken *prev; // r16
                 char sticky[64]; // stack 0x3C
@@ -874,10 +872,10 @@ static int Options_DoParse(OptionList *search, int flags) {
                         strcpy(sticky, opttok->text);
                         sticky[strlen(tok->text)] = 0;
                         Option_PushOpt(0, sticky);
-                        Param_Error(36, Arg_GetTokenName(tok));
+                        Param_Error(CLPStr36_UnexpectedAdditionalArgumentX, Arg_GetTokenName(tok));
                         Option_PopOpt(0);
                     } else {
-                        CLPReportError(36, Arg_GetTokenName(tok));
+                        CLPReportError(CLPStr36_UnexpectedAdditionalArgumentX, Arg_GetTokenName(tok));
                     }
                     // 1251
                     haderrors++;
@@ -900,21 +898,21 @@ static int Options_DoParse(OptionList *search, int flags) {
                     ArgToken *prev = tok; // r16
                     tok = Arg_UsedToken();
                     // 1278
-                    if ((mystery_r31 != 1) || (tok->val != ATK_3)) {
+                    if ((mystery_r31 != 1) || (tok->val != ATK_OPTION)) {
                         // 1280
                         if (opttok) {
                             Option_PushOpt(0, opttok->text);
-                            if (tok->val == ATK_2)
-                                Param_Error(36, Arg_GetTokenName(tok));
+                            if (tok->val == ATK_ARG)
+                                Param_Error(CLPStr36_UnexpectedAdditionalArgumentX, Arg_GetTokenName(tok));
                             else
-                                Param_Error(35, Arg_GetTokenName(prev));
+                                Param_Error(CLPStr35_TokenXNotExpected, Arg_GetTokenName(prev));
                             Option_PopOpt(opttok->text);
-                        } else if (tok->val == ATK_2) {
+                        } else if (tok->val == ATK_ARG) {
                             // 1292
-                            CLPReportError(36, Arg_GetTokenName(tok));
+                            CLPReportError(CLPStr36_UnexpectedAdditionalArgumentX, Arg_GetTokenName(tok));
                         } else {
                             // 1294
-                            CLPReportError(35, Arg_GetTokenName(prev));
+                            CLPReportError(CLPStr35_TokenXNotExpected, Arg_GetTokenName(prev));
                         }
                         haderrors++;
                         failed++;
@@ -924,15 +922,15 @@ static int Options_DoParse(OptionList *search, int flags) {
                     // 1303
                     if (opttok) {
                         Option_PushOpt(0, opttok->text);
-                        if (tok->val == ATK_2)
-                            Param_Error(36, Arg_GetTokenName(tok));
+                        if (tok->val == ATK_ARG)
+                            Param_Error(CLPStr36_UnexpectedAdditionalArgumentX, Arg_GetTokenName(tok));
                         else
-                            Param_Error(35, Arg_GetTokenName(tok));
+                            Param_Error(CLPStr35_TokenXNotExpected, Arg_GetTokenName(tok));
                         Option_PopOpt(opttok->text);
-                    } else if (tok->val == ATK_2) {
-                        CLPReportError(36, Arg_GetTokenName(tok));
+                    } else if (tok->val == ATK_ARG) {
+                        CLPReportError(CLPStr36_UnexpectedAdditionalArgumentX, Arg_GetTokenName(tok));
                     } else {
-                        CLPReportError(35, Arg_GetTokenName(tok));
+                        CLPReportError(CLPStr35_TokenXNotExpected, Arg_GetTokenName(tok));
                     }
                     haderrors++;
                     failed++;
@@ -1115,11 +1113,11 @@ int Option_Help(const char *opt) {
     if (find) {
         Help_Init();
         if (!Help_Option(Options_GetOptions(), find, 0, ""))
-            CLPReportWarning(38, opt);
+            CLPReportWarning(CLPStr38_NoHelpAvailableForOptionX, opt);
         Help_Term();
         ret = 1;
     } else {
-        Option_Error(19, opt);
+        Option_Error(CLPStr19_UnknownOptionX, opt);
         ret = 0;
     }
 
@@ -1130,7 +1128,7 @@ int Option_Help(const char *opt) {
 
 int Options_DisplayHelp() {
     if (parseopts.helpFlags & HELPFLAGS_1)
-        Option_Help(parseopts.helpKey);
+        return Option_Help(parseopts.helpKey);
     else
-        Options_Help(parseopts.helpKey);
+        return Options_Help(parseopts.helpKey);
 }
diff --git a/Parameter.c b/unsorted/Parameter.c
index 95bde45..b3c7367 100644
--- a/Parameter.c
+++ b/unsorted/Parameter.c
@@ -1,4 +1,4 @@
-#include "includes/mwcc_decomp.h"
+#include "parser.h"
 
 char curparam[4096];
 char *descparam = &curparam[0];
@@ -750,7 +750,7 @@ static int Param_Setting(SETTING_T *p, const char *pstr, int flags) {
 
     strncpy(savevar, pstr, sizeof(savevar));
     tok = Arg_PeekToken();
-    if (tok && tok->val == ATK_4) {
+    if (tok && tok->val == ATK_EQUALS) {
         Arg_UsedToken();
         equals = 1;
         if (!Param_GetArgument((PARAM_T *) p, &vstr, flags))
@@ -1007,22 +1007,22 @@ static int Param_GetArgument(PARAM_T *param, const char **cparam, int exec) {
     ArgToken *tok;
 
     subparse = (exec & PARAMPARSEFLAGS_4) != 0;
-    nextOpt = !subparse ? ATK_1 : ATK_5;
-    nextParam = !subparse ? ATK_5 : ATK_4;
-    lastOpt = !subparse ? ATK_0 : ATK_1;
+    nextOpt = !subparse ? ATK_ARG_END : ATK_COMMA;
+    nextParam = !subparse ? ATK_COMMA : ATK_EQUALS;
+    lastOpt = !subparse ? ATK_END : ATK_ARG_END;
 
     tok = Arg_PeekToken();
 #line 1467
     OPTION_ASSERT(tok);
 
     if ((param->flags & PARAMFLAGS_3) == 0) {
-        if (tok->val == nextParam || tok->val == ATK_4)
+        if (tok->val == nextParam || tok->val == ATK_EQUALS)
             tok = Arg_UsedToken();
         if (tok->val == nextOpt || tok->val == nextParam || tok->val == lastOpt) {
             Param_Error(34);
             return 0;
         }
-        if (tok->val != ATK_2) {
+        if (tok->val != ATK_ARG) {
             Param_Error(57, "parameter", Arg_GetTokenName(tok));
             return 0;
         }
@@ -1032,12 +1032,12 @@ static int Param_GetArgument(PARAM_T *param, const char **cparam, int exec) {
 
         if (param->flags & PARAMFLAGS_8) {
             tok = Arg_PeekToken();
-            if (tok->val == ATK_4)
+            if (tok->val == ATK_EQUALS)
                 Arg_UsedToken();
         }
     } else if (param->flags & PARAMFLAGS_1) {
         *cparam = 0;
-        if (tok->val == ATK_4 && !subparse) {
+        if (tok->val == ATK_EQUALS && !subparse) {
             if (!(exec & PARAMPARSEFLAGS_40)) {
                 Param_Error(37);
                 return 0;
@@ -1049,7 +1049,7 @@ static int Param_GetArgument(PARAM_T *param, const char **cparam, int exec) {
             *cparam = 0;
         } else if (tok->val == nextParam) {
             tok = Arg_UsedToken();
-            if (tok->val == ATK_2) {
+            if (tok->val == ATK_ARG) {
                 Arg_GetTokenText(tok, curparam, sizeof(curparam), 1);
                 if ((param->flags & PARAMFLAGS_12) && Param_IsNonTextFile(curparam, !(exec & PARAMPARSEFLAGS_1))) {
                     *cparam = 0;
@@ -1060,17 +1060,17 @@ static int Param_GetArgument(PARAM_T *param, const char **cparam, int exec) {
             } else {
                 *cparam = 0;
             }
-        } else if (tok->val == ATK_2 && !tok->text[0]) {
+        } else if (tok->val == ATK_ARG && !tok->text[0]) {
             tok = Arg_UsedToken();
             if (tok->val == nextParam)
                 Arg_UsedToken();
             *cparam = 0;
-        } else if ((exec & PARAMPARSEFLAGS_4) && tok->val != ATK_4) {
+        } else if ((exec & PARAMPARSEFLAGS_4) && tok->val != ATK_EQUALS) {
             *cparam = 0;
         } else {
-            if (tok->val == ATK_4)
+            if (tok->val == ATK_EQUALS)
                 tok = Arg_UsedToken();
-            if (tok->val == ATK_2) {
+            if (tok->val == ATK_ARG) {
                 Arg_GetTokenText(tok, curparam, sizeof(curparam), 1);
                 if ((param->flags & PARAMFLAGS_12) && Param_IsNonTextFile(curparam, !(exec & PARAMPARSEFLAGS_1))) {
                     *cparam = 0;
@@ -1089,9 +1089,9 @@ static int Param_GetArgument(PARAM_T *param, const char **cparam, int exec) {
     if (pTool->TYPE == CWDROPINCOMPILERTYPE && (exec & PARAMPARSEFLAGS_2) && *cparam) {
         if (!(exec & PARAMPARSEFLAGS_10)) {
             if (subparse)
-                Arg_AddToToolArgs(&linkargs, ATK_4, 0);
+                Arg_AddToToolArgs(&linkargs, ATK_EQUALS, 0);
             else
-                Arg_AddToToolArgs(&linkargs, ATK_5, 0);
+                Arg_AddToToolArgs(&linkargs, ATK_COMMA, 0);
         }
         Param_PushParam(*cparam);
         Args_AddToToolArgs(&linkargs);
diff --git a/unsorted/ParserErrors.c b/unsorted/ParserErrors.c
index 172e04c..df5e67e 100644
--- a/unsorted/ParserErrors.c
+++ b/unsorted/ParserErrors.c
@@ -1,4 +1,4 @@
-#include "mwcc_decomp.h"
+#include "parser.h"
 
 static char errorbuf[1024];
 
diff --git a/unsorted/ParserFace.c b/unsorted/ParserFace.c
index 24f3213..a005ece 100644
--- a/unsorted/ParserFace.c
+++ b/unsorted/ParserFace.c
@@ -1,8 +1,8 @@
-#include "mwcc_decomp.h"
+#include "parser.h"
 
 const char *failedCallback;
 jmp_buf exit_plugin;
-struct ParseOptsType parseopts;
+ParseOptsType parseopts;
 
 static CWResult SetupParamBlock(CWPluginContext context) {
     CWResult result;
@@ -136,9 +136,9 @@ CWResult Parser_StorePanels(CWPluginContext context) {
         name = parseopts.panelNames[idx];
         h = Parser_FindPrefPanel(name);
         if (h) {
-            result = CWParserSetNamedPreferences(parseopts.context, name, (CWMemHandle) h);
+            result = CWParserSetNamedPreferences(parseopts.context, name, h);
             if (result) {
-                CLPReportError(68, name);
+                CLPReportError(CLPStr68, name);
                 return result;
             }
         }
@@ -190,10 +190,10 @@ static CWResult StoreResults(CWPluginContext context) {
     return cwNoErr;
 }
 
-short CWParser_GetDropInFlags(const DropInFlags **flags, SInt32 *flagsSize) {
+CWPLUGIN_ENTRY (CWParser_GetDropInFlags)(const DropInFlags **flags, SInt32 *flagsSize) {
     static const DropInFlags sFlags = {
             kCurrentDropInFlagsVersion,
-            CWFOURCHAR('P','a','r','s'),
+            CWDROPINPARSERTYPE,
             7,
             0,
             'Seep',
@@ -204,19 +204,19 @@ short CWParser_GetDropInFlags(const DropInFlags **flags, SInt32 *flagsSize) {
     return 0;
 }
 
-short CWParser_GetDropInName(const char **dropinName) {
+CWPLUGIN_ENTRY (CWParser_GetDropInName)(const char **dropinName) {
     static const char *sDropInName = "Command-Line Parser";
     *dropinName = sDropInName;
     return 0;
 }
 
-short CWParser_GetDisplayName(const char **displayName) {
+CWPLUGIN_ENTRY (CWParser_GetDisplayName)(const char **displayName) {
     static const char *sDisplayName = "Command-Line Parser";
     *displayName = sDisplayName;
     return 0;
 }
 
-short CWParser_GetPanelList(const CWPanelList **panelList) {
+CWPLUGIN_ENTRY (CWParser_GetPanelList)(const CWPanelList **panelList) {
     static CWPanelList sPanelList = {
             kCurrentCWFamilyListVersion,
             0,
@@ -226,7 +226,7 @@ short CWParser_GetPanelList(const CWPanelList **panelList) {
     return 0;
 }
 
-short CWParser_GetTargetList(const CWTargetList **targetList) {
+CWPLUGIN_ENTRY (CWParser_GetTargetList)(const CWTargetList **targetList) {
     static CWDataType sCPU = '****';
     static CWDataType sOS = '****';
     static CWTargetList sTargetList = {
@@ -240,7 +240,7 @@ short CWParser_GetTargetList(const CWTargetList **targetList) {
     return 0;
 }
 
-short CWParser_GetVersionInfo(const VersionInfo **versioninfo) {
+CWPLUGIN_ENTRY (CWParser_GetVersionInfo)(const VersionInfo **versioninfo) {
     static const VersionInfo vi = {
             1, 1, 0, 0
     };
@@ -248,17 +248,17 @@ short CWParser_GetVersionInfo(const VersionInfo **versioninfo) {
     return 0;
 }
 
-short Parser_SupportsPlugin(struct CLPluginInfo *pluginfo, CWDataType cpu, CWDataType os, Boolean *isSupported) {
+CWPLUGIN_ENTRY (Parser_SupportsPlugin)(const struct CLPluginInfo *pluginfo, CWDataType cpu, CWDataType os, Boolean *isSupported) {
     *isSupported = ParserToolMatchesPlugin(pluginfo->plugintype, pluginfo->language, cpu, os);
     return 0;
 }
 
-short Parser_SupportsPanels(int numPanels, const char **panelNames, Boolean *isSupported) {
+CWPLUGIN_ENTRY (Parser_SupportsPanels)(int numPanels, const char **panelNames, Boolean *isSupported) {
     *isSupported = ParserToolHandlesPanels(numPanels, panelNames);
     return 0;
 }
 
-short parser_main(CWPluginContext context) {
+CWPLUGIN_ENTRY (parser_main)(CWPluginContext context) {
     CWResult result;
     SInt32 request;
 
diff --git a/unsorted/ParserHelpers-cc.c b/unsorted/ParserHelpers-cc.c
index d56fe4d..fe081ad 100644
--- a/unsorted/ParserHelpers-cc.c
+++ b/unsorted/ParserHelpers-cc.c
@@ -1,8 +1,8 @@
-#include "mwcc_decomp.h"
+#include "parser.h"
 
 Handle definesHandle;
 
-int Opt_AddStringToDefines(const char *opt, void *str, const char *param) {
+int Opt_AddStringToDefines(const char *opt, void *str, const char *param, int flags) {
     AddStringToHandle(&definesHandle, (const char *) str);
     if (param)
         AddStringToHandle(&definesHandle, param);
@@ -18,7 +18,7 @@ int Opt_DefineSymbol(const char *var, const char *value) {
         sprintf(tmp, "{$definec %s %s}\n", var, value ? value : "1");
     } else {
         sprintf(tmp, "Option '-D|d' is not supported with this plugin");
-        CLPReportError(28, tmp);
+        CLPReportError(CLPStr28_WarningText, tmp);
         return 0;
     }
 
@@ -26,7 +26,7 @@ int Opt_DefineSymbol(const char *var, const char *value) {
     return 1;
 }
 
-int Opt_UndefineSymbol(const char *opt, void *, const char *arg) {
+int Opt_UndefineSymbol(const char *opt, void *, const char *arg, int flags) {
     char tmp[300];
 
     if (pTool->LANG == Lang_C_CPP || pTool->LANG == CWFOURCHAR('A','s','m',' ')) {
@@ -35,7 +35,7 @@ int Opt_UndefineSymbol(const char *opt, void *, const char *arg) {
         sprintf(tmp, "{$undefc %s}\n", arg);
     } else {
         sprintf(tmp, "Option -%s is not supported with this plugin", opt);
-        CLPReportError(28, tmp);
+        CLPReportError(CLPStr28_WarningText, tmp);
         return 0;
     }
 
@@ -43,7 +43,7 @@ int Opt_UndefineSymbol(const char *opt, void *, const char *arg) {
     return 1;
 }
 
-int Opt_AddPrefixFile(const char *opt, void *handle, const char *filename) {
+int Opt_AddPrefixFile(const char *opt, void *handle, const char *filename, int flags) {
     char tmp[300];
 
     handle = !handle ? &definesHandle : handle;
@@ -60,7 +60,7 @@ int Opt_AddPrefixFile(const char *opt, void *handle, const char *filename) {
         snprintf(tmp, sizeof(tmp), "{$I+}\n{$I %s}\n{$I-}\n", filename);
     } else {
         sprintf(tmp, "Option -%s is not supported with this plugin", opt);
-        CLPReportError(28, tmp);
+        CLPReportError(CLPStr28_WarningText, tmp);
         return 0;
     }
 
@@ -86,7 +86,7 @@ int Opt_PragmaFalseTrue(const char *, void *flag, const char *, int flags) {
 
 int Opt_PragmaOnOff(const char *, void *flag, const char *arg) {
     if (!arg) {
-        CLPReportError(34);
+        CLPReportError(CLPStr34_ArgumentsExpected);
         return 0;
     }
 
@@ -95,7 +95,7 @@ int Opt_PragmaOnOff(const char *, void *flag, const char *arg) {
     } else if (!ustrcmp(arg, "off")) {
         *((unsigned char *) flag) = PR_OFF;
     } else {
-        CLPReportError(12, arg);
+        CLPReportError(CLPStr12, arg);
         return 0;
     }
 
@@ -104,7 +104,7 @@ int Opt_PragmaOnOff(const char *, void *flag, const char *arg) {
 
 int Opt_PragmaOffOn(const char *, void *flag, const char *arg) {
     if (!arg) {
-        CLPReportError(34);
+        CLPReportError(CLPStr34_ArgumentsExpected);
         return 0;
     }
 
@@ -113,7 +113,7 @@ int Opt_PragmaOffOn(const char *, void *flag, const char *arg) {
     } else if (!ustrcmp(arg, "off")) {
         *((unsigned char *) flag) = PR_ON;
     } else {
-        CLPReportError(12, arg);
+        CLPReportError(CLPStr12, arg);
         return 0;
     }
 
diff --git a/unsorted/ParserHelpers.c b/unsorted/ParserHelpers.c
index c8d4c55..4cb793e 100644
--- a/unsorted/ParserHelpers.c
+++ b/unsorted/ParserHelpers.c
@@ -1,4 +1,5 @@
-#include "mwcc_decomp.h"
+#include "parser.h"
+#include "cmdline.h"
 #include <errno.h>
 
 SInt16 lastStage;
@@ -44,7 +45,7 @@ char *GetEnvVar(const char *name, Boolean warn, const char **match) {
     }
 
     if (warn)
-        CLPReportWarning(52, last);
+        CLPReportWarning(CLPStr52, last);
     *match = 0;
     return 0;
 }
@@ -82,7 +83,7 @@ static Boolean MatchesExtension(const char *list, const char *filename) {
     return !*list && !*ptr;
 }
 
-int Opt_AddAccessPath(const char *opt, void *var, const char *arg) {
+int Opt_AddAccessPath(const char *opt, void *var, const char *arg, int flags) {
     OSPathSpec spec;
     int err;
 
@@ -93,16 +94,16 @@ int Opt_AddAccessPath(const char *opt, void *var, const char *arg) {
         return 1;
 
     if (strlen(arg) >= 256) {
-        CLPReportError(13, arg + strlen(arg) - 32, 256);
+        CLPReportError(CLPStr13, arg + strlen(arg) - 32, 256);
         return 0;
     }
 
     err = OS_MakePathSpec(0, arg, &spec);
     if (err == ENOENT || err == ENOENT) {
-        CLPReportWarning(45, arg);
+        CLPReportWarning(CLPStr45, arg);
         return 1;
     } else if (err != 0) {
-        CLPOSAlert(45, err, arg);
+        CLPOSAlert(CLPStr45, err, arg);
         return 1;
     }
 
@@ -113,7 +114,7 @@ int Opt_AddAccessPath(const char *opt, void *var, const char *arg) {
         return 1;
 }
 
-int Opt_AddFrameworkPath(const char *opt, void *var, const char *arg) {
+int Opt_AddFrameworkPath(const char *opt, void *var, const char *arg, int flags) {
     OSPathSpec spec;
     int err;
 
@@ -124,16 +125,16 @@ int Opt_AddFrameworkPath(const char *opt, void *var, const char *arg) {
         return 1;
 
     if (strlen(arg) >= 256) {
-        CLPReportError(13, arg + strlen(arg) - 32, 256);
+        CLPReportError(CLPStr13, arg + strlen(arg) - 32, 256);
         return 0;
     }
 
     err = OS_MakePathSpec(0, arg, &spec);
     if (err == ENOENT || err == ENOENT) {
-        CLPReportWarning(45, arg);
+        CLPReportWarning(CLPStr45, arg);
         return 1;
     } else if (err != 0) {
-        CLPOSAlert(45, err, arg);
+        CLPOSAlert(CLPStr45, err, arg);
         return 1;
     } else {
         Frameworks_AddPath(&spec);
@@ -141,7 +142,7 @@ int Opt_AddFrameworkPath(const char *opt, void *var, const char *arg) {
     }
 }
 
-int Opt_AddFramework(const char *opt, void *var, const char *arg) {
+int Opt_AddFramework(const char *opt, void *var, const char *arg, int flags) {
     if (!Frameworks_AddFramework(arg ? arg : opt, 0, 0))
         return 0;
     else
@@ -190,7 +191,7 @@ int AddAccessPathList(const char *list, char sep1, char sep2, int source, char *
             ListParseMessage(
                     CLPReportError_V,
                     (source == 1) ? text : NULL,
-                    9,
+                    CLPStr9,
                     tmp,
                     tmp + strlen(tmp) - 16,
                     256);
@@ -202,7 +203,7 @@ int AddAccessPathList(const char *list, char sep1, char sep2, int source, char *
             ListParseMessage(
                     CLPReportWarning_V,
                     (source == 1) ? text : NULL,
-                    45,
+                    CLPStr45,
                     tmp);
         } else {
             AddAccessPath(&spec, type, position, recurse ^ recursive);
@@ -218,7 +219,7 @@ int AddAccessPathList(const char *list, char sep1, char sep2, int source, char *
     return 1;
 }
 
-int Opt_FindAndAddFile(const char *opt, void *var, const char *arg) {
+int Opt_FindAndAddFile(const char *opt, void *var, const char *arg, int flags) {
     OSSpec spec;
     int err;
     Boolean isfile;
@@ -235,11 +236,11 @@ int Opt_FindAndAddFile(const char *opt, void *var, const char *arg) {
         err = OS_Status(&spec);
 
     if (!err && !isfile) {
-        CLPReportError(47, arg);
+        CLPReportError(CLPStr47, arg);
         parseopts.unusedFiles++;
         return 0;
     } else if (err && err != ENOENT) {
-        CLPOSAlert(44, err, arg);
+        CLPOSAlert(CLPStr44, err, arg);
         parseopts.unusedFiles++;
         return 0;
     } else if (err && parseopts.alwaysUsePaths) {
@@ -247,13 +248,13 @@ int Opt_FindAndAddFile(const char *opt, void *var, const char *arg) {
     }
 
     if (err) {
-        CLPReportError(44, arg);
+        CLPReportError(CLPStr44, arg);
         parseopts.unusedFiles++;
         return 0;
     }
 
     if (var && !MatchesExtension((const char *) var, arg))
-        CLPReportWarning(76, arg, var);
+        CLPReportWarning(CLPStr76, arg, var);
 
     if (!AddFileToProject(&spec, lastStage, parseopts.lastoutputname, 1, -1)) {
         parseopts.unusedFiles++;
@@ -277,14 +278,14 @@ int Opt_FindAndAddFileRef(const char *opt, void *var, const char *arg) {
 
     parseopts.userSpecifiedFiles++;
     if (var && !MatchesExtension((const char *) var, arg))
-        CLPReportWarning(76, arg, var);
+        CLPReportWarning(CLPStr76, arg, var);
 
     err = OS_MakeSpec(arg, &spec, &isfile);
     if (!err)
         err = OS_Status(&spec);
 
     if (!err && !isfile) {
-        CLPReportError(47, arg);
+        CLPReportError(CLPStr47, arg);
         parseopts.unusedFiles++;
         return 0;
     } else if (err && parseopts.alwaysUsePaths) {
@@ -307,7 +308,7 @@ int Opt_AddUnixLibraryFile(const char *opt, void *var, const char *name) {
     char tmpname[64];
 
     if (strlen(name) >= 56) {
-        CLPReportError(13, name + strlen(name) - 32, 64);
+        CLPReportError(CLPStr13, name + strlen(name) - 32, 64);
         return 0;
     }
 
@@ -336,7 +337,7 @@ int Opt_AddUnixLibraryFile(const char *opt, void *var, const char *name) {
     if (failed) {
         failed = !FindFileInPath(name, &spec);
         if (failed)
-            CLPReportError(49, name, var, name);
+            CLPReportError(CLPStr49, name, var, name);
     }
 
     if (!failed) {
@@ -368,7 +369,7 @@ int AddFileList(const char *list, char sep1, char sep2, int source, char *text,
             ListParseMessage(
                     CLPReportError_V,
                     (source == 1) ? text : 0,
-                    9,
+                    CLPStr9,
                     tmp,
                     tmp + strlen(tmp) - 16,
                     256
@@ -381,14 +382,14 @@ int AddFileList(const char *list, char sep1, char sep2, int source, char *text,
                 ListParseMessage(
                         CLPReportError_V,
                         (source == 1) ? text : 0,
-                        16,
+                        CLPStr16,
                         tmp
                         );
             } else {
                 ListParseMessage(
                         CLPReportWarning_V,
                         (source == 1) ? text : 0,
-                        44,
+                        CLPStr44,
                         tmp
                 );
             }
@@ -416,18 +417,18 @@ void GetCFileNameInOutputDirectory(const char *input, char *name, int maxlen) {
 
     err = OS_MakeFileSpec(input, &spec);
     if (err) {
-        CLPOSAlert(64, err, input);
+        CLPOSAlert(CLPStr64, err, input);
         name[0] = 0;
         return;
     }
 
     if (!IsFileInOutputDirectory(&spec)) {
-        CLPReportWarning(61, OS_SpecToStringRelative(&spec, 0, STSbuf, sizeof(STSbuf)));
+        CLPReportWarning(CLPStr61, OS_SpecToStringRelative(&spec, 0, STSbuf, sizeof(STSbuf)));
     }
 
     OS_NameSpecToString(&spec.name, filename, 256);
     if (strlen(filename) >= maxlen) {
-        CLPReportWarning(65, filename, maxlen - 1);
+        CLPReportWarning(CLPStr65, filename, maxlen - 1);
         filename[maxlen - 1] = 0;
     }
 
@@ -469,7 +470,7 @@ void AddStringToHandle(Handle *h, const char *str) {
     AddStringLenToHandle(h, str, strlen(str));
 }
 
-int Opt_PrintVersion(const char *opt, void *var, const char *arg) {
+int Opt_PrintVersion(const char *opt, void *var, const char *arg, int flags) {
     ShowVersion(0);
     return 1;
 }
@@ -500,7 +501,7 @@ void GetFirstSourceFilenameBase(char *buffer, char *defaul) {
     strcpy(buffer, defaul);
 }
 
-int Opt_SavePrefs(const char *opt, void *var, const char *arg) {
+int Opt_SavePrefs(const char *opt, void *var, const char *arg, int flags) {
     Parser_StorePanels(parseopts.context);
     return 1;
 }
@@ -520,14 +521,14 @@ int ParseNumber(const char *arg, Boolean emit_error, SInt32 *ret, const char **e
         *endptr = end;
 
     if (*end && emit_error) {
-        CLPReportError(5, "", arg);
+        CLPReportError(CLPStr5, "", arg);
         return 0;
     }
 
     return 1;
 }
 
-int Opt_MaybeMoveAccessPaths(const char *opt, void *var, const char *arg) {
+int Opt_MaybeMoveAccessPaths(const char *opt, void *var, const char *arg, int flags) {
     if (dashIMinusMovesPaths && !usedDashIMinus)
         MoveSystemPathsIntoUserList();
     return 1;
diff --git a/unsorted/Projects.c b/unsorted/Projects.c
index 72b06b1..fda92df 100644
--- a/unsorted/Projects.c
+++ b/unsorted/Projects.c
@@ -1,6 +1,5 @@
-#include "mwcc_decomp.h"
+#include "parser.h"
 
-// TODO: figure out who defines this
 extern char STSbuf[256];
 
 int GetFileCount() {
diff --git a/unsorted/StaticParserGlue.c b/unsorted/StaticParserGlue.c
index 4673c27..c2e130d 100644
--- a/unsorted/StaticParserGlue.c
+++ b/unsorted/StaticParserGlue.c
@@ -1,4 +1,5 @@
-#include "mwcc_decomp.h"
+#include "parser.h"
+#include "cmdline.h"
 
 static BasePluginCallbacks cb = {
         parser_main,
diff --git a/unsorted/TargetOptimizer-ppc-mach.c b/unsorted/TargetOptimizer-ppc-mach.c
new file mode 100644
index 0000000..10fe33e
--- /dev/null
+++ b/unsorted/TargetOptimizer-ppc-mach.c
@@ -0,0 +1,69 @@
+#include "parser.h"
+
+char schedule_ppc_default;
+
+int TargetSetOptFlags(short val, Boolean set) {
+    switch (val) {
+        case 'Pe':
+            pBackEnd.peephole = set;
+            break;
+        case 'Sn':
+            pBackEnd.schedule = 0;
+            break;
+        case 'Sh':
+            pBackEnd.schedule = set;
+            break;
+        case 'S?':
+            pBackEnd.processor = schedule_ppc_default;
+            break;
+        case 'SG':
+            pBackEnd.processor = schedule_ppc_default = 0;
+            break;
+        case 'S1':
+            pBackEnd.processor = schedule_ppc_default = 1;
+            break;
+        case 'S3':
+            pBackEnd.processor = schedule_ppc_default = 2;
+            break;
+        case 'S#':
+            pBackEnd.processor = schedule_ppc_default = 3;
+            break;
+        case 'S4':
+            pBackEnd.processor = schedule_ppc_default = 4;
+            break;
+        case 'S%':
+            pBackEnd.processor = schedule_ppc_default = 5;
+            break;
+        case 'S7':
+            pBackEnd.processor = schedule_ppc_default = 6;
+            break;
+        case 'SA':
+            pBackEnd.processor = schedule_ppc_default = 7;
+            break;
+        default:
+            return 0;
+    }
+
+    return 1;
+}
+
+void TargetDisplayOptimizationOptions(Handle txt) {
+    if (!pBackEnd.schedule) {
+        HPrintF(txt, "\t- no instruction scheduling\n");
+    } else {
+        HPrintF(txt, "\t- schedule for %s\n",
+                (pBackEnd.processor == 0) ? "generic PPC" :
+                (pBackEnd.processor == 1) ? "601" :
+                (pBackEnd.processor == 2) ? "603" :
+                (pBackEnd.processor == 3) ? "603e" :
+                (pBackEnd.processor == 4) ? "604" :
+                (pBackEnd.processor == 5) ? "604e" :
+                (pBackEnd.processor == 6) ? "750" :
+                (pBackEnd.processor == 7) ? "Altivec" :
+                "???"
+                );
+    }
+}
+
+void TargetSetPragmaOptimizationsToUnspecified() {
+}
diff --git a/unsorted/Targets.c b/unsorted/Targets.c
index b4307ff..accad8b 100644
--- a/unsorted/Targets.c
+++ b/unsorted/Targets.c
@@ -1,4 +1,4 @@
-#include "mwcc_decomp.h"
+#include "parser.h"
 
 ParserTool *pTool;
 
@@ -18,8 +18,8 @@ Boolean ParserToolMatchesPlugin(OSType type, OSType lang, OSType cpu, OSType os)
     }
 
     if (
-            (type == CWFOURCHAR('*','*','*','*') || pTool->TYPE == CWFOURCHAR('*','*','*','*') || pTool->TYPE == type) &&
-            (lang == CWFOURCHAR('*','*','*','*') || pTool->LANG == CWFOURCHAR('*','*','*','*') || pTool->LANG == lang) &&
+            (type == CWDROPINANYTYPE || pTool->TYPE == CWDROPINANYTYPE || pTool->TYPE == type) &&
+            (lang == Lang_Any || pTool->LANG == Lang_Any || pTool->LANG == lang) &&
             (cpu == targetCPUAny || pTool->CPU == targetCPUAny || pTool->CPU == cpu) &&
             (os == targetOSAny || pTool->OS == targetOSAny || pTool->OS == os)
             )
diff --git a/unsorted/ToolHelpers-cc.c b/unsorted/ToolHelpers-cc.c
index dd0bc92..fee7517 100644
--- a/unsorted/ToolHelpers-cc.c
+++ b/unsorted/ToolHelpers-cc.c
@@ -1,6 +1,7 @@
-#include "mwcc_decomp.h"
+#include "parser.h"
+#include "cmdline.h"
 
-int Opt_DummyLinkerRoutine(const char *opt) {
+int Opt_DummyLinkerRoutine(const char *opt, void *, const char *, int) {
     CLPFatalError("Calling linker option '%s'\n", opt);
     return 0;
 }
diff --git a/unsorted/ToolHelpers.c b/unsorted/ToolHelpers.c
index 1942072..e872546 100644
--- a/unsorted/ToolHelpers.c
+++ b/unsorted/ToolHelpers.c
@@ -1,16 +1,16 @@
-#include "mwcc_decomp.h"
+#include "parser.h"
+#include "cmdline.h"
 #include <errno.h>
 
-// TODO: figure out who defines this
 extern char STSbuf[256];
 
 static Boolean setStage;
-SInt16 outputOrdering;
-Boolean setOutputDirectory;
-Boolean setLinkerOutputFilename;
 char linkerOutputFilename[256];
+Boolean setLinkerOutputFilename;
+Boolean setOutputDirectory;
+SInt16 outputOrdering;
 
-int Opt_HandleOutputName(const char *opt, void *, const char *filename) {
+int Opt_HandleOutputName(const char *opt, void *, const char *filename, int flags) {
     OSSpec spec;
     int err;
     SInt32 result;
@@ -21,7 +21,7 @@ int Opt_HandleOutputName(const char *opt, void *, const char *filename) {
 
     if ((pCmdLine.state == OptsCmdLineState_3 || (pCmdLine.state == OptsCmdLineState_0 && pTool->TYPE == CWDROPINLINKERTYPE)) && pCmdLine.toDisk != 4) {
         if (setLinkerOutputFilename) {
-            CLPReportError(41, filename);
+            CLPReportError(CLPStr41, filename);
             return 0;
         }
         setLinkerOutputFilename = 1;
@@ -33,7 +33,7 @@ int Opt_HandleOutputName(const char *opt, void *, const char *filename) {
             Boolean isfile;
             err = OS_MakeSpec(filename, &spec, &isfile);
             if (err) {
-                CLPOSAlert(64, err, filename);
+                CLPOSAlert(CLPStr64, err, filename);
                 return 0;
             }
             if (isfile)
@@ -44,14 +44,14 @@ int Opt_HandleOutputName(const char *opt, void *, const char *filename) {
     } else {
         err = OS_MakeSpec(filename, &spec, &isfile);
         if (err) {
-            CLPOSAlert(64, err, filename);
+            CLPOSAlert(CLPStr64, err, filename);
             return 0;
         }
 
         if (!err && !isfile) {
             FSSpec ofd;
             if (setOutputDirectory) {
-                CLPReportError(59, filename);
+                CLPReportError(CLPStr59, filename);
                 return 0;
             }
             setOutputDirectory = 1;
@@ -67,7 +67,7 @@ int Opt_HandleOutputName(const char *opt, void *, const char *filename) {
             SInt32 index;
             CWProjectFileInfo pfi;
             if (parseopts.lastoutputname[0]) {
-                CLPReportError(41, filename);
+                CLPReportError(CLPStr41, filename);
                 return 0;
             }
             strncpy(parseopts.lastoutputname, filename, 256);
@@ -115,7 +115,7 @@ int ValidateToolState(Boolean mustHaveFiles) {
         if (!parseopts.userSpecifiedFiles) {
             if (!parseopts.hadAnyOutput) {
                 if (mustHaveFiles) {
-                    CLPReportError(70);
+                    CLPReportError(CLPStr70);
                     return 0;
                 }
             } else {
@@ -124,7 +124,7 @@ int ValidateToolState(Boolean mustHaveFiles) {
                 return 1;
             }
         } else if (parseopts.unusedFiles > 0) {
-            CLPReportError(69);
+            CLPReportError(CLPStr69);
             return 0;
         }
     }
@@ -195,7 +195,7 @@ int Opt_DoNotLink(const char *opt, void *var, const char *arg) {
     return 1;
 }
 
-int Opt_IncreaseVerbosity(const char *opt, void *var, const char *arg) {
+int Opt_IncreaseVerbosity(const char *opt, void *var, const char *arg, int flags) {
     if (pCmdLine.verbose)
         pCmdLine.verbose++;
     else
@@ -275,13 +275,13 @@ int Opt_RedirectStream(const char *opt, void *file, const char *filename) {
 
     err = OS_MakeFileSpec(filename, &spec);
     if (err) {
-        CLPReportError(78, filename, OS_GetErrText(err));
+        CLPReportError(CLPStr78, filename, OS_GetErrText(err));
         return 0;
     }
 
     nw = freopen(OS_SpecToString(&spec, STSbuf, 256), "wt", (FILE *) file);
     if (!nw) {
-        CLPReportError(78, filename, strerror(errno));
+        CLPReportError(CLPStr78, filename, strerror(errno));
         return 0;
     }
 
diff --git a/unsorted/Utils.c b/unsorted/Utils.c
new file mode 100644
index 0000000..b627c4d
--- /dev/null
+++ b/unsorted/Utils.c
@@ -0,0 +1,174 @@
+#include "parser.h"
+
+int my_tolower(char c) {
+    if (c >= 'A' && c <= 'Z')
+        return c | 0x20;
+    else
+        return c;
+}
+
+int my_isdigit(char c) {
+    return (c >= '0' && c <= '9');
+}
+
+int my_isalpha(char c) {
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+}
+
+int my_isalnum(char c) {
+    return my_isdigit(c) || my_isalpha(c);
+}
+
+int my_isxdigit(char c) {
+    return my_isdigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
+}
+
+char *Utils_SpellList(char *list, char *buffer, char opts) {
+    char *sptr;
+    char *eptr;
+    char *nptr;
+    char *bptr;
+    int pflen;
+    int npflen;
+    int undo;
+    char *neptr;
+    int cnt;
+
+    undo = 0;
+    bptr = buffer;
+    sptr = list;
+    pflen = 0;
+    while (sptr) {
+        if ((opts & 1) && !pflen)
+            *(bptr++) = *MAINOPTCHAR;
+
+        eptr = strchr(sptr, '|');
+        if (!eptr) {
+            eptr = sptr + strlen(sptr);
+            nptr = 0;
+        } else if (eptr[1] == '|') {
+            nptr = 0;
+        } else {
+            nptr = eptr + 1;
+        }
+
+        if (undo == 0 && !pflen) {
+            if (opts & 8) {
+                *(bptr++) = '[';
+                *(bptr++) = 'n';
+                *(bptr++) = 'o';
+                *(bptr++) = ']';
+            }
+            if (opts & 0x20) {
+                *(bptr++) = '[';
+                *(bptr++) = 'n';
+                *(bptr++) = 'o';
+                *(bptr++) = '-';
+                *(bptr++) = ']';
+            }
+        }
+
+        npflen = 0;
+        if (nptr) {
+            while (sptr < nptr && *nptr && *nptr != '|' && sptr[npflen] == nptr[npflen])
+                npflen++;
+
+            if (npflen) {
+                neptr = strchr(nptr, '|');
+                if (!neptr)
+                    neptr = nptr + strlen(nptr);
+                if ((neptr - nptr) < (eptr - sptr) || ((sptr[1] && sptr[1] != '|') ? (sptr[1] != nptr[1]) : 0))
+                    npflen = 0;
+                if (opts & 0x40)
+                    npflen = 0;
+            }
+        }
+
+        if (pflen) {
+            sptr += pflen;
+            while (sptr < eptr) {
+                *(bptr++) = *(sptr++);
+            }
+            if (npflen > pflen) {
+                *(bptr++) = '[';
+                undo++;
+            }
+            if (npflen < pflen) {
+                *(bptr++) = ']';
+                undo--;
+            }
+        } else if (npflen) {
+            for (cnt = npflen; cnt > 0; cnt--) {
+                *(bptr++) = *(sptr++);
+            }
+            *(bptr++) = '[';
+            undo++;
+        }
+
+        while (sptr < eptr) {
+            *(bptr++) = *(sptr++);
+        }
+
+        if (opts & 0x10) {
+            *(bptr++) = '[';
+            *(bptr++) = '-';
+            *(bptr++) = ']';
+        }
+        if (opts & 0x40) {
+            *(bptr++) = '+';
+        }
+
+        sptr = nptr;
+        if (nptr && bptr[-1] != '[') {
+            if ((opts & 1) || (bptr[-1] == ']') || ((opts & 8) && !undo)) {
+                *(bptr++) = ' ';
+                *(bptr++) = '|';
+                *(bptr++) = ' ';
+            } else {
+                *(bptr++) = '|';
+            }
+        }
+
+        opts &= ~0x40;
+        pflen = npflen;
+    }
+
+    for (cnt = undo; cnt; cnt--) {
+        *(bptr++) = ']';
+    }
+
+    if (opts & 4)
+        bptr += sprintf(bptr, "=...");
+
+    *bptr = 0;
+    return bptr;
+}
+
+int Utils_CompareOptionString(const char *a, const char *b, int cased, int sticky) {
+    const char *ae;
+    const char *be;
+
+    for (ae = a; *ae && *ae != '|'; ae++) {}
+    for (be = b; *be && *be != '|'; be++) {}
+
+    if (sticky && (be - b) < (ae - a))
+        return 0;
+
+    if (cased) {
+        while (a < ae && b < be) {
+            if (*a != *b)
+                break;
+            a++;
+            b++;
+        }
+    } else {
+        while (a < ae && b < be) {
+            if (my_tolower(*a) != my_tolower(*b))
+                break;
+            a++;
+            b++;
+        }
+    }
+
+    return (a == ae) && (sticky || b == be);
+}
diff --git a/unsorted/uCOS.c b/unsorted/uCOS.c
new file mode 100644
index 0000000..5564e5b
--- /dev/null
+++ b/unsorted/uCOS.c
@@ -0,0 +1,292 @@
+#include "cw_common.h"
+#include "cos.h"
+
+extern Boolean systemHandles;
+
+static StringPtr COS_pstrcpy(StringPtr dst, ConstStringPtr src) {
+    short cnt;
+    for (cnt = src[0]; cnt >= 0; cnt--) {
+        *(dst++) = *(src++);
+    }
+    return dst;
+}
+
+static StringPtr COS_pstrcat(StringPtr dst, ConstStringPtr src) {
+    // not matching
+    short as;
+    short bs;
+
+    bs = *(src++);
+    as = dst[0];
+    if ((bs + as) > 255)
+        bs = 255 - as;
+
+    dst[0] += bs;
+    dst = &dst[as];
+    dst++;
+
+    while (bs-- > 0) {
+        *(dst++) = *(src++);
+    }
+    return dst;
+}
+
+static void COS_pstrcharcat(StringPtr to, char ch) {
+    if (to[0] < 255) {
+        to[0]++;
+        to[to[0]] = ch;
+    }
+}
+
+static short COS_pstrcmp(ConstStringPtr a, ConstStringPtr b) {
+    short as, bs;
+    if ((bs = *(b++)) != (as = *(a++)))
+        return 1;
+    while (as-- > 0) {
+        if (*(a++) != *(b++))
+            return 1;
+    }
+    return 0;
+}
+
+Handle COS_NewHandle(SInt32 byteCount) {
+    return NewHandle(byteCount);
+}
+
+Handle COS_NewOSHandle(SInt32 logicalSize) {
+    OSErr err;
+    Handle h;
+
+    if (systemHandles) {
+        h = TempNewHandle(logicalSize, &err);
+        if (!err)
+            return h;
+    }
+
+    return NULL;
+}
+
+void COS_FreeHandle(Handle handle) {
+    DisposeHandle(handle);
+}
+
+Boolean COS_ResizeHandle(Handle handle, SInt32 newSize) {
+    SetHandleSize(handle, newSize);
+    return LMGetMemErr() == noErr;
+}
+
+SInt32 COS_GetHandleSize(Handle handle) {
+    return GetHandleSize(handle);
+}
+
+void COS_LockHandle(Handle handle) {
+    HLock(handle);
+}
+
+void COS_LockHandleHi(Handle handle) {
+    HLockHi(handle);
+}
+
+void COS_UnlockHandle(Handle handle) {
+    HUnlock(handle);
+}
+
+int COS_GetHandleState(Handle handle) {
+    return HGetState(handle);
+}
+
+void COS_SetHandleState(Handle handle, int state) {
+    HSetState(handle, state);
+}
+
+Boolean COS_IsLockedState(int state) {
+    return (state & 0x80) >> 7;
+}
+
+char *COS_NewPtr(SInt32 byteCount) {
+    return NewPtr(byteCount);
+}
+
+char *COS_NewPtrClear(SInt32 byteCount) {
+    return NewPtrClear(byteCount);
+}
+
+void COS_FreePtr(char *ptr) {
+    DisposePtr(ptr);
+}
+
+void COS_AppendPtrToHandle(char *ptr1, Handle hand2, SInt32 size) {
+    PtrAndHand(ptr1, hand2, size);
+}
+
+OSErr COS_GetMemErr() {
+    return LMGetMemErr();
+}
+
+SInt32 COS_GetTicks() {
+    return LMGetTicks();
+}
+
+SInt32 COS_GetTime() {
+    return LMGetTime();
+}
+
+void COS_GetString(char *buffer, SInt16 strListID, SInt16 index) {
+    GetIndString((StringPtr) buffer, strListID, index);
+    p2cstr((StringPtr) buffer);
+}
+
+void COS_GetPString(StringPtr buffer, SInt16 strListID, SInt16 index) {
+    GetIndString((StringPtr) buffer, strListID, index);
+}
+
+Boolean COS_IsMultiByte(const char *str, int offset) {
+    return OS_IsMultiByte(str, offset);
+}
+
+OSErr COS_FileNew(const FSSpec *spec, SInt16 *refNum, OSType creator, OSType fileType) {
+    OSErr err;
+
+    HDelete(spec->vRefNum, spec->parID, spec->name);
+    err = HCreate(spec->vRefNum, spec->parID, spec->name, creator, fileType);
+    if (!err)
+        err = HOpenDF(spec->vRefNum, spec->parID, spec->name, fsRdWrPerm, refNum);
+    return err;
+}
+
+OSErr COS_FileOpen(const FSSpec *spec, SInt16 *refNum) {
+    return HOpenDF(spec->vRefNum, spec->parID, spec->name, fsRdPerm, refNum);
+}
+
+OSErr COS_FileGetType(const FSSpec *spec, OSType *fileType) {
+    OSErr err;
+    FInfo fi;
+
+    err = HGetFInfo(spec->vRefNum, spec->parID, spec->name, &fi);
+    *fileType = fi.fdType;
+    return err;
+}
+
+OSErr COS_FileGetSize(SInt16 refNum, SInt32 *logEOF) {
+    return GetEOF(refNum, logEOF);
+}
+
+OSErr COS_FileRead(SInt16 refNum, void *buffPtr, SInt32 count) {
+    return FSRead(refNum, &count, buffPtr);
+}
+
+OSErr COS_FileWrite(SInt16 refNum, const void *buffPtr, SInt32 count) {
+    return FSWrite(refNum, &count, buffPtr);
+}
+
+OSErr COS_FileGetPos(SInt16 refNum, SInt32 *filePos) {
+    return GetFPos(refNum, filePos);
+}
+
+OSErr COS_FileSetPos(SInt16 refNum, SInt32 filePos) {
+    return SetFPos(refNum, fsFromStart, filePos);
+}
+
+OSErr COS_FileClose(SInt16 refNum) {
+    return FSClose(refNum);
+}
+
+void COS_FileSetFSSpec(FSSpec *spec, ConstStringPtr path) {
+    char buf[256];
+    OSSpec ospec;
+
+    memcpy(buf, path + 1, path[0]);
+    buf[path[0]] = 0;
+
+    if (OS_MakeSpec(buf, &ospec, NULL) || OS_OSSpec_To_FSSpec(&ospec, spec)) {
+        spec->vRefNum = 0;
+        spec->parID = 0;
+        c2pstrcpy(spec->name, buf);
+    }
+}
+
+OSErr COS_FileMakeFSSpec(SInt16 vRefNum, SInt32 dirID, ConstStringPtr fileName, FSSpec *spec) {
+    int oerr;
+    OSPathSpec opspec;
+    char buf[256];
+    OSSpec ospec;
+
+    oerr = OS_VolDir_To_OSPathSpec(vRefNum, dirID, &opspec);
+    if (oerr)
+        return OS_MacError(oerr);
+
+    p2cstrcpy(buf, fileName);
+    oerr = OS_MakeSpecWithPath(&opspec, buf, 0, &ospec);
+    if (oerr) {
+        pstrncpy(spec->name, fileName, 256);
+        return OS_MacError(oerr);
+    } else {
+        return OS_MacError(OS_OSSpec_To_FSSpec(&ospec, spec));
+    }
+}
+
+OSErr COS_FileMakeFSSpecWithPath(const FSSpec *inputSpec, ConstStringPtr fileName, FSSpec *spec) {
+    spec->vRefNum = inputSpec->vRefNum;
+    spec->parID = inputSpec->parID;
+    COS_pstrcpy(spec->name, fileName);
+    return noErr;
+}
+
+OSErr COS_FileGetFileInfo(const FSSpec *spec, OSType *creator, OSType *fileType) {
+    OSErr err;
+    FInfo fi;
+    err = HGetFInfo(spec->vRefNum, spec->parID, spec->name, &fi);
+    if (fileType)
+        *fileType = fi.fdType;
+    if (creator)
+        *creator = fi.fdCreator;
+    return err;
+}
+
+void COS_FileGetFSSpecInfo(const FSSpec *spec, SInt16 *vRefNum, SInt32 *dirID, StringPtr fileName) {
+    if (vRefNum)
+        *vRefNum = spec->vRefNum;
+    if (dirID)
+        *dirID = spec->parID;
+    if (fileName)
+        COS_pstrcpy(fileName, spec->name);
+}
+
+static void COS_MakePath(SInt16 vRefNum, SInt32 dirID, StringPtr path) {
+    FSSpec fss;
+    OSSpec oss;
+    fss.vRefNum = vRefNum;
+    fss.parID = dirID;
+    COS_pstrcpy(fss.name, path);
+    if (!OS_FSSpec_To_OSSpec(&fss, &oss)) {
+        OS_SpecToString(&oss, (char *) path, 256);
+        c2pstr((char *) path);
+    }
+}
+
+void COS_FileGetPathName(char *buffer, const FSSpec *spec, SInt32 *mdDat) {
+    HParamBlockRec rec;
+
+    if (mdDat) {
+        rec.fileParam.ioNamePtr = (StringPtr) spec->name;
+        rec.fileParam.ioVRefNum = spec->vRefNum;
+        rec.fileParam.ioDirID = spec->parID;
+        rec.fileParam.ioFDirIndex = 0;
+        if (!PBHGetFInfoSync(&rec))
+            *mdDat = rec.fileParam.ioFlMdDat;
+        else
+            *mdDat = 0;
+    }
+
+    COS_pstrcpy((StringPtr) buffer, spec->name);
+    COS_MakePath(spec->vRefNum, spec->parID, (StringPtr) buffer);
+    p2cstr((StringPtr) buffer);
+}
+
+int COS_EqualFileSpec(const FSSpec *a, const FSSpec *b) {
+    if (a->vRefNum != b->vRefNum)
+        return 0;
+    if (a->parID != b->parID)
+        return 0;
+    return COS_pstrcmp(a->name, b->name) == 0;
+}
diff --git a/unsorted/uContextParser.cpp b/unsorted/uContextParser.cpp
index be1aa0a..35d6dfa 100644
--- a/unsorted/uContextParser.cpp
+++ b/unsorted/uContextParser.cpp
@@ -103,7 +103,7 @@ CW_CALLBACK CWParserStoreCommandLineForPlugin(CWPluginContext context, int index
     return cwNoErr;
 }
 
-CW_CALLBACK CWParserSetNamedPreferences(CWPluginContext context, const char *panelName, CWMemHandle paneldata) {
+CW_CALLBACK CWParserSetNamedPreferences(CWPluginContext context, const char *panelName, Handle paneldata) {
     CWParserContext *pc;
     if (!(pc = GetContext(context)))
         return cwErrInvalidCallback;
diff --git a/unsorted/uLibImporter.c b/unsorted/uLibImporter.c
new file mode 100644
index 0000000..3cf3475
--- /dev/null
+++ b/unsorted/uLibImporter.c
@@ -0,0 +1,103 @@
+#include "cw_common.h"
+#include "cos.h"
+
+static CWPluginContext compiler_context;
+
+static void pstrcpy(StringPtr dst, ConstStringPtr src) {
+    short len = src[0];
+    do {
+        *(dst++) = *(src++);
+    } while (len-- > 0);
+}
+
+static void ReportError(int index, int osErr) {
+    char buf[256];
+    COS_GetString(buf, 911, index);
+    if (osErr)
+        CWOSErrorMessage(compiler_context, buf, osErr);
+    else
+        CWReportMessage(compiler_context, NULL, buf, NULL, messagetypeError, 0);
+}
+
+static CWMemHandle ImportObjectLibrary(CWFileSpec *spec, SInt32 *codesize, SInt32 *udatasize, SInt32 *idatasize) {
+    int err;
+    short ref;
+    CWMemHandle mh;
+    UInt32 *ptr;
+    SInt32 fsize;
+
+    err = COS_FileOpen(spec, &ref);
+    if (err) {
+        ReportError(1, err);
+        return NULL;
+    }
+
+    err = COS_FileGetSize(ref, &fsize);
+    if (err) {
+        COS_FileClose(ref);
+        ReportError(1, err);
+        return NULL;
+    }
+
+    err = CWAllocMemHandle(compiler_context, 8, 1, &mh);
+    if (err) {
+        COS_FileClose(ref);
+        ReportError(1, err);
+        return NULL;
+    }
+
+    err = CWLockMemHandle(compiler_context, mh, 0, (void **) &ptr);
+    if (err) {
+        COS_FileClose(ref);
+        CWFreeMemHandle(compiler_context, mh);
+        ReportError(1, err);
+        return NULL;
+    }
+
+    err = COS_FileRead(ref, ptr, 8);
+    if (err != (short) err) {
+        ReportError(1, err);
+        return NULL;
+    }
+
+    COS_FileClose(ref);
+
+    if (ptr[0] != 0xFEEDFACE && ptr[0] != 0xCAFEBABE && ptr[0] != CWFOURCHAR('!','<','a','r') && ptr[1] != CWFOURCHAR('c','h','>','\n')) {
+        CWFreeMemHandle(compiler_context, mh);
+        ReportError(2, 0);
+        return NULL;
+    }
+
+    CWUnlockMemHandle(compiler_context, mh);
+    *codesize = fsize;
+    *udatasize = 0;
+    *idatasize = 0;
+    return mh;
+}
+
+CWPLUGIN_ENTRY(PPCLibImport_main)(CWPluginContext context) {
+    SInt32 request;
+    CWResult result;
+    CWFileSpec fss;
+    SInt32 fileNumber;
+    CWObjectData od;
+
+    result = cwNoErr;
+
+    CWGetPluginRequest(context, &request);
+    switch (request) {
+        case reqInitialize:
+        case reqTerminate:
+            break;
+        case 0:
+            compiler_context = context;
+            CWGetMainFileSpec(context, &fss);
+            CWGetMainFileNumber(context, &fileNumber);
+            memset(&od, 0, sizeof(od));
+            od.objectdata = ImportObjectLibrary(&fss, &od.codesize, &od.udatasize, &od.idatasize);
+            result = CWDonePluginRequest(context, od.objectdata ? CWStoreObjectData(context, fileNumber, &od) : cwErrRequestFailed);
+            break;
+    }
+
+    return result;
+}