diff -ruN klic-3.003-2002-03-21/include/klic/g_basic.h klic-3.003-2002-03-23/include/klic/g_basic.h
--- klic-3.003-2002-03-21/include/klic/g_basic.h	Thu Mar 21 21:58:37 2002
+++ klic-3.003-2002-03-23/include/klic/g_basic.h	Sat Mar 23 21:34:27 2002
@@ -10,6 +10,7 @@
 
 #include <assert.h>
 #include <klic/stdc.h>  /* CONCATENATE*, STRINGIFY */
+#include <klic/g_methtab.h>  /* struct object */
 
 /* external module/class reference */
 
@@ -17,34 +18,10 @@
 extern const struct predicate name
 
 /* type judgement. */
-#define G_ISCONS(x) iscons(x)
-#define G_ISFUNCTOR(x) isfunctor(x)
-#define G_ISREF(x) isref(x)
-#define G_ISINT(x) isint(x)
-#define G_ISSYM(x) issym(x)
 #define G_ISGOBJ(x) (isfunctor(x) && isref(functor_of(x)))
 
-/* data manipulation macro. */
-#define G_FUNCTOR_OF(s) functor_of(s)
-#define G_ARG(s, k) arg(s, k)
-#define G_CAR_OF(x) car_of(x)
-#define G_CDR_OF(x) cdr_of(x)
-#define G_DEREFONE(x) derefone(x)
-
-/* convertion. C->KLIC. */
-#define G_MAKEINT(n) makeint(n)
-#define G_MAKEREF(x) makeref(x)
-#define G_MAKECONS(x) makecons(x)
-#define G_MAKEFUNCTOR(x) makefunctor(x)
-
-/* convertion. KLIC->C. */
-#define G_INTVAL(x) intval(x)
-#define G_SYMVAL(x) symval(x)
-#define G_FUNCTORP(x) functorp(x)
-
 #define G_functor(fa)  CONCATENATE(functor_, fa)
 #define G_atom(fa)     CONCATENATE(atom_, fa)
-#define G_stringify(s) STRINGIFY(s)
 
 #define G_rappend0(class,post) CONCATENATE_3(class, _g_, post)
 #define G_guard0(class,fa)     CONCATENATE_3(class, _g_guard_, fa)
@@ -56,7 +33,7 @@
 
 #define G_method_table  G_method_table0(CLASS_NAME)
 
-#define G_CLASS_NAME_STRING  G_stringify(CLASS_NAME)
+#define G_CLASS_NAME_STRING  STRINGIFY(CLASS_NAME)
 
 #define	G_ERROR_IN_NEW(errmsg) \
   G_error((errmsg), "creation", "", G_CLASS_NAME_STRING)
@@ -95,6 +72,20 @@
 
 #define G_DEF_NEW()  extern q G_rappend(new) (long g_argc, q* g_argv)
 
+#define G_DEF_PRINT() \
+static long G_rappend(print) \
+  (G_OBJ_TYPE* g_self, FILE* g_fp, unsigned long g_depth, unsigned long g_length)
+
+#define G_DEF_GC()  static q* G_rappend(gc) (G_OBJ_TYPE* g_self)
+
+#define G_DEF_DEALLOCATE() \
+static void G_rappend(deallocate) (G_OBJ_TYPE* g_self)
+
+#define G_DEF_ENCODE() \
+static q G_rappend(encode) (G_OBJ_TYPE* g_self, combuf* buffer, long depth)
+
+#define G_PRINT(x)  (klic_fprintf(g_fp, (x)))
+
 #define G_STD_DECL_FOR_NEW() \
   G_STD_DECL; \
   q (*g_myself)() = G_rappend(new)
@@ -115,6 +106,28 @@
   } \
 }while(0)
 
+#define G_SET_NEWOBJ_FOR_NEW(newgobj,size) \
+do{ \
+  q res; \
+  G_HEAPALLOC_WITH_CHECK((newgobj), (size), (G_OBJ_TYPE*), res); \
+  if(res == GENERIC_GCREQUEST){ \
+    q var; \
+    struct goalrec* goal; \
+    G_MAKE_THE_NEW_GOAL(&var, &goal, g_myself, g_argc, g_argv); \
+    resume_same_prio(goal); \
+    return var; \
+  } \
+  (newgobj)->method_table = &G_method_table; \
+}while(0)
+
+#define G_SET_NEWOBJ_IN_NEWGEN(newobj) \
+do{ \
+  unsigned long size = G_OBJ_SIZE; \
+  (newobj) = (G_OBJ_TYPE*) klic_alloc(size); \
+  (newobj)->method_table = g_self->method_table; \
+  if( heapp() > real_heaplimit() ) fatal("not enough space collected"); \
+}while(0)
+
 
 /** G_HEAPALLOC: procedure
  * from: type&
@@ -182,17 +195,6 @@
 }while(0)
 
 
-/** G_PUSH_GOAL: procedure
- * goal: struct goalrec*
- */
-
-#define G_PUSH_GOAL(goal) \
-do{ resume_same_prio(goal); }while(0)
-
-#define G_PUSH_GOAL_TO_SPECIAL_QUEUE(goal) \
-  G_PUSH_GOAL(goal)
-
-
 /* deta flag for Object Table */
 enum g_type { G_DATA, G_CONSUMER, G_GENERATOR };
 
@@ -209,5 +211,19 @@
 G_MAKE_THE_NEW_GOAL(q* var, struct goalrec** goalp1,
   q (*myself)(), unsigned long argc, q* argv );
 
+extern void G_SUSPEND(q x, struct goalrec* goal);
+
+extern long G_STD_PRINT(
+  struct object* g_self, FILE* g_fp,
+  unsigned long g_depth, unsigned long g_length );
+
+extern q* G_STD_GC(struct object* g_self);
+extern void G_STD_DEALLOCATE(struct object* g_self);
+extern q G_STD_ENCODE(struct object* self, void* buffer);
+
+
+/* runtime/unify.c */
+extern void do_shallow_unify(q x, q y);
+extern void do_shallow_unify_value(q x, q y);
 
 #endif /* _KLIC_G_BASIC_H_ */
diff -ruN klic-3.003-2002-03-21/include/klic/g_extern.h klic-3.003-2002-03-23/include/klic/g_extern.h
--- klic-3.003-2002-03-21/include/klic/g_extern.h	Wed Mar 20 15:35:27 2002
+++ klic-3.003-2002-03-23/include/klic/g_extern.h	Sat Mar 23 21:34:01 2002
@@ -13,7 +13,7 @@
 
 /* runtime/print.c */
 extern void general_print(
-  q* a, FILE* stream, unsigned long depth, unsigned long length );
+  q a, FILE* stream, unsigned long depth, unsigned long length );
 
 /* runtime/gen.c */
 extern struct predicate predicate_generic_xnew_3;
diff -ruN klic-3.003-2002-03-21/include/klic/g_methtab.h klic-3.003-2002-03-23/include/klic/g_methtab.h
--- klic-3.003-2002-03-21/include/klic/g_methtab.h	Tue Mar 19 14:24:19 2002
+++ klic-3.003-2002-03-23/include/klic/g_methtab.h	Sat Mar 23 21:34:01 2002
@@ -12,25 +12,36 @@
 #define GENERIC_FAILED     ((q) 1L)
 #define GENERIC_GCREQUEST  ((q) 2L)
 
-/*
-  Data Object
-*/
+struct object {
+  struct object_method_table* method_table;
+};
+
+struct object_method_table {
+  long (*print) (struct object* g_self, FILE* g_fp,
+		 unsigned long g_depth, unsigned long g_length );
+  q* (*gc) (struct object* g_self);
+  void (*deallocate) (struct object* g_self);
+  q (*encode) (struct object* g_self, void* buffer, long depth);
+};
+
+
+/* Data Object */
 
 struct data_object {
-  struct data_object_method_table *method_table;
+  struct data_object_method_table* method_table;
 };
 
 struct data_object_method_table {
+  long (*print) (struct object* g_self, FILE* g_fp,
+		 unsigned long g_depth, unsigned long g_length );
+  q* (*gc) (struct object* g_self);
+  void (*deallocate) (struct object* g_self);
+  q (*encode) (struct object* g_self, void* buffer, long depth);
+
   q (*passive_unify)( /* struct data_object *one,
 			 struct data_object *another */ );
   void (*active_unify)( /* struct data_object* one,
               with method_result      struct data_object* another */ );
-  long (*print)( /* struct iimutable_object * obj,
-		    FILE *out_stream,
-		    unsigned long depth,
-		    unsigned long length */ );
-  q* (*gc)( /* struct data_object* obj */ );
-  void (*deallocate)( /* struct data_object* obj */ );
   void (*body_generic)( /* struct data_object* obj,
 				      q method_functor,
 				      q* argv */ );
@@ -40,52 +51,46 @@
   q (*compare)( /* struct data_object *obj,
 		   struct data_object *another_obj */ );
   q (*hash)( /* struct data_object *obj, unsigned long level */ );
-  q (*encode)(/* struct data_object *obj, long node */);
 };
 
 #define data_objectp(obj) \
-  ((struct data_object *) (((unsigned long)(obj)) - FUNCTOR))
+  ((struct data_object*) (((unsigned long) (obj)) - FUNCTOR))
 
 
-/*
-  Consumer Object
-*/
+/* Consumer Object */
 
 struct consumer_object {
-  struct consumer_object_method_table *method_table;
+  struct consumer_object_method_table* method_table;
 };
 
 struct consumer_object_method_table {
+  long (*print) (struct object* g_self, FILE* g_fp,
+		 unsigned long g_depth, unsigned long g_length );
+  q* (*gc) (struct object* g_self);
+  void (*deallocate) (struct object* g_self);
+  q (*encode) (struct object* g_self, void* buffer, long depth);
+
   void (*active_unify)(/* struct consumer_object* self,
 		with method_result   q other */ );
-  long (*print)(/* struct consumer_object *obj,
-		  FILE *out_stream,
-		  unsigned long max_depth,
-		  unsigned long max_length */);
-  q* (*gc)(/* struct consumer_object* obj */);
-  void (*deallocate)( /* struct consumer_object* obj */ );
-  q (*encode)(/* struct consumer_object *obj, long node */);
 };
 
-/*
-  Generator Object
-*/
+
+/* Generator Object */
 		    
 struct generator_object {
   struct generator_object_method_table* method_table;
 };
 
 struct generator_object_method_table {
+  long (*print) (struct object* g_self, FILE* g_fp,
+		 unsigned long g_depth, unsigned long g_length );
+  q* (*gc) (struct object* g_self);
+  void (*deallocate) (struct object* g_self);
+  q (*encode) (struct object* g_self, void* buffer, long depth);
+
   int (*active_unify)(/* q self, q other */);
   q (*generate)(/* struct generator_object* self */);
   q (*suspend)(/* q reference, struct goalrec* goal */);
-  long (*print)/* print what ? */ (/* struct generator_object* self,
-		  FILE* out_stream,
-		  unsigned long max_depth,
-		  unsigned long max_length */);
-  q* (*gc)(/* struct generator_object* self */);
-  void (*deallocate)(/* struct generator_object* self */);
-  q (*encode)(/* struct generator_object* self, long node */);
 };
 
 #endif /* _KLIC_G_METHTAB_H_ */
diff -ruN klic-3.003-2002-03-21/include/klic/gc_macro.h klic-3.003-2002-03-23/include/klic/gc_macro.h
--- klic-3.003-2002-03-21/include/klic/gc_macro.h	Thu Mar 21 21:57:07 2002
+++ klic-3.003-2002-03-23/include/klic/gc_macro.h	Sat Mar 23 21:34:01 2002
@@ -13,12 +13,9 @@
 #include <klic/g_basic.h>
 
 /* runtime/unify.c */
-extern void do_shallow_unify(q x, q y);
-extern void do_shallow_unify_value(q x, q y);
 extern void set_rest_of_stream(q term);
 
 /* runtime/generic.c */
-extern void G_SUSPEND(q x, struct goalrec* goal);
 extern q GC_MAKE_HOOK_VAR(struct consumer_object* obj);
 
 #define    GC_RETURN_WITH_HOOK(x) \
@@ -42,68 +39,22 @@
   if (res == GENERIC_GCREQUEST) goto gc_request; \
 }while(0)
 
-/**************************************************************************/
-
-#define GCSET_NEWOBJ_FOR_NEW(newgobj,size) \
-do{ \
-  q res; \
-  G_HEAPALLOC_WITH_CHECK((newgobj), (size), (GC_OBJ_TYPE*), res); \
-  if(res == GENERIC_GCREQUEST){ \
-    q var; \
-    struct goalrec *goal; \
-    G_MAKE_THE_NEW_GOAL(&var, &goal, g_myself, g_argc, g_argv); \
-    G_PUSH_GOAL_TO_SPECIAL_QUEUE(goal); \
-    return var; \
-  } \
-  (newgobj)->method_table = &G_method_table; \
-}while(0)
-
-
 /**********************************************************************/
 
 #define GCDEF_UNIFY() \
-static void G_rappend(active_unify) (GC_OBJ_TYPE* GC_SELF, q g_term)
-
-#define GC_PRINT(x) klic_fprintf(g_fp, (x))
-
-#define GCDEF_PRINT() \
-  static \
-  long \
-  G_rappend(print) (GC_SELF,g_fp,g_depth,g_length) \
-    GC_OBJ_TYPE *GC_SELF; \
-    FILE *g_fp; \
-    unsigned long g_depth; \
-    unsigned long g_length;
-
-/******************************************************************/
-
-#define GCDEF_GC() \
-static q* G_rappend(gc) (GC_OBJ_TYPE* GC_SELF)
-
-#define GCSET_NEWOBJ_IN_NEWGEN(newobj) \
-do{ \
-  unsigned long size = GC_OBJ_SIZE(GC_SELF); \
-  *heapp() = (q) GC_SELF->method_table; \
-  (newobj) = (GC_OBJ_TYPE*) klic_alloc(size); \
-  if(heapp() > real_heaplimit()) fatal("not enough space collected"); \
-}while(0)
-
-#define GCDEF_DEALLOCATE() \
-  static void \
-  G_rappend(deallocate) (GC_SELF) \
-    GC_OBJ_TYPE* GC_SELF;
+static void G_rappend(active_unify) (G_OBJ_TYPE* g_self, q g_term)
 
 /*******************************************/
 
 #define GCSET_MESSAGE(message)					\
 do{								\
-  (message) = G_CAR_OF(g_term);				\
-  while (G_ISREF(message)) {					\
-    q temp = G_DEREFONE(message);				\
-    if (G_ISREF(temp) &&					\
-	(temp == (message) || G_DEREFONE(temp) == (message))) {	\
+  (message) = car_of(g_term);				\
+  while( isref(message) ){					\
+    q temp = derefone(message);				\
+    if( isref(temp) &&					\
+	(temp == (message) || derefone(temp) == (message))) {	\
       reason = (message);					\
-      GC_SELF->stream = g_term;				\
+      g_self->stream = g_term;				\
       goto suspend;						\
     } else {							\
       (message) = temp;						\
@@ -111,15 +62,15 @@
   }								\
 }while(0)
 
-#define GCSET_MESSAGE_INT_ARG(arg, message, pos)		\
+#define GCSET_MESSAGE_INT_ARG(_arg, message, pos)		\
 do{								\
-  q temp = G_ARG((message), (pos));				\
-  while (!G_ISINT(temp)) {					\
-    if (G_ISREF(temp)) {					\
-      q temp1 = G_DEREFONE(temp);				\
-      if (G_ISREF(temp1) && G_DEREFONE(temp1) == temp) {	\
+  q temp = arg((message), (pos));				\
+  while( !isint(temp) ){					\
+    if( isref(temp) ){					\
+      q temp1 = derefone(temp);				\
+      if( isref(temp1) && derefone(temp1) == temp ){	\
 	reason = temp1;						\
-	GC_SELF->stream = g_term;				\
+	g_self->stream = g_term;				\
 	goto suspend;						\
       }								\
       temp = temp1;						\
@@ -127,21 +78,21 @@
       goto message_error;					\
     }								\
   }								\
-  (arg) = G_INTVAL(temp);					\
+  (_arg) = intval(temp);					\
 }while(0)
 
-#define GCSET_MESSAGE_STR_ARG(arg, message, pos)		\
+#define GCSET_MESSAGE_STR_ARG(_arg, message, pos)		\
 do{								\
-  q temp = G_ARG((message), (pos));				\
+  q temp = arg((message), (pos));				\
   while (!G_ISGOBJ(temp) ||					\
 	 (struct data_object_method_table *)			\
-	 G_FUNCTOR_OF(temp) !=					\
+	 functor_of(temp) !=					\
 	 &byte__string_g_method_table) {			\
-    if (G_ISREF(temp)) {					\
-      q temp1 = G_DEREFONE(temp);				\
-      if (G_ISREF(temp1) && G_DEREFONE(temp1) == temp) {	\
+    if( isref(temp) ){					\
+      q temp1 = derefone(temp);				\
+      if( isref(temp1) && derefone(temp1) == temp ){	\
 	reason = temp1;						\
-	GC_SELF->stream = g_term;				\
+	g_self->stream = g_term;				\
 	goto suspend;						\
       }								\
       temp = temp1;						\
@@ -149,10 +100,10 @@
       goto message_error;					\
     }								\
   }								\
-  (arg) = (struct byte_string_object *) G_FUNCTORP(temp);	\
+  (_arg) = (struct byte_string_object*) functorp(temp);	\
 }while(0)
 
-#define GCSET_VAR(self)  ((self) = G_MAKEREF(&(self)))
+#define GCSET_VAR(self)  ((self) = makeref(&(self)))
 
 extern struct predicate predicate_unify__term__dcode_xunify__goal_2;
 #define GC_KL1_UNIFY(x, y) \
diff -ruN klic-3.003-2002-03-21/include/klic/gc_methtab.h klic-3.003-2002-03-23/include/klic/gc_methtab.h
--- klic-3.003-2002-03-21/include/klic/gc_methtab.h	Wed Mar 20 15:35:27 2002
+++ klic-3.003-2002-03-23/include/klic/gc_methtab.h	Sat Mar 23 21:34:01 2002
@@ -8,42 +8,35 @@
 #ifndef _KLIC_GC_METHTAB_H_
 #define _KLIC_GC_METHTAB_H_
 
-/* runtime/generic.c */
-extern void GD_STD_DEALLOCATE(struct data_object* GD_SELF);
-extern q GD_STD_ENCODE(struct data_object* self, void* buffer);
-
-#define GC_STD_DEALLOCATE GD_STD_DEALLOCATE
-#define GC_STD_ENCODE GD_STD_ENCODE
-
 struct consumer_object_method_table G_method_table = {
-#ifndef GCUSE_MY_UNIFY
-#error "please GCDEF_UNIFY and GCUSE_MY_UNIFY"
-#else
-  G_rappend(active_unify) ,
-#endif
-
 #ifndef GCUSE_MY_PRINT
-#error "please GCDEF_PRINT and GCUSE_MY_PRINT"
+  G_STD_PRINT,
 #else
- G_rappend(print) ,
+  G_rappend(print),
 #endif
 
 #ifndef GCUSE_MY_GC
-#error "please GCDEF_GC and GCUSE_MY_GC"
+  G_STD_GC,
 #else
- G_rappend(gc) ,
+  G_rappend(gc),
 #endif
 
 #ifndef GCUSE_MY_DEALLOCATE
- GC_STD_DEALLOCATE ,
+  G_STD_DEALLOCATE,
 #else
- G_rappend(deallocate) ,
+  G_rappend(deallocate),
 #endif
 
 #ifndef GCUSE_MY_ENCODE
- GC_STD_ENCODE 
+  G_STD_ENCODE,
+#else
+  G_rappend(encode),
+#endif
+
+#ifndef GCUSE_MY_UNIFY
+#error "please GCDEF_UNIFY and GCUSE_MY_UNIFY"
 #else
- G_rappend(encode) 
+  G_rappend(active_unify)
 #endif
 };
 
diff -ruN klic-3.003-2002-03-21/include/klic/gd_macro.h klic-3.003-2002-03-23/include/klic/gd_macro.h
--- klic-3.003-2002-03-21/include/klic/gd_macro.h	Thu Mar 21 21:58:58 2002
+++ klic-3.003-2002-03-23/include/klic/gd_macro.h	Sat Mar 23 21:34:01 2002
@@ -16,24 +16,15 @@
 /* runtime/unify2.c */
 extern q eq_terms_body(q x, q y);
 
-/* runtime/unify.c */
-extern void do_shallow_unify(q x, q y);
-extern void do_shallow_unify_value(q x, q y);
-
-
 /* runtime/generic.c */
-
 extern void GD_MAKE_GENERIC_GOAL(
   struct goalrec** goalp1, q var,
   unsigned long method_functor, q argv[] );
 
-extern void G_SUSPEND(q x, struct goalrec* goal);
-
-
 #define GD_guard(fa) G_guard0(CLASS_NAME,fa)
 #define GD_body(fa) G_body0(CLASS_NAME,fa)
 
-#define GD_OBJ(x) G_MAKEFUNCTOR(x)
+#define GD_OBJ(x)  makefunctor(x)
 
 #define GD_USE_CLASS(class) \
 extern struct data_object_method_table G_method_table0(class)
@@ -56,9 +47,9 @@
   G_HEAPALLOC_WITH_CHECK((new), (size), type, res); \
   if(res == GENERIC_GCREQUEST){ \
     struct goalrec *goal; \
-    GD_MAKE_GENERIC_GOAL(&goal, makefunctor(GD_SELF), g_method_functor, \
+    GD_MAKE_GENERIC_GOAL(&goal, makefunctor(g_self), g_method_functor, \
 			 g_argv ); \
-    G_PUSH_GOAL(goal); \
+    resume_same_prio(goal); \
     return; \
   } \
 }while(0)
@@ -71,48 +62,25 @@
     q var; \
     struct goalrec *goal; \
     G_MAKE_THE_NEW_GOAL(&var, &goal, g_myself, g_argc, g_argv); \
-    G_PUSH_GOAL_TO_SPECIAL_QUEUE(goal); \
+    resume_same_prio(goal); \
     return var; \
   } \
 }while(0)
 
 /***************************************************************************/
 
-#define GDSET_NEWOBJ_FOR_NEW(newgobj,size) \
-do{ \
-  q res; \
-  G_HEAPALLOC_WITH_CHECK((newgobj), (size), (GD_OBJ_TYPE*), res); \
-  if(res == GENERIC_GCREQUEST){ \
-    q var; \
-    struct goalrec *goal; \
-    G_MAKE_THE_NEW_GOAL(&var, &goal, g_myself, g_argc, g_argv); \
-    G_PUSH_GOAL_TO_SPECIAL_QUEUE(goal); \
-    return var; \
-  } \
-  (newgobj)->method_table = &G_method_table; \
-}while(0)
-
 #define GDSET_NEWOBJ(newgobj) \
 do{ \
   q res; \
-  G_HEAPALLOC_WITH_CHECK((newgobj), GD_OBJ_SIZE(GD_SELF), \
-			 (GD_OBJ_TYPE*), res); \
+  G_HEAPALLOC_WITH_CHECK((newgobj), G_OBJ_SIZE, (G_OBJ_TYPE*), res); \
   if (res == GENERIC_GCREQUEST) { \
     struct goalrec *goal; \
-    GD_MAKE_GENERIC_GOAL(&goal, makefunctor(GD_SELF), \
+    GD_MAKE_GENERIC_GOAL(&goal, makefunctor(g_self), \
 			 g_method_functor, g_argv ); \
-    G_PUSH_GOAL(goal); \
+    resume_same_prio(goal); \
     return; \
   } \
-  (newgobj)->method_table = GD_SELF->method_table; \
-}while(0)
-
-#define GDSET_NEWOBJ_IN_NEWGEN(newobj) \
-do{ \
-  unsigned long size = GD_OBJ_SIZE(GD_SELF); \
-  (newobj) = (GD_OBJ_TYPE*) klic_alloc(size); \
-  (newobj)->method_table = GD_SELF->method_table; \
-  if(heapp() > real_heaplimit()) fatal("not enough space collected"); \
+  (newgobj)->method_table = g_self->method_table; \
 }while(0)
 
 /***************************************************************************/
@@ -146,7 +114,7 @@
 	q temp0 = derefone(x); \
 	if(isref(temp0) && (x) == derefone(temp0)) { \
           struct goalrec *goal; \
-	  GD_MAKE_GENERIC_GOAL(&goal, makefunctor(GD_SELF), \
+	  GD_MAKE_GENERIC_GOAL(&goal, makefunctor(g_self), \
 				g_method_functor, g_argv ); \
           G_SUSPEND((x), goal); \
           return; \
@@ -179,7 +147,7 @@
 
 #define GD_METHOD_CASE(fa) \
    case (long) G_functor(fa): \
-  GD_body(fa) (GD_SELF, g_method_functor, g_argv); \
+  GD_body(fa) (g_self, g_method_functor, g_argv); \
   break
 
 #define GD_METHOD_CASE_DEFAULT \
@@ -190,38 +158,23 @@
 
 #define GD_METHOD_NAME_CASE(sym) \
  case ((long)(G_atom(sym))) : \
-  GD_body(sym)(GD_SELF, g_method_functor, g_argv); \
+  GD_body(sym)(g_self, g_method_functor, g_argv); \
   break
 
 #define GD_METHOD_NAME_CASE_DEFAULT default: fatal("undefined method")
 
 #define GDDEF_METHOD(fa) \
-static void \
-GD_body(fa) (GD_OBJ_TYPE* GD_SELF, long g_method_functor, q* g_argv)
+static void GD_body(fa) (G_OBJ_TYPE* g_self, long g_method_functor, q* g_argv)
 
 /**********************************************************************/
 #define GDDEF_GUNIFY() \
-static q \
-  G_rappend(passive_unify) (GD_SELF, GD_OTHER) \
-    GD_OBJ_TYPE * GD_SELF; \
-    GD_OBJ_TYPE * GD_OTHER;
+static q G_rappend(passive_unify) (G_OBJ_TYPE* g_self, G_OBJ_TYPE* GD_OTHER)
 
 #define GDDEF_UNIFY() \
-static void \
-G_rappend(active_unify) (GD_OBJ_TYPE* GD_SELF, GD_OBJ_TYPE* GD_OTHER)
+static void G_rappend(active_unify) (G_OBJ_TYPE* g_self, G_OBJ_TYPE* GD_OTHER)
 
 #define GD_PUTC(x)  klic_putc((x), g_fp)
 
-#define GDDEF_PRINT() \
-  static long \
-  G_rappend(print) (GD_SELF,g_fp,g_depth,g_length) \
-    GD_OBJ_TYPE * GD_SELF; \
-    FILE *g_fp; \
-    unsigned long g_depth; \
-    unsigned long g_length;
-
-#define GD_PRINT(x) klic_fprintf(g_fp, (x))
-
 #define GD_PRINTF(s, arg) \
 do{ klic_fprintf(g_fp, (s), (arg)); }while(0)
 
@@ -231,55 +184,41 @@
 #define GD_PRINT_KL1_TERMS(x,b,s) \
 do{ \
   int i; \
-  general_print((((q *)(x))+(b)),g_fp,g_depth,g_length); \
+  general_print(((q*) (x))+(b), g_fp, g_depth, g_length); \
   for(i=(b)+1; i<(b)+(s); i++){ \
     klic_fprintf(g_fp,","); \
-    general_print((((q *)(x))+i),g_fp,g_depth,g_length); \
+    general_print(((q*) (x))+i, g_fp, g_depth, g_length); \
   } \
 }while(0)
 
 /******************************************************************/
 
 #define GDDEF_COMPARE() \
-  static q \
-  G_rappend(compare) (GD_SELF,GD_OTHER) \
-    GD_OBJ_TYPE * GD_SELF, * GD_OTHER;
+static q G_rappend(compare) (G_OBJ_TYPE* g_self, G_OBJ_TYPE* GD_OTHER)
 
 #define GDDEF_HASH() \
-  static q \
-  G_rappend(hash) (GD_SELF,GD_LEVEL) \
-    GD_OBJ_TYPE * GD_SELF; \
-    long GD_LEVEL;
-
-#define GDDEF_GC() \
-static q* G_rappend(gc) (GD_OBJ_TYPE* GD_SELF)
-
-#define GDDEF_DEALLOCATE() \
-  static void \
-  G_rappend(deallocate) (GD_SELF) \
-    GD_OBJ_TYPE* GD_SELF;
+static q G_rappend(hash) (G_OBJ_TYPE* g_self, long GD_LEVEL)
 
 #define GDDEF_GENERIC() \
 static void \
-G_rappend(generic) (GD_OBJ_TYPE* GD_SELF, long g_method_functor, q* g_argv)
+G_rappend(generic) (G_OBJ_TYPE* g_self, long g_method_functor, q* g_argv)
 
 /**********************************************************************/
 /*  guard utility */
 #define GDDEF_GGENERIC() \
 static q G_rappend(guard_generic) \
-  (GD_OBJ_TYPE* GD_SELF, long g_method_functor, q* g_argv)
+  (G_OBJ_TYPE* g_self, long g_method_functor, q* g_argv)
 
 #define GD_GMETHOD_CASE(fa) \
   case (long) G_functor(fa): \
   { \
-    q retval = (q) GD_guard(fa) (GD_SELF, g_method_functor, g_argv); \
+    q retval = (q) GD_guard(fa) (g_self, g_method_functor, g_argv); \
     GD_GRETURN(retval); \
   } \
   break
 
 #define GDDEF_GMETHOD(fa) \
-static q \
-GD_guard(fa) (GD_OBJ_TYPE* GD_SELF, long g_method_functor, q* g_argv)
+static q GD_guard(fa) (G_OBJ_TYPE* g_self, long g_method_functor, q* g_argv)
 
 #define GD_GMETHOD_CASE_DEFAULT \
   default: \
@@ -289,19 +228,19 @@
 /* utility */
 #define GDSET_INTARG_FOR_NEW(var,argv_i) \
 do{ \
-  while (!G_ISINT(argv_i)) { \
-    if (!G_ISREF(argv_i)) { \
+  while( !isint(argv_i) ){ \
+    if( !isref(argv_i) ){ \
       G_ERROR_IN_NEW("Non-integer parameter"); \
     } \
     G_DEREF_FOR_NEW(argv_i); \
   } \
-  (var) = G_INTVAL(argv_i); \
+  (var) = intval(argv_i); \
 }while(0)
 
 #define GDSET_SYMARG_FOR_NEW(var, arg) \
 do{ \
-  while (!G_ISSYM(arg)) { \
-    if (!G_ISREF(arg)) G_ERROR_IN_NEW("Non-atom paramter"); \
+  while( !issym(arg) ){ \
+    if( !isref(arg) ) G_ERROR_IN_NEW("Non-atom paramter"); \
     G_DEREF_FOR_NEW(arg); \
   } \
   (var) = (arg); \
@@ -309,22 +248,22 @@
 
 #define GDSET_INTARG_WITHIN_RANGE(var,argv_i,llim,ulim) \
 do{ \
-  while (!G_ISINT(argv_i)) { \
-    if (!G_ISREF(argv_i)) GD_ERROR_IN_METHOD("Non-integer paramter", 0); \
+  while( !isint(argv_i) ){ \
+    if( !isref(argv_i) ) GD_ERROR_IN_METHOD("Non-integer paramter", 0); \
     GD_DEREF(argv_i); \
   } \
-  (var) = G_INTVAL(argv_i); \
+  (var) = intval(argv_i); \
   if ((var) < (llim) || (ulim) <= (var)) \
     GD_ERROR_IN_METHOD("out of range", 0); \
 }while(0)
 
 #define GDSET_GINTARG_WITHIN_RANGE(var,x,from,to) \
 do{ \
-  while (!G_ISINT(x)) { \
-    if (!G_ISREF(x)) GD_GFAIL; \
+  while( !isint(x) ){ \
+    if( !isref(x) ) GD_GFAIL; \
     GD_GDEREF(x); \
   } \
-  (var) = G_INTVAL(x); \
+  (var) = intval(x); \
   if((var) < (from) || (to) <= (var)) GD_GFAIL; \
 }while(0)
 
@@ -336,13 +275,5 @@
 #define GD_CALL_GMETHOD(obj,method,argv) \
   ((q) ((((struct data_object *)functorp(obj))->method_table)->g_generic) \
          ((struct data_object *)functorp(obj), G_functor(method), (argv)))
-
-
-#define GDDEF_ENCODE() \
- q \
-  G_rappend(encode) (GD_SELF,buffer,depth) \
-    GD_OBJ_TYPE * GD_SELF; \
-    combuf *buffer; \
-    long depth;
 
 #endif /* _KLIC_GD_MACRO_H_ */
diff -ruN klic-3.003-2002-03-21/include/klic/gd_methtab.h klic-3.003-2002-03-23/include/klic/gd_methtab.h
--- klic-3.003-2002-03-21/include/klic/gd_methtab.h	Thu Mar 21 21:02:43 2002
+++ klic-3.003-2002-03-23/include/klic/gd_methtab.h	Sat Mar 23 21:34:01 2002
@@ -12,89 +12,81 @@
 /* runtime/generic.c */
 
 extern q GD_STD_GUNIFY(
-  struct data_object* GD_SELF, struct data_object* GD_OTHER );
+  struct data_object* g_self, struct data_object* GD_OTHER );
 
 extern q* GD_STD_UNIFY(
-  struct data_object* GD_SELF, struct data_object* GD_OTHER );
-
-extern long GD_STD_PRINT(
-  struct data_object* GD_SELF, FILE* g_fp,
-  unsigned long g_depth, unsigned long g_length );
-
-extern q* GD_STD_GC(struct data_object* GD_SELF);
-extern void GD_STD_DEALLOCATE(struct data_object* GD_SELF);
+  struct data_object* g_self, struct data_object* GD_OTHER );
 
 extern q* GD_STD_GENERIC(
-  struct data_object* GD_SELF, long g_method_functor, q* g_argv );
+  struct data_object* g_self, long g_method_functor, q* g_argv );
 extern q GD_STD_GGENERIC(
-  struct data_object* GD_SELF, long g_method_functor, q* g_argv );
+  struct data_object* g_self, long g_method_functor, q* g_argv );
 
 extern q GD_STD_COMPARE(
-  struct data_object* GD_SELF, struct data_object* GD_OTHER );
+  struct data_object* g_self, struct data_object* GD_OTHER );
 
-extern q GD_STD_HASH(struct data_object* GD_SELF, long level);
-extern q GD_STD_ENCODE(struct data_object* self, void* buffer);
+extern q GD_STD_HASH(struct data_object* g_self, long level);
 
 
 struct data_object_method_table G_method_table = {
-#ifndef GDUSE_MY_GUNIFY
-  GD_STD_GUNIFY ,
+#ifndef GDUSE_MY_PRINT
+  G_STD_PRINT,
 #else
-  G_rappend(passive_unify) ,
+  G_rappend(print),
 #endif
 
-#ifndef GDUSE_MY_UNIFY
-  GD_STD_UNIFY ,
+#ifndef GDUSE_MY_GC
+  G_STD_GC,
 #else
-  G_rappend(active_unify) ,
+  G_rappend(gc),
 #endif
 
-#ifndef GDUSE_MY_PRINT
- GD_STD_PRINT ,
+#ifndef GDUSE_MY_DEALLOCATE
+  G_STD_DEALLOCATE,
 #else
- G_rappend(print) ,
+  G_rappend(deallocate),
 #endif
 
-#ifndef GDUSE_MY_GC
- GD_STD_GC ,
+#ifndef GDUSE_MY_ENCODE
+  G_STD_ENCODE,
 #else
- G_rappend(gc) ,
+  G_rappend(encode),
 #endif
 
-#ifndef GDUSE_MY_DEALLOCATE
- GD_STD_DEALLOCATE ,
+#ifndef GDUSE_MY_GUNIFY
+  GD_STD_GUNIFY,
+#else
+  G_rappend(passive_unify),
+#endif
+
+#ifndef GDUSE_MY_UNIFY
+  GD_STD_UNIFY,
 #else
- G_rappend(deallocate) ,
+  G_rappend(active_unify),
 #endif
 
 #ifndef GDUSE_MY_GENERIC
- GD_STD_GENERIC ,
+  GD_STD_GENERIC,
 #else
- G_rappend(generic) ,
+  G_rappend(generic),
 #endif
 
 #ifndef GDUSE_MY_GGENERIC
- GD_STD_GGENERIC ,
+  GD_STD_GGENERIC,
 #else
- G_rappend(guard_generic) ,
+  G_rappend(guard_generic),
 #endif
 
 #ifndef GDUSE_MY_COMPARE
- GD_STD_COMPARE ,
+  GD_STD_COMPARE,
 #else
- G_rappend(compare) ,
+  G_rappend(compare),
 #endif
 
 #ifndef GDUSE_MY_HASH
- GD_STD_HASH ,
-#else
- G_rappend(hash) ,
-#endif
-
-#ifndef GDUSE_MY_ENCODE
- GD_STD_ENCODE ,
+  GD_STD_HASH
 #else
- G_rappend(encode) ,
+  G_rappend(hash)
 #endif
 };
 
diff -ruN klic-3.003-2002-03-21/include/klic/gg_macro.h klic-3.003-2002-03-23/include/klic/gg_macro.h
--- klic-3.003-2002-03-21/include/klic/gg_macro.h	Thu Mar 21 21:59:35 2002
+++ klic-3.003-2002-03-23/include/klic/gg_macro.h	Sat Mar 23 21:34:01 2002
@@ -10,17 +10,14 @@
 
 #include <klic/stdc.h>  /* CONCATENATE */
 #include <klic/basic.h>  /* fatal, klic_fprintf */
+#include <klic/g_basic.h>
 
 extern q GC_wakeup_g_new();
 
-/* runtime/unify.c */
-extern void do_shallow_unify(q x, q y);
-
 /* runtime/generic.c */
-extern void G_SUSPEND(q x, struct goalrec* goal);
 extern q GG_MAKE_HOOK_VAR(struct generator_object* obj);
 
-#define GG_OBJ_SIZE G_SIZE_IN_Q(GG_OBJ_TYPE)
+#define G_OBJ_SIZE  G_SIZE_IN_Q(G_OBJ_TYPE)
 
 #define GG_TERMINATE  do{ return !0; }while(0)
 
@@ -58,71 +55,24 @@
   } \
 }while(0)
 
-/**************************************************************************/
-
-#define GGSET_NEWOBJ_FOR_NEW(newgobj, type) \
-do{ \
-  q res; \
-  G_HEAPALLOC_WITH_CHECK((newgobj), GG_OBJ_SIZE, type, res); \
-  if(res == GENERIC_GCREQUEST) { \
-    q var; \
-    struct goalrec *goal; \
-    G_MAKE_THE_NEW_GOAL(&var, &goal, g_myself, g_argc, g_argv); \
-    G_PUSH_GOAL_TO_SPECIAL_QUEUE(goal); \
-    return var; \
-  } \
-  (newgobj)->method_table = &G_method_table; \
-}while(0)
-
 /**********************************************************************/
 
 #define GGDEF_UNIFY() \
-static int G_rappend(active_unify) (q GG_SELF, q g_term)
+static int G_rappend(active_unify) (q g_self, q g_term)
 
 #define GGDEF_SUSPEND() \
-static q \
-G_rappend(suspend) (GG_SELF, GG_GOAL) \
-  q GG_SELF; \
-  struct goalrec* GG_GOAL;
+static q G_rappend(suspend) (q g_self, struct goalrec* GG_GOAL)
 
 #define GGDEF_GENERATE() \
-static q G_rappend(generate) (GG_OBJ_TYPE* GG_SELF)
-
-#define GGDEF_PRINT() \
-  static \
-  long \
-  G_rappend(print) (GG_SELF,g_fp,g_depth,g_length) \
-    GG_OBJ_TYPE *GG_SELF; \
-    FILE *g_fp; \
-    unsigned long g_depth; \
-    unsigned long g_length;
-
-/******************************************************************/
-
-
-#define GGDEF_GC() \
-static q* G_rappend(gc) (GG_OBJ_TYPE* GG_SELF)
-
-#define GGSET_NEWOBJ_IN_NEWGEN(newobj) \
-do{ \
-  unsigned long size = GG_OBJ_SIZE; \
-  *heapp() = (q) GG_SELF->method_table; \
-  (newobj) = (GG_OBJ_TYPE *) klic_alloc(size); \
-  if(heapp() > real_heaplimit()) fatal("not enough space collected"); \
-}while(0)
-
-#define GGDEF_DEALLOCATE() \
-  static void \
-  G_rappend(deallocate) (GG_SELF) \
-    GG_OBJ_TYPE* GG_SELF;
+static q G_rappend(generate) (G_OBJ_TYPE* g_self)
 
 /*******************************************/
 
 #define GGSET_INTARG_FOR_NEW(var,argv_i) \
 do{ \
   G_DEREF_FOR_NEW(argv_i); \
-  if(!G_ISINT(argv_i)) fatal("not integer"); \
-  (var) = G_INTVAL(argv_i); \
+  if( !isint(argv_i) ) fatal("not integer"); \
+  (var) = intval(argv_i); \
 }while(0)
 
 extern struct predicate predicate_unify__term__dcode_xunify__goal_2;
@@ -135,14 +85,5 @@
   gp->args[1] = (y); \
   resume_same_prio(gp); \
 }while(0)
-
-/*** for Distribute KLIC system ***/
-
-#define GGDEF_ENCODE() \
-  static q \
-  G_rappend(encode) (GG_SELF, buffer, depth)\
-    GG_OBJ_TYPE *GG_SELF;\
-    combuf *buffer;\
-    long depth;
 
 #endif /* _KLIC_GG_MACRO_H_ */
diff -ruN klic-3.003-2002-03-21/include/klic/gg_methtab.h klic-3.003-2002-03-23/include/klic/gg_methtab.h
--- klic-3.003-2002-03-21/include/klic/gg_methtab.h	Wed Mar 20 15:35:27 2002
+++ klic-3.003-2002-03-23/include/klic/gg_methtab.h	Sat Mar 23 21:34:01 2002
@@ -10,56 +10,48 @@
 
 extern q GG_STD_SUSPEND();
 
-/* runtime/generic.c */
-extern void GD_STD_DEALLOCATE(struct data_object* GD_SELF);
-extern q GD_STD_ENCODE(struct data_object* self, void* buffer);
-
-#define GG_STD_DEALLOCATE GD_STD_DEALLOCATE
-#define GG_STD_ENCODE GD_STD_ENCODE
-
 struct generator_object_method_table G_method_table = {
-#ifndef GGUSE_MY_UNIFY
-#error "please GGDEF_UNIFY and GGUSE_MY_UNIFY"
+#ifndef GGUSE_MY_PRINT
+  G_STD_PRINT,
 #else
-  G_rappend(active_unify) ,
+  G_rappend(print),
 #endif
 
-#ifndef GGUSE_MY_GENERATE
-#error "please GGDEF_GENERATE and GGUSE_MY_GENERATE"
+#ifndef GGUSE_MY_GC
+  G_STD_GC,
 #else
-  G_rappend(generate) ,
+  G_rappend(gc),
 #endif
 
-#ifndef GGUSE_MY_SUSPEND
-  GG_STD_SUSPEND,
+#ifndef GGUSE_MY_DEALLOCATE
+  G_STD_DEALLOCATE,
 #else
-  G_rappend(suspend) ,
+  G_rappend(deallocate),
 #endif
 
-#ifndef GGUSE_MY_PRINT
-#error "please GGDEF_PRINT and GGUSE_MY_PRINT"
+#ifndef GGUSE_MY_ENCODE
+  G_STD_ENCODE,
 #else
- G_rappend(print) ,
+  G_rappend(encode),
 #endif
 
-#ifndef GGUSE_MY_GC
-#error "please GGDEF_GC and GGUSE_MY_GC"
+#ifndef GGUSE_MY_UNIFY
+#error "please GGDEF_UNIFY and GGUSE_MY_UNIFY"
 #else
- G_rappend(gc) ,
+  G_rappend(active_unify),
 #endif
 
-#ifndef GGUSE_MY_DEALLOCATE
- GG_STD_DEALLOCATE ,
+#ifndef GGUSE_MY_GENERATE
+#error "please GGDEF_GENERATE and GGUSE_MY_GENERATE"
 #else
- G_rappend(deallocate) ,
+  G_rappend(generate),
 #endif
 
-#ifndef GGUSE_MY_ENCODE
- GG_STD_ENCODE 
+#ifndef GGUSE_MY_SUSPEND
+  GG_STD_SUSPEND
 #else
- G_rappend(encode)
+  G_rappend(suspend)
 #endif
-
 };
 
 #endif /* _KLIC_GG_METHTAB_H_ */
diff -ruN klic-3.003-2002-03-21/runtime/gcode.c klic-3.003-2002-03-23/runtime/gcode.c
--- klic-3.003-2002-03-21/runtime/gcode.c	Thu Mar 21 21:48:50 2002
+++ klic-3.003-2002-03-23/runtime/gcode.c	Sat Mar 23 21:34:01 2002
@@ -21,8 +21,8 @@
 #include <klic/gmodule.h>
 
 #define CLASS_NAME  predicate
-#define GD_OBJ_TYPE struct predicate_object
-#define GD_OBJ_SIZE(obj) G_SIZE_IN_Q(GD_OBJ_TYPE)
+#define G_OBJ_TYPE  struct predicate_object
+#define G_OBJ_SIZE  G_SIZE_IN_Q(G_OBJ_TYPE)
 
 #include <klic/gd_macro.h>
 
@@ -35,8 +35,8 @@
 {
   G_STD_DECL;
 
-  if( GD_SELF->method_table != GD_OTHER->method_table ||
-      GD_SELF->pdesc != GD_OTHER->pdesc )
+  if( g_self->method_table != GD_OTHER->method_table ||
+      g_self->pdesc != GD_OTHER->pdesc )
     GD_GFAIL;
   else
     GD_GSUCCEED;
@@ -46,20 +46,20 @@
 {
   G_STD_DECL;
 
-  if( GD_SELF->method_table != GD_OTHER->method_table ||
-      GD_SELF->pdesc != GD_OTHER->pdesc )
+  if( g_self->method_table != GD_OTHER->method_table ||
+      g_self->pdesc != GD_OTHER->pdesc )
     GD_UNIFY_FAIL;
 }
 
-GDDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GD_OBJ_TYPE* newself;
+  G_OBJ_TYPE* newself;
 
-  GDSET_NEWOBJ_IN_NEWGEN(newself);
-  newself->pdesc = GD_SELF->pdesc;
-  G_COPY_KL1_TERM_TO_NEWGEN(GD_SELF->module_obj, newself->module_obj);
-  newself->predicate_name = GD_SELF->predicate_name;
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
+  newself->pdesc = g_self->pdesc;
+  G_COPY_KL1_TERM_TO_NEWGEN(g_self->module_obj, newself->module_obj);
+  newself->predicate_name = g_self->predicate_name;
   G_RETURN_FROM_GC(newself);
 }
 
@@ -69,20 +69,20 @@
 {
   G_STD_DECL;
 
-  do_shallow_unify(g_argv[0], GD_SELF->module_obj);
+  do_shallow_unify(g_argv[0], g_self->module_obj);
 }
 
 GDDEF_METHOD(name_1)
 {
   G_STD_DECL;
 
-  do_shallow_unify(g_argv[0], GD_SELF->predicate_name);
+  do_shallow_unify(g_argv[0], g_self->predicate_name);
 }
 
 GDDEF_METHOD(arity_1)
 {
   G_STD_DECL;
-  const struct predicate* pred = GD_SELF->pdesc;
+  const struct predicate* pred = g_self->pdesc;
 
   do_shallow_unify(g_argv[0], makeint(pred->arity));
 }
@@ -106,22 +106,22 @@
 
   GD_DEREF(g_argv[0]);
   func = g_argv[0];
-  if( !G_ISFUNCTOR(func) || !GD_IS_CLASS(vector, func) ){
+  if( !isfunctor(func) || !GD_IS_CLASS(vector, func) ){
     GD_ERROR_IN_METHOD("Invalid argument specification", "apply");
   }
 
   GD_CALL_GMETHOD(func, vector_1, argv);
-  size = G_INTVAL(argv[0]);
-  if( GD_SELF->pdesc->arity != size ){
+  size = intval(argv[0]);
+  if( g_self->pdesc->arity != size ){
     GD_ERROR_IN_METHOD("Arity mismatch", "apply");
   }
-  GD_ALLOC_GOAL(goal, GD_SELF->pdesc, size);
+  GD_ALLOC_GOAL(goal, g_self->pdesc, size);
   for( i=0; i<size; ++i ){
-    argv[0] = G_MAKEINT(i);
+    argv[0] = makeint(i);
     GD_CALL_GMETHOD(func, element_2, argv);
     GD_GOAL_ARG(i, goal) = argv[1];
   }
-  G_PUSH_GOAL(goal);
+  resume_same_prio(goal);
 }
 
 #define GD_METHOD_ARITY  arities (g_method_functor)
@@ -133,11 +133,11 @@
   int i;
   int size = GD_METHOD_ARITY;
 
-  GD_ALLOC_GOAL(goal, GD_SELF->pdesc, size);
+  GD_ALLOC_GOAL(goal, g_self->pdesc, size);
   for( i=0; i<size; ++i ){
     GD_GOAL_ARG(i, goal) = g_argv[i];
   }
-  G_PUSH_GOAL(goal);
+  resume_same_prio(goal);
 }
 
 GDDEF_GENERIC()
@@ -157,22 +157,22 @@
   }
 }
 
-GDDEF_PRINT()
+G_DEF_PRINT()
 {
   G_STD_DECL;
-  GD_PRINT("predicate#(");
+  G_PRINT("predicate#(");
   GD_PRINT_KL1_TERMS
-    (((struct module_object*) G_FUNCTORP(GD_SELF->module_obj))->name, 0, 1);
-  GD_PRINT(":");
-  GD_PRINT_KL1_TERMS(GD_SELF->predicate_name, 0, 1);
-  GD_PRINTF("/%d)", GD_SELF->pdesc->arity);
+    (((struct module_object*) functorp(g_self->module_obj))->name, 0, 1);
+  G_PRINT(":");
+  GD_PRINT_KL1_TERMS(g_self->predicate_name, 0, 1);
+  GD_PRINTF("/%d)", g_self->pdesc->arity);
   G_RETURN_FROM_PRINT();
 }
 
 GDDEF_GMETHOD(arity_1)
 {
   G_STD_DECL;
-  const struct predicate* pred = GD_SELF->pdesc;
+  const struct predicate* pred = g_self->pdesc;
 
   g_argv[0] =  makeint(pred->arity);
   GD_GSUCCEED;
@@ -181,7 +181,7 @@
 GDDEF_GMETHOD(predicate_0)
 {
   G_STD_DECL;
-  if( GD_SELF->pdesc )
+  if( g_self->pdesc )
     { GD_GSUCCEED; }
   else
     { GD_GFAIL; }
@@ -235,7 +235,7 @@
 G_DEF_NEW()
 {
   G_STD_DECL_FOR_NEW();
-  GD_OBJ_TYPE* newpred;
+  G_OBJ_TYPE* newpred;
   struct module_object* module_obj;
   const struct predicate* predaddr;
   q predname;
@@ -244,12 +244,12 @@
   if( g_argc != 3 ) G_ERROR_IN_NEW("Too few or too many arguments");
 
   G_DEREF_FOR_NEW(g_argv[0]);
-  if( !G_ISFUNCTOR(g_argv[0]) ||
-      (((struct module_object*) G_FUNCTORP(g_argv[0]))->method_table
+  if( !isfunctor(g_argv[0]) ||
+      (((struct module_object*) functorp(g_argv[0]))->method_table
       != &G_method_table0(module) ) ){
     G_ERROR_IN_NEW("First parameter is not a module");
   }
-  module_obj = (struct module_object*) G_FUNCTORP(g_argv[0]);
+  module_obj = (struct module_object*) functorp(g_argv[0]);
 
   GDSET_SYMARG_FOR_NEW(predname, g_argv[1]);
   GDSET_INTARG_FOR_NEW(arity, g_argv[2]);
@@ -265,9 +265,9 @@
     G_ERROR_IN_NEW(message);
   }
 
-  GDSET_NEWOBJ_FOR_NEW(newpred, sizeof(struct predicate_object));
+  G_SET_NEWOBJ_FOR_NEW(newpred, sizeof(struct predicate_object));
   newpred->pdesc = predaddr;
-  newpred->module_obj = G_MAKEFUNCTOR(module_obj);
+  newpred->module_obj = makefunctor(module_obj);
   newpred->predicate_name = predname;
   GD_RETURN_FROM_NEW(newpred);
 }
diff -ruN klic-3.003-2002-03-21/runtime/ge_exref.c klic-3.003-2002-03-23/runtime/ge_exref.c
--- klic-3.003-2002-03-21/runtime/ge_exref.c	Thu Mar 21 21:32:22 2002
+++ klic-3.003-2002-03-23/runtime/ge_exref.c	Sat Mar 23 21:34:01 2002
@@ -4,6 +4,9 @@
 %   (C)1996, 1997, 1998, 1999 Japan Information Processing Development Center
 %       (Read COPYRIGHT-JIPDEC for detailed information.)
 ----------------------------------------------------------- */
+
+#ifdef DIST
+
 #include <stdio.h>
 
 #include <klic/basic.h>  /* fatal, klic_fprintf */
@@ -26,7 +29,7 @@
 #include "ge_exref.h"
 
 #define CLASS_NAME  exref
-#define GG_OBJ_TYPE struct exref_object
+#define G_OBJ_TYPE  struct exref_object
 
 #include <klic/gc_macro.h>
 #include <klic/gd_macro.h>
@@ -41,19 +44,19 @@
   q rdhok;
   q* allocp = heapp();
 
-  generic_arg[0] = makeint(GG_SELF->node);
-  generic_arg[1] = makeint(GG_SELF->index);
-  generic_arg[2] = makeint(GG_SELF->wec);
+  generic_arg[0] = makeint(g_self->node);
+  generic_arg[1] = makeint(g_self->index);
+  generic_arg[2] = makeint(g_self->wec);
 
   new_generic(read_hook_g_new, 3, rdhok);
 
-  GG_SELF->method_table = 0;
+  g_self->method_table = 0;
 
-  GG_SELF->node = 0;
-  GG_SELF->index = 0;
-  GG_SELF->wec = 0;
+  g_self->node = 0;
+  g_self->index = 0;
+  g_self->wec = 0;
 
-  GG_SELF->gc_flag = IMPREC_RELEASED;
+  g_self->gc_flag = IMPREC_RELEASED;
 
   return rdhok;
 }
@@ -61,7 +64,7 @@
 GGDEF_UNIFY()
 {
   G_STD_DECL;
-  struct generator_susp* gsusp = generator_suspp(derefone(GG_SELF));
+  struct generator_susp* gsusp = generator_suspp(derefone(g_self));
   struct exref_object* GG_OBJ =
     (struct exref_object*) untag_generator_susp(gsusp->u.o);
 
@@ -73,7 +76,7 @@
  generic_data0:
   send_unify(GG_OBJ->node, GG_OBJ->index, GG_OBJ->wec, g_term);
 
-  derefone(GG_SELF) = g_term;
+  derefone(g_self) = g_term;
 
   GG_OBJ->method_table = NULL;
   GG_OBJ->gc_flag = IMPREC_RELEASED;
@@ -103,61 +106,57 @@
   return 0;  /* Cannot unify now */
 }
 
-GGDEF_ENCODE()
+G_DEF_ENCODE()
 {
   long send_wec;
 
-  if( GG_SELF->wec < MIN_WEC ){
+  if( g_self->wec < MIN_WEC ){
     fatal("invalid WEC in exref object");
   }
 
-  if( GG_SELF->wec < MIN_WEC*2 ){
+  if( g_self->wec < MIN_WEC*2 ){
     return GENERIC_FAILED;
   }
-  send_wec = (GG_SELF->wec) >> 1;
+  send_wec = (g_self->wec) >> 1;
 
-  GG_SELF->wec -= send_wec;
+  g_self->wec -= send_wec;
 
   PUT_BUFFER(buffer, decode_exref);
-  PUT_BUFFER(buffer, GG_SELF->node);
-  PUT_BUFFER(buffer, GG_SELF->index);
+  PUT_BUFFER(buffer, g_self->node);
+  PUT_BUFFER(buffer, g_self->index);
   PUT_BUFFER(buffer, send_wec);
 
   return GENERIC_SUCCEEDED;
 }
 
-GGDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GG_OBJ_TYPE* newself;
+  G_OBJ_TYPE* newself;
 
   INT_CL_DEBUG_X(klic_fprintf(stdout, "exref GC invoked\n"));
 
-  if( GG_SELF->gc_flag != IMPREC_NOT_COPIED ){
+  if( g_self->gc_flag != IMPREC_NOT_COPIED ){
     ioeprintf("invalid exref in GC\n");
     ERROR_STOP;
   }
 
-  GGSET_NEWOBJ_IN_NEWGEN(newself);
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
 
-  newself->node = GG_SELF->node;
-  newself->index = GG_SELF->index;
-  newself->wec = GG_SELF->wec;
-  G_COPY_KL1_TERM_TO_NEWGEN(GG_SELF->to_exref, newself->to_exref);
+  newself->node = g_self->node;
+  newself->index = g_self->index;
+  newself->wec = g_self->wec;
+  G_COPY_KL1_TERM_TO_NEWGEN(g_self->to_exref, newself->to_exref);
 
-  GG_SELF->gc_flag = IMPREC_COPIED;
+  g_self->gc_flag = IMPREC_COPIED;
   newself->gc_flag = IMPREC_NOT_COPIED;
 
   G_RETURN_FROM_GC(newself);
 }
 
-GGDEF_PRINT()
-{}
-
 #define GGUSE_MY_GENERATE
 #define GGUSE_MY_UNIFY
 #define GGUSE_MY_GC
-#define GGUSE_MY_PRINT
 #define GGUSE_MY_ENCODE
 
 #include <klic/gg_methtab.h>
@@ -165,9 +164,9 @@
 G_DEF_NEW() /* node, index, wec */
 {
   G_STD_DECL_FOR_NEW();
-  GG_OBJ_TYPE* new_exref;
+  G_OBJ_TYPE* new_exref;
 
-  GGSET_NEWOBJ_FOR_NEW(new_exref, (struct exref_object*));
+  G_SET_NEWOBJ_FOR_NEW(new_exref, G_OBJ_SIZE);
 
   new_exref->node  = (long) intval(g_argv[0]);
   new_exref->index = (long) intval(g_argv[1]);
@@ -187,3 +186,5 @@
 {
   return &G_method_table;
 }
+
+#endif /* DIST */
diff -ruN klic-3.003-2002-03-21/runtime/ge_readhook.c klic-3.003-2002-03-23/runtime/ge_readhook.c
--- klic-3.003-2002-03-21/runtime/ge_readhook.c	Thu Mar 21 21:32:39 2002
+++ klic-3.003-2002-03-23/runtime/ge_readhook.c	Sat Mar 23 21:34:01 2002
@@ -13,8 +13,8 @@
 #include "funct.h"
 
 #define CLASS_NAME  read_hook
-#define GC_OBJ_TYPE struct read_hook_object
-#define GC_OBJ_SIZE(obj)  G_SIZE_IN_Q(GC_OBJ_TYPE)
+#define G_OBJ_TYPE  struct read_hook_object
+#define G_OBJ_SIZE  G_SIZE_IN_Q(G_OBJ_TYPE)
 
 #include <klic/gc_macro.h>
 #include <klic/gd_macro.h>
@@ -39,63 +39,59 @@
  functor0:
  generic_data0:
   if( receive_answer_flag ){
-    if( GC_SELF->return_index == answer_return_exp_index ){
+    if( g_self->return_index == answer_return_exp_index ){
       INT_CL_DEBUG_X
 	(klic_fprintf(stdout, "rdhok receive answer value -> send_release\n"));
-      send_release(GC_SELF->node, GC_SELF->index, GC_SELF->wec);
+      send_release(g_self->node, g_self->index, g_self->wec);
     }else{
       INT_CL_DEBUG_X
 	(klic_fprintf(stdout, "rdhok receive answer value -> send_unify\n"));
-      send_unify(GC_SELF->node, GC_SELF->index, GC_SELF->wec, g_term);
+      send_unify(g_self->node, g_self->index, g_self->wec, g_term);
     }
   }else{
     INT_CL_DEBUG_X(klic_fprintf(stdout, "rdhok active unify -> send_unify\n"));
-    send_unify(GC_SELF->node, GC_SELF->index, GC_SELF->wec, g_term);
-    /* GC_SELF->method_table = NULL; */
+    send_unify(g_self->node, g_self->index, g_self->wec, g_term);
+    /* g_self->method_table = NULL; */
   }
-  GC_SELF->node = 0;
-  GC_SELF->index = 0;
-  GC_SELF->wec = 0;
+  g_self->node = 0;
+  g_self->index = 0;
+  g_self->wec = 0;
   GC_TERMINATE;
 
  susp0:
   fatal("invalid data for unify rdhok");
 }
 
-GCDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GC_OBJ_TYPE* newself;
+  G_OBJ_TYPE* newself;
 
   INT_CL_DEBUG_X(klic_fprintf(stdout, "readhook GC invoked\n"));
 
-  GCSET_NEWOBJ_IN_NEWGEN(newself);
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
 
-  newself->node = GC_SELF->node;
-  newself->index = GC_SELF->index;
-  newself->wec = GC_SELF->wec;
-  newself->return_index = GC_SELF->return_index;
+  newself->node = g_self->node;
+  newself->index = g_self->index;
+  newself->wec = g_self->wec;
+  newself->return_index = g_self->return_index;
 
-  G_COPY_KL1_TERM_TO_NEWGEN(GC_SELF->to_read_hook, newself->to_read_hook);
+  G_COPY_KL1_TERM_TO_NEWGEN(g_self->to_read_hook, newself->to_read_hook);
 
   G_RETURN_FROM_GC(newself);
 }
 
-GCDEF_PRINT()
-{}
-
 #define GCUSE_MY_UNIFY
 #define GCUSE_MY_GC
-#define GCUSE_MY_PRINT
 
 #include <klic/gc_methtab.h>
 
 G_DEF_NEW() /* node, index, wec */
 {
   G_STD_DECL_FOR_NEW();
-  GC_OBJ_TYPE* new_read_hook;
+  G_OBJ_TYPE* new_read_hook;
 
-  GCSET_NEWOBJ_FOR_NEW(new_read_hook, GC_OBJ_SIZE(new_read_hook));
+  G_SET_NEWOBJ_FOR_NEW(new_read_hook, G_OBJ_SIZE);
   new_read_hook->node  = (long) intval(g_argv[0]);
   new_read_hook->index = (long) intval(g_argv[1]);
   new_read_hook->wec   = (long) intval(g_argv[2]);
diff -ruN klic-3.003-2002-03-21/runtime/ge_replyhook.c klic-3.003-2002-03-23/runtime/ge_replyhook.c
--- klic-3.003-2002-03-21/runtime/ge_replyhook.c	Thu Mar 21 21:32:47 2002
+++ klic-3.003-2002-03-23/runtime/ge_replyhook.c	Sat Mar 23 21:34:01 2002
@@ -10,8 +10,8 @@
 #include "funct.h"
 
 #define CLASS_NAME  reply_hook
-#define GC_OBJ_TYPE struct reply_hook_object
-#define GC_OBJ_SIZE(obj)  G_SIZE_IN_Q(GC_OBJ_TYPE)
+#define G_OBJ_TYPE  struct reply_hook_object
+#define G_OBJ_SIZE  G_SIZE_IN_Q(G_OBJ_TYPE)
 
 #include <klic/gc_macro.h>
 #include <klic/gd_macro.h>
@@ -35,43 +35,38 @@
  atomic0:
  functor0:
  generic_data0:
-  send_answer_value(g_term, GC_SELF->node, GC_SELF->index, GC_SELF->wec);
+  send_answer_value(g_term, g_self->node, g_self->index, g_self->wec);
   GC_TERMINATE;
 
  susp0:
   fatal("invalid data for unify rhook");
 }
 
-GCDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GC_OBJ_TYPE* newself;
+  G_OBJ_TYPE* newself;
 
-  GCSET_NEWOBJ_IN_NEWGEN(newself);
-  newself->node = GC_SELF->node;
-  newself->index = GC_SELF->index;
-  newself->wec = GC_SELF->wec;
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
+  newself->node = g_self->node;
+  newself->index = g_self->index;
+  newself->wec = g_self->wec;
 
   G_RETURN_FROM_GC(newself);
 }
 
-GCDEF_PRINT()
-{}
-
-
 #define GCUSE_MY_UNIFY
 #define GCUSE_MY_GC
-#define GCUSE_MY_PRINT
 
 #include <klic/gc_methtab.h>
 
 G_DEF_NEW() /* node, index, wec */
 {
   G_STD_DECL_FOR_NEW();
-  GC_OBJ_TYPE* new_reply_hook;
+  G_OBJ_TYPE* new_reply_hook;
   q var;
 
-  GCSET_NEWOBJ_FOR_NEW(new_reply_hook, GC_OBJ_SIZE(new_reply_hook));
+  G_SET_NEWOBJ_FOR_NEW(new_reply_hook, G_OBJ_SIZE);
   new_reply_hook->node  = intval(g_argv[0]);
   new_reply_hook->index = intval(g_argv[1]);
   new_reply_hook->wec   = intval(g_argv[2]);
diff -ruN klic-3.003-2002-03-21/runtime/generic.c klic-3.003-2002-03-23/runtime/generic.c
--- klic-3.003-2002-03-21/runtime/generic.c	Thu Mar 21 21:10:39 2002
+++ klic-3.003-2002-03-23/runtime/generic.c	Sat Mar 23 21:34:01 2002
@@ -139,74 +139,59 @@
 /************************* standard methods *************************/
 
 extern q
-GD_STD_GUNIFY(GD_SELF, GD_OTHER)
-  struct data_object* GD_SELF;
-  struct data_object* GD_OTHER;
+GD_STD_GUNIFY(struct data_object* g_self, struct data_object* GD_OTHER)
 {
   GD_GSUCCEED;
 }
 
 extern q*
-GD_STD_UNIFY(GD_SELF, GD_OTHER) 
-  struct data_object* GD_SELF; 
-  struct data_object* GD_OTHER;
+GD_STD_UNIFY(struct data_object* g_self, struct data_object* GD_OTHER)
 {
   return heapp();
 }
 
-extern long
-GD_STD_PRINT(GD_SELF, g_fp, g_depth, g_length)
-  struct data_object* GD_SELF;
-  FILE* g_fp;
-  unsigned long g_depth;
-  unsigned long g_length;
+extern long G_STD_PRINT(
+  struct object* g_self, FILE* g_fp,
+  unsigned long g_depth, unsigned long g_length )
 {
-  klic_fprintf(g_fp, "<OBJ@%x>", (long) GD_SELF);
+  klic_fprintf(g_fp, "<OBJ@%x>", (long) g_self);
   return 1L;
 }
 
-extern q*
-GD_STD_GC(GD_SELF)
-  struct data_object* GD_SELF;
+extern q* G_STD_GC(struct object* g_self)
 {
   return heapp();
 }
 
-extern void
-GD_STD_DEALLOCATE(GD_SELF)
-  struct data_object* GD_SELF;
+extern void G_STD_DEALLOCATE(struct object* g_self)
 {
 }
 
 
 extern q*
-GD_STD_GENERIC(struct data_object* GD_SELF, long g_method_functor, q* g_argv)
+GD_STD_GENERIC(struct data_object* g_self, long g_method_functor, q* g_argv)
 {
   return heapp();
 }
 
 extern q
-GD_STD_GGENERIC(struct data_object* GD_SELF, long g_method_functor, q* g_argv)
+GD_STD_GGENERIC(struct data_object* g_self, long g_method_functor, q* g_argv)
 {
   return GENERIC_SUCCEEDED;
 }
 
 extern q
-GD_STD_COMPARE(GD_SELF, GD_OTHER)
-  struct data_object* GD_SELF;
-  struct data_object* GD_OTHER;
+GD_STD_COMPARE(struct data_object* g_self, struct data_object* GD_OTHER)
 {
   debug_printf("### %k compared with %k ###\n",
-	       makefunctor(GD_SELF), makefunctor(GD_OTHER));
+	       makefunctor(g_self), makefunctor(GD_OTHER));
   fatal("Comparision of objects of an inappropriate class made");
 }
 
 extern q
-GD_STD_HASH(GD_SELF, level)
-  struct data_object* GD_SELF;
-  long level;
+GD_STD_HASH(struct data_object* g_self, long level)
 {
-  return makeint((long) GD_SELF->method_table);
+  return makeint((long) g_self->method_table);
 }
 
 extern NeverReturn void
@@ -218,10 +203,7 @@
 	 object_kind, (class != NULL ? class : ""));
 }
 
-extern q
-GD_STD_ENCODE(self, buffer)
-  struct data_object* self;
-  combuf* buffer;
+extern q G_STD_ENCODE(struct object* self, void* buffer)
 {
   return GENERIC_FAILED;
 }
diff -ruN klic-3.003-2002-03-21/runtime/gfloat.c klic-3.003-2002-03-23/runtime/gfloat.c
--- klic-3.003-2002-03-21/runtime/gfloat.c	Thu Mar 21 21:49:03 2002
+++ klic-3.003-2002-03-23/runtime/gfloat.c	Sat Mar 23 21:34:01 2002
@@ -18,8 +18,8 @@
 #endif
 
 #define CLASS_NAME  float
-#define GD_OBJ_TYPE struct float_object
-#define GD_OBJ_SIZE(obj) (G_SIZE_IN_Q(GD_OBJ_TYPE))
+#define G_OBJ_TYPE  struct float_object
+#define G_OBJ_SIZE  (G_SIZE_IN_Q(G_OBJ_TYPE))
 
 #define ALIGN() \
 do{ \
@@ -40,7 +40,7 @@
 
 GD_USE_CLASS(byte__string);
 
-GD_OBJ_TYPE {
+G_OBJ_TYPE {
   struct data_object_method_table *method_table;
   double value;
 };
@@ -57,8 +57,8 @@
 GDDEF_GUNIFY()
 {
   G_STD_DECL;
-  if( GD_SELF->method_table != GD_OTHER->method_table ||
-      GD_SELF->value != GD_OTHER->value )
+  if( g_self->method_table != GD_OTHER->method_table ||
+      g_self->value != GD_OTHER->value )
     GD_GUNIFY_FAIL;
   GD_GSUCCEED;
 }
@@ -67,19 +67,19 @@
 {
   G_STD_DECL;
 
-  if( GD_SELF->method_table != GD_OTHER->method_table ||
-      GD_SELF->value != GD_OTHER->value )
+  if( g_self->method_table != GD_OTHER->method_table ||
+      g_self->value != GD_OTHER->value )
     GD_UNIFY_FAIL;
 }
 
-GDDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GD_OBJ_TYPE* newself;
+  G_OBJ_TYPE* newself;
 
   ALIGN();
-  GDSET_NEWOBJ_IN_NEWGEN(newself);
-  newself->value = GD_SELF->value;
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
+  newself->value = g_self->value;
   G_RETURN_FROM_GC(newself);
 }
 
@@ -88,7 +88,7 @@
 GDDEF_METHOD(print_1)
 {
   G_STD_DECL;
-  double value = GD_SELF->value;
+  double value = g_self->value;
   q str;
   char buf[100];
   sprintf(buf, "%1.16g", value);
@@ -112,7 +112,7 @@
 GDDEF_METHOD(int_1)
 {
   G_STD_DECL;
-  double value = GD_SELF->value;
+  double value = g_self->value;
   q result = makeint((long) value);
   G_UNIFY_VALUE(g_argv[0], result);
 }
@@ -137,10 +137,10 @@
   G_STD_DECL;
   double self, result;
   unsigned long result_index;
-  GD_OBJ_TYPE* newobj;
+  G_OBJ_TYPE* newobj;
   double (*func)();
 
-  self = GD_SELF->value;
+  self = g_self->value;
   GD_SWITCH_ON_METHOD {
 
   GD_METHOD_CASE(print_1);
@@ -179,13 +179,13 @@
       GD_DEREF(another);
       result_index = 1;
       if( !isfunctor(another) ||
-	  ((GD_OBJ_TYPE*) functorp(another))->method_table !=
-	  GD_SELF->method_table ){
+	  ((G_OBJ_TYPE*) functorp(another))->method_table !=
+	  g_self->method_table ){
 	debug_printf("### \"%k\" given to floating point method %F ###\n",
 		     another, g_method_functor);
 	fatal("Invalid argument in floating point object method.");
       }
-      another_value = ((GD_OBJ_TYPE*) functorp(another))->value;
+      another_value = ((G_OBJ_TYPE*) functorp(another))->value;
       GD_SWITCH_ON_METHOD {
       GD_METHOD_CASE_DIRECT(add_2):
 	result = self + another_value;
@@ -224,13 +224,13 @@
 {								\
   G_STD_DECL;							\
   q otherq = g_argv[0];					\
-  GD_OBJ_TYPE* other;						\
+  G_OBJ_TYPE* other;						\
   double self, theother;					\
 								\
   if( !G_ISGOBJ(otherq) ) GD_GFAIL;				\
-  other = (GD_OBJ_TYPE*) G_FUNCTORP(otherq);			\
-  if( other->method_table != GD_SELF->method_table ) GD_GFAIL;	\
-  self = GD_SELF->value;					\
+  other = (G_OBJ_TYPE*) functorp(otherq);			\
+  if( other->method_table != g_self->method_table ) GD_GFAIL;	\
+  self = g_self->value;					\
   theother = other->value;					\
   if( comparison ) GD_GSUCCEED;					\
   GD_GFAIL;							\
@@ -275,11 +275,11 @@
   }
 }
 
-GDDEF_PRINT()
+G_DEF_PRINT()
 {
   G_STD_DECL;
   char b[100];
-  sprintf(b, "%f", GD_SELF->value);
+  sprintf(b, "%f", g_self->value);
   klic_fprintf(g_fp, "%s", b);
   G_RETURN_FROM_PRINT();
 }
@@ -287,32 +287,32 @@
 GDDEF_COMPARE()
 {
   G_STD_DECL;
-  if( GD_SELF->value > GD_OTHER->value ){
-    return G_MAKEINT(1);
-  }else if( GD_SELF->value < GD_OTHER->value ){
-    return G_MAKEINT(-1);
+  if( g_self->value > GD_OTHER->value ){
+    return makeint(1);
+  }else if( g_self->value < GD_OTHER->value ){
+    return makeint(-1);
   }else{
-    return G_MAKEINT(0);
+    return makeint(0);
   }
 }
 
 GDDEF_HASH()
 {
   G_STD_DECL;
-  return G_MAKEINT((long) GD_SELF->value);
+  return makeint((long) g_self->value);
 }
 
 #ifdef DIST
-GDDEF_ENCODE()
+G_DEF_ENCODE()
 {
   G_STD_DECL;
 
   PUT_BUFFER(buffer, decode_float);
   if( sizeof(double) == sizeof(long) ){
-    PUT_BUFFER(buffer, (long) GD_SELF->value);
+    PUT_BUFFER(buffer, (long) g_self->value);
   }else{
     union dl dl;
-    dl.d = GD_SELF->value;
+    dl.d = g_self->value;
     PUT_BUFFER(buffer, dl.l[0]);
     PUT_BUFFER(buffer, dl.l[1]);
   }
@@ -341,17 +341,17 @@
 {
   G_STD_DECL_FOR_NEW();
   q init = g_argv[0];
-  GD_OBJ_TYPE* newobj;
+  G_OBJ_TYPE* newobj;
 
   G_DEREF_FOR_NEW(init);
   ALIGN();
-  GDSET_NEWOBJ_FOR_NEW(newobj, G_SIZE_IN_Q(GD_OBJ_TYPE));
-  if( G_ISINT(init) ){
-    newobj->value = (double) G_INTVAL(init);
+  G_SET_NEWOBJ_FOR_NEW(newobj, G_SIZE_IN_Q(G_OBJ_TYPE));
+  if( isint(init) ){
+    newobj->value = (double) intval(init);
   }else if( G_ISGOBJ(init) &&
-	    (struct data_object_method_table*) G_FUNCTOR_OF(init)
+	    (struct data_object_method_table*) functor_of(init)
 	    == &byte__string_g_method_table ){
-    newobj->value = atof((char*) generic_string_body(G_FUNCTORP(init)));
+    newobj->value = atof((char*) generic_string_body(functorp(init)));
   }else{
     debug_printf("### %k ###\n", init);
     fatal("Invalid initial value for floating point objects");
@@ -365,10 +365,10 @@
   combuf* inbuf;
 {
   G_STD_DECL;
-  GD_OBJ_TYPE* newobj;
+  G_OBJ_TYPE* newobj;
 
   ALIGN();
-  G_HEAPALLOC(newobj, G_SIZE_IN_Q(GD_OBJ_TYPE), (GD_OBJ_TYPE*));
+  G_HEAPALLOC(newobj, G_SIZE_IN_Q(G_OBJ_TYPE), (G_OBJ_TYPE*));
 
   newobj->method_table = &G_method_table;
   if( sizeof(long) == sizeof(double) ){
diff -ruN klic-3.003-2002-03-21/runtime/ggoal.c klic-3.003-2002-03-23/runtime/ggoal.c
--- klic-3.003-2002-03-21/runtime/ggoal.c	Thu Mar 21 21:49:16 2002
+++ klic-3.003-2002-03-23/runtime/ggoal.c	Sat Mar 23 21:34:01 2002
@@ -13,8 +13,8 @@
 #include "funct.h"
 
 #define CLASS_NAME  goal
-#define GD_OBJ_TYPE struct goal_object
-#define GD_OBJ_SIZE(obj) G_SIZE_IN_Q(GD_OBJ_TYPE)
+#define G_OBJ_TYPE  struct goal_object
+#define G_OBJ_SIZE  G_SIZE_IN_Q(G_OBJ_TYPE)
 
 #include <klic/gd_macro.h>
 #include <klic/gmodule.h>
@@ -116,11 +116,11 @@
 
 /* Copy for Garbage Colleciton */
 
-GDDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GD_OBJ_TYPE *newself;
-  struct goalrec *goal = GD_SELF->goal;
+  G_OBJ_TYPE* newself;
+  struct goalrec *goal = g_self->goal;
   struct goalrec* newgoal;
   long arity, k;
 
@@ -131,9 +131,9 @@
   for (k = 0; k < arity; k++) {
     G_COPY_KL1_TERM_TO_NEWGEN(goal->args[k], newgoal->args[k]);
   }
-  GDSET_NEWOBJ_IN_NEWGEN(newself);
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
   newself->goal = newgoal;
-  newself->id = GD_SELF->id;
+  newself->id = g_self->id;
   G_RETURN_FROM_GC(newself);
 }
 
@@ -142,7 +142,7 @@
 GDDEF_METHOD(reduce_0)
 {
   G_STD_DECL;
-  resume_same_prio(GD_SELF->goal);
+  resume_same_prio(g_self->goal);
 }
 
 GDDEF_METHOD(step_4)
@@ -151,7 +151,7 @@
   struct goalrec *newgoal;
   GD_ALLOC_AREA(newgoal, (struct goalrec *), 2+5);
   newgoal->pred = &step_trigger_pred;
-  newgoal->args[0] = makefunctor(GD_SELF);
+  newgoal->args[0] = makefunctor(g_self);
   newgoal->args[1] = g_argv[0]; /* children info */
   newgoal->args[2] = g_argv[1]; /* woken-up info */
   newgoal->args[3] = g_argv[2]; /* failure info */
@@ -166,7 +166,7 @@
   struct goalrec *goal;
   q the_arg;
 
-  goal = GD_SELF->goal;
+  goal = g_self->goal;
   size = goal->pred->arity;
   GDSET_INTARG_WITHIN_RANGE(position, g_argv[0], 1, size+1);
   the_arg = goal->args[position-1];
@@ -178,18 +178,18 @@
 {
   G_STD_DECL;
   long size, position;
-  GD_OBJ_TYPE *newobj;
+  G_OBJ_TYPE* newobj;
   struct goalrec *oldgoal, *newgoal;
   q oldarg;
   long k;
 
-  size = GD_SELF->goal->pred->arity;
+  size = g_self->goal->pred->arity;
   GDSET_INTARG_WITHIN_RANGE(position, g_argv[0], 1, size+1);
-  oldarg = GD_SELF->goal->args[position-1];
+  oldarg = g_self->goal->args[position-1];
 
   /* Allocate and set up new goal record */
   GD_ALLOC_AREA(newgoal, (struct goalrec *), size+2);
-  oldgoal = GD_SELF->goal;
+  oldgoal = g_self->goal;
   newgoal->pred = oldgoal->pred;
   for (k = 0; k < size; k++) {
     newgoal->args[k] = oldgoal->args[k];
@@ -209,7 +209,7 @@
   G_STD_DECL;
   unsigned long id;
 
-  id = GD_SELF->id;
+  id = g_self->id;
   G_UNIFY_VALUE(g_argv[0], makeint(id));
 }
 
@@ -218,7 +218,7 @@
   G_STD_DECL;
   struct pred_tab_ent *pte;
 
-  pte = find_pred_ent(GD_SELF->goal->pred);
+  pte = find_pred_ent(g_self->goal->pred);
   G_UNIFY_VALUE(g_argv[0], pte->modname);
   G_UNIFY_VALUE(g_argv[1], pte->name);
   G_UNIFY_VALUE(g_argv[2], makeint(pte->pred->arity));
@@ -229,13 +229,13 @@
 {
   G_STD_DECL;
   long arity;
-  GD_OBJ_TYPE *newobj;
+  G_OBJ_TYPE* newobj;
   struct goalrec *oldgoal, *newgoal;
   q predq;
   const struct predicate_object* pred;
   long k;
 
-  oldgoal = GD_SELF->goal;
+  oldgoal = g_self->goal;
   arity = oldgoal->pred->arity;
 
   predq = g_argv[0];
@@ -326,7 +326,7 @@
 G_DEF_NEW()
 {
   G_STD_DECL_FOR_NEW();
-  GD_OBJ_TYPE *newobj;
+  G_OBJ_TYPE* newobj;
   struct goalrec *newgoal;
   q predq, argvq;
   struct predicate_object *pred;
@@ -361,7 +361,7 @@
     extern q element_of_vector();
     newgoal->args[k] = element_of_vector(argvq, makeint(k));
   }
-  GDSET_NEWOBJ_FOR_NEW(newobj, G_SIZE_IN_Q(GD_OBJ_TYPE));
+  G_SET_NEWOBJ_FOR_NEW(newobj, G_SIZE_IN_Q(G_OBJ_TYPE));
   newobj->goal = newgoal;
   newobj->id = goal_obj_id++;
   GD_RETURN_FROM_NEW(newobj);
diff -ruN klic-3.003-2002-03-21/runtime/gio.c klic-3.003-2002-03-23/runtime/gio.c
--- klic-3.003-2002-03-21/runtime/gio.c	Thu Mar 21 21:49:41 2002
+++ klic-3.003-2002-03-23/runtime/gio.c	Sat Mar 23 21:34:01 2002
@@ -21,20 +21,20 @@
 #include "funct.h"
 
 #define CLASS_NAME  file__io
-#define GC_OBJ_TYPE struct file_io_object
-#define GC_OBJ_SIZE(obj)  G_SIZE_IN_Q(GC_OBJ_TYPE)
+#define G_OBJ_TYPE  struct file_io_object
+#define G_OBJ_SIZE  G_SIZE_IN_Q(G_OBJ_TYPE)
 
 #include <klic/gc_macro.h>
 
 #define CheckInput() \
 do{ \
-  if( GC_SELF->infile == NULL ) goto message_error; \
-  if( GC_SELF->outfile != NULL ) do_flush(GC_SELF); \
+  if( g_self->infile == NULL ) goto message_error; \
+  if( g_self->outfile != NULL ) do_flush(g_self); \
 }while(0)
 
 #define CheckOutput() \
 do{ \
-  if( GC_SELF->outfile == NULL ) goto message_error; \
+  if( g_self->outfile == NULL ) goto message_error; \
 }while(0)
 
 extern size_t strlen();
@@ -76,28 +76,28 @@
   q newvar;
   q reason;
 
-  if( GC_SELF->stream != 0 ){
-    g_term = GC_SELF->stream;
-    GC_SELF->stream = 0;
+  if( g_self->stream != 0 ){
+    g_term = g_self->stream;
+    g_self->stream = 0;
   }
  top:
-  if( G_ISCONS(g_term) ){
+  if( iscons(g_term) ){
     q message;
     GCSET_MESSAGE(message);
-    if( G_ISINT(message) ){
-      long c = G_INTVAL(message);
+    if( isint(message) ){
+      long c = intval(message);
 #ifdef DIST
-      if( GC_SELF->outfile == stdout ){
+      if( g_self->outfile == stdout ){
 	UserPutc(c);
-      }else if( GC_SELF->outfile == stderr ){
+      }else if( g_self->outfile == stderr ){
 	UserEPutc(c);
       }else
 #endif
-      if( klic_putc(c, GC_SELF->outfile) == EOF ){
+      if( klic_putc(c, g_self->outfile) == EOF ){
 	fatal("putc failed");
       }
-    }else if( G_ISFUNCTOR(message) ){
-      switch( G_SYMVAL(G_FUNCTOR_OF(message)) ){
+    }else if( isfunctor(message) ){
+      switch( symval(functor_of(message)) ){
 
 	/*** Input Messages ***/
 
@@ -105,15 +105,15 @@
 	long c;
 	CheckInput();
 #ifdef DIST
-	if( GC_SELF->infile == stdin ){
+	if( g_self->infile == stdin ){
           c = UserGetc();
 	}else
 #endif
 	{
-	  c = klic_getc(GC_SELF->infile);
+	  c = klic_getc(g_self->infile);
 	}
-	if( c=='\n' ){ GC_SELF->linecount++; }
-	G_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(c));
+	if( c=='\n' ){ g_self->linecount++; }
+	G_UNIFY_VALUE(arg(message, 0), makeint(c));
 	break;
       }
 
@@ -121,14 +121,14 @@
 	long c;
 	CheckInput();
 	GCSET_MESSAGE_INT_ARG(c, message, 0);
-	if( c=='\n' ){ GC_SELF->linecount--; }
+	if( c=='\n' ){ g_self->linecount--; }
 #ifdef DIST
-	if( GC_SELF->infile == stdin ){
+	if( g_self->infile == stdin ){
 	  UserUngetc(c);
 	}else
 #endif
 	{
-	  ungetc(c, GC_SELF->infile);
+	  ungetc(c, g_self->infile);
 	}
 	break;
       }
@@ -148,30 +148,30 @@
 	}
 	buf = (char*) malloc_check(n);
 #ifdef DIST
-	if( GC_SELF->infile == stdin ){
+	if( g_self->infile == stdin ){
           Read(buf);
 	  n = strlen(buf);
 	}else
 #endif
 	{
-	  n = klic_fread(buf, 1, n, GC_SELF->infile);
+	  n = klic_fread(buf, 1, n, g_self->infile);
 	}
 
 	for( k=0; k<n; k++ ){
-	  if( buf[k] == '\n' ){ GC_SELF->linecount++; }
+	  if( buf[k] == '\n' ){ g_self->linecount++; }
 	}
 	string = convert_binary_c_string_to_klic_string(buf, n);
-	if( G_ISREF(string) ){
+	if( isref(string) ){
 	  fatal("internal error: string allocation for fread");
 	}
 	free(buf);
-	G_UNIFY_VALUE(G_ARG(message, 1), string);
+	G_UNIFY_VALUE(arg(message, 1), string);
 	break;
       }
 
       case functor_linecount_1: {
 	CheckInput();
-	G_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(GC_SELF->linecount));
+	G_UNIFY_VALUE(arg(message, 0), makeint(g_self->linecount));
 	break;
       }
 
@@ -182,11 +182,11 @@
 	CheckOutput();
 	GCSET_MESSAGE_INT_ARG(c, message, 0);
 #ifdef DIST
-	if( GC_SELF->outfile == stdout ){ UserPutc((int) c); }
-	else if( GC_SELF->outfile == stderr ){ UserEPutc((int) c); }
+	if( g_self->outfile == stdout ){ UserPutc((int) c); }
+	else if( g_self->outfile == stderr ){ UserEPutc((int) c); }
 	else
 #endif
-	if( klic_putc(c, GC_SELF->outfile) == EOF ){
+	if( klic_putc(c, g_self->outfile) == EOF ){
 	  fatal("putc failed");
 	}
 	break;
@@ -200,19 +200,19 @@
 	GCSET_MESSAGE_STR_ARG(str, message, 0);
 	size = generic_string_size(str);
 #ifdef DIST
-	if( GC_SELF->outfile == stdout ){
+	if( g_self->outfile == stdout ){
 	  UserWrite(generic_string_body(str), size);
 	  written = size;
-	}else if( GC_SELF->outfile == stderr ){
+	}else if( g_self->outfile == stderr ){
 	  UserEWrite(generic_string_body(str), size);
 	  written = size;
 	}else
 #endif
 	{
 	  written = klic_fwrite(generic_string_body(str),
-				1, size, GC_SELF->outfile);
+				1, size, g_self->outfile);
 	}
-	G_UNIFY_VALUE(G_ARG(message, 1), G_MAKEINT(written));
+	G_UNIFY_VALUE(arg(message, 1), makeint(written));
 	break;
       }
 
@@ -226,16 +226,16 @@
 	strbody = (char*) generic_string_body(str);
 	size = generic_string_size(str);
 #ifdef DIST
-	if( GC_SELF->outfile == stdout ){
+	if( g_self->outfile == stdout ){
 	  UserWrite(strbody, size);
-	}else if( GC_SELF->outfile == stderr ){
+	}else if( g_self->outfile == stderr ){
 	  UserEWrite(strbody, size);
 	}else
 #endif
 	{
 	  while( size > 0 ){
 	    written =
-	      klic_fwrite(strbody+written, 1, size, GC_SELF->outfile);
+	      klic_fwrite(strbody+written, 1, size, g_self->outfile);
 	    size -= written;
 	  }
 	}
@@ -247,19 +247,19 @@
       case functor_feof_1: {
 	long iseof;
 #ifdef DIST
-	if( GC_SELF->infile == stdin ||
-	    GC_SELF->outfile == stdout ||
-	    GC_SELF->outfile == stderr ){ iseof = 0; }
+	if( g_self->infile == stdin ||
+	    g_self->outfile == stdout ||
+	    g_self->outfile == stderr ){ iseof = 0; }
 	else
 #endif
 	{
-	  if( GC_SELF->infile != NULL ){
-	    iseof = feof(GC_SELF->infile);
+	  if( g_self->infile != NULL ){
+	    iseof = feof(g_self->infile);
 	  }else{
-	    iseof = feof(GC_SELF->outfile);
+	    iseof = feof(g_self->outfile);
 	  }
 	}
-	G_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(iseof));
+	G_UNIFY_VALUE(arg(message, 0), makeint(iseof));
 	break;
       }
 
@@ -268,74 +268,74 @@
 	GCSET_MESSAGE_INT_ARG(offset, message, 0);
 	GCSET_MESSAGE_INT_ARG(whence, message, 1);
 #ifdef DIST
-	if( GC_SELF->infile == stdin ||
-	    GC_SELF->outfile == stdout || GC_SELF->outfile == stderr ){
+	if( g_self->infile == stdin ||
+	    g_self->outfile == stdout || g_self->outfile == stderr ){
 	  result = 0;
 	}else
 #endif
 	{
 	  FILE* file =
-	    (GC_SELF->infile == NULL ? GC_SELF->outfile : GC_SELF->infile);
+	    (g_self->infile == NULL ? g_self->outfile : g_self->infile);
 	  result = fseek(file, offset, whence);
 	}
-	G_UNIFY_VALUE(G_ARG(message, 2), G_MAKEINT(result));
+	G_UNIFY_VALUE(arg(message, 2), makeint(result));
 	break;
       }
 
       case functor_ftell_1: {
 	long result;
 #ifdef DIST
-	if( GC_SELF->infile == stdin ||
-	    GC_SELF->outfile == stdout || GC_SELF->outfile == stderr ){
+	if( g_self->infile == stdin ||
+	    g_self->outfile == stdout || g_self->outfile == stderr ){
 	  result = 0;
 	}else
 #endif
 	{
 	  FILE* file =
-	    (GC_SELF->infile == NULL ? GC_SELF->outfile : GC_SELF->infile);
+	    (g_self->infile == NULL ? g_self->outfile : g_self->infile);
 	  result = ftell(file);
 	}
-	G_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(result));
+	G_UNIFY_VALUE(arg(message, 0), makeint(result));
 	break;
       }
 
       case functor_fflush_1: {
-	long result = do_flush(GC_SELF);
-	G_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(result));
+	long result = do_flush(g_self);
+	G_UNIFY_VALUE(arg(message, 0), makeint(result));
 	break;
       }
 
       case functor_fclose_1: {
 	long result;
 #ifdef DIST
-	if( GC_SELF->infile == stdin ||
-	    GC_SELF->outfile == stdout || GC_SELF->outfile == stderr ){
+	if( g_self->infile == stdin ||
+	    g_self->outfile == stdout || g_self->outfile == stderr ){
 	  result = 0;
 	}else
 #endif
 	{
-	  if( GC_SELF->outfile != NULL &&
-	      GC_SELF->outfile != stdout &&
-	      GC_SELF->outfile != stderr ){
-	    result = fclose(GC_SELF->outfile);
-	    GC_SELF->outfile = NULL;
+	  if( g_self->outfile != NULL &&
+	      g_self->outfile != stdout &&
+	      g_self->outfile != stderr ){
+	    result = fclose(g_self->outfile);
+	    g_self->outfile = NULL;
 	  }else{
 	    result = 0;
 	  }
 	  if( result == 0 ){
-	    if( GC_SELF->infile != NULL &&
-		GC_SELF->infile != stdin ){
-	      result = fclose(GC_SELF->infile);
-	      GC_SELF->infile = NULL;
+	    if( g_self->infile != NULL &&
+		g_self->infile != stdin ){
+	      result = fclose(g_self->infile);
+	      g_self->infile = NULL;
 	    }
 	  }
 	}
-	G_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(result));
+	G_UNIFY_VALUE(arg(message, 0), makeint(result));
 	break;
       }
 
       case functor_sync_1: {
-	G_UNIFY_VALUE(G_ARG(message, 0), G_MAKEINT(0));
+	G_UNIFY_VALUE(arg(message, 0), makeint(0));
 	break;
       }
 
@@ -344,13 +344,13 @@
     }else{
       goto message_error;
     }
-    g_term = G_CDR_OF(g_term);
+    g_term = cdr_of(g_term);
     goto top;
 
   message_error:
     {
-      char* inname = (char*) generic_string_body(G_FUNCTORP(GC_SELF->inname));
-      char* outname = (char*) generic_string_body(G_FUNCTORP(GC_SELF->outname));
+      char* inname = (char*) generic_string_body(functorp(g_self->inname));
+      char* outname = (char*) generic_string_body(functorp(g_self->outname));
       if( inname == NULL ) inname = "";
       if( outname == NULL ) outname = "";
       debug_printf("Invalid message %k to I/O stream for %s%s%s\n",
@@ -362,30 +362,30 @@
     }
   }else if( g_term==NILATOM ){
 #ifdef DIST
-    if( GC_SELF->outfile == stdout ){
+    if( g_self->outfile == stdout ){
       UserFflush();
-    }else if( GC_SELF->outfile == stderr ){
+    }else if( g_self->outfile == stderr ){
       UserEFflush();
-    }else if( GC_SELF->infile == stdin ){
+    }else if( g_self->infile == stdin ){
     }else
 #endif
     {
-      if( GC_SELF->infile != NULL && GC_SELF->infile != stdin ){
-	fclose(GC_SELF->infile);
+      if( g_self->infile != NULL && g_self->infile != stdin ){
+	fclose(g_self->infile);
       }
-      if( GC_SELF->outfile != NULL &&
-	  GC_SELF->outfile != stdout &&
-	  GC_SELF->outfile != stderr ){
-	fclose(GC_SELF->outfile);
+      if( g_self->outfile != NULL &&
+	  g_self->outfile != stdout &&
+	  g_self->outfile != stderr ){
+	fclose(g_self->outfile);
       }
     }
     GC_TERMINATE;
-  }else if( G_ISREF(g_term) ){
-    q temp = G_DEREFONE(g_term);
-    if( G_ISREF(temp) &&
-	(temp == g_term || G_DEREFONE(temp) == g_term) ){
+  }else if( isref(g_term) ){
+    q temp = derefone(g_term);
+    if( isref(temp) &&
+	(temp == g_term || derefone(temp) == g_term) ){
       reason = g_term;
-      GC_SELF->stream = 0;
+      g_self->stream = 0;
       goto suspend;
     }else{
       g_term = temp;
@@ -402,27 +402,27 @@
   GC_RETURN_WITH_HOOK(reason);
 }
 
-GCDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GC_OBJ_TYPE* newself;
+  G_OBJ_TYPE* newself;
 
-  GCSET_NEWOBJ_IN_NEWGEN(newself);
-  *newself = *GC_SELF;
-  if( GC_SELF->stream != 0 ){
-    G_COPY_KL1_TERM_TO_NEWGEN(GC_SELF->stream, newself->stream);
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
+  *newself = *g_self;
+  if( g_self->stream != 0 ){
+    G_COPY_KL1_TERM_TO_NEWGEN(g_self->stream, newself->stream);
   }else{
     newself->stream = 0;
   }
-  G_COPY_KL1_TERM_TO_NEWGEN(GC_SELF->inname, newself->inname);
-  G_COPY_KL1_TERM_TO_NEWGEN(GC_SELF->outname, newself->outname);
+  G_COPY_KL1_TERM_TO_NEWGEN(g_self->inname, newself->inname);
+  G_COPY_KL1_TERM_TO_NEWGEN(g_self->outname, newself->outname);
   G_RETURN_FROM_GC(newself);
 }
 
-GCDEF_PRINT()
+G_DEF_PRINT()
 {
   G_STD_DECL;
-  GC_PRINT("$$FILE I/O$");
+  G_PRINT("$$FILE I/O$");
   G_RETURN_FROM_PRINT();
 }
 
@@ -436,7 +436,7 @@
 G_DEF_NEW()
 {
   G_STD_DECL_FOR_NEW();
-  GC_OBJ_TYPE* newobj;
+  G_OBJ_TYPE* newobj;
   q infile, outfile, inpath, outpath;
   q var;
   struct pointer_object* inptr;
@@ -455,7 +455,7 @@
   G_DEREF_FOR_NEW(infile);
   if( infile != NILATOM &&
       (!G_ISGOBJ(infile) ||
-       (struct data_object_method_table*) G_FUNCTOR_OF(infile) !=
+       (struct data_object_method_table*) functor_of(infile) !=
        &pointer_g_method_table) ){
     fatal("First argument for file creation is not a pointer object");
   }
@@ -466,25 +466,25 @@
   G_DEREF_FOR_NEW(outfile);
   if( outfile != NILATOM &&
       (!G_ISGOBJ(outfile) ||
-       (struct data_object_method_table*) G_FUNCTOR_OF(outfile) !=
+       (struct data_object_method_table*) functor_of(outfile) !=
        &pointer_g_method_table) ){
     fatal("Third argument for file creation is not a pointer object");
   }
   outpath = g_argv[3];
   G_DEREF_FOR_NEW(outpath);
 
-  GCSET_NEWOBJ_FOR_NEW(newobj, GC_OBJ_SIZE(newobj));
+  G_SET_NEWOBJ_FOR_NEW(newobj, G_OBJ_SIZE);
   if( infile == NILATOM ){
     newobj->infile = NULL;
   }else{
     newobj->infile = (FILE*)
-      ((struct pointer_object*) G_FUNCTORP(infile))->pointer;
+      ((struct pointer_object*) functorp(infile))->pointer;
   }
   if( outfile == NILATOM ){
     newobj->outfile = NULL;
   }else{
     newobj->outfile = (FILE*)
-      ((struct pointer_object*) G_FUNCTORP(outfile))->pointer;
+      ((struct pointer_object*) functorp(outfile))->pointer;
   }
   newobj->linecount = 0;
   newobj->inname = inpath;
diff -ruN klic-3.003-2002-03-21/runtime/gmerge.c klic-3.003-2002-03-23/runtime/gmerge.c
--- klic-3.003-2002-03-21/runtime/gmerge.c	Thu Mar 21 21:33:14 2002
+++ klic-3.003-2002-03-23/runtime/gmerge.c	Sat Mar 23 21:34:01 2002
@@ -17,8 +17,8 @@
 };
 
 #define CLASS_NAME  merge
-#define GC_OBJ_TYPE struct merge_object
-#define GC_OBJ_SIZE(obj)  G_SIZE_IN_Q(GC_OBJ_TYPE)
+#define G_OBJ_TYPE  struct merge_object
+#define G_OBJ_SIZE  G_SIZE_IN_Q(G_OBJ_TYPE)
 
 #include <klic/gc_macro.h>
 #include <klic/gd_macro.h>
@@ -32,9 +32,9 @@
   goalp1->pred = GC_MERGE_IN_GOAL; \
   goalp1->args[0] = newvar; \
   goalp1->args[1] = vec; \
-  goalp1->args[2] = G_MAKEINT(index); \
-  goalp1->args[3] = G_MAKEINT(size); \
-  G_PUSH_GOAL(goalp1); \
+  goalp1->args[2] = makeint(index); \
+  goalp1->args[3] = makeint(size); \
+  resume_same_prio(goalp1); \
 }while(0)
 
 G_USE_PREDICATE(predicate_gcmerge_xin_4);
@@ -55,17 +55,17 @@
     {
       struct cons *newout;
       GC_TRY_TO_ALLOC(newout,(struct cons *),2,gc_request);
-      newout->car = G_CAR_OF(g_term);
+      newout->car = car_of(g_term);
       GCSET_VAR(newout->cdr);
-      do_shallow_unify(GC_SELF->outstream, G_MAKECONS(newout));
-      GC_SELF->outstream = newout->cdr;
-      g_term = G_CDR_OF(g_term);
+      do_shallow_unify(g_self->outstream, makecons(newout));
+      g_self->outstream = newout->cdr;
+      g_term = cdr_of(g_term);
       goto top;
     }
   atomic0:
     if (g_term == NILATOM) {
-      if (--(GC_SELF->count) == 0) {
-	do_shallow_unify(GC_SELF->outstream, NILATOM);
+      if (--(g_self->count) == 0) {
+	do_shallow_unify(g_self->outstream, NILATOM);
       }
       GC_TERMINATE;
     } else goto invalid_data;
@@ -78,26 +78,26 @@
       {
 	q argv[1];
 	GD_CALL_GMETHOD(g_term, vector_1, argv);
-	size = G_INTVAL(argv[0]);
+	size = intval(argv[0]);
       }
-      GC_SELF->count += size - 1;
-      if (GC_SELF->count == 0) {
-	do_shallow_unify(GC_SELF->outstream, NILATOM);
+      g_self->count += size - 1;
+      if (g_self->count == 0) {
+	do_shallow_unify(g_self->outstream, NILATOM);
       } else {
 	q argv[2];
 	q hook_var;
 	for (i=0; i<size; i++) {
-	  argv[0] = G_MAKEINT(i);
+	  argv[0] = makeint(i);
 	  GD_CALL_GMETHOD(g_term, element_2, argv);
 	  GC_TRY_TO_ALLOC(hook_var,(q),1,gc_request2);
 	  derefone(hook_var) =
-	    GC_MAKE_HOOK_VAR((struct consumer_object*) GC_SELF);
+	    GC_MAKE_HOOK_VAR((struct consumer_object*) g_self);
 	  GC_KL1_UNIFY(argv[1],hook_var);
 	}
       }
       GC_TERMINATE;
     gc_request2:
-      GC_SELF->count -= size-i-1;
+      g_self->count -= size-i-1;
       G_MAKE_VAR(newvar);
       GC_MAKE_MERGE_IN_GOAL(newvar, g_term, i, size);
       GC_RETURN_WITH_HOOK(newvar);
@@ -113,22 +113,22 @@
   GC_RETURN_WITH_HOOK(newvar);
 }
 
-GCDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GC_OBJ_TYPE *newself;
+  G_OBJ_TYPE* newself;
 
-  GCSET_NEWOBJ_IN_NEWGEN(newself);
-  newself->count = GC_SELF->count;
-  G_COPY_KL1_TERM_TO_NEWGEN(GC_SELF->outstream, newself->outstream);
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
+  newself->count = g_self->count;
+  G_COPY_KL1_TERM_TO_NEWGEN(g_self->outstream, newself->outstream);
   G_RETURN_FROM_GC(newself);
 }
 
 
-GCDEF_PRINT()
+G_DEF_PRINT()
 {
   G_STD_DECL;
-  GC_PRINT("$$MERGER$");
+  G_PRINT("$$MERGER$");
   G_RETURN_FROM_PRINT();
 }
 
@@ -143,12 +143,12 @@
 G_DEF_NEW()
 {
   G_STD_DECL_FOR_NEW();
-  GC_OBJ_TYPE *newmerger;
+  G_OBJ_TYPE* newmerger;
   q var;
 
   if (g_argc != 1) G_ERROR_IN_NEW("Arity mismatch");
 
-  GCSET_NEWOBJ_FOR_NEW(newmerger,GC_OBJ_SIZE(newmerger));
+  G_SET_NEWOBJ_FOR_NEW(newmerger, G_OBJ_SIZE);
   newmerger->count = 1;
   newmerger->outstream = g_argv[0];
   var = GC_MAKE_HOOK_VAR((struct consumer_object*) newmerger);
diff -ruN klic-3.003-2002-03-21/runtime/gmodule.c klic-3.003-2002-03-23/runtime/gmodule.c
--- klic-3.003-2002-03-21/runtime/gmodule.c	Thu Mar 21 21:33:19 2002
+++ klic-3.003-2002-03-23/runtime/gmodule.c	Sat Mar 23 21:34:01 2002
@@ -22,8 +22,8 @@
 #include "funct.h"
 
 #define CLASS_NAME  module
-#define GD_OBJ_TYPE struct module_object
-#define GD_OBJ_SIZE(obj)  ((sizeof(struct module_object))/sizeof(q))
+#define G_OBJ_TYPE  struct module_object
+#define G_OBJ_SIZE  ((sizeof(struct module_object)) / sizeof(q))
 
 #include <klic/gd_macro.h>
 #include <klic/gmodule.h>
@@ -37,8 +37,8 @@
 {
   G_STD_DECL;
 
-  if (GD_SELF->method_table != GD_OTHER->method_table ||
-      GD_SELF->name != GD_OTHER->name)
+  if (g_self->method_table != GD_OTHER->method_table ||
+      g_self->name != GD_OTHER->name)
     GD_GUNIFY_FAIL;
   else
     GD_GSUCCEED;
@@ -49,18 +49,18 @@
 {
   G_STD_DECL;
 
-  if (GD_SELF->method_table != GD_OTHER->method_table ||
-      GD_SELF->name != GD_OTHER->name)
+  if (g_self->method_table != GD_OTHER->method_table ||
+      g_self->name != GD_OTHER->name)
     GD_UNIFY_FAIL;
 }
 
-GDDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GD_OBJ_TYPE *newself;
+  G_OBJ_TYPE* newself;
 
-  GDSET_NEWOBJ_IN_NEWGEN(newself);
-  newself->name = GD_SELF->name;
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
+  newself->name = g_self->name;
   G_RETURN_FROM_GC(newself);
 }
 
@@ -69,7 +69,7 @@
 GDDEF_METHOD(name_1)
 {
   G_STD_DECL;
-  do_shallow_unify(g_argv[0], GD_SELF->name);
+  do_shallow_unify(g_argv[0], g_self->name);
 }
 
 
@@ -83,12 +83,12 @@
   }
 }
 
-GDDEF_PRINT()
+G_DEF_PRINT()
 {
   G_STD_DECL;
-  GD_PRINT("<MODULE#");
-  GD_PRINT_KL1_TERMS(GD_SELF->name, 0, 1);
-  GD_PRINT(">");
+  G_PRINT("<MODULE#");
+  GD_PRINT_KL1_TERMS(g_self->name, 0, 1);
+  G_PRINT(">");
   G_RETURN_FROM_PRINT();
 }
 
@@ -105,11 +105,11 @@
  q arity = g_argv[1];
 
  GD_GDEREF(predname);
- if (!G_ISSYM(predname)) GD_GFAIL;
+ if( !issym(predname) ) GD_GFAIL;
  GD_GDEREF(arity);
- if (!G_ISINT(arity) || G_INTVAL(arity) < 0) GD_GFAIL;
- if (locate_predicate_in_module(GD_SELF->name, predname,
-				G_INTVAL(arity)) != NULL) {
+ if( !isint(arity) || intval(arity) < 0 ) GD_GFAIL;
+ if( locate_predicate_in_module(g_self->name, predname,
+				intval(arity)) != NULL ){
    GD_GSUCCEED;
  } else {
    GD_GFAIL;
@@ -153,8 +153,8 @@
   name = namestringof(atom);
   for (mp = defined_modules; mp->name != 0; mp++) {
     if (strcmp((char *)mp->name, (char *)name) == 0) {
-      GD_OBJ_TYPE *newmodule;
-      GDSET_NEWOBJ_FOR_NEW(newmodule,sizeof(struct module_object));
+      G_OBJ_TYPE* newmodule;
+      G_SET_NEWOBJ_FOR_NEW(newmodule, sizeof(struct module_object));
       newmodule->name = atom;
       GD_RETURN_FROM_NEW(newmodule);
     }
diff -ruN klic-3.003-2002-03-21/runtime/gmvv.c klic-3.003-2002-03-23/runtime/gmvv.c
--- klic-3.003-2002-03-21/runtime/gmvv.c	Thu Mar 21 21:49:55 2002
+++ klic-3.003-2002-03-23/runtime/gmvv.c	Sat Mar 23 21:34:01 2002
@@ -20,13 +20,13 @@
 #include "atom.h"
 #include "funct.h"
 
-#define CLASS_NAME		vector
-#define GD_OBJ_TYPE		struct vector_object
-#define GD_OBJ_SIZE(obj)	(G_SIZE_IN_Q(GD_OBJ_TYPE))
+#define CLASS_NAME  vector
+#define G_OBJ_TYPE  struct vector_object
+#define G_OBJ_SIZE  (G_SIZE_IN_Q(G_OBJ_TYPE))
 
 #include <klic/gd_macro.h>
 
-#define VECTOR_OBJ(x)	((GD_OBJ_TYPE *)(G_FUNCTORP(x)))
+#define VECTOR_OBJ(x)	((G_OBJ_TYPE*) functorp(x))
 #define Shallow(vector) \
 do{ if( !IS_SHALLOW_VECTOR(vector) ) do_shallow(vector); }while(0)
 
@@ -86,16 +86,16 @@
 {
   G_STD_DECL;
   long size, k;
-  if (GD_SELF->method_table != GD_OTHER->method_table) GD_GUNIFY_FAIL;
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
+  if( g_self->method_table != GD_OTHER->method_table ) GD_GUNIFY_FAIL;
+  Shallow(g_self);
+  size = g_self->index;
   Shallow(GD_OTHER);
   if (GD_OTHER->index != size) GD_GUNIFY_FAIL;
   for (k=0; k<size; k++) {
     q retval;
     q x = GD_OTHER->body[k];
-    Shallow(GD_SELF);
-    retval = GD_GUNIFY(GD_SELF->body[k], x);
+    Shallow(g_self);
+    retval = GD_GUNIFY(g_self->body[k], x);
     switch ((long)retval) {
     case GENERIC_SUCCEEDED:
       break;
@@ -115,33 +115,33 @@
   G_STD_DECL;
   long size, k;
 
-  if (GD_SELF->method_table != GD_OTHER->method_table) GD_UNIFY_FAIL;
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
+  if( g_self->method_table != GD_OTHER->method_table ) GD_UNIFY_FAIL;
+  Shallow(g_self);
+  size = g_self->index;
   Shallow(GD_OTHER);
   if (GD_OTHER->index != size) GD_UNIFY_FAIL;
   for (k=0; k<size; k++) {
     q x = GD_OTHER->body[k];
-    Shallow(GD_SELF);
-    do_shallow_unify(GD_SELF->body[k], x);
+    Shallow(g_self);
+    do_shallow_unify(g_self->body[k], x);
     Shallow(GD_OTHER);
   }
 }
 
-GDDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GD_OBJ_TYPE *newself;
+  G_OBJ_TYPE* newself;
 
-  if (GD_SELF->iscnst) {
+  if( g_self->iscnst ){
     fatal("GC method for constant vector unexpected");
   }
-  GDSET_NEWOBJ_IN_NEWGEN(newself);
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
   newself->iscnst = 0;
-  if (IS_SHALLOW_VECTOR(GD_SELF)) {
+  if( IS_SHALLOW_VECTOR(g_self) ){
     /* Shallow version */
-    q *body = GD_SELF->body;
-    long size = GD_SELF->index;
+    q* body = g_self->body;
+    long size = g_self->index;
     q *newbody;
     long k;
     if(heapp() + size > real_heaplimit()) fatal("Not enough space collected");
@@ -154,29 +154,29 @@
     }
   } else {
     /* Deep version */
-    newself->index = GD_SELF->index;
-    G_COPY_KL1_TERM_TO_NEWGEN(GD_SELF->next, newself->next);
+    newself->index = g_self->index;
+    G_COPY_KL1_TERM_TO_NEWGEN(g_self->next, newself->next);
 
-    /* G_COPY_KL1_TERM_TO_NEWGEN(GD_SELF->body, newself->body); */
-    newself->body = GD_SELF->body;
+    /* G_COPY_KL1_TERM_TO_NEWGEN(g_self->body, newself->body); */
+    newself->body = g_self->body;
     push_gc_stack((q*) &(newself->body));
   }
   G_RETURN_FROM_GC(newself);
 }
 
 #ifdef DIST
-GDDEF_ENCODE()
+G_DEF_ENCODE()
 {
   G_STD_DECL;
   int i;
   q   elem;
   long size;
 
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
+  Shallow(g_self);
+  size = g_self->index;
   depth--;
   for(i = 0; i<size; i++){
-    elem = element_of_vector(makefunctor(GD_SELF), makeint(i));
+    elem = element_of_vector(makefunctor(g_self), makeint(i));
     if (elem == 0){
       fatal("Error in element_of_vector");
     }
@@ -195,16 +195,16 @@
 {
   G_STD_DECL;
   int position;
-  Shallow(GD_SELF);
-  GDSET_INTARG_WITHIN_RANGE(position, g_argv[0], 0, GD_SELF->index);
-  do_shallow_unify(g_argv[1], GD_SELF->body[position]);
+  Shallow(g_self);
+  GDSET_INTARG_WITHIN_RANGE(position, g_argv[0], 0, g_self->index);
+  do_shallow_unify(g_argv[1], g_self->body[position]);
 }
 
 GDDEF_METHOD(size_1)
 {
   G_STD_DECL;
-  Shallow(GD_SELF);
-  G_UNIFY_VALUE(g_argv[0], G_MAKEINT(GD_SELF->index));
+  Shallow(g_self);
+  G_UNIFY_VALUE(g_argv[0], makeint(g_self->index));
 }
 
 GDDEF_METHOD(set__element_3)
@@ -212,23 +212,23 @@
   G_STD_DECL;
   long position;
   long size;
-  GD_OBJ_TYPE *newvect;
+  G_OBJ_TYPE* newvect;
   q *body;
   int iscnst;
 
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
-  iscnst = GD_SELF->iscnst;
-  body = GD_SELF->body;
+  Shallow(g_self);
+  size = g_self->index;
+  iscnst = g_self->iscnst;
+  body = g_self->body;
   GDSET_INTARG_WITHIN_RANGE(position, g_argv[0], 0, size);
   GDSET_NEWOBJ(newvect);
   if (!iscnst) {
     q olddata = body[position];
 
-    GD_SELF->index = position;
-    GD_SELF->body = (q *)olddata;
+    g_self->index = position;
+    g_self->body = (q*) olddata;
     body[position] = g_argv[1];
-    GD_SELF->next = GD_OBJ(newvect);
+    g_self->next = GD_OBJ(newvect);
     newvect->body = body;
   } else {
     long k;
@@ -249,25 +249,25 @@
   G_STD_DECL;
   long position;
   long size;
-  GD_OBJ_TYPE *newvect;
+  G_OBJ_TYPE* newvect;
   q *body;
   int iscnst;
   q olddata;
 
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
-  body = GD_SELF->body;
-  iscnst = GD_SELF->iscnst;
+  Shallow(g_self);
+  size = g_self->index;
+  body = g_self->body;
+  iscnst = g_self->iscnst;
 
   GDSET_INTARG_WITHIN_RANGE(position, g_argv[0], 0, size);
   GDSET_NEWOBJ(newvect);
   olddata = body[position];
   do_shallow_unify(g_argv[1], olddata);
   if (!iscnst) {
-    GD_SELF->index = position;
-    GD_SELF->body = (q *)olddata;
+    g_self->index = position;
+    g_self->body = (q*) olddata;
     body[position] = g_argv[2];
-    GD_SELF->next = GD_OBJ(newvect);
+    g_self->next = GD_OBJ(newvect);
     newvect->body = body;
   } else {
     long k;
@@ -291,26 +291,26 @@
   q *upper_body, *lower_body;
   struct vector_object *upper, *lower;
 
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
+  Shallow(g_self);
+  size = g_self->index;
   GDSET_INTARG_WITHIN_RANGE(split_point, g_argv[0], 0, size + 1);
   lower_size = size-split_point;
   GD_ALLOC_AREA(upper_body, (q *), split_point);
   GD_ALLOC_AREA(lower_body, (q *), lower_size);
-  GD_ALLOC_AREA(upper, (GD_OBJ_TYPE *), GD_OBJ_SIZE(GD_SELF));
-  GD_ALLOC_AREA(lower, (GD_OBJ_TYPE *), GD_OBJ_SIZE(GD_SELF));
-  BCOPY((char *)GD_SELF->body, (char *)upper_body, split_point*sizeof(q));
-  BCOPY((char *)(GD_SELF->body+split_point), (char *)lower_body,
+  GD_ALLOC_AREA(upper, (G_OBJ_TYPE*), G_OBJ_SIZE);
+  GD_ALLOC_AREA(lower, (G_OBJ_TYPE*), G_OBJ_SIZE);
+  BCOPY((char*) g_self->body, (char*) upper_body, split_point*sizeof(q));
+  BCOPY((char*) (g_self->body + split_point), (char*) lower_body,
 	lower_size*sizeof(q));
-  upper->method_table = lower->method_table = GD_SELF->method_table;
+  upper->method_table = lower->method_table = g_self->method_table;
   upper->next = lower->next = VECTOR_SHALLOW_MARK;
   upper->index = split_point;
   lower->index = lower_size;
   upper->body = upper_body;
   lower->body = lower_body;
   upper->iscnst = lower->iscnst = 0;
-  G_UNIFY_VALUE(g_argv[1], G_MAKEFUNCTOR(upper));
-  G_UNIFY_VALUE(g_argv[2], G_MAKEFUNCTOR(lower));
+  G_UNIFY_VALUE(g_argv[1], makefunctor(upper));
+  G_UNIFY_VALUE(g_argv[2], makefunctor(lower));
 }
 
 GDDEF_METHOD(join_2)
@@ -318,15 +318,15 @@
   G_STD_DECL;
   unsigned long size1, size2, newsize;
   q anotherq = g_argv[0];
-  GD_OBJ_TYPE *another, *new;
+  G_OBJ_TYPE *another, *new;
   q *newbody;
 
-  Shallow(GD_SELF);
-  size1 = GD_SELF->index;
+  Shallow(g_self);
+  size1 = g_self->index;
   GD_DEREF(anotherq);
-  another = (GD_OBJ_TYPE*)G_FUNCTORP(anotherq);
-  if (!G_ISFUNCTOR(anotherq) ||
-      another->method_table != GD_SELF->method_table) {
+  another = (G_OBJ_TYPE*) functorp(anotherq);
+  if( !isfunctor(anotherq) ||
+      another->method_table != g_self->method_table) {
     debug_printf("### %k ###\n", another);
     fatal("Invalid argument to string join");
   }
@@ -334,17 +334,17 @@
   size2 = another->index;
   newsize = size1+size2;
   GD_ALLOC_AREA(newbody, (q *), newsize);
-  GD_ALLOC_AREA(new, (GD_OBJ_TYPE *), GD_OBJ_SIZE(GD_SELF));
-  Shallow(GD_SELF);
-  BCOPY((char *)GD_SELF->body, (char *)newbody, size1*sizeof(q));
+  GD_ALLOC_AREA(new, (G_OBJ_TYPE*), G_OBJ_SIZE);
+  Shallow(g_self);
+  BCOPY((char*) g_self->body, (char*) newbody, size1*sizeof(q));
   Shallow(another);
-  BCOPY((char *)another->body, (char *)(newbody+size1), size2*sizeof(q));
-  new->method_table = GD_SELF->method_table;
+  BCOPY((char*) another->body, (char*) (newbody+size1), size2*sizeof(q));
+  new->method_table = g_self->method_table;
   new->next = VECTOR_SHALLOW_MARK;
   new->index = newsize;
   new->body = newbody;
   new->iscnst = 0;
-  G_UNIFY_VALUE(g_argv[1], G_MAKEFUNCTOR(new));
+  G_UNIFY_VALUE(g_argv[1], makefunctor(new));
 }
 
 /*  Generic Method Table */
@@ -370,17 +370,17 @@
   G_STD_DECL;
   long position;
 
-  Shallow(GD_SELF);
-  GDSET_GINTARG_WITHIN_RANGE(position, g_argv[0], 0, GD_SELF->index);
-  g_argv[1] = GD_SELF->body[position];
+  Shallow(g_self);
+  GDSET_GINTARG_WITHIN_RANGE(position, g_argv[0], 0, g_self->index);
+  g_argv[1] = g_self->body[position];
   GD_GSUCCEED;
 }
 
 GDDEF_GMETHOD(vector_1)
 {
   G_STD_DECL;
-  Shallow(GD_SELF);
-  g_argv[0] = G_MAKEINT(GD_SELF->index);
+  Shallow(g_self);
+  g_argv[0] = makeint(g_self->index);
   GD_GSUCCEED;
 }
 
@@ -394,21 +394,21 @@
   }
 }
 
-GDDEF_PRINT()
+G_DEF_PRINT()
 {
   G_STD_DECL;
   unsigned long size, limit, k;
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
+  Shallow(g_self);
+  size = g_self->index;
   limit = (size > g_length ? g_length : size);
-  GD_PRINT("{");
-  if (size != 0) GD_PRINT_KL1_TERM(GD_SELF->body[0]);
+  G_PRINT("{");
+  if( size != 0 ) GD_PRINT_KL1_TERM(g_self->body[0]);
   for (k=1; k<limit; k++) {
-    GD_PRINT(",");
-    if (size>0) GD_PRINT_KL1_TERM(GD_SELF->body[k]);
+    G_PRINT(",");
+    if( size>0 ) GD_PRINT_KL1_TERM(g_self->body[k]);
   }
-  if (size != limit) GD_PRINT(",..");
-  GD_PRINT("}");
+  if (size != limit) G_PRINT(",..");
+  G_PRINT("}");
   G_RETURN_FROM_PRINT();
 }
 
@@ -416,24 +416,24 @@
 {
   G_STD_DECL;
   unsigned long size1, size2, limit, k;
-  Shallow(GD_SELF);
-  size1 = GD_SELF->index;
+  Shallow(g_self);
+  size1 = g_self->index;
   Shallow(GD_OTHER);
   size2 = GD_OTHER->index;
   limit = (size1 <= size2 ? size1 : size2);
   for (k = 0; k < limit; k++) {
     q elem, tmp;
-    Shallow(GD_SELF);
-    elem = GD_SELF->body[k];
+    Shallow(g_self);
+    elem = g_self->body[k];
     Shallow(GD_OTHER);
     tmp = builtin_compare_terms(elem, GD_OTHER->body[k]);
-    if (!isint(tmp)) return tmp;
-    if (tmp != G_MAKEINT(0)) return tmp;
+    if( !isint(tmp) ) return tmp;
+    if( tmp != makeint(0) ) return tmp;
   }
   if (size1 != size2) {
-    return G_MAKEINT(size1 >= size2 ? size1+1 : -(size2+1));
+    return makeint(size1 >= size2 ? size1+1 : -(size2+1));
   } else {
-    return G_MAKEINT(0);
+    return makeint(0);
   }
 }
 
@@ -441,22 +441,22 @@
 {
   G_STD_DECL;
   unsigned long size;
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
+  Shallow(g_self);
+  size = g_self->index;
   if (GD_LEVEL == 0 || size == 0) {
-    return G_MAKEINT((long)GD_SELF->method_table + 0xb5d*size);
+    return makeint((long) g_self->method_table + 0xb5d*size);
   } else {
     q h1, h2, h3;
     GD_LEVEL--;
-    h1 = hash_kl1_term(GD_SELF->body[0], GD_LEVEL);
+    h1 = hash_kl1_term(g_self->body[0], GD_LEVEL);
     if (!isint(h1)) return h1;
-    h2 = hash_kl1_term(GD_SELF->body[size>>1], GD_LEVEL);
+    h2 = hash_kl1_term(g_self->body[size>>1], GD_LEVEL);
     if (!isint(h1)) return h2;
-    h3 = hash_kl1_term(GD_SELF->body[size-1], GD_LEVEL);
+    h3 = hash_kl1_term(g_self->body[size-1], GD_LEVEL);
     if (!isint(h1)) return h3;
     return
-      G_MAKEINT(0x813*intval(h1) + 0x425*intval(h2) + 0x3c9*intval(h3) +
-		(long)GD_SELF->method_table + 0xb5d*size);
+      makeint(0x813*intval(h1) + 0x425*intval(h2) + 0x3c9*intval(h3) +
+		(long) g_self->method_table + 0xb5d*size );
   }
 }
 
@@ -480,7 +480,7 @@
 G_DEF_NEW()
 {
   G_STD_DECL_FOR_NEW();
-  GD_OBJ_TYPE *newvect;
+  G_OBJ_TYPE* newvect;
   q *body;
   long size, k;
   q init;
@@ -488,26 +488,26 @@
   if( g_argc != 1 ) G_ERROR_IN_NEW("Too few or too many arguments");
   init = g_argv[0];
   G_DEREF_FOR_NEW(init);
-  GDSET_NEWOBJ_FOR_NEW(newvect, G_SIZE_IN_Q(GD_OBJ_TYPE));
-  if (G_ISINT(init)) {
-    size = G_INTVAL(init);
+  G_SET_NEWOBJ_FOR_NEW(newvect, G_SIZE_IN_Q(G_OBJ_TYPE));
+  if( isint(init) ){
+    size = intval(init);
     if (size < 0) G_ERROR_IN_NEW("Negative size specified");
     GD_ALLOC_AREA_FOR_NEW(body, (q*), size);
-    for (k=0; k<size; k++) body[k] = G_MAKEINT(0L);
-  } else if (init==NILATOM || G_ISCONS(init)) {
+    for (k=0; k<size; k++) body[k] = makeint(0L);
+  }else if( init==NILATOM || iscons(init) ){
     for (size=0; ; size++) {
       if (init == NILATOM) break;
-      init = G_CDR_OF(init);
+      init = cdr_of(init);
       G_DEREF_FOR_NEW(init);
-      if (init!=NILATOM && !G_ISCONS(init))
+      if( init != NILATOM && !iscons(init) )
 	G_ERROR_IN_NEW("Invalid parameter");
     }
     init = g_argv[0];
     GD_ALLOC_AREA_FOR_NEW(body, (q*), size);
     for (k=0; k<size; k++) {
       G_DEREF_FOR_NEW(init);
-      body[k] = G_CAR_OF(init);
-      init = G_CDR_OF(init);
+      body[k] = car_of(init);
+      init = cdr_of(init);
     }
   } else {
     G_ERROR_IN_NEW("Invalid parameter");
@@ -536,13 +536,13 @@
 {
   G_STD_DECL;
   struct vector_object *newvect;
-  heapalloc(newvect, G_SIZE_IN_Q(GD_OBJ_TYPE), (GD_OBJ_TYPE *));
+  heapalloc(newvect, G_SIZE_IN_Q(G_OBJ_TYPE), (G_OBJ_TYPE*));
   newvect->method_table = &G_method_table;
   newvect->next = VECTOR_SHALLOW_MARK;
   newvect->iscnst = 0;
   newvect->index = size;
   newvect->body = body;
-  return G_MAKEFUNCTOR(newvect);
+  return makefunctor(newvect);
 }
 
 extern q
@@ -550,7 +550,7 @@
      q v;
 {
   Shallow(VECTOR_OBJ(v));
-  return G_MAKEINT(VECTOR_OBJ(v)->index);
+  return makeint(VECTOR_OBJ(v)->index);
 }
 
 extern q
@@ -558,10 +558,10 @@
      q v, k;
 {
   Shallow(VECTOR_OBJ(v));
-  if (G_INTVAL(k) < 0 || VECTOR_OBJ(v)->index <= G_INTVAL(k)) {
+  if( intval(k) < 0 || VECTOR_OBJ(v)->index <= intval(k) ){
     return (q) 0;
   } else {
-    return VECTOR_OBJ(v)->body[G_INTVAL(k)];
+    return VECTOR_OBJ(v)->body[intval(k)];
   }
 }
 
@@ -571,15 +571,15 @@
      combuf *inbuf;
 {
   G_STD_DECL;
-  GD_OBJ_TYPE *newvect;
+  G_OBJ_TYPE* newvect;
   q *body;
   long size, k;
   q res;
 
-  G_HEAPALLOC_WITH_CHECK(newvect, G_SIZE_IN_Q(GD_OBJ_TYPE),
-                          (GD_OBJ_TYPE*), res);
+  G_HEAPALLOC_WITH_CHECK(newvect, G_SIZE_IN_Q(G_OBJ_TYPE),
+                          (G_OBJ_TYPE*), res);
   if(res == GENERIC_GCREQUEST){
-      add_this_more_space(G_SIZE_IN_Q(GD_OBJ_TYPE));
+      add_this_more_space(G_SIZE_IN_Q(G_OBJ_TYPE));
       inbuf->rd_index--;
       return;
   }
diff -ruN klic-3.003-2002-03-21/runtime/gpointer.c klic-3.003-2002-03-23/runtime/gpointer.c
--- klic-3.003-2002-03-21/runtime/gpointer.c	Thu Mar 21 21:33:33 2002
+++ klic-3.003-2002-03-23/runtime/gpointer.c	Sat Mar 23 21:34:01 2002
@@ -9,8 +9,8 @@
 #include "g_pointer.h"
 
 #define CLASS_NAME  pointer
-#define GD_OBJ_TYPE struct pointer_object
-#define GD_OBJ_SIZE(obj) (G_SIZE_IN_Q(GD_OBJ_TYPE))
+#define G_OBJ_TYPE  struct pointer_object
+#define G_OBJ_SIZE  (G_SIZE_IN_Q(G_OBJ_TYPE))
 
 #include <klic/gd_macro.h>
 
@@ -19,8 +19,8 @@
 {
   G_STD_DECL;
 
-  if (GD_SELF->method_table != GD_OTHER->method_table) GD_GUNIFY_FAIL;
-  if (GD_SELF->pointer != GD_OTHER->pointer) GD_GUNIFY_FAIL;
+  if (g_self->method_table != GD_OTHER->method_table) GD_GUNIFY_FAIL;
+  if (g_self->pointer != GD_OTHER->pointer) GD_GUNIFY_FAIL;
   GD_GSUCCEED;
 }
 
@@ -28,17 +28,17 @@
 {
   G_STD_DECL;
 
-  if (GD_SELF->method_table != GD_OTHER->method_table) GD_UNIFY_FAIL;
-  if (GD_SELF->pointer != GD_OTHER->pointer) GD_UNIFY_FAIL;
+  if (g_self->method_table != GD_OTHER->method_table) GD_UNIFY_FAIL;
+  if (g_self->pointer != GD_OTHER->pointer) GD_UNIFY_FAIL;
 }
 
-GDDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GD_OBJ_TYPE *newself;
+  G_OBJ_TYPE* newself;
 
-  GDSET_NEWOBJ_IN_NEWGEN(newself);
-  newself->pointer = GD_SELF->pointer;
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
+  newself->pointer = g_self->pointer;
   G_RETURN_FROM_GC(newself);
 }
 
@@ -51,10 +51,10 @@
 G_DEF_NEW()
 {
   G_STD_DECL_FOR_NEW();
-  GD_OBJ_TYPE *newobj;
+  G_OBJ_TYPE* newobj;
 
   if (g_argc != 1) fatal("Argument mismatch in pointer:new");
-  G_HEAPALLOC(newobj,GD_OBJ_SIZE(newobj),(GD_OBJ_TYPE *));
+  G_HEAPALLOC(newobj, G_OBJ_SIZE, (G_OBJ_TYPE*));
   newobj->method_table = &G_method_table;
   newobj->pointer = (char*) g_argv[0];
   GD_RETURN_FROM_NEW(newobj);
diff -ruN klic-3.003-2002-03-21/runtime/gstring.c klic-3.003-2002-03-23/runtime/gstring.c
--- klic-3.003-2002-03-21/runtime/gstring.c	Thu Mar 21 22:05:29 2002
+++ klic-3.003-2002-03-23/runtime/gstring.c	Sat Mar 23 21:34:01 2002
@@ -17,20 +17,20 @@
 #endif
 
 #define CLASS_NAME  byte__string
-#define GD_OBJ_TYPE struct byte_string_object
-#define GD_OBJ_SIZE(obj) (G_SIZE_IN_Q(GD_OBJ_TYPE))
+#define G_OBJ_TYPE  struct byte_string_object
+#define G_OBJ_SIZE  (G_SIZE_IN_Q(G_OBJ_TYPE))
 
 #include <klic/gd_macro.h>
 
 #define ELEMSIZE 8
-#define STRING_OBJ(x)	((GD_OBJ_TYPE *)(G_FUNCTORP(x)))
+#define STRING_OBJ(x)	((G_OBJ_TYPE*) functorp(x))
 #define ROUND_UP(size)	(((size)+sizeof(q)-1)/sizeof(q))
 #define Shallow(string) \
 do{ if( !IS_SHALLOW_STRING(string) ) do_shallow(string); }while(0)
 
 #ifdef DIST
 extern void push_decode_stack();
-extern unsigned char* generic_string_body(GD_OBJ_TYPE* str);
+extern unsigned char* generic_string_body(G_OBJ_TYPE* str);
 static void decode_byte_string(combuf* inbuf);
 #endif /* DIST */
 
@@ -80,18 +80,18 @@
 {
   G_STD_DECL;
   long size, k;
-  if (GD_SELF->method_table != GD_OTHER->method_table) GD_GUNIFY_FAIL;
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
+  if (g_self->method_table != GD_OTHER->method_table) GD_GUNIFY_FAIL;
+  Shallow(g_self);
+  size = g_self->index;
   Shallow(GD_OTHER);
   if (GD_OTHER->index != size) GD_GUNIFY_FAIL;
-  if (IS_SHALLOW_STRING(GD_SELF)) {
-    if (BCMP(GD_SELF->body, GD_OTHER->body, size) != 0) GD_GUNIFY_FAIL;
+  if (IS_SHALLOW_STRING(g_self)) {
+    if (BCMP(g_self->body, GD_OTHER->body, size) != 0) GD_GUNIFY_FAIL;
   } else {
     for (k=0; k<size; k++) {
       unsigned char c = GD_OTHER->body[k];
-      Shallow(GD_SELF);
-      if (GD_SELF->body[k] != c) GD_GUNIFY_FAIL;
+      Shallow(g_self);
+      if (g_self->body[k] != c) GD_GUNIFY_FAIL;
       Shallow(GD_OTHER);
     }
   }
@@ -102,37 +102,37 @@
 {
   G_STD_DECL;
   long size, k;
-  if (GD_SELF->method_table != GD_OTHER->method_table) GD_UNIFY_FAIL;
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
+  if (g_self->method_table != GD_OTHER->method_table) GD_UNIFY_FAIL;
+  Shallow(g_self);
+  size = g_self->index;
   Shallow(GD_OTHER);
   if (GD_OTHER->index != size) GD_UNIFY_FAIL;
-  if (IS_SHALLOW_STRING(GD_SELF)) {
-    if (BCMP(GD_SELF->body, GD_OTHER->body, size) != 0) GD_UNIFY_FAIL;
+  if (IS_SHALLOW_STRING(g_self)) {
+    if (BCMP(g_self->body, GD_OTHER->body, size) != 0) GD_UNIFY_FAIL;
   } else {
     for (k=0; k<size; k++) {
       unsigned char c = GD_OTHER->body[k];
-      Shallow(GD_SELF);
-      if (GD_SELF->body[k] != c) GD_UNIFY_FAIL;
+      Shallow(g_self);
+      if (g_self->body[k] != c) GD_UNIFY_FAIL;
       Shallow(GD_OTHER);
     }
   }
 }
 
-GDDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GD_OBJ_TYPE *newself;
+  G_OBJ_TYPE* newself;
 
-  GDSET_NEWOBJ_IN_NEWGEN(newself);
-  if (GD_SELF->iscnst) {
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
+  if (g_self->iscnst) {
     fatal("GC method for constant string unexpected");
   }
   newself->iscnst = 0;
-  if (IS_SHALLOW_STRING(GD_SELF)) {
-    unsigned char *body = GD_SELF->body;
+  if (IS_SHALLOW_STRING(g_self)) {
+    unsigned char *body = g_self->body;
     unsigned char *newbody;
-    unsigned long size = GD_SELF->index;
+    unsigned long size = g_self->index;
     unsigned long qsize = ROUND_UP(size);
     if(heapp() + qsize > real_heaplimit()) fatal("Not enough space collected");
     newbody = (unsigned char*) klic_alloc(qsize);
@@ -141,29 +141,29 @@
     newself->body = newbody;
     BCOPY(body,newbody,qsize*sizeof(q));
   } else {
-    newself->index = GD_SELF->index;
-    newself->body = GD_SELF->body;
-    G_COPY_KL1_TERM_TO_NEWGEN(GD_SELF->next, newself->next);
+    newself->index = g_self->index;
+    newself->body = g_self->body;
+    G_COPY_KL1_TERM_TO_NEWGEN(g_self->next, newself->next);
   }
   G_RETURN_FROM_GC(newself);
 }
 
 #ifdef DIST
 /* for byte string */
-GDDEF_ENCODE()  
+G_DEF_ENCODE()  
 {
   G_STD_DECL;
   long size;
   int i;
   long *tmp_buf;
 
-  Shallow(GD_SELF);
+  Shallow(g_self);
 
   PUT_BUFFER(buffer, decode_byte_string);
-  PUT_BUFFER(buffer, GD_SELF->index);
-  size = ROUND_UP(GD_SELF->index);
+  PUT_BUFFER(buffer, g_self->index);
+  size = ROUND_UP(g_self->index);
   
-  tmp_buf = (long *)generic_string_body(GD_SELF);
+  tmp_buf = (long *)generic_string_body(g_self);
   for(i = 0 ; i < size ; i++){
     PUT_BUFFER(buffer, tmp_buf[i]);  /* Should be carefule of endian */
   }
@@ -176,57 +176,57 @@
 GDDEF_METHOD(string_2)
 {
   G_STD_DECL;
-  Shallow(GD_SELF);
-  G_UNIFY_VALUE(g_argv[0], G_MAKEINT(GD_SELF->index));
-  G_UNIFY_VALUE(g_argv[1], G_MAKEINT(ELEMSIZE));
+  Shallow(g_self);
+  G_UNIFY_VALUE(g_argv[0], makeint(g_self->index));
+  G_UNIFY_VALUE(g_argv[1], makeint(ELEMSIZE));
 }
 
 GDDEF_METHOD(element_2)
 {
   G_STD_DECL;
   long position;
-  Shallow(GD_SELF);
-  GDSET_INTARG_WITHIN_RANGE(position, g_argv[0], 0, (long) GD_SELF->index);
-  G_UNIFY_VALUE(g_argv[1], G_MAKEINT((unsigned long) GD_SELF->body[position]));
+  Shallow(g_self);
+  GDSET_INTARG_WITHIN_RANGE(position, g_argv[0], 0, (long) g_self->index);
+  G_UNIFY_VALUE(g_argv[1], makeint((unsigned long) g_self->body[position]));
 }
 
 GDDEF_METHOD(size_1)
 {
   G_STD_DECL;
-  Shallow(GD_SELF);
-  G_UNIFY_VALUE(g_argv[0], G_MAKEINT(GD_SELF->index));
+  Shallow(g_self);
+  G_UNIFY_VALUE(g_argv[0], makeint(g_self->index));
 }
 
 GDDEF_METHOD(element__size_1)
 {
   G_STD_DECL;
-  Shallow(GD_SELF);
-  G_UNIFY_VALUE(g_argv[0], G_MAKEINT(ELEMSIZE));
+  Shallow(g_self);
+  G_UNIFY_VALUE(g_argv[0], makeint(ELEMSIZE));
 }
 
 GDDEF_METHOD(set__element_3)
 {
   G_STD_DECL;
   long position, newelem;
-  GD_OBJ_TYPE *newstr;
+  G_OBJ_TYPE* newstr;
   unsigned char *body;
   int iscnst;
   long size;
 
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
-  iscnst = GD_SELF->iscnst;
-  body = GD_SELF->body;
+  Shallow(g_self);
+  size = g_self->index;
+  iscnst = g_self->iscnst;
+  body = g_self->body;
   GDSET_INTARG_WITHIN_RANGE(position, g_argv[0], 0, size);
   GDSET_INTARG_WITHIN_RANGE(newelem, g_argv[1], 0, 256);
   GDSET_NEWOBJ(newstr);
   if (!iscnst) {
     unsigned char olddata = body[position];
 
-    GD_SELF->index = position;
-    GD_SELF->body = (unsigned char *)(unsigned long)olddata;
+    g_self->index = position;
+    g_self->body = (unsigned char *)(unsigned long)olddata;
     body[position] = newelem;
-    GD_SELF->next = GD_OBJ(newstr);
+    g_self->next = GD_OBJ(newstr);
     newstr->body = body;
   } else {
     unsigned char *newbody;
@@ -250,17 +250,17 @@
   unsigned char *upper_body, *lower_body;
   struct byte_string_object *upper, *lower;
 
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
+  Shallow(g_self);
+  size = g_self->index;
   GDSET_INTARG_WITHIN_RANGE(split_point, g_argv[0], 0, size + 1);
   lower_size = size-split_point;
   GD_ALLOC_AREA(upper_body, (unsigned char *), ROUND_UP(split_point));
   GD_ALLOC_AREA(lower_body, (unsigned char *), ROUND_UP(lower_size));
-  GD_ALLOC_AREA(upper, (GD_OBJ_TYPE *), GD_OBJ_SIZE(GD_SELF));
-  GD_ALLOC_AREA(lower, (GD_OBJ_TYPE *), GD_OBJ_SIZE(GD_SELF));
-  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;
+  GD_ALLOC_AREA(upper, (G_OBJ_TYPE*), G_OBJ_SIZE);
+  GD_ALLOC_AREA(lower, (G_OBJ_TYPE*), G_OBJ_SIZE);
+  BCOPY(g_self->body, upper_body, split_point);
+  BCOPY(g_self->body+split_point, lower_body, lower_size);
+  upper->method_table = lower->method_table = g_self->method_table;
   upper->next = lower->next = STRING_SHALLOW_MARK;
   upper->index = split_point;
   lower->index = lower_size;
@@ -268,8 +268,8 @@
   upper->ismbdiff = lower->ismbdiff = 0;
   upper->body = upper_body;
   lower->body = lower_body;
-  G_UNIFY_VALUE(g_argv[1], G_MAKEFUNCTOR(upper));
-  G_UNIFY_VALUE(g_argv[2], G_MAKEFUNCTOR(lower));
+  G_UNIFY_VALUE(g_argv[1], makefunctor(upper));
+  G_UNIFY_VALUE(g_argv[2], makefunctor(lower));
 }
 
 GDDEF_METHOD(join_2)
@@ -277,15 +277,15 @@
   G_STD_DECL;
   unsigned long size1, size2, newsize;
   q anotherq = g_argv[0];
-  GD_OBJ_TYPE *another, *new;
+  G_OBJ_TYPE *another, *new;
   unsigned char *newbody;
 
-  Shallow(GD_SELF);
-  size1 = GD_SELF->index;
+  Shallow(g_self);
+  size1 = g_self->index;
   GD_DEREF(anotherq);
-  another = (GD_OBJ_TYPE*)G_FUNCTORP(anotherq);
-  if (!G_ISFUNCTOR(anotherq) ||
-      another->method_table != GD_SELF->method_table) {
+  another = (G_OBJ_TYPE*) functorp(anotherq);
+  if( !isfunctor(anotherq) ||
+      another->method_table != g_self->method_table) {
     debug_printf("### %k ###\n", another);
     fatal("Invalid argument to string join");
   }
@@ -293,18 +293,18 @@
   size2 = another->index;
   newsize = size1+size2;
   GD_ALLOC_AREA(newbody, (unsigned char *), ROUND_UP(newsize));
-  GD_ALLOC_AREA(new, (GD_OBJ_TYPE *), GD_OBJ_SIZE(GD_SELF));
-  Shallow(GD_SELF);
-  BCOPY(GD_SELF->body, newbody, size1);
+  GD_ALLOC_AREA(new, (G_OBJ_TYPE*), G_OBJ_SIZE);
+  Shallow(g_self);
+  BCOPY(g_self->body, newbody, size1);
   Shallow(another);
   BCOPY(another->body, newbody+size1, size2);
-  new->method_table = GD_SELF->method_table;
+  new->method_table = g_self->method_table;
   new->next = STRING_SHALLOW_MARK;
   new->index = newsize;
   new->iscnst = 0;
   new->ismbdiff = 0;
   new->body = newbody;
-  G_UNIFY_VALUE(g_argv[1], G_MAKEFUNCTOR(new));
+  G_UNIFY_VALUE(g_argv[1], makefunctor(new));
 }
 
 GDDEF_METHOD(search__character_4)
@@ -313,24 +313,24 @@
   long start, end, code;
   unsigned long k;
 
-  Shallow(GD_SELF);
-  GDSET_INTARG_WITHIN_RANGE(start, g_argv[0], 0, (long) GD_SELF->index);
-  GDSET_INTARG_WITHIN_RANGE(end,   g_argv[1], 0, (long) GD_SELF->index);
+  Shallow(g_self);
+  GDSET_INTARG_WITHIN_RANGE(start, g_argv[0], 0, (long) g_self->index);
+  GDSET_INTARG_WITHIN_RANGE(end,   g_argv[1], 0, (long) g_self->index);
   GDSET_INTARG_WITHIN_RANGE(code,  g_argv[2], 0, 256L);
   if (start <= end) {
     for (k=start; k<=end; k++) {
-      if (((unsigned long) GD_SELF->body[k]) == code) goto done;
+      if (((unsigned long) g_self->body[k]) == code) goto done;
     }
   } else {
     for (k=start; k>=end; k--) {
-      if (((unsigned long) GD_SELF->body[k]) == code) goto done;
+      if (((unsigned long) g_self->body[k]) == code) goto done;
     }
   }
-  G_UNIFY_VALUE(g_argv[3], G_MAKEINT(-1L));
+  G_UNIFY_VALUE(g_argv[3], makeint(-1L));
   return;
 
  done:
-  G_UNIFY_VALUE(g_argv[3], G_MAKEINT(k));
+  G_UNIFY_VALUE(g_argv[3], makeint(k));
 }
 
 
@@ -359,9 +359,9 @@
   G_STD_DECL;
   long position;
 
-  Shallow(GD_SELF);
-  GDSET_GINTARG_WITHIN_RANGE(position, g_argv[0], 0, (long) GD_SELF->index);
-  g_argv[1] = G_MAKEINT((long) GD_SELF->body[position]);
+  Shallow(g_self);
+  GDSET_GINTARG_WITHIN_RANGE(position, g_argv[0], 0, (long) g_self->index);
+  g_argv[1] = makeint((long) g_self->body[position]);
   GD_GSUCCEED;
 }
 
@@ -369,14 +369,13 @@
 {
   G_STD_DECL;
 
-  Shallow(GD_SELF);
-  g_argv[0] = G_MAKEINT(GD_SELF->index);
-  g_argv[1] = G_MAKEINT(ELEMSIZE);
+  Shallow(g_self);
+  g_argv[0] = makeint(g_self->index);
+  g_argv[1] = makeint(ELEMSIZE);
   GD_GSUCCEED;
 }
 
-static int compare_two_strings(s1, s2)
-     GD_OBJ_TYPE *s1, *s2;
+static int compare_two_strings(G_OBJ_TYPE* s1, G_OBJ_TYPE* s2)
 {
   long size1, size2, minsize, k;
   Shallow(s1);
@@ -413,13 +412,13 @@
 {
   G_STD_DECL;
   q otherq = g_argv[0];
-  GD_OBJ_TYPE *other;
+  G_OBJ_TYPE* other;
   int cmp;
 
   if (!G_ISGOBJ(otherq)) GD_GFAIL;
-  other = (GD_OBJ_TYPE *)G_FUNCTORP(otherq);
-  if (other->method_table != GD_SELF->method_table) GD_GFAIL;
-  cmp = compare_two_strings(GD_SELF, other);
+  other = (G_OBJ_TYPE*) functorp(otherq);
+  if (other->method_table != g_self->method_table) GD_GFAIL;
+  cmp = compare_two_strings(g_self, other);
   if (cmp < 0) GD_GSUCCEED; else GD_GFAIL;
 }
 
@@ -427,13 +426,13 @@
 {
   G_STD_DECL;
   q otherq = g_argv[0];
-  GD_OBJ_TYPE *other;
+  G_OBJ_TYPE* other;
   int cmp;
 
   if (!G_ISGOBJ(otherq)) GD_GFAIL;
-  other = (GD_OBJ_TYPE *)G_FUNCTORP(otherq);
-  if (other->method_table != GD_SELF->method_table) GD_GFAIL;
-  cmp = compare_two_strings(GD_SELF, other);
+  other = (G_OBJ_TYPE*) functorp(otherq);
+  if (other->method_table != g_self->method_table) GD_GFAIL;
+  cmp = compare_two_strings(g_self, other);
   if (cmp >= 0) GD_GSUCCEED; else GD_GFAIL;
 }
 
@@ -443,13 +442,13 @@
   long size, k;
   q tmp;
 
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
-  if( G_INTVAL(g_argv[0]) != size ) GD_GFAIL;
-  if( G_INTVAL(g_argv[1]) != ELEMSIZE ) GD_GFAIL;
+  Shallow(g_self);
+  size = g_self->index;
+  if( intval(g_argv[0]) != size ) GD_GFAIL;
+  if( intval(g_argv[1]) != ELEMSIZE ) GD_GFAIL;
   tmp = g_argv[2];
-  for(k=0; k<size; k++, tmp = G_CDR_OF(tmp)) {
-    if(G_INTVAL(G_CAR_OF(tmp))!= GD_SELF->body[k]) GD_GFAIL;
+  for( k=0; k < size; k++, tmp = cdr_of(tmp) ){
+    if( intval(car_of(tmp)) != g_self->body[k] ) GD_GFAIL;
   }
   GD_GSUCCEED;
 }
@@ -468,16 +467,16 @@
   }
 }
 
-GDDEF_PRINT()
+G_DEF_PRINT()
 {
   G_STD_DECL;
   unsigned long size, limit, k;
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
+  Shallow(g_self);
+  size = g_self->index;
   limit = (size > g_length ? g_length : size);
   GD_PUTC('"');
   for (k = 0; k < limit; k++) {
-    int c = GD_SELF->body[k];
+    int c = g_self->body[k];
     if (!isgraph(c) && c!=' ') {
       GD_PUTC('\\');
       GD_PUTC('0'+((c>>6)&3));
@@ -488,7 +487,7 @@
       GD_PUTC(c);
     }
   }
-  if (limit != size) GD_PRINT("..");
+  if( limit != size ) G_PRINT("..");
   GD_PUTC('"');
   G_RETURN_FROM_PRINT();
 }
@@ -497,24 +496,24 @@
 {
   G_STD_DECL;
   unsigned long size1, size2, limit, k;
-  Shallow(GD_SELF);
-  size1 = GD_SELF->index;
+  Shallow(g_self);
+  size1 = g_self->index;
   Shallow(GD_OTHER);
   size2 = GD_OTHER->index;
   limit = (size1 <= size2 ? size1 : size2);
   for (k = 0; k < limit; k++) {
     unsigned char elem;
-    Shallow(GD_SELF);
-    elem = GD_SELF->body[k];
+    Shallow(g_self);
+    elem = g_self->body[k];
     Shallow(GD_OTHER);
     if (elem != GD_OTHER->body[k]) {
-      return G_MAKEINT(elem > GD_OTHER->body[k] ? k+1 : -(k+1));
+      return makeint(elem > GD_OTHER->body[k] ? k+1 : -(k+1));
     }
   }
   if (size1 != size2) {
-    return G_MAKEINT(size1 >= size2 ? size1+1 : -(size2+1));
+    return makeint(size1 >= size2 ? size1+1 : -(size2+1));
   } else {
-    return G_MAKEINT(0);
+    return makeint(0);
   }
 }
 
@@ -522,15 +521,15 @@
 {
   G_STD_DECL;
   unsigned long size;
-  Shallow(GD_SELF);
-  size = GD_SELF->index;
+  Shallow(g_self);
+  size = g_self->index;
   if (size == 0) {
-    return G_MAKEINT(0);
+    return makeint(0);
   } else {
     return
-      G_MAKEINT(0x813 * GD_SELF->body[0] +
-		0x425 * GD_SELF->body[size>>1] +
-		0x3c9 * GD_SELF->body[size-1]);
+      makeint( 0x813 * g_self->body[0] +
+		0x425 * g_self->body[size >> 1] +
+		0x3c9 * g_self->body[size - 1] );
   }
 }
 
@@ -553,7 +552,7 @@
 G_DEF_NEW()
 {
   G_STD_DECL_FOR_NEW();
-  GD_OBJ_TYPE *newstr;
+  G_OBJ_TYPE* newstr;
   unsigned char *body;
   long size;
   q init;
@@ -561,27 +560,27 @@
   if( g_argc != 1 ) G_ERROR_IN_NEW("Too few or too many arguments");
   init = g_argv[0];
   G_DEREF_FOR_NEW(init);
-  GDSET_NEWOBJ_FOR_NEW(newstr, G_SIZE_IN_Q(GD_OBJ_TYPE));
-  if (G_ISINT(init)) {
+  G_SET_NEWOBJ_FOR_NEW(newstr, G_SIZE_IN_Q(G_OBJ_TYPE));
+  if( isint(init) ){
     unsigned long qsize;
-    size = G_INTVAL(init);
+    size = intval(init);
     if (size < 0) G_ERROR_IN_NEW("Negative size specified");
     qsize = ROUND_UP(size);
     GD_ALLOC_AREA_FOR_NEW(body, (unsigned char *), qsize);
     BZERO(body, qsize*sizeof(q));
-  } else if (init==NILATOM || G_ISCONS(init)) {
+  }else if( init==NILATOM || iscons(init) ){
     unsigned long qsize, k;
     for (size=0; ; size++) {
       q elem;
       if (init == NILATOM) break;
-      elem = G_CAR_OF(init);
+      elem = car_of(init);
       G_DEREF_FOR_NEW(elem);
-      if (!G_ISINT(elem) || G_INTVAL(elem) < 0 || 256 <= G_INTVAL(elem)) {
+      if( !isint(elem) || intval(elem) < 0 || 256 <= intval(elem) ){
 	G_ERROR_IN_NEW("Invalid parameter");
       }
-      init = G_CDR_OF(init);
+      init = cdr_of(init);
       G_DEREF_FOR_NEW(init);
-      if (init!=NILATOM && !G_ISCONS(init))
+      if( init != NILATOM && !iscons(init) )
 	G_ERROR_IN_NEW("Invalid parameter");
     }
     qsize = ROUND_UP(size);
@@ -590,10 +589,10 @@
     for (k=0; k<size; k++) {
       q elem;
       G_DEREF_FOR_NEW(init);
-      elem = G_CAR_OF(init);
+      elem = car_of(init);
       G_DEREF_FOR_NEW(elem);
-      body[k] = G_INTVAL(elem);
-      init = G_CDR_OF(init);
+      body[k] = intval(elem);
+      init = cdr_of(init);
     }
   } else {
     G_ERROR_IN_NEW("Invalid parameter");
@@ -611,17 +610,17 @@
      combuf *inbuf;
 {
   G_STD_DECL;
-  GD_OBJ_TYPE *newstring;
+  G_OBJ_TYPE* newstring;
   unsigned char *body;
   unsigned long size;
   long *tmp_buf;
   int i;
   q res;
 
-  G_HEAPALLOC_WITH_CHECK(newstring, G_SIZE_IN_Q(GD_OBJ_TYPE), 
-			  (GD_OBJ_TYPE*), res);
+  G_HEAPALLOC_WITH_CHECK(newstring, G_SIZE_IN_Q(G_OBJ_TYPE),
+			 (G_OBJ_TYPE*), res);
   if(res == GENERIC_GCREQUEST){ 
-      add_this_more_space(G_SIZE_IN_Q(GD_OBJ_TYPE));
+      add_this_more_space(G_SIZE_IN_Q(G_OBJ_TYPE));
       inbuf->rd_index--;
       return;
   }
@@ -656,16 +655,14 @@
 #endif /* DIST */
 
 extern unsigned char*
-generic_string_body(str)
-  GD_OBJ_TYPE* str;
+generic_string_body(G_OBJ_TYPE* str)
 {
   Shallow(str);
   return (str->body);
 }
 
 extern unsigned long
-generic_string_size(str)
-  GD_OBJ_TYPE* str;
+generic_string_size(G_OBJ_TYPE* str)
 {
   Shallow(str);
   return (str->index);
@@ -681,7 +678,7 @@
 
   argv[0] = makeint(len);
   str = byte__string_g_new(1, argv);
-  if (!G_ISREF(str)) {
+  if( !isref(str) ){
     BCOPY(cstr, ((struct byte_string_object *)functorp(str))->body, len);
   }
   return str;
@@ -697,7 +694,7 @@
 
   argv[0] = makeint(len);
   str = byte__string_g_new(1, argv);
-  if (!G_ISREF(str)) {
+  if( !isref(str) ){
     BCOPY(cstr, ((struct byte_string_object *)functorp(str))->body, len);
   }
   return str;
@@ -724,7 +721,7 @@
      q s;
 {
   Shallow(STRING_OBJ(s));
-  return G_MAKEINT(STRING_OBJ(s)->index);
+  return makeint(STRING_OBJ(s)->index);
 }
 
 extern q
@@ -732,10 +729,10 @@
      q s, k;
 {
   Shallow(STRING_OBJ(s));
-  if (G_INTVAL(k) < 0 || (long)(STRING_OBJ(s)->index) <= G_INTVAL(k)) {
+  if( intval(k) < 0 || (long) STRING_OBJ(s)->index <= intval(k) ){
     return (q) 0;
   } else {
-    return G_MAKEINT(STRING_OBJ(s)->body[G_INTVAL(k)]);
+    return makeint(STRING_OBJ(s)->body[intval(k)]);
   }
 }
 
diff -ruN klic-3.003-2002-03-21/runtime/gtermarray.c klic-3.003-2002-03-23/runtime/gtermarray.c
--- klic-3.003-2002-03-21/runtime/gtermarray.c	Thu Mar 21 21:33:56 2002
+++ klic-3.003-2002-03-23/runtime/gtermarray.c	Sat Mar 23 21:34:01 2002
@@ -9,8 +9,8 @@
 #include "g_termarray.h"
 
 #define CLASS_NAME  termarray
-#define GD_OBJ_TYPE struct termarray_object
-#define GD_OBJ_SIZE(obj) (G_SIZE_IN_Q(GD_OBJ_TYPE)+obj->nterm-1)
+#define G_OBJ_TYPE  struct termarray_object
+#define G_OBJ_SIZE  (G_SIZE_IN_Q(G_OBJ_TYPE) + g_self->nterm - 1)
 
 #include <klic/gd_macro.h>
 
@@ -18,9 +18,9 @@
 {
   G_STD_DECL;
 
-  if (GD_SELF->method_table != GD_OTHER->method_table) GD_GUNIFY_FAIL;
-  if (GD_SELF->terms != GD_OTHER->terms) GD_GUNIFY_FAIL;
-  if (GD_SELF->nterm != GD_OTHER->nterm) GD_GUNIFY_FAIL;
+  if (g_self->method_table != GD_OTHER->method_table) GD_GUNIFY_FAIL;
+  if (g_self->terms != GD_OTHER->terms) GD_GUNIFY_FAIL;
+  if (g_self->nterm != GD_OTHER->nterm) GD_GUNIFY_FAIL;
   GD_GSUCCEED;
 }
 
@@ -28,22 +28,22 @@
 {
   G_STD_DECL;
 
-  if (GD_SELF->method_table != GD_OTHER->method_table) GD_UNIFY_FAIL;
-  if (GD_SELF->terms != GD_OTHER->terms) GD_UNIFY_FAIL;
-  if (GD_SELF->nterm != GD_OTHER->nterm) GD_UNIFY_FAIL;
+  if (g_self->method_table != GD_OTHER->method_table) GD_UNIFY_FAIL;
+  if (g_self->terms != GD_OTHER->terms) GD_UNIFY_FAIL;
+  if (g_self->nterm != GD_OTHER->nterm) GD_UNIFY_FAIL;
 }
 
-GDDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  unsigned long size = GD_SELF->nterm;
-  GD_OBJ_TYPE *newself;
+  unsigned long size = g_self->nterm;
+  G_OBJ_TYPE* newself;
   unsigned long i;
 
-  GDSET_NEWOBJ_IN_NEWGEN(newself);
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
   newself->nterm = size;
   for (i=0; i < size; i++) {
-    G_COPY_KL1_TERM_TO_NEWGEN(GD_SELF->terms[i],newself->terms[i]);
+    G_COPY_KL1_TERM_TO_NEWGEN(g_self->terms[i],newself->terms[i]);
   }
   G_RETURN_FROM_GC(newself);
 }
@@ -58,10 +58,10 @@
 {
   G_STD_DECL_FOR_NEW();
   unsigned long size = g_argc;
-  GD_OBJ_TYPE *newobj;
+  G_OBJ_TYPE* newobj;
   int i;
 
-  G_HEAPALLOC(newobj,G_SIZE_IN_Q(GD_OBJ_TYPE)+size-1,(GD_OBJ_TYPE *));
+  G_HEAPALLOC(newobj, G_SIZE_IN_Q(G_OBJ_TYPE)+size-1, (G_OBJ_TYPE*));
   newobj->method_table = &G_method_table;
   newobj->nterm = size;
   for (i=0; i<size; i++) {
diff -ruN klic-3.003-2002-03-21/runtime/random.c klic-3.003-2002-03-23/runtime/random.c
--- klic-3.003-2002-03-21/runtime/random.c	Thu Mar 21 21:50:26 2002
+++ klic-3.003-2002-03-23/runtime/random.c	Sat Mar 23 21:34:01 2002
@@ -16,13 +16,13 @@
 #include <klic/g_basic.h>
 #include <klic/gcobject.h>
 
-#define CLASS_NAME		random__numbers
-#define GC_OBJ_TYPE		struct random_number_generator
-#define GC_OBJ_SIZE(obj)  G_SIZE_IN_Q(GC_OBJ_TYPE)
+#define CLASS_NAME  random__numbers
+#define G_OBJ_TYPE  struct random_number_generator
+#define G_OBJ_SIZE  G_SIZE_IN_Q(G_OBJ_TYPE)
 
 #include <klic/gc_macro.h>
 
-GC_OBJ_TYPE {
+G_OBJ_TYPE {
   struct consumer_object_method_table* method_table;
   long range;
   long max;
@@ -48,10 +48,10 @@
     long one_random;
 
     do{
-      one_random = nrand48(GC_SELF->state);
-    }while( one_random >= GC_SELF->max );
+      one_random = nrand48(g_self->state);
+    }while( one_random >= g_self->max );
 
-    derefone(car_of(g_term)) = makeint(one_random % GC_SELF->range);
+    derefone(car_of(g_term)) = makeint(one_random % g_self->range);
     g_term = cdr_of(g_term);
     goto top;
   }else{
@@ -59,19 +59,19 @@
   }
 }
 
-GCDEF_PRINT()
+G_DEF_PRINT()
 {
   G_STD_DECL;
-  fprintf(g_fp, "RANDOM@%X", (q*) GC_SELF - new_space_top());
+  fprintf(g_fp, "RANDOM@%X", (q*) g_self - new_space_top());
   return 0;
 }
 
-GCDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  q* newself = klic_alloc(sizeof(GC_OBJ_TYPE) / sizeof(q));
+  q* newself = klic_alloc(sizeof(G_OBJ_TYPE) / sizeof(q));
 
-  BCOPY(GC_SELF, newself, sizeof(GC_OBJ_TYPE));
+  BCOPY(g_self, newself, sizeof(G_OBJ_TYPE));
   return newself;
 }
 
@@ -84,7 +84,7 @@
 G_DEF_NEW()
 {
   G_STD_DECL_FOR_NEW();
-  GC_OBJ_TYPE* obj;
+  G_OBJ_TYPE* obj;
   long seed;
   long range;
 
@@ -109,7 +109,7 @@
     seed = 0;
   }
 
-  GCSET_NEWOBJ_FOR_NEW(obj, GC_OBJ_SIZE(obj));
+  G_SET_NEWOBJ_FOR_NEW(obj, G_OBJ_SIZE);
 
   obj->state[0] = seed >> (sizeof(seed)*4);
   obj->state[1] = seed >> (sizeof(seed)*2);
diff -ruN klic-3.003-2002-03-21/runtime/wakeup.c klic-3.003-2002-03-23/runtime/wakeup.c
--- klic-3.003-2002-03-21/runtime/wakeup.c	Thu Mar 21 21:34:07 2002
+++ klic-3.003-2002-03-23/runtime/wakeup.c	Sat Mar 23 21:34:01 2002
@@ -16,8 +16,8 @@
 };
 
 #define CLASS_NAME  GC_wakeup
-#define GC_OBJ_TYPE struct GC_wakeup_object
-#define GC_OBJ_SIZE(obj)  sizeof(GC_OBJ_TYPE)
+#define G_OBJ_TYPE  struct GC_wakeup_object
+#define G_OBJ_SIZE  sizeof(G_OBJ_TYPE)
 
 #include <klic/gc_macro.h>
 
@@ -27,26 +27,26 @@
 {
   G_STD_DECL;
 
-  GC_KL1_UNIFY(GC_SELF->x,GC_SELF->y);
+  GC_KL1_UNIFY(g_self->x, g_self->y);
   GC_TERMINATE;
 }
 
-GCDEF_GC()
+G_DEF_GC()
 {
   G_STD_DECL;
-  GC_OBJ_TYPE *newself;
+  G_OBJ_TYPE* newself;
 
-  GCSET_NEWOBJ_IN_NEWGEN(newself);
-  G_COPY_KL1_TERM_TO_NEWGEN(GC_SELF->x,newself->x);
-  G_COPY_KL1_TERM_TO_NEWGEN(GC_SELF->y,newself->y);
+  G_SET_NEWOBJ_IN_NEWGEN(newself);
+  G_COPY_KL1_TERM_TO_NEWGEN(g_self->x, newself->x);
+  G_COPY_KL1_TERM_TO_NEWGEN(g_self->y, newself->y);
   G_RETURN_FROM_GC(newself);
 }
 
 
-GCDEF_PRINT()
+G_DEF_PRINT()
 {
   G_STD_DECL;
-  GC_PRINT("$$WAKEUP$");
+  G_PRINT("$$WAKEUP$");
   G_RETURN_FROM_PRINT();
 }
 
@@ -61,12 +61,12 @@
 G_DEF_NEW()
 {
   G_STD_DECL_FOR_NEW();
-  GC_OBJ_TYPE *wakeup;
+  G_OBJ_TYPE* wakeup;
   q var;
 
   if (g_argc != 2) fatal("arity mismatch in creation of a merger.");
 
-  GCSET_NEWOBJ_FOR_NEW(wakeup,GC_OBJ_SIZE(wakeup));
+  G_SET_NEWOBJ_FOR_NEW(wakeup, G_OBJ_SIZE);
   wakeup->x = g_argv[0];
   wakeup->y = g_argv[1];
   var = GC_MAKE_HOOK_VAR((struct consumer_object*) wakeup);