From a8d146dd4daf6c6ed671e6038c04dd53a5cff6f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Sun, 3 Jan 2016 04:53:42 +0000 Subject: [PATCH] missing_files --- H/heap/#hstruct.h# | 302 +++++++++++++++++++++++++++ H/heap/dglobals.h | 146 ++++++++++++++ H/heap/dlocals.h | 493 +++++++++++++++++++++++++++++++++++++++++++++ H/heap/h0globals.h | 146 ++++++++++++++ H/heap/h0struct.h | 303 ++++++++++++++++++++++++++++ H/heap/ihstruct.h | 303 ++++++++++++++++++++++++++++ H/heap/ilocals.h | 277 +++++++++++++++++++++++++ H/heap/rglobals.h | 146 ++++++++++++++ H/heap/rhstruct.h | 303 ++++++++++++++++++++++++++++ H/heap/rlocals.h | 277 +++++++++++++++++++++++++ 10 files changed, 2696 insertions(+) create mode 100755 H/heap/#hstruct.h# create mode 100644 H/heap/dglobals.h create mode 100644 H/heap/dlocals.h create mode 100644 H/heap/h0globals.h create mode 100644 H/heap/h0struct.h create mode 100644 H/heap/ihstruct.h create mode 100755 H/heap/ilocals.h create mode 100644 H/heap/rglobals.h create mode 100644 H/heap/rhstruct.h create mode 100644 H/heap/rlocals.h diff --git a/H/heap/#hstruct.h# b/H/heap/#hstruct.h# new file mode 100755 index 000000000..ad06cc11a --- /dev/null +++ b/H/heap/#hstruct.h# @@ -0,0 +1,302 @@ + + /* This file, hstruct.h, was generated automatically by "yap -L misc/buildlocalglobal" + please do not update, update misc/HEAPFIELDS instead */ + + + + + + + + + + + + + + + + + + + + + + + + + + +{ + + UInt Yap_HoleSize_; + struct malloc_state *Yap_av_; +#if USE_DL_MALLOC + struct Yap_MemoryHoles[MAX_DLMALLOC_HOLES] void_; + UInt Yap_NOfMemoryHoles_; +#if defined(YAPOR) || defined(THREADS) + lockvar DLMallocLock_; +#endif +#endif +#if USE_DL_MALLOC || (USE_SYSTEM_MALLOC && HAVE_MALLINFO) +#ifndef HeapUsed +#define HeapUsed Yap_givemallinfo() +#endif + Int NotHeapUsed_; +#else + Int HeapUsed_; +#endif + Int HeapMax_; + ADDR HeapTop_; + ADDR HeapLim_; + struct FREEB *FreeBlocks_; +#if defined(YAPOR) || defined(THREADS) + lockvar FreeBlocksLock_; + lockvar HeapUsedLock_; + lockvar HeapTopLock_; + int HeapTopOwner_; +#endif + UInt MaxStack_; + UInt MaxTrail_; + + +#if USE_THREADED_CODE + op_entry *OP_RTABLE_; +#endif + + OPCODE EXECUTE_CPRED_OP_CODE_; + OPCODE EXPAND_OP_CODE_; + OPCODE FAIL_OPCODE_; + OPCODE INDEX_OPCODE_; + OPCODE LOCKPRED_OPCODE_; + OPCODE ORLAST_OPCODE_; + OPCODE UNDEF_OPCODE_; + OPCODE RETRY_USERC_OPCODE_; + OPCODE EXECUTE_CPRED_OPCODE_; + + UInt NOfAtoms_; + UInt AtomHashTableSize_; + UInt WideAtomHashTableSize_; + UInt NOfWideAtoms_; + AtomHashEntry INVISIBLECHAIN_; + AtomHashEntry *WideHashChain_; + AtomHashEntry *HashChain_; + +#include "tatoms.h" +#ifdef EUROTRA + Term TermDollarU_; +#endif + + Term USER_MODULE_; + Term IDB_MODULE_; + Term ATTRIBUTES_MODULE_; + Term CHARSIO_MODULE_; + Term CHTYPE_MODULE_; + Term TERMS_MODULE_; + Term SYSTEM_MODULE_; + Term READUTIL_MODULE_; + Term HACKS_MODULE_; + Term ARG_MODULE_; + Term GLOBALS_MODULE_; + Term SWI_MODULE_; + Term DBLOAD_MODULE_; + Term RANGE_MODULE_; + Term ERROR_MODULE_; + + + + struct mod_entry *CurrentModules_; + + + + + Prop HIDDEN_PREDICATES_; + + + + union flagTerm* GLOBAL_Flags_; + UInt GLOBAL_flagCount_; + + yap_exec_mode Yap_ExecutionMode_; + + struct pred_entry **PredHash_; +#if defined(YAPOR) || defined(THREADS) + rwlock_t PredHashRWLock_; +#endif + UInt PredsInHashTable_; + UInt PredHashTableSize_; + + struct pred_entry *CreepCode_; + struct pred_entry *UndefCode_; + struct pred_entry *SpyCode_; + struct pred_entry *PredFail_; + struct pred_entry *PredTrue_; +#ifdef COROUTINING + struct pred_entry *WakeUpCode_; +#endif + struct pred_entry *PredGoalExpansion_; + struct pred_entry *PredMetaCall_; + struct pred_entry *PredTraceMetaCall_; + struct pred_entry *PredDollarCatch_; + struct pred_entry *PredRecordedWithKey_; + struct pred_entry *PredLogUpdClause_; + struct pred_entry *PredLogUpdClauseErase_; + struct pred_entry *PredLogUpdClause0_; + struct pred_entry *PredStaticClause_; + struct pred_entry *PredThrow_; + struct pred_entry *PredHandleThrow_; + struct pred_entry *PredIs_; + struct pred_entry *PredSafeCallCleanup_; + struct pred_entry *PredRestoreRegs_; + struct pred_entry *PredCommentHook_; +#ifdef YAPOR + struct pred_entry *PredGetwork_; + struct pred_entry *PredProcedure_; +#endif /* YAPOR */ + +#ifdef LOW_LEVEL_TRACER + int Yap_do_low_level_trace_; +#if defined(YAPOR) || defined(THREADS) + lockvar Yap_low_level_trace_lock_; +#endif +#endif + + UInt Yap_ClauseSpace_; + UInt Yap_IndexSpace_Tree_; + UInt Yap_IndexSpace_EXT_; + UInt Yap_IndexSpace_SW_; + UInt Yap_LUClauseSpace_; + UInt Yap_LUIndexSpace_Tree_; + UInt Yap_LUIndexSpace_CP_; + UInt Yap_LUIndexSpace_EXT_; + UInt Yap_LUIndexSpace_SW_; + + yamop COMMA_CODE_[5]; + yamop DUMMYCODE_[1]; + yamop FAILCODE_[1]; + yamop NOCODE_[1]; + yamop ENV_FOR_TRUSTFAIL_[2]; + yamop *TRUSTFAILCODE_; + yamop ENV_FOR_YESCODE_[2]; + yamop *YESCODE_; + yamop RTRYCODE_[1]; +#ifdef BEAM + yamop BEAM_RETRY_CODE_[1]; +#endif /* BEAM */ +#ifdef YAPOR + yamop GETWORK_[1]; + yamop GETWORK_SEQ_[1]; + yamop GETWORK_FIRST_TIME_[1]; +#endif /* YAPOR */ +#ifdef TABLING + yamop LOAD_ANSWER_[1]; + yamop TRY_ANSWER_[1]; + yamop ANSWER_RESOLUTION_[1]; + yamop COMPLETION_[1]; +#ifdef THREADS_CONSUMER_SHARING + yamop ANSWER_RESOLUTION_COMPLETION_[1]; +#endif /* THREADS_CONSUMER_SHARING */ +#endif /* TABLING */ + + + + + yamop *P_before_spy_; + + yamop *RETRY_C_RECORDEDP_CODE_; + yamop *RETRY_C_RECORDED_K_CODE_; + + int PROFILING_; + int CALL_COUNTING_; + int optimizer_on_; + int compile_mode_; + int profiling_; + int call_counting_; + + int compile_arrays_; + +#if defined(YAPOR) || defined(THREADS) + lockvar DBTermsListLock_; +#endif + struct dbterm_list *DBTermsList_; + + yamop *ExpandClausesFirst_; + yamop *ExpandClausesLast_; + UInt Yap_ExpandClauses_; +#if defined(YAPOR) || defined(THREADS) + lockvar ExpandClausesListLock_; + lockvar OpListLock_; +#endif + +#ifdef DEBUG + UInt Yap_NewCps_; + UInt Yap_LiveCps_; + UInt Yap_DirtyCps_; + UInt Yap_FreedCps_; +#endif + UInt Yap_expand_clauses_sz_; + + struct udi_info *UdiControlBlocks_; + + + Int STATIC_PREDICATES_MARKED_; + + Prop *INT_KEYS_; + Prop *INT_LU_KEYS_; + Prop *INT_BB_KEYS_; + + UInt INT_KEYS_SIZE_; + UInt INT_KEYS_TIMESTAMP_; + UInt INT_BB_KEYS_SIZE_; + + int UPDATE_MODE_; + + struct DB_STRUCT *DBErasedMarker_; + struct logic_upd_clause *LogDBErasedMarker_; + + struct static_clause *DeadStaticClauses_; + struct static_mega_clause *DeadMegaClauses_; + struct static_index *DeadStaticIndices_; + struct logic_upd_clause *DBErasedList_; + struct logic_upd_index *DBErasedIList_; +#if defined(YAPOR) || defined(THREADS) + lockvar DeadStaticClausesLock_; + lockvar DeadMegaClausesLock_; + lockvar DeadStaticIndicesLock_; +#endif +#ifdef COROUTINING + + int NUM_OF_ATTS_; + + UInt Yap_AttsSize_; +#endif + + struct operator_entry *OpList_; + + struct ForeignLoadItem *ForeignCodeLoaded_; + ADDR ForeignCodeBase_; + ADDR ForeignCodeTop_; + ADDR ForeignCodeMax_; + + struct record_list *Yap_Records_; + + Atom *SWI_Atoms_; + Functor *SWI_Functors_; + swi_rev_hash SWI_ReverseHash_[N_SWI_HASH]; + + Int AtomTranslations_; + Int MaxAtomTranslations_; + + Int FunctorTranslations_; + Int MaxFunctorTranslations_; + Atom EmptyWakeups_[MAX_EMPTY_WAKEUPS]; + int MaxEmptyWakeups_; + + struct YAP_blob_t *BlobTypes_; + struct AtomEntryStruct *Blobs_; + UInt NOfBlobs_; + UInt NOfBlobsMax_; +#if defined(YAPOR) || defined(THREADS) + lockvar Blobs_Lock_; +#endif +} diff --git a/H/heap/dglobals.h b/H/heap/dglobals.h new file mode 100644 index 000000000..1d787b765 --- /dev/null +++ b/H/heap/dglobals.h @@ -0,0 +1,146 @@ + + /* This file, dglobals.h, was generated automatically by "yap -L misc/buildlocalglobal" + please do not update, update misc/GLOBALS instead */ + + + + + + + + + + + + + + + + + + + +#define GLOBAL_Initialised Yap_global->Initialised_ +#define GLOBAL_InitialisedFromPL Yap_global->InitialisedFromPL_ +#define GLOBAL_PL_Argc Yap_global->PL_Argc_ +#define GLOBAL_PL_Argv Yap_global->PL_Argv_ +#define GLOBAL_FAST_BOOT_FLAG Yap_global->FAST_BOOT_FLAG_ + +#define GLOBAL_HaltHooks Yap_global->HaltHooks_ +#define GLOBAL_JIT_finalizer Yap_global->JIT_finalizer_ + +#define GLOBAL_AllowLocalExpansion Yap_global->AllowLocalExpansion_ +#define GLOBAL_AllowGlobalExpansion Yap_global->AllowGlobalExpansion_ +#define GLOBAL_AllowTrailExpansion Yap_global->AllowTrailExpansion_ +#define GLOBAL_SizeOfOverflow Yap_global->SizeOfOverflow_ + +#define GLOBAL_AGcThreshold Yap_global->AGcThreshold_ +#define GLOBAL_AGCHook Yap_global->AGCHook_ +#if __ANDROID__ + +#define GLOBAL_assetManager Yap_global->assetManager_ +#define GLOBAL_AssetsWD Yap_global->AssetsWD_ +#endif + +#if THREADS + +#define GLOBAL_NOfThreads Yap_global->NOfThreads_ + +#define GLOBAL_NOfThreadsCreated Yap_global->NOfThreadsCreated_ + +#define GLOBAL_ThreadsTotalTime Yap_global->ThreadsTotalTime_ + +#define GLOBAL_ThreadHandlesLock Yap_global->ThreadHandlesLock_ +#endif +#if defined(YAPOR) || defined(THREADS) + +#define GLOBAL_BGL Yap_global->BGL_ +#endif +#if defined(YAPOR) || defined(TABLING) +#define GLOBAL_optyap_data Yap_global->optyap_data_ +#endif /* YAPOR || TABLING */ + +#define GLOBAL_PrologShouldHandleInterrupts Yap_global->PrologShouldHandleInterrupts_ + +#if defined(THREADS) +#define GLOBAL_master_thread Yap_global->master_thread_ +#define GLOBAL_named_mboxes Yap_global->named_mboxes_ +#define GLOBAL_mboxq_lock Yap_global->mboxq_lock_ +#define GLOBAL_mbox_count Yap_global->mbox_count_ +#define GLOBAL_WithMutex Yap_global->WithMutex_ +#endif /* THREADS */ + +#define GLOBAL_Stream Yap_global->Stream_ +#if defined(THREADS)||defined(YAPOR) +#define GLOBAL_StreamDescLock Yap_global->StreamDescLock_ +#endif + +#define GLOBAL_argv Yap_global->argv_ +#define GLOBAL_argc Yap_global->argc_ + +#ifdef COROUTINING + +#define GLOBAL_attas Yap_global->attas_ +#endif + +#define GLOBAL_agc_calls Yap_global->agc_calls_ +#define GLOBAL_agc_collected Yap_global->agc_collected_ + +#define GLOBAL_tot_agc_time Yap_global->tot_agc_time_ + +#define GLOBAL_tot_agc_recovered Yap_global->tot_agc_recovered_ + +#if HAVE_MMAP +#define GLOBAL_mmap_arrays Yap_global->mmap_arrays_ +#endif +#ifdef DEBUG + +#define GLOBAL_Option Yap_global->Option_ +#define GLOBAL_logfile Yap_global->logfile_ + + +#endif +#if defined(COFF) || defined(A_OUT) + +#define GLOBAL_Executable Yap_global->Executable_ +#endif +#define GLOBAL_OpaqueHandlersCount Yap_global->OpaqueHandlersCount_ +#define GLOBAL_OpaqueHandlers Yap_global->OpaqueHandlers_ +#if __simplescalar__ +#define GLOBAL_pwd Yap_global->pwd_ +#endif + + +#define GLOBAL_RestoreFile Yap_global->RestoreFile_ + +#define GLOBAL_ProfCalls Yap_global->ProfCalls_ +#define GLOBAL_ProfGCs Yap_global->ProfGCs_ +#define GLOBAL_ProfHGrows Yap_global->ProfHGrows_ +#define GLOBAL_ProfSGrows Yap_global->ProfSGrows_ +#define GLOBAL_ProfMallocs Yap_global->ProfMallocs_ +#define GLOBAL_ProfIndexing Yap_global->ProfIndexing_ +#define GLOBAL_ProfOn Yap_global->ProfOn_ +#define GLOBAL_ProfOns Yap_global->ProfOns_ +#define GLOBAL_ProfilerRoot Yap_global->ProfilerRoot_ +#define GLOBAL_ProfilerNil Yap_global->ProfilerNil_ +#define GLOBAL_DIRNAME Yap_global->DIRNAME_ +#if LOW_PROF +#define GLOBAL_ProfilerOn Yap_global->ProfilerOn_ +#define GLOBAL_FProf Yap_global->FProf_ +#define GLOBAL_FPreds Yap_global->FPreds_ +#endif /* LOW_PROF */ + +#if THREADS +#define GLOBAL_FreeMutexes Yap_global->FreeMutexes_ +#define GLOBAL_mutex_backbone Yap_global->mutex_backbone_ +#define GLOBAL_MUT_ACCESS Yap_global->MUT_ACCESS_ +#endif +#define GLOBAL_Home Yap_global->Home_ + +#define GLOBAL_CharConversionTable Yap_global->CharConversionTable_ +#define GLOBAL_CharConversionTable2 Yap_global->CharConversionTable2_ + +#define GLOBAL_LastWTimePtr Yap_global->LastWTimePtr_ + +#define GLOBAL_MaxPriority Yap_global->MaxPriority_ + diff --git a/H/heap/dlocals.h b/H/heap/dlocals.h new file mode 100644 index 000000000..56e3e0da2 --- /dev/null +++ b/H/heap/dlocals.h @@ -0,0 +1,493 @@ + + /* This file, dlocals.h, was generated automatically by "yap -L misc/buildlocalglobal" + please do not update, update misc/LOCALS instead */ + + + + +#define LOCAL_FileAliases LOCAL->FileAliases_ +#define REMOTE_FileAliases(wid) REMOTE(wid)->FileAliases_ +#define LOCAL_NOfFileAliases LOCAL->NOfFileAliases_ +#define REMOTE_NOfFileAliases(wid) REMOTE(wid)->NOfFileAliases_ +#define LOCAL_SzOfFileAliases LOCAL->SzOfFileAliases_ +#define REMOTE_SzOfFileAliases(wid) REMOTE(wid)->SzOfFileAliases_ +#define LOCAL_c_input_stream LOCAL->c_input_stream_ +#define REMOTE_c_input_stream(wid) REMOTE(wid)->c_input_stream_ +#define LOCAL_c_output_stream LOCAL->c_output_stream_ +#define REMOTE_c_output_stream(wid) REMOTE(wid)->c_output_stream_ +#define LOCAL_c_error_stream LOCAL->c_error_stream_ +#define REMOTE_c_error_stream(wid) REMOTE(wid)->c_error_stream_ +#define LOCAL_sockets_io LOCAL->sockets_io_ +#define REMOTE_sockets_io(wid) REMOTE(wid)->sockets_io_ +#define LOCAL_within_print_message LOCAL->within_print_message_ +#define REMOTE_within_print_message(wid) REMOTE(wid)->within_print_message_ + + + + +#define LOCAL_newline LOCAL->newline_ +#define REMOTE_newline(wid) REMOTE(wid)->newline_ +#define LOCAL_AtPrompt LOCAL->AtPrompt_ +#define REMOTE_AtPrompt(wid) REMOTE(wid)->AtPrompt_ +#define LOCAL_Prompt LOCAL->Prompt_ +#define REMOTE_Prompt(wid) REMOTE(wid)->Prompt_ +#define LOCAL_encoding LOCAL->encoding_ +#define REMOTE_encoding(wid) REMOTE(wid)->encoding_ +#define LOCAL_quasi_quotations LOCAL->quasi_quotations_ +#define REMOTE_quasi_quotations(wid) REMOTE(wid)->quasi_quotations_ +#define LOCAL_default_priority LOCAL->default_priority_ +#define REMOTE_default_priority(wid) REMOTE(wid)->default_priority_ +#define LOCAL_eot_before_eof LOCAL->eot_before_eof_ +#define REMOTE_eot_before_eof(wid) REMOTE(wid)->eot_before_eof_ +#define LOCAL_max_depth LOCAL->max_depth_ +#define REMOTE_max_depth(wid) REMOTE(wid)->max_depth_ +#define LOCAL_max_list LOCAL->max_list_ +#define REMOTE_max_list(wid) REMOTE(wid)->max_list_ +#define LOCAL_max_write_args LOCAL->max_write_args_ +#define REMOTE_max_write_args(wid) REMOTE(wid)->max_write_args_ + +#define LOCAL_OldASP LOCAL->OldASP_ +#define REMOTE_OldASP(wid) REMOTE(wid)->OldASP_ +#define LOCAL_OldLCL0 LOCAL->OldLCL0_ +#define REMOTE_OldLCL0(wid) REMOTE(wid)->OldLCL0_ +#define LOCAL_OldTR LOCAL->OldTR_ +#define REMOTE_OldTR(wid) REMOTE(wid)->OldTR_ +#define LOCAL_OldGlobalBase LOCAL->OldGlobalBase_ +#define REMOTE_OldGlobalBase(wid) REMOTE(wid)->OldGlobalBase_ +#define LOCAL_OldH LOCAL->OldH_ +#define REMOTE_OldH(wid) REMOTE(wid)->OldH_ +#define LOCAL_OldH0 LOCAL->OldH0_ +#define REMOTE_OldH0(wid) REMOTE(wid)->OldH0_ +#define LOCAL_OldTrailBase LOCAL->OldTrailBase_ +#define REMOTE_OldTrailBase(wid) REMOTE(wid)->OldTrailBase_ +#define LOCAL_OldTrailTop LOCAL->OldTrailTop_ +#define REMOTE_OldTrailTop(wid) REMOTE(wid)->OldTrailTop_ +#define LOCAL_OldHeapBase LOCAL->OldHeapBase_ +#define REMOTE_OldHeapBase(wid) REMOTE(wid)->OldHeapBase_ +#define LOCAL_OldHeapTop LOCAL->OldHeapTop_ +#define REMOTE_OldHeapTop(wid) REMOTE(wid)->OldHeapTop_ +#define LOCAL_ClDiff LOCAL->ClDiff_ +#define REMOTE_ClDiff(wid) REMOTE(wid)->ClDiff_ +#define LOCAL_GDiff LOCAL->GDiff_ +#define REMOTE_GDiff(wid) REMOTE(wid)->GDiff_ +#define LOCAL_HDiff LOCAL->HDiff_ +#define REMOTE_HDiff(wid) REMOTE(wid)->HDiff_ +#define LOCAL_GDiff0 LOCAL->GDiff0_ +#define REMOTE_GDiff0(wid) REMOTE(wid)->GDiff0_ +#define LOCAL_GSplit LOCAL->GSplit_ +#define REMOTE_GSplit(wid) REMOTE(wid)->GSplit_ +#define LOCAL_LDiff LOCAL->LDiff_ +#define REMOTE_LDiff(wid) REMOTE(wid)->LDiff_ +#define LOCAL_TrDiff LOCAL->TrDiff_ +#define REMOTE_TrDiff(wid) REMOTE(wid)->TrDiff_ +#define LOCAL_XDiff LOCAL->XDiff_ +#define REMOTE_XDiff(wid) REMOTE(wid)->XDiff_ +#define LOCAL_DelayDiff LOCAL->DelayDiff_ +#define REMOTE_DelayDiff(wid) REMOTE(wid)->DelayDiff_ +#define LOCAL_BaseDiff LOCAL->BaseDiff_ +#define REMOTE_BaseDiff(wid) REMOTE(wid)->BaseDiff_ + +#define LOCAL_ReductionsCounter LOCAL->ReductionsCounter_ +#define REMOTE_ReductionsCounter(wid) REMOTE(wid)->ReductionsCounter_ +#define LOCAL_PredEntriesCounter LOCAL->PredEntriesCounter_ +#define REMOTE_PredEntriesCounter(wid) REMOTE(wid)->PredEntriesCounter_ +#define LOCAL_RetriesCounter LOCAL->RetriesCounter_ +#define REMOTE_RetriesCounter(wid) REMOTE(wid)->RetriesCounter_ +#define LOCAL_ReductionsCounterOn LOCAL->ReductionsCounterOn_ +#define REMOTE_ReductionsCounterOn(wid) REMOTE(wid)->ReductionsCounterOn_ +#define LOCAL_PredEntriesCounterOn LOCAL->PredEntriesCounterOn_ +#define REMOTE_PredEntriesCounterOn(wid) REMOTE(wid)->PredEntriesCounterOn_ +#define LOCAL_RetriesCounterOn LOCAL->RetriesCounterOn_ +#define REMOTE_RetriesCounterOn(wid) REMOTE(wid)->RetriesCounterOn_ + + +#define LOCAL_ConsultSp LOCAL->ConsultSp_ +#define REMOTE_ConsultSp(wid) REMOTE(wid)->ConsultSp_ + +#define LOCAL_ConsultCapacity LOCAL->ConsultCapacity_ +#define REMOTE_ConsultCapacity(wid) REMOTE(wid)->ConsultCapacity_ + +#define LOCAL_ConsultBase LOCAL->ConsultBase_ +#define REMOTE_ConsultBase(wid) REMOTE(wid)->ConsultBase_ + +#define LOCAL_ConsultLow LOCAL->ConsultLow_ +#define REMOTE_ConsultLow(wid) REMOTE(wid)->ConsultLow_ +#define LOCAL_VarNames LOCAL->VarNames_ +#define REMOTE_VarNames(wid) REMOTE(wid)->VarNames_ +#define LOCAL_SourceFileName LOCAL->SourceFileName_ +#define REMOTE_SourceFileName(wid) REMOTE(wid)->SourceFileName_ +#define LOCAL_SourceFileLineno LOCAL->SourceFileLineno_ +#define REMOTE_SourceFileLineno(wid) REMOTE(wid)->SourceFileLineno_ + +#define LOCAL_GlobalArena LOCAL->GlobalArena_ +#define REMOTE_GlobalArena(wid) REMOTE(wid)->GlobalArena_ +#define LOCAL_GlobalArenaOverflows LOCAL->GlobalArenaOverflows_ +#define REMOTE_GlobalArenaOverflows(wid) REMOTE(wid)->GlobalArenaOverflows_ +#define LOCAL_ArenaOverflows LOCAL->ArenaOverflows_ +#define REMOTE_ArenaOverflows(wid) REMOTE(wid)->ArenaOverflows_ +#define LOCAL_DepthArenas LOCAL->DepthArenas_ +#define REMOTE_DepthArenas(wid) REMOTE(wid)->DepthArenas_ +#define LOCAL_ArithError LOCAL->ArithError_ +#define REMOTE_ArithError(wid) REMOTE(wid)->ArithError_ +#define LOCAL_LastAssertedPred LOCAL->LastAssertedPred_ +#define REMOTE_LastAssertedPred(wid) REMOTE(wid)->LastAssertedPred_ +#define LOCAL_TmpPred LOCAL->TmpPred_ +#define REMOTE_TmpPred(wid) REMOTE(wid)->TmpPred_ +#define LOCAL_ScannerStack LOCAL->ScannerStack_ +#define REMOTE_ScannerStack(wid) REMOTE(wid)->ScannerStack_ +#define LOCAL_ScannerExtraBlocks LOCAL->ScannerExtraBlocks_ +#define REMOTE_ScannerExtraBlocks(wid) REMOTE(wid)->ScannerExtraBlocks_ +#define LOCAL_BallTerm LOCAL->BallTerm_ +#define REMOTE_BallTerm(wid) REMOTE(wid)->BallTerm_ +#define LOCAL_MaxActiveSignals LOCAL->MaxActiveSignals_ +#define REMOTE_MaxActiveSignals(wid) REMOTE(wid)->MaxActiveSignals_ +#define LOCAL_Signals LOCAL->Signals_ +#define REMOTE_Signals(wid) REMOTE(wid)->Signals_ +#define LOCAL_IPredArity LOCAL->IPredArity_ +#define REMOTE_IPredArity(wid) REMOTE(wid)->IPredArity_ +#define LOCAL_ProfEnd LOCAL->ProfEnd_ +#define REMOTE_ProfEnd(wid) REMOTE(wid)->ProfEnd_ +#define LOCAL_UncaughtThrow LOCAL->UncaughtThrow_ +#define REMOTE_UncaughtThrow(wid) REMOTE(wid)->UncaughtThrow_ +#define LOCAL_DoingUndefp LOCAL->DoingUndefp_ +#define REMOTE_DoingUndefp(wid) REMOTE(wid)->DoingUndefp_ +#define LOCAL_StartCharCount LOCAL->StartCharCount_ +#define REMOTE_StartCharCount(wid) REMOTE(wid)->StartCharCount_ +#define LOCAL_StartLineCount LOCAL->StartLineCount_ +#define REMOTE_StartLineCount(wid) REMOTE(wid)->StartLineCount_ +#define LOCAL_StartLinePos LOCAL->StartLinePos_ +#define REMOTE_StartLinePos(wid) REMOTE(wid)->StartLinePos_ +#define LOCAL_ScratchPad LOCAL->ScratchPad_ +#define REMOTE_ScratchPad(wid) REMOTE(wid)->ScratchPad_ +#ifdef COROUTINING +#define LOCAL_WokenGoals LOCAL->WokenGoals_ +#define REMOTE_WokenGoals(wid) REMOTE(wid)->WokenGoals_ +#define LOCAL_AttsMutableList LOCAL->AttsMutableList_ +#define REMOTE_AttsMutableList(wid) REMOTE(wid)->AttsMutableList_ +#endif + +#define LOCAL_GcGeneration LOCAL->GcGeneration_ +#define REMOTE_GcGeneration(wid) REMOTE(wid)->GcGeneration_ +#define LOCAL_GcPhase LOCAL->GcPhase_ +#define REMOTE_GcPhase(wid) REMOTE(wid)->GcPhase_ +#define LOCAL_GcCurrentPhase LOCAL->GcCurrentPhase_ +#define REMOTE_GcCurrentPhase(wid) REMOTE(wid)->GcCurrentPhase_ +#define LOCAL_GcCalls LOCAL->GcCalls_ +#define REMOTE_GcCalls(wid) REMOTE(wid)->GcCalls_ +#define LOCAL_TotGcTime LOCAL->TotGcTime_ +#define REMOTE_TotGcTime(wid) REMOTE(wid)->TotGcTime_ +#define LOCAL_TotGcRecovered LOCAL->TotGcRecovered_ +#define REMOTE_TotGcRecovered(wid) REMOTE(wid)->TotGcRecovered_ +#define LOCAL_LastGcTime LOCAL->LastGcTime_ +#define REMOTE_LastGcTime(wid) REMOTE(wid)->LastGcTime_ +#define LOCAL_LastSSTime LOCAL->LastSSTime_ +#define REMOTE_LastSSTime(wid) REMOTE(wid)->LastSSTime_ +#define LOCAL_OpenArray LOCAL->OpenArray_ +#define REMOTE_OpenArray(wid) REMOTE(wid)->OpenArray_ + +#define LOCAL_total_marked LOCAL->total_marked_ +#define REMOTE_total_marked(wid) REMOTE(wid)->total_marked_ +#define LOCAL_total_oldies LOCAL->total_oldies_ +#define REMOTE_total_oldies(wid) REMOTE(wid)->total_oldies_ +#define LOCAL_current_B LOCAL->current_B_ +#define REMOTE_current_B(wid) REMOTE(wid)->current_B_ +#define LOCAL_prev_HB LOCAL->prev_HB_ +#define REMOTE_prev_HB(wid) REMOTE(wid)->prev_HB_ +#define LOCAL_HGEN LOCAL->HGEN_ +#define REMOTE_HGEN(wid) REMOTE(wid)->HGEN_ +#define LOCAL_iptop LOCAL->iptop_ +#define REMOTE_iptop(wid) REMOTE(wid)->iptop_ +#if defined(GC_NO_TAGS) +#define LOCAL_bp LOCAL->bp_ +#define REMOTE_bp(wid) REMOTE(wid)->bp_ +#endif +#define LOCAL_sTR LOCAL->sTR_ +#define REMOTE_sTR(wid) REMOTE(wid)->sTR_ +#define LOCAL_sTR0 LOCAL->sTR0_ +#define REMOTE_sTR0(wid) REMOTE(wid)->sTR0_ +#define LOCAL_new_TR LOCAL->new_TR_ +#define REMOTE_new_TR(wid) REMOTE(wid)->new_TR_ +#define LOCAL_cont_top0 LOCAL->cont_top0_ +#define REMOTE_cont_top0(wid) REMOTE(wid)->cont_top0_ +#define LOCAL_cont_top LOCAL->cont_top_ +#define REMOTE_cont_top(wid) REMOTE(wid)->cont_top_ +#define LOCAL_discard_trail_entries LOCAL->discard_trail_entries_ +#define REMOTE_discard_trail_entries(wid) REMOTE(wid)->discard_trail_entries_ +#define LOCAL_gc_ma_hash_table LOCAL->gc_ma_hash_table_ +#define REMOTE_gc_ma_hash_table(wid) REMOTE(wid)->gc_ma_hash_table_ +#define LOCAL_gc_ma_h_top LOCAL->gc_ma_h_top_ +#define REMOTE_gc_ma_h_top(wid) REMOTE(wid)->gc_ma_h_top_ +#define LOCAL_gc_ma_h_list LOCAL->gc_ma_h_list_ +#define REMOTE_gc_ma_h_list(wid) REMOTE(wid)->gc_ma_h_list_ +#define LOCAL_gc_timestamp LOCAL->gc_timestamp_ +#define REMOTE_gc_timestamp(wid) REMOTE(wid)->gc_timestamp_ +#define LOCAL_db_vec LOCAL->db_vec_ +#define REMOTE_db_vec(wid) REMOTE(wid)->db_vec_ +#define LOCAL_db_vec0 LOCAL->db_vec0_ +#define REMOTE_db_vec0(wid) REMOTE(wid)->db_vec0_ +#define LOCAL_db_root LOCAL->db_root_ +#define REMOTE_db_root(wid) REMOTE(wid)->db_root_ +#define LOCAL_db_nil LOCAL->db_nil_ +#define REMOTE_db_nil(wid) REMOTE(wid)->db_nil_ +#define LOCAL_gc_restore LOCAL->gc_restore_ +#define REMOTE_gc_restore(wid) REMOTE(wid)->gc_restore_ +#define LOCAL_extra_gc_cells LOCAL->extra_gc_cells_ +#define REMOTE_extra_gc_cells(wid) REMOTE(wid)->extra_gc_cells_ +#define LOCAL_extra_gc_cells_base LOCAL->extra_gc_cells_base_ +#define REMOTE_extra_gc_cells_base(wid) REMOTE(wid)->extra_gc_cells_base_ +#define LOCAL_extra_gc_cells_top LOCAL->extra_gc_cells_top_ +#define REMOTE_extra_gc_cells_top(wid) REMOTE(wid)->extra_gc_cells_top_ +#define LOCAL_extra_gc_cells_size LOCAL->extra_gc_cells_size_ +#define REMOTE_extra_gc_cells_size(wid) REMOTE(wid)->extra_gc_cells_size_ +#define LOCAL_DynamicArrays LOCAL->DynamicArrays_ +#define REMOTE_DynamicArrays(wid) REMOTE(wid)->DynamicArrays_ +#define LOCAL_StaticArrays LOCAL->StaticArrays_ +#define REMOTE_StaticArrays(wid) REMOTE(wid)->StaticArrays_ +#define LOCAL_GlobalVariables LOCAL->GlobalVariables_ +#define REMOTE_GlobalVariables(wid) REMOTE(wid)->GlobalVariables_ +#define LOCAL_AllowRestart LOCAL->AllowRestart_ +#define REMOTE_AllowRestart(wid) REMOTE(wid)->AllowRestart_ + +#define LOCAL_CMemFirstBlock LOCAL->CMemFirstBlock_ +#define REMOTE_CMemFirstBlock(wid) REMOTE(wid)->CMemFirstBlock_ +#define LOCAL_CMemFirstBlockSz LOCAL->CMemFirstBlockSz_ +#define REMOTE_CMemFirstBlockSz(wid) REMOTE(wid)->CMemFirstBlockSz_ + +#define LOCAL_nperm LOCAL->nperm_ +#define REMOTE_nperm(wid) REMOTE(wid)->nperm_ + +#define LOCAL_LabelFirstArray LOCAL->LabelFirstArray_ +#define REMOTE_LabelFirstArray(wid) REMOTE(wid)->LabelFirstArray_ +#define LOCAL_LabelFirstArraySz LOCAL->LabelFirstArraySz_ +#define REMOTE_LabelFirstArraySz(wid) REMOTE(wid)->LabelFirstArraySz_ + + +#ifdef THREADS +#define LOCAL_ThreadHandle LOCAL->ThreadHandle_ +#define REMOTE_ThreadHandle(wid) REMOTE(wid)->ThreadHandle_ +#endif /* THREADS */ +#if defined(YAPOR) || defined(TABLING) +#define LOCAL_optyap_data LOCAL->optyap_data_ +#define REMOTE_optyap_data(wid) REMOTE(wid)->optyap_data_ +#define LOCAL_TabMode LOCAL->TabMode_ +#define REMOTE_TabMode(wid) REMOTE(wid)->TabMode_ +#endif /* YAPOR || TABLING */ +#define LOCAL_InterruptsDisabled LOCAL->InterruptsDisabled_ +#define REMOTE_InterruptsDisabled(wid) REMOTE(wid)->InterruptsDisabled_ +#define LOCAL_execution LOCAL->execution_ +#define REMOTE_execution(wid) REMOTE(wid)->execution_ +#if LOW_LEVEL_TRACER +#define LOCAL_total_choicepoints LOCAL->total_choicepoints_ +#define REMOTE_total_choicepoints(wid) REMOTE(wid)->total_choicepoints_ +#endif +#define LOCAL_consult_level LOCAL->consult_level_ +#define REMOTE_consult_level(wid) REMOTE(wid)->consult_level_ + +#define LOCAL_LocalBase LOCAL->LocalBase_ +#define REMOTE_LocalBase(wid) REMOTE(wid)->LocalBase_ +#define LOCAL_GlobalBase LOCAL->GlobalBase_ +#define REMOTE_GlobalBase(wid) REMOTE(wid)->GlobalBase_ +#define LOCAL_TrailBase LOCAL->TrailBase_ +#define REMOTE_TrailBase(wid) REMOTE(wid)->TrailBase_ +#define LOCAL_TrailTop LOCAL->TrailTop_ +#define REMOTE_TrailTop(wid) REMOTE(wid)->TrailTop_ +#define LOCAL_ErrorMessage LOCAL->ErrorMessage_ +#define REMOTE_ErrorMessage(wid) REMOTE(wid)->ErrorMessage_ +#define LOCAL_Error_Term LOCAL->Error_Term_ +#define REMOTE_Error_Term(wid) REMOTE(wid)->Error_Term_ +#define LOCAL_Error_TYPE LOCAL->Error_TYPE_ +#define REMOTE_Error_TYPE(wid) REMOTE(wid)->Error_TYPE_ +#define LOCAL_Error_File LOCAL->Error_File_ +#define REMOTE_Error_File(wid) REMOTE(wid)->Error_File_ +#define LOCAL_Error_Function LOCAL->Error_Function_ +#define REMOTE_Error_Function(wid) REMOTE(wid)->Error_Function_ +#define LOCAL_Error_Lineno LOCAL->Error_Lineno_ +#define REMOTE_Error_Lineno(wid) REMOTE(wid)->Error_Lineno_ +#define LOCAL_Error_Size LOCAL->Error_Size_ +#define REMOTE_Error_Size(wid) REMOTE(wid)->Error_Size_ +#define LOCAL_ErrorSay LOCAL->ErrorSay_ +#define REMOTE_ErrorSay(wid) REMOTE(wid)->ErrorSay_ +#define LOCAL_IOBotch LOCAL->IOBotch_ +#define REMOTE_IOBotch(wid) REMOTE(wid)->IOBotch_ +#define LOCAL_tokptr LOCAL->tokptr_ +#define REMOTE_tokptr(wid) REMOTE(wid)->tokptr_ +#define LOCAL_toktide LOCAL->toktide_ +#define REMOTE_toktide(wid) REMOTE(wid)->toktide_ +#define LOCAL_VarTable LOCAL->VarTable_ +#define REMOTE_VarTable(wid) REMOTE(wid)->VarTable_ +#define LOCAL_AnonVarTable LOCAL->AnonVarTable_ +#define REMOTE_AnonVarTable(wid) REMOTE(wid)->AnonVarTable_ +#define LOCAL_Comments LOCAL->Comments_ +#define REMOTE_Comments(wid) REMOTE(wid)->Comments_ +#define LOCAL_CommentsTail LOCAL->CommentsTail_ +#define REMOTE_CommentsTail(wid) REMOTE(wid)->CommentsTail_ +#define LOCAL_CommentsNextChar LOCAL->CommentsNextChar_ +#define REMOTE_CommentsNextChar(wid) REMOTE(wid)->CommentsNextChar_ +#define LOCAL_CommentsBuff LOCAL->CommentsBuff_ +#define REMOTE_CommentsBuff(wid) REMOTE(wid)->CommentsBuff_ +#define LOCAL_CommentsBuffPos LOCAL->CommentsBuffPos_ +#define REMOTE_CommentsBuffPos(wid) REMOTE(wid)->CommentsBuffPos_ +#define LOCAL_CommentsBuffLim LOCAL->CommentsBuffLim_ +#define REMOTE_CommentsBuffLim(wid) REMOTE(wid)->CommentsBuffLim_ +#define LOCAL_RestartEnv LOCAL->RestartEnv_ +#define REMOTE_RestartEnv(wid) REMOTE(wid)->RestartEnv_ +#define LOCAL_FileNameBuf LOCAL->FileNameBuf_ +#define REMOTE_FileNameBuf(wid) REMOTE(wid)->FileNameBuf_ +#define LOCAL_FileNameBuf2 LOCAL->FileNameBuf2_ +#define REMOTE_FileNameBuf2(wid) REMOTE(wid)->FileNameBuf2_ + +#define LOCAL_BreakLevel LOCAL->BreakLevel_ +#define REMOTE_BreakLevel(wid) REMOTE(wid)->BreakLevel_ +#define LOCAL_PrologMode LOCAL->PrologMode_ +#define REMOTE_PrologMode(wid) REMOTE(wid)->PrologMode_ +#define LOCAL_CritLocks LOCAL->CritLocks_ +#define REMOTE_CritLocks(wid) REMOTE(wid)->CritLocks_ + +#define LOCAL_Flags LOCAL->Flags_ +#define REMOTE_Flags(wid) REMOTE(wid)->Flags_ +#define LOCAL_flagCount LOCAL->flagCount_ +#define REMOTE_flagCount(wid) REMOTE(wid)->flagCount_ + + +#ifdef ANALYST +#define LOCAL_opcount LOCAL->opcount_ +#define REMOTE_opcount(wid) REMOTE(wid)->opcount_ +#define LOCAL_2opcount LOCAL->2opcount_ +#define REMOTE_2opcount(wid) REMOTE(wid)->2opcount_ +#endif /* ANALYST */ + +#define LOCAL_s_dbg LOCAL->s_dbg_ +#define REMOTE_s_dbg(wid) REMOTE(wid)->s_dbg_ + +#define LOCAL_matherror LOCAL->matherror_ +#define REMOTE_matherror(wid) REMOTE(wid)->matherror_ +#define LOCAL_mathtt LOCAL->mathtt_ +#define REMOTE_mathtt(wid) REMOTE(wid)->mathtt_ +#define LOCAL_mathstring LOCAL->mathstring_ +#define REMOTE_mathstring(wid) REMOTE(wid)->mathstring_ +#define LOCAL_CurrentError LOCAL->CurrentError_ +#define REMOTE_CurrentError(wid) REMOTE(wid)->CurrentError_ + +#define LOCAL_heap_overflows LOCAL->heap_overflows_ +#define REMOTE_heap_overflows(wid) REMOTE(wid)->heap_overflows_ +#define LOCAL_total_heap_overflow_time LOCAL->total_heap_overflow_time_ +#define REMOTE_total_heap_overflow_time(wid) REMOTE(wid)->total_heap_overflow_time_ +#define LOCAL_stack_overflows LOCAL->stack_overflows_ +#define REMOTE_stack_overflows(wid) REMOTE(wid)->stack_overflows_ +#define LOCAL_total_stack_overflow_time LOCAL->total_stack_overflow_time_ +#define REMOTE_total_stack_overflow_time(wid) REMOTE(wid)->total_stack_overflow_time_ +#define LOCAL_delay_overflows LOCAL->delay_overflows_ +#define REMOTE_delay_overflows(wid) REMOTE(wid)->delay_overflows_ +#define LOCAL_total_delay_overflow_time LOCAL->total_delay_overflow_time_ +#define REMOTE_total_delay_overflow_time(wid) REMOTE(wid)->total_delay_overflow_time_ +#define LOCAL_trail_overflows LOCAL->trail_overflows_ +#define REMOTE_trail_overflows(wid) REMOTE(wid)->trail_overflows_ +#define LOCAL_total_trail_overflow_time LOCAL->total_trail_overflow_time_ +#define REMOTE_total_trail_overflow_time(wid) REMOTE(wid)->total_trail_overflow_time_ +#define LOCAL_atom_table_overflows LOCAL->atom_table_overflows_ +#define REMOTE_atom_table_overflows(wid) REMOTE(wid)->atom_table_overflows_ +#define LOCAL_total_atom_table_overflow_time LOCAL->total_atom_table_overflow_time_ +#define REMOTE_total_atom_table_overflow_time(wid) REMOTE(wid)->total_atom_table_overflow_time_ + +#ifdef LOAD_DYLD +#define LOCAL_dl_errno LOCAL->dl_errno_ +#define REMOTE_dl_errno(wid) REMOTE(wid)->dl_errno_ +#endif + +#ifdef LOW_LEVEL_TRACER +#define LOCAL_do_trace_primitives LOCAL->do_trace_primitives_ +#define REMOTE_do_trace_primitives(wid) REMOTE(wid)->do_trace_primitives_ +#endif + +#define LOCAL_ExportAtomHashChain LOCAL->ExportAtomHashChain_ +#define REMOTE_ExportAtomHashChain(wid) REMOTE(wid)->ExportAtomHashChain_ +#define LOCAL_ExportAtomHashTableSize LOCAL->ExportAtomHashTableSize_ +#define REMOTE_ExportAtomHashTableSize(wid) REMOTE(wid)->ExportAtomHashTableSize_ +#define LOCAL_ExportAtomHashTableNum LOCAL->ExportAtomHashTableNum_ +#define REMOTE_ExportAtomHashTableNum(wid) REMOTE(wid)->ExportAtomHashTableNum_ +#define LOCAL_ExportFunctorHashChain LOCAL->ExportFunctorHashChain_ +#define REMOTE_ExportFunctorHashChain(wid) REMOTE(wid)->ExportFunctorHashChain_ +#define LOCAL_ExportFunctorHashTableSize LOCAL->ExportFunctorHashTableSize_ +#define REMOTE_ExportFunctorHashTableSize(wid) REMOTE(wid)->ExportFunctorHashTableSize_ +#define LOCAL_ExportFunctorHashTableNum LOCAL->ExportFunctorHashTableNum_ +#define REMOTE_ExportFunctorHashTableNum(wid) REMOTE(wid)->ExportFunctorHashTableNum_ +#define LOCAL_ExportPredEntryHashChain LOCAL->ExportPredEntryHashChain_ +#define REMOTE_ExportPredEntryHashChain(wid) REMOTE(wid)->ExportPredEntryHashChain_ +#define LOCAL_ExportPredEntryHashTableSize LOCAL->ExportPredEntryHashTableSize_ +#define REMOTE_ExportPredEntryHashTableSize(wid) REMOTE(wid)->ExportPredEntryHashTableSize_ +#define LOCAL_ExportPredEntryHashTableNum LOCAL->ExportPredEntryHashTableNum_ +#define REMOTE_ExportPredEntryHashTableNum(wid) REMOTE(wid)->ExportPredEntryHashTableNum_ +#define LOCAL_ExportDBRefHashChain LOCAL->ExportDBRefHashChain_ +#define REMOTE_ExportDBRefHashChain(wid) REMOTE(wid)->ExportDBRefHashChain_ +#define LOCAL_ExportDBRefHashTableSize LOCAL->ExportDBRefHashTableSize_ +#define REMOTE_ExportDBRefHashTableSize(wid) REMOTE(wid)->ExportDBRefHashTableSize_ +#define LOCAL_ExportDBRefHashTableNum LOCAL->ExportDBRefHashTableNum_ +#define REMOTE_ExportDBRefHashTableNum(wid) REMOTE(wid)->ExportDBRefHashTableNum_ +#define LOCAL_ImportAtomHashChain LOCAL->ImportAtomHashChain_ +#define REMOTE_ImportAtomHashChain(wid) REMOTE(wid)->ImportAtomHashChain_ +#define LOCAL_ImportAtomHashTableSize LOCAL->ImportAtomHashTableSize_ +#define REMOTE_ImportAtomHashTableSize(wid) REMOTE(wid)->ImportAtomHashTableSize_ +#define LOCAL_ImportAtomHashTableNum LOCAL->ImportAtomHashTableNum_ +#define REMOTE_ImportAtomHashTableNum(wid) REMOTE(wid)->ImportAtomHashTableNum_ +#define LOCAL_ImportFunctorHashChain LOCAL->ImportFunctorHashChain_ +#define REMOTE_ImportFunctorHashChain(wid) REMOTE(wid)->ImportFunctorHashChain_ +#define LOCAL_ImportFunctorHashTableSize LOCAL->ImportFunctorHashTableSize_ +#define REMOTE_ImportFunctorHashTableSize(wid) REMOTE(wid)->ImportFunctorHashTableSize_ +#define LOCAL_ImportFunctorHashTableNum LOCAL->ImportFunctorHashTableNum_ +#define REMOTE_ImportFunctorHashTableNum(wid) REMOTE(wid)->ImportFunctorHashTableNum_ +#define LOCAL_ImportOPCODEHashChain LOCAL->ImportOPCODEHashChain_ +#define REMOTE_ImportOPCODEHashChain(wid) REMOTE(wid)->ImportOPCODEHashChain_ +#define LOCAL_ImportOPCODEHashTableSize LOCAL->ImportOPCODEHashTableSize_ +#define REMOTE_ImportOPCODEHashTableSize(wid) REMOTE(wid)->ImportOPCODEHashTableSize_ +#define LOCAL_ImportPredEntryHashChain LOCAL->ImportPredEntryHashChain_ +#define REMOTE_ImportPredEntryHashChain(wid) REMOTE(wid)->ImportPredEntryHashChain_ +#define LOCAL_ImportPredEntryHashTableSize LOCAL->ImportPredEntryHashTableSize_ +#define REMOTE_ImportPredEntryHashTableSize(wid) REMOTE(wid)->ImportPredEntryHashTableSize_ +#define LOCAL_ImportPredEntryHashTableNum LOCAL->ImportPredEntryHashTableNum_ +#define REMOTE_ImportPredEntryHashTableNum(wid) REMOTE(wid)->ImportPredEntryHashTableNum_ +#define LOCAL_ImportDBRefHashChain LOCAL->ImportDBRefHashChain_ +#define REMOTE_ImportDBRefHashChain(wid) REMOTE(wid)->ImportDBRefHashChain_ +#define LOCAL_ImportDBRefHashTableSize LOCAL->ImportDBRefHashTableSize_ +#define REMOTE_ImportDBRefHashTableSize(wid) REMOTE(wid)->ImportDBRefHashTableSize_ +#define LOCAL_ImportDBRefHashTableNum LOCAL->ImportDBRefHashTableNum_ +#define REMOTE_ImportDBRefHashTableNum(wid) REMOTE(wid)->ImportDBRefHashTableNum_ +#define LOCAL_ImportFAILCODE LOCAL->ImportFAILCODE_ +#define REMOTE_ImportFAILCODE(wid) REMOTE(wid)->ImportFAILCODE_ +#if __ANDROID__ + +#define LOCAL_assetManager LOCAL->assetManager_ +#define REMOTE_assetManager(wid) REMOTE(wid)->assetManager_ +#define LOCAL_InAssetDir LOCAL->InAssetDir_ +#define REMOTE_InAssetDir(wid) REMOTE(wid)->InAssetDir_ +#endif + +#define LOCAL_ibnds LOCAL->ibnds_ +#define REMOTE_ibnds(wid) REMOTE(wid)->ibnds_ +#define LOCAL_exo_it LOCAL->exo_it_ +#define REMOTE_exo_it(wid) REMOTE(wid)->exo_it_ +#define LOCAL_exo_base LOCAL->exo_base_ +#define REMOTE_exo_base(wid) REMOTE(wid)->exo_base_ +#define LOCAL_exo_arity LOCAL->exo_arity_ +#define REMOTE_exo_arity(wid) REMOTE(wid)->exo_arity_ +#define LOCAL_exo_arg LOCAL->exo_arg_ +#define REMOTE_exo_arg(wid) REMOTE(wid)->exo_arg_ + +#define LOCAL_search_atoms LOCAL->search_atoms_ +#define REMOTE_search_atoms(wid) REMOTE(wid)->search_atoms_ + +#define LOCAL_CurSlot LOCAL->CurSlot_ +#define REMOTE_CurSlot(wid) REMOTE(wid)->CurSlot_ +#define LOCAL_NSlots LOCAL->NSlots_ +#define REMOTE_NSlots(wid) REMOTE(wid)->NSlots_ +#define LOCAL_SlotBase LOCAL->SlotBase_ +#define REMOTE_SlotBase(wid) REMOTE(wid)->SlotBase_ + +#define LOCAL_Mutexes LOCAL->Mutexes_ +#define REMOTE_Mutexes(wid) REMOTE(wid)->Mutexes_ +#define LOCAL_SourceModule LOCAL->SourceModule_ +#define REMOTE_SourceModule(wid) REMOTE(wid)->SourceModule_ +#define LOCAL_Including LOCAL->Including_ +#define REMOTE_Including(wid) REMOTE(wid)->Including_ +#define LOCAL_MAX_SIZE LOCAL->MAX_SIZE_ +#define REMOTE_MAX_SIZE(wid) REMOTE(wid)->MAX_SIZE_ + diff --git a/H/heap/h0globals.h b/H/heap/h0globals.h new file mode 100644 index 000000000..59c00abb9 --- /dev/null +++ b/H/heap/h0globals.h @@ -0,0 +1,146 @@ + + /* This file, hglobals.h, was generated automatically by "yap -L misc/buildlocalglobal" + please do not update, update misc/GLOBALS instead */ + +// +// File defining fields in the Yap_GLOBAL global structure +// +// these fields used to spread all over the place, because they must be used in 3 ways: +// - they must be defined somewhere +// - they have an #ifdef to get a shorter name +// - they must be initialised somewhere +// - they may be of interest to restore +// +// The defs include 3+ components: +// Type +// name in structured / global name +// init code (optional) +// restore code (optional) +// +// Stuff that must be shared by all threads or workers + +// initialization: tell whether the system has been initialised and by whom. +EXTERNAL int GLOBAL_Initialised; +EXTERNAL int GLOBAL_InitialisedFromPL; +EXTERNAL int GLOBAL_PL_Argc; +EXTERNAL char** GLOBAL_PL_Argv; +EXTERNAL bool GLOBAL_FAST_BOOT_FLAG; +// halt hooks +EXTERNAL struct halt_hook* GLOBAL_HaltHooks; +EXTERNAL fptr_t GLOBAL_JIT_finalizer; +// stack overflow expansion/gc control +EXTERNAL int GLOBAL_AllowLocalExpansion; +EXTERNAL int GLOBAL_AllowGlobalExpansion; +EXTERNAL int GLOBAL_AllowTrailExpansion; +EXTERNAL UInt GLOBAL_SizeOfOverflow; +// amount of space recovered in all garbage collections +EXTERNAL UInt GLOBAL_AGcThreshold; +EXTERNAL Agc_hook GLOBAL_AGCHook; +#if __ANDROID__ +// no need to perform initialization, it is done before we start the Prolog engine. +EXTERNAL struct AAssetManager* GLOBAL_assetManager; +EXTERNAL char* GLOBAL_AssetsWD; +#endif +/* multi-thread support */ +#if THREADS +/* number of threads and processes in system */ +EXTERNAL UInt GLOBAL_NOfThreads; +/* number of threads created since start */ +EXTERNAL UInt GLOBAL_NOfThreadsCreated; +/* total run time for dead threads */ +EXTERNAL UInt GLOBAL_ThreadsTotalTime; +// Threads Array +EXTERNAL lockvar GLOBAL_ThreadHandlesLock; +#endif +#if defined(YAPOR) || defined(THREADS) +// protect long critical regions +EXTERNAL lockvar GLOBAL_BGL; +#endif +#if defined(YAPOR) || defined(TABLING) +EXTERNAL struct global_optyap_data GLOBAL_optyap_data; +#endif /* YAPOR || TABLING */ +// whether Yap is responsible for signal handling +EXTERNAL int GLOBAL_PrologShouldHandleInterrupts; +/* This is the guy who actually started the system, and who has the correct registers */ +#if defined(THREADS) +EXTERNAL pthread_t GLOBAL_master_thread; +EXTERNAL struct thread_mbox* GLOBAL_named_mboxes; +EXTERNAL lockvar GLOBAL_mboxq_lock; +EXTERNAL UInt GLOBAL_mbox_count; +EXTERNAL struct swi_mutex* GLOBAL_WithMutex; +#endif /* THREADS */ +// streams +EXTERNAL struct stream_desc* GLOBAL_Stream; +#if defined(THREADS)||defined(YAPOR) +EXTERNAL lockvar GLOBAL_StreamDescLock; +#endif +// access to yap initial arguments +EXTERNAL char** GLOBAL_argv; +EXTERNAL int GLOBAL_argc; +// extensions to Terms +#ifdef COROUTINING +/* array with the ops for your favourite extensions */ +EXTERNAL ext_op GLOBAL_attas[attvars_ext+1]; +#endif +// agc.c +EXTERNAL int GLOBAL_agc_calls; +EXTERNAL YAP_ULONG_LONG GLOBAL_agc_collected; +/* total time spent in GC */ +EXTERNAL Int GLOBAL_tot_agc_time; +/* number of heap objects in all garbage collections */ +EXTERNAL Int GLOBAL_tot_agc_recovered; +//arrays.c +#if HAVE_MMAP +EXTERNAL struct MMAP_ARRAY_BLOCK* GLOBAL_mmap_arrays; +#endif +#ifdef DEBUG +//computils.c +EXTERNAL char GLOBAL_Option[20]; +EXTERNAL YP_FILE* GLOBAL_logfile; +//init.c +//int output_msg =FALSE +#endif +#if defined(COFF) || defined(A_OUT) +// loada_coff.c && load_aout.c +EXTERNAL char GLOBAL_Executable[YAP_FILENAME_MAX]; +#endif +EXTERNAL int GLOBAL_OpaqueHandlersCount; +EXTERNAL struct opaque_handler_struct* GLOBAL_OpaqueHandlers; +#if __simplescalar__ +EXTERNAL char GLOBAL_pwd[YAP_FILENAME_MAX]; +#endif +//udi.c +//struct udi_control_block RtreeCmd void +EXTERNAL char* GLOBAL_RestoreFile; +//gprof.c +EXTERNAL Int GLOBAL_ProfCalls; +EXTERNAL Int GLOBAL_ProfGCs; +EXTERNAL Int GLOBAL_ProfHGrows; +EXTERNAL Int GLOBAL_ProfSGrows; +EXTERNAL Int GLOBAL_ProfMallocs; +EXTERNAL Int GLOBAL_ProfIndexing; +EXTERNAL Int GLOBAL_ProfOn; +EXTERNAL Int GLOBAL_ProfOns; +EXTERNAL struct RB_red_blk_node* GLOBAL_ProfilerRoot; +EXTERNAL struct RB_red_blk_node* GLOBAL_ProfilerNil; +EXTERNAL char* GLOBAL_DIRNAME; +#if LOW_PROF +EXTERNAL int GLOBAL_ProfilerOn; +EXTERNAL FILE* GLOBAL_FProf; +EXTERNAL FILE* GLOBAL_FPreds; +#endif /* LOW_PROF */ +// Mutexes +#if THREADS +EXTERNAL struct swi_mutex* GLOBAL_FreeMutexes; +EXTERNAL struct swi_mutex* GLOBAL_mutex_backbone; +EXTERNAL lockvar GLOBAL_MUT_ACCESS; +#endif +EXTERNAL char* GLOBAL_Home; +/* ISO char conversion: I will make no comments */ +EXTERNAL char* GLOBAL_CharConversionTable; +EXTERNAL char* GLOBAL_CharConversionTable2; +/* time */ +EXTERNAL void* GLOBAL_LastWTimePtr; +/* max priority */ +EXTERNAL int GLOBAL_MaxPriority; + diff --git a/H/heap/h0struct.h b/H/heap/h0struct.h new file mode 100644 index 000000000..6d49462c5 --- /dev/null +++ b/H/heap/h0struct.h @@ -0,0 +1,303 @@ + + /* This file, d0hstruct.h, was generated automatically by "yap -L misc/buildlocalglobal" + please do not update, update misc/HEAPFIELDS instead */ + +// +// File defining fields in the Yap_heap_codes global structure +// +// these fields used to spread all over the place, because they must be used in 4 ways: +// - they must be defined somewhere +// - they have an #ifdef to get a shorter name +// - they must be initialised somewhere +// - they must be restorable and collectable (from the atom gc). +// +// +// The defs include 4+ components: +// Type +// name in structured +// global name +// init code and restore code (optional) +// +// +// +// MkAT (MkAtomTerm) cvts from a predefined atom to a term +// MkPred constructs a pred_entry +// MkOp gets an opcode +// void does nothing +// =VALUE inits as VALUE +// Init... sets up call to InitFunc +// Restore... sets up call to RestoreFunc +// + +/* memory management */ +EXTERNAL UInt Yap_HoleSize; +EXTERNAL struct malloc_state *Yap_av; +#if USE_DL_MALLOC +EXTERNAL struct Yap_MemoryHoles[MAX_DLMALLOC_HOLES] void; +EXTERNAL UInt Yap_NOfMemoryHoles; +#if defined(YAPOR) || defined(THREADS) +EXTERNAL lockvar DLMallocLock; +#endif +#endif +#if USE_DL_MALLOC || (USE_SYSTEM_MALLOC && HAVE_MALLINFO) +#ifndef HeapUsed +#define HeapUsed Yap_givemallinfo() +#endif +EXTERNAL Int NotHeapUsed; +#else +EXTERNAL Int HeapUsed; +#endif +EXTERNAL Int HeapMax; +EXTERNAL ADDR HeapTop; +EXTERNAL ADDR HeapLim; +EXTERNAL struct FREEB *FreeBlocks; +#if defined(YAPOR) || defined(THREADS) +EXTERNAL lockvar FreeBlocksLock; +EXTERNAL lockvar HeapUsedLock; +EXTERNAL lockvar HeapTopLock; +EXTERNAL int HeapTopOwner; +#endif +EXTERNAL UInt MaxStack; +EXTERNAL UInt MaxTrail; +/* execution info */ +/* OPCODE REVERSE TABLE, needed to recover op tables */ +#if USE_THREADED_CODE +EXTERNAL op_entry *OP_RTABLE; +#endif +/* popular opcodes */ +EXTERNAL OPCODE EXECUTE_CPRED_OP_CODE; +EXTERNAL OPCODE EXPAND_OP_CODE; +EXTERNAL OPCODE FAIL_OPCODE; +EXTERNAL OPCODE INDEX_OPCODE; +EXTERNAL OPCODE LOCKPRED_OPCODE; +EXTERNAL OPCODE ORLAST_OPCODE; +EXTERNAL OPCODE UNDEF_OPCODE; +EXTERNAL OPCODE RETRY_USERC_OPCODE; +EXTERNAL OPCODE EXECUTE_CPRED_OPCODE; +/* atom tables */ +EXTERNAL UInt NOfAtoms; +EXTERNAL UInt AtomHashTableSize; +EXTERNAL UInt WideAtomHashTableSize; +EXTERNAL UInt NOfWideAtoms; +EXTERNAL AtomHashEntry INVISIBLECHAIN; +EXTERNAL AtomHashEntry *WideHashChain; +EXTERNAL AtomHashEntry *HashChain; +/* use atom defs here */ +#include "tatoms.h" +#ifdef EUROTRA +EXTERNAL Term TermDollarU; +#endif +//modules +EXTERNAL Term USER_MODULE; +EXTERNAL Term IDB_MODULE; +EXTERNAL Term ATTRIBUTES_MODULE; +EXTERNAL Term CHARSIO_MODULE; +EXTERNAL Term CHTYPE_MODULE; +EXTERNAL Term TERMS_MODULE; +EXTERNAL Term SYSTEM_MODULE; +EXTERNAL Term READUTIL_MODULE; +EXTERNAL Term HACKS_MODULE; +EXTERNAL Term ARG_MODULE; +EXTERNAL Term GLOBALS_MODULE; +EXTERNAL Term SWI_MODULE; +EXTERNAL Term DBLOAD_MODULE; +EXTERNAL Term RANGE_MODULE; +EXTERNAL Term ERROR_MODULE; +// +// Module list +// +EXTERNAL struct mod_entry *CurrentModules; +// make sure we have the modules set at this point. +// don't actually want to define a field + +// hidden predicates +EXTERNAL Prop HIDDEN_PREDICATES; +// make sure we have the streams set at this point. +// don't actually want to define a field + +EXTERNAL union flagTerm* GLOBAL_Flags; +EXTERNAL UInt GLOBAL_flagCount; +/* Anderson's JIT */ +EXTERNAL yap_exec_mode Yap_ExecutionMode; +/* The Predicate Hash Table: fast access to predicates. */ +EXTERNAL struct pred_entry **PredHash; +#if defined(YAPOR) || defined(THREADS) +EXTERNAL rwlock_t PredHashRWLock; +#endif +EXTERNAL UInt PredsInHashTable; +EXTERNAL UInt PredHashTableSize; +/* Well-Known Predicates */ +EXTERNAL struct pred_entry *CreepCode; +EXTERNAL struct pred_entry *UndefCode; +EXTERNAL struct pred_entry *SpyCode; +EXTERNAL struct pred_entry *PredFail; +EXTERNAL struct pred_entry *PredTrue; +#ifdef COROUTINING +EXTERNAL struct pred_entry *WakeUpCode; +#endif +EXTERNAL struct pred_entry *PredGoalExpansion; +EXTERNAL struct pred_entry *PredMetaCall; +EXTERNAL struct pred_entry *PredTraceMetaCall; +EXTERNAL struct pred_entry *PredDollarCatch; +EXTERNAL struct pred_entry *PredRecordedWithKey; +EXTERNAL struct pred_entry *PredLogUpdClause; +EXTERNAL struct pred_entry *PredLogUpdClauseErase; +EXTERNAL struct pred_entry *PredLogUpdClause0; +EXTERNAL struct pred_entry *PredStaticClause; +EXTERNAL struct pred_entry *PredThrow; +EXTERNAL struct pred_entry *PredHandleThrow; +EXTERNAL struct pred_entry *PredIs; +EXTERNAL struct pred_entry *PredSafeCallCleanup; +EXTERNAL struct pred_entry *PredRestoreRegs; +EXTERNAL struct pred_entry *PredCommentHook; +#ifdef YAPOR +EXTERNAL struct pred_entry *PredGetwork; +#endif /* YAPOR */ +EXTERNAL struct pred_entry *PredProcedure; +/* low-level tracer */ +#ifdef LOW_LEVEL_TRACER +EXTERNAL int Yap_do_low_level_trace; +#if defined(YAPOR) || defined(THREADS) +EXTERNAL lockvar Yap_low_level_trace_lock; +#endif +#endif +/* code management info */ +EXTERNAL UInt Yap_ClauseSpace; +EXTERNAL UInt Yap_IndexSpace_Tree; +EXTERNAL UInt Yap_IndexSpace_EXT; +EXTERNAL UInt Yap_IndexSpace_SW; +EXTERNAL UInt Yap_LUClauseSpace; +EXTERNAL UInt Yap_LUIndexSpace_Tree; +EXTERNAL UInt Yap_LUIndexSpace_CP; +EXTERNAL UInt Yap_LUIndexSpace_EXT; +EXTERNAL UInt Yap_LUIndexSpace_SW; +/* static code: may be shared by many predicate or may be used for meta-execution */ +EXTERNAL yamop COMMA_CODE[5]; +EXTERNAL yamop DUMMYCODE[1]; +EXTERNAL yamop FAILCODE[1]; +EXTERNAL yamop NOCODE[1]; +EXTERNAL yamop ENV_FOR_TRUSTFAIL[2]; +EXTERNAL yamop *TRUSTFAILCODE; +EXTERNAL yamop ENV_FOR_YESCODE[2]; +EXTERNAL yamop *YESCODE; +EXTERNAL yamop RTRYCODE[1]; +#ifdef BEAM +EXTERNAL yamop BEAM_RETRY_CODE[1]; +#endif /* BEAM */ +#ifdef YAPOR +EXTERNAL yamop GETWORK[1]; +EXTERNAL yamop GETWORK_SEQ[1]; +EXTERNAL yamop GETWORK_FIRST_TIME[1]; +#endif /* YAPOR */ +#ifdef TABLING +EXTERNAL yamop LOAD_ANSWER[1]; +EXTERNAL yamop TRY_ANSWER[1]; +EXTERNAL yamop ANSWER_RESOLUTION[1]; +EXTERNAL yamop COMPLETION[1]; +#ifdef THREADS_CONSUMER_SHARING +EXTERNAL yamop ANSWER_RESOLUTION_COMPLETION[1]; +#endif /* THREADS_CONSUMER_SHARING */ +#endif /* TABLING */ +/* */ +/* PREG just before we enter $spy. We use that to find out the clause which */ +/* was calling the debugged goal. */ +/* */ +EXTERNAL yamop *P_before_spy; +/* support recorded_k */ +EXTERNAL yamop *RETRY_C_RECORDEDP_CODE; +EXTERNAL yamop *RETRY_C_RECORDED_K_CODE; +/* compiler flags */ +EXTERNAL int PROFILING; +EXTERNAL int CALL_COUNTING; +EXTERNAL int optimizer_on; +EXTERNAL int compile_mode; +EXTERNAL int profiling; +EXTERNAL int call_counting; +/********* whether we should try to compile array references ******************/ +EXTERNAL int compile_arrays; +/* DBTerms: pre-compiled ground terms */ +#if defined(YAPOR) || defined(THREADS) +EXTERNAL lockvar DBTermsListLock; +#endif +EXTERNAL struct dbterm_list *DBTermsList; +/* JITI support */ +EXTERNAL yamop *ExpandClausesFirst; +EXTERNAL yamop *ExpandClausesLast; +EXTERNAL UInt Yap_ExpandClauses; +#if defined(YAPOR) || defined(THREADS) +EXTERNAL lockvar ExpandClausesListLock; +EXTERNAL lockvar OpListLock; +#endif +/* instrumentation */ +#ifdef DEBUG +EXTERNAL UInt Yap_NewCps; +EXTERNAL UInt Yap_LiveCps; +EXTERNAL UInt Yap_DirtyCps; +EXTERNAL UInt Yap_FreedCps; +#endif +EXTERNAL UInt Yap_expand_clauses_sz; +/* UDI support */ +EXTERNAL struct udi_info *UdiControlBlocks; +/* data-base statistics */ +/* system boots in compile mode */ +EXTERNAL Int STATIC_PREDICATES_MARKED; +/* Internal Database */ +EXTERNAL Prop *INT_KEYS; +EXTERNAL Prop *INT_LU_KEYS; +EXTERNAL Prop *INT_BB_KEYS; +/* Internal Database Statistics */ +EXTERNAL UInt INT_KEYS_SIZE; +EXTERNAL UInt INT_KEYS_TIMESTAMP; +EXTERNAL UInt INT_BB_KEYS_SIZE; +/* Internal Data-Base Control */ +EXTERNAL int UPDATE_MODE; +/* nasty IDB stuff */ +EXTERNAL struct DB_STRUCT *DBErasedMarker; +EXTERNAL struct logic_upd_clause *LogDBErasedMarker; +/* Dead clauses and IDB entries */ +EXTERNAL struct static_clause *DeadStaticClauses; +EXTERNAL struct static_mega_clause *DeadMegaClauses; +EXTERNAL struct static_index *DeadStaticIndices; +EXTERNAL struct logic_upd_clause *DBErasedList; +EXTERNAL struct logic_upd_index *DBErasedIList; +#if defined(YAPOR) || defined(THREADS) +EXTERNAL lockvar DeadStaticClausesLock; +EXTERNAL lockvar DeadMegaClausesLock; +EXTERNAL lockvar DeadStaticIndicesLock; +#endif +#ifdef COROUTINING +/* number of attribute modules */ +EXTERNAL int NUM_OF_ATTS; +/* initialised by memory allocator */ +EXTERNAL UInt Yap_AttsSize; +#endif +/* Operators */ +EXTERNAL struct operator_entry *OpList; +/* foreign code loaded */ +EXTERNAL struct ForeignLoadItem *ForeignCodeLoaded; +EXTERNAL ADDR ForeignCodeBase; +EXTERNAL ADDR ForeignCodeTop; +EXTERNAL ADDR ForeignCodeMax; +/* recorded terms */ +EXTERNAL struct record_list *Yap_Records; +/* SWI atoms and functors */ +EXTERNAL Atom *SWI_Atoms; +EXTERNAL Functor *SWI_Functors; +EXTERNAL swi_rev_hash SWI_ReverseHash[N_SWI_HASH]; +/* integer access to atoms */ +EXTERNAL Int AtomTranslations; +EXTERNAL Int MaxAtomTranslations; +/* integer access to functors */ +EXTERNAL Int FunctorTranslations; +EXTERNAL Int MaxFunctorTranslations; +EXTERNAL Atom EmptyWakeups[MAX_EMPTY_WAKEUPS]; +EXTERNAL int MaxEmptyWakeups; +/* SWI blobs */ +EXTERNAL struct YAP_blob_t *BlobTypes; +EXTERNAL struct AtomEntryStruct *Blobs; +EXTERNAL UInt NOfBlobs; +EXTERNAL UInt NOfBlobsMax; +#if defined(YAPOR) || defined(THREADS) +EXTERNAL lockvar Blobs_Lock; +#endif + diff --git a/H/heap/ihstruct.h b/H/heap/ihstruct.h new file mode 100644 index 000000000..271a6b289 --- /dev/null +++ b/H/heap/ihstruct.h @@ -0,0 +1,303 @@ + + /* This file, ihstruct.h, was generated automatically by "yap -L misc/buildlocalglobal" + please do not update, update misc/HEAPFIELDS instead */ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +#if USE_DL_MALLOC + + +#if defined(YAPOR) || defined(THREADS) + INIT_LOCK(DLMallocLock); +#endif +#endif +#if USE_DL_MALLOC || (USE_SYSTEM_MALLOC && HAVE_MALLINFO) +#ifndef HeapUsed +#define HeapUsed Yap_givemallinfo() +#endif + +#else + +#endif + + + + +#if defined(YAPOR) || defined(THREADS) + INIT_LOCK(FreeBlocksLock); + INIT_LOCK(HeapUsedLock); + INIT_LOCK(HeapTopLock); + HeapTopOwner = -1; +#endif + MaxStack = 0; + MaxTrail = 0; + + +#if USE_THREADED_CODE + +#endif + + EXECUTE_CPRED_OP_CODE = Yap_opcode(_execute_cpred); + EXPAND_OP_CODE = Yap_opcode(_expand_index); + FAIL_OPCODE = Yap_opcode(_op_fail); + INDEX_OPCODE = Yap_opcode(_index_pred); + LOCKPRED_OPCODE = Yap_opcode(_lock_pred); + ORLAST_OPCODE = Yap_opcode(_or_last); + UNDEF_OPCODE = Yap_opcode(_undef_p); + RETRY_USERC_OPCODE = Yap_opcode(_retry_userc); + EXECUTE_CPRED_OPCODE = Yap_opcode(_execute_cpred); + + + + + + InitInvisibleAtoms(); + InitWideAtoms(); + InitAtoms(); + +#include "iatoms.h" +#ifdef EUROTRA + TermDollarU = MkAtomTerm(AtomDollarU); +#endif + + USER_MODULE = MkAtomTerm(AtomUser); + IDB_MODULE = MkAtomTerm(AtomIDB); + ATTRIBUTES_MODULE = MkAtomTerm(AtomAttributes); + CHARSIO_MODULE = MkAtomTerm(AtomCharsio); + CHTYPE_MODULE = MkAtomTerm(AtomChType); + TERMS_MODULE = MkAtomTerm(AtomTerms); + SYSTEM_MODULE = MkAtomTerm(AtomSystem); + READUTIL_MODULE = MkAtomTerm(AtomReadutil); + HACKS_MODULE = MkAtomTerm(AtomYapHacks); + ARG_MODULE = MkAtomTerm(AtomArg); + GLOBALS_MODULE = MkAtomTerm(AtomNb); + SWI_MODULE = MkAtomTerm(AtomSwi); + DBLOAD_MODULE = MkAtomTerm(AtomDBLoad); + RANGE_MODULE = MkAtomTerm(AtomRange); + ERROR_MODULE = MkAtomTerm(AtomError); + + + + CurrentModules = NULL; + + + Yap_InitModules(); + + HIDDEN_PREDICATES = NULL; + + + Yap_InitPlIO(); + GLOBAL_Flags = 0; + Yap_InitFlags(true); + + Yap_ExecutionMode = INTERPRETED; + + InitPredHash(); +#if defined(YAPOR) || defined(THREADS) + +#endif + PredsInHashTable = 0; + + + CreepCode = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomCreep,1),PROLOG_MODULE)); + UndefCode = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomUndefp,2),PROLOG_MODULE)); + SpyCode = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomSpy,1),PROLOG_MODULE)); + PredFail = RepPredProp(PredPropByAtom(AtomFail,PROLOG_MODULE)); + PredTrue = RepPredProp(PredPropByAtom(AtomTrue,PROLOG_MODULE)); +#ifdef COROUTINING + WakeUpCode = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomWakeUpGoal,2),PROLOG_MODULE)); +#endif + PredGoalExpansion = RepPredProp(PredPropByFunc(FunctorGoalExpansion,USER_MODULE)); + PredMetaCall = RepPredProp(PredPropByFunc(FunctorMetaCall,PROLOG_MODULE)); + PredTraceMetaCall = RepPredProp(PredPropByFunc(FunctorTraceMetaCall,PROLOG_MODULE)); + PredDollarCatch = RepPredProp(PredPropByFunc(FunctorCatch,PROLOG_MODULE)); + PredRecordedWithKey = RepPredProp(PredPropByFunc(FunctorRecordedWithKey,PROLOG_MODULE)); + PredLogUpdClause = RepPredProp(PredPropByFunc(FunctorDoLogUpdClause,PROLOG_MODULE)); + PredLogUpdClauseErase = RepPredProp(PredPropByFunc(FunctorDoLogUpdClauseErase,PROLOG_MODULE)); + PredLogUpdClause0 = RepPredProp(PredPropByFunc(FunctorDoLogUpdClause,PROLOG_MODULE)); + PredStaticClause = RepPredProp(PredPropByFunc(FunctorDoStaticClause,PROLOG_MODULE)); + PredThrow = RepPredProp(PredPropByFunc(FunctorThrow,PROLOG_MODULE)); + PredHandleThrow = RepPredProp(PredPropByFunc(FunctorHandleThrow,PROLOG_MODULE)); + PredIs = RepPredProp(PredPropByFunc(FunctorIs,PROLOG_MODULE)); + PredSafeCallCleanup = RepPredProp(PredPropByFunc(FunctorSafeCallCleanup,PROLOG_MODULE)); + PredRestoreRegs = RepPredProp(PredPropByFunc(FunctorRestoreRegs,PROLOG_MODULE)); + PredCommentHook = RepPredProp(PredPropByFunc(FunctorCommentHook,PROLOG_MODULE)); +#ifdef YAPOR + PredGetwork = RepPredProp(PredPropByAtom(AtomGetwork,PROLOG_MODULE)); +#endif /* YAPOR */ + PredProcedure = Yap_MkLogPred(RepPredProp(PredPropByFunc(FunctorProcedure,PROLOG_MODULE))); + +#ifdef LOW_LEVEL_TRACER + Yap_do_low_level_trace = FALSE; +#if defined(YAPOR) || defined(THREADS) + INIT_LOCK(Yap_low_level_trace_lock); +#endif +#endif + + Yap_ClauseSpace = 0; + Yap_IndexSpace_Tree = 0; + Yap_IndexSpace_EXT = 0; + Yap_IndexSpace_SW = 0; + Yap_LUClauseSpace = 0; + Yap_LUIndexSpace_Tree = 0; + Yap_LUIndexSpace_CP = 0; + Yap_LUIndexSpace_EXT = 0; + Yap_LUIndexSpace_SW = 0; + + + DUMMYCODE->opc = Yap_opcode(_op_fail); + FAILCODE->opc = Yap_opcode(_op_fail); + NOCODE->opc = Yap_opcode(_Nstop); + InitEnvInst(ENV_FOR_TRUSTFAIL,&TRUSTFAILCODE,_trust_fail,PredFail); + + InitEnvInst(ENV_FOR_YESCODE,&YESCODE,_Ystop,PredFail); + + InitOtaplInst(RTRYCODE,_retry_and_mark,PredFail); +#ifdef BEAM + BEAM_RETRY_CODE->opc = Yap_opcode(_beam_retry_code); +#endif /* BEAM */ +#ifdef YAPOR + InitOtaplInst(GETWORK,_getwork,PredGetwork); + InitOtaplInst(GETWORK_SEQ,_getwork_seq,PredGetworkSeq); + GETWORK_FIRST_TIME->opc = Yap_opcode(_getwork_first_time); +#endif /* YAPOR */ +#ifdef TABLING + InitOtaplInst(LOAD_ANSWER,_table_load_answer,PredFail); + InitOtaplInst(TRY_ANSWER,_table_try_answer,PredFail); + InitOtaplInst(ANSWER_RESOLUTION,_table_answer_resolution,PredFail); + InitOtaplInst(COMPLETION,_table_completion,PredFail); +#ifdef THREADS_CONSUMER_SHARING + InitOtaplInst(ANSWER_RESOLUTION_COMPLETION,_table_answer_resolution_completion,PredFail); +#endif /* THREADS_CONSUMER_SHARING */ +#endif /* TABLING */ + + + + + P_before_spy = NULL; + + RETRY_C_RECORDEDP_CODE = NULL; + RETRY_C_RECORDED_K_CODE = NULL; + + PROFILING = FALSE; + CALL_COUNTING = FALSE; + optimizer_on = TRUE; + compile_mode = 0; + profiling = FALSE; + call_counting = FALSE; + + compile_arrays = FALSE; + +#if defined(YAPOR) || defined(THREADS) + INIT_LOCK(DBTermsListLock); +#endif + DBTermsList = NULL; + + ExpandClausesFirst = NULL; + ExpandClausesLast = NULL; + Yap_ExpandClauses = 0; +#if defined(YAPOR) || defined(THREADS) + INIT_LOCK(ExpandClausesListLock); + INIT_LOCK(OpListLock); +#endif + +#ifdef DEBUG + Yap_NewCps = 0L; + Yap_LiveCps = 0L; + Yap_DirtyCps = 0L; + Yap_FreedCps = 0L; +#endif + Yap_expand_clauses_sz = 0L; + + UdiControlBlocks = NULL; + + + STATIC_PREDICATES_MARKED = FALSE; + + INT_KEYS = NULL; + INT_LU_KEYS = NULL; + INT_BB_KEYS = NULL; + + INT_KEYS_SIZE = INT_KEYS_DEFAULT_SIZE; + INT_KEYS_TIMESTAMP = 0L; + INT_BB_KEYS_SIZE = INT_KEYS_DEFAULT_SIZE; + + UPDATE_MODE = UPDATE_MODE_LOGICAL; + + InitDBErasedMarker(); + InitLogDBErasedMarker(); + + DeadStaticClauses = NULL; + DeadMegaClauses = NULL; + DeadStaticIndices = NULL; + DBErasedList = NULL; + DBErasedIList = NULL; +#if defined(YAPOR) || defined(THREADS) + INIT_LOCK(DeadStaticClausesLock); + INIT_LOCK(DeadMegaClausesLock); + INIT_LOCK(DeadStaticIndicesLock); +#endif +#ifdef COROUTINING + + NUM_OF_ATTS = 1; + + +#endif + + OpList = NULL; + + ForeignCodeLoaded = NULL; + ForeignCodeBase = NULL; + ForeignCodeTop = NULL; + ForeignCodeMax = NULL; + + Yap_Records = NULL; + + InitSWIAtoms(); + + + + + + + + + InitEmptyWakeups(); + MaxEmptyWakeups = 0; + + BlobTypes = NULL; + Blobs = NULL; + NOfBlobs = 0; + NOfBlobsMax = 256; +#if defined(YAPOR) || defined(THREADS) + INIT_LOCK(Blobs_Lock); +#endif + diff --git a/H/heap/ilocals.h b/H/heap/ilocals.h new file mode 100755 index 000000000..fa53fe070 --- /dev/null +++ b/H/heap/ilocals.h @@ -0,0 +1,277 @@ + + /* This file, ilocals.h, was generated automatically by "yap -L misc/buildlocalglobal" + please do not update, update misc/LOCALS instead */ + + +static void InitWorker(int wid) { + + REMOTE_FileAliases(wid) = Yap_InitStandardAliases(); + + + REMOTE_c_input_stream(wid) = 0; + REMOTE_c_output_stream(wid) = 1; + REMOTE_c_error_stream(wid) = 2; + REMOTE_sockets_io(wid) = false; + REMOTE_within_print_message(wid) = false; + + + + + REMOTE_newline(wid) = true; + REMOTE_AtPrompt(wid) = AtomNil; + + REMOTE_encoding(wid) = Yap_DefaultEncoding(); + REMOTE_quasi_quotations(wid) = false; + REMOTE_default_priority(wid) = 1200; + REMOTE_eot_before_eof(wid) = false; + REMOTE_max_depth(wid) = 0; + REMOTE_max_list(wid) = 0; + REMOTE_max_write_args(wid) = 0; + + REMOTE_OldASP(wid) = NULL; + REMOTE_OldLCL0(wid) = NULL; + REMOTE_OldTR(wid) = NULL; + REMOTE_OldGlobalBase(wid) = NULL; + REMOTE_OldH(wid) = NULL; + REMOTE_OldH0(wid) = NULL; + REMOTE_OldTrailBase(wid) = NULL; + REMOTE_OldTrailTop(wid) = NULL; + REMOTE_OldHeapBase(wid) = NULL; + REMOTE_OldHeapTop(wid) = NULL; + REMOTE_ClDiff(wid) = 0L; + REMOTE_GDiff(wid) = 0L; + REMOTE_HDiff(wid) = 0L; + REMOTE_GDiff0(wid) = 0L; + REMOTE_GSplit(wid) = NULL; + REMOTE_LDiff(wid) = 0L; + REMOTE_TrDiff(wid) = 0L; + REMOTE_XDiff(wid) = 0L; + REMOTE_DelayDiff(wid) = 0L; + REMOTE_BaseDiff(wid) = 0L; + + REMOTE_ReductionsCounter(wid) = 0L; + REMOTE_PredEntriesCounter(wid) = 0L; + REMOTE_RetriesCounter(wid) = 0L; + REMOTE_ReductionsCounterOn(wid) = 0L; + REMOTE_PredEntriesCounterOn(wid) = 0L; + REMOTE_RetriesCounterOn(wid) = 0L; + + + REMOTE_ConsultSp(wid) = NULL; + + + + REMOTE_ConsultBase(wid) = NULL; + + REMOTE_ConsultLow(wid) = NULL; + REMOTE_VarNames(wid) = ((Term)0); + REMOTE_SourceFileName(wid) = NULL; + REMOTE_SourceFileLineno(wid) = 0; + + REMOTE_GlobalArena(wid) = 0L; + REMOTE_GlobalArenaOverflows(wid) = 0L; + REMOTE_ArenaOverflows(wid) = 0L; + REMOTE_DepthArenas(wid) = 0; + REMOTE_ArithError(wid) = FALSE; + REMOTE_LastAssertedPred(wid) = NULL; + REMOTE_TmpPred(wid) = NULL; + REMOTE_ScannerStack(wid) = NULL; + REMOTE_ScannerExtraBlocks(wid) = NULL; + REMOTE_BallTerm(wid) = NULL; + REMOTE_MaxActiveSignals(wid) = 64L; + REMOTE_Signals(wid) = 0L; + REMOTE_IPredArity(wid) = 0L; + REMOTE_ProfEnd(wid) = NULL; + REMOTE_UncaughtThrow(wid) = FALSE; + REMOTE_DoingUndefp(wid) = FALSE; + REMOTE_StartCharCount(wid) = 0L; + REMOTE_StartLineCount(wid) = 0L; + REMOTE_StartLinePos(wid) = 0L; + InitScratchPad(wid); +#ifdef COROUTINING + REMOTE_WokenGoals(wid) = 0L; + REMOTE_AttsMutableList(wid) = 0L; +#endif + + REMOTE_GcGeneration(wid) = 0L; + REMOTE_GcPhase(wid) = 0L; + REMOTE_GcCurrentPhase(wid) = 0L; + REMOTE_GcCalls(wid) = 0L; + REMOTE_TotGcTime(wid) = 0L; + REMOTE_TotGcRecovered(wid) = 0L; + REMOTE_LastGcTime(wid) = 0L; + REMOTE_LastSSTime(wid) = 0L; + REMOTE_OpenArray(wid) = NULL; + + REMOTE_total_marked(wid) = 0L; + REMOTE_total_oldies(wid) = 0L; + REMOTE_current_B(wid) = NULL; + REMOTE_prev_HB(wid) = NULL; + REMOTE_HGEN(wid) = NULL; + REMOTE_iptop(wid) = NULL; +#if defined(GC_NO_TAGS) + REMOTE_bp(wid) = NULL; +#endif + REMOTE_sTR(wid) = NULL; + REMOTE_sTR0(wid) = NULL; + REMOTE_new_TR(wid) = NULL; + REMOTE_cont_top0(wid) = NULL; + REMOTE_cont_top(wid) = NULL; + REMOTE_discard_trail_entries(wid) = 0; + + REMOTE_gc_ma_h_top(wid) = NULL; + REMOTE_gc_ma_h_list(wid) = NULL; + REMOTE_gc_timestamp(wid) = 0L; + REMOTE_db_vec(wid) = NULL; + REMOTE_db_vec0(wid) = NULL; + REMOTE_db_root(wid) = NULL; + REMOTE_db_nil(wid) = NULL; + + + + + REMOTE_extra_gc_cells_size(wid) = 256; + REMOTE_DynamicArrays(wid) = NULL; + REMOTE_StaticArrays(wid) = NULL; + REMOTE_GlobalVariables(wid) = NULL; + REMOTE_AllowRestart(wid) = FALSE; + + REMOTE_CMemFirstBlock(wid) = NULL; + REMOTE_CMemFirstBlockSz(wid) = 0L; + + REMOTE_nperm(wid) = 0L; + + REMOTE_LabelFirstArray(wid) = NULL; + REMOTE_LabelFirstArraySz(wid) = 0L; + + +#ifdef THREADS + InitThreadHandle(wid); +#endif /* THREADS */ +#if defined(YAPOR) || defined(TABLING) + Yap_init_local_optyap_data(wid); + REMOTE_TabMode(wid) = 0L; +#endif /* YAPOR || TABLING */ + REMOTE_InterruptsDisabled(wid) = FALSE; + REMOTE_execution(wid) = NULL; +#if LOW_LEVEL_TRACER + REMOTE_total_choicepoints(wid) = 0; +#endif + REMOTE_consult_level(wid) = 0; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + REMOTE_BreakLevel(wid) = 0; + REMOTE_PrologMode(wid) = BootMode; + REMOTE_CritLocks(wid) = 0; + + + + + +#ifdef ANALYST + + +#endif /* ANALYST */ + + + + REMOTE_matherror(wid) = YAP_NO_ERROR; + + REMOTE_mathstring(wid) = NULL; + REMOTE_CurrentError(wid) = YAP_NO_ERROR; + + REMOTE_heap_overflows(wid) = 0; + REMOTE_total_heap_overflow_time(wid) = 0; + REMOTE_stack_overflows(wid) = 0; + REMOTE_total_stack_overflow_time(wid) = 0; + REMOTE_delay_overflows(wid) = 0; + REMOTE_total_delay_overflow_time(wid) = 0; + REMOTE_trail_overflows(wid) = 0; + REMOTE_total_trail_overflow_time(wid) = 0; + REMOTE_atom_table_overflows(wid) = 0; + REMOTE_total_atom_table_overflow_time(wid) = 0; + +#ifdef LOAD_DYLD + REMOTE_dl_errno(wid) = 0; +#endif + +#ifdef LOW_LEVEL_TRACER + REMOTE_do_trace_primitives(wid) = TRUE; +#endif + + REMOTE_ExportAtomHashChain(wid) = NULL; + REMOTE_ExportAtomHashTableSize(wid) = 0; + REMOTE_ExportAtomHashTableNum(wid) = 0; + REMOTE_ExportFunctorHashChain(wid) = NULL; + REMOTE_ExportFunctorHashTableSize(wid) = 0; + REMOTE_ExportFunctorHashTableNum(wid) = 0; + REMOTE_ExportPredEntryHashChain(wid) = NULL; + REMOTE_ExportPredEntryHashTableSize(wid) = 0; + REMOTE_ExportPredEntryHashTableNum(wid) = 0; + REMOTE_ExportDBRefHashChain(wid) = NULL; + REMOTE_ExportDBRefHashTableSize(wid) = 0; + REMOTE_ExportDBRefHashTableNum(wid) = 0; + REMOTE_ImportAtomHashChain(wid) = NULL; + REMOTE_ImportAtomHashTableSize(wid) = 0; + REMOTE_ImportAtomHashTableNum(wid) = 0; + REMOTE_ImportFunctorHashChain(wid) = NULL; + REMOTE_ImportFunctorHashTableSize(wid) = 0; + REMOTE_ImportFunctorHashTableNum(wid) = 0; + REMOTE_ImportOPCODEHashChain(wid) = NULL; + REMOTE_ImportOPCODEHashTableSize(wid) = 0; + REMOTE_ImportPredEntryHashChain(wid) = NULL; + REMOTE_ImportPredEntryHashTableSize(wid) = 0; + REMOTE_ImportPredEntryHashTableNum(wid) = 0; + REMOTE_ImportDBRefHashChain(wid) = NULL; + REMOTE_ImportDBRefHashTableSize(wid) = 0; + REMOTE_ImportDBRefHashTableNum(wid) = 0; + REMOTE_ImportFAILCODE(wid) = NULL; +#if __ANDROID__ + + REMOTE_assetManager(wid) = GLOBAL_assetManager; + REMOTE_InAssetDir(wid) = NULL; +#endif + + + REMOTE_exo_it(wid) = NULL; + REMOTE_exo_base(wid) = NULL; + REMOTE_exo_arity(wid) = 0; + REMOTE_exo_arg(wid) = 0; + + + + REMOTE_CurSlot(wid) = 0; + REMOTE_NSlots(wid) = 0; + REMOTE_SlotBase(wid) = InitHandles(wid); + + REMOTE_Mutexes(wid) = NULL; + REMOTE_SourceModule(wid) = 0; + REMOTE_Including(wid) = TermNil; + REMOTE_MAX_SIZE(wid) = 1024L; +} diff --git a/H/heap/rglobals.h b/H/heap/rglobals.h new file mode 100644 index 000000000..ac1994536 --- /dev/null +++ b/H/heap/rglobals.h @@ -0,0 +1,146 @@ + + /* This file, rglobals.h, was generated automatically by "yap -L misc/buildlocalglobal" + please do not update, update misc/GLOBALS instead */ + + + + + + + + + + + + + + + + + +static void RestoreGlobal(void) { + + + + + + + + + + + + + + + + + +#if __ANDROID__ + + + +#endif + +#if THREADS + + + + + + + + REINIT_LOCK(GLOBAL_ThreadHandlesLock); +#endif +#if defined(YAPOR) || defined(THREADS) + + REINIT_LOCK(GLOBAL_BGL); +#endif +#if defined(YAPOR) || defined(TABLING) + +#endif /* YAPOR || TABLING */ + + + +#if defined(THREADS) + + + REINIT_LOCK(GLOBAL_mboxq_lock); + + +#endif /* THREADS */ + + +#if defined(THREADS)||defined(YAPOR) + REINIT_LOCK(GLOBAL_StreamDescLock); +#endif + + + + +#ifdef COROUTINING + + +#endif + + + + + + + + +#if HAVE_MMAP + +#endif +#ifdef DEBUG + + + + + +#endif +#if defined(COFF) || defined(A_OUT) + + +#endif + + +#if __simplescalar__ + +#endif + + + + + + + + + + + + + + + +#if LOW_PROF + + + +#endif /* LOW_PROF */ + +#if THREADS + + + REINIT_LOCK(GLOBAL_MUT_ACCESS); +#endif + + + + + + + + +} diff --git a/H/heap/rhstruct.h b/H/heap/rhstruct.h new file mode 100644 index 000000000..bb9c39931 --- /dev/null +++ b/H/heap/rhstruct.h @@ -0,0 +1,303 @@ + + /* This file, rhstruct.h, was generated automatically by "yap -L misc/buildlocalglobal" + please do not update, update misc/HEAPFIELDS instead */ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +#if USE_DL_MALLOC + + +#if defined(YAPOR) || defined(THREADS) + REINIT_LOCK(DLMallocLock); +#endif +#endif +#if USE_DL_MALLOC || (USE_SYSTEM_MALLOC && HAVE_MALLINFO) +#ifndef HeapUsed +#define HeapUsed Yap_givemallinfo() +#endif + +#else + +#endif + + + + +#if defined(YAPOR) || defined(THREADS) + REINIT_LOCK(FreeBlocksLock); + REINIT_LOCK(HeapUsedLock); + REINIT_LOCK(HeapTopLock); + +#endif + + + + +#if USE_THREADED_CODE + OP_RTABLE = OpRTableAdjust(OP_RTABLE); +#endif + + EXECUTE_CPRED_OP_CODE = Yap_opcode(_execute_cpred); + EXPAND_OP_CODE = Yap_opcode(_expand_index); + FAIL_OPCODE = Yap_opcode(_op_fail); + INDEX_OPCODE = Yap_opcode(_index_pred); + LOCKPRED_OPCODE = Yap_opcode(_lock_pred); + ORLAST_OPCODE = Yap_opcode(_or_last); + UNDEF_OPCODE = Yap_opcode(_undef_p); + RETRY_USERC_OPCODE = Yap_opcode(_retry_userc); + EXECUTE_CPRED_OPCODE = Yap_opcode(_execute_cpred); + + + + + + RestoreInvisibleAtoms(); + RestoreWideAtoms(); + RestoreAtoms(); + +#include "ratoms.h" +#ifdef EUROTRA + TermDollarU = AtomTermAdjust(TermDollarU); +#endif + + USER_MODULE = AtomTermAdjust(USER_MODULE); + IDB_MODULE = AtomTermAdjust(IDB_MODULE); + ATTRIBUTES_MODULE = AtomTermAdjust(ATTRIBUTES_MODULE); + CHARSIO_MODULE = AtomTermAdjust(CHARSIO_MODULE); + CHTYPE_MODULE = AtomTermAdjust(CHTYPE_MODULE); + TERMS_MODULE = AtomTermAdjust(TERMS_MODULE); + SYSTEM_MODULE = AtomTermAdjust(SYSTEM_MODULE); + READUTIL_MODULE = AtomTermAdjust(READUTIL_MODULE); + HACKS_MODULE = AtomTermAdjust(HACKS_MODULE); + ARG_MODULE = AtomTermAdjust(ARG_MODULE); + GLOBALS_MODULE = AtomTermAdjust(GLOBALS_MODULE); + SWI_MODULE = AtomTermAdjust(SWI_MODULE); + DBLOAD_MODULE = AtomTermAdjust(DBLOAD_MODULE); + RANGE_MODULE = AtomTermAdjust(RANGE_MODULE); + ERROR_MODULE = AtomTermAdjust(ERROR_MODULE); + + + + CurrentModules = ModEntryPtrAdjust(CurrentModules); + + + + + RestoreHiddenPredicates(); + + + + + RestoreFlags(GLOBAL_flagCount); + + + + RestorePredHash(); +#if defined(YAPOR) || defined(THREADS) + +#endif + + + + CreepCode = PtoPredAdjust(CreepCode); + UndefCode = PtoPredAdjust(UndefCode); + SpyCode = PtoPredAdjust(SpyCode); + PredFail = PtoPredAdjust(PredFail); + PredTrue = PtoPredAdjust(PredTrue); +#ifdef COROUTINING + WakeUpCode = PtoPredAdjust(WakeUpCode); +#endif + PredGoalExpansion = PtoPredAdjust(PredGoalExpansion); + PredMetaCall = PtoPredAdjust(PredMetaCall); + PredTraceMetaCall = PtoPredAdjust(PredTraceMetaCall); + PredDollarCatch = PtoPredAdjust(PredDollarCatch); + PredRecordedWithKey = PtoPredAdjust(PredRecordedWithKey); + PredLogUpdClause = PtoPredAdjust(PredLogUpdClause); + PredLogUpdClauseErase = PtoPredAdjust(PredLogUpdClauseErase); + PredLogUpdClause0 = PtoPredAdjust(PredLogUpdClause0); + PredStaticClause = PtoPredAdjust(PredStaticClause); + PredThrow = PtoPredAdjust(PredThrow); + PredHandleThrow = PtoPredAdjust(PredHandleThrow); + PredIs = PtoPredAdjust(PredIs); + PredSafeCallCleanup = PtoPredAdjust(PredSafeCallCleanup); + PredRestoreRegs = PtoPredAdjust(PredRestoreRegs); + PredCommentHook = PtoPredAdjust(PredCommentHook); +#ifdef YAPOR + PredGetwork = PtoPredAdjust(PredGetwork); +#endif /* YAPOR */ + PredProcedure = PtoPredAdjust(PredProcedure); + +#ifdef LOW_LEVEL_TRACER + +#if defined(YAPOR) || defined(THREADS) + REINIT_LOCK(Yap_low_level_trace_lock); +#endif +#endif + + + + + + + + + + + + + DUMMYCODE->opc = Yap_opcode(_op_fail); + FAILCODE->opc = Yap_opcode(_op_fail); + NOCODE->opc = Yap_opcode(_Nstop); + RestoreEnvInst(ENV_FOR_TRUSTFAIL,&TRUSTFAILCODE,_trust_fail,PredFail); + + RestoreEnvInst(ENV_FOR_YESCODE,&YESCODE,_Ystop,PredFail); + + RestoreOtaplInst(RTRYCODE,_retry_and_mark,PredFail); +#ifdef BEAM + BEAM_RETRY_CODE->opc = Yap_opcode(_beam_retry_code); +#endif /* BEAM */ +#ifdef YAPOR + RestoreOtaplInst(GETWORK,_getwork,PredGetwork); + RestoreOtaplInst(GETWORK_SEQ,_getwork_seq,PredGetworkSeq); + GETWORK_FIRST_TIME->opc = Yap_opcode(_getwork_first_time); +#endif /* YAPOR */ +#ifdef TABLING + RestoreOtaplInst(LOAD_ANSWER,_table_load_answer,PredFail); + RestoreOtaplInst(TRY_ANSWER,_table_try_answer,PredFail); + RestoreOtaplInst(ANSWER_RESOLUTION,_table_answer_resolution,PredFail); + RestoreOtaplInst(COMPLETION,_table_completion,PredFail); +#ifdef THREADS_CONSUMER_SHARING + RestoreOtaplInst(ANSWER_RESOLUTION_COMPLETION,_table_answer_resolution_completion,PredFail); +#endif /* THREADS_CONSUMER_SHARING */ +#endif /* TABLING */ + + + + + P_before_spy = PtoOpAdjust(P_before_spy); + + RETRY_C_RECORDEDP_CODE = PtoOpAdjust(RETRY_C_RECORDEDP_CODE); + RETRY_C_RECORDED_K_CODE = PtoOpAdjust(RETRY_C_RECORDED_K_CODE); + + + + + + + + + + +#if defined(YAPOR) || defined(THREADS) + REINIT_LOCK(DBTermsListLock); +#endif + RestoreDBTermsList(); + + + RestoreExpandList(); + +#if defined(YAPOR) || defined(THREADS) + REINIT_LOCK(ExpandClausesListLock); + REINIT_LOCK(OpListLock); +#endif + +#ifdef DEBUG + + + + +#endif + + + RestoreUdiControlBlocks(); + + + + + RestoreIntKeys(); + RestoreIntLUKeys(); + RestoreIntBBKeys(); + + + + + + + + RestoreDBErasedMarker(); + RestoreLogDBErasedMarker(); + + RestoreDeadStaticClauses(); + RestoreDeadMegaClauses(); + RestoreDeadStaticIndices(); + RestoreDBErasedList(); + RestoreDBErasedIList(); +#if defined(YAPOR) || defined(THREADS) + REINIT_LOCK(DeadStaticClausesLock); + REINIT_LOCK(DeadMegaClausesLock); + REINIT_LOCK(DeadStaticIndicesLock); +#endif +#ifdef COROUTINING + + + + +#endif + + OpList = OpListAdjust(OpList); + + RestoreForeignCode(); + + + + + RestoreYapRecords(); + + RestoreSWIAtoms(); + + + + + + + + + RestoreEmptyWakeups(); + + + RestoreBlobTypes(); + RestoreBlobs(); + + +#if defined(YAPOR) || defined(THREADS) + REINIT_LOCK(Blobs_Lock); +#endif + diff --git a/H/heap/rlocals.h b/H/heap/rlocals.h new file mode 100644 index 000000000..7eef90296 --- /dev/null +++ b/H/heap/rlocals.h @@ -0,0 +1,277 @@ + + /* This file, rlocals.h, was generated automatically by "yap -L misc/buildlocalglobal" + please do not update, update misc/LOCALS instead */ + + +static void RestoreWorker(int wid USES_REGS) { + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + REMOTE_GlobalArena(wid) = TermToGlobalOrAtomAdjust(REMOTE_GlobalArena(wid)); + + + + + + + + + RestoreBallTerm(wid); + + + + + + + + + + +#ifdef COROUTINING + REMOTE_WokenGoals(wid) = TermToGlobalAdjust(REMOTE_WokenGoals(wid)); + REMOTE_AttsMutableList(wid) = TermToGlobalAdjust(REMOTE_AttsMutableList(wid)); +#endif + + REMOTE_GcGeneration(wid) = TermToGlobalAdjust(REMOTE_GcGeneration(wid)); + REMOTE_GcPhase(wid) = TermToGlobalAdjust(REMOTE_GcPhase(wid)); + + + + + + + + + + + + + + +#if defined(GC_NO_TAGS) + +#endif + + + + + + + + + + + + + + + + + + + + REMOTE_DynamicArrays(wid) = PtoArrayEAdjust(REMOTE_DynamicArrays(wid)); + REMOTE_StaticArrays(wid) = PtoArraySAdjust(REMOTE_StaticArrays(wid)); + REMOTE_GlobalVariables(wid) = PtoGlobalEAdjust(REMOTE_GlobalVariables(wid)); + + + + + + + + + + + +#ifdef THREADS + +#endif /* THREADS */ +#if defined(YAPOR) || defined(TABLING) + + +#endif /* YAPOR || TABLING */ + + +#if LOW_LEVEL_TRACER + +#endif + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +#ifdef ANALYST + + +#endif /* ANALYST */ + + + + + + + + + + + + + + + + + + + +#ifdef LOAD_DYLD + +#endif + +#ifdef LOW_LEVEL_TRACER + +#endif + + + + + + + + + + + + + + + + + + + + + + + + + + + + +#if __ANDROID__ + + + +#endif + + + + + + + + + + + + + + + + + +}