diff options
Diffstat (limited to 'compiler_and_linker/FrontEnd/C/CPrep.c')
| -rw-r--r-- | compiler_and_linker/FrontEnd/C/CPrep.c | 921 |
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 = ¯ohashtable[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; +} |