#include "compiler/CPrec.h"
#include "compiler/CError.h"
#include "compiler/CFunc.h"
#include "compiler/CInit.h"
#include "compiler/CInline.h"
#include "compiler/CMachine.h"
#include "compiler/CObjC.h"
#include "compiler/CParser.h"
#include "compiler/CPrep.h"
#include "compiler/CScope.h"
#include "compiler/CSOM.h"
#include "compiler/CTemplateNew.h"
#include "compiler/CompilerTools.h"
#include "compiler/Exceptions.h"
#include "compiler/enode.h"
#include "compiler/objc.h"
#include "compiler/objects.h"
#include "compiler/scopes.h"
#include "compiler/som.h"
#include "compiler/templates.h"
#include "compiler/types.h"
#include "cos.h"
#include "compiler/CCompiler.h"
#include "compiler/InlineAsm.h"

#define RESOLVE_BUFFER(offset) ((void *) (((char *) cprec_buffer) + ((uintptr_t) (offset))))
#define RESOLVE_RAW_BUFFER(offset) ((void *) (((char *) cprec_rawbuffer) + ((uintptr_t) (offset))))
#define RESOLVE_SAFE(offset) (!(offset) ? NULL : ((void *) (((char *) cprec_rawbuffer) + ((uintptr_t) (offset)))))

#ifdef __MWERKS__
#pragma options align=mac68k
#endif
typedef struct StaticData {
    struct StaticData *next;
    Object *object;
    void *buffer;
    OLinkList *links;
    SInt32 size;
} StaticData;

typedef struct Header {
    UInt32 magic;
    UInt16 version;
    UInt16 x6;
    char target;
    Boolean check_header_flags;
    Boolean cplusplus;
    UInt32 xC;
    UInt32 x10;
    UInt32 x14;
    UInt32 x18;
    UInt32 x1C;
    UInt32 x20;
    UInt32 x24;
    UInt32 x28;
    UInt32 x2C;
    UInt32 x30;
    UInt32 compressedPatchCount;
    UInt32 compressedPatchSize;
    UInt32 compressedPatchOffset;
    UInt32 builtinPatchSize;
    UInt32 builtinPatchOffset;
    UInt32 tokenStreamPatchSize;
    UInt32 tokenStreamPatchOffset;
    UInt32 root_names;
    NameSpaceList *usings;
    TemplClass *ctempl_templates;
    CSOMStub *csom_stubs;
    StaticData *cprec_staticdata;
    UInt32 uniqueID;
    CallbackAction *callbackactions;
    Type *cobjc_type_class;
    Type *cobjc_type_id;
    Type *cobjc_type_sel;
    ObjCSelector **cobjc_selhashtable;
    BClassList *cobjc_classdefs;
    ObjCProtocol *cobjc_protocols;
    UInt32 cobjc_selrefcount;
    UInt32 cobjc_classrefcount;
    UInt32 cobjc_stringcount;
    InitExpr *init_expressions;
    CI_Action *cinline_tactionlist;
    TemplateFunction *ctempl_templatefuncs;
    UInt32 x9C;
    UInt32 xA0;
    UInt32 xA4;
    UInt32 xA8;
    UInt32 xAC;
    UInt32 xB0;
    UInt32 xB4;
    UInt32 xB8;
    UInt32 xBC;
    UInt32 xC0;
    UInt32 xC4;
    UInt32 xC8;
    UInt32 xCC;
    UInt32 xD0;
    UInt32 xD4;
    UInt32 xD8;
    UInt32 xDC;
    UInt32 xE0;
    UInt32 xE4;
    HashNameNode *nametable[0x800];
    Macro *macrotable[0x800];
    NameSpaceName *root_nametable[0x400];
} Header;

typedef struct Patch {
    struct Patch *next;
    SInt32 offset;
} Patch;

typedef struct AddrPatch {
    struct AddrPatch *next;
    void *addr;
    void *value;
} AddrPatch;

typedef struct BuiltIn {
    void *target;
    SInt32 idx;
    Patch *patches;
} BuiltIn;

static Boolean cprec_exportargnames;
static Boolean cprec_dowrite;
static OSErr cprec_ioerror;
static void *cprec_rawbuffer;
static void *cprec_buffer;
static SInt32 cprec_zero_offset;
static SInt32 cprec_offset;
static int cprec_builtins;
static void **cprec_builtin_array;

typedef struct TokenPatch {
    struct TokenPatch *next;
    TStreamElement *tokens;
    SInt32 count;
} TokenPatch;
static TokenPatch *cprec_tokenpatches;
static StaticData *cprec_staticdata;

typedef struct PointerHash {
    struct PointerHash *next;
    TypePointer *tptr;
    TypePointer *prec_tptr;
} PointerHash;
static PointerHash **cprec_pointerhash;

static BuiltIn *cprec_builtin;
static Patch *cprec_patch_list;
static AddrPatch **cprec_addrhash;
static Header *cprec_header;
static GList cprec_glist;
static short cprec_refnum;
char *precomp_target_str;
#ifdef __MWERKS__
#pragma options align=reset
#endif

// Assorted forward declarations
static NameSpace *CPrec_GetNameSpacePatch(NameSpace *nspace);
static ObjEnumConst *CPrec_GetObjEnumConstPatch(ObjEnumConst *obj);
static Object *CPrec_GetObjectPatch(Object *obj);
static ObjBase *CPrec_GetObjBasePatch(ObjBase *obj);
static ObjMemberVar *CPrec_GetObjMemberVarPatch(ObjMemberVar *ivar);
static Type *CPrec_GetTypePatch(Type *type);
static ENode *CPrec_GetExpressionPatch(ENode *expr);
static ObjCMethod *CPrec_GetObjCMethodPatch(ObjCMethod *meth);
static ObjCProtocolList *CPrec_GetObjCProtocolListPatch(ObjCProtocolList *lst);
static TemplArg *CPrec_GetTemplateArgPatch(TemplArg *arg);
static NameSpaceObjectList *CPrec_GetNameSpaceObjectListPatch(NameSpaceObjectList *nsol);
static OSErr CPrec_FlushBufferCheck(void);

void SetupPrecompiler(Boolean isPrecompiling) {
    cprec_refnum = 0;
    cprec_glist.data = NULL;
    cprec_header = NULL;
    cprec_staticdata = NULL;
    cprec_ioerror = noErr;
}

void CleanupPrecompiler(void) {
    if (cprec_refnum) {
        COS_FileClose(cprec_refnum);
        cprec_refnum = 0;
    }

    if (cprec_glist.data)
        FreeGList(&cprec_glist);
}

static OLinkList *CPrec_OLinkListCopy(OLinkList *list) {
    OLinkList *copy;

    if (!list)
        return NULL;

    copy = galloc(sizeof(OLinkList));
    *copy = *list;
    copy->next = CPrec_OLinkListCopy(copy->next);
    return copy;
}

void PreComp_StaticData(Object *obj, const void *data, OLinkList *links, SInt32 size) {
    StaticData *entry;

    if (obj->sclass != TK_STATIC && !(obj->qual & (Q_20000 | Q_OVERLOAD)))
        CError_Error(CErrorStr180);

    entry = galloc(sizeof(StaticData));
    entry->object = obj;
    entry->size = size;

    entry->next = cprec_staticdata;
    cprec_staticdata = entry;

    if (data) {
        entry->buffer = galloc(obj->type->size);
        memcpy(entry->buffer, data, obj->type->size);
    } else {
        entry->buffer = NULL;
    }

    entry->links = CPrec_OLinkListCopy(links);
}

static void CPrec_InitAddressHashTable(void) {
    cprec_addrhash = lalloc(0x4000 * sizeof(AddrPatch *));
    memclrw(cprec_addrhash, 0x4000 * sizeof(AddrPatch *));
}

static void CPrec_InitPointerHashTable(void) {
    cprec_pointerhash = lalloc(0x400 * sizeof(PointerHash *));
    memclrw(cprec_pointerhash, 0x400 * sizeof(PointerHash *));
}

static int CPrec_AddressHashVal(void *addr) {
    UInt32 v = (UInt32) addr;
    return (
                   v +
                   ((unsigned char *) &v)[0] +
                           ((unsigned char *) &v)[1] +
                           ((unsigned char *) &v)[2] +
                           ((unsigned char *) &v)[3]
            ) & 0x3FFF;
}

static AddrPatch *CPrec_FindAddrPatch(void *addr) {
    AddrPatch *scan;

    for (scan = cprec_addrhash[CPrec_AddressHashVal(addr)]; scan; scan = scan->next) {
        if (scan->addr == addr)
            return scan;
    }

    return NULL;
}

static AddrPatch *CPrec_NewAddrPatch(void *addr, void *value) {
    AddrPatch **loc;
    AddrPatch *patch;

    loc = cprec_addrhash + CPrec_AddressHashVal(addr);
    patch = lalloc(sizeof(AddrPatch));
    patch->addr = addr;
    patch->value = value;
    patch->next = *loc;
    *loc = patch;
    return patch;
}

static void CPrec_SetupBuiltInArray(void) {
    int count1, count2;
    Boolean flag;
    void **array;

#define REG_BUILTIN(a) \
    if (!flag) { array[count2++] = (a); } else { count1++; }

    for (count2 = count1 = 0, flag = 1; ;) {
        REG_BUILTIN(cscope_root);
        REG_BUILTIN(&stvoid);
        REG_BUILTIN(&stbool);
        REG_BUILTIN(&stchar);
        REG_BUILTIN(&stsignedchar);
        REG_BUILTIN(&stunsignedchar);
        REG_BUILTIN(&stwchar);
        REG_BUILTIN(&stsignedshort);
        REG_BUILTIN(&stunsignedshort);
        REG_BUILTIN(&stsignedint);
        REG_BUILTIN(&stunsignedint);
        REG_BUILTIN(&stsignedlong);
        REG_BUILTIN(&stunsignedlong);
        REG_BUILTIN(&stsignedlonglong);
        REG_BUILTIN(&stunsignedlonglong);
        REG_BUILTIN(&stfloat);
        REG_BUILTIN(&stshortdouble);
        REG_BUILTIN(&stdouble);
        REG_BUILTIN(&stlongdouble);
        REG_BUILTIN(&elipsis);
        REG_BUILTIN(&oldstyle);
        REG_BUILTIN(&stillegal);
        REG_BUILTIN(&sttemplexpr);
        REG_BUILTIN(&stvoid);
        REG_BUILTIN(&void_ptr);
        REG_BUILTIN(&rt_func);
        REG_BUILTIN(&catchinfostruct);
        REG_BUILTIN(newh_func);
        REG_BUILTIN(delh_func);
        REG_BUILTIN(copy_func);
        REG_BUILTIN(clear_func);
        REG_BUILTIN(Rgtid_func);
        REG_BUILTIN(Rdync_func);
        REG_BUILTIN(rt_ptmf_cast);
        REG_BUILTIN(rt_ptmf_cmpr);
        REG_BUILTIN(rt_ptmf_test);
        REG_BUILTIN(rt_ptmf_call);
        REG_BUILTIN(rt_ptmf_scall);
        REG_BUILTIN(rt_ptmf_null);
        REG_BUILTIN(rt_som_glue1);
        REG_BUILTIN(rt_som_glue2);
        REG_BUILTIN(rt_som_glue3);
        REG_BUILTIN(rt_som_check);
        REG_BUILTIN(rt_som_new);
        REG_BUILTIN(rt_som_newcheck);
        REG_BUILTIN(rt_ptmf_call4);
        REG_BUILTIN(rt_ptmf_scall4);
        REG_BUILTIN(carr_func);
        REG_BUILTIN(cnar_func);
        REG_BUILTIN(darr_func);
        REG_BUILTIN(dnar_func);
        REG_BUILTIN(dnar3_func);
        REG_BUILTIN(Xgreg_func);
        REG_BUILTIN(Xthrw_func);
        REG_BUILTIN(Xicth_func);
        REG_BUILTIN(Xecth_func);
        REG_BUILTIN(Xunex_func);
        REG_BUILTIN(&stvectorunsignedchar);
        REG_BUILTIN(&stvectorsignedchar);
        REG_BUILTIN(&stvectorboolchar);
        REG_BUILTIN(&stvectorunsignedshort);
        REG_BUILTIN(&stvectorsignedshort);
        REG_BUILTIN(&stvectorboolshort);
        REG_BUILTIN(&stvectorunsignedlong);
        REG_BUILTIN(&stvectorsignedlong);
        REG_BUILTIN(&stvectorboollong);
        REG_BUILTIN(&stvectorfloat);
        REG_BUILTIN(&stvectorpixel);

        if (flag) {
            array = lalloc(sizeof(void *) * count1);
            cprec_builtin_array = array;
            cprec_builtins = count1;
            flag = 0;
        } else {
            return;
        }
    }
}

static void CPrec_SetupBuiltIn(void) {
    int x;

    CPrec_SetupBuiltInArray();
    cprec_builtin = lalloc(sizeof(BuiltIn) * cprec_builtins);
    memclrw(cprec_builtin, sizeof(BuiltIn) * cprec_builtins);

    for (x = 0; x < cprec_builtins; x++) {
        cprec_builtin[x].target = cprec_builtin_array[x];
        cprec_builtin[x].idx = ~x;
        CPrec_NewAddrPatch(cprec_builtin[x].target, (void *) cprec_builtin[x].idx);
    }
}

static void CPrec_NewPointerPatch(void *src, void *ptr) {
    if (cprec_dowrite) {
        Patch *patch = lalloc(sizeof(Patch));
        patch->offset = (SInt32) src;
        CError_ASSERT(507, (patch->offset & 0x80000001) == 0);

        if ((SInt32) ptr < 0) {
            ptr = (void *) ~((SInt32) ptr);
            CError_ASSERT(513, (SInt32) ptr < cprec_builtins);

            patch->next = cprec_builtin[(SInt32) ptr].patches;
            cprec_builtin[(SInt32) ptr].patches = patch;
            ptr = NULL;
        } else {
            patch->next = cprec_patch_list;
            cprec_patch_list = patch;
        }

        src = (void *)((char *) src - cprec_zero_offset);
        CError_ASSERT(525, (SInt32) src >= 0 && (SInt32) src <= cprec_glist.size);
        *((void **) (*cprec_glist.data + (SInt32) src)) = ptr;
    }
}

static void CPrec_ExistingPointerPatch(void *src, void *ptr) {
    if (cprec_dowrite) {
        AddrPatch *addrPatch;
        Patch *patch;

        CError_ASSERT(543, addrPatch = CPrec_FindAddrPatch(ptr));

        patch = lalloc(sizeof(Patch));
        patch->offset = (SInt32) src;
        patch->next = cprec_patch_list;
        cprec_patch_list = patch;

        CError_ASSERT(548, (patch->offset & 0x80000001) == 0);

        src = (void *)((char *) src - cprec_zero_offset);
        CError_ASSERT(552, (SInt32) src >= 0 && (SInt32) src <= cprec_glist.size);
        *((void **) (*cprec_glist.data + (SInt32) src)) = addrPatch->value;
    }
}

static void CPrec_NamePatch(void *src, HashNameNode *name) {
    name->id = 1;
    CPrec_ExistingPointerPatch(src, name);
}

static void *CPrec_AppendAlign(void) {
    if (cprec_dowrite) {
        while (cprec_offset & 3) {
            AppendGListByte(&cprec_glist, 0);
            ++cprec_offset;
        }
    }

    return (void *) cprec_offset;
}

static UInt32 CPrec_AppendByte(UInt8 v) {
    if (cprec_dowrite)
        AppendGListByte(&cprec_glist, v);
    return cprec_offset++;
}

static UInt32 CPrec_AppendWord16(UInt16 v) {
    UInt32 offset;
    if (cprec_dowrite)
        AppendGListWord(&cprec_glist, v);
    offset = cprec_offset;
    cprec_offset += 2;
    return offset;
}

static UInt32 CPrec_AppendWord32(UInt32 v) {
    UInt32 offset;
    if (cprec_dowrite)
        AppendGListLong(&cprec_glist, v);
    offset = cprec_offset;
    cprec_offset += 4;
    return offset;
}

static UInt32 CPrec_AppendPointer(void *v) {
    UInt32 offset;
    if (cprec_dowrite)
        AppendGListLong(&cprec_glist, (SInt32) v);
    offset = cprec_offset;
    cprec_offset += 4;
    return offset;
}

static UInt32 CPrec_AppendPointerPatch(void *v) {
    AddrPatch *addrPatch;

    if (v) {
        CError_ASSERT(644, addrPatch = CPrec_FindAddrPatch(v));

        if (cprec_dowrite) {
            Patch *patch = lalloc(sizeof(Patch));
            patch->offset = cprec_offset;
            patch->next = cprec_patch_list;
            cprec_patch_list = patch;
            CError_ASSERT(651, (patch->offset & 0x80000001) == 0);
        }

        return CPrec_AppendPointer(addrPatch->value);
    } else {
        return CPrec_AppendPointer(NULL);
    }
}

static void CPrec_AppendNamePatch(HashNameNode *name) {
    if (name) {
        CPrec_AppendPointerPatch(name);
        name->id = 1;
    }
}

static void CPrec_AppendString(const char *str) {
    int len = strlen(str) + 1;
    if (cprec_dowrite)
        AppendGListData(&cprec_glist, str, len);
    cprec_offset += len;
}

static void CPrec_AppendData(const void *data, int len) {
    if (cprec_dowrite)
        AppendGListData(&cprec_glist, data, len);
    cprec_offset += len;
}

static void CPrec_RawMemPatch(void *source, const void *data, int len) {
    void *ptr = CPrec_AppendAlign();
    CPrec_AppendData(data, len);
    CPrec_NewPointerPatch(source, ptr);
}

static void CPrec_DumpNameTable(void) {
    HashNameNode *name;
    int i;
    HashNameNode *p;
    HashNameNode *next;

    if (cprec_dowrite) {
        i = 0;
        do {
            name = name_hash_nodes[i];
            while (name && name->id == 0)
                name = name->next;

            if (name) {
                p = CPrec_AppendAlign();
                cprec_header->nametable[i] = p;

                while (1) {
                    CPrec_NewAddrPatch(name, p);
                    CPrec_AppendPointer(NULL);
                    CPrec_AppendWord32(0);
                    CPrec_AppendWord16(name->hashval);
                    CPrec_AppendString(name->name);

                    name = name->next;
                    while (name && name->id == 0)
                        name = name->next;

                    if (!name)
                        break;

                    next = CPrec_AppendAlign();
                    CPrec_NewPointerPatch(&p->next, next);
                    p = next;
                }
            }
        } while (++i < 0x800);
    } else {
        i = 0;
        do {
            if ((name = name_hash_nodes[i])) {
                p = CPrec_AppendAlign();
                while (1) {
                    CPrec_NewAddrPatch(name, p);
                    CPrec_AppendPointer(NULL);
                    CPrec_AppendWord32(0);
                    CPrec_AppendWord16(name->hashval);
                    CPrec_AppendString(name->name);

                    name = name->next;
                    if (!name)
                        break;

                    next = CPrec_AppendAlign();
                    CPrec_NewPointerPatch(&p->next, next);
                    p = next;
                }
            }
        } while (++i < 0x800);
    }
}

static void CPrec_DumpMacroTable(void) {
    Macro *macro;
    int i;
    int j;
    Macro *p;
    Macro *next;

    i = 0;
    do {
        for (macro = macrohashtable[i]; macro; macro = macro->next) {
            if (macro->c) {
                CPrec_NewAddrPatch(macro->c, (void *) cprec_offset);
                CPrec_AppendString(macro->c);
            }
        }
    } while (++i < 0x800);

    i = 0;
    do {
        macro = macrohashtable[i];

        if (macro) {
            p = CPrec_AppendAlign();
            if (cprec_dowrite)
                cprec_header->macrotable[i] = p;

            while (1) {
                CPrec_AppendPointer(NULL);
                CPrec_AppendNamePatch(macro->name);
                CPrec_AppendPointerPatch(macro->c);
                CPrec_AppendWord16(macro->xC);
                CPrec_AppendByte(macro->is_special);
                CPrec_AppendByte(macro->xF);

                for (j = 1; j < (macro->xC & 0x7FFF); j++)
                    CPrec_AppendNamePatch(macro->names[j - 1]);

                macro = macro->next;
                if (!macro)
                    break;

                next = CPrec_AppendAlign();
                CPrec_NewPointerPatch(&p->next, next);
                p = next;
            }
        }
    } while (++i < 0x800);
}

static BClassList *CPrec_GetClassAccessPatch(BClassList *path) {
    AddrPatch *addrPatch;
    BClassList *first, *current, *next;

    if ((addrPatch = CPrec_FindAddrPatch(path)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(path, first);

    while (1) {
        CPrec_AppendData(path, sizeof(BClassList));
        CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(path->type));
        if (!path->next)
            break;

        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        path = path->next;
    }

    return first;
}

static int CPrec_PointerHash(TypePointer *type) {
    Type *target;
    int work;
    FuncArg *arg;

    work = type->qual;
    target = type->target;

restart:
    switch (target->type) {
        case TYPECLASS:
            if (TYPE_CLASS(target)->classname)
                work += TYPE_CLASS(target)->classname->hashval;
            break;
        case TYPEENUM:
            if (TYPE_ENUM(target)->enumname)
                work += TYPE_ENUM(target)->enumname->hashval;
            target = TYPE_ENUM(target)->enumtype;
            work += 3;
        case TYPEINT:
        case TYPEFLOAT:
            work += TYPE_INTEGRAL(target)->integral;
            break;
        case TYPEPOINTER:
            work += TYPE_POINTER(target)->qual;
            target = TYPE_POINTER(target)->target;
            goto restart;
        case TYPEARRAY:
            work += target->size;
            target = TYPE_POINTER(target)->target;
            goto restart;
        case TYPEFUNC:
            work += TYPE_FUNC(target)->functype->type;
            work += TYPE_FUNC(target)->functype->size;
            for (arg = TYPE_FUNC(target)->args; arg; arg = arg->next) {
                if (arg->type) {
                    work += arg->type->type;
                    work += arg->type->size;
                }
            }
            break;
    }

    work += target->type + target->size;
    return (work + (work >> 24) + (work >> 16) + (work >> 8)) & 0x3FF;
}

static TypePointer *CPrec_GetTypePointerPatch(TypePointer *tptr) {
    TypePointer *p;
    int hash;
    PointerHash *phash;
    TypePointer *scan1;
    TypePointer *scan2;

    if (tptr->qual & Q_100000) {
        p = CPrec_AppendAlign();
        CPrec_NewAddrPatch(tptr, p);
        CPrec_AppendData(tptr, sizeof(TypeObjCID));
        if (TYPE_OBJC_ID(tptr)->protocols)
            CPrec_NewPointerPatch(&TYPE_OBJC_ID(p)->protocols, CPrec_GetObjCProtocolListPatch(TYPE_OBJC_ID(tptr)->protocols));
    } else {
        if (!copts.faster_pch_gen && cprec_dowrite && tptr->size > 0) {
            hash = CPrec_PointerHash(tptr);
            for (phash = cprec_pointerhash[hash]; phash; phash = phash->next) {
                scan1 = tptr;
                scan2 = phash->tptr;
            check_again:
                if (scan1->type == scan2->type && scan1->size == scan2->size && scan1->qual == scan2->qual) {
                    scan1 = TYPE_POINTER(TPTR_TARGET(scan1));
                    scan2 = TYPE_POINTER(TPTR_TARGET(scan2));
                    if (scan1->type == TYPEPOINTER && scan1->type == TYPEARRAY)
                        goto check_again;
                    if (scan1 == scan2)
                        return phash->prec_tptr;
                }
            }

            p = CPrec_AppendAlign();
            CPrec_NewAddrPatch(tptr, p);

            phash = lalloc(sizeof(PointerHash));
            phash->tptr = tptr;
            phash->prec_tptr = p;
            phash->next = cprec_pointerhash[hash];
            cprec_pointerhash[hash] = phash;
        } else {
            p = CPrec_AppendAlign();
            CPrec_NewAddrPatch(tptr, p);
        }

        CPrec_AppendData(tptr, sizeof(TypePointer));
    }

    CPrec_NewPointerPatch(&p->target, CPrec_GetTypePatch(tptr->target));
    return p;
}

static TypeEnum *CPrec_GetTypeEnumPatch(TypeEnum *type) {
    TypeEnum *p = CPrec_AppendAlign();

    CPrec_NewAddrPatch(type, p);
    CPrec_AppendData(type, sizeof(TypeEnum));

    if (type->nspace)
        CPrec_NewPointerPatch(&p->nspace, CPrec_GetNameSpacePatch(type->nspace));
    if (type->enumlist)
        CPrec_NewPointerPatch(&p->enumlist, CPrec_GetObjEnumConstPatch(type->enumlist));

    CPrec_NewPointerPatch(&p->enumtype, CPrec_GetTypePatch(type->enumtype));
    if (type->enumname)
        CPrec_NamePatch(&p->enumname, type->enumname);

    return p;
}

static TypeBitfield *CPrec_GetTypeBitfieldPatch(TypeBitfield *type) {
    TypeBitfield *p = CPrec_AppendAlign();

    CPrec_NewAddrPatch(type, p);
    CPrec_AppendData(type, sizeof(TypeBitfield));
    CPrec_NewPointerPatch(&p->bitfieldtype, CPrec_GetTypePatch(type->bitfieldtype));

    return p;
}

static TypeStruct *CPrec_GetTypeStructPatch(TypeStruct *tstruct) {
    StructMember *member;
    TypeStruct *p;
    StructMember *current, *next;

    p = CPrec_AppendAlign();
    CPrec_NewAddrPatch(tstruct, p);
    CPrec_AppendData(tstruct, sizeof(TypeStruct));

    if (tstruct->name)
        CPrec_NamePatch(&p->name, tstruct->name);

    if ((member = tstruct->members)) {
        current = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&p->members, current);

        while (1) {
            CPrec_AppendData(member, sizeof(StructMember));
            CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(member->type));
            CPrec_NamePatch(&current->name, member->name);

            if (!member->next)
                break;

            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&current->next, next);
            current = next;

            member = member->next;
        }
    }

    return p;
}

static ExceptSpecList *CPrec_GetExceptSpecPatch(ExceptSpecList *exspec) {
    ExceptSpecList *first, *current, *next;

    first = current = CPrec_AppendAlign();
    while (exspec) {
        CPrec_AppendData(exspec, sizeof(ExceptSpecList));
        if (exspec->type)
            CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(exspec->type));

        if (!exspec->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        exspec = exspec->next;
    }

    return first;
}

static FuncArg *CPrec_GetArgListPatch(FuncArg *lst, Boolean includeNames) {
    FuncArg *first, *current, *next;
    AddrPatch *addrPatch;

    if ((addrPatch = CPrec_FindAddrPatch(lst)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    while (1) {
        if (!includeNames)
            lst->name = NULL;
        CPrec_AppendData(lst, sizeof(FuncArg));
        if (includeNames && lst->name)
            CPrec_NamePatch(&current->name, lst->name);

        if (lst->dexpr)
            CPrec_NewPointerPatch(&current->dexpr, CPrec_GetExpressionPatch(lst->dexpr));
        if (lst->type)
            CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(lst->type));
        else
            CError_FATAL(1167);

        if (!lst->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(lst->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        }

        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        lst = lst->next;
        CPrec_NewAddrPatch(lst, next);
    }

    return first;
}

static TypeFunc *CPrec_GetTypeFuncPatch(TypeFunc *type) {
    TypeFunc *p = CPrec_AppendAlign();
    CPrec_NewAddrPatch(type, p);

    CPrec_AppendData(type, (type->flags & FUNC_FLAGS_METHOD) ? sizeof(TypeMethod) : sizeof(TypeFunc));

    CPrec_NewPointerPatch(&p->functype, CPrec_GetTypePatch(type->functype));
    if (type->args)
        CPrec_NewPointerPatch(&p->args, CPrec_GetArgListPatch(type->args, (type->flags & FUNC_FLAGS_900000) != 0));
    if (type->exspecs)
        CPrec_NewPointerPatch(&p->exspecs, CPrec_GetExceptSpecPatch(type->exspecs));
    if (type->flags & FUNC_FLAGS_METHOD)
        CPrec_NewPointerPatch(&TYPE_METHOD(p)->theclass, CPrec_GetTypePatch((Type *) TYPE_METHOD(type)->theclass));

    return p;
}

static TypeMemberPointer *CPrec_GetTypeMemberPointerPatch(TypeMemberPointer *type) {
    TypeMemberPointer *p = CPrec_AppendAlign();
    CPrec_NewAddrPatch(type, p);

    CPrec_AppendData(type, sizeof(TypeMemberPointer));

    CPrec_NewPointerPatch(&p->ty1, CPrec_GetTypePatch(type->ty1));
    CPrec_NewPointerPatch(&p->ty2, CPrec_GetTypePatch(type->ty2));

    return p;
}

static TypeTemplDep *CPrec_GetTypeTemplDepPatch(TypeTemplDep *type) {
    TypeTemplDep *p = CPrec_AppendAlign();
    CPrec_NewAddrPatch(type, p);

    CPrec_AppendData(type, sizeof(TypeTemplDep));

    switch (type->dtype) {
        case TEMPLDEP_ARGUMENT:
            break;
        case TEMPLDEP_QUALNAME:
            CPrec_NewPointerPatch(&p->u.qual.type, CPrec_GetTypeTemplDepPatch(type->u.qual.type));
            CPrec_NamePatch(&p->u.qual.name, type->u.qual.name);
            break;
        case TEMPLDEP_TEMPLATE:
            CPrec_NewPointerPatch(&p->u.templ.templ, CPrec_GetTypePatch((Type *) type->u.templ.templ));
            CPrec_NewPointerPatch(&p->u.templ.args, CPrec_GetTemplateArgPatch(type->u.templ.args));
            break;
        case TEMPLDEP_ARRAY:
            CPrec_NewPointerPatch(&p->u.array.type, CPrec_GetTypePatch(type->u.array.type));
            CPrec_NewPointerPatch(&p->u.array.index, CPrec_GetExpressionPatch(type->u.array.index));
            break;
        case TEMPLDEP_QUALTEMPL:
            CPrec_NewPointerPatch(&p->u.qualtempl.type, CPrec_GetTypeTemplDepPatch(type->u.qualtempl.type));
            CPrec_NewPointerPatch(&p->u.qualtempl.args, CPrec_GetTemplateArgPatch(type->u.qualtempl.args));
            break;
        case TEMPLDEP_BITFIELD:
            CPrec_NewPointerPatch(&p->u.bitfield.type, CPrec_GetTypePatch(type->u.bitfield.type));
            CPrec_NewPointerPatch(&p->u.bitfield.size, CPrec_GetExpressionPatch(type->u.bitfield.size));
            break;
        default:
            CError_FATAL(1295);
    }

    return p;
}

static ClassList *CPrec_GetClassListPatch(ClassList *cl) {
    AddrPatch *addrPatch;
    ClassList *first, *current, *next;

    if ((addrPatch = CPrec_FindAddrPatch(cl)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(cl, first);

    do {
        CPrec_AppendData(cl, sizeof(ClassList));
        CPrec_NewPointerPatch(&current->base, CPrec_GetTypePatch((Type *) cl->base));

        if (!cl->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(cl->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        } else {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&current->next, next);
            current = next;
            cl = cl->next;
        }
    } while (1);

    return first;
}

static VClassList *CPrec_GetVClassListPatch(VClassList *vcl) {
    VClassList *first, *current, *next;
    first = current = CPrec_AppendAlign();

    do {
        CPrec_AppendData(vcl, sizeof(VClassList));
        CPrec_NewPointerPatch(&current->base, CPrec_GetTypePatch((Type *) vcl->base));

        if (!vcl->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        vcl = vcl->next;
    } while (1);

    return first;
}

static ClassFriend *CPrec_GetClassFriendPatch(ClassFriend *cf) {
    ClassFriend *first, *current, *next;
    first = current = CPrec_AppendAlign();

    do {
        CPrec_AppendData(cf, sizeof(ClassFriend));
        if (cf->isclass)
            CPrec_NewPointerPatch(&current->u.theclass, CPrec_GetTypePatch((Type *) cf->u.theclass));
        else
            CPrec_NewPointerPatch(&current->u.theclass, CPrec_GetObjectPatch(cf->u.obj));

        if (!cf->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        cf = cf->next;
    } while (1);

    return first;
}

static BClassList *CPrec_GetBClassListPatch(BClassList *bcl) {
    BClassList *first, *current, *next;
    first = current = CPrec_AppendAlign();

    do {
        CPrec_AppendData(bcl, sizeof(BClassList));
        CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch((Type *) bcl->type));

        if (!bcl->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        bcl = bcl->next;
    } while (1);

    return first;
}

static VTable *CPrec_GetVTablePatch(VTable *vtbl) {
    VTable *p = CPrec_AppendAlign();
    CPrec_AppendData(vtbl, sizeof(VTable));

    if (vtbl->object)
        CPrec_NewPointerPatch(&p->object, CPrec_GetObjectPatch(vtbl->object));
    if (vtbl->owner)
        CPrec_NewPointerPatch(&p->owner, CPrec_GetTypePatch((Type *) vtbl->owner));

    return p;
}

static SOMReleaseOrder *CPrec_GetSOMReleaseOrderPatch(SOMReleaseOrder *sro) {
    SOMReleaseOrder *first, *current, *next;
    first = current = CPrec_AppendAlign();

    do {
        CPrec_AppendData(sro, sizeof(SOMReleaseOrder));
        CPrec_NamePatch(&current->name, sro->name);
        if (!sro->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        sro = sro->next;
    } while (1);

    return first;
}

static SOMInfo *CPrec_GetSOMInfoPatch(SOMInfo *som) {
    SOMInfo *p = CPrec_AppendAlign();
    CPrec_AppendData(som, sizeof(SOMInfo));

    if (som->metaclass)
        CPrec_NewPointerPatch(&p->metaclass, CPrec_GetTypePatch((Type *) som->metaclass));
    if (som->classdataobject)
        CPrec_NewPointerPatch(&p->classdataobject, CPrec_GetObjectPatch(som->classdataobject));
    if (som->order)
        CPrec_NewPointerPatch(&p->order, CPrec_GetSOMReleaseOrderPatch(som->order));

    return p;
}

static ObjCMethodArg *CPrec_GetObjCMethodArgPatch(ObjCMethodArg *arg) {
    ObjCMethodArg *first, *current, *next;
    first = current = CPrec_AppendAlign();

    do {
        CPrec_AppendData(arg, sizeof(ObjCMethod));
        if (arg->selector)
            CPrec_NamePatch(&current->selector, arg->selector);
        if (arg->name)
            CPrec_NamePatch(&current->name, arg->name);
        if (arg->type)
            CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(arg->type));

        if (!arg->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        arg = arg->next;
    } while (1);

    return first;
}

static ObjCMethodList *CPrec_GetObjCMethodListPatch(ObjCMethodList *lst) {
    AddrPatch *addrPatch;
    ObjCMethodList *first, *current, *next;

    if ((addrPatch = CPrec_FindAddrPatch(lst)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(lst, first);

    do {
        CPrec_AppendData(lst, sizeof(ObjCMethodList));
        if (lst->method)
            CPrec_NewPointerPatch(&current->method, CPrec_GetObjCMethodPatch(lst->method));

        if (!lst->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(lst->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        } else {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&current->next, next);
            current = next;
            lst = lst->next;
            CPrec_NewAddrPatch(lst, next);
        }
    } while (1);

    return first;
}

static ObjCSelector *CPrec_GetObjCSelectorPatch(ObjCSelector *sel) {
    AddrPatch *addrPatch;
    ObjCSelector *current, *first, *next;

    if ((addrPatch = CPrec_FindAddrPatch(sel)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(sel, first);

    do {
        CPrec_AppendData(sel, sizeof(ObjCSelector));
        if (sel->selobject)
            CPrec_NewPointerPatch(&current->selobject, CPrec_GetObjectPatch(sel->selobject));
        CPrec_NamePatch(&current->name, sel->name);
        if (sel->methods)
            CPrec_NewPointerPatch(&current->methods, CPrec_GetObjCMethodListPatch(sel->methods));

        if (!sel->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(sel->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        } else {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&current->next, next);
            current = next;
            sel = sel->next;
            CPrec_NewAddrPatch(sel, next);
        }
    } while (1);

    return first;
}

static ObjCMethod *CPrec_GetObjCMethodPatch(ObjCMethod *meth) {
    // does not match - affected by weirdness where the arg goes into r31 instead of r28
    AddrPatch *addrPatch;
    ObjCMethod *current, *first, *next;

    if ((addrPatch = CPrec_FindAddrPatch(meth)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(meth, first);

    do {
        CPrec_AppendData(meth, sizeof(ObjCMethod));
        if (meth->object)
            CPrec_NewPointerPatch(&current->object, CPrec_GetObjectPatch(meth->object));
        if (meth->functype)
            CPrec_NewPointerPatch(&current->functype, CPrec_GetTypePatch((Type *) meth->functype));
        if (meth->selector)
            CPrec_NewPointerPatch(&current->selector, CPrec_GetObjCSelectorPatch(meth->selector));
        if (meth->return_type)
            CPrec_NewPointerPatch(&current->return_type, CPrec_GetTypePatch(meth->return_type));
        if (meth->selector_args)
            CPrec_NewPointerPatch(&current->selector_args, CPrec_GetObjCMethodArgPatch(meth->selector_args));

        if (!meth->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(meth->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        } else {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&current->next, next);
            current = next;
            meth = meth->next;
            CPrec_NewAddrPatch(meth, next);
        }
    } while (1);

    return first;
}

static ObjCProtocol *CPrec_GetObjCProtocolPatch(ObjCProtocol *prot) {
    AddrPatch *addrPatch;
    ObjCProtocol *current, *first, *next;

    if ((addrPatch = CPrec_FindAddrPatch(prot)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(prot, first);

    do {
        CPrec_AppendData(prot, sizeof(ObjCProtocol));
        CPrec_NamePatch(&current->name, prot->name);
        if (prot->protocols)
            CPrec_NewPointerPatch(&current->protocols, CPrec_GetObjCProtocolListPatch(prot->protocols));
        if (prot->methods)
            CPrec_NewPointerPatch(&current->methods, CPrec_GetObjCMethodPatch(prot->methods));
        if (prot->object)
            CPrec_NewPointerPatch(&current->object, CPrec_GetObjectPatch(prot->object));

        if (!prot->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(prot->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        } else {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&current->next, next);
            current = next;
            prot = prot->next;
            CPrec_NewAddrPatch(prot, next);
        }
    } while (1);

    return first;
}

static ObjCProtocolList *CPrec_GetObjCProtocolListPatch(ObjCProtocolList *lst) {
    AddrPatch *addrPatch;
    ObjCProtocolList *first, *current, *next;

    if ((addrPatch = CPrec_FindAddrPatch(lst)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(lst, first);

    do {
        CPrec_AppendData(lst, sizeof(ObjCProtocolList));
        CPrec_NewPointerPatch(&current->protocol, CPrec_GetObjCProtocolPatch(lst->protocol));

        if (!lst->next)
            break;

        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        lst = lst->next;
    } while (1);

    return first;
}

static ObjCCategory *CPrec_GetObjCCategoryPatch(ObjCCategory *cat) {
    AddrPatch *addrPatch;
    ObjCCategory *current, *first, *next;

    if ((addrPatch = CPrec_FindAddrPatch(cat)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(cat, first);

    do {
        CPrec_AppendData(cat, sizeof(ObjCCategory));
        CPrec_NamePatch(&current->name, cat->name);
        if (cat->protocols)
            CPrec_NewPointerPatch(&current->protocols, CPrec_GetObjCProtocolListPatch(cat->protocols));
        if (cat->methods)
            CPrec_NewPointerPatch(&current->methods, CPrec_GetObjCMethodPatch(cat->methods));

        if (!cat->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(cat->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        } else {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&current->next, next);
            current = next;
            cat = cat->next;
            CPrec_NewAddrPatch(cat, next);
        }
    } while (1);

    return first;
}

static ObjCInfo *CPrec_GetObjCInfoPatch(ObjCInfo *info) {
    ObjCInfo *p = CPrec_AppendAlign();
    CPrec_AppendData(info, sizeof(ObjCInfo));

    if (info->classobject)
        CPrec_NewPointerPatch(&p->classobject, CPrec_GetObjectPatch(info->classobject));
    if (info->metaobject)
        CPrec_NewPointerPatch(&p->metaobject, CPrec_GetObjectPatch(info->metaobject));
    if (info->classrefobj)
        CPrec_NewPointerPatch(&p->classrefobj, CPrec_GetObjectPatch(info->classrefobj));
    if (info->methods)
        CPrec_NewPointerPatch(&p->methods, CPrec_GetObjCMethodPatch(info->methods));
    if (info->protocols)
        CPrec_NewPointerPatch(&p->protocols, CPrec_GetObjCProtocolListPatch(info->protocols));
    if (info->categories)
        CPrec_NewPointerPatch(&p->categories, CPrec_GetObjCCategoryPatch(info->categories));

    return p;
}

static TemplArg *CPrec_GetTemplateArgPatch(TemplArg *arg) {
    TemplArg *first, *current, *next;
    first = current = CPrec_AppendAlign();

    do {
        CPrec_AppendData(arg, sizeof(TemplArg));
        switch (arg->pid.type) {
            case TPT_TYPE:
                if (arg->data.typeparam.type)
                    CPrec_NewPointerPatch(&current->data.typeparam.type, CPrec_GetTypePatch(arg->data.typeparam.type));
                break;
            case TPT_NONTYPE:
                if (arg->data.paramdecl.expr)
                    CPrec_NewPointerPatch(&current->data.paramdecl.expr, CPrec_GetExpressionPatch(arg->data.paramdecl.expr));
                break;
            case TPT_TEMPLATE:
                if (arg->data.ttargtype)
                    CPrec_NewPointerPatch(&current->data.ttargtype, CPrec_GetTypePatch(arg->data.ttargtype));
                break;
            default:
                CError_FATAL(1879);
        }

        if (!arg->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        arg = arg->next;
    } while (1);

    return first;
}

static TemplParam *CPrec_GetTemplateParamPatch(TemplParam *param) {
    // register swap issues
    TemplParam *first, *current, *next;
    first = current = CPrec_AppendAlign();

    do {
        CPrec_AppendData(param, sizeof(TemplParam));
        if (param->name)
            CPrec_NamePatch(&current->name, param->name);

        switch (param->pid.type) {
            case TPT_TYPE:
                if (param->data.typeparam.type)
                    CPrec_NewPointerPatch(&current->data.typeparam.type, CPrec_GetTypePatch(param->data.typeparam.type));
                break;
            case TPT_NONTYPE:
                CPrec_NewPointerPatch(&current->data.paramdecl.type, CPrec_GetTypePatch(param->data.paramdecl.type));
                if (param->data.paramdecl.defaultarg)
                    CPrec_NewPointerPatch(&current->data.paramdecl.defaultarg, CPrec_GetExpressionPatch(param->data.paramdecl.defaultarg));
                break;
            case TPT_TEMPLATE:
                if (param->data.templparam.plist)
                    CPrec_NewPointerPatch(&current->data.templparam.plist, CPrec_GetTemplateParamPatch(param->data.templparam.plist));
                CError_ASSERT(1953, !param->data.templparam.defaultarg);
                break;
            default:
                CError_FATAL(1958);
        }

        if (!param->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        param = param->next;
    } while (1);

    return first;
}

static TStreamElement *CPrec_GetTStreamPatch(TStreamElement *tokens, SInt32 count) {
    TStreamElement elem;
    TStreamElement *first, *current, *scan;
    SInt32 x;

    scan = tokens;
    x = 0;
    while (x < count) {
        elem = *scan;
        memclrw(scan, sizeof(TStreamElement));

        scan->tokentype = elem.tokentype;
        switch (elem.tokentype) {
            case TK_IDENTIFIER:
                scan->data.tkidentifier = elem.data.tkidentifier;
                break;
            case TK_INTCONST:
                scan->subtype = elem.subtype;
                scan->data.tkintconst = elem.data.tkintconst;
                break;
            case TK_FLOATCONST:
                scan->subtype = elem.subtype;
                scan->data.tkfloatconst = elem.data.tkfloatconst;
                break;
            case TK_STRING:
            case TK_STRING_WIDE:
                scan->subtype = elem.subtype;
                scan->data.tkstring = elem.data.tkstring;
                break;
        }
        x++;
        scan++;
    }

    first = current = CPrec_AppendAlign();
    CPrec_AppendData(tokens, count * sizeof(TStreamElement));

    if (cprec_dowrite) {
        TokenPatch *tp = lalloc(sizeof(TokenPatch));
        tp->tokens = current;
        tp->count = count;
        tp->next = cprec_tokenpatches;
        cprec_tokenpatches = tp;
    }

    x = 0;
    while (x < count) {
        switch (tokens->tokentype) {
            case TK_IDENTIFIER:
                CPrec_NamePatch(&current->data.tkidentifier, tokens->data.tkidentifier);
                break;
            case TK_INTCONST:
            case TK_FLOATCONST:
                break;
            case TK_STRING:
            case TK_STRING_WIDE:
                CPrec_RawMemPatch(&current->data.tkstring.data, tokens->data.tkstring.data, tokens->data.tkstring.size);
                break;
            case TK_EOL:
                break;
            default:
                if (tokens->tokentype < 0)
                    CError_FATAL(2063);
        }
        x++;
        tokens++;
        current++;
    }

    return first;
}

static TemplFuncInstance *CPrec_GetTemplFuncInstancePatch(TemplFuncInstance *inst) {
    AddrPatch *addrPatch;
    TemplFuncInstance *first, *current, *next;

    if ((addrPatch = CPrec_FindAddrPatch(inst)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(inst, first);

    do {
        CPrec_AppendData(inst, sizeof(TemplFuncInstance));
        CPrec_NewPointerPatch(&current->object, CPrec_GetObjectPatch(inst->object));
        CPrec_NewPointerPatch(&current->args, CPrec_GetTemplateArgPatch(inst->args));

        if (!inst->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(inst->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        } else {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&current->next, next);
            current = next;
            inst = inst->next;
            CPrec_NewAddrPatch(inst, next);
        }
    } while (1);

    return first;
}

static TemplateMember *CPrec_GetTemplateMemberPatch(TemplateMember *memb) {
    TemplateMember *current, *first, *next;
    first = current = CPrec_AppendAlign();

    do {
        memclrw(&memb->fileoffset, sizeof(FileOffsetInfo));
        memb->srcfile = NULL;
        memb->startoffset = 0;
        memb->endoffset = 0;

        CPrec_AppendData(memb, sizeof(TemplateMember));
        if (memb->params)
            CPrec_NewPointerPatch(&current->params, CPrec_GetTemplateParamPatch(memb->params));
        CPrec_NewPointerPatch(&current->object, CPrec_GetObjectPatch(memb->object));
        if (memb->stream.firsttoken)
            CPrec_NewPointerPatch(&current->stream.firsttoken, CPrec_GetTStreamPatch(memb->stream.firsttoken, memb->stream.tokens));

        if (!memb->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        memb = memb->next;
    } while (1);

    return first;
}

static TemplPartialSpec *CPrec_GetTemplPartialSpecPatch(TemplPartialSpec *pspec) {
    TemplPartialSpec *first, *current, *next;
    first = current = CPrec_AppendAlign();

    do {
        CPrec_AppendData(pspec, sizeof(TemplPartialSpec));
        if (pspec->templ)
            CPrec_NewPointerPatch(&current->templ, CPrec_GetTypePatch((Type *) pspec->templ));
        if (pspec->args)
            CPrec_NewPointerPatch(&current->args, CPrec_GetTemplateArgPatch(pspec->args));

        if (!pspec->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        pspec = pspec->next;
    } while (1);

    return first;
}

static TemplateFriend *CPrec_GetTemplateFriendPatch(TemplateFriend *frnd) {
    TemplateFriend *p;

    memclrw(&frnd->fileoffset, sizeof(FileOffsetInfo));
    p = CPrec_AppendAlign();
    CPrec_AppendData(frnd, sizeof(TemplateFriend));

    if (frnd->decl.thetype)
        CPrec_NewPointerPatch(&p->decl.thetype, CPrec_GetTypePatch(frnd->decl.thetype));
    if (frnd->decl.nspace)
        CPrec_NewPointerPatch(&p->decl.nspace, CPrec_GetNameSpacePatch(frnd->decl.nspace));
    if (frnd->decl.name)
        CPrec_NamePatch(&p->decl.name, frnd->decl.name);
    if (frnd->decl.expltargs)
        CPrec_NewPointerPatch(&p->decl.expltargs, CPrec_GetTemplateArgPatch(frnd->decl.expltargs));
    if (frnd->stream.firsttoken)
        CPrec_NewPointerPatch(&p->stream.firsttoken, CPrec_GetTStreamPatch(frnd->stream.firsttoken, frnd->stream.tokens));

    return p;
}

static TemplateAction *CPrec_GetTemplateActionPatch(TemplateAction *act) {
    // register swap issue
    TemplateAction *current, *first, *next;
    first = current = CPrec_AppendAlign();

    do {
        memclrw(&act->source_ref, sizeof(TStreamElement));
        CPrec_AppendData(act, sizeof(TemplateAction));

        switch (act->type) {
            case TAT_NESTEDCLASS:
                CPrec_NewPointerPatch(&current->u.tclasstype, CPrec_GetTypePatch((Type *) act->u.tclasstype));
                break;
            case TAT_ENUMTYPE:
                CPrec_NewPointerPatch(&current->u.enumtype, CPrec_GetTypePatch((Type *) act->u.enumtype));
                break;
            case TAT_FRIEND:
                CPrec_NewPointerPatch(&current->u.tfriend, CPrec_GetTemplateFriendPatch(act->u.tfriend));
                break;
            case TAT_ENUMERATOR:
                CPrec_NewPointerPatch(&current->u.enumerator.objenumconst, CPrec_GetObjEnumConstPatch(act->u.enumerator.objenumconst));
                if (act->u.enumerator.initexpr)
                    CPrec_NewPointerPatch(&current->u.enumerator.initexpr, CPrec_GetExpressionPatch(act->u.enumerator.initexpr));
                break;
            case TAT_BASE:
                CPrec_NewPointerPatch(&current->u.base.type, CPrec_GetTypePatch(act->u.base.type));
                if (act->u.base.insert_after)
                    CPrec_NewPointerPatch(&current->u.base.insert_after, CPrec_GetClassListPatch(act->u.base.insert_after));
                break;
            case TAT_OBJECTINIT:
                CPrec_NewPointerPatch(&current->u.objectinit.object, CPrec_GetObjectPatch(act->u.objectinit.object));
                CPrec_NewPointerPatch(&current->u.objectinit.initexpr, CPrec_GetExpressionPatch(act->u.objectinit.initexpr));
                break;
            case TAT_USINGDECL:
                CPrec_NewPointerPatch(&current->u.usingdecl.type, CPrec_GetTypeTemplDepPatch(act->u.usingdecl.type));
                break;
            case TAT_OBJECTDEF:
                CPrec_NewPointerPatch(&current->u.refobj, CPrec_GetObjBasePatch(act->u.refobj));
                break;
            default:
                CError_FATAL(2410);
        }

        if (!act->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        act = act->next;
    } while (1);

    return first;
}

static TemplateFunction *CPrec_GetTemplateFunctionPatch(TemplateFunction *tf) {
    // the same cursed register swaps
    AddrPatch *addrPatch;
    TemplateFunction *first, *current, *next;

    if ((addrPatch = CPrec_FindAddrPatch(tf)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(tf, first);

    do {
        memclrw(&tf->deftoken, sizeof(TStreamElement));
        tf->srcfile = NULL;
        tf->startoffset = 0;
        tf->endoffset = 0;

        CPrec_AppendData(tf, sizeof(TemplateFunction));
        if (tf->unk4)
            CPrec_NewPointerPatch(&current->unk4, CPrec_GetTemplateFunctionPatch(tf->unk4));
        CPrec_NamePatch(&current->name, tf->name);
        if (tf->params)
            CPrec_NewPointerPatch(&current->params, CPrec_GetTemplateParamPatch(tf->params));
        if (tf->stream.firsttoken)
            CPrec_NewPointerPatch(&current->stream.firsttoken, CPrec_GetTStreamPatch(tf->stream.firsttoken, tf->stream.tokens));
        CPrec_NewPointerPatch(&current->tfunc, CPrec_GetObjectPatch(tf->tfunc));
        if (tf->instances)
            CPrec_NewPointerPatch(&current->instances, CPrec_GetTemplFuncInstancePatch(tf->instances));

        if (!tf->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(tf->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        } else {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&current->next, next);
            current = next;
            tf = tf->next;
            CPrec_NewAddrPatch(tf, next);
        }
    } while (1);

    return first;
}

static TypeClass *CPrec_GetTypeClassPatch(TypeClass *tclass) {
    TypeClass *first, *current, *next;
    Boolean hasNextTempl, hasNextTemplInst;
    first = current = CPrec_AppendAlign();

    do_over:
    hasNextTempl = hasNextTemplInst = 0;
    CPrec_NewAddrPatch(tclass, current);

    if (tclass->flags & CLASS_FLAGS_100) {
        // template class
        CPrec_AppendData(tclass, sizeof(TemplClass));
        if (TEMPL_CLASS(tclass)->next)
            hasNextTempl = 1;
        if (TEMPL_CLASS(tclass)->templ_parent)
            CPrec_NewPointerPatch(&TEMPL_CLASS(current)->templ_parent, CPrec_GetTypePatch((Type *) TEMPL_CLASS(tclass)->templ_parent));
        if (TEMPL_CLASS(tclass)->inst_parent)
            CPrec_NewPointerPatch(&TEMPL_CLASS(current)->inst_parent, CPrec_GetTypePatch((Type *) TEMPL_CLASS(tclass)->inst_parent));
        if (TEMPL_CLASS(tclass)->templ__params)
            CPrec_NewPointerPatch(&TEMPL_CLASS(current)->templ__params, CPrec_GetTemplateParamPatch(TEMPL_CLASS(tclass)->templ__params));
        if (TEMPL_CLASS(tclass)->members)
            CPrec_NewPointerPatch(&TEMPL_CLASS(current)->members, CPrec_GetTemplateMemberPatch(TEMPL_CLASS(tclass)->members));
        if (TEMPL_CLASS(tclass)->instances)
            CPrec_NewPointerPatch(&TEMPL_CLASS(current)->instances, CPrec_GetTypePatch((Type *) TEMPL_CLASS(tclass)->instances));
        if (TEMPL_CLASS(tclass)->pspec_owner)
            CPrec_NewPointerPatch(&TEMPL_CLASS(current)->pspec_owner, CPrec_GetTypePatch((Type *) TEMPL_CLASS(tclass)->pspec_owner));
        if (TEMPL_CLASS(tclass)->pspecs)
            CPrec_NewPointerPatch(&TEMPL_CLASS(current)->pspecs, CPrec_GetTemplPartialSpecPatch(TEMPL_CLASS(tclass)->pspecs));
        if (TEMPL_CLASS(tclass)->actions)
            CPrec_NewPointerPatch(&TEMPL_CLASS(current)->actions, CPrec_GetTemplateActionPatch(TEMPL_CLASS(tclass)->actions));
    } else if (tclass->flags & CLASS_FLAGS_800) {
        // template class instance
        CPrec_AppendData(tclass, sizeof(TemplClassInst));
        if (TEMPL_CLASS_INST(tclass)->next)
            hasNextTemplInst = 1;
        if (TEMPL_CLASS_INST(tclass)->parent)
            CPrec_NewPointerPatch(&TEMPL_CLASS_INST(current)->parent, CPrec_GetTypePatch((Type *) TEMPL_CLASS_INST(tclass)->parent));
        if (TEMPL_CLASS_INST(tclass)->templ)
            CPrec_NewPointerPatch(&TEMPL_CLASS_INST(current)->templ, CPrec_GetTypePatch((Type *) TEMPL_CLASS_INST(tclass)->templ));
        if (TEMPL_CLASS_INST(tclass)->inst_args)
            CPrec_NewPointerPatch(&TEMPL_CLASS_INST(current)->inst_args, CPrec_GetTemplateArgPatch(TEMPL_CLASS_INST(tclass)->inst_args));
        if (TEMPL_CLASS_INST(tclass)->oargs)
            CPrec_NewPointerPatch(&TEMPL_CLASS_INST(current)->oargs, CPrec_GetTemplateArgPatch(TEMPL_CLASS_INST(tclass)->oargs));
    } else {
        // base
        CPrec_AppendData(tclass, sizeof(TypeClass));
    }

    if (tclass->nspace)
        CPrec_NewPointerPatch(&current->nspace, CPrec_GetNameSpacePatch(tclass->nspace));
    if (tclass->classname)
        CPrec_NamePatch(&current->classname, tclass->classname);
    if (tclass->bases)
        CPrec_NewPointerPatch(&current->bases, CPrec_GetClassListPatch(tclass->bases));
    if (tclass->vbases)
        CPrec_NewPointerPatch(&current->vbases, CPrec_GetVClassListPatch(tclass->vbases));
    if (tclass->ivars)
        CPrec_NewPointerPatch(&current->ivars, CPrec_GetObjMemberVarPatch(tclass->ivars));
    if (tclass->friends)
        CPrec_NewPointerPatch(&current->friends, CPrec_GetClassFriendPatch(tclass->friends));
    if (tclass->vtable)
        CPrec_NewPointerPatch(&current->vtable, CPrec_GetVTablePatch(tclass->vtable));
    if (tclass->sominfo)
        CPrec_NewPointerPatch(&current->sominfo, CPrec_GetSOMInfoPatch(tclass->sominfo));
    if (tclass->objcinfo)
        CPrec_NewPointerPatch(&current->objcinfo, CPrec_GetObjCInfoPatch(tclass->objcinfo));

    if (hasNextTempl) {
        AddrPatch *addrPatch = CPrec_FindAddrPatch(TEMPL_CLASS(tclass)->next);
        if (!addrPatch) {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&TEMPL_CLASS(current)->next, next);
            current = next;
            tclass = (TypeClass *) TEMPL_CLASS(tclass)->next;
            goto do_over;
        } else {
            CPrec_NewPointerPatch(&TEMPL_CLASS(current)->next, addrPatch->value);
        }
    }

    if (hasNextTemplInst) {
        AddrPatch *addrPatch = CPrec_FindAddrPatch(TEMPL_CLASS_INST(tclass)->next);
        if (!addrPatch) {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&TEMPL_CLASS_INST(current)->next, next);
            current = next;
            tclass = (TypeClass *) TEMPL_CLASS_INST(tclass)->next;
            goto do_over;
        } else {
            CPrec_NewPointerPatch(&TEMPL_CLASS_INST(current)->next, addrPatch->value);
        }
    }

    return first;
}

static Type *CPrec_GetTypePatch(Type *type) {
    AddrPatch *addrPatch = CPrec_FindAddrPatch(type);
    if (addrPatch)
        return addrPatch->value;

    switch (type->type) {
        case TYPEPOINTER:
        case TYPEARRAY:
            return (Type *) CPrec_GetTypePointerPatch(TYPE_POINTER(type));
        case TYPEENUM:
            return (Type *) CPrec_GetTypeEnumPatch(TYPE_ENUM(type));
        case TYPEBITFIELD:
            return (Type *) CPrec_GetTypeBitfieldPatch(TYPE_BITFIELD(type));
        case TYPESTRUCT:
            return (Type *) CPrec_GetTypeStructPatch(TYPE_STRUCT(type));
        case TYPEFUNC:
            return (Type *) CPrec_GetTypeFuncPatch(TYPE_FUNC(type));
        case TYPEMEMBERPOINTER:
            return (Type *) CPrec_GetTypeMemberPointerPatch(TYPE_MEMBER_POINTER(type));
        case TYPETEMPLATE:
            return (Type *) CPrec_GetTypeTemplDepPatch(TYPE_TEMPLATE(type));
        case TYPECLASS:
            return (Type *) CPrec_GetTypeClassPatch(TYPE_CLASS(type));
        case TYPEVOID:
        case TYPEINT:
        case TYPEFLOAT:
        case TYPELABEL:
        case TYPEOBJCID:
        case TYPETEMPLDEPEXPR:
        default:
            CError_FATAL(2796);
            return NULL;
    }
}

static ExceptionAction *CPrec_GetExceptionPatch(ExceptionAction *exc) {
    ExceptionAction *first, *current, *next;

    first = current = CPrec_AppendAlign();
repeat:
    CPrec_AppendData(exc, sizeof(ExceptionAction));
    switch (exc->type) {
        case EAT_DESTROYLOCAL:
            CPrec_NewPointerPatch(&current->data.destroy_local.dtor, CPrec_GetObjectPatch(exc->data.destroy_local.dtor));
            break;
        case EAT_DESTROYLOCALCOND:
            CPrec_NewPointerPatch(&current->data.destroy_local_cond.dtor, CPrec_GetObjectPatch(exc->data.destroy_local_cond.dtor));
            break;
        case EAT_DESTROYLOCALOFFSET:
            CPrec_NewPointerPatch(&current->data.destroy_local_offset.dtor, CPrec_GetObjectPatch(exc->data.destroy_local_offset.dtor));
            break;
        case EAT_DESTROYLOCALPOINTER:
            CPrec_NewPointerPatch(&current->data.destroy_local_pointer.dtor, CPrec_GetObjectPatch(exc->data.destroy_local_pointer.dtor));
            break;
        case EAT_DESTROYLOCALARRAY:
            CPrec_NewPointerPatch(&current->data.destroy_local_array.dtor, CPrec_GetObjectPatch(exc->data.destroy_local_array.dtor));
            break;
        case EAT_DESTROYPARTIALARRAY:
            break;
        case EAT_DESTROYMEMBER:
        case EAT_DESTROYBASE:
            CPrec_NewPointerPatch(&current->data.destroy_member.dtor, CPrec_GetObjectPatch(exc->data.destroy_member.dtor));
            break;
        case EAT_DESTROYMEMBERCOND:
            CPrec_NewPointerPatch(&current->data.destroy_member_cond.dtor, CPrec_GetObjectPatch(exc->data.destroy_member_cond.dtor));
            break;
        case EAT_DESTROYMEMBERARRAY:
            CPrec_NewPointerPatch(&current->data.destroy_member_array.dtor, CPrec_GetObjectPatch(exc->data.destroy_member_array.dtor));
            break;
        case EAT_DELETEPOINTER:
        case EAT_DELETELOCALPOINTER:
            CPrec_NewPointerPatch(&current->data.delete_pointer.deletefunc, CPrec_GetObjectPatch(exc->data.delete_pointer.deletefunc));
            break;
        case EAT_DELETEPOINTERCOND:
            CPrec_NewPointerPatch(&current->data.delete_pointer_cond.deletefunc, CPrec_GetObjectPatch(exc->data.delete_pointer_cond.deletefunc));
            break;
        case EAT_CATCHBLOCK:
            if (exc->data.catch_block.catch_typeid) {
                CPrec_NewPointerPatch(&current->data.catch_block.catch_typeid, CPrec_GetObjectPatch(exc->data.catch_block.catch_typeid));
                CPrec_NewPointerPatch(&current->data.catch_block.catch_type, CPrec_GetTypePatch(exc->data.catch_block.catch_type));
            }
            break;
        case EAT_ACTIVECATCHBLOCK:
            break;
        case EAT_SPECIFICATION:
            if (exc->data.specification.unexp_id) {
                int x;
                char *ptrs;
                ptrs = CPrec_AppendAlign();
                CPrec_NewPointerPatch(&current->data.specification.unexp_id, ptrs);
                CPrec_AppendData(exc->data.specification.unexp_id, sizeof(Object *) * exc->data.specification.unexp_ids);
                for (x = 0; x < exc->data.specification.unexp_ids; x++) {
                    CPrec_NewPointerPatch(ptrs + x * sizeof(Object *), CPrec_GetObjectPatch(exc->data.specification.unexp_id[x]));
                }
            }
            break;
        case EAT_TERMINATE:
            break;
        default:
            CError_FATAL(2905);
    }

    if (exc->prev) {
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->prev, next);
        current = next;
        exc = exc->prev;
        goto repeat;
    }
    return first;
}

static ENodeList *CPrec_GetExpressionListPatch(ENodeList *lst) {
    ENodeList *first, *current, *next;
    first = current = CPrec_AppendAlign();

    do {
        CPrec_AppendData(lst, sizeof(ENodeList));
        CPrec_NewPointerPatch(&current->node, CPrec_GetExpressionPatch(lst->node));

        if (!lst->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        lst = lst->next;
    } while (1);

    return first;
}

static EMemberInfo *CPrec_GetEMemberInfoPatch(EMemberInfo *emember) {
    EMemberInfo *p;

    CError_FATAL(2953);

    p = CPrec_AppendAlign();
    CPrec_AppendData(emember, sizeof(EMemberInfo));

    if (emember->path)
        CPrec_NewPointerPatch(&p->path, CPrec_GetClassAccessPatch(emember->path));
    if (emember->expr)
        CPrec_NewPointerPatch(&p->expr, CPrec_GetExpressionPatch(emember->expr));
    CError_ASSERT(2968, !emember->templargs);
    CPrec_NewPointerPatch(&p->list, CPrec_GetNameSpaceObjectListPatch(emember->list));

    return p;
}

static ENode *CPrec_GetExpressionPatch(ENode *expr) {
    ENode *p;

    if (ENODE_IS(expr, ETEMPLDEP) && expr->data.templdep.subtype == TDE_SOURCEREF)
        expr->data.templdep.u.sourceref.token = NULL;

    p = CPrec_AppendAlign();
    CPrec_AppendData(expr, sizeof(ENode));

    CPrec_NewPointerPatch(&p->rtype, CPrec_GetTypePatch(expr->rtype));

    switch (expr->type) {
        ENODE_CASE_MONADIC:
            CPrec_NewPointerPatch(&p->data.monadic, CPrec_GetExpressionPatch(expr->data.monadic));
            break;
        ENODE_CASE_DIADIC_ALL:
            CPrec_NewPointerPatch(&p->data.diadic.left, CPrec_GetExpressionPatch(expr->data.diadic.left));
            CPrec_NewPointerPatch(&p->data.diadic.right, CPrec_GetExpressionPatch(expr->data.diadic.right));
            break;
        case ECOND:
            CPrec_NewPointerPatch(&p->data.cond.cond, CPrec_GetExpressionPatch(expr->data.cond.cond));
            CPrec_NewPointerPatch(&p->data.cond.expr1, CPrec_GetExpressionPatch(expr->data.cond.expr1));
            CPrec_NewPointerPatch(&p->data.cond.expr2, CPrec_GetExpressionPatch(expr->data.cond.expr2));
            break;
        case ESTRINGCONST:
            CPrec_RawMemPatch(&p->data.string.data, expr->data.string.data, expr->data.string.size);
            break;
        case EOBJREF:
            CPrec_NewPointerPatch(&p->data.objref, CPrec_GetObjectPatch(expr->data.objref));
            break;
        case EOBJLIST:
            CPrec_NewPointerPatch(&p->data.objlist.list, CPrec_GetNameSpaceObjectListPatch(expr->data.objlist.list));
            CError_ASSERT(3043, !expr->data.objlist.templargs);
            if (expr->data.objlist.name)
                CPrec_NamePatch(&p->data.objlist.name, expr->data.objlist.name);
            break;
        case EMFPOINTER:
            CPrec_NewPointerPatch(&p->data.mfpointer.accessnode, CPrec_GetExpressionPatch(expr->data.mfpointer.accessnode));
            CPrec_NewPointerPatch(&p->data.mfpointer.mfpointer, CPrec_GetExpressionPatch(expr->data.mfpointer.mfpointer));
            break;
        case ENULLCHECK:
            CPrec_NewPointerPatch(&p->data.nullcheck.nullcheckexpr, CPrec_GetExpressionPatch(expr->data.nullcheck.nullcheckexpr));
            CPrec_NewPointerPatch(&p->data.nullcheck.condexpr, CPrec_GetExpressionPatch(expr->data.nullcheck.condexpr));
            break;
        case ETEMP:
            CPrec_NewPointerPatch(&p->data.temp.type, CPrec_GetTypePatch(expr->data.temp.type));
            break;
        case EFUNCCALL:
        case EFUNCCALLP:
            CPrec_NewPointerPatch(&p->data.funccall.funcref, CPrec_GetExpressionPatch(expr->data.funccall.funcref));
            CPrec_NewPointerPatch(&p->data.funccall.functype, CPrec_GetTypePatch(TYPE(expr->data.funccall.functype)));
            if (expr->data.funccall.args)
                CPrec_NewPointerPatch(&p->data.funccall.args, CPrec_GetExpressionListPatch(expr->data.funccall.args));
            break;
        case EMEMBER:
            CPrec_NewPointerPatch(&p->data.emember, CPrec_GetEMemberInfoPatch(expr->data.emember));
            break;
        case ETEMPLDEP:
            switch (expr->data.templdep.subtype) {
                case TDE_PARAM:
                    break;
                case TDE_SIZEOF:
                case TDE_ALIGNOF:
                    CPrec_NewPointerPatch(&p->data.templdep.u.typeexpr.type, CPrec_GetTypePatch(expr->data.templdep.u.typeexpr.type));
                    break;
                case TDE_CAST:
                    if (expr->data.templdep.u.cast.args)
                        CPrec_NewPointerPatch(&p->data.templdep.u.cast.args, CPrec_GetExpressionListPatch(expr->data.templdep.u.cast.args));
                    CPrec_NewPointerPatch(&p->data.templdep.u.cast.type, CPrec_GetTypePatch(expr->data.templdep.u.cast.type));
                    break;
                case TDE_QUALNAME:
                    CPrec_NamePatch(&p->data.templdep.u.qual.name, expr->data.templdep.u.qual.name);
                    CPrec_NewPointerPatch(&p->data.templdep.u.qual.type, CPrec_GetTypePatch(TYPE(expr->data.templdep.u.qual.type)));
                    break;
                case TDE_OBJ:
                    CPrec_NewPointerPatch(&p->data.templdep.u.obj, CPrec_GetObjectPatch(expr->data.templdep.u.obj));
                    break;
                case TDE_SOURCEREF:
                    CPrec_NewPointerPatch(&p->data.templdep.u.sourceref.expr, CPrec_GetExpressionPatch(expr->data.templdep.u.sourceref.expr));
                    break;
                case TDE_ADDRESS_OF:
                    CPrec_NewPointerPatch(&p->data.templdep.u.monadic, CPrec_GetExpressionPatch(expr->data.templdep.u.monadic));
                    break;
                default:
                    CError_FATAL(3136);
            }
            break;
        case EINTCONST:
        case EFLOATCONST:
        case EPRECOMP:
        case EARGOBJ:
        case ELOCOBJ:
        case ELABEL:
        case EINSTRUCTION:
        case EVECTOR128CONST:
            break;
        default:
            CError_FATAL(3142);
    }

    return p;
}

static CI_Switch *CPrec_GetSwitchInfoPatch(CI_Switch *si) {
    CI_Switch *p = CPrec_AppendAlign();
    CPrec_AppendData(si, sizeof(CI_Switch) + sizeof(CI_SwitchCase) * (si->numcases - 1));

    CPrec_NewPointerPatch(&p->expr, CPrec_GetExpressionPatch(si->expr));
    CPrec_NewPointerPatch(&p->unkSwitch8, CPrec_GetTypePatch(si->unkSwitch8));
    return p;
}

static InlineAsm *CPrec_GetInlineAsmPatch(InlineAsm *ia, SInt32 size) {
    InlineAsm *p;
    SInt32 index;
    SInt32 offset;
    Object *object;

    p = CPrec_AppendAlign();
    CPrec_AppendData(ia, size);

    index = 0;
    while (1) {
        object = InlineAsm_GetObjectOffset(ia, index, &offset);
        if (!object)
            break;

        object = CPrec_GetObjectPatch(object);
        CPrec_NewPointerPatch((char *) p + offset, object);
        index++;
    }

    return p;
}

static CI_Statement *CPrec_GetStatementPatch(CI_Statement *stmt, short count) {
    short i;
    CI_Statement *first, *current;

    for (i = 0; i < count; i++) {
        stmt[i].sourcefilepath = NULL;
        stmt[i].sourceoffset = -1;
    }

    first = current = CPrec_AppendAlign();
    CPrec_AppendData(stmt, sizeof(CI_Statement) * count);

    for (i = 0; i < count; i++) {
        if (stmt->dobjstack)
            CPrec_NewPointerPatch(&current->dobjstack, CPrec_GetExceptionPatch(stmt->dobjstack));

        switch (stmt->type) {
            case ST_EXPRESSION:
            case ST_RETURN:
            case ST_BEGINCATCH:
            case ST_ENDCATCH:
            case ST_ENDCATCHDTOR:
                if (stmt->u.expr)
                    CPrec_NewPointerPatch(&current->u.expr, CPrec_GetExpressionPatch(stmt->u.expr));
                break;
            case ST_IFGOTO:
            case ST_IFNGOTO:
                CPrec_NewPointerPatch(&current->u.ifgoto.expr, CPrec_GetExpressionPatch(stmt->u.ifgoto.expr));
                break;
            case ST_SWITCH:
                CPrec_NewPointerPatch(&current->u.switchdata, CPrec_GetSwitchInfoPatch(stmt->u.switchdata));
                break;
            case ST_ASM:
                CPrec_NewPointerPatch(&current->u.asmdata.data, CPrec_GetInlineAsmPatch(stmt->u.asmdata.data, stmt->u.asmdata.size));
                break;
            case ST_NOP:
            case ST_LABEL:
            case ST_GOTO:
                break;
            default:
                CError_FATAL(3261);
        }

        current++;
        stmt++;
    }

    return first;
}

static CI_Var *CPrec_GetLocObjectPatch(CI_Var *obj, short count) {
    CI_Var *first, *current;
    short i;

    first = current = CPrec_AppendAlign();
    CPrec_AppendData(obj, sizeof(CI_Var) * count);

    for (i = 0; i < count; i++) {
        CPrec_NamePatch(&current->name, obj->name);
        CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(obj->type));
        current++;
        obj++;
    }

    return first;
}

static CI_FuncData *CPrec_GetInlineFuncPatch(CI_FuncData *ifunc) {
    CI_FuncData *p;

    memclrw(&ifunc->fileoffset, sizeof(FileOffsetInfo));
    ifunc->symdecloffset = 0;
    ifunc->functionbodyoffset = 0;
    ifunc->functionbodypath = NULL;
    ifunc->symdeclend = 0;

    p = CPrec_AppendAlign();
    CPrec_AppendData(ifunc, sizeof(CI_FuncData));

    if (ifunc->numarguments)
        CPrec_NewPointerPatch(&p->arguments, CPrec_GetLocObjectPatch(ifunc->arguments, ifunc->numarguments));
    if (ifunc->numlocals)
        CPrec_NewPointerPatch(&p->locals, CPrec_GetLocObjectPatch(ifunc->locals, ifunc->numlocals));
    if (ifunc->numstatements)
        CPrec_NewPointerPatch(&p->statements, CPrec_GetStatementPatch(ifunc->statements, ifunc->numstatements));

    return p;
}

static ObjEnumConst *CPrec_GetObjEnumConstPatch(ObjEnumConst *obj) {
    AddrPatch *addrPatch;
    ObjEnumConst *first, *current, *next;

    if ((addrPatch = CPrec_FindAddrPatch(obj)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(obj, first);

    do {
        CPrec_AppendData(obj, sizeof(ObjEnumConst));
        if (cprec_dowrite) {
            CError_ASSERT(3349, obj->access != 255);
            obj->access = 255;
        }
        CPrec_NamePatch(&current->name, obj->name);
        CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch( obj->type));

        if (!obj->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(obj->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        } else {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&current->next, next);
            current = next;
            obj = obj->next;
            CPrec_NewAddrPatch(obj, next);
        }
    } while (1);

    return first;
}

static ObjType *CPrec_GetObjTypePatch(ObjType *obj) {
    AddrPatch *addrPatch;
    ObjType *p;

    if ((addrPatch = CPrec_FindAddrPatch(obj)))
        return addrPatch->value;

    p = CPrec_AppendAlign();
    CPrec_NewAddrPatch(obj, p);
    CPrec_AppendData(obj, sizeof(ObjType));
    CPrec_NewPointerPatch(&p->type, CPrec_GetTypePatch(obj->type));
    return p;
}

static ObjTypeTag *CPrec_GetObjTypeTagPatch(ObjTypeTag *obj) {
    AddrPatch *addrPatch;
    ObjTypeTag *p;

    if ((addrPatch = CPrec_FindAddrPatch(obj)))
        return addrPatch->value;

    p = CPrec_AppendAlign();
    CPrec_NewAddrPatch(obj, p);
    CPrec_AppendData(obj, sizeof(ObjTypeTag));
    CPrec_NewPointerPatch(&p->type, CPrec_GetTypePatch(obj->type));
    return p;
}

static ObjNameSpace *CPrec_GetObjNameSpacePatch(ObjNameSpace *obj) {
    AddrPatch *addrPatch;
    ObjNameSpace *p;

    if ((addrPatch = CPrec_FindAddrPatch(obj)))
        return addrPatch->value;

    p = CPrec_AppendAlign();
    CPrec_NewAddrPatch(obj, p);
    CPrec_AppendData(obj, sizeof(ObjNameSpace));
    CPrec_NewPointerPatch(&p->nspace, CPrec_GetNameSpacePatch(obj->nspace));
    return p;
}

static ObjMemberVar *CPrec_GetObjMemberVarPatch(ObjMemberVar *ivar) {
    AddrPatch *addrPatch;
    ObjMemberVar *first, *current, *next;

    if ((addrPatch = CPrec_FindAddrPatch(ivar)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(ivar, first);

    while (1) {
        if (ivar->has_path) {
            CPrec_AppendData(ivar, sizeof(ObjMemberVarPath));
            if (OBJ_MEMBER_VAR_PATH(ivar)->path)
                CPrec_NewPointerPatch(
                    &OBJ_MEMBER_VAR_PATH(current)->path,
                    CPrec_GetClassAccessPatch(OBJ_MEMBER_VAR_PATH(ivar)->path));
        } else {
            CPrec_AppendData(ivar, sizeof(ObjMemberVar));
        }

        if (ivar->name)
            CPrec_NamePatch(&current->name, ivar->name);
        CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(ivar->type));

        if (!ivar->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(ivar->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        }

        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);

        current = next;
        ivar = ivar->next;
        CPrec_NewAddrPatch(ivar, current);
    }

    return first;
}

static DefArgCtorInfo *CPrec_GetDefArgCtorInfoPatch(DefArgCtorInfo *dac) {
    DefArgCtorInfo *p = CPrec_AppendAlign();
    CPrec_AppendData(dac, sizeof(DefArgCtorInfo));
    CPrec_NewPointerPatch(&p->default_func, CPrec_GetObjectPatch(dac->default_func));
    CPrec_NewPointerPatch(&p->default_arg, CPrec_GetExpressionPatch(dac->default_arg));
    return p;
}

static InlineXRef *CPrec_GetInlineXRefPatch(InlineXRef *ix) {
    InlineXRef *first, *current, *next;
    first = current = CPrec_AppendAlign();

    do {
        CPrec_AppendData(ix, sizeof(InlineXRef) + sizeof(XRefOffset) * (ix->numxrefs - 1));
        CPrec_NewPointerPatch(&current->object, CPrec_GetObjectPatch(ix->object));

        if (!ix->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        ix = ix->next;
    } while (1);

    return first;
}

static Object *CPrec_GetObjectPatch(Object *obj) {
    AddrPatch *addrPatch;
    Object *p;

    if (CWUserBreak(cparams.context) != cwNoErr)
        CError_UserBreak();

    if ((addrPatch = CPrec_FindAddrPatch(obj)))
        return addrPatch->value;

    p = CPrec_AppendAlign();
    CPrec_NewAddrPatch(obj, p);

    obj->toc = NULL;

    if ((obj->qual & Q_400000) && obj->datatype != DALIAS) {
        CPrec_AppendData(obj, sizeof(ObjectTemplated));
        CPrec_NewPointerPatch(&OBJECT_TEMPL(p)->parent, CPrec_GetObjectPatch(OBJECT_TEMPL(obj)->parent));
    } else {
        CPrec_AppendData(obj, sizeof(Object));
    }

    if (obj->nspace)
        CPrec_NewPointerPatch(&p->nspace, CPrec_GetNameSpacePatch(obj->nspace));
    if (obj->name)
        CPrec_NamePatch(&p->name, obj->name);
    CPrec_NewPointerPatch(&p->type, CPrec_GetTypePatch(obj->type));

    switch (obj->datatype) {
        case DABSOLUTE:
            break;

        case DLOCAL:
            CError_FATAL(3580);
            break;

        case DFUNC:
        case DVFUNC:
            if (IS_TEMPL_FUNC(obj->type))
                CPrec_NewPointerPatch(&p->u.func.u.templ, CPrec_GetTemplateFunctionPatch(obj->u.func.u.templ));
            else if ((obj->qual & Q_INLINE) && obj->u.func.u.ifuncdata)
                CPrec_NewPointerPatch(&p->u.func.u.ifuncdata, CPrec_GetInlineFuncPatch(obj->u.func.u.ifuncdata));

            if (obj->u.func.defargdata)
                CPrec_NewPointerPatch(&p->u.func.defargdata, CPrec_GetDefArgCtorInfoPatch(obj->u.func.defargdata));
            if (obj->u.func.linkname)
                CPrec_NamePatch(&p->u.func.linkname, obj->u.func.linkname);
            if (obj->u.func.inst)
                CPrec_NewPointerPatch(&p->u.func.inst, CPrec_GetTemplFuncInstancePatch(obj->u.func.inst));
            break;

        case DDATA:
            CError_ASSERT(3622, !obj->u.data.info);
            if (obj->qual & Q_10000) {
                switch (obj->type->type) {
                    case TYPEINT:
                    case TYPEENUM:
                    case TYPEPOINTER:
                        break;
                    case TYPEFLOAT:
                        CPrec_RawMemPatch(&p->u.data.u.floatconst, obj->u.data.u.floatconst, sizeof(Float));
                        break;
                    default:
                        CError_FATAL(3638);
                }
            }
            if (obj->u.data.linkname)
                CPrec_NamePatch(&p->u.data.linkname, obj->u.data.linkname);
            break;

        case DINLINEFUNC:
            CPrec_RawMemPatch(&p->u.ifunc.data, obj->u.ifunc.data, obj->u.ifunc.size);
            if (obj->u.ifunc.xrefs)
                CPrec_NewPointerPatch(&p->u.ifunc.xrefs, CPrec_GetInlineXRefPatch(obj->u.ifunc.xrefs));
            break;

        case DALIAS:
            CPrec_NewPointerPatch(&p->u.alias.object, CPrec_GetObjectPatch(obj->u.alias.object));
            if (obj->u.alias.member)
                CPrec_NewPointerPatch(&p->u.alias.member, CPrec_GetClassAccessPatch(obj->u.alias.member));
            break;

        default:
            CError_FATAL(3677);
    }

    if (cprec_dowrite)
        obj->datatype = -1;

    return p;
}

static ObjBase *CPrec_GetObjBasePatch(ObjBase *obj) {
    switch (obj->otype) {
        default:
            CError_FATAL(3694);
        case OT_ENUMCONST:
            return (ObjBase *) CPrec_GetObjEnumConstPatch((ObjEnumConst *) obj);
        case OT_TYPE:
            return (ObjBase *) CPrec_GetObjTypePatch((ObjType *) obj);
        case OT_TYPETAG:
            return (ObjBase *) CPrec_GetObjTypeTagPatch((ObjTypeTag *) obj);
        case OT_NAMESPACE:
            return (ObjBase *) CPrec_GetObjNameSpacePatch((ObjNameSpace *) obj);
        case OT_MEMBERVAR:
            return (ObjBase *) CPrec_GetObjMemberVarPatch((ObjMemberVar *) obj);
        case OT_OBJECT:
            return (ObjBase *) CPrec_GetObjectPatch((Object *) obj);
    }
}

static ObjectList *CPrec_GetObjectListPatch(ObjectList *ol) {
    AddrPatch *addrPatch;
    ObjectList *first, *current, *next;

    if ((addrPatch = CPrec_FindAddrPatch(ol)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(ol, first);
restart:
    CPrec_AppendData(ol, sizeof(ObjectList));
    CPrec_NewPointerPatch(&current->object, CPrec_GetObjectPatch(ol->object));
    if (ol->next) {
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        ol = ol->next;
        goto restart;
    }

    return first;
}

static NameSpaceObjectList *CPrec_GetNameSpaceObjectListPatch(NameSpaceObjectList *nsol) {
    AddrPatch *addrPatch;
    NameSpaceObjectList *first, *current, *next;

    if ((addrPatch = CPrec_FindAddrPatch(nsol)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(nsol, first);

    do {
        CPrec_AppendData(nsol, sizeof(NameSpaceObjectList));
        CPrec_NewPointerPatch(&current->object, CPrec_GetObjBasePatch(nsol->object));

        if (!nsol->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(nsol->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        } else {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&current->next, next);
            current = next;
            nsol = nsol->next;
            CPrec_NewAddrPatch(nsol, next);
        }
    } while (1);

    return first;
}

static NameSpaceName *CPrec_GetNameSpaceNamePatch(NameSpaceName *nsn, Boolean flag) {
    AddrPatch *addrPatch;
    NameSpaceName *first, *current, *next;

    if ((addrPatch = CPrec_FindAddrPatch(nsn)))
        return addrPatch->value;

    first = current = CPrec_AppendAlign();
    CPrec_NewAddrPatch(nsn, first);

    do {
        CPrec_AppendData(nsn, sizeof(NameSpaceName));
        CPrec_NamePatch(&current->name, nsn->name);
        CPrec_NewPointerPatch(&current->first.object, CPrec_GetObjBasePatch(nsn->first.object));
        if (nsn->first.next)
            CPrec_NewPointerPatch(&current->first.next, CPrec_GetNameSpaceObjectListPatch(nsn->first.next));

        if (!nsn->next)
            break;

        if ((addrPatch = CPrec_FindAddrPatch(nsn->next))) {
            CPrec_NewPointerPatch(&current->next, addrPatch->value);
            break;
        } else {
            next = CPrec_AppendAlign();
            CPrec_NewPointerPatch(&current->next, next);
            current = next;
            nsn = nsn->next;
            CPrec_NewAddrPatch(nsn, next);
        }
    } while (!flag || !cprec_dowrite || CPrec_FlushBufferCheck() == noErr);

    return first;
}

static NameSpaceList *CPrec_GetNameSpaceListPatch(NameSpaceList *nsl) {
    NameSpaceList *first, *current, *next;
    first = current = CPrec_AppendAlign();

    do {
        CPrec_AppendData(nsl, sizeof(NameSpaceList));
        CPrec_NewPointerPatch(&current->nspace, CPrec_GetNameSpacePatch(nsl->nspace));

        if (!nsl->next)
            break;
        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        nsl = nsl->next;
    } while (1);

    return first;
}

static NameSpace *CPrec_GetNameSpacePatch(NameSpace *nspace) {
    NameSpace *p;
    AddrPatch *addrPatch;

    if ((addrPatch = CPrec_FindAddrPatch(nspace)))
        return addrPatch->value;

    p = CPrec_AppendAlign();
    CPrec_NewAddrPatch(nspace, p);
    CPrec_AppendData(nspace, sizeof(NameSpace));

    if (nspace->parent)
        CPrec_NewPointerPatch(&p->parent, CPrec_GetNameSpacePatch(nspace->parent));
    if (nspace->name)
        CPrec_NamePatch(&p->name, nspace->name);
    if (nspace->usings)
        CPrec_NewPointerPatch(&p->usings, CPrec_GetNameSpaceListPatch(nspace->usings));
    if (nspace->theclass)
        CPrec_NewPointerPatch(&p->theclass, CPrec_GetTypePatch((Type *) nspace->theclass));

    if (nspace->is_hash) {
        char *hash;
        int i;
        hash = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&p->data.hash, hash);
        CPrec_AppendData(nspace->data.hash, sizeof(NameSpaceName *) * 1024);
        for (i = 0; i < 1024; i++) {
            if (nspace->data.hash[i])
                CPrec_NewPointerPatch(hash + (i * sizeof(NameSpaceName *)), CPrec_GetNameSpaceNamePatch(nspace->data.hash[i], 0));
        }
    } else if (nspace->data.list) {
        CPrec_NewPointerPatch(&p->data.list, CPrec_GetNameSpaceNamePatch(nspace->data.list, 0));
    }

    return p;
}

static void CPrec_DumpRootNameSpace(void) {
    NameSpaceList *nslist;
    NameSpaceName *nsname;
    int i;

    CError_ASSERT(3905, cscope_root->is_hash);

    if (cscope_root->usings) {
        nslist = CPrec_GetNameSpaceListPatch(cscope_root->usings);
        if (cprec_dowrite)
            cprec_header->usings = nslist;
    }

    if (cprec_dowrite)
        cprec_header->root_names = cscope_root->names;

    i = 0;
    do {
        if (cscope_root->data.hash[i]) {
            nsname = CPrec_GetNameSpaceNamePatch(cscope_root->data.hash[i], 1);
            if (cprec_dowrite) {
                if (cprec_ioerror != noErr)
                    break;
                cprec_header->root_nametable[i] = nsname;
            }
        }
    } while (++i < 0x400);
}

static CSOMStub *CPrec_GetSOMPatch(CSOMStub *stub) {
    CSOMStub *first, *current, *next;

    first = current = CPrec_AppendAlign();
    while (1) {
        CPrec_AppendData(stub, sizeof(CSOMStub));

        CPrec_NewPointerPatch(&current->object, CPrec_GetObjectPatch(stub->object));
        CPrec_NewPointerPatch(&current->tclass, CPrec_GetTypePatch(TYPE(stub->tclass)));

        if (!stub->next)
            break;

        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        stub = stub->next;
    }

    return first;
}

static OLinkList *CPrec_GetOLinkPatch(OLinkList *olink) {
    OLinkList *first, *current, *next;

    first = current = CPrec_AppendAlign();
    while (1) {
        CPrec_AppendData(olink, sizeof(OLinkList));

        CPrec_NewPointerPatch(&current->obj, CPrec_GetObjectPatch(olink->obj));

        if (!olink->next)
            break;

        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        olink = olink->next;
    }

    return first;
}

static StaticData *CPrec_GetStaticDataPatch(StaticData *sd) {
    StaticData *current, *first, *next;

    first = current = CPrec_AppendAlign();
    while (1) {
        CPrec_AppendData(sd, sizeof(StaticData));

        CPrec_NewPointerPatch(&current->object, CPrec_GetObjectPatch(sd->object));
        if (sd->buffer)
            CPrec_RawMemPatch(&current->buffer, sd->buffer, sd->object->type->size);
        if (sd->links)
            CPrec_NewPointerPatch(&current->links, CPrec_GetOLinkPatch(sd->links));

        if (!sd->next)
            break;

        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        sd = sd->next;
    }

    return first;
}

static CallbackAction *CPrec_GetCallbackPatch(CallbackAction *ca) {
    CallbackAction *first, *current, *next;

    first = current = CPrec_AppendAlign();
    while (1) {
        CPrec_AppendData(ca, sizeof(CallbackAction));

        CPrec_NewPointerPatch(&current->obj, CPrec_GetObjectPatch(ca->obj));
        CPrec_NewPointerPatch(&current->tclass, CPrec_GetTypePatch(TYPE(ca->tclass)));

        if (!ca->next)
            break;

        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        ca = ca->next;
    }

    return first;
}

static ObjCSelector **CPrec_GetSelHashTablePatch(ObjCSelector **table) {
    ObjCSelector **first, **current;
    int i;

    first = current = CPrec_AppendAlign();
    CPrec_AppendData(table, sizeof(ObjCSelector *) * 0x400);

    for (i = 0; i < 0x400; i++) {
        if (*table)
            CPrec_NewPointerPatch(current, CPrec_GetObjCSelectorPatch(*table));
        table++;
        current++;
    }

    return first;
}

static InitExpr *CPrec_GetIExpressionPatch(InitExpr *initexpr) {
    InitExpr *first, *current, *next;

    first = current = CPrec_AppendAlign();
    while (1) {
        CPrec_AppendData(initexpr, sizeof(InitExpr));

        CPrec_NewPointerPatch(&current->object, CPrec_GetObjectPatch(initexpr->object));
        CPrec_NewPointerPatch(&current->expr, CPrec_GetExpressionPatch(initexpr->expr));

        if (!initexpr->next)
            break;

        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        initexpr = initexpr->next;
    }

    return first;
}

static CI_Action *CPrec_GetInlineActionPatch(CI_Action *act) {
    CI_Action *current, *first, *next;

    first = current = CPrec_AppendAlign();
    while (1) {
        if (act->actiontype == CI_ActionInlineFunc)
            memclrw(&act->u.inlinefunc.fileoffset, sizeof(FileOffsetInfo));

        CPrec_AppendData(act, sizeof(CI_Action));

        CPrec_NewPointerPatch(&current->obj, CPrec_GetObjectPatch(act->obj));

        switch (act->actiontype) {
            case CI_ActionInlineFunc:
                if (act->u.inlinefunc.stream.firsttoken)
                    CPrec_NewPointerPatch(
                        &current->u.inlinefunc.stream.firsttoken,
                        CPrec_GetTStreamPatch(act->u.inlinefunc.stream.firsttoken, act->u.inlinefunc.stream.tokens));
                if (act->u.inlinefunc.tclass)
                    CPrec_NewPointerPatch(&current->u.inlinefunc.tclass, CPrec_GetTypePatch(TYPE(act->u.inlinefunc.tclass)));
                break;

            case CI_ActionMemberFunc:
                CPrec_NewPointerPatch(&current->u.memberfunc.templ, CPrec_GetTypePatch(TYPE(act->u.memberfunc.templ)));
                CPrec_NewPointerPatch(&current->u.memberfunc.inst, CPrec_GetTypePatch(TYPE(act->u.memberfunc.inst)));
                CPrec_NewPointerPatch(&current->u.memberfunc.tmemb, CPrec_GetTemplateMemberPatch(act->u.memberfunc.tmemb));
                break;

            case CI_ActionTemplateFunc:
                CPrec_NewPointerPatch(&current->u.templatefunc.func, CPrec_GetTemplateFunctionPatch(act->u.templatefunc.func));
                CPrec_NewPointerPatch(&current->u.templatefunc.inst, CPrec_GetTemplFuncInstancePatch(act->u.templatefunc.inst));
                break;

            case CI_ActionDefaultFunc:
                break;

            default:
                CError_FATAL(4177);
        }

        if (!act->next)
            break;

        next = CPrec_AppendAlign();
        CPrec_NewPointerPatch(&current->next, next);
        current = next;
        act = act->next;
    }

    return first;
}

static void CPrec_GenerateBuiltinPatches(void) {
    int x;
    int y;
    Patch *scan;

    for (x = 0; x < cprec_builtins; x++) {
        y = 0;
        for (scan = cprec_builtin[x].patches; scan; scan = scan->next)
            ++y;

        if (y) {
            CPrec_AppendWord32(y);
            CPrec_AppendWord32(x);
            for (scan = cprec_builtin[x].patches; scan; scan = scan->next)
                CPrec_AppendWord32(scan->offset);
        }
    }

    CPrec_AppendWord32(0);
}

static void CPrec_GenerateTokenStreamPatches(void) {
    TokenPatch *scan;

    for (scan = cprec_tokenpatches; scan; scan = scan->next) {
        CPrec_AppendWord32((UInt32) scan->tokens);
        CPrec_AppendWord32((UInt32) scan->count);
    }
    CPrec_AppendWord32(0);
}

static OSErr CPrec_CompressWrite(const char *data, SInt32 size) {
    char buf[2048 + 256];
    OSErr err;
    int bufpos = 0;
    int blockstart;
    int c;
    const char *p = data;
    const char *end = data + size;

    for (;;) {
        if (p < end) {
            if (!*p) {
                c = 224;
                while (!*p && p < end && c < 256) {
                    c++;
                    p++;
                }
                buf[bufpos++] = c - 1;
            } else {
                blockstart = bufpos++;
                c = 0;
                while (p < end && c < 224) {
                    if (!p[0] && !p[1]) {
                        break;
                    } else {
                        buf[bufpos++] = *(p++);
                        c++;
                    }
                }
                buf[blockstart] = c - 1;
            }
        }

        if (p >= end || bufpos > 2048) {
            if ((err = COS_FileWrite(cprec_refnum, buf, bufpos)))
                return err;

            if (p >= end)
                break;
            else
                bufpos = 0;
        }
    }

    return noErr;
}

static OSErr CPrec_FlushRawBuffer(void) {
    OSErr err;

    if (cprec_dowrite) {
        CPrec_AppendAlign();
        cprec_zero_offset += cprec_glist.size;
        COS_LockHandle(cprec_glist.data);
        err = CPrec_CompressWrite(*cprec_glist.data, cprec_glist.size);
        COS_UnlockHandle(cprec_glist.data);
        cprec_glist.size = 0;

        return err;
    } else {
        return noErr;
    }
}

static OSErr CPrec_FlushBufferCheck(void) {
    static SInt32 flushmax;
    OSErr err;

    if (cprec_glist.size > flushmax)
        flushmax = cprec_glist.size;

    if (cprec_glist.size > 10000) {
        err = CPrec_FlushRawBuffer();
        if (err) {
            cprec_ioerror = err;
            return err;
        }
    }

    return noErr;
}

static int CPrec_CompressPatches(void) {
    Patch *scan;
    int count;
    SInt32 last;

    cprec_glist.size = 0;

    scan = cprec_patch_list;
    last = 0;
    count = 0;
    while (scan) {
        CError_ASSERT(4339, (scan->offset & 0x80000001) == 0);

        if ((scan->offset - last) >= -128 && (scan->offset - last) <= 126)
            CPrec_AppendByte(((scan->offset - last) >> 1) | 0x80);
        else
            CPrec_AppendWord32(scan->offset);

        last = scan->offset;
        scan = scan->next;
        count++;
    }

    return count;
}

static OSErr CPrec_DumpColorSymbolTable(Boolean doWrite) {
    OSErr err;

    freelheap();

    CPrec_InitAddressHashTable();
    CPrec_InitPointerHashTable();

    cprec_patch_list = NULL;
    cprec_tokenpatches = NULL;
    cprec_offset = 0;
    cprec_zero_offset = 0;
    cprec_dowrite = doWrite;
    cprec_ioerror = noErr;

    CPrec_SetupBuiltIn();
    CPrec_AppendWord32(0);

    CPrec_DumpNameTable();
    if ((err = CPrec_FlushRawBuffer()) != noErr)
        return err;

    CPrec_DumpMacroTable();
    if ((err = CPrec_FlushRawBuffer()) != noErr)
        return err;

    CPrec_DumpRootNameSpace();
    if (doWrite) {
        if (cprec_ioerror != noErr)
            return cprec_ioerror;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (ctempl_templates) {
        TemplClass *p = TEMPL_CLASS(CPrec_GetTypePatch(TYPE(ctempl_templates)));
        if (doWrite)
            cprec_header->ctempl_templates = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (ctempl_templatefuncs) {
        TemplateFunction *p = CPrec_GetTemplateFunctionPatch(ctempl_templatefuncs);
        if (doWrite)
            cprec_header->ctempl_templatefuncs = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (csom_stubs) {
        CSOMStub *p = CPrec_GetSOMPatch(csom_stubs);
        if (doWrite)
            cprec_header->csom_stubs = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (cprec_staticdata) {
        StaticData *p = CPrec_GetStaticDataPatch(cprec_staticdata);
        if (doWrite)
            cprec_header->cprec_staticdata = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (callbackactions) {
        CallbackAction *p = CPrec_GetCallbackPatch(callbackactions);
        if (doWrite)
            cprec_header->callbackactions = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (cobjc_type_class) {
        Type *p = CPrec_GetTypePatch(cobjc_type_class);
        if (doWrite)
            cprec_header->cobjc_type_class = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (cobjc_type_id) {
        Type *p = CPrec_GetTypePatch(cobjc_type_id);
        if (doWrite)
            cprec_header->cobjc_type_id = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (cobjc_type_sel) {
        Type *p = CPrec_GetTypePatch(cobjc_type_sel);
        if (doWrite)
            cprec_header->cobjc_type_sel = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (cobjc_selhashtable) {
        ObjCSelector **p = CPrec_GetSelHashTablePatch(cobjc_selhashtable);
        if (doWrite)
            cprec_header->cobjc_selhashtable = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (cobjc_classdefs) {
        BClassList *p = CPrec_GetBClassListPatch(cobjc_classdefs);
        if (doWrite)
            cprec_header->cobjc_classdefs = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (cobjc_protocols) {
        ObjCProtocol *p = CPrec_GetObjCProtocolPatch(cobjc_protocols);
        if (doWrite)
            cprec_header->cobjc_protocols = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (init_expressions) {
        InitExpr *p = CPrec_GetIExpressionPatch(init_expressions);
        if (doWrite)
            cprec_header->init_expressions = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    if (cinline_tactionlist) {
        CI_Action *p = CPrec_GetInlineActionPatch(cinline_tactionlist);
        if (doWrite)
            cprec_header->cinline_tactionlist = p;
        if ((err = CPrec_FlushRawBuffer()) != noErr)
            return err;
    }

    return noErr;
}

static OSErr CPrec_FileAlign(short refnum, SInt32 *len) {
    OSErr err;
    SInt32 n;
    char buf[8];

    n = *len;
    if ((n & 7) == 0)
        return noErr;

    memclrw(buf, 8);
    err = COS_FileWrite(refnum, buf, n = 8 - (n & 7));
    *len += n;

    return err;
}

static OSErr CPrec_WriteFile(void) {
    char str[128];
    int i;
    HashNameNode *name;
    OSErr err;
    SInt32 offset;

    if (InitGList(&cprec_glist, 0x40000))
        CError_NoMem();

    CompilerGetCString(10, str);
    CWShowStatus(cparams.context, str, "");
    CPrep_RemoveSpecialMacros();

    for (i = 0; i < 0x800; i++) {
        for (name = name_hash_nodes[i]; name; name = name->next)
            name->id = 0;
    }

    if ((err = CPrec_DumpColorSymbolTable(0)) != noErr)
        return err;

    CompilerGetCString(11, str);
    CWShowStatus(cparams.context, str, "");

    cprec_header = galloc(sizeof(Header));
    memclrw(cprec_header, sizeof(Header));

    cprec_header->magic = 0xBEEFFACE;
    cprec_header->version = 1047;
    cprec_header->target = 2;
    cprec_header->check_header_flags = copts.checkprecompflags;
    cprec_header->cplusplus = copts.cplusplus;
    cprec_header->uniqueID = CParser_GetUniqueID();
    cprec_header->cobjc_selrefcount = cobjc_selrefcount;
    cprec_header->cobjc_classrefcount = cobjc_classrefcount;
    cprec_header->cobjc_stringcount = cobjc_stringcount;

    if ((err = COS_FileWrite(cprec_refnum, cprec_header, sizeof(Header))) != noErr)
        return err;

    offset = sizeof(Header);

    if ((err = CPrec_DumpColorSymbolTable(1)) != noErr)
        return err;

    cprec_header->x28 = cprec_offset;
    cprec_header->x30 = offset;

    if ((err = COS_FileGetPos(cprec_refnum, &offset)) != noErr)
        return err;

    cprec_header->x2C = offset - cprec_header->x30;

    cprec_header->compressedPatchCount = CPrec_CompressPatches();
    cprec_header->compressedPatchSize = cprec_glist.size;
    cprec_header->compressedPatchOffset = offset;

    if (cprec_header->compressedPatchCount) {
        if ((err = COS_FileWrite(cprec_refnum, *cprec_glist.data, cprec_glist.size)) != noErr)
            return err;
        offset += cprec_glist.size;
    }

    if ((err = CPrec_FileAlign(cprec_refnum, &offset)) != noErr)
        return err;

    cprec_glist.size = 0;
    CPrec_GenerateBuiltinPatches();
    cprec_header->builtinPatchSize = cprec_glist.size;
    cprec_header->builtinPatchOffset = offset;

    if ((err = COS_FileWrite(cprec_refnum, *cprec_glist.data, cprec_glist.size)) != noErr)
        return err;
    offset += cprec_glist.size;

    if (cprec_tokenpatches) {
        cprec_glist.size = 0;
        CPrec_GenerateTokenStreamPatches();
        cprec_header->tokenStreamPatchSize = cprec_glist.size;
        cprec_header->tokenStreamPatchOffset = offset;

        if ((err = COS_FileWrite(cprec_refnum, *cprec_glist.data, cprec_glist.size)) != noErr)
            return err;
        offset += cprec_glist.size;
    }

    if ((err = COS_FileSetPos(cprec_refnum, 0)) != noErr)
        return err;

    if ((err = COS_FileWrite(cprec_refnum, cprec_header, sizeof(Header))) != noErr)
        return err;

    return noErr;
}

void PrecompilerWrite(void) {
    OSErr err;
    short strindex;
    char str[128];
    FSSpec spec;

    spec = cparamblkptr->sourcefile;
    if (CWGetPrecompiledHeaderSpec(cparamblkptr->context, &spec, precomp_target_str) == cwNoErr) {
        strindex = 3;
        err = COS_FileNew(&spec, &cprec_refnum, copts.appltype, copts.headtype);
        if (err == noErr) {
            strindex = 4;
            err = CPrec_WriteFile();
        }
        CleanupPrecompiler();

        if (err != noErr) {
            CompilerGetCString(strindex, str);
            sprintf(string, str, err);
            CWReportMessage(cparamblkptr->context, NULL, string, NULL, messagetypeError, 0);
        } else {
            CWFileTime time = 0;
            CWSetModDate(cparamblkptr->context, &spec, &time, 1);
        }
    }
}

static void CPrec_ReadData(SInt32 offset, void *buffer, SInt32 size) {
    if (
        COS_FileSetPos(cprec_refnum, offset) != noErr ||
        COS_FileRead(cprec_refnum, buffer, size) != noErr
        )
        CError_ErrorTerm(CErrorStr181);
}

static void CPrec_ReadRawBuffer(void) {
    UInt8 *buffer;
    UInt8 *work;
    UInt8 *end;
    UInt32 size;
    int ch;

    if (!cprec_buffer) {
        size = cprec_header->x28 + (cprec_header->x28 >> 7) + 64;
        buffer = galloc(size);
        cprec_rawbuffer = buffer;

        work = buffer + size - cprec_header->x2C;
        CPrec_ReadData(cprec_header->x30, work, cprec_header->x2C);
    } else {
        buffer = galloc(cprec_header->x28);
        cprec_rawbuffer = buffer;
        work = (UInt8 *) cprec_buffer + cprec_header->x30;
    }

    end = work + cprec_header->x2C;

    while (work < end) {
        if ((ch = *(work++)) >= 0xE0) {
            ch -= 0xE0;
            do {
                *(buffer++) = 0;
            } while (--ch >= 0);
        } else {
            do {
                *(buffer++) = *(work++);
            } while (--ch >= 0);
        }
    }

    if (work != end || buffer != RESOLVE_RAW_BUFFER(cprec_header->x28))
        CError_ErrorTerm(CErrorStr181);
}

static void CPrec_RelocateRawBuffer(void) {
    UInt8 *patches;
    UInt32 offset;
    UInt8 *dest;
    SInt32 count;
    UInt8 *patch;
    UInt32 var;

    if ((count = cprec_header->compressedPatchCount)) {
        if (!cprec_buffer) {
            patches = lalloc(cprec_header->compressedPatchSize);
            CPrec_ReadData(cprec_header->compressedPatchOffset, patches, cprec_header->compressedPatchSize);
        } else {
            patches = RESOLVE_BUFFER(cprec_header->compressedPatchOffset);
        }

        offset = 0;
        patch = patches;
        dest = cprec_rawbuffer;
        do {
            if (!(*patch & 0x80)) {
                ((UInt8 *) &var)[0] = *(patch++);
                ((UInt8 *) &var)[1] = *(patch++);
                ((UInt8 *) &var)[2] = *(patch++);
                ((UInt8 *) &var)[3] = *(patch++);
                offset = var;
            } else {
                offset += (char) (*(patch++) * 2);
            }
            *((uintptr_t *) (dest + offset)) += (uintptr_t) dest;
        } while (--count > 0);

        freelheap();

        if (patch != (patches + cprec_header->compressedPatchSize))
            CError_ErrorTerm(CErrorStr181);
    }
}

static void CPrec_RelocateBuiltins(void) {
    UInt32 *patches;
    void *builtin;
    UInt32 count;
    UInt8 *buffer;

    if (cprec_header->builtinPatchSize) {
        CPrec_SetupBuiltInArray();
        if (!cprec_buffer) {
            patches = lalloc(cprec_header->builtinPatchSize);
            CPrec_ReadData(cprec_header->builtinPatchOffset, patches, cprec_header->builtinPatchSize);
        } else {
            patches = RESOLVE_BUFFER(cprec_header->builtinPatchOffset);
        }

        buffer = cprec_rawbuffer;
        while (1) {
            if (!(count = *(patches++)))
                break;

            builtin = cprec_builtin_array[*(patches++)];
            do {
                *((void **) (buffer + *(patches++))) = builtin;
            } while (--count);
        }
    }
}

static void CPrec_RelocateTokenStreams(void) {
    UInt32 *patches;
    UInt32 count;
    TStreamElement *tokens;
    UInt8 *buffer;
    CPrepFileInfo *file;
    SInt32 pos;

    if (cprec_header->tokenStreamPatchSize) {
        CPrep_GetPrepPos(&file, &pos);

        if (!cprec_buffer) {
            patches = lalloc(cprec_header->tokenStreamPatchSize);
            CPrec_ReadData(cprec_header->tokenStreamPatchOffset, patches, cprec_header->tokenStreamPatchSize);
        } else {
            patches = RESOLVE_BUFFER(cprec_header->tokenStreamPatchOffset);
        }

        buffer = cprec_rawbuffer;
        while (1) {
            if (!*patches)
                break;

            tokens = (TStreamElement *) (buffer + *(patches++));
            count = *(patches++);

            while (count--) {
                tokens->tokenfile = file;
                tokens->tokenoffset = pos;
                tokens++;
            }
        }
    }
}

static void CPrec_RelocateMacroTable(void) {
    int i;
    int j;
    int count;
    UInt8 *buffer;
    Macro **prec_table;
    Macro **table;
    Macro *macro;
    uintptr_t offset;

    buffer = cprec_rawbuffer;
    prec_table = cprec_header->macrotable;
    table = macrohashtable;

    i = 0;
    do {
        for (macro = *table; macro; macro = macro->next) {
            macro->name = GetHashNameNodeExport(macro->name->name);
            count = macro->xC & 0x7FFF;
            for (j = 1; j < count; j++)
                macro->names[j - 1] = GetHashNameNodeExport(macro->names[j - 1]->name);
        }

        if ((offset = (uintptr_t) *prec_table)) {
            if (*table) {
                macro = (Macro *) (buffer + offset);
                while (macro->next)
                    macro = macro->next;
                macro->next = *table;
            }
            *table = (Macro *) (buffer + offset);
        }

        prec_table++;
        table++;
    } while (++i < 0x800);
}

static void CPrec_RelocateTable(void **table, int size, void **dest) {
    int i;
    void *buffer = cprec_rawbuffer;

    for (i = 0; i < size; i++) {
        if (*table)
            *dest = (char *) buffer + (uintptr_t) *table;
        else
            *dest = NULL;
        table++;
        dest++;
    }
}

static void CPrec_RelocateRootNameSpace(void) {
    CError_ASSERT(4981, cscope_root->is_hash);

    cscope_root->names = cprec_header->root_names;
    CPrec_RelocateTable(
        (void **) cprec_header->root_nametable,
        0x400,
        (void **) cscope_root->data.hash);
}

static void CPrec_FixNameIds(void) {
    int i;
    HashNameNode *node;

    for (i = 0; i < 2048; i++) {
        for (node = name_hash_nodes[i]; node; node = node->next)
            node->id = -1;
    }
}

static void CPrec_DefineStaticData(void) {
    StaticData *sd = cprec_staticdata;
    cprec_staticdata = NULL;

    while (sd) {
        CInit_DeclareData(sd->object, sd->buffer, sd->links, sd->size);
        sd = sd->next;
    }
}

void PrecompilerRead(short refnum, void *buffer) {
    cprec_refnum = refnum;
    cprec_buffer = buffer;

    CPrep_RemoveSpecialMacros();

    if (!CScope_IsEmptySymTable())
        CError_ErrorTerm(CErrorStr180);

    if (!cprec_buffer) {
        cprec_header = galloc(sizeof(Header));
        CPrec_ReadData(0, cprec_header, sizeof(Header));
    } else {
        cprec_header = cprec_buffer;
    }

    if (cprec_header->magic != 0xBEEFFACE)
        CError_ErrorTerm(CErrorStr181);
    if (cprec_header->version != 1047)
        CError_ErrorTerm(CErrorStr222);
    if (cprec_header->target != 2)
        CError_ErrorTerm(CErrorStr223);

    copts.checkprecompflags = cprec_header->check_header_flags;

    CPrec_ReadRawBuffer();
    CPrec_RelocateRawBuffer();
    CPrec_RelocateBuiltins();
    CPrec_RelocateTable((void **) cprec_header->nametable, 0x800, (void **) name_hash_nodes);
    CPrec_FixNameIds();
    CPrec_RelocateMacroTable();
    CPrec_RelocateTokenStreams();
    CPrec_RelocateRootNameSpace();

    if (!cprec_header->usings)
        cscope_root->usings = NULL;
    else
        cscope_root->usings = RESOLVE_RAW_BUFFER(cprec_header->usings);

    ctempl_templates = RESOLVE_SAFE(cprec_header->ctempl_templates);
    ctempl_templatefuncs = RESOLVE_SAFE(cprec_header->ctempl_templatefuncs);
    csom_stubs = RESOLVE_SAFE(cprec_header->csom_stubs);
    cprec_staticdata = RESOLVE_SAFE(cprec_header->cprec_staticdata);
    callbackactions = RESOLVE_SAFE(cprec_header->callbackactions);
    cobjc_type_class = RESOLVE_SAFE(cprec_header->cobjc_type_class);
    cobjc_type_id = RESOLVE_SAFE(cprec_header->cobjc_type_id);
    cobjc_type_sel = RESOLVE_SAFE(cprec_header->cobjc_type_sel);
    cobjc_selhashtable = RESOLVE_SAFE(cprec_header->cobjc_selhashtable);
    cobjc_classdefs = RESOLVE_SAFE(cprec_header->cobjc_classdefs);
    cobjc_protocols = RESOLVE_SAFE(cprec_header->cobjc_protocols);
    init_expressions = RESOLVE_SAFE(cprec_header->init_expressions);
    cinline_tactionlist = RESOLVE_SAFE(cprec_header->cinline_tactionlist);
    CParser_SetUniqueID(cprec_header->uniqueID);
    cobjc_selrefcount = cprec_header->cobjc_selrefcount;
    cobjc_classrefcount = cprec_header->cobjc_classrefcount;
    cobjc_stringcount = cprec_header->cobjc_stringcount;

    cprec_refnum = 0;

    CleanupPrecompiler();
    cscope_current = cscope_root;

    if (!CParser_ReInitRuntimeObjects(1))
        CError_ErrorTerm(CErrorStr181);

    CPrep_InsertSpecialMacros();

    if (cparamblkptr->precompile != 1)
        CPrec_DefineStaticData();
}