diff -ruN klic-3.003-2002-03-11b/include/klic/g_basic.h klic-3.003-2002-03-11c/include/klic/g_basic.h
--- klic-3.003-2002-03-11b/include/klic/g_basic.h	Mon Mar 11 16:05:27 2002
+++ klic-3.003-2002-03-11c/include/klic/g_basic.h	Mon Mar 11 17:04:06 2002
@@ -58,10 +58,7 @@
  */
 #define G_HEAPALLOC(from,size,type) \
 do{ \
-  assert(g_allocp == heapp()); \
-  (from) = type(g_allocp); \
-  g_allocp += (size); \
-  set_heapp(g_allocp); \
+  (from) = type(klic_alloc(size)); \
 }while(0)
 
 
@@ -78,13 +75,9 @@
     heaplimit = 0; \
     (res) = GENERIC_GCREQUEST; \
   } else { \
-    set_heapp(g_allocp); \
     G_HEAPALLOC((from), (size), type); \
-    assert(g_allocp == heapp()); \
     (res) = GENERIC_SUCCEEDED; \
   } \
-  assert((res)==GENERIC_GCREQUEST || \
-        ((res)==GENERIC_SUCCEEDED && g_allocp == heapp()) ); \
 }while(0)
 
 
@@ -93,9 +86,7 @@
  */
 #define G_MAKE_VAR(x) \
 do{ \
-  set_heapp(g_allocp); \
   G_HEAPALLOC((x), 1, (q)); \
-  assert(g_allocp == heapp()); \
   derefone(x) = (x); \
 }while(0)
 
diff -ruN klic-3.003-2002-03-11b/include/klic/gc_macro.h klic-3.003-2002-03-11c/include/klic/gc_macro.h
--- klic-3.003-2002-03-11b/include/klic/gc_macro.h	Mon Mar 11 16:14:57 2002
+++ klic-3.003-2002-03-11c/include/klic/gc_macro.h	Mon Mar 11 17:06:46 2002
@@ -46,7 +46,6 @@
 do{ \
   set_method_result(GC_SUCCEEDED); \
   set_rest_of_stream(x); \
-  set_heapp(g_allocp); \
   return; \
 }while(0)
 
@@ -54,7 +53,6 @@
 do{ \
   set_method_result(GC_SUCCEEDED); \
   set_rest_of_stream(NULL); \
-  set_heapp(g_allocp); \
   return; \
 }while(0)
 
@@ -64,16 +62,12 @@
   q argv[2]; \
   set_method_result(GC_SUCCEEDED); \
   G_MAKE_VAR(newvar); \
-  assert(g_allocp == heapp()); \
   set_rest_of_stream(newvar); \
   argv[0] = GC_TERM; \
   argv[1] = newvar; \
-  set_heapp(g_allocp); \
   tmp = GC_wakeup_g_new(2, argv); \
-  g_allocp = heapp(); \
   GC_KL1_UNIFY((var), tmp); \
-  assert(g_allocp == heapp()); \
-  return g_allocp; \
+  return heapp(); \
 }while(0)
 
 /**************************************************/
@@ -107,26 +101,21 @@
 #define GC_TRY_TO_ALLOC(new, type, size, gc_request) \
 do{ \
   q res; \
-  assert(g_allocp==heapp()); \
   G_HEAPALLOC_WITH_CHECK((new), (size), type, res); \
-  assert(g_allocp == heapp()); \
   if (GC_GCREQUEST == res) goto gc_request; \
 }while(0)
 
 
 #define GC_UNIFY(x,y) \
-  (assert(g_allocp==heapp()), do_shallow_unify((x), (y)), g_allocp = heapp())
+  (do_shallow_unify((x), (y)))
 
 #define GC_UNIFY_VALUE(x, y)					\
 do{								\
-  assert(g_allocp == heapp()); \
   if (!isref(x) || derefone(x) != (x)) {			\
     do_shallow_unify_value((x), (y));	\
-    g_allocp = heapp(); \
   } else {							\
     derefone(x) = (y);						\
   }								\
-  assert(g_allocp == heapp()); \
 }while(0)
 
 /**************************************************************************/
@@ -153,10 +142,8 @@
 	if(isref(temp0) && (x) == derefone(temp0)) { \
           q var; \
           struct goalrec *goal; \
-          set_heapp(g_allocp); \
 	  G_MAKE_THE_NEW_GOAL(&var, &goal, g_myself, GC_ARGC, GC_ARGV); \
           G_SUSPEND((x), goal); \
-          g_allocp = heapp(); \
           GC_RETURN_FROM_NEW(var); \
 	} else { \
 	  (x) = temp0; \
@@ -172,14 +159,11 @@
 #define GCSET_NEWOBJ_FOR_NEW(newgobj,size) \
 do{ \
   q res; \
-  assert(g_allocp == heapp()); \
   G_HEAPALLOC_WITH_CHECK((newgobj), (size), (GC_OBJ_TYPE*), res); \
-  assert(g_allocp == heapp()); \
   if(GC_GCREQUEST == res){ \
     q var; \
     struct goalrec *goal; \
     G_MAKE_THE_NEW_GOAL(&var, &goal, g_myself, GC_ARGC, GC_ARGV); \
-    g_allocp = heapp(); \
     G_PUSH_GOAL_TO_SPECIAL_QUEUE(goal); \
     GC_RETURN_FROM_NEW(var); \
   } \
@@ -188,7 +172,6 @@
 
 #define GC_RETURN_FROM_NEW(x) \
 do{ \
-  set_heapp(g_allocp); \
   return (x); \
 }while(0)
 
@@ -299,14 +282,11 @@
 #define GC_KL1_UNIFY(x, y) \
 do{ \
   struct goalrec *gp; \
-  set_heapp(g_allocp); \
   G_HEAPALLOC(gp, 4, (struct goalrec *)); \
-  assert(g_allocp == heapp()); \
   gp->pred = &predicate_unify__term__dcode_xunify__goal_2; \
   gp->args[0] = (x); \
   gp->args[1] = (y); \
   resume_same_prio(gp); \
-  assert(g_allocp == heapp()); \
 }while(0)
 
 #endif /* _KLIC_GC_MACRO_H_ */
diff -ruN klic-3.003-2002-03-11b/include/klic/gd_macro.h klic-3.003-2002-03-11c/include/klic/gd_macro.h
--- klic-3.003-2002-03-11b/include/klic/gd_macro.h	Mon Mar 11 16:16:07 2002
+++ klic-3.003-2002-03-11c/include/klic/gd_macro.h	Mon Mar 11 17:41:07 2002
@@ -55,7 +55,7 @@
 #define GD_ERROR_IN_METHOD(errmsg, methodname) \
   G_error((errmsg), (methodname), "data", GD_CLASS_NAME_STRING)
 
-#define GD_RETURN  do{ return g_allocp; }while(0)
+#define GD_RETURN  do{ return heapp(); }while(0)
 #define GD_GCREQUEST GENERIC_GCREQUEST
 
 #define GD_GSUCCESS  ((long) GENERIC_SUCCEEDED)
@@ -71,14 +71,11 @@
 #define GD_ALLOC_AREA(new,type,size) \
 do{ \
   q res; \
-  assert(g_allocp == heapp()); \
   G_HEAPALLOC_WITH_CHECK((new), (size), type, res); \
-  assert(g_allocp == heapp()); \
   if(GD_GCREQUEST == res){ \
     struct goalrec *goal; \
     GD_MAKE_GENERIC_GOAL(&goal, makefunctor(GD_SELF), g_method_functor, \
 			   GD_ARGV); \
-    g_allocp = heapp(); \
     G_PUSH_GOAL(goal); \
     GD_RETURN; \
   } \
@@ -87,16 +84,12 @@
 #define GD_ALLOC_AREA_FOR_NEW(new,type,size) \
 do{ \
   q res; \
-  assert(g_allocp == heapp()); \
   G_HEAPALLOC_WITH_CHECK((new), (size), type, res); \
-  assert(g_allocp == heapp()); \
   if(GD_GCREQUEST == res){ \
     q var; \
     struct goalrec *goal; \
     G_MAKE_THE_NEW_GOAL(&var, &goal, g_myself, GD_ARGC, GD_ARGV); \
-    g_allocp = heapp(); \
     G_PUSH_GOAL_TO_SPECIAL_QUEUE(goal); \
-    assert(g_allocp == heapp()); \
     GD_SUSPEND_NEW(var); \
   } \
 }while(0)
@@ -106,16 +99,12 @@
 #define GDSET_NEWOBJ_FOR_NEW(newgobj,size) \
 do{ \
   q res; \
-  assert(g_allocp == heapp()); \
   G_HEAPALLOC_WITH_CHECK((newgobj), (size), (GD_OBJ_TYPE*), res); \
-  assert(g_allocp == heapp()); \
   if(GENERIC_GCREQUEST == res){ \
     q var; \
     struct goalrec *goal; \
     G_MAKE_THE_NEW_GOAL(&var, &goal, g_myself, GD_ARGC, GD_ARGV); \
-    g_allocp = heapp(); \
     G_PUSH_GOAL_TO_SPECIAL_QUEUE(goal); \
-    assert(g_allocp == heapp()); \
     GD_SUSPEND_NEW(var); \
   } \
   (newgobj)->method_table = &GD_method_table; \
@@ -124,15 +113,12 @@
 #define GDSET_NEWOBJ(newgobj) \
 do{ \
   q res; \
-  assert(g_allocp == heapp()); \
   G_HEAPALLOC_WITH_CHECK((newgobj), GD_OBJ_SIZE(GD_SELF), \
 			 (GD_OBJ_TYPE*), res); \
-  assert(g_allocp == heapp()); \
   if (GD_GCREQUEST == res) { \
     struct goalrec *goal; \
     GD_MAKE_GENERIC_GOAL(&goal, makefunctor(GD_SELF), \
 			   g_method_functor, GD_ARGV ); \
-    g_allocp = heapp(); \
     G_PUSH_GOAL(goal); \
     GD_RETURN; \
   } \
@@ -178,11 +164,9 @@
 	q temp0 = derefone(x); \
 	if(isref(temp0) && (x) == derefone(temp0)) { \
           struct goalrec *goal; \
-          set_heapp(g_allocp); \
 	  GD_MAKE_GENERIC_GOAL(&goal, makefunctor(GD_SELF), \
 				 g_method_functor, GD_ARGV ); \
           G_SUSPEND((x), goal); \
-          g_allocp = heapp(); \
           GD_RETURN; \
 	} else { \
 	  (x) = temp0; \
@@ -207,10 +191,8 @@
 	if(isref(temp0) && (x) == derefone(temp0)) { \
           q var; \
           struct goalrec *goal; \
-          set_heapp(g_allocp); \
 	  G_MAKE_THE_NEW_GOAL(&var, &goal, g_myself, GD_ARGC, GD_ARGV); \
           G_SUSPEND((x), goal); \
-          g_allocp = heapp(); \
           GD_SUSPEND_NEW(var); \
 	} else { \
 	  (x) = temp0; \
@@ -229,13 +211,11 @@
 
 #define GD_SUSPEND_NEW(v) \
 do{ \
-  assert(g_allocp == heapp()); \
   return (v); \
 }while(0)
 
 #define GD_RETURN_FROM_NEW(x) \
 do{ \
-  assert(g_allocp == heapp()); \
   return makefunctor(x); \
 }while(0)
 
@@ -251,17 +231,13 @@
 
 #define GD_UNIFY(x,y) \
 do{ \
-  assert(g_allocp == heapp()); \
   do_shallow_unify((x), (y)); \
-  g_allocp = heapp(); \
 }while(0)
 
 #define GD_UNIFY_VALUE(x,y) \
 do{								\
   if (!isref(x) || derefone(x) != (x)) {			\
-    set_heapp(g_allocp); \
     do_shallow_unify_value((x), (y));	\
-    g_allocp = heapp(); \
   } else {							\
     derefone(x) = (y);						\
   }								\
@@ -276,7 +252,7 @@
 
 #define GD_METHOD_CASE(fa) \
    case (long) G_functor(fa): \
-  g_allocp = GD_body(fa) (GD_SELF,g_method_functor,GD_ARGV,g_allocp); \
+  GD_body(fa) (GD_SELF, g_method_functor, GD_ARGV); \
   break
 
 #define GD_METHOD_CASE_DEFAULT \
@@ -287,19 +263,14 @@
 
 #define GD_METHOD_NAME_CASE(sym) \
  case ((long)(G_atom(sym))) : \
-  g_allocp = GD_body(sym)(GD_SELF, g_method_functor, \
-					GD_ARGV, g_allocp); \
+  GD_body(sym)(GD_SELF, g_method_functor, GD_ARGV); \
   break
 
 #define GD_METHOD_NAME_CASE_DEFAULT default: fatal("undefined method")
 
 #define GDDEF_METHOD(fa) \
-  static q * \
-  GD_body(fa) (GD_SELF,g_method_functor,GD_ARGV,g_allocp) \
-    GD_OBJ_TYPE * GD_SELF; \
-    long g_method_functor; \
-    q GD_ARGV[]; \
-    q *g_allocp;
+static void \
+GD_body(fa) (GD_OBJ_TYPE* GD_SELF, long g_method_functor, q* GD_ARGV)
 
 /**********************************************************************/
 #define GDDEF_GUNIFY() \
diff -ruN klic-3.003-2002-03-11b/include/klic/gg_macro.h klic-3.003-2002-03-11c/include/klic/gg_macro.h
--- klic-3.003-2002-03-11b/include/klic/gg_macro.h	Mon Mar 11 16:38:04 2002
+++ klic-3.003-2002-03-11c/include/klic/gg_macro.h	Mon Mar 11 17:10:45 2002
@@ -39,22 +39,20 @@
 
 #define GG_FAIL(errmsg) fatal(errmsg)
 #define GG_GCREQUEST GENERIC_GCREQUEST
-#define GG_RETURN  do{ return g_allocp; }while(0)
+#define GG_RETURN  do{ return heapp(); }while(0)
 
-#define GG_TERMINATE  do{ set_heapp(g_allocp); return !0; }while(0)
+#define GG_TERMINATE  do{ return !0; }while(0)
 
 #define GG_SUSPEND(var) \
 do{ \
   q newvar, tmp; \
   q argv[2]; \
   G_MAKE_VAR(newvar); \
-  assert(g_allocp == heapp()); \
   argv[0] = GG_TERM; \
   argv[1] = newvar; \
-  assert(g_allocp == heapp()); \
   tmp = GC_wakeup_g_new(2, argv); \
   GG_KL1_UNIFY((var), tmp); \
-  return(g_allocp); \
+  return heapp(); \
 }while(0)
 
 #define GG_SWITCH_ON_TERM(cons,atomic,funct,dobj,susp) \
@@ -93,7 +91,7 @@
 	q temp0 = derefone(x); \
 	if(isref(temp0) && (x) == derefone(temp0)) { \
 	  GG_SUSPEND(x); \
-	  return g_allocp; \
+	  return heapp(); \
 	} else { \
 	  (x) = temp0; \
 	} \
@@ -106,10 +104,8 @@
 
 #define GG_TRY_TO_ALLOC(new,type,size,label) \
 do{ \
-  set_heapp(g_allocp); \
   G_HEAPALLOC((new), (size), type); \
-  assert(g_allocp == heapp()); \
-  if((long) real_heaplimit() <= (long) g_allocp) { \
+  if((long) real_heaplimit() <= (long) heapp()) { \
     goto label; \
   } \
 }while(0)
@@ -136,10 +132,8 @@
 	if(isref(temp0) && (x) == derefone(temp0)) { \
           q var; \
           struct goalrec *goal; \
-          set_heapp(g_allocp); \
 	  G_MAKE_THE_NEW_GOAL(&var, &goal, g_myself, GG_ARGC, GG_ARGV); \
           G_SUSPEND((x), goal); \
-          g_allocp = heapp(); \
           GG_RETURN_FROM_NEW(var); \
 	} else { \
 	  (x) = temp0; \
@@ -154,14 +148,11 @@
 #define GGSET_NEWOBJ_FOR_NEW(newgobj, type) \
 do{ \
   q res; \
-  assert(g_allocp == heapp()); \
   G_HEAPALLOC_WITH_CHECK((newgobj), GG_OBJ_SIZE, type, res); \
-  assert(g_allocp == heapp()); \
   if(GG_GCREQUEST == res) { \
     q var; \
     struct goalrec *goal; \
     G_MAKE_THE_NEW_GOAL(&var, &goal, g_myself, GG_ARGC, GG_ARGV); \
-    g_allocp = heapp(); \
     G_PUSH_GOAL_TO_SPECIAL_QUEUE(goal); \
     GG_RETURN_FROM_NEW(var); \
   } \
@@ -170,7 +161,6 @@
 
 #define GG_RETURN_FROM_NEW(var) \
 do{ \
-  assert(g_allocp == heapp()); \
   return (var); \
 }while(0)
 
@@ -234,9 +224,7 @@
 #define GG_KL1_UNIFY(x, y) \
 do{ \
   struct goalrec *gp; \
-  set_heapp(g_allocp); \
   G_HEAPALLOC(gp, 4, (struct goalrec *)); \
-  assert(g_allocp == heapp()); \
   gp->pred = &predicate_unify__term__dcode_xunify__goal_2; \
   gp->args[0] = (x); \
   gp->args[1] = (y); \
diff -ruN klic-3.003-2002-03-11b/runtime/gcode.c klic-3.003-2002-03-11c/runtime/gcode.c
--- klic-3.003-2002-03-11b/runtime/gcode.c	Mon Mar 11 16:37:16 2002
+++ klic-3.003-2002-03-11c/runtime/gcode.c	Mon Mar 11 17:37:09 2002
@@ -69,9 +69,7 @@
 {
   G_STD_DECL;
 
-  set_heapp(g_allocp);
   GD_UNIFY(GD_ARGV[0], GD_SELF->module_obj);
-  assert(g_allocp == heapp());
   GD_RETURN;
 }
 
@@ -79,9 +77,7 @@
 {
   G_STD_DECL;
 
-  set_heapp(g_allocp);
   GD_UNIFY(GD_ARGV[0], GD_SELF->predicate_name);
-  assert(g_allocp == heapp());
   GD_RETURN;
 }
 
@@ -90,17 +86,13 @@
   G_STD_DECL;
   const struct predicate* pred = GD_SELF->pdesc;
 
-  set_heapp(g_allocp);
   GD_UNIFY(GD_ARGV[0], makeint(pred->arity));
-  assert(g_allocp == heapp());
   GD_RETURN;
 }
 
 #define GD_ALLOC_GOAL(goal, pdesc, size) \
 do{ \
-  set_heapp(g_allocp); \
   G_HEAPALLOC(goal, (size)+2, (struct goalrec*)); \
-  assert(g_allocp == heapp()); \
   (goal)->pred = (pdesc); \
 }while(0)
 
@@ -156,7 +148,6 @@
 GDDEF_GENERIC()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
 
   GD_SWITCH_ON_GMETHOD {
     GD_METHOD_CASE(module_1);
@@ -169,7 +160,6 @@
       GD_METHOD_NAME_CASE_DEFAULT;
     }
   }
-  set_heapp(g_allocp);
 }
 
 GDDEF_PRINT()
@@ -255,7 +245,6 @@
   const struct predicate* predaddr;
   q predname;
   int arity;
-  q* g_allocp = heapp();
 
   if( GD_ARGC != 3 ) GD_ERROR_IN_NEW("Too few or too many arguments");
 
@@ -281,12 +270,9 @@
     GD_ERROR_IN_NEW(message);
   }
 
-  set_heapp(g_allocp);
   GDSET_NEWOBJ_FOR_NEW(newpred, sizeof(struct predicate_object));
-  assert(g_allocp == heapp());
   newpred->pdesc = predaddr;
   newpred->module_obj = G_MAKEFUNCTOR(module_obj);
   newpred->predicate_name = predname;
-  assert(g_allocp == heapp());
   GD_RETURN_FROM_NEW(newpred);
 }
diff -ruN klic-3.003-2002-03-11b/runtime/ge_exref.c klic-3.003-2002-03-11c/runtime/ge_exref.c
--- klic-3.003-2002-03-11b/runtime/ge_exref.c	Mon Mar 11 16:36:55 2002
+++ klic-3.003-2002-03-11c/runtime/ge_exref.c	Mon Mar 11 17:13:09 2002
@@ -62,7 +62,6 @@
 GGDEF_UNIFY()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
   struct generator_susp* gsusp = generator_suspp(derefone(GG_SELF));
   struct exref_object* GG_OBJ =
     (struct exref_object*) untag_generator_susp(gsusp->u.o);
@@ -168,10 +167,8 @@
 {
   GG_STD_DECL_FOR_NEW;
   GG_OBJ_TYPE* new_exref;
-  q* g_allocp = heapp();
 
   GGSET_NEWOBJ_FOR_NEW(new_exref, (struct exref_object*));
-  assert(g_allocp == heapp());
 
   new_exref->node  = (long) intval(GG_ARGV[0]);
   new_exref->index = (long) intval(GG_ARGV[1]);
@@ -183,7 +180,6 @@
 
   regist_imp_entry(new_exref);
 
-  assert(g_allocp == heapp());
   GG_RETURN_FROM_NEW(new_exref->to_exref);
 }
 
diff -ruN klic-3.003-2002-03-11b/runtime/ge_readhook.c klic-3.003-2002-03-11c/runtime/ge_readhook.c
--- klic-3.003-2002-03-11b/runtime/ge_readhook.c	Mon Mar 11 16:17:57 2002
+++ klic-3.003-2002-03-11c/runtime/ge_readhook.c	Mon Mar 11 17:13:23 2002
@@ -31,7 +31,6 @@
 GCDEF_UNIFY()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
 
   GC_SWITCH_ON_TERM(list0, atomic0, functor0, generic_data0, susp0);
 
@@ -95,10 +94,8 @@
 {
   GC_STD_DECL_FOR_NEW;
   GC_OBJ_TYPE* new_read_hook;
-  q* g_allocp = heapp();
 
   GCSET_NEWOBJ_FOR_NEW(new_read_hook, GC_OBJ_SIZE(new_read_hook));
-  assert(g_allocp == heapp());
   new_read_hook->node  = (long) intval(GC_ARGV[0]);
   new_read_hook->index = (long) intval(GC_ARGV[1]);
   new_read_hook->wec   = (long) intval(GC_ARGV[2]);
diff -ruN klic-3.003-2002-03-11b/runtime/ge_replyhook.c klic-3.003-2002-03-11c/runtime/ge_replyhook.c
--- klic-3.003-2002-03-11b/runtime/ge_replyhook.c	Mon Mar 11 16:18:06 2002
+++ klic-3.003-2002-03-11c/runtime/ge_replyhook.c	Mon Mar 11 17:13:35 2002
@@ -26,7 +26,6 @@
 GCDEF_UNIFY()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
 
   /* INT_CL_DEBUG_X(printf("replyhook active unify\n")); */
 
@@ -71,10 +70,8 @@
   GC_STD_DECL_FOR_NEW;
   GC_OBJ_TYPE* new_reply_hook;
   q var;
-  q* g_allocp = heapp();
 
   GCSET_NEWOBJ_FOR_NEW(new_reply_hook, GC_OBJ_SIZE(new_reply_hook));
-  assert(g_allocp == heapp());
   new_reply_hook->node = intval(GC_ARGV[0]);
   new_reply_hook->index  = intval(GC_ARGV[1]);
   new_reply_hook->wec    = intval(GC_ARGV[2]);
diff -ruN klic-3.003-2002-03-11b/runtime/generic.c klic-3.003-2002-03-11c/runtime/generic.c
--- klic-3.003-2002-03-11b/runtime/generic.c	Mon Mar 11 16:36:16 2002
+++ klic-3.003-2002-03-11c/runtime/generic.c	Mon Mar 11 17:36:45 2002
@@ -44,24 +44,19 @@
 {
   G_STD_DECL;
   unsigned long argc = arities (method_functor);
-  q* g_allocp = heapp();
   q objp;
   int i;
 
   G_HEAPALLOC(objp, G_SIZE_IN_Q(struct functor)+argc-1, makefunctor);
-  assert(g_allocp == heapp());
   functor_of(objp) = makesym(method_functor);
   for( i=0; i<argc; i++ ){
     arg(objp, i) = argv[i];
   }
 
-  set_heapp(g_allocp);
   G_HEAPALLOC(*goalp1, G_SIZE_IN_Q(struct goalrec)-4, (struct goalrec*));
-  assert(g_allocp == heapp());
   (*goalp1)->pred    = GD_GENERIC_GOAL;
   (*goalp1)->args[0] = objp;
   (*goalp1)->args[1] = var;
-  assert(g_allocp == heapp());
 }
 
 extern void
@@ -75,22 +70,17 @@
   G_STD_DECL;
   q newvar;
   q newobj, newobj2;
-  q* g_allocp;
 
   newobj = gd_new_pointer(myself);
   newobj2 = gd_new_termarray(argc, argv);
-  g_allocp = heapp();
 
   G_HEAPALLOC(*goalp1, G_SIZE_IN_Q(struct goalrec)-3, (struct goalrec*));
-  assert(g_allocp == heapp());
   G_MAKE_VAR(newvar);
-  assert(g_allocp == heapp());
   (*goalp1)->pred    = G_NEW_GOAL;
   (*goalp1)->args[0] = newvar;
   (*goalp1)->args[1] = newobj;
   (*goalp1)->args[2] = newobj2;
   *var = newvar;
-  assert(g_allocp == heapp());
 }
 
 /**********************************************************************/
@@ -100,10 +90,8 @@
     q temp0 = derefone(obj); \
     if( isref(temp0) && (obj) == derefone(temp0) ){ \
       struct goalrec* goal; \
-      set_heapp(g_allocp); \
       GD_MAKE_GENERIC_GOAL(&goal, (obj), g_method_functor, g_argv); \
       G_SUSPEND((obj), goal); \
-      g_allocp = heapp(); \
       GD_RETURN; \
     }else{ \
       (obj) = temp0; \
@@ -122,7 +110,6 @@
 {
   G_STD_DECL;
   struct data_object* g_obj;
-  q* g_allocp = heapp();
 
   GD_DEREF_FOR_GENERIC(g_object);
   if( !isfunctor(g_object) || !isref(functor_of(g_object)) ){
@@ -131,7 +118,6 @@
     fatal("Generic method issued to a non-object");
   }
   g_obj = data_objectp(g_object);
-  set_heapp(g_allocp);
   g_obj->method_table->body_generic(g_obj, g_method_functor, g_argv);
 }
 
@@ -166,7 +152,7 @@
   struct data_object* GD_OTHER;
   q* g_allocp;
 {
-  return g_allocp;
+  return heapp();
 }
 
 extern long
@@ -201,7 +187,7 @@
   q GD_ARGV[];
   q* g_allocp;
 {
-  return g_allocp;
+  return heapp();
 }
 
 extern q
diff -ruN klic-3.003-2002-03-11b/runtime/gfloat.c klic-3.003-2002-03-11c/runtime/gfloat.c
--- klic-3.003-2002-03-11b/runtime/gfloat.c	Mon Mar 11 16:19:32 2002
+++ klic-3.003-2002-03-11c/runtime/gfloat.c	Mon Mar 11 17:36:00 2002
@@ -28,8 +28,8 @@
 #define ALIGN() \
 do{ \
   if( sizeof(double) != sizeof(long) ){ \
-    g_allocp = (q*) (((unsigned long)g_allocp + sizeof(double) - 1) \
-		     & -sizeof(double) ); \
+    set_heapp((q*) (((unsigned long) heapp() + sizeof(double) - 1) \
+		     & -sizeof(double) )); \
   } \
 }while(0)
 
@@ -110,9 +110,7 @@
   G_STD_DECL;
   GD_OBJ_TYPE* newself;
 
-  q* g_allocp = heapp();
   ALIGN();
-  set_heapp(g_allocp);
   GDSET_NEWOBJ_IN_NEWGEN(newself);
   newself->value = GD_SELF->value;
   GD_RETURN_FROM_GC(newself);
@@ -140,9 +138,7 @@
       strcat(buf, ".0");
     }
   }
-  set_heapp(g_allocp);
   str = convert_c_string_to_klic_string(buf);
-  g_allocp = heapp();
   GD_UNIFY_VALUE(GD_ARGV[0], str);
   GD_RETURN;
 }
@@ -178,7 +174,6 @@
   unsigned long result_index;
   GD_OBJ_TYPE* newobj;
   double (*func)();
-  q* g_allocp = heapp();
 
   self = GD_SELF->value;
   GD_SWITCH_ON_METHOD {
@@ -189,9 +184,7 @@
 
   default:
     ALIGN();
-    set_heapp(g_allocp);
     GDSET_NEWOBJ(newobj);
-    assert(g_allocp == heapp());
     GD_SWITCH_ON_ARITY {
     case 1: {
       result_index = 0;
@@ -251,16 +244,13 @@
     GD_METHOD_CASE_DEFAULT;
     }
   }
-  set_heapp(g_allocp);
   return;
 
  apply_1:
   result = func(self);
  apply_2:
   newobj->value = result;
-  set_heapp(g_allocp);
   GD_UNIFY(GD_ARGV[result_index], makefunctor(newobj));
-  assert(g_allocp == heapp());
 }
 
 /* guard generic methods */
@@ -390,13 +380,10 @@
   GD_STD_DECL_FOR_NEW;
   q init = GD_ARGV[0];
   GD_OBJ_TYPE* newobj;
-  q* g_allocp = heapp();
 
   GD_DEREF_FOR_NEW(init);
   ALIGN();
-  set_heapp(g_allocp);
   GDSET_NEWOBJ_FOR_NEW(newobj, G_SIZE_IN_Q(GD_OBJ_TYPE));
-  assert(g_allocp == heapp());
   if( G_ISINT(init) ){
     newobj->value = (double) G_INTVAL(init);
   }else if( G_ISGOBJ(init) &&
@@ -407,7 +394,6 @@
     debug_printf("### %k ###\n", init);
     GD_FAIL("Invalid initial value for floating point objects");
   }
-  set_heapp(g_allocp);
   GD_RETURN_FROM_NEW(newobj);
 }
 
@@ -420,10 +406,9 @@
   G_STD_DECL;
   GD_OBJ_TYPE* newobj;
 
-  ALIGN();
   set_heapp(g_allocp);
+  ALIGN();
   G_HEAPALLOC(newobj, G_SIZE_IN_Q(GD_OBJ_TYPE), (GD_OBJ_TYPE*));
-  assert(g_allocp == heapp());
 
   newobj->method_table = &GD_method_table;
   if( sizeof(long) == sizeof(double) ){
@@ -435,6 +420,6 @@
     newobj->value = dl.d;
   }
   push_decode_stack((q) makefunctor(newobj));
-  return g_allocp;
+  return heapp();
 }
 #endif /* DIST */
diff -ruN klic-3.003-2002-03-11b/runtime/gg_shbusy.c klic-3.003-2002-03-11c/runtime/gg_shbusy.c
--- klic-3.003-2002-03-11b/runtime/gg_shbusy.c	Mon Mar 11 13:27:53 2002
+++ klic-3.003-2002-03-11c/runtime/gg_shbusy.c	Mon Mar 11 17:16:26 2002
@@ -21,7 +21,7 @@
 #define GG_CLASS_NAME() shbusy
 #define GG_OBJ_TYPE struct Shbusy
 
-#define One_more()  (set_heapp(g_allocp), do_unify(GG_SELF, GG_TERM))
+#define One_more()  (do_unify(GG_SELF, GG_TERM))
 
 struct Shbusy {
   struct generator_object_method_table *method_table;
@@ -30,7 +30,6 @@
 GGDEF_UNIFY()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
 
   struct generator_object* gobj;
   q pair = derefone(GG_SELF);
diff -ruN klic-3.003-2002-03-11b/runtime/gg_shvar.c klic-3.003-2002-03-11c/runtime/gg_shvar.c
--- klic-3.003-2002-03-11b/runtime/gg_shvar.c	Mon Mar 11 13:27:13 2002
+++ klic-3.003-2002-03-11c/runtime/gg_shvar.c	Mon Mar 11 17:18:41 2002
@@ -22,7 +22,7 @@
 #define GG_CLASS_NAME() shvar
 #define GG_OBJ_TYPE struct Shvar
 
-#define One_more()  (set_heapp(g_allocp), do_unify(GG_SELF, GG_TERM))
+#define One_more()  (do_unify(GG_SELF, GG_TERM))
 
 struct Shvar {
   struct generator_object_method_table *method_table;
@@ -58,7 +58,6 @@
 GGDEF_UNIFY()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
 
   struct generator_object *addi;
   Shvar *gobjp;
@@ -75,9 +74,9 @@
     derefone(GG_SELF) = GG_TERM;
     if( gobjp->chain ){
       if( is_genhook(gobjp->chain) ){
-	g_allocp = shm_ck_request(g_allocp, gobjp->chain);
+	set_heapp(shm_ck_request(heapp(), gobjp->chain));
       }else{
-	g_allocp = shm_resume_goals(g_allocp, gobjp->chain);
+	set_heapp(shm_resume_goals(heapp(), gobjp->chain));
       }
     }
     GG_TERMINATE;
@@ -99,9 +98,9 @@
       derefone(GG_SELF) = y;
       if( gobjp->chain ){
 	if( is_genhook(gobjp->chain) ){
-	  g_allocp = shm_ck_request(g_allocp, gobjp->chain);
+	  set_heapp(shm_ck_request(heapp(), gobjp->chain));
 	}else{
-	  g_allocp = shm_resume_goals(g_allocp, gobjp->chain);
+	  set_heapp(shm_resume_goals(heapp(), gobjp->chain));
 	}
       }
     }
@@ -153,7 +152,7 @@
 	if( xobjp->chain ){
 	  if( is_genhook(xobjp->chain) ){ /* one is a generator hook. */
 	    derefone(x) = y;
-	    g_allocp = shm_ck_request(g_allocp, xobjp->chain);
+	    set_heapp(shm_ck_request(heapp(), xobjp->chain));
 	  }else{              /* one is a normal hook */
 	    yaddi = n_lock(y, ytemp);
 	    if( derefone(y) != ytemp ){
@@ -170,7 +169,7 @@
 		yobjp->chain = shm_copy_chain(xobjp->chain);
 		n_unlock(ytemp, yaddi);
 		derefone(x) = y;
-		g_allocp = shm_ck_request(g_allocp, ychain);
+		set_heapp(shm_ck_request(heapp(), ychain));
 	      }else{ /* both are ordinary hooks */
 		ck_new_galloc(yobjp);
 		yobjp->chain = shm_merge_chain(xobjp->chain, yobjp->chain);
@@ -199,7 +198,6 @@
 	if( xobjp->chain ){ /* x has any info */
 	  struct generator_object* gobjy = untag_generator_susp(yaddi);
 	  q tmpy;
-	  set_heapp(g_allocp);
 	  tmpy = generic_generate(gobjy);
 	  switch( (long)tmpy ){
 	  case (long) makeref(0):
@@ -208,7 +206,6 @@
 	  case (long) makecons(0):
 	    fatal("system bug!!!");
 	  default:
-	    g_allocp = heapp();
 	    derefone(y) = tmpy;
 	    One_more();
 	    GG_TERMINATE;
@@ -221,7 +218,7 @@
     }else{ /* y is a consumer */
       if( xobjp && is_genhook(xobjp->chain) ){ /* global generator hook */
 	Shvar* tobj = shm_add_consumer(x, 0, y, glbl);
-	g_allocp = shm_ck_request(g_allocp, xobjp->chain);
+	set_heapp(shm_ck_request(heapp(), xobjp->chain));
 	n_unlock(temp, tag_generator_susp(tobj));
       }else{
 	Shvar* tobj = (Shvar*) shm_add_consumer(x, xobjp, y, glbl);
diff -ruN klic-3.003-2002-03-11b/runtime/ggoal.c klic-3.003-2002-03-11c/runtime/ggoal.c
--- klic-3.003-2002-03-11b/runtime/ggoal.c	Mon Mar 11 16:35:18 2002
+++ klic-3.003-2002-03-11c/runtime/ggoal.c	Mon Mar 11 17:34:38 2002
@@ -150,9 +150,7 @@
 {
   G_STD_DECL;
   struct goalrec *newgoal;
-  set_heapp(g_allocp);
   GD_ALLOC_AREA(newgoal, (struct goalrec *), 2+5);
-  assert(g_allocp == heapp());
   newgoal->pred = &step_trigger_pred;
   newgoal->args[0] = makefunctor(GD_SELF);
   newgoal->args[1] = GD_ARGV[0]; /* children info */
@@ -175,9 +173,7 @@
   GDSET_INTARG_WITHIN_RANGE(position, GD_ARGV[0], 1, size+1);
   the_arg = goal->args[position-1];
 
-  set_heapp(g_allocp);
   GD_UNIFY(GD_ARGV[1], the_arg);
-  assert(g_allocp == heapp());
   GD_RETURN;
 }
 
@@ -195,9 +191,7 @@
   oldarg = GD_SELF->goal->args[position-1];
 
   /* Allocate and set up new goal record */
-  set_heapp(g_allocp);
   GD_ALLOC_AREA(newgoal, (struct goalrec *), size+2);
-  assert(g_allocp == heapp());
   oldgoal = GD_SELF->goal;
   newgoal->pred = oldgoal->pred;
   for (k = 0; k < size; k++) {
@@ -206,14 +200,10 @@
   newgoal->args[position-1] = GD_ARGV[2];
 
   /* Allocate and set up new goal object */
-  set_heapp(g_allocp);
   GDSET_NEWOBJ(newobj);
-  assert(g_allocp == heapp());
   newobj->goal = newgoal;
 
-  set_heapp(g_allocp);
   GD_UNIFY(GD_ARGV[1], oldarg);
-  assert(g_allocp == heapp());
   GD_UNIFY_VALUE(GD_ARGV[3], GD_OBJ(newobj));
   GD_RETURN;
 }
@@ -267,18 +257,14 @@
   }
 
   /* Allocate and set up new goal record */
-  set_heapp(g_allocp);
   GD_ALLOC_AREA(newgoal, (struct goalrec *), arity+2);
-  assert(g_allocp == heapp());
   newgoal->pred = pred->pdesc;
   for (k = 0; k < arity; k++) {
     newgoal->args[k] = oldgoal->args[k];
   }
 
   /* Allocate and set up new goal object */
-  set_heapp(g_allocp);
   GDSET_NEWOBJ(newobj);
-  assert(g_allocp == heapp());
   newobj->goal = newgoal;
 
   GD_UNIFY_VALUE(GD_ARGV[1], GD_OBJ(newobj));
@@ -289,7 +275,6 @@
 GDDEF_GENERIC()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
 
   GD_SWITCH_ON_METHOD{
     GD_METHOD_CASE(reduce_0);
@@ -301,7 +286,6 @@
     GD_METHOD_CASE(set__predicate_2);
     GD_METHOD_CASE_DEFAULT;
   }
-  set_heapp(g_allocp);
 }
 
 /* Guard Methods */
@@ -357,7 +341,6 @@
   struct predicate_object *pred;
   long pred_arity, argv_arity;
   long k;
-  q* g_allocp = heapp();
 
   if (GD_ARGC != 2) {
     GD_ERROR_IN_NEW("Wrong number of arguments");
@@ -381,19 +364,14 @@
     GD_ERROR_IN_NEW("Number of args mismatch with the predicate");
   }
 
-  set_heapp(g_allocp);
   GD_ALLOC_AREA_FOR_NEW(newgoal, (struct goalrec *), pred_arity+2);
-  assert(g_allocp == heapp());
   newgoal->pred = pred->pdesc;
   for (k = 0; k < pred_arity; k++) {
     extern q element_of_vector();
     newgoal->args[k] = element_of_vector(argvq, makeint(k));
   }
-  set_heapp(g_allocp);
   GDSET_NEWOBJ_FOR_NEW(newobj, G_SIZE_IN_Q(GD_OBJ_TYPE));
-  assert(g_allocp == heapp());
   newobj->goal = newgoal;
   newobj->id = goal_obj_id++;
-  assert(g_allocp == heapp());
   GD_RETURN_FROM_NEW(newobj);
 }
diff -ruN klic-3.003-2002-03-11b/runtime/gio.c klic-3.003-2002-03-11c/runtime/gio.c
--- klic-3.003-2002-03-11b/runtime/gio.c	Mon Mar 11 16:20:48 2002
+++ klic-3.003-2002-03-11c/runtime/gio.c	Mon Mar 11 17:21:26 2002
@@ -73,7 +73,6 @@
 GCDEF_UNIFY()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
   q newvar;
   q reason;
 
@@ -114,9 +113,7 @@
 	  c = klic_getc(GC_SELF->infile);
 	}
 	if( c=='\n' ){ GC_SELF->linecount++; }
-	set_heapp(g_allocp);
 	GC_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(c));
-	assert(g_allocp == heapp());
 	break;
       }
 
@@ -145,7 +142,7 @@
 	GCSET_MESSAGE_INT_ARG(n, message, 0);
 	if( n<0 ) goto message_error;
 	space_needed = sizeof(struct byte_string_object) + n + sizeof(q);
-	if( (char*) g_allocp+space_needed >= (char*) real_heaplimit() ){
+	if( (char*) heapp()+space_needed >= (char*) real_heaplimit() ){
 	  add_this_more_space((space_needed + sizeof(q) - 1) / sizeof(q));
 	  goto gc_request;
 	}
@@ -163,23 +160,18 @@
 	for( k=0; k<n; k++ ){
 	  if( buf[k] == '\n' ){ GC_SELF->linecount++; }
 	}
-	set_heapp(g_allocp);
 	string = convert_binary_c_string_to_klic_string(buf, n);
 	if( G_ISREF(string) ){
 	  GC_FAIL("internal error: string allocation for fread");
 	}
-	g_allocp = heapp();
 	free(buf);
 	GC_UNIFY_VALUE(G_ARG(message, 1), string);
-	assert(g_allocp == heapp());
 	break;
       }
 
       case functor_linecount_1: {
 	CheckInput();
-	set_heapp(g_allocp);
 	GC_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(GC_SELF->linecount));
-	assert(g_allocp == heapp());
 	break;
       }
 
@@ -220,9 +212,7 @@
 	  written = klic_fwrite(generic_string_body(str),
 				1, size, GC_SELF->outfile);
 	}
-	set_heapp(g_allocp);
 	GC_UNIFY_VALUE(G_ARG(message, 1), G_MAKEINT(written));
-	assert(g_allocp == heapp());
 	break;
       }
 
@@ -269,9 +259,7 @@
 	    iseof = feof(GC_SELF->outfile);
 	  }
 	}
-	set_heapp(g_allocp);
 	GC_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(iseof));
-	assert(g_allocp == heapp());
 	break;
       }
 
@@ -290,9 +278,7 @@
 	    (GC_SELF->infile == NULL ? GC_SELF->outfile : GC_SELF->infile);
 	  result = fseek(file, offset, whence);
 	}
-	set_heapp(g_allocp);
 	GC_UNIFY_VALUE(G_ARG(message, 2), G_MAKEINT(result));
-	assert(g_allocp == heapp());
 	break;
       }
 
@@ -309,17 +295,13 @@
 	    (GC_SELF->infile == NULL ? GC_SELF->outfile : GC_SELF->infile);
 	  result = ftell(file);
 	}
-	set_heapp(g_allocp);
 	GC_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(result));
-	assert(g_allocp == heapp());
 	break;
       }
 
       case functor_fflush_1: {
 	long result = do_flush(GC_SELF);
-	set_heapp(g_allocp);
 	GC_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(result));
-	assert(g_allocp == heapp());
 	break;
       }
 
@@ -348,16 +330,12 @@
 	    }
 	  }
 	}
-	set_heapp(g_allocp);
 	GC_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(result));
-	assert(g_allocp == heapp());
 	break;
       }
 
       case functor_sync_1: {
-	set_heapp(g_allocp);
 	GC_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(0));
-	assert(g_allocp == heapp());
 	break;
       }
 
@@ -417,9 +395,7 @@
 
  gc_request:
   G_MAKE_VAR(newvar);
-  assert(g_allocp == heapp());
   GC_KL1_UNIFY(GC_TERM, newvar);
-  assert(g_allocp == heapp());
   GC_RETURN_WITH_HOOK(newvar);
 
  suspend:
@@ -465,7 +441,6 @@
   q var;
   struct pointer_object* inptr;
   struct pointer_object* outptr;
-  q* g_allocp = heapp();
 
   /*
    * Arguments are:
@@ -498,9 +473,7 @@
   outpath = GC_ARGV[3];
   GC_DEREF_FOR_NEW(outpath);
 
-  set_heapp(g_allocp);
   GCSET_NEWOBJ_FOR_NEW(newobj, GC_OBJ_SIZE(newobj));
-  assert(g_allocp == heapp());
   if( infile == NILATOM ){
     newobj->infile = NULL;
   }else{
diff -ruN klic-3.003-2002-03-11b/runtime/gmerge.c klic-3.003-2002-03-11c/runtime/gmerge.c
--- klic-3.003-2002-03-11b/runtime/gmerge.c	Mon Mar 11 16:21:35 2002
+++ klic-3.003-2002-03-11c/runtime/gmerge.c	Mon Mar 11 17:22:20 2002
@@ -28,9 +28,7 @@
 #define GC_MAKE_MERGE_IN_GOAL(newvar,vec,index,size) \
 do{ \
   struct goalrec *goalp1; \
-  set_heapp(g_allocp); \
   G_HEAPALLOC(goalp1,G_SIZE_IN_Q(struct goalrec)-2,(struct goalrec *)); \
-  assert(g_allocp == heapp()); \
   goalp1->pred = GC_MERGE_IN_GOAL; \
   goalp1->args[0] = newvar; \
   goalp1->args[1] = vec; \
@@ -48,7 +46,6 @@
 GCDEF_UNIFY()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
   q newvar;
 
  top:
@@ -57,14 +54,10 @@
   list0:
     {
       struct cons *newout;
-      set_heapp(g_allocp);
       GC_TRY_TO_ALLOC(newout,(struct cons *),2,gc_request);
-      assert(g_allocp == heapp());
       newout->car = G_CAR_OF(GC_TERM);
       GCSET_VAR(newout->cdr);
-      set_heapp(g_allocp);
       GC_UNIFY(GC_SELF->outstream,G_MAKECONS(newout));
-      assert(g_allocp == heapp());
       GC_SELF->outstream = newout->cdr;
       GC_TERM = G_CDR_OF(GC_TERM);
       goto top;
@@ -72,9 +65,7 @@
   atomic0:
     if (GC_TERM == NILATOM) {
       if (--(GC_SELF->count) == 0) {
-	set_heapp(g_allocp);
 	GC_UNIFY(GC_SELF->outstream,NILATOM);
-	assert(g_allocp == heapp());
       }
       GC_TERMINATE;
     } else goto invalid_data;
@@ -91,30 +82,23 @@
       }
       GC_SELF->count += size - 1;
       if (GC_SELF->count == 0) {
-	set_heapp(g_allocp);
 	GC_UNIFY(GC_SELF->outstream,NILATOM);
-	assert(g_allocp == heapp());
       } else {
 	q argv[2];
 	q hook_var;
 	for (i=0; i<size; i++) {
 	  argv[0] = G_MAKEINT(i);
 	  GD_CALL_GMETHOD(GC_TERM,element_2,argv);
-	  set_heapp(g_allocp);
 	  GC_TRY_TO_ALLOC(hook_var,(q),1,gc_request2);
-	  assert(g_allocp == heapp());
 	  derefone(hook_var) =
 	    GC_MAKE_HOOK_VAR((struct consumer_object*) GC_SELF);
 	  GC_KL1_UNIFY(argv[1],hook_var);
-	  assert(g_allocp == heapp());
 	}
       }
       GC_TERMINATE;
     gc_request2:
-      assert(g_allocp == heapp());
       GC_SELF->count -= size-i-1;
       G_MAKE_VAR(newvar);
-      assert(g_allocp == heapp());
       GC_MAKE_MERGE_IN_GOAL(newvar,GC_TERM,i,size);
       GC_RETURN_WITH_HOOK(newvar);
     } else goto invalid_data;
@@ -124,11 +108,8 @@
   debug_printf("### %k ###\n", GC_TERM);
   GC_FAIL("Invalid data unified with merger");
  gc_request:
-  assert(g_allocp == heapp());
   G_MAKE_VAR(newvar);
-  assert(g_allocp == heapp());
   GC_KL1_UNIFY(GC_TERM,newvar);
-  assert(g_allocp == heapp());
   GC_RETURN_WITH_HOOK(newvar);
 }
 
@@ -164,12 +145,10 @@
   GC_STD_DECL_FOR_NEW;
   GC_OBJ_TYPE *newmerger;
   q var;
-  q* g_allocp = heapp();
 
   if (GC_ARGC != 1) GC_ERROR_IN_NEW("Arity mismatch");
 
   GCSET_NEWOBJ_FOR_NEW(newmerger,GC_OBJ_SIZE(newmerger));
-  assert(g_allocp == heapp());
   newmerger->count = 1;
   newmerger->outstream = GC_ARGV[0];
   var = GC_MAKE_HOOK_VAR((struct consumer_object*) newmerger);
diff -ruN klic-3.003-2002-03-11b/runtime/gmodule.c klic-3.003-2002-03-11c/runtime/gmodule.c
--- klic-3.003-2002-03-11b/runtime/gmodule.c	Mon Mar 11 16:33:51 2002
+++ klic-3.003-2002-03-11c/runtime/gmodule.c	Mon Mar 11 17:33:29 2002
@@ -69,9 +69,7 @@
 GDDEF_METHOD(name_1)
 {
   G_STD_DECL;
-  set_heapp(g_allocp);
   GD_UNIFY( GD_ARGV[0],GD_SELF->name);
-  assert(g_allocp == heapp());
   GD_RETURN;
 }
 
@@ -79,13 +77,11 @@
 GDDEF_GENERIC()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
 
   GD_SWITCH_ON_GMETHOD {
     GD_METHOD_CASE(name_1);
     GD_METHOD_CASE_DEFAULT;
   }
-  set_heapp(g_allocp);
 }
 
 GDDEF_PRINT()
@@ -153,18 +149,14 @@
   q atom;
   const struct modinfo* mp;
   unsigned char *name;
-  q* g_allocp = heapp();
 
   GDSET_SYMARG_FOR_NEW(atom,GD_ARGV[0]);
   name = namestringof(atom);
   for (mp = defined_modules; mp->name != 0; mp++) {
     if (strcmp((char *)mp->name, (char *)name) == 0) {
       GD_OBJ_TYPE *newmodule;
-      set_heapp(g_allocp);
       GDSET_NEWOBJ_FOR_NEW(newmodule,sizeof(struct module_object));
-      assert(g_allocp == heapp());
       newmodule->name = atom;
-      assert(g_allocp == heapp());
       GD_RETURN_FROM_NEW(newmodule);
     }
   }
diff -ruN klic-3.003-2002-03-11b/runtime/gmvv.c klic-3.003-2002-03-11c/runtime/gmvv.c
--- klic-3.003-2002-03-11b/runtime/gmvv.c	Mon Mar 11 16:33:29 2002
+++ klic-3.003-2002-03-11c/runtime/gmvv.c	Mon Mar 11 17:33:16 2002
@@ -116,7 +116,6 @@
 GDDEF_UNIFY()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
   long size, k;
 
   if (GD_SELF->method_table != GD_OTHER->method_table) GD_UNIFY_FAIL;
@@ -127,12 +126,9 @@
   for (k=0; k<size; k++) {
     q x = GD_OTHER->body[k];
     Shallow(GD_SELF);
-    set_heapp(g_allocp);
     GD_UNIFY(GD_SELF->body[k], x);
-    assert(g_allocp == heapp());
     Shallow(GD_OTHER);
   }
-  set_heapp(g_allocp);
 }
 
 GDDEF_GC()
@@ -233,9 +229,7 @@
   int position;
   Shallow(GD_SELF);
   GDSET_INTARG_WITHIN_RANGE(position,GD_ARGV[0],0,GD_SELF->index);
-  set_heapp(g_allocp);
   GD_UNIFY(GD_ARGV[1], GD_SELF->body[position]);
-  assert(g_allocp == heapp());
   GD_RETURN;
 }
 
@@ -243,9 +237,7 @@
 {
   G_STD_DECL;
   Shallow(GD_SELF);
-  set_heapp(g_allocp);
   GD_UNIFY_VALUE(GD_ARGV[0], G_MAKEINT(GD_SELF->index));
-  assert(g_allocp == heapp());
   GD_RETURN;
 }
 
@@ -263,9 +255,7 @@
   iscnst = GD_SELF->iscnst;
   body = GD_SELF->body;
   GDSET_INTARG_WITHIN_RANGE(position,GD_ARGV[0],0,size);
-  set_heapp(g_allocp);
   GDSET_NEWOBJ(newvect);
-  assert(g_allocp == heapp());
   if (!iscnst) {
     q olddata = body[position];
 
@@ -277,9 +267,7 @@
   } else {
     long k;
     q *newbody;
-    set_heapp(g_allocp);
     GD_ALLOC_AREA(newbody,(q*),size);
-    assert(g_allocp == heapp());
     for (k=0; k<size; k++) newbody[k] = body[k];
     newbody[position] = GD_ARGV[1];
     newvect->body = newbody;
@@ -307,13 +295,9 @@
   iscnst = GD_SELF->iscnst;
 
   GDSET_INTARG_WITHIN_RANGE(position,GD_ARGV[0],0,size);
-  set_heapp(g_allocp);
   GDSET_NEWOBJ(newvect);
-  assert(g_allocp == heapp());
   olddata = body[position];
-  set_heapp(g_allocp);
   GD_UNIFY(GD_ARGV[1], olddata);
-  assert(g_allocp == heapp());
   if (!iscnst) {
     GD_SELF->index = position;
     GD_SELF->body = (q *)olddata;
@@ -323,9 +307,7 @@
   } else {
     long k;
     q *newbody;
-    assert(g_allocp == heapp());
     GD_ALLOC_AREA(newbody,(q*),size);
-    assert(g_allocp == heapp());
     for (k=0; k<size; k++) newbody[k] = body[k];
     newbody[position] = GD_ARGV[2];
     newvect->body = newbody;
@@ -349,15 +331,10 @@
   size = GD_SELF->index;
   GDSET_INTARG_WITHIN_RANGE(split_point,GD_ARGV[0],0,size+1);
   lower_size = size-split_point;
-  set_heapp(g_allocp);
   GD_ALLOC_AREA(upper_body, (q *), split_point);
-  assert(g_allocp == heapp());
   GD_ALLOC_AREA(lower_body, (q *), lower_size);
-  assert(g_allocp == heapp());
   GD_ALLOC_AREA(upper, (GD_OBJ_TYPE *), GD_OBJ_SIZE(GD_SELF));
-  assert(g_allocp == heapp());
   GD_ALLOC_AREA(lower, (GD_OBJ_TYPE *), GD_OBJ_SIZE(GD_SELF));
-  assert(g_allocp == heapp());
   BCOPY((char *)GD_SELF->body, (char *)upper_body, split_point*sizeof(q));
   BCOPY((char *)(GD_SELF->body+split_point), (char *)lower_body,
 	lower_size*sizeof(q));
@@ -393,11 +370,8 @@
   Shallow(another);
   size2 = another->index;
   newsize = size1+size2;
-  set_heapp(g_allocp);
   GD_ALLOC_AREA(newbody, (q *), newsize);
-  assert(g_allocp == heapp());
   GD_ALLOC_AREA(new, (GD_OBJ_TYPE *), GD_OBJ_SIZE(GD_SELF));
-  assert(g_allocp == heapp());
   Shallow(GD_SELF);
   BCOPY((char *)GD_SELF->body, (char *)newbody, size1*sizeof(q));
   Shallow(another);
@@ -415,7 +389,6 @@
 GDDEF_GENERIC()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
 
   GD_SWITCH_ON_METHOD{
     GD_METHOD_CASE(element_2);
@@ -426,7 +399,6 @@
     GD_METHOD_CASE(join_2);
     GD_METHOD_CASE_DEFAULT;
   }
-  set_heapp(g_allocp);
 }
 
 /* guard generic methods */
@@ -553,20 +525,15 @@
   q *body;
   long size, k;
   q init;
-  q* g_allocp = heapp();
 
   if (GD_ARGC!=1) GD_ERROR_IN_NEW("Too few or too many arguments");
   init = GD_ARGV[0];
   GD_DEREF_FOR_NEW(init);
-  set_heapp(g_allocp);
   GDSET_NEWOBJ_FOR_NEW(newvect, G_SIZE_IN_Q(GD_OBJ_TYPE));
-  assert(g_allocp == heapp());
   if (G_ISINT(init)) {
     size = G_INTVAL(init);
     if (size < 0) GD_ERROR_IN_NEW("Negative size specified");
-    set_heapp(g_allocp);
     GD_ALLOC_AREA_FOR_NEW(body, (q*), size);
-    assert(g_allocp == heapp());
     for (k=0; k<size; k++) body[k] = G_MAKEINT(0L);
   } else if (init==NILATOM || G_ISCONS(init)) {
     for (size=0; ; size++) {
@@ -577,9 +544,7 @@
 	GD_ERROR_IN_NEW("Invalid parameter");
     }
     init = GD_ARGV[0];
-    set_heapp(g_allocp);
     GD_ALLOC_AREA_FOR_NEW(body, (q*), size);
-    assert(g_allocp == heapp());
     for (k=0; k<size; k++) {
       GD_DEREF_FOR_NEW(init);
       body[k] = G_CAR_OF(init);
@@ -592,7 +557,6 @@
   newvect->iscnst = 0;
   newvect->index = size;
   newvect->body = body;
-  set_heapp(g_allocp);
   GD_RETURN_FROM_NEW(newvect);
 }
 
@@ -649,11 +613,9 @@
   module decoder;
 
   set_heapp(g_allocp);
-  /* GDSET_NEWOBJ_FOR_NEW(newvect, G_SIZE_IN_Q(GD_OBJ_TYPE));
-   * assert(g_allocp == heapp()); */
+  /* GDSET_NEWOBJ_FOR_NEW(newvect, G_SIZE_IN_Q(GD_OBJ_TYPE)); */
   G_HEAPALLOC_WITH_CHECK(newvect, G_SIZE_IN_Q(GD_OBJ_TYPE),
                           (GD_OBJ_TYPE*), res);
-  assert(g_allocp == heapp());
   /* G_HEAPALLOC(newvect, G_SIZE_IN_Q(GD_OBJ_TYPE), (GD_OBJ_TYPE*)); */
 
   if(GENERIC_GCREQUEST == res){
@@ -662,16 +624,13 @@
       inbuf->rd_index--;
 
       /* fprintf(stderr, "Node %d Heap shortage in decoding vector(1)", my_node); */
-      return(g_allocp);
+      return heapp();
   }
   newvect->method_table = &GD_method_table;
   newvect-> index = size = (long)GET_BUFFER(inbuf);
 
-  set_heapp(g_allocp);
-  /* GD_ALLOC_AREA_FOR_NEW(body, (q*), size);
-   * assert(g_allocp == heapp()); */
+  /* GD_ALLOC_AREA_FOR_NEW(body, (q*), size); */
   G_HEAPALLOC_WITH_CHECK(body, size, (q*), res); 
-  assert(g_allocp == heapp());
   /* G_HEAPALLOC(body, size, (q*)); */
   if(GD_GCREQUEST == res){
       add_this_more_space(size);
@@ -679,7 +638,7 @@
       inbuf->rd_index -= 2;
 
       /* fprintf(stderr, "Node %d Heap shortage in decoding vector(2)", my_node); */
-      return(g_allocp);
+      return heapp();
   }
 
   for(k = size; k > 0 ; k--){
@@ -691,6 +650,6 @@
   newvect->body = body;
 
   push_decode_stack((q)makefunctor(newvect));
-  return(g_allocp);
+  return heapp();
 }
 #endif /* DIST */
diff -ruN klic-3.003-2002-03-11b/runtime/gpointer.c klic-3.003-2002-03-11c/runtime/gpointer.c
--- klic-3.003-2002-03-11b/runtime/gpointer.c	Mon Mar 11 16:32:21 2002
+++ klic-3.003-2002-03-11c/runtime/gpointer.c	Mon Mar 11 17:25:45 2002
@@ -52,14 +52,11 @@
 {
   GD_STD_DECL_FOR_NEW;
   GD_OBJ_TYPE *newobj;
-  q* g_allocp = heapp();
 
   if (GD_ARGC != 1) GD_FAIL("Argument mismatch in pointer:new");
   G_HEAPALLOC(newobj,GD_OBJ_SIZE(newobj),(GD_OBJ_TYPE *));
-  assert(g_allocp == heapp());
   newobj->method_table = &GD_method_table;
   newobj->pointer = (char *)GD_ARGV[0];
-  assert(g_allocp == heapp());
   GD_RETURN_FROM_NEW(newobj);
 }
 
diff -ruN klic-3.003-2002-03-11b/runtime/gstring.c klic-3.003-2002-03-11c/runtime/gstring.c
--- klic-3.003-2002-03-11b/runtime/gstring.c	Mon Mar 11 16:32:02 2002
+++ klic-3.003-2002-03-11c/runtime/gstring.c	Mon Mar 11 17:31:05 2002
@@ -105,7 +105,6 @@
 GDDEF_UNIFY()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
   long size, k;
   if (GD_SELF->method_table != GD_OTHER->method_table) GD_UNIFY_FAIL;
   Shallow(GD_SELF);
@@ -122,7 +121,6 @@
       Shallow(GD_OTHER);
     }
   }
-  set_heapp(g_allocp);
 }
 
 GDDEF_GC()
@@ -257,9 +255,7 @@
   body = GD_SELF->body;
   GDSET_INTARG_WITHIN_RANGE(position,GD_ARGV[0],0,size);
   GDSET_INTARG_WITHIN_RANGE(newelem,GD_ARGV[1],0,256);
-  set_heapp(g_allocp);
   GDSET_NEWOBJ(newstr);
-  assert(g_allocp == heapp());
   if (!iscnst) {
     unsigned char olddata = body[position];
 
@@ -271,9 +267,7 @@
   } else {
     unsigned char *newbody;
     unsigned long qsize = ROUND_UP(size);
-    assert(g_allocp == heapp());
     GD_ALLOC_AREA(newbody, (unsigned char *), qsize);
-    assert(g_allocp == heapp());
     BCOPY(body, newbody, qsize*sizeof(q));
     newbody[position] = newelem;
     newstr->body = newbody;
@@ -297,15 +291,10 @@
   size = GD_SELF->index;
   GDSET_INTARG_WITHIN_RANGE(split_point,GD_ARGV[0],0,size+1);
   lower_size = size-split_point;
-  set_heapp(g_allocp);
   GD_ALLOC_AREA(upper_body, (unsigned char *), ROUND_UP(split_point));
-  assert(g_allocp == heapp());
   GD_ALLOC_AREA(lower_body, (unsigned char *), ROUND_UP(lower_size));
-  assert(g_allocp == heapp());
   GD_ALLOC_AREA(upper, (GD_OBJ_TYPE *), GD_OBJ_SIZE(GD_SELF));
-  assert(g_allocp == heapp());
   GD_ALLOC_AREA(lower, (GD_OBJ_TYPE *), GD_OBJ_SIZE(GD_SELF));
-  assert(g_allocp == heapp());
   BCOPY(GD_SELF->body, upper_body, split_point);
   BCOPY(GD_SELF->body+split_point, lower_body, lower_size);
   upper->method_table = lower->method_table = GD_SELF->method_table;
@@ -341,11 +330,8 @@
   Shallow(another);
   size2 = another->index;
   newsize = size1+size2;
-  set_heapp(g_allocp);
   GD_ALLOC_AREA(newbody, (unsigned char *), ROUND_UP(newsize));
-  assert(g_allocp == heapp());
   GD_ALLOC_AREA(new, (GD_OBJ_TYPE *), GD_OBJ_SIZE(GD_SELF));
-  assert(g_allocp == heapp());
   Shallow(GD_SELF);
   BCOPY(GD_SELF->body, newbody, size1);
   Shallow(another);
@@ -392,7 +378,6 @@
 GDDEF_GENERIC()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
 
   GD_SWITCH_ON_METHOD{
     GD_METHOD_CASE(string_2);
@@ -405,7 +390,6 @@
     GD_METHOD_CASE(search__character_4);
     GD_METHOD_CASE_DEFAULT;
   }
-  set_heapp(g_allocp);
 }
 
 /* guard generic methods */
@@ -616,22 +600,17 @@
   unsigned char *body;
   long size;
   q init;
-  q* g_allocp = heapp();
 
   if (GD_ARGC!=1) GD_ERROR_IN_NEW("Too few or too many arguments");
   init = GD_ARGV[0];
   GD_DEREF_FOR_NEW(init);
-  set_heapp(g_allocp);
   GDSET_NEWOBJ_FOR_NEW(newstr, G_SIZE_IN_Q(GD_OBJ_TYPE));
-  assert(g_allocp == heapp());
   if (G_ISINT(init)) {
     unsigned long qsize;
     size = G_INTVAL(init);
     if (size < 0) GD_ERROR_IN_NEW("Negative size specified");
     qsize = ROUND_UP(size);
-    assert(g_allocp == heapp());
     GD_ALLOC_AREA_FOR_NEW(body, (unsigned char *), qsize);
-    assert(g_allocp == heapp());
     BZERO(body, qsize*sizeof(q));
   } else if (init==NILATOM || G_ISCONS(init)) {
     unsigned long qsize, k;
@@ -650,9 +629,7 @@
     }
     qsize = ROUND_UP(size);
     init = GD_ARGV[0];
-    set_heapp(g_allocp);
     GD_ALLOC_AREA_FOR_NEW(body, (unsigned char *), qsize);
-    assert(g_allocp == heapp());
     for (k=0; k<size; k++) {
       q elem;
       GD_DEREF_FOR_NEW(init);
@@ -668,7 +645,6 @@
   newstr->iscnst = 0;
   newstr->index = size;
   newstr->body = body;
-  set_heapp(g_allocp);
   GD_RETURN_FROM_NEW(newstr);
 }
 
@@ -689,7 +665,6 @@
   set_heapp(g_allocp);
   G_HEAPALLOC_WITH_CHECK(newstring, G_SIZE_IN_Q(GD_OBJ_TYPE), 
 			  (GD_OBJ_TYPE*), res);
-  assert(g_allocp == heapp());
   /* G_HEAPALLOC(newstring, G_SIZE_IN_Q(GD_OBJ_TYPE), (GD_OBJ_TYPE*)); */
 
   if(GENERIC_GCREQUEST == res){ 
@@ -698,7 +673,7 @@
       inbuf->rd_index--;
 
       /* fprintf(stderr, "Node %d Heap shortage in decoding string(1)", my_node); */
-      return(g_allocp);
+      return heapp();
   }
   newstring->method_table = &GD_method_table;
   newstring->index = (long)GET_BUFFER(inbuf);
@@ -707,9 +682,7 @@
 
   {
     q *tmpbody;
-    set_heapp(g_allocp);
     G_HEAPALLOC_WITH_CHECK(tmpbody, size, (q*), res); 
-    assert(g_allocp == heapp());
     body = (unsigned char *) tmpbody;
   }
   /* G_HEAPALLOC(body, size, (unsigned char*)); */
@@ -720,7 +693,7 @@
       inbuf->rd_index -= 2;
 
       /* fprintf(stderr, "Node %d Heap shortage in decoding string(2)", my_node); */
-      return(g_allocp);
+      return heapp();
   }
 
   tmp_buf = (long *)body;
@@ -734,7 +707,7 @@
 
   /* decode_data = (q) makefunctor(newstring); */
   push_decode_stack((q)makefunctor(newstring));
-  return(g_allocp);
+  return heapp();
 }
 #endif /* DIST */
 
@@ -829,11 +802,9 @@
 {
   GD_STD_DECL_FOR_NEW;
   long elemsize;
-  q* g_allocp = heapp();
 
   if (GD_ARGC!=2) GD_ERROR_IN_NEW("Too few or too many arguments");
   GDSET_INTARG_FOR_NEW(elemsize, GD_ARGV[1]);
   if (elemsize != 8) GD_ERROR_IN_NEW("Only byte strings are supported now");
-  set_heapp(g_allocp);
   return byte__string_g_new(1, GD_ARGV);
 }
diff -ruN klic-3.003-2002-03-11b/runtime/gtermarray.c klic-3.003-2002-03-11c/runtime/gtermarray.c
--- klic-3.003-2002-03-11b/runtime/gtermarray.c	Mon Mar 11 16:30:01 2002
+++ klic-3.003-2002-03-11c/runtime/gtermarray.c	Mon Mar 11 17:27:36 2002
@@ -60,16 +60,13 @@
   unsigned long size = GD_ARGC;
   GD_OBJ_TYPE *newobj;
   int i;
-  q* g_allocp = heapp();
 
   G_HEAPALLOC(newobj,G_SIZE_IN_Q(GD_OBJ_TYPE)+size-1,(GD_OBJ_TYPE *));
-  assert(g_allocp == heapp());
   newobj->method_table = &GD_method_table;
   newobj->nterm = size;
   for (i=0; i<size; i++) {
     newobj->terms[i] = GD_ARGV[i];
   }
-  assert(g_allocp == heapp());
   GD_RETURN_FROM_NEW(newobj);
 }
 
diff -ruN klic-3.003-2002-03-11b/runtime/random.c klic-3.003-2002-03-11c/runtime/random.c
--- klic-3.003-2002-03-11b/runtime/random.c	Mon Mar 11 16:29:39 2002
+++ klic-3.003-2002-03-11c/runtime/random.c	Mon Mar 11 17:27:59 2002
@@ -42,7 +42,6 @@
   q var;
   long one_random;
   struct generator_susp* s;
-  q* g_allocp = heapp();
 
   GG_TRY_TO_ALLOC(cons, makecons, 2, gc_request);
   GG_TRY_TO_ALLOC(var, makeref, 1, gc_request);
@@ -58,10 +57,8 @@
   cdr_of(cons) = var;
   s->backpt = makeref(var);
   s->u.o = tag_generator_susp(GG_SELF);
-  set_heapp(g_allocp);
   return cons;
  gc_request:
-  set_heapp(g_allocp);
   return 0;
 }
 
@@ -101,7 +98,6 @@
   GG_OBJ_TYPE* obj;
   long seed;
   long range;
-  q* g_allocp = heapp();
 
   if( GG_ARGC < 1 || 2 < GG_ARGC ){
     fatalf("Wrong number of arguments (%d) in creation of random number generator",
@@ -118,16 +114,13 @@
     fatalf("Invalid first argument (%d) in creation of random number generator",
 	   range);
   }
-  set_heapp(g_allocp);
   GGSET_NEWOBJ_FOR_NEW(obj, (GG_OBJ_TYPE*));
-  assert(g_allocp == heapp());
 
   obj->state[0] = seed >> (sizeof(seed)*4);
   obj->state[1] = seed >> (sizeof(seed)*2);
   obj->state[2] = seed >> (sizeof(seed)*0);
   obj->range = range;
   obj->max = ((((unsigned long)(~0))<<1)>>1)/range*range;
-  assert(g_allocp == heapp());
   GG_RETURN_FROM_NEW(GG_MAKE_HOOK_VAR(obj));
 }
 #endif  /* NRAND48 */
diff -ruN klic-3.003-2002-03-11b/runtime/wakeup.c klic-3.003-2002-03-11c/runtime/wakeup.c
--- klic-3.003-2002-03-11b/runtime/wakeup.c	Mon Mar 11 16:28:49 2002
+++ klic-3.003-2002-03-11c/runtime/wakeup.c	Mon Mar 11 17:28:10 2002
@@ -26,10 +26,8 @@
 GCDEF_UNIFY()
 {
   G_STD_DECL;
-  q* g_allocp = heapp();
 
   GC_KL1_UNIFY(GC_SELF->x,GC_SELF->y);
-  assert(g_allocp == heapp());
   GC_TERMINATE;
 }
 
@@ -65,12 +63,10 @@
   GC_STD_DECL_FOR_NEW;
   GC_OBJ_TYPE *wakeup;
   q var;
-  q* g_allocp = heapp();
 
   if (GC_ARGC != 2) GC_FAIL("arity mismatch in creation of a merger.");
 
   GCSET_NEWOBJ_FOR_NEW(wakeup,GC_OBJ_SIZE(wakeup));
-  assert(g_allocp == heapp());
   wakeup->x = GC_ARGV[0];
   wakeup->y = GC_ARGV[1];
   var = GC_MAKE_HOOK_VAR((struct consumer_object*) wakeup);