Update to use new microcode types and macros.

diff --git a/v7/src/microcode/cmpgc.h b/v7/src/microcode/cmpgc.h
index 01a773ed4e79a8f3f646f08b2b99ebfd475a9069..625006637210a92927015b25606d8802e52b07fc 100644 (file)
--- a/v7/src/microcode/cmpgc.h
+++ b/v7/src/microcode/cmpgc.h
@@ -30,7 +30,7 @@ Technology nor of any adaptation thereof in any advertising,
 promotional, or sales literature without prior written consent from
 MIT in each case. */
 
-/* $Header: /Users/cph/tmp/foo/mit-scheme/mit-scheme/v7/src/microcode/cmpgc.h,v 1.1 1989/06/02 14:49:36 jinx Exp $
+/* $Header: /Users/cph/tmp/foo/mit-scheme/mit-scheme/v7/src/microcode/cmpgc.h,v 1.2 1989/10/23 21:36:48 jinx Exp $
    $MC68020-Header: cmp68kgc.h,v 9.30 89/03/27 23:14:31 GMT jinx Exp $
 
 Utilities to relocate compiled code in garbage collection-like processes. 
@@ -55,10 +55,10 @@ See cmpint.txt, cmpint.h, cmpint.c, and cmpaux.m4 for more details.
 
 #else
 
-extern Pointer compiler_utilities;
+extern SCHEME_OBJECT compiler_utilities;
 
 #define Compiled_Code_Pre_Test(then_what)                              \
-if (Old == Get_Pointer(compiler_utilities))                            \
+if (Old == (OBJECT_ADDRESS(compiler_utilities)))                       \
   then_what;                                                           \
 else
 
@@ -89,19 +89,20 @@ else
   do                                                                   \
   {                                                                    \
     offset_word = (COMPILED_ENTRY_OFFSET_WORD(var));                   \
-    var = ((Pointer *) (((char *) (var)) -                             \
-                       (OFFSET_WORD_TO_BYTE_OFFSET(offset_word))));    \
+    var = ((SCHEME_OBJECT *)                                           \
+          (((char *) (var)) -                                          \
+           (OFFSET_WORD_TO_BYTE_OFFSET(offset_word))));                \
   } while (OFFSET_WORD_CONTINUATION_P(offset_word));                   \
 }
 
 #define RELOCATE_COMPILED_ADDRESS(object, new_block, old_block)                \
-((Pointer *) (((char *) new_block) +                                   \
-             (((char *) Get_Pointer(object)) -                         \
-              ((char *) old_block))))
+((SCHEME_OBJECT *) (((char *) new_block) +                             \
+                   (((char *) (OBJECT_ADDRESS(object))) -              \
+                    ((char *) old_block))))
 
 #define Relocate_Compiled(object, new_block, old_block)                        \
-Make_Pointer(OBJECT_TYPE(object),                                      \
-            RELOCATE_COMPILED_ADDRESS(object, new_block, old_block))
+MAKE_POINTER_OBJECT((OBJECT_TYPE(object)),                             \
+                   (RELOCATE_COMPILED_ADDRESS(object, new_block, old_block)))
 
 #define Compiled_BH(In_GC, then_what)                                  \
 {                                                                      \
@@ -111,19 +112,19 @@ Make_Pointer(OBJECT_TYPE(object),                                 \
   Compiled_Code_Pre_Test(then_what)                                    \
   if (OBJECT_TYPE(*Old) == TC_BROKEN_HEART)                            \
   {                                                                    \
-    *Scan = Relocate_Compiled(Temp, Get_Pointer(*Old), Old);           \
+    *Scan = Relocate_Compiled(Temp, (OBJECT_ADDRESS(*Old)), Old);      \
     then_what;                                                         \
   }                                                                    \
 }
 
 #define Transport_Compiled()                                           \
 {                                                                      \
-  Pointer *Saved_Old = Old;                                            \
+  SCHEME_OBJECT *Saved_Old = Old;                                      \
                                                                        \
   Real_Transport_Vector();                                             \
   *Saved_Old = New_Address;                                            \
   *Scan = Relocate_Compiled(Temp,                                      \
-                           Get_Pointer(New_Address),                   \
+                           (OBJECT_ADDRESS (New_Address)),             \
                            Saved_Old);                                 \
 }
 \f
@@ -133,29 +134,35 @@ Make_Pointer(OBJECT_TYPE(object),                                 \
 
 /* Bump back to header. */
 
-#define FIRST_MANIFEST_CLOSURE_ENTRY(scan)             \
-  ((machine_word *) (((Pointer *) scan) - 1))
+#define FIRST_MANIFEST_CLOSURE_ENTRY(scan)                             \
+  ((machine_word *) (((SCHEME_OBJECT *) scan) - 1))
 
-#define VALID_MANIFEST_CLOSURE_ENTRY(word_ptr)         \
-  ((OBJECT_TYPE(*((Pointer *) word_ptr))) == TC_MANIFEST_CLOSURE)
+#define VALID_MANIFEST_CLOSURE_ENTRY(word_ptr)                         \
+  ((OBJECT_TYPE(*((SCHEME_OBJECT *) word_ptr))) == TC_MANIFEST_CLOSURE)
 
-#define MANIFEST_CLOSURE_ENTRY_ADDRESS(word_ptr)       \
+/* *** THIS DOES NOT WORK *** */
+
+/* The macro is more general and needs a destination.
+   The garbage collector must be changed for that.
+ */
+
+#define MANIFEST_CLOSURE_ENTRY_ADDRESS(word_ptr)               \
   (COMPILED_CLOSURE_ENTRY_ADDRESS(word_ptr))
 
-#define NEXT_MANIFEST_CLOSURE_ENTRY(word_ptr)          \
-  ((machine_word *)                                    \
-   (((Pointer *) word_ptr) +                           \
+#define NEXT_MANIFEST_CLOSURE_ENTRY(word_ptr)                  \
+  ((machine_word *)                                            \
+   (((SCHEME_OBJECT *) word_ptr) +                             \
     (COMPILED_CLOSURE_ENTRY_SIZE + 1)))
 
 /* This takes into account the fact that the relocation loop increments
    by 1 on each major iteration.
  */
 
-#define MANIFEST_CLOSURE_END(end_ptr, start_ptr)       \
-  (((Pointer *) end_ptr) - 1)
+#define MANIFEST_CLOSURE_END(end_ptr, start_ptr)               \
+  (((SCHEME_OBJECT *) end_ptr) - 1)
 
-#define MANIFEST_CLOSURE_VALID_FITS_P(word_ptr, top)   \
-  ((NEXT_MANIFEST_CLOSURE_ENTRY(word_ptr)) <=          \
+#define MANIFEST_CLOSURE_VALID_FITS_P(word_ptr, top)           \
+  ((NEXT_MANIFEST_CLOSURE_ENTRY(word_ptr)) <=                  \
    ((machine_word *) top))
 \f
 /* Linkage sections */
@@ -164,36 +171,43 @@ Make_Pointer(OBJECT_TYPE(object),                                 \
 #define REFERENCE_LINKAGE_KIND                 0x010000
 #define ASSIGNMENT_LINKAGE_KIND                        0x020000
 
-#define READ_LINKAGE_KIND(header)                      \
+#define READ_LINKAGE_KIND(header)                              \
   ((header) & 0xff0000)
 
-#define READ_CACHE_LINKAGE_COUNT(header)               \
+#define READ_CACHE_LINKAGE_COUNT(header)                       \
   ((header) & 0xffff)
 
-#define READ_OPERATOR_LINKAGE_COUNT(header)            \
+#define READ_OPERATOR_LINKAGE_COUNT(header)                    \
   (OPERATOR_LINK_COUNT_TO_ENTRIES((header) & 0xffff))
   
 /* This takes into account the 1 added by the main loop of the
    relocators.
  */
 
-#define END_OPERATOR_LINKAGE_AREA(scan, count)         \
-  (((Pointer *) (scan)) + ((count) * OPERATOR_LINK_ENTRY_SIZE))
+#define END_OPERATOR_LINKAGE_AREA(scan, count)                 \
+  (((SCHEME_OBJECT *) (scan)) + ((count) * OPERATOR_LINK_ENTRY_SIZE))
 
-#define FIRST_OPERATOR_LINKAGE_ENTRY(scan)             \
-  ((machine_word *) (((Pointer *) (scan)) + 1))
+#define FIRST_OPERATOR_LINKAGE_ENTRY(scan)                     \
+  ((machine_word *) (((SCHEME_OBJECT *) (scan)) + 1))
+
+/* *** THIS DOES NOT WORK *** */
+
+/* The macro is more general and needs a destination.
+   The garbage collector must be changed for that.
+ */
 
-#define OPERATOR_LINKAGE_ENTRY_ADDRESS(word_ptr)       \
-  (OPERATOR_LINK_ENTRY_ADDRESS(word_ptr))
+#define OPERATOR_LINKAGE_ENTRY_ADDRESS(word_ptr)               \
+  (OPERATOR_LINK_ADDRESS(word_ptr))
 
-#define NEXT_LINKAGE_OPERATOR_ENTRY(word_ptr)          \
-  ((machine_word *) (((Pointer *) (word_ptr)) + OPERATOR_LINK_ENTRY_SIZE))
+#define NEXT_LINKAGE_OPERATOR_ENTRY(word_ptr)                  \
+  ((machine_word *) (((SCHEME_OBJECT *) (word_ptr)) +          \
+                    OPERATOR_LINK_ENTRY_SIZE))
 \f
 /* Heuristic recovery aid.  See unix.c for details. */
 
-#define CC_BLOCK_FIRST_GC_OFFSET                       \
+#define CC_BLOCK_FIRST_GC_OFFSET                               \
   (CC_BLOCK_FIRST_ENTRY_OFFSET - (sizeof(machine_word)))
 
 #define PLAUSIBLE_CC_BLOCK_P(block)                                    \
-  ((*((machine_word *) (((char *) block) + CC_BLOCK_FIRST_GC_OFFSET))) == \
+((*((machine_word *) (((char *) block) + CC_BLOCK_FIRST_GC_OFFSET))) ==        \
    ((BYTE_OFFSET_TO_OFFSET_WORD(CC_BLOCK_FIRST_ENTRY_OFFSET))))