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

5 files changed, 1125 insertions, 0 deletions

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