From 676dd26c901bc041ec7f80a99ed45f10d085e120 Mon Sep 17 00:00:00 2001 From: Joao Date: Tue, 10 May 2011 10:06:51 +0100 Subject: [PATCH] change macros in misc/GLOBALS to GLOBAL_. --- C/absmi.c | 4 ++-- C/agc.c | 8 ++++---- C/alloc.c | 4 ++-- C/c_interface.c | 28 +++++++++++++------------- C/dlmalloc.c | 4 ++-- C/grow.c | 16 +++++++-------- C/init.c | 10 ++++----- C/save.c | 4 ++-- C/stdpreds.c | 4 ++-- C/threads.c | 38 +++++++++++++++++------------------ H/dglobals.h | 34 +++++++++++++++---------------- H/iglobals.h | 34 +++++++++++++++---------------- H/rglobals.h | 4 ++-- library/dialect/swi/fli/swi.c | 14 ++++++------- misc/GLOBALS | 34 +++++++++++++++---------------- 15 files changed, 120 insertions(+), 120 deletions(-) diff --git a/C/absmi.c b/C/absmi.c index 3efb4e562..c73596d2b 100755 --- a/C/absmi.c +++ b/C/absmi.c @@ -7711,14 +7711,14 @@ Yap_absmi(int inp) { PredEntry *pt0; #ifdef THREADS - LOCK(Yap_ThreadHandlesLock); + LOCK(GLOBAL_ThreadHandlesLock); #endif pt0 = SpyCode; P_before_spy = PREG; PREG = pt0->CodeOfPred; /* for profiler */ #ifdef THREADS - UNLOCK(Yap_ThreadHandlesLock); + UNLOCK(GLOBAL_ThreadHandlesLock); #endif save_pc(); CACHE_A1(); diff --git a/C/agc.c b/C/agc.c index b87a1c8b9..f71d23dc9 100755 --- a/C/agc.c +++ b/C/agc.c @@ -384,7 +384,7 @@ clean_atom_list(AtomHashEntry *HashPtr) AtomEntry *at = RepAtom(atm); if (AtomResetMark(at) || at->PropsOfAE != NIL || - (Yap_AGCHook != NULL && !Yap_AGCHook(atm))) { + (GLOBAL_AGCHook != NULL && !GLOBAL_AGCHook(atm))) { patm = &(at->NextOfAE); atm = at->NextOfAE; } else { @@ -463,7 +463,7 @@ atom_gc(USES_REGS1) mark_stacks(PASS_REGS1); restore_codes(); clean_atoms(); - Yap_AGcLastCall = NOfAtoms; + GLOBAL_AGcLastCall = NOfAtoms; YAPLeaveCriticalSection(); agc_time = Yap_cputime()-time_start; tot_agc_time += agc_time; @@ -511,7 +511,7 @@ p_agc_threshold(USES_REGS1) { Term t = Deref(ARG1); if (IsVarTerm(t)) { - return Yap_unify(ARG1, MkIntegerTerm(Yap_AGcThreshold)); + return Yap_unify(ARG1, MkIntegerTerm(GLOBAL_AGcThreshold)); } else if (!IsIntegerTerm(t)) { Yap_Error(TYPE_ERROR_INTEGER,t,"prolog_flag/2 agc_margin"); return FALSE; @@ -521,7 +521,7 @@ p_agc_threshold(USES_REGS1) Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,t,"prolog_flag/2 agc_margin"); return FALSE; } else { - Yap_AGcThreshold = i; + GLOBAL_AGcThreshold = i; return TRUE; } } diff --git a/C/alloc.c b/C/alloc.c index 328ff69a9..0ef851b1e 100755 --- a/C/alloc.c +++ b/C/alloc.c @@ -703,8 +703,8 @@ AllocHeap(unsigned long int size) UNLOCK(HeapTopLock); Yap_signal(YAP_CDOVF_SIGNAL); } else { - if (size > Yap_SizeOfOverflow) - Yap_SizeOfOverflow = size*sizeof(CELL) + sizeof(YAP_SEG_SIZE); + if (size > GLOBAL_SizeOfOverflow) + GLOBAL_SizeOfOverflow = size*sizeof(CELL) + sizeof(YAP_SEG_SIZE); /* big allocations, the caller must handle the problem */ UNLOCK(HeapUsedLock); UNLOCK(HeapTopLock); diff --git a/C/c_interface.c b/C/c_interface.c index e9187c511..320de21e7 100755 --- a/C/c_interface.c +++ b/C/c_interface.c @@ -2781,9 +2781,9 @@ YAP_Init(YAP_init_args *yap_init) LOCAL_ThreadHandle.ssize = Trail+Stack; #endif #endif - Yap_AllowGlobalExpansion = TRUE; - Yap_AllowLocalExpansion = TRUE; - Yap_AllowTrailExpansion = TRUE; + GLOBAL_AllowGlobalExpansion = TRUE; + GLOBAL_AllowLocalExpansion = TRUE; + GLOBAL_AllowTrailExpansion = TRUE; Yap_InitExStacks (Trail, Stack); if (yap_init->QuietMode) { yap_flags[QUIET_MODE_FLAG] = TRUE; @@ -2849,19 +2849,19 @@ YAP_Init(YAP_init_args *yap_init) } /* make sure we do this after restore */ if (yap_init->MaxStackSize) { - Yap_AllowLocalExpansion = FALSE; + GLOBAL_AllowLocalExpansion = FALSE; } else { - Yap_AllowLocalExpansion = TRUE; + GLOBAL_AllowLocalExpansion = TRUE; } if (yap_init->MaxGlobalSize) { - Yap_AllowGlobalExpansion = FALSE; + GLOBAL_AllowGlobalExpansion = FALSE; } else { - Yap_AllowGlobalExpansion = TRUE; + GLOBAL_AllowGlobalExpansion = TRUE; } if (yap_init->MaxTrailSize) { - Yap_AllowTrailExpansion = FALSE; + GLOBAL_AllowTrailExpansion = FALSE; } else { - Yap_AllowTrailExpansion = TRUE; + GLOBAL_AllowTrailExpansion = TRUE; } if (yap_init->YapPrologRCFile) { Yap_PutValue(AtomConsultOnBoot, MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologRCFile))); @@ -3029,7 +3029,7 @@ YAP_Reset(void) } /* reinitialise the engine */ Yap_InitYaamRegs(); - Yap_Initialised = TRUE; + GLOBAL_Initialised = TRUE; RECOVER_MACHINE_REGS(); return(TRUE); @@ -3290,8 +3290,8 @@ YAP_AtomReleaseHold(Atom at) X_API Agc_hook YAP_AGCRegisterHook(Agc_hook hook) { - Agc_hook old = Yap_AGCHook; - Yap_AGCHook = hook; + Agc_hook old = GLOBAL_AGCHook; + GLOBAL_AGCHook = hook; return old; } @@ -3527,9 +3527,9 @@ YAP_SetYAPFlag(yap_flag_t flag, int val) return TRUE; case YAPC_ENABLE_AGC: if (val) { - Yap_AGcThreshold = 10000; + GLOBAL_AGcThreshold = 10000; } else { - Yap_AGcThreshold = 0; + GLOBAL_AGcThreshold = 0; } return TRUE; default: diff --git a/C/dlmalloc.c b/C/dlmalloc.c index 9c7942831..9ec17147b 100755 --- a/C/dlmalloc.c +++ b/C/dlmalloc.c @@ -212,8 +212,8 @@ yapsbrk(long size) UNLOCK(HeapTopLock); Yap_signal(YAP_CDOVF_SIGNAL); } else { - if (size > Yap_SizeOfOverflow) - Yap_SizeOfOverflow = size; + if (size > GLOBAL_SizeOfOverflow) + GLOBAL_SizeOfOverflow = size; /* big allocations, the caller must handle the problem */ UNLOCK(HeapUsedLock); UNLOCK(HeapTopLock); diff --git a/C/grow.c b/C/grow.c index 081074555..636ca75a6 100755 --- a/C/grow.c +++ b/C/grow.c @@ -903,12 +903,12 @@ static_growglobal(long request, CELL **ptr, CELL *hsplit USES_REGS) Yap_PrologMode |= GrowStackMode; start_growth_time = Yap_cputime(); if (do_grow) { - if (!Yap_AllowGlobalExpansion) { + if (!GLOBAL_AllowGlobalExpansion) { Yap_ErrorMessage = "Global Stack crashed against Local Stack"; LeaveGrowMode(GrowStackMode); return 0; } - if (!Yap_AllowGlobalExpansion || !Yap_ExtendWorkSpace(size)) { + if (!GLOBAL_AllowGlobalExpansion || !Yap_ExtendWorkSpace(size)) { /* always fails when using malloc */ Yap_ErrorMessage = NULL; size += AdjustPageSize(((CELL)Yap_TrailTop-(CELL)Yap_GlobalBase)+MinHeapGap); @@ -1256,10 +1256,10 @@ do_growheap(int fix_code, UInt in_size, struct intermediates *cip, tr_fr_ptr *ol Yap_Error(OUT_OF_HEAP_ERROR,TermNil,"cannot grow Heap: more than a worker/thread running"); return FALSE; #endif - if (Yap_SizeOfOverflow > sz) { + if (GLOBAL_SizeOfOverflow > sz) { if (size < YAP_ALLOC_SIZE) size = YAP_ALLOC_SIZE; - sz = AdjustPageSize(Yap_SizeOfOverflow); + sz = AdjustPageSize(GLOBAL_SizeOfOverflow); } while(sz >= sizeof(CELL) * K16 && !static_growheap(sz, fix_code, cip, old_trp, tksp, vep PASS_REGS)) { size = size/2; @@ -1401,7 +1401,7 @@ Yap_growheap(int fix_code, UInt in_size, void *cip) if (NOfAtoms > 2*AtomHashTableSize) { UInt n = NOfAtoms; - if (Yap_AGcThreshold) + if (GLOBAL_AGcThreshold) Yap_atom_gc( PASS_REGS1 ); /* check if we have a significant improvement from agc */ if (n > NOfAtoms+ NOfAtoms/10 || @@ -1447,7 +1447,7 @@ Yap_growglobal(CELL **ptr) return(FALSE); } #elif defined(THREADS) - if (Yap_NOfThreads != 1) { + if (GLOBAL_NOfThreads != 1) { Yap_Error(OUT_OF_STACK_ERROR,TermNil,"cannot grow Global: more than a worker/thread running"); return(FALSE); } @@ -1493,7 +1493,7 @@ execute_growstack(long size0, int from_trail, int in_parser, tr_fr_ptr *old_trp, long size = size0; ADDR old_Yap_GlobalBase = Yap_GlobalBase; - if (!Yap_AllowGlobalExpansion) { + if (!GLOBAL_AllowGlobalExpansion) { Yap_ErrorMessage = "Database crashed against stacks"; return FALSE; } @@ -1703,7 +1703,7 @@ static int do_growtrail(long size, int contiguous_only, int in_parser, tr_fr_ptr fprintf(Yap_stderr, "%% growing the trail %ld bytes\n", size); } Yap_ErrorMessage = NULL; - if (!Yap_AllowTrailExpansion) { + if (!GLOBAL_AllowTrailExpansion) { Yap_ErrorMessage = "Trail Overflow"; return FALSE; } diff --git a/C/init.c b/C/init.c index 6bf9cb030..7eb00a8b6 100755 --- a/C/init.c +++ b/C/init.c @@ -1447,17 +1447,17 @@ Yap_HaltRegisterHook (HaltHookFunc f, void * env) return FALSE; h->environment = env; h->hook = f; - LOCK(Yap_BGL); - h->next = Yap_HaltHooks; - Yap_HaltHooks = h; - UNLOCK(Yap_BGL); + LOCK(GLOBAL_BGL); + h->next = GLOBAL_HaltHooks; + GLOBAL_HaltHooks = h; + UNLOCK(GLOBAL_BGL); return TRUE; } static void run_halt_hooks(int code) { - struct halt_hook *hooke = Yap_HaltHooks; + struct halt_hook *hooke = GLOBAL_HaltHooks; while (hooke) { hooke->hook(code, hooke->environment); diff --git a/C/save.c b/C/save.c index f979f2562..1130ea34a 100755 --- a/C/save.c +++ b/C/save.c @@ -623,7 +623,7 @@ p_save2( USES_REGS1 ) } #endif /* YAPOR */ #ifdef THREADS - if (Yap_NOfThreads != 1) { + if (GLOBAL_NOfThreads != 1) { Yap_Error(SYSTEM_ERROR,TermNil, "cannot perform save: more than a worker/thread running"); return(FALSE); @@ -1802,7 +1802,7 @@ p_restore( USES_REGS1 ) } #endif /* YAPOR */ #ifdef THREADS - if (Yap_NOfThreads != 1) { + if (GLOBAL_NOfThreads != 1) { Yap_Error(SYSTEM_ERROR,TermNil,"cannot perform save: more than a worker/thread running"); return(FALSE); } diff --git a/C/stdpreds.c b/C/stdpreds.c index 05bec5e63..0a22ff7df 100755 --- a/C/stdpreds.c +++ b/C/stdpreds.c @@ -3913,14 +3913,14 @@ p_system_mode( USES_REGS1 ) static Int p_lock_system( USES_REGS1 ) { - LOCK(Yap_BGL); + LOCK(GLOBAL_BGL); return TRUE; } static Int p_unlock_system( USES_REGS1 ) { - UNLOCK(Yap_BGL); + UNLOCK(GLOBAL_BGL); return TRUE; } diff --git a/C/threads.c b/C/threads.c index 54669a266..1acbb645a 100755 --- a/C/threads.c +++ b/C/threads.c @@ -50,7 +50,7 @@ static int allocate_new_tid(void) { int new_worker_id = 0; - LOCK(Yap_ThreadHandlesLock); + LOCK(GLOBAL_ThreadHandlesLock); while(new_worker_id < MAX_THREADS && Yap_local[new_worker_id] && (REMOTE_ThreadHandle(new_worker_id).in_use == TRUE || @@ -72,7 +72,7 @@ allocate_new_tid(void) } else { new_worker_id = -1; } - UNLOCK(Yap_ThreadHandlesLock); + UNLOCK(GLOBAL_ThreadHandlesLock); return new_worker_id; } @@ -146,7 +146,7 @@ kill_thread_engine (int wid, int always_die) free(REMOTE_ThreadHandle(wid).start_of_timesp); free(REMOTE_ThreadHandle(wid).last_timep); Yap_FreeCodeSpace((ADDR)REMOTE_ThreadHandle(wid).texit); - LOCK(Yap_ThreadHandlesLock); + LOCK(GLOBAL_ThreadHandlesLock); if (REMOTE_ThreadHandle(wid).tdetach == MkAtomTerm(AtomTrue) || always_die) { REMOTE_ThreadHandle(wid).zombie = FALSE; @@ -154,7 +154,7 @@ kill_thread_engine (int wid, int always_die) DEBUG_TLOCK_ACCESS(1, wid); pthread_mutex_unlock(&(REMOTE_ThreadHandle(wid).tlock)); } - UNLOCK(Yap_ThreadHandlesLock); + UNLOCK(GLOBAL_ThreadHandlesLock); } static void @@ -162,7 +162,7 @@ thread_die(int wid, int always_die) { if (!always_die) { /* called by thread itself */ - Yap_ThreadsTotalTime += Yap_cputime(); + GLOBAL_ThreadsTotalTime += Yap_cputime(); } kill_thread_engine(wid, always_die); } @@ -188,7 +188,7 @@ setup_engine(int myworker_id, int init_thread) Yap_InitYaamRegs(); Yap_ReleasePreAllocCodeSpace(Yap_PreAllocCodeSpace()); /* I exist */ - Yap_NOfThreadsCreated++; + GLOBAL_NOfThreadsCreated++; DEBUG_TLOCK_ACCESS(2, myworker_id); pthread_mutex_unlock(&(REMOTE_ThreadHandle(myworker_id).tlock)); } @@ -481,17 +481,17 @@ p_thread_join( USES_REGS1 ) { Int tid = IntegerOfTerm(Deref(ARG1)); - LOCK(Yap_ThreadHandlesLock); + LOCK(GLOBAL_ThreadHandlesLock); if (!REMOTE_ThreadHandle(tid).in_use && !REMOTE_ThreadHandle(tid).zombie) { - UNLOCK(Yap_ThreadHandlesLock); + UNLOCK(GLOBAL_ThreadHandlesLock); return FALSE; } if (!REMOTE_ThreadHandle(tid).tdetach == MkAtomTerm(AtomTrue)) { - UNLOCK(Yap_ThreadHandlesLock); + UNLOCK(GLOBAL_ThreadHandlesLock); return FALSE; } - UNLOCK(Yap_ThreadHandlesLock); + UNLOCK(GLOBAL_ThreadHandlesLock); /* make sure this lock is accessible */ if (pthread_join(REMOTE_ThreadHandle(tid).pthread_handle, NULL) < 0) { /* ERROR */ @@ -506,12 +506,12 @@ p_thread_destroy( USES_REGS1 ) { Int tid = IntegerOfTerm(Deref(ARG1)); - LOCK(Yap_ThreadHandlesLock); + LOCK(GLOBAL_ThreadHandlesLock); REMOTE_ThreadHandle(tid).zombie = FALSE; REMOTE_ThreadHandle(tid).in_use = FALSE; DEBUG_TLOCK_ACCESS(32, tid); pthread_mutex_unlock(&(REMOTE_ThreadHandle(tid).tlock)); - UNLOCK(Yap_ThreadHandlesLock); + UNLOCK(GLOBAL_ThreadHandlesLock); return TRUE; } @@ -747,16 +747,16 @@ p_thread_stacks( USES_REGS1 ) Int tid = IntegerOfTerm(Deref(ARG1)); Int status= TRUE; - LOCK(Yap_ThreadHandlesLock); + LOCK(GLOBAL_ThreadHandlesLock); if (!REMOTE_ThreadHandle(tid).in_use && !REMOTE_ThreadHandle(tid).zombie) { - UNLOCK(Yap_ThreadHandlesLock); + UNLOCK(GLOBAL_ThreadHandlesLock); return FALSE; } status &= Yap_unify(ARG2,MkIntegerTerm(REMOTE_ThreadHandle(tid).ssize)); status &= Yap_unify(ARG3,MkIntegerTerm(REMOTE_ThreadHandle(tid).tsize)); status &= Yap_unify(ARG4,MkIntegerTerm(REMOTE_ThreadHandle(tid).sysize)); - UNLOCK(Yap_ThreadHandlesLock); + UNLOCK(GLOBAL_ThreadHandlesLock); return status; } @@ -828,13 +828,13 @@ static Int p_nof_threads( USES_REGS1 ) { /* '$nof_threads'(+P) */ int i = 0, wid; - LOCK(Yap_ThreadHandlesLock); + LOCK(GLOBAL_ThreadHandlesLock); for (wid = 0; wid < MAX_THREADS; wid++) { if (!Yap_local[wid]) break; if (REMOTE_ThreadHandle(wid).in_use) i++; } - UNLOCK(Yap_ThreadHandlesLock); + UNLOCK(GLOBAL_ThreadHandlesLock); return Yap_unify(ARG1,MkIntegerTerm(i)); } @@ -853,13 +853,13 @@ p_max_threads( USES_REGS1 ) static Int p_nof_threads_created( USES_REGS1 ) { /* '$nof_threads'(+P) */ - return Yap_unify(ARG1,MkIntTerm(Yap_NOfThreadsCreated)); + return Yap_unify(ARG1,MkIntTerm(GLOBAL_NOfThreadsCreated)); } static Int p_thread_runtime( USES_REGS1 ) { /* '$thread_runtime'(+P) */ - return Yap_unify(ARG1,MkIntegerTerm(Yap_ThreadsTotalTime)); + return Yap_unify(ARG1,MkIntegerTerm(GLOBAL_ThreadsTotalTime)); } static Int diff --git a/H/dglobals.h b/H/dglobals.h index 804318466..c3b5a7d07 100644 --- a/H/dglobals.h +++ b/H/dglobals.h @@ -21,39 +21,39 @@ -#define Yap_Initialised Yap_global->initialised -#define Yap_InitialisedFromPL Yap_global->initialised_from_pl -#define Yap_PL_Argc Yap_global->pl_argc -#define Yap_PL_Argv Yap_global->pl_argv +#define GLOBAL_Initialised Yap_global->initialised +#define GLOBAL_InitialisedFromPL Yap_global->initialised_from_pl +#define GLOBAL_PL_Argc Yap_global->pl_argc +#define GLOBAL_PL_Argv Yap_global->pl_argv -#define Yap_HaltHooks Yap_global->yap_halt_hook +#define GLOBAL_HaltHooks Yap_global->yap_halt_hook -#define Yap_AllowLocalExpansion Yap_global->allow_local_expansion -#define Yap_AllowGlobalExpansion Yap_global->allow_global_expansion -#define Yap_AllowTrailExpansion Yap_global->allow_trail_expansion -#define Yap_SizeOfOverflow Yap_global->size_of_overflow +#define GLOBAL_AllowLocalExpansion Yap_global->allow_local_expansion +#define GLOBAL_AllowGlobalExpansion Yap_global->allow_global_expansion +#define GLOBAL_AllowTrailExpansion Yap_global->allow_trail_expansion +#define GLOBAL_SizeOfOverflow Yap_global->size_of_overflow -#define Yap_AGcLastCall Yap_global->agc_last_call +#define GLOBAL_AGcLastCall Yap_global->agc_last_call -#define Yap_AGcThreshold Yap_global->agc_threshold -#define Yap_AGCHook Yap_global->agc_hook +#define GLOBAL_AGcThreshold Yap_global->agc_threshold +#define GLOBAL_AGCHook Yap_global->agc_hook #if THREADS -#define Yap_NOfThreads Yap_global->n_of_threads +#define GLOBAL_NOfThreads Yap_global->n_of_threads -#define Yap_NOfThreadsCreated Yap_global->n_of_threads_created +#define GLOBAL_NOfThreadsCreated Yap_global->n_of_threads_created -#define Yap_ThreadsTotalTime Yap_global->threads_total_time +#define GLOBAL_ThreadsTotalTime Yap_global->threads_total_time #endif #if defined(YAPOR) || defined(THREADS) -#define Yap_BGL Yap_global->bgl +#define GLOBAL_BGL Yap_global->bgl #endif #ifdef THREADS -#define Yap_ThreadHandlesLock Yap_global->thread_handles_lock +#define GLOBAL_ThreadHandlesLock Yap_global->thread_handles_lock #endif #if defined(YAPOR) || defined(TABLING) #define Yap_optyap_data Yap_global->optyap_data diff --git a/H/iglobals.h b/H/iglobals.h index a0a3af909..df32d43e2 100644 --- a/H/iglobals.h +++ b/H/iglobals.h @@ -21,39 +21,39 @@ static void InitGlobal(void) { - Yap_Initialised = FALSE; - Yap_InitialisedFromPL = FALSE; - Yap_PL_Argc = 0; - Yap_PL_Argv = NULL; + GLOBAL_Initialised = FALSE; + GLOBAL_InitialisedFromPL = FALSE; + GLOBAL_PL_Argc = 0; + GLOBAL_PL_Argv = NULL; - Yap_HaltHooks = NULL; + GLOBAL_HaltHooks = NULL; - Yap_AllowLocalExpansion = TRUE; - Yap_AllowGlobalExpansion = TRUE; - Yap_AllowTrailExpansion = TRUE; - Yap_SizeOfOverflow = 0; + GLOBAL_AllowLocalExpansion = TRUE; + GLOBAL_AllowGlobalExpansion = TRUE; + GLOBAL_AllowTrailExpansion = TRUE; + GLOBAL_SizeOfOverflow = 0; - Yap_AGcLastCall = 0; + GLOBAL_AGcLastCall = 0; - Yap_AGcThreshold = 10000; - Yap_AGCHook = NULL; + GLOBAL_AGcThreshold = 10000; + GLOBAL_AGCHook = NULL; #if THREADS - Yap_NOfThreads = 1; + GLOBAL_NOfThreads = 1; - Yap_NOfThreadsCreated = 1; + GLOBAL_NOfThreadsCreated = 1; - Yap_ThreadsTotalTime = 0L; + GLOBAL_ThreadsTotalTime = 0L; #endif #if defined(YAPOR) || defined(THREADS) - INIT_LOCK(Yap_BGL); + INIT_LOCK(GLOBAL_BGL); #endif #ifdef THREADS - INIT_LOCK(Yap_ThreadHandlesLock); + INIT_LOCK(GLOBAL_ThreadHandlesLock); #endif #if defined(YAPOR) || defined(TABLING) diff --git a/H/rglobals.h b/H/rglobals.h index f6963dbb0..054db7250 100644 --- a/H/rglobals.h +++ b/H/rglobals.h @@ -49,11 +49,11 @@ static void RestoreGlobal(void) { #if defined(YAPOR) || defined(THREADS) - REINIT_LOCK(Yap_BGL); + REINIT_LOCK(GLOBAL_BGL); #endif #ifdef THREADS - REINIT_LOCK(Yap_ThreadHandlesLock); + REINIT_LOCK(GLOBAL_ThreadHandlesLock); #endif #if defined(YAPOR) || defined(TABLING) diff --git a/library/dialect/swi/fli/swi.c b/library/dialect/swi/fli/swi.c index d6076378f..e6e1e0e2c 100755 --- a/library/dialect/swi/fli/swi.c +++ b/library/dialect/swi/fli/swi.c @@ -1988,22 +1988,22 @@ PL_initialise(int myargc, char **myargv) init_args.SchedulerLoop = 10; init_args.DelayedReleaseLoad = 3; - Yap_PL_Argc = myargc; - Yap_PL_Argv = myargv; - Yap_InitialisedFromPL = TRUE; + GLOBAL_PL_Argc = myargc; + GLOBAL_PL_Argv = myargv; + GLOBAL_InitialisedFromPL = TRUE; return YAP_Init(&init_args) != YAP_BOOT_ERROR; } X_API int PL_is_initialised(int *argcp, char ***argvp) { - if (Yap_InitialisedFromPL) { + if (GLOBAL_InitialisedFromPL) { if (argcp) - *argcp = Yap_PL_Argc; + *argcp = GLOBAL_PL_Argc; if (argvp) - *argvp = Yap_PL_Argv; + *argvp = GLOBAL_PL_Argv; } - return Yap_InitialisedFromPL; + return GLOBAL_InitialisedFromPL; } X_API module_t diff --git a/misc/GLOBALS b/misc/GLOBALS index a3085797c..d6f0289c1 100644 --- a/misc/GLOBALS +++ b/misc/GLOBALS @@ -19,44 +19,44 @@ START_GLOBAL_DATA // initialization: tell whether the system has been initialised and by whom. -int initialised Yap_Initialised =FALSE -int initialised_from_pl Yap_InitialisedFromPL =FALSE -int pl_argc Yap_PL_Argc =0 -char **pl_argv Yap_PL_Argv =NULL +int initialised GLOBAL_Initialised =FALSE +int initialised_from_pl GLOBAL_InitialisedFromPL =FALSE +int pl_argc GLOBAL_PL_Argc =0 +char **pl_argv GLOBAL_PL_Argv =NULL // halt hooks -struct halt_hook *yap_halt_hook Yap_HaltHooks =NULL +struct halt_hook *yap_halt_hook GLOBAL_HaltHooks =NULL // stack overflow expansion/gc control -int allow_local_expansion Yap_AllowLocalExpansion =TRUE -int allow_global_expansion Yap_AllowGlobalExpansion =TRUE -int allow_trail_expansion Yap_AllowTrailExpansion =TRUE -UInt size_of_overflow Yap_SizeOfOverflow =0 +int allow_local_expansion GLOBAL_AllowLocalExpansion =TRUE +int allow_global_expansion GLOBAL_AllowGlobalExpansion =TRUE +int allow_trail_expansion GLOBAL_AllowTrailExpansion =TRUE +UInt size_of_overflow GLOBAL_SizeOfOverflow =0 // amount of space recovered in all garbage collections -UInt agc_last_call Yap_AGcLastCall =0 +UInt agc_last_call GLOBAL_AGcLastCall =0 // amount of space recovered in all garbage collections -UInt agc_threshold Yap_AGcThreshold =10000 -Agc_hook agc_hook Yap_AGCHook =NULL +UInt agc_threshold GLOBAL_AGcThreshold =10000 +Agc_hook agc_hook GLOBAL_AGCHook =NULL /* multi-thread support */ #if THREADS /* number of threads and processes in system */ -UInt n_of_threads Yap_NOfThreads =1 +UInt n_of_threads GLOBAL_NOfThreads =1 /* number of threads created since start */ -UInt n_of_threads_created Yap_NOfThreadsCreated =1 +UInt n_of_threads_created GLOBAL_NOfThreadsCreated =1 /* total run time for dead threads */ -UInt threads_total_time Yap_ThreadsTotalTime =0L +UInt threads_total_time GLOBAL_ThreadsTotalTime =0L #endif // multi-thread/ORP support #if defined(YAPOR) || defined(THREADS) // protect long critical regions -lockvar bgl Yap_BGL MkLock +lockvar bgl GLOBAL_BGL MkLock #endif // Threads Array #ifdef THREADS -lockvar thread_handles_lock Yap_ThreadHandlesLock MkLock +lockvar thread_handles_lock GLOBAL_ThreadHandlesLock MkLock #endif #if defined(YAPOR) || defined(TABLING)