a bunch of compiler stuff

1 files changed, 921 insertions, 0 deletions

diff --git a/compiler_and_linker/FrontEnd/C/CPrep.c b/compiler_and_linker/FrontEnd/C/CPrep.c
new file mode 100644
index 0000000..e69bcfb
--- /dev/null
+++ b/compiler_and_linker/FrontEnd/C/CPrep.c
@@ -0,0 +1,921 @@
+#include "compiler.h"
+#include "compiler/CError.h"
+#include "compiler/tokens.h"
+#include "cos.h"
+
+extern SInt16 *CLT_filesp;
+extern CPrepFileInfo **CLT_filestack;
+
+//#define OPT_OFFSET(optname) ((short) (((char *) (&copts.optname)) - ((char *) &copts)))
+#define OPT_OFFSET(optname) ((short) ( &((COpts *)0)->optname ))
+enum {
+    OPT_FLAG_2000 = 0x2000,
+    OPT_FLAG_4000 = 0x4000
+};
+
+struct {
+    char *name;
+    short bits;
+} compileroptions[138] = {
+        "little_endian", OPT_FLAG_4000 | OPT_OFFSET(little_endian),
+        "longlong", OPT_OFFSET(longlong),
+        "traceback", OPT_OFFSET(traceback),
+        "disable_registers", OPT_OFFSET(disable_registers),
+        "fp_contract", OPT_OFFSET(fp_contract),
+        "no_common", OPT_OFFSET(no_common),
+        "no_implicit_templates", OPT_OFFSET(no_implicit_templates),
+        "absolutepath", OPT_OFFSET(absolutepath),
+        "debug_listing", OPT_OFFSET(debuglisting),
+        "profile", OPT_OFFSET(profile),
+        "optimizewithasm", OPT_OFFSET(optimizewithasm),
+        "use_lmw_stmw", OPT_OFFSET(use_lmw_stmw),
+        "no_register_save_helpers", OPT_OFFSET(no_register_save_helpers),
+        "ppc_opt_bclr_bcctr", OPT_OFFSET(ppc_opt_bclr_bcctr),
+        "misaligned_mem_access", OPT_OFFSET(misaligned_mem_access),
+        "switch_tables", OPT_OFFSET(switch_tables),
+        "prepare_compress", OPT_OFFSET(prepare_compress),
+        "asmsemicolcomment", OPT_OFFSET(asmsemicolcomment),
+        "asmpoundcomment", OPT_OFFSET(asmpoundcomment),
+        "cplusplus", OPT_OFFSET(cplusplus),
+        "ecplusplus", OPT_OFFSET(ecplusplus),
+        "objective_c", OPT_OFFSET(objective_c),
+        "objc_strict", OPT_OFFSET(objc_strict),
+        "ARM_conform", OPT_OFFSET(ARM_conform),
+        "ARM_scoping", OPT_OFFSET(ARM_scoping),
+        "require_prototypes", OPT_OFFSET(require_prototypes),
+        "trigraphs", OPT_OFFSET(trigraphs),
+        "only_std_keywords", OPT_OFFSET(only_std_keywords),
+        "enumsalwaysint", OPT_OFFSET(enumsalwaysint),
+        "ANSI_strict", OPT_OFFSET(ANSI_strict),
+        "mpwc_relax", OPT_OFFSET(mpwc_relax),
+        "mpwc_newline", OPT_OFFSET(mpwc_newline),
+        "ignore_oldstyle", OPT_OFFSET(ignore_oldstyle),
+        "cpp_extensions", OPT_OFFSET(cpp_extensions),
+        "pointercast_lvalue", OPT_OFFSET(pointercast_lvalue),
+        "RTTI", OPT_OFFSET(useRTTI),
+        "delete_exception", OPT_OFFSET(delete_exception),
+        "oldalignment", OPT_OFFSET(oldalignment),
+        "multibyteaware", OPT_OFFSET(multibyteaware),
+        "unsigned_char", OPT_OFFSET(unsignedchars),
+        "auto_inline", OPT_OFFSET(autoinline),
+        "inline_bottom_up", OPT_OFFSET(inline_bottom_up),
+        "defer_codegen", OPT_OFFSET(defer_codegen),
+        "direct_to_som", OPT_OFFSET(direct_to_som),
+        "SOMCheckEnvironment", OPT_OFFSET(som_env_check),
+        "SOMCallOptimization", OPT_OFFSET(som_call_opt),
+        "bool", OPT_OFFSET(booltruefalse),
+        "old_enum_mangler", OPT_OFFSET(old_enum_mangler),
+        "longlong_enums", OPT_OFFSET(longlong_enums),
+        "no_tfuncinline", OPT_OFFSET(no_tfuncinline),
+        "flat_include", OPT_OFFSET(flat_include),
+        "syspath_once", OPT_OFFSET(syspath_once),
+        "always_import", OPT_OFFSET(always_import),
+        "simple_class_byval", OPT_OFFSET(simple_class_byval),
+        "wchar_type", OPT_OFFSET(wchar_type),
+        "vbase_ctor_offset", OPT_OFFSET(vbase_ctor_offset),
+        "vbase_abi_v2", OPT_OFFSET(vbase_abi_v2),
+        "def_inherited", OPT_OFFSET(def_inherited),
+        "template_patch", OPT_OFFSET(template_patch),
+        "template_friends", OPT_OFFSET(template_friends),
+        "faster_pch_gen", OPT_OFFSET(faster_pch_gen),
+        "array_new_delete", OPT_OFFSET(array_new_delete),
+        "dollar_identifiers", OPT_OFFSET(dollar_identifiers),
+        "def_inline_tfuncs", OPT_OFFSET(def_inline_tfuncs),
+        "arg_dep_lookup", OPT_OFFSET(arg_dep_lookup),
+        "simple_prepdump", OPT_OFFSET(simple_prepdump),
+        "line_prepdump", OPT_OFFSET(line_prepdump),
+        "fullpath_prepdump", OPT_OFFSET(fullpath_prepdump),
+        "old_mtemplparser", OPT_OFFSET(old_mtemplparser),
+        "suppress_init_code", OPT_OFFSET(suppress_init_code),
+        "reverse_bitfields", OPT_OFFSET(reverse_bitfields),
+        "c9x", OPT_OFFSET(c9x),
+        "float_constants", OPT_OFFSET(float_constants),
+        "no_static_dtors", OPT_OFFSET(no_static_dtors),
+        "longlong_prepeval", OPT_OFFSET(longlong_prepeval),
+        "const_strings", OPT_OFFSET(const_strings),
+        "dumpir", OPT_OFFSET(dumpir),
+        "experimental", OPT_OFFSET(experimental),
+        "gcc_extensions", OPT_OFFSET(gcc_extensions),
+        "stdc_fp_contract", OPT_OFFSET(stdc_fp_contract),
+        "stdc_fenv_access", OPT_OFFSET(stdc_fenv_access),
+        "stdc_cx_limitedr", OPT_OFFSET(stdc_cx_limitedr),
+        "old_argmatch", OPT_OFFSET(old_argmatch),
+        "optEH", OPT_OFFSET(optEH),
+        "optEH2", OPT_OFFSET(optEH2),
+        "new_mangler", OPT_OFFSET(new_mangler),
+        "microsoft_exceptions", OPT_OFFSET(microsoft),
+        "microsoft_RTTI", OPT_OFFSET(microsoft),
+        "warning_errors", OPT_OFFSET(warningerrors),
+        "extended_errorcheck", OPT_OFFSET(pedantic),
+        "check_header_flags", OPT_OFFSET(check_header_flags),
+        "supress_warnings", OPT_OFFSET(supress_warnings),
+        "warn_illpragma", OPT_OFFSET(warn_illpragma),
+        "warn_emptydecl", OPT_OFFSET(warn_emptydecl),
+        "warn_possunwant", OPT_OFFSET(warn_possunwant),
+        "warn_unusedvar", OPT_OFFSET(warn_unusedvar),
+        "warn_unusedarg", OPT_OFFSET(warn_unusedarg),
+        "warn_extracomma", OPT_OFFSET(warn_extracomma),
+        "warn_hidevirtual", OPT_OFFSET(warn_hidevirtual),
+        "warn_largeargs", OPT_OFFSET(warn_largeargs),
+        "warn_implicitconv", OPT_OFFSET(warn_implicitconv),
+        "warn_notinlined", OPT_OFFSET(warn_notinlined),
+        "warn_structclass", OPT_OFFSET(warn_structclass),
+        "warn_padding", OPT_OFFSET(warn_padding),
+        "warn_no_side_effect", OPT_OFFSET(warn_no_side_effect),
+        "warn_resultnotused", OPT_OFFSET(warn_resultnotused),
+        "warn_ptr_int_conv", OPT_OFFSET(warn_ptr_int_conv),
+        "align_array_members", OPT_OFFSET(align_array_members),
+        "dont_reuse_strings", OPT_OFFSET(dont_reuse_strings),
+        "pool_strings", OPT_OFFSET(pool_strings),
+        "explicit_zero_data", OPT_OFFSET(explicit_zero_data),
+        "readonly_strings", OPT_OFFSET(readonly_strings),
+        "opt_common_subs", OPT_OFFSET(opt_common_subs),
+        "opt_loop_invariants", OPT_OFFSET(opt_loop_invariants),
+        "opt_propagation", OPT_OFFSET(opt_propagation),
+        "opt_unroll_loops", OPT_OFFSET(opt_unroll_loops),
+        "opt_lifetimes", OPT_OFFSET(opt_lifetimes),
+        "opt_strength_reduction", OPT_OFFSET(opt_strength_reduction),
+        "opt_strength_reduction_strict", OPT_OFFSET(opt_strength_reduction_strict),
+        "opt_dead_code", OPT_OFFSET(opt_dead_code),
+        "opt_dead_assignments", OPT_OFFSET(opt_dead_assignments),
+        "opt_vectorize_loops", OPT_OFFSET(opt_vectorize_loops),
+        "opt_pointer_analysis", OPT_OFFSET(opt_pointer_analysis),
+        "exceptions", OPT_OFFSET(exceptions),
+        "dont_inline", OPT_OFFSET(dont_inline),
+        "always_inline", OPT_OFFSET(always_inline),
+        "optimize_for_size", OPT_OFFSET(optimize_for_size),
+        "peephole", OPT_OFFSET(peephole),
+        "global_optimizer", OPT_OFFSET(global_optimizer),
+        "side_effects", OPT_OFFSET(side_effects),
+        "internal", OPT_FLAG_2000 | OPT_OFFSET(internal),
+        "import", OPT_FLAG_2000 | OPT_OFFSET(import),
+        "export", OPT_FLAG_2000 | OPT_OFFSET(export),
+        "lib_export", OPT_FLAG_2000 | OPT_OFFSET(lib_export),
+        "nosyminline", OPT_OFFSET(nosyminline),
+        "force_active", OPT_OFFSET(force_active),
+        "sym", OPT_OFFSET(isGeneratingDebugInfo),
+        NULL, 0
+};
+
+CParams *cparamblkptr;
+short tk;
+CInt64 tkintconst;
+Float tkfloatconst;
+char *tkstring;
+HashNameNode *tkidentifier;
+SInt32 tksize;
+short ispascalstring;
+short nlflag;
+SInt32 lines;
+Boolean spaceskip;
+Macro **macrohashtable;
+Boolean cprep_nomem_exit;
+Boolean cprep_nostring;
+Boolean cprep_eoltokens;
+static void *ifstack[100]; // TODO type+size
+static short iflevel;
+TokenStack tokenstack[128];
+short tokenstacklevel;
+SInt32 cprep_cursymfile; // might be a ptr?
+char *pos;
+char *macropos;
+char *nextcharpos;
+char CPrep_SkipNewCommentChar;
+Boolean preprocessing_only;
+Handle stringmem;
+SInt32 maxstringsize;
+char cprep_idarray[256];
+Boolean was_escchar;
+Boolean macrocheck;
+Boolean widestring;
+Boolean at_linestart;
+char *prep_file_start;
+char *prep_file_end;
+char *macrostart;
+Boolean cprep_strconcat;
+CPrepFileInfo *prep_file;
+short filesp;
+SInt32 linenumber;
+static CPrepFileInfo *filestack[32];
+static void *cprep_files; // TODO type
+static SInt32 linetick;
+static Boolean waslockedmacro;
+static Boolean include_once;
+static time_t now_time;
+static SInt32 lineoffset;
+static Boolean was_prep_error;
+static Boolean cprep_hasprepline;
+static Boolean cprep_incondexpr;
+static void *cprep_packstack[100]; // TODO type+size
+static short cprep_packstackp;
+static Macro lineM;
+static Macro fileM;
+static Macro dateM;
+static Macro timeM;
+static Macro stdcM;
+static Macro stcvM;
+static Macro stchM;
+static Macro casmM;
+static Macro cpplM;
+static Macro MWRSM;
+static Macro dtsomM;
+static Macro ecppM;
+static Macro optiM;
+static Macro trgtM;
+GList pplist;
+struct COptsPush {
+    struct COptsPush *next;
+    COpts opts;
+};
+static struct COptsPush *coptpushs;
+static void *coptpush; // TODO type
+static void *coptssave; // TODO type
+static Boolean dofreeaheap;
+static GList mlist;
+static Handle ts_buffer;
+static TStreamElement *ts_first;
+static TStreamElement *ts_last;
+TStreamElement *ts_current;
+static SInt32 ts_elements;
+SInt32 ts_preread_elements;
+static SInt32 gDirectiveStart;
+static SInt32 high_mem_mark;
+// static TStreamElement dummyelement; // in CPrep_CurStreamElement
+static short exprtk;
+
+static void cannotopenerror(StringPtr filename, Boolean err) {
+    static char fname[64];
+
+    short len = filename[0];
+    if (len > 63)
+        len = 63;
+    memcpy(fname, filename + 1, len);
+    fname[len] = 0;
+
+    CError_ResetErrorSkip();
+
+    if (prep_file) {
+        was_prep_error = 1;
+        CError_Error(151, fname);
+        if (err)
+            longjmp(errorreturn, 1);
+    } else {
+        CError_CannotOpen();
+    }
+}
+
+static void insertmacro(Macro *macro) {
+    macro->next = macrohashtable[macro->name->hashval];
+    macrohashtable[macro->name->hashval] = macro;
+    macro->xF = 0;
+}
+
+void CPrep_InsertSpecialMacro(Macro *macro, char *name) {
+    macro->name = GetHashNameNodeExport(name);
+    macro->is_special = 1;
+    insertmacro(macro);
+}
+
+void CPrep_InsertSpecialMacros() {
+    CPrep_InsertSpecialMacro(&lineM, "__LINE__");
+    CPrep_InsertSpecialMacro(&fileM, "__FILE__");
+    CPrep_InsertSpecialMacro(&dateM, "__DATE__");
+    CPrep_InsertSpecialMacro(&timeM, "__TIME__");
+    CPrep_InsertSpecialMacro(&stdcM, "__STDC__");
+    CPrep_InsertSpecialMacro(&stcvM, "__STDC_VERSION__");
+    CPrep_InsertSpecialMacro(&stchM, "__STDC_HOSTED__");
+    CPrep_InsertSpecialMacro(&casmM, "__CASM__");
+    CPrep_InsertSpecialMacro(&cpplM, "__cplusplus");
+    CPrep_InsertSpecialMacro(&MWRSM, "__MWERKS__");
+    CPrep_InsertSpecialMacro(&dtsomM, "__SOM_ENABLED__");
+    CPrep_InsertSpecialMacro(&ecppM, "__embedded_cplusplus");
+    CPrep_InsertSpecialMacro(&optiM, "__option");
+    CPrep_InsertSpecialMacro(&trgtM, "__ide_target");
+    CodeGen_InsertSpecialMacros();
+}
+
+void CPrep_RemoveSpecialMacros() {
+    Macro **scan;
+    int x;
+
+    for (x = 0; x < 2048; x++) {
+        scan = &macrohashtable[x];
+        while (*scan) {
+            if ((*scan)->is_special) {
+                *scan = (*scan)->next;
+            } else {
+                scan = &(*scan)->next;
+            }
+        }
+    }
+}
+
+static void CPrep_Reconfig() {
+    cprep_idarray['$'] = copts.dollar_identifiers != 0;
+}
+
+Boolean setupprep() {
+    int x;
+
+    now_time = time(NULL);
+    lineoffset = 0;
+    include_once = 0;
+    cprep_eoltokens = 0;
+    cprep_nostring = 0;
+    cprep_incondexpr = 0;
+    filesp = -1;
+    linetick = 0;
+    lines = 0;
+    dofreeaheap = 1;
+    macrocheck = 1;
+    maxstringsize = 256;
+    iflevel = 0;
+    tokenstacklevel = 0;
+    cprep_cursymfile = 0;
+    cprep_files = 0;
+    CLT_filesp = &filesp;
+    CLT_filestack = filestack;
+    anyerrors = 0;
+    fatalerrors = 0;
+    was_prep_error = 0;
+    cprep_strconcat = 0;
+
+    GListErrorProc = CError_NoMem;
+    mlist.data = NULL;
+    pplist.data = NULL;
+    if (InitGList(&mlist, 10000))
+        CError_NoMem();
+
+    stringmem = COS_NewHandle(256);
+    if (!stringmem)
+        CError_NoMem();
+    ts_buffer = COS_NewHandle(1024 * sizeof(TStreamElement));
+    if (!ts_buffer)
+        CError_NoMem();
+    COS_LockHandleHi(ts_buffer);
+    ts_first = (TStreamElement *) *ts_buffer;
+    ts_last = ts_first + 1023;
+    ts_current = ts_first;
+    ts_elements = 1024;
+    ts_preread_elements = 0;
+
+    macrohashtable = galloc(sizeof(Macro *) * 2048);
+    memclrw(macrohashtable, sizeof(Macro *) * 2048);
+    CPrep_InsertSpecialMacros();
+
+    for (x = 0; x < 256; x++)
+        cprep_idarray[x] = 0;
+
+    for (x = 'a'; ; x++) {
+        cprep_idarray[x] = 1;
+        if (x == 'z') break;
+    }
+
+    for (x = 'A'; ; x++) {
+        cprep_idarray[x] = 1;
+        if (x == 'Z') break;
+    }
+
+    for (x = '0'; ; x++) {
+        cprep_idarray[x] = 2;
+        if (x == '9') break;
+    }
+
+    cprep_idarray['_'] = 1;
+
+    CPrep_Reconfig();
+    return 0;
+}
+
+void cleanupprep() {
+    while (filesp >= 0)
+        popfile();
+
+    high_mem_mark = CTool_TotalHeapSize();
+    releaseheaps();
+    GListErrorProc = NULL;
+    FreeGList(&mlist);
+    FreeGList(&pplist);
+
+    if (stringmem) {
+        COS_FreeHandle(stringmem);
+        stringmem = NULL;
+    }
+
+    if (ts_buffer) {
+        COS_FreeHandle(ts_buffer);
+        ts_buffer = NULL;
+    }
+    ts_current = NULL;
+    ts_first = ts_last = NULL;
+}
+
+static char *getfiledata(FSSpec *spec) {
+    const char *text;
+    SInt32 textlength;
+    short filedatatype;
+
+    if (CWGetFileText(cparamblkptr->context, spec, &text, &textlength, &filedatatype) != cwNoErr) {
+        Str255 filename;
+        COS_FileGetFSSpecInfo(spec, NULL, NULL, filename);
+        cannotopenerror(filename, 1);
+        return NULL;
+    } else {
+        return (char *) text;
+    }
+}
+
+static Boolean setupfile(StringPtr filename, Boolean flag1, Boolean flag2) {
+    CPrepFileInfo prepinfo;
+    CWFileInfo fileinfo;
+    Str255 file_filename;
+    char myfilename[256];
+    OSType file_type;
+    SInt32 file_size;
+    SInt32 file_dirid;
+    CWMemHandle cache_hnd;
+    void *cache;
+    SInt16 refnum;
+    SInt16 file_vrefnum;
+    char *extpos;
+
+    if (filesp >= 31) {
+        was_prep_error = 1;
+        CError_ErrorTerm(243);
+        return 0;
+    }
+
+    memclrw(&prepinfo, sizeof(CPrepFileInfo));
+    prepinfo.unkfield126 = !flag1; // may be wrong field!
+    if (filename) {
+        memclrw(&fileinfo, sizeof(CWFileInfo));
+        fileinfo.fullsearch = flag2;
+        fileinfo.dependencyType = cwNormalDependency;
+        fileinfo.isdependentoffile = -1;
+        memcpy(myfilename, &filename[1], filename[0]);
+        myfilename[filename[0]] = 0;
+
+        if (CWFindAndLoadFile(cparamblkptr->context, myfilename, &fileinfo) != cwNoErr) {
+            if (filename[0] + strlen(".framework/Headers") < 255) {
+                if ((extpos = strchr(myfilename, '/'))) {
+                    // Do Me! 37D8C
+                } else {
+                    cannotopenerror(filename, 0);
+                    return 0;
+                }
+            } else {
+                cannotopenerror(filename, 0);
+                return 0;
+            }
+        }
+
+        if ((flag2 || include_once) && fileinfo.alreadyincluded)
+            return 1;
+
+        prepinfo.textfile = fileinfo.filespec;
+        prepinfo.nameNode = CTool_GetPathName(&fileinfo.filespec, &prepinfo.fileModDate);
+        if (fileinfo.filedata) {
+            if (fileinfo.filedatatype == cwFileTypeText) {
+                prepinfo.textbuffer = (char *) fileinfo.filedata;
+                prepinfo.textlength = fileinfo.filedatalength;
+                prepinfo.fileID = fileinfo.fileID;
+                prepinfo.recordbrowseinfo = fileinfo.recordbrowseinfo;
+            } else if (fileinfo.filedatatype == cwFileTypePrecompiledHeader) {
+                PrecompilerRead(0, (void *) fileinfo.filedata);
+                return 1;
+            } else {
+                cannotopenerror(filename, 0);
+                return 0;
+            }
+        } else {
+            COS_FileGetFSSpecInfo(&prepinfo.textfile, &file_vrefnum, &file_dirid, file_filename);
+            if (COS_FileOpen(&prepinfo.textfile, &refnum)) {
+                cannotopenerror(filename, 0);
+                return 0;
+            }
+            if (COS_FileGetType(&prepinfo.textfile, &file_type) || COS_FileGetSize(refnum, &file_size)) {
+                COS_FileClose(refnum);
+                cannotopenerror(filename, 0);
+                return 0;
+            }
+            if (file_type == copts.pchType) {
+                if (cparamblkptr->isCachingPrecompiledHeaders) {
+                    if (CWAllocMemHandle(cparamblkptr->context, file_size, 1, &cache_hnd) != cwNoErr) {
+                        if (CWAllocMemHandle(cparamblkptr->context, file_size, 0, &cache_hnd) != cwNoErr) {
+                            COS_FileClose(refnum);
+                            CError_NoMem();
+                        }
+                    }
+
+                    CWLockMemHandle(cparamblkptr->context, cache_hnd, 0, &cache);
+                    if (COS_FileRead(refnum, cache, file_size)) {
+                        COS_FileClose(refnum);
+                        CWFreeMemHandle(cparamblkptr->context, cache_hnd);
+                        cannotopenerror(filename, 0);
+                        return 0;
+                    }
+                    COS_FileClose(refnum);
+                    CWCachePrecompiledHeader(cparamblkptr->context, &prepinfo.textfile, cache_hnd);
+                    PrecompilerRead(0, cache);
+                    CWUnlockMemHandle(cparamblkptr->context, cache_hnd);
+                    return 1;
+                } else {
+                    PrecompilerRead(refnum, 0);
+                    COS_FileClose(refnum);
+                    return 1;
+                }
+            } else {
+                COS_FileClose(refnum);
+                cannotopenerror(filename, 0);
+                return 0;
+            }
+        }
+    } else {
+        if (!cparamblkptr->mainFileText) {
+            COS_FileGetFSSpecInfo(&cparamblkptr->mainFileSpec, &file_vrefnum, &file_dirid, file_filename);
+            cannotopenerror(file_filename, 1);
+            return 0;
+        }
+
+        prepinfo.textfile = cparamblkptr->mainFileSpec;
+        prepinfo.textbuffer = (char *) cparamblkptr->mainFileText;
+        prepinfo.textlength = cparamblkptr->mainFileTextLength;
+        prepinfo.fileID = cparamblkptr->mainFileID;
+        prepinfo.recordbrowseinfo = cparamblkptr->field276;
+    }
+
+    if (filesp >= 0) {
+        filestack[filesp]->linenumber = linenumber;
+        filestack[filesp]->hasprepline = cprep_hasprepline;
+        filestack[filesp]->pos = pos - filestack[filesp]->textbuffer;
+    }
+
+    pos = prepinfo.textbuffer;
+    linenumber = 1;
+    at_linestart = 1;
+    filestack[++filesp] = galloc(sizeof(CPrepFileInfo));
+    *filestack[filesp] = prepinfo;
+    prep_file = filestack[filesp];
+    prep_file_start = prep_file->textbuffer;
+    prep_file_end = prep_file->textbuffer + prep_file->textlength;
+    if (preprocessing_only && !copts.simple_prepdump)
+        CPrep_PreprocessDumpFileInfo(1);
+
+    return 1;
+}
+
+void CPrep_TSBufferGrow(int amount) {
+    int current_offset = ts_current - ts_first;
+    COS_UnlockHandle(ts_buffer);
+    if (!COS_ResizeHandle(ts_buffer, sizeof(TStreamElement) * (ts_elements + amount)))
+        CError_NoMem();
+    COS_LockHandleHi(ts_buffer);
+    ts_elements += amount;
+    ts_first = (TStreamElement *) *ts_buffer;
+    ts_last = ts_first + (ts_elements - 1);
+    ts_current = ts_first + current_offset;
+}
+
+void CPrep_TokenStreamGetState(SInt32 *state) {
+    *state = ts_current - ts_first;
+}
+
+void CPrep_TokenStreamSetState(SInt32 *state) {
+    ts_preread_elements += ts_current - ts_first - *state;
+    ts_current = ts_first + *state;
+}
+
+void CPrep_UnLex() {
+    ++ts_preread_elements;
+    --ts_current;
+#line 900
+    CError_ASSERT(ts_current >= ts_first);
+}
+
+void CPrep_TokenStreamSetCurState(SInt32 *state) {
+    ts_preread_elements += ts_current - ts_first - (*state - 1);
+    ts_current = ts_first + (*state - 1);
+    tk = lex();
+}
+
+static void CPrep_StreamSkipToBrace() {}
+static void CPrep_StreamSkipBlock() {}
+void CPrep_StreamGetBlock() {}
+void CPrep_StreamGetSemicolon() {}
+void CPrep_StreamGetTemplate() {}
+void CPrep_StreamInsert() {}
+void CPrep_StreamRemove() {}
+void CPrep_RemoveTokens() {}
+void CPrep_TokenStreamFlush() {}
+static void CPrep_TokenSize() {}
+void CPrep_CurStreamElement() {}
+
+void CPrep_GetTokenContext(TStreamElement *token, CPrepFileInfo **tokenfile, SInt32 *selectionoffset, short *tokensize, SInt32 *linenumber, char *buf1, short *tokenoffset, short *tokenlength, char *buf2, short *lastarg) {
+}
+
+void CPrep_Error(short code) {
+    Boolean save = in_assembler;
+    in_assembler = 0;
+    if (code == 102 && (tokenstacklevel > 0 || pos < prep_file_end))
+        code = 105;
+    was_prep_error = 1;
+    CError_Error(code);
+    in_assembler = save;
+}
+
+void CPrep_ErrorName(short code, const char *name) {
+    Boolean save = in_assembler;
+    in_assembler = 0;
+    was_prep_error = 1;
+    if (code == 102 && (tokenstacklevel > 0 || pos < prep_file_end))
+        CError_Error(105, name);
+    else
+        CError_Error(code, name);
+    in_assembler = save;
+}
+
+void CPrep_Warning(short code) {
+    Boolean save = in_assembler;
+    in_assembler = 0;
+    was_prep_error = 1;
+    CError_Warning(code);
+    in_assembler = save;
+}
+
+void CPrep_WarningName(short code, const char *name) {
+    Boolean save = in_assembler;
+    in_assembler = 0;
+    was_prep_error = 1;
+    CError_Warning(code, name);
+    in_assembler = save;
+}
+
+void CPrep_ErrorMessage(int errTable, char *str, Boolean flag1, Boolean flag2) {
+    Boolean save = in_assembler;
+    in_assembler = 0;
+    was_prep_error = 1;
+    CError_ErrorMessage(errTable, str, flag1, flag2);
+    in_assembler = save;
+}
+
+void CPrep_ErrorMessageVA(int code, const char *format, va_list list, Boolean flag1, Boolean flag2) {
+    Boolean save = in_assembler;
+    in_assembler = 0;
+    was_prep_error = 1;
+    CError_ErrorMessageVA(code, format, list, flag1, flag2);
+    in_assembler = save;
+}
+
+void popfile() {
+    // r5 and r6 are swapped, not sure why
+    if (filesp >= 0) {
+        CWReleaseFileText(cparamblkptr->context, prep_file->textbuffer);
+        prep_file->textbuffer = NULL;
+        if (--filesp >= 0) {
+            prep_file = filestack[filesp];
+            prep_file_start = prep_file->textbuffer;
+            prep_file_end = prep_file->textbuffer + prep_file->textlength;
+            pos = prep_file_start + prep_file->pos;
+            linenumber = prep_file->linenumber;
+            cprep_hasprepline = prep_file->hasprepline;
+            at_linestart = 1;
+        }
+        if (preprocessing_only && !copts.simple_prepdump)
+            CPrep_PreprocessDumpFileInfo(1);
+    }
+}
+
+static void prepoffset() {}
+static void prepoffset2() {}
+void CPrep_SetSourceFile() {}
+void CPrep_GetSourceFilePath() {}
+void CPrep_NewFileOffsetInfo() {}
+void CPrep_GetFileOffsetInfo() {}
+void CPrep_GetFileOffsetInfo2() {}
+void CPrep_ResetFileInfo() {}
+void CPrep_GetPrepPos() {}
+Boolean C_Compiler(CParams *param) {}
+
+static void pushtokenseq(Macro *macro) {
+    if (tokenstacklevel >= 128) {
+        was_prep_error = 1;
+        CError_ErrorTerm(111);
+    } else {
+        tokenstack[tokenstacklevel].pos = pos;
+        tokenstack[tokenstacklevel].macrostart = macrostart;
+        tokenstack[tokenstacklevel].macro = macro;
+        if (macro)
+            macro->xF = 1;
+        tokenstack[tokenstacklevel].macrocheck = macrocheck;
+        tokenstacklevel++;
+    }
+}
+
+void poptokenseq() {
+    if (!--tokenstacklevel && dofreeaheap)
+        freeaheap();
+
+    pos = tokenstack[tokenstacklevel].pos;
+    macrostart = tokenstack[tokenstacklevel].macrostart;
+    if (tokenstack[tokenstacklevel].macro)
+        tokenstack[tokenstacklevel].macro->xF = 0;
+    macrocheck = tokenstack[tokenstacklevel].macrocheck;
+    spaceskip = 1;
+}
+
+static void is_nextchar() {}
+static void ismacroname() {}
+static void ismacroname2() {}
+static void ismacroname5() {}
+static void ismacroname3() {}
+static void ismacroname4() {}
+void foundnl() {}
+void newline() {}
+static void gotonexttoken() {}
+short notendofline() {}
+static void CPrep_MacroRedefError() {}
+static void goendofline() {}
+static void CPrep_Define() {}
+static void prepundefine() {}
+static Boolean CPrep_CheckTarget() {}
+static Boolean CPrep_CheckOption() {}
+static void CPrep_XpandDefinedCheck() {}
+static void XpandString() {}
+char *CPrep_GetFileName(char *buffer, Boolean flag1, Boolean flag2) {
+}
+
+static char *XpandSpecialMacro(Macro *macro) {
+    char buf[512];
+    char smallbuf[32];
+    char *strptr;
+    struct tm *tm;
+
+    if (macro == &optiM) {
+        return CPrep_CheckOption() ? "1" : "0";
+    } else if (macro == &trgtM) {
+        return CPrep_CheckTarget() ? "1" : "0";
+    } else if (macro == &lineM) {
+        sprintf(buf, "%ld", linenumber);
+    do_string:
+        strptr = aalloc(strlen(buf) + 1);
+        strcpy(strptr, buf);
+        return strptr;
+    } else if (macro == &fileM) {
+        CPrep_GetFileName(buf, 0, 1);
+        goto do_string;
+    } else if (macro == &dateM) {
+        tm = localtime(&now_time);
+        strftime(buf, 64, "\"%b ", tm);
+        strftime(smallbuf, 32, "%d", tm);
+        if (smallbuf[0] == '0')
+            smallbuf[0] = ' ';
+        strcat(buf, smallbuf);
+        strftime(smallbuf, 32, " %Y\"", tm);
+        strcat(buf, smallbuf);
+        goto do_string;
+    } else if (macro == &timeM) {
+        strftime(buf, 64, "\"%H:%M:%S\"", localtime(&now_time));
+        goto do_string;
+    } else if (macro == &stdcM) {
+        return "1";
+    } else if (macro == &casmM || macro == &MWRSM) {
+        return "0x2405";
+    } else if (macro == &cpplM) {
+        return "199711L";
+    } else if (macro == &dtsomM) {
+        return copts.direct_to_som ? "1" : "0";
+    } else if (macro == &ecppM) {
+        return copts.ecplusplus ? "1" : "0";
+    } else if (macro == &stcvM) {
+        return copts.c9x ? "199901L" : "199409L";
+    } else if (macro == &stchM) {
+        return "0";
+    } else {
+        return CodeGen_ExpandSpecialMacro(macro);
+    }
+}
+
+static void XpandMacro() {}
+static void prepmacro() {}
+void macrotest() {}
+void CPrep_PragmaLex() {}
+void CPrep_PushOption() {}
+void CPrep_PopOption() {}
+static void CPrep_PragmaImExport() {}
+static void pragma_on_off_reset() {}
+static void CPrep_PragmaOnceName() {}
+static void pragma_precompile_target() {}
+static void CPrep_DefinePragmaOnceMacro() {}
+static void CPrep_PragmaOnce() {}
+static void CPrep_PragmaUnused() {}
+static void CPrep_PragmaInlineDepth() {}
+static void CPrep_PragmaInlineMaxSize() {}
+static void CPrep_PragmaInlineMaxTotalSize() {}
+
+static void pragma_segment() {
+    short i;
+    short t;
+    char name[256];
+
+    if (notendofline()) {
+        for (i = 0; i < 255; i++) {
+            spaceskip = 0;
+            t = prepskipnextchar();
+            if (spaceskip)
+                break;
+            if (t <= ' ')
+                break;
+            name[i] = t;
+            pos = nextcharpos;
+        }
+        name[i] = 0;
+
+        if (!i || i >= 255)
+            CPrep_Warning(186);
+
+        copts.forcedSegment = GetHashNameNodeExport(name);
+        ObjGen_SegmentName();
+    } else {
+        if (copts.warn_illpragma)
+            CPrep_Warning(186);
+    }
+}
+
+static void pragma_options() {}
+
+static void pragma_push() {
+    struct COptsPush *push;
+
+    push = galloc(sizeof(struct COptsPush));
+    push->next = coptpushs;
+    coptpushs = push;
+
+    push->opts = copts;
+}
+
+static void pragma_pop() {
+    if (coptpushs) {
+        copts = coptpushs->opts;
+        coptpushs = coptpushs->next;
+        CMach_Configure();
+    } else {
+        CPrep_Error(237);
+    }
+}
+
+static void pragma_overload() {}
+static void pragma_optimization_level() {}
+static void pragma_opt_unroll_count() {}
+static void pragma_opt_unroll_instr_count() {}
+static void pragma_pack() {}
+static void pragma_comment() {}
+static void pragma_message() {}
+static void preppragma() {}
+static void prepinclude() {}
+static void prepline() {}
+static void CPrep_GetPrepType() {}
+static void CPrep_ParseUnary() {}
+static void CPrep_ParseBinary() {}
+static void CPrep_ParseCond() {}
+static void doevalconstexpr() {}
+static void pushifstate() {}
+static void popifstate() {}
+static void positiveif() {}
+static void negativeif() {}
+static void prepif() {}
+static void prepifdef() {}
+static void prepifndef() {}
+static void prepelif() {}
+static void prepelse() {}
+static void prependif() {}
+static void prepifskip() {}
+void preprocessor() {}
+void CPrep_BrowserTokenOffset() {}
+void CPrep_BrowserFileOffset() {}
+
+void CPrep_BrowserFilePosition(CPrepFileInfo **fileinfo, SInt32 *offset) {
+    CPrepFileInfo *file;
+
+    if (ts_first < ts_current) {
+        file = ts_current[-1].tokenfile;
+        *offset = ts_current[-1].tokenoffset + 1;
+    } else {
+        file = filestack[filesp];
+        if (tokenstacklevel) {
+            *offset = tokenstack[0].pos - filestack[filesp]->textbuffer;
+        } else {
+            *offset = pos - filestack[filesp]->textbuffer;
+        }
+    }
+
+    if (file && file->fileID > 0 && (file->recordbrowseinfo || gForceSourceLoc)) {
+        *fileinfo = file;
+    } else {
+        *fileinfo = NULL;
+        *offset = 0;
+    }
+}
+
+CPrepFileInfo *CPrep_BrowserCurrentFile() {
+    return prep_file;
+}