/*************************************************************************
*									 *
*	 YAP Prolog 	%W% %G% 					 *
*	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
*									 *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997	 *
*									 *
**************************************************************************
*									 *
* File:		Heap.h         						 *
* mods:									 *
* comments:	Heap Init Structure					 *
* version:      $Id: Heap.h,v 1.61 2004/03/02 16:44:55 vsc Exp $	 *
*************************************************************************/

/* information that can be stored in Code Space */

#ifndef HEAP_H
#define HEAP_H 1

#ifndef INT_KEYS_DEFAULT_SIZE
#define INT_KEYS_DEFAULT_SIZE 256
#endif


typedef struct atom_hash_entry {
#if defined(YAPOR) || defined(THREADS)
  rwlock_t AERWLock;
#endif
  Atom Entry;
} AtomHashEntry;

typedef struct reduction_counters {
  YAP_ULONG_LONG reductions;
  YAP_ULONG_LONG reductions_retries;
  YAP_ULONG_LONG retries;
  int reductions_on;
  int reductions_retries_on;
  int retries_on;
} red_counters;

typedef struct scratch_block_struct {
  char *ptr;
  UInt sz, msz;
} scratch_block;

typedef struct worker_local_struct {
#if defined(YAPOR) || defined(THREADS)
  lockvar  signal_lock;        /* protect signal handlers from IPIs */
  struct pred_entry *wpp;
#endif
  UInt   active_signals;
  UInt   i_pred_arity;
  yamop *prof_end;
  Int    start_line;
  scratch_block scratchpad;
#ifdef MULTI_ASSIGNMENT_VARIABLES
  Term   woken_goals;
  Term   mutable_list;
  Term   atts_mutable_list;
#endif
} worker_local;

#ifdef THREADS
typedef struct thandle {
  int in_use;
  UInt ssize;
  UInt tsize;
  Term tdetach;
  Term  cmod;
  struct DB_TERM *tgoal;
  int id;
  int ret;
  REGSTORE *default_yaam_regs;
  REGSTORE *current_yaam_regs;
  struct pred_entry *local_preds;
  pthread_t handle;
  pthread_mutex_t tlock;
#if HAVE_GETRUSAGE
  struct timeval *start_of_timesp;
  struct timeval *last_timep;
#endif
} yap_thandle;
#endif

typedef int   (*Agc_hook)(Atom);

typedef struct various_codes {
  special_functors funcs;
  Int heap_used;
  Int heap_max;
  ADDR heap_top;
  ADDR heap_lim;
  struct FREEB  *free_blocks;
#if defined(YAPOR) || defined(THREADS)
  lockvar  bgl;		 /* protect long critical regions   */
  lockvar  free_blocks_lock;     /* protect the list of free blocks */
  worker_local wl[MAX_WORKERS];
#else
  worker_local wl;
#endif
#ifdef YAPOR
  int   seq_def;
  yamop getworkcode;
  yamop getworkcode_seq;
  yamop getworkfirsttimecode;
#endif /* YAPOR */
#ifdef TABLING
  yamop tablecompletioncode;
  yamop tableanswerresolutioncode;
#endif /* TABLING */
  OPCODE expand_op_code;
  yamop comma_code[5];
  yamop failcode[1];
  OPCODE failcode_1;
  OPCODE failcode_2;
  OPCODE failcode_3;
  OPCODE failcode_4;
  OPCODE failcode_5;
  OPCODE failcode_6;
  struct {
    OPCODE op;
#ifdef YAPOR
    COUNT             ltt;
    COUNT             cut;
    COUNT             seq;
#endif /* YAPOR */
    COUNT s;
    CELL *l2;
    struct pred_entry *p;
    struct pred_entry *p0;
  } env_for_trustfail_code; /* sla */
  yamop trustfailcode[1];
  struct {
    OPCODE op;
#ifdef YAPOR
    COUNT             ltt;
    COUNT             cut;
    COUNT             seq;
#endif /* YAPOR */
    COUNT s;
    CELL *l2;
    struct pred_entry *p;
    struct pred_entry *p0;
  } env_for_yes_code; /* sla */
  yamop yescode[1];
  yamop nocode[1];
  yamop rtrycode[1];
  struct {
    OPREG arity;
    struct yami *clause;
    Functor func;
  } clausecode[1];
  union CONSULT_OBJ *consultsp;
  union CONSULT_OBJ *consultbase;
  union CONSULT_OBJ *consultlow;
  UInt   consultcapacity;
#if HAVE_LIBREADLINE
  char *readline_buf, *readline_pos;
#endif
#if USE_THREADED_CODE
  opentry *op_rtable;
#endif
#ifdef COROUTINING
  int  num_of_atts;            /* max. number of attributes we have for a variable */
  struct pred_entry  *wake_up_code;
#endif
  struct pred_entry  *creep_code;
  struct pred_entry  *undef_code;
  struct pred_entry  *spy_code;
  int   system_profiling;
  int   system_call_counting;
  int   system_pred_goal_expansion_on;
  int   compiler_optimizer_on;
  int   compiler_compile_mode;
  AtomHashEntry invisiblechain;
  OPCODE dummycode[1];
  UInt maxdepth, maxlist;
  int update_mode;
  Atom atprompt;
  char prompt[MAX_PROMPT];
  OPCODE undef_op; 
  OPCODE index_op; 
  OPCODE fail_op; 
  yamop *retry_recorded_k_code,
    *retry_c_recordedp_code;
  Int static_predicates_marked;
  UInt int_keys_size;
  UInt int_keys_timestamp;
  Prop *IntKeys;
  UInt int_lu_keys_size;
  UInt int_lu_keys_timestamp;
  Prop *IntLUKeys;
  UInt int_bb_keys_size;
  Prop *IntBBKeys;
  Int   yap_flags_field[NUMBER_OF_YAP_FLAGS];
  char *char_conversion_table;
  char *char_conversion_table2;
#if THREADS
  unsigned int n_of_threads;      /* number of threads and processes in system */
  unsigned int n_of_threads_created;      /* number of threads created since start */
  UInt  threads_total_time;      /* total run time for dead threads */
#endif
#if defined(YAPOR) || defined(THREADS)
  lockvar  heap_used_lock;        /* protect HeapUsed */
  lockvar  heap_top_lock;        /* protect HeapTop */
  lockvar  dead_clauses_lock;        /* protect DeadClauses */
  int      heap_top_owner;
#ifdef LOW_LEVEL_TRACER
  lockvar  low_level_trace_lock;
#endif
#endif
  unsigned int size_of_overflow;
  Term  module_name[MaxModules];
  struct pred_entry *module_pred[MaxModules];
  SMALLUNSGN   no_of_modules;
  struct dead_clause *dead_clauses;
  Atom
    atom_abol,
    atom_alarm,
    atom_append,
    atom_array,
    atom_assert,
    atom_b,
    atom_break,
    atom_call,
    atom_catch,
    atom_comma,
    atom_cpu_time,
    atom_csult,
    atom_cut,
    atom_cut_by,
#ifdef EUROTRA
#ifdef SFUNC
    atom_dollar_undef,
#endif
#endif
    atom_dbref,
    atom_e,
    atom_e_q,
    atom_eof,
#ifdef EUROTRA
    atom_f_b,
#endif
    atom_fail,
    atom_false,
    atom_fast,
    atom_g_t,
    atom_gc,
    atom_gc_margin,
    atom_gc_trace,
    atom_gc_verbose,
    atom_gc_very_verbose,
    atom_global,
    atom_heap_used,
    atom_inf,
    atom_l_t,
    atom_local,
    atom_meta_call,
    atom_minus,
    atom_nan,
    atom_otherwise,
    atom_pi,
    atom_plus,
    atom_portray,
    atom_profile,
    atom_random,
    atom_read,
    atom_repeat,
    atom_restore_regs,
#if HAVE_SIGACTION
    atom_sig_pending,
#endif
    atom_stack_free,
    atom_true,
    atom_unwritable,
    atom_user,
    atom_usr_in,
    atom_usr_out,
    atom_usr_err,
    atom_version_number,
    atom_write;
  Functor
#ifdef   USE_SOCKET
    functor_af_inet,
    functor_af_local,
    functor_af_unix,
#endif
    functor_alt_not,
#ifdef COROUTINING
    functor_array_entry,
#endif
    functor_arrow,
    functor_assert,
#ifdef COROUTINING
    functor_att_goal,   /* goal that activates attributed variables */
#endif
    functor_braces,
    functor_call,
    functor_clist,
    functor_comma,
    functor_creep,
    functor_csult,
    functor_cut_by,
    functor_eq,
    functor_execute_in_mod,
    functor_execute_within,
    functor_g_atom,
    functor_g_atomic,
    functor_g_compound,
    functor_g_integer,
    functor_g_float,
    functor_g_number,
    functor_g_primitive,
    functor_g_var,
    functor_last_execute_within,
    functor_list,
    functor_module,
#ifdef MULTI_ASSIGNMENT_VARIABLES
    functor_mutable,
#endif
    functor_not,
    functor_or,
    functor_portray,
    functor_query,
    functor_stream,
    functor_stream_pos,
    functor_stream_eOS,
    functor_thread_run,
    functor_change_module,
    functor_current_module,
    functor_u_minus,
    functor_u_plus,
    functor_v_bar,
    functor_var;
  Term
#ifdef EUROTRA
    term_dollar_u,
#endif
    term_prolog,
    term_refound_var,
    user_module,
    idb_module,
    attributes_module,
    charsio_module,
    terms_module;
  void *last_wtime;
  struct pred_entry *pred_goal_expansion;
  struct pred_entry *pred_meta_call;
  struct pred_entry *pred_dollar_catch;
  struct pred_entry *pred_recorded_with_key;
  struct pred_entry *pred_log_upd_clause;
  struct pred_entry *pred_log_upd_clause0;
  struct pred_entry *pred_static_clause;
  struct pred_entry *pred_throw;
  struct pred_entry *pred_handle_throw;
  struct array_entry *dyn_array_list;
  struct DB_STRUCT *db_erased_marker;
#ifdef DEBUG
  struct logic_upd_clause *db_erased_list;
  struct logic_upd_index *db_erased_ilist;
#endif /* DEBUG */
  struct stream_desc *yap_streams;
#ifdef DEBUG
  int    debugger_output_msg;
#endif
  UInt n_of_file_aliases;
  UInt sz_of_file_aliases;
  struct AliasDescS * file_aliases;
#if LOW_PROF
  int   profiler_on;
  void *f_prof, *f_preds;
  UInt  prof_preds;
#endif /* LOW_PROF */
  struct reduction_counters call_counters;
  char *yap_lib_dir;
  Agc_hook  agc_hook;
  void *foreign_code_loaded;
  ADDR  foreign_code_base;
  ADDR  foreign_code_top;
  ADDR  foreign_code_max;
  int parser_error_style;
  int   compiler_profiling;
  int   compiler_call_counting;
  /********* whether we should try to compile array references ******************/
  int   compiler_compile_arrays;
  /*
    PREG just before we enter $spy. We use that to find out the clause which
    was calling the debugged goal.
  */
  yamop   *debugger_p_before_spy;
#if defined(YAPOR) || defined(TABLING)
  struct global_data global;
  struct local_data remote[MAX_WORKERS];
#endif /* YAPOR || TABLING */
#ifdef THREADS
  lockvar  thread_handles_lock;        /* protect ThreadManipulation */
  struct thandle thread_handle[MAX_WORKERS];
#endif
  UInt n_of_atoms;
  UInt atom_hash_table_size;
  AtomHashEntry *hash_chain;
} all_heap_codes;

#ifdef THREADS
struct various_codes *heap_regs;
#else
#define heap_regs  ((all_heap_codes *)HEAP_INIT_BASE)
#endif

#define  HeapUsed                heap_regs->heap_used
#define  HeapMax                 heap_regs->heap_max
#define  HeapTop                 heap_regs->heap_top
#define  HeapLim                 heap_regs->heap_lim
#ifdef YAPOR
#define  SEQUENTIAL_IS_DEFAULT   heap_regs->seq_def
#define  GETWORK		 (&(heap_regs->getworkcode               ))
#define  GETWORK_SEQ             (&(heap_regs->getworkcode_seq           ))
#define  GETWORK_FIRST_TIME      (&(heap_regs->getworkfirsttimecode      ))
#endif /* YAPOR */
#ifdef TABLING
#define  COMPLETION               ((yamop *)&(heap_regs->tablecompletioncode   ))
#define  ANSWER_RESOLUTION        ((yamop *)&(heap_regs->tableanswerresolutioncode ))
#endif /* TABLING */
#define  EXPAND_OP_CODE           heap_regs->expand_op_code
#define  COMMA_CODE               heap_regs->comma_code
#define  FAILCODE                 heap_regs->failcode
#define  TRUSTFAILCODE            heap_regs->trustfailcode
#define  YESCODE                  heap_regs->yescode
#define  NOCODE                   heap_regs->nocode
#define  RTRYCODE                 heap_regs->rtrycode
#define  DUMMYCODE                heap_regs->dummycode
#define  CLAUSECODE               heap_regs->clausecode
#define  INVISIBLECHAIN           heap_regs->invisiblechain
#define  max_depth                heap_regs->maxdepth
#define  max_list                 heap_regs->maxlist
#define  AtPrompt                 (&(heap_regs->atprompt    	         ))
#define  Prompt                   heap_regs->prompt
#if USE_THREADED_CODE
#define  OP_RTABLE                heap_regs->op_rtable
#endif
#define  PROFILING                heap_regs->system_profiling
#define  CALL_COUNTING            heap_regs->system_call_counting
#define  PRED_GOAL_EXPANSION_ON   heap_regs->system_pred_goal_expansion_on
#define  UPDATE_MODE              heap_regs->update_mode
#define  RETRY_C_RECORDED_CODE    heap_regs->retry_recorded_code
#define  RETRY_C_RECORDED_K_CODE  heap_regs->retry_recorded_k_code
#define  RETRY_C_RECORDEDP_CODE   heap_regs->retry_c_recordedp_code
#define  STATIC_PREDICATES_MARKED heap_regs->static_predicates_marked
#define  yap_flags                heap_regs->yap_flags_field
#define  UNDEF_OPCODE             heap_regs->undef_op
#define  INDEX_OPCODE             heap_regs->index_op
#define  FAIL_OPCODE              heap_regs->fail_op
#ifdef THREADS
#define  ThreadHandlesLock	  heap_regs->thread_handles_lock
#define  ThreadHandle		  heap_regs->thread_handle
#endif
#define  NOfAtoms                 heap_regs->n_of_atoms
#define  AtomHashTableSize        heap_regs->atom_hash_table_size
#define  HashChain                heap_regs->hash_chain
#define  INT_KEYS_SIZE            heap_regs->int_keys_size
#define  INT_KEYS_TIMESTAMP       heap_regs->int_keys_timestamp
#define  INT_KEYS                 heap_regs->IntKeys
#define  INT_LU_KEYS_SIZE         heap_regs->int_lu_keys_size
#define  INT_LU_KEYS_TIMESTAMP    heap_regs->int_lu_keys_timestamp
#define  INT_LU_KEYS              heap_regs->IntLUKeys
#define  INT_BB_KEYS_SIZE         heap_regs->int_bb_keys_size
#define  INT_BB_KEYS              heap_regs->IntBBKeys
#define  CharConversionTable      heap_regs->char_conversion_table
#define  CharConversionTable2     heap_regs->char_conversion_table2
#define  ModuleName               heap_regs->module_name
#define  ModulePred               heap_regs->module_pred
#define  NoOfModules              heap_regs->no_of_modules
#define  AtomAbol                 heap_regs->atom_abol
#define  AtomAlarm                heap_regs->atom_alarm
#define  AtomAppend               heap_regs->atom_append
#define  AtomArray                heap_regs->atom_array
#define  AtomAssert               heap_regs->atom_assert
#define  AtomB                    heap_regs->atom_b
#define  AtomBreak                heap_regs->atom_break
#define  AtomCall                 heap_regs->atom_call
#define  AtomCatch                heap_regs->atom_catch
#define  AtomComma                heap_regs->atom_comma
#define  AtomCpuTime              heap_regs->atom_cpu_time
#define  AtomCsult                heap_regs->atom_csult
#define  AtomCut                  heap_regs->atom_cut
#define  AtomCutBy                heap_regs->atom_cut_by
#if defined(EUROTRA) && defined(SFUNC)
#define  AtomDollarUndef          heap_regs->atom_dollar_undef
#endif
#define  AtomDBRef                heap_regs->atom_dbref
#define  AtomE                    heap_regs->atom_e
#define  AtomEQ                   heap_regs->atom_e_q
#define  AtomEof                  heap_regs->atom_eof
#ifdef EUROTRA
#define  AtomFB                   heap_regs->atom_f_b
#endif
#define  AtomFail                 heap_regs->atom_fail
#define  AtomFalse                heap_regs->atom_false
#define  AtomFast                 heap_regs->atom_fast
#define  AtomGT                   heap_regs->atom_g_t
#define  AtomGc                   heap_regs->atom_gc
#define  AtomGcMargin             heap_regs->atom_gc_margin
#define  AtomGcTrace              heap_regs->atom_gc_trace
#define  AtomGcVerbose            heap_regs->atom_gc_verbose
#define  AtomGcVeryVerbose        heap_regs->atom_gc_very_verbose
#define  AtomGlobal               heap_regs->atom_global
#define  AtomHeapUsed             heap_regs->atom_heap_used
#define  AtomInf                  heap_regs->atom_inf
#define  AtomLocal                heap_regs->atom_local
#define  AtomLT                   heap_regs->atom_l_t
#define  AtomMetaCall             heap_regs->atom_meta_call
#define  AtomMinus                heap_regs->atom_minus
#define  AtomNan                  heap_regs->atom_nan
#define  AtomOtherwise            heap_regs->atom_otherwise
#define  AtomPi                   heap_regs->atom_pi
#define  AtomPlus                 heap_regs->atom_plus
#define  AtomPortray              heap_regs->atom_portray
#define  AtomProfile              heap_regs->atom_profile
#define  AtomRandom               heap_regs->atom_random
#define  AtomRead                 heap_regs->atom_read
#define  AtomRepeat               heap_regs->atom_repeat
#define  AtomRestoreRegs          heap_regs->atom_restore_regs
#if HAVE_SIGACTION
#define  AtomSigPending           heap_regs->atom_sig_pending
#endif
#define  AtomStackFree            heap_regs->atom_stack_free
#define  AtomTrue                 heap_regs->atom_true
#define  AtomUser                 heap_regs->atom_user
#define  AtomUsrErr               heap_regs->atom_usr_err
#define  AtomUsrIn                heap_regs->atom_usr_in
#define  AtomUsrOut               heap_regs->atom_usr_out
#define  AtomVersionNumber        heap_regs->atom_version_number
#define  AtomWrite                heap_regs->atom_write
#ifdef   USE_SOCKET
#define  FunctorAfInet            heap_regs->functor_af_inet
#define  FunctorAfLocal           heap_regs->functor_af_local
#define  FunctorAfUnix            heap_regs->functor_af_unix
#endif
#define  FunctorAltNot            heap_regs->functor_alt_not
#ifdef COROUTINING
#define  FunctorArrayEntry        heap_regs->functor_array_entry
#endif
#define  FunctorArrow             heap_regs->functor_arrow
#define  FunctorAssert            heap_regs->functor_assert
#ifdef COROUTINING
#define  FunctorAttGoal           heap_regs->functor_att_goal
#endif
#define  FunctorBraces            heap_regs->functor_braces
#define  FunctorCall              heap_regs->functor_call
#define  FunctorClist             heap_regs->functor_clist
#define  FunctorComma             heap_regs->functor_comma
#define  FunctorCreep             heap_regs->functor_creep
#define  FunctorCsult             heap_regs->functor_csult
#define  FunctorCutBy             heap_regs->functor_cut_by
#define  FunctorEq                heap_regs->functor_eq
#define  FunctorExecuteInMod      heap_regs->functor_execute_in_mod
#define  FunctorExecuteWithin     heap_regs->functor_execute_within
#define  FunctorGAtom             heap_regs->functor_g_atom
#define  FunctorGAtomic           heap_regs->functor_g_atomic
#define  FunctorGCompound         heap_regs->functor_g_compound
#define  FunctorGFloat            heap_regs->functor_g_float
#define  FunctorGInteger          heap_regs->functor_g_integer
#define  FunctorGNumber           heap_regs->functor_g_number
#define  FunctorGPrimitive        heap_regs->functor_g_primitive
#define  FunctorGVar              heap_regs->functor_g_var
#define  FunctorLastExecuteWithin     heap_regs->functor_last_execute_within
#define  FunctorList              heap_regs->functor_list
#define  FunctorModule            heap_regs->functor_module
#ifdef MULTI_ASSIGNMENT_VARIABLES
#define  FunctorMutable           heap_regs->functor_mutable
#endif
#define  FunctorNot               heap_regs->functor_not
#define  FunctorOr                heap_regs->functor_or
#define  FunctorPortray           heap_regs->functor_portray
#define  FunctorQuery             heap_regs->functor_query
#define  FunctorStream            heap_regs->functor_stream
#define  FunctorStreamPos         heap_regs->functor_stream_pos
#define  FunctorStreamEOS         heap_regs->functor_stream_eOS
#define  FunctorThreadRun         heap_regs->functor_thread_run
#define  FunctorChangeModule      heap_regs->functor_change_module
#define  FunctorCurrentModule     heap_regs->functor_current_module
#define  FunctorModSwitch         heap_regs->functor_mod_switch
#define  FunctorUMinus            heap_regs->functor_u_minus
#define  FunctorUPlus             heap_regs->functor_u_plus
#define  FunctorVBar              heap_regs->functor_v_bar
#define  FunctorVar               heap_regs->functor_var
#define  TermDollarU              heap_regs->term_dollar_u
#define  TermProlog               heap_regs->term_prolog
#define  TermReFoundVar           heap_regs->term_refound_var
#define  PROLOG_MODULE            0
#define  USER_MODULE              heap_regs->user_module
#define  IDB_MODULE               heap_regs->idb_module
#define  ATTRIBUTES_MODULE        heap_regs->attributes_module
#define  CHARSIO_MODULE           heap_regs->charsio_module
#define  TERMS_MODULE             heap_regs->terms_module
#define  PredGoalExpansion        heap_regs->pred_goal_expansion
#define  PredMetaCall             heap_regs->pred_meta_call
#define  PredDollarCatch          heap_regs->pred_dollar_catch
#define  PredRecordedWithKey      heap_regs->pred_recorded_with_key
#define  PredLogUpdClause         heap_regs->pred_log_upd_clause
#define  PredLogUpdClause0        heap_regs->pred_log_upd_clause0
#define  PredStaticClause         heap_regs->pred_static_clause
#define  PredThrow                heap_regs->pred_throw
#define  PredHandleThrow          heap_regs->pred_handle_throw
#define  DynArrayList             heap_regs->dyn_array_list
#define  DBErasedMarker           heap_regs->db_erased_marker
#ifdef DEBUG
#define  DBErasedList             heap_regs->db_erased_list
#define  DBErasedIList            heap_regs->db_erased_ilist
#endif /* DEBUG */
#define  Stream		          heap_regs->yap_streams
#define  output_msg	          heap_regs->debugger_output_msg
#define  NOfFileAliases           heap_regs->n_of_file_aliases
#define  SzOfFileAliases          heap_regs->sz_of_file_aliases
#define  FileAliases              heap_regs->file_aliases
#if LOW_PROF
#define  ProfilerOn		  heap_regs->profiler_on
#define  FProf     		  ((FILE *)heap_regs->f_prof)
#define  FPreds     		  ((FILE *)heap_regs->f_preds)
#define  ProfPreds		  heap_regs->prof_preds
#endif /* LOW_PROF */
#define  ReductionsCounter        heap_regs->call_counters.reductions
#define  PredEntriesCounter       heap_regs->call_counters.reductions_retries
#define  RetriesCounter           heap_regs->call_counters.retries
#define  ReductionsCounterOn      heap_regs->call_counters.reductions_on
#define  PredEntriesCounterOn     heap_regs->call_counters.reductions_retries_on
#define  RetriesCounterOn         heap_regs->call_counters.retries_on
#define  Yap_LibDir               heap_regs->yap_lib_dir
#define  AGCHook                  heap_regs->agc_hook
#define  ParserErrorStyle         heap_regs->parser_error_style
#ifdef  COROUTINING
#define  WakeUpCode               heap_regs->wake_up_code
#endif
#if defined(YAPOR) || defined(THREADS)
#define  SignalLock               heap_regs->wl[worker_id].signal_lock
#define  WPP                      heap_regs->wl[worker_id].wpp
#define  ActiveSignals            heap_regs->wl[worker_id].active_signals
#define  IPredArity               heap_regs->wl[worker_id].i_pred_arity
#define  ProfEnd                  heap_regs->wl[worker_id].prof_end
#define  StartLine                heap_regs->wl[worker_id].start_line
#define  ScratchPad               heap_regs->wl[worker_id].scratchpad
#ifdef  COROUTINING
#define  WokenGoals               heap_regs->wl[worker_id].woken_goals
#define  MutableList              heap_regs->wl[worker_id].mutable_list
#define  AttsMutableList          heap_regs->wl[worker_id].atts_mutable_list
#endif
#else
#define  ActiveSignals            heap_regs->wl.active_signals
#define  IPredArity               heap_regs->wl.i_pred_arity
#define  ProfEnd                  heap_regs->wl.prof_end
#define  StartLine                heap_regs->wl.start_line
#define  ScratchPad               heap_regs->wl.scratchpad
#ifdef  COROUTINING
#define  WokenGoals               heap_regs->wl.woken_goals
#define  MutableList              heap_regs->wl.mutable_list
#define  AttsMutableList          heap_regs->wl.atts_mutable_list
#endif
#endif
#define  profiling                heap_regs->compiler_profiling
#define  call_counting            heap_regs->compiler_call_counting
#define  compile_arrays           heap_regs->compiler_compile_arrays
#define  optimizer_on             heap_regs->compiler_optimizer_on
#define  compile_mode             heap_regs->compiler_compile_mode
#define  P_before_spy             heap_regs->debugger_p_before_spy
#define  ForeignCodeBase          heap_regs->foreign_code_base;
#define  ForeignCodeTop           heap_regs->foreign_code_top;
#define  ForeignCodeMax           heap_regs->foreign_code_max;
#define  ForeignCodeLoaded        heap_regs->foreign_code_loaded
#define  ParserErrorStyle         heap_regs->parser_error_style
#define  DeadClauses              heap_regs->dead_clauses
#define  SizeOfOverflow           heap_regs->size_of_overflow
#define  LastWtimePtr             heap_regs->last_wtime
#define  BGL			  heap_regs->bgl
#define  FreeBlocks		  heap_regs->free_blocks
#if defined(YAPOR) || defined(THREADS)
#define  FreeBlocksLock           heap_regs->free_blocks_lock
#define  HeapTopLock              heap_regs->heap_top_lock
#define  HeapTopOwner             heap_regs->heap_top_owner
#define  NOfThreads               heap_regs->n_of_threads
#define  NOfThreadsCreated        heap_regs->n_of_threads_created
#define  ThreadsTotalTime         heap_regs->threads_total_time
#define  HeapUsedLock             heap_regs->heap_used_lock
#define  DeadClausesLock          heap_regs->dead_clauses_lock
#endif
#define  CreepCode                heap_regs->creep_code
#define  UndefCode                heap_regs->undef_code
#define  SpyCode                  heap_regs->spy_code
#if defined(YAPOR) || defined(TABLING)
#define  GLOBAL		          heap_regs->global
#define  REMOTE                   heap_regs->remote
#endif /* YAPOR || TABLING */

#define UPDATE_MODE_IMMEDIATE          0
#define UPDATE_MODE_LOGICAL            1
#define UPDATE_MODE_LOGICAL_ASSERT     2


#ifdef COROUTINING
#define  NUM_OF_ATTS              heap_regs->num_of_atts
#endif

/* initially allow for files with up to 1024 predicates. This number
   is extended whenever needed */
#define  InitialConsultCapacity    1024
/* current consult stack */
#define  ConsultSp                (heap_regs->consultsp                   )
/* top of consult stack  */
#define  ConsultBase              (heap_regs->consultbase                 )
/* low-water mark for consult  */
#define  ConsultLow               (heap_regs->consultlow	          )
/* current maximum number of cells in consult stack */
#define  ConsultCapacity          (heap_regs->consultcapacity             )
#if HAVE_LIBREADLINE
#define  ReadlineBuf              heap_regs->readline_buf
#define  ReadlinePos              heap_regs->readline_pos
#endif


ADDR    STD_PROTO(Yap_ExpandPreAllocCodeSpace, (UInt));
#define Yap_ReleasePreAllocCodeSpace(x)
#if defined(YAPOR) || defined(THREADS)
ADDR    STD_PROTO(Yap_InitPreAllocCodeSpace, (void));
EXTERN inline ADDR
Yap_PreAllocCodeSpace(void)
{
  ADDR ptr = ScratchPad.ptr;
  if (ptr) return ptr;
  return Yap_InitPreAllocCodeSpace();
}
#else
EXTERN inline ADDR
Yap_PreAllocCodeSpace(void)
{
  return Addr(HeapTop) + sizeof(CELL);
}
#endif

#if THREADS
Prop STD_PROTO(Yap_NewThreadPred, (PredEntry *));
Prop STD_PROTO(Yap_NewPredPropByFunctor, (Functor, Term));

EXTERN inline PredEntry *
Yap_GetThreadPred(PredEntry *ap)
{
  Functor f = ap->FunctorOfPred;
  Term  mod = ap->ModuleOfPred;
  Prop p0 = AbsPredProp(heap_regs->thread_handle[worker_id].local_preds);

  while(p0) {
    PredEntry *ap = RepPredProp(p0);
    if (ap->FunctorOfPred == f &&
	ap->ModuleOfPred == mod) return ap;
    p0 = ap->NextOfPE;
  }
  return RepPredProp(Yap_NewThreadPred(ap));
}
#endif

#endif /* HEAP_H */
