MWCC/compiler_and_linker/FrontEnd/C/CPrep.c

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