Replace deprecated format structures and functions in test cases.

The object format variant structures (mps_fmt_A_s, mps_fmt_B_s,
mps_fmt_auto_header_s) and the functions taking them as
arguments (mps_fmt_create_A, mps_fmt_create_B,
mps_fmt_create_auto_header) were deprecated in release 1.112.0.

Using the recommended interface mps_fmt_create_k in test cases
improves the coverage of that interfaces, makes it easy to remove the
deprecated interfaces if needed, and prepares the test cases for the
addition of more format methods if needed.

Additionally, remove copy methods and associated code for counting the
number of copies, as copy methods are not called and so this code is
unreachable or ineffective.

Author: gareth-rees

code/amsss.c

@@ -213,7 +213,7 @@ int main(int argc, char *argv[])
   mps_message_type_enable(arena, mps_message_type_gc_start());
   mps_message_type_enable(arena, mps_message_type_gc());
   die(mps_thread_reg(&thread, arena), "thread_reg");
-  die(mps_fmt_create_A(&format, arena, dylan_fmt_A()), "fmt_create");
+  die(dylan_fmt(&format, arena), "fmt_create");
   die(mps_chain_create(&chain, arena, 1, testChain), "chain_create");
 
   for (i = 0; i < 8; i++) {

code/awlut.c

@@ -305,10 +305,8 @@ static void setup(struct guff_s *guff)
 
   die(mps_root_create_thread(&stack, arena, thr, guff),
       "Root Create\n");
-  die(mps_fmt_create_A(&dylanfmt, arena, dylan_fmt_A()),
-      "Format Create\n");
-  die(mps_fmt_create_A(&dylanweakfmt, arena, dylan_fmt_A_weak()),
-      "Format Create (weak)\n");
+  die(dylan_fmt(&dylanfmt, arena), "Format Create");
+  die(dylan_fmt_weak(&dylanweakfmt, arena), "Format Create (weak)");
   MPS_ARGS_BEGIN(args) {
     MPS_ARGS_ADD(args, MPS_KEY_FORMAT, dylanfmt);
     die(mps_pool_create_k(&leafpool, arena, mps_class_lo(), args),

code/awlutth.c

@@ -254,10 +254,8 @@ static void setup(struct guff_s *guff)
 
   die(mps_root_create_thread(&stack, arena, thr, guff),
       "Root Create\n");
-  die(mps_fmt_create_A(&dylanfmt, arena, dylan_fmt_A()),
-      "Format Create\n");
-  die(mps_fmt_create_A(&dylanweakfmt, arena, dylan_fmt_A_weak()),
-      "Format Create (weak)\n");
+  die(dylan_fmt(&dylanfmt, arena), "Format Create");
+  die(dylan_fmt_weak(&dylanweakfmt, arena), "Format Create (weak)");
   die(mps_pool_create(&leafpool, arena, mps_class_lo(), dylanfmt),
       "Leaf Pool Create\n");
   die(mps_pool_create(&tablepool, arena, mps_class_awl(), dylanweakfmt,

code/comm.gmk

@@ -162,9 +162,9 @@ MV2 = poolmv2.c
 MVFF = poolmvff.c
 TESTLIB = testlib.c
 TESTTHR = testthrix.c
-FMTDY = fmtdy.c fmtno.c
-FMTDYTST = fmtdy.c fmtno.c fmtdytst.c
-FMTHETST = fmthe.c fmtdy.c fmtno.c fmtdytst.c
+FMTDY = fmtdy.c
+FMTDYTST = fmtdy.c fmtdytst.c
+FMTHETST = fmthe.c fmtdy.c fmtdytst.c
 FMTSCM = fmtscheme.c
 PLINTH = mpsliban.c mpsioan.c
 MPMCOMMON = \

code/commpre.nmk

@@ -181,8 +181,8 @@ LO = [poollo]
 MVFF = [poolmvff]
 POOLN = [pooln]
 SNC = [poolsnc]
-FMTDY = [fmtdy] [fmtno]
-FMTTEST = [fmthe] [fmtdy] [fmtno] [fmtdytst]
+FMTDY = [fmtdy]
+FMTTEST = [fmthe] [fmtdy] [fmtdytst]
 FMTSCHEME = [fmtscheme]
 TESTLIB = [testlib] [getoptl]
 TESTTHR = [testthrw3]

code/finalcv.c

@@ -116,7 +116,7 @@ static void test(mps_arena_t arena, mps_pool_class_t pool_class)
 
   printf("---- finalcv: pool class %s ----\n", ClassName(pool_class));
 
-  die(mps_fmt_create_A(&fmt, arena, dylan_fmt_A()), "fmt_create\n");
+  die(dylan_fmt(&fmt, arena), "fmt_create");
   die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
   MPS_ARGS_BEGIN(args) {
     MPS_ARGS_ADD(args, MPS_KEY_CHAIN, chain);

code/finaltest.c

@@ -239,7 +239,7 @@ static void test_pool(int mode, mps_arena_t arena, mps_chain_t chain,
   mps_pool_t pool;
   mps_root_t mps_root;
 
-  die(mps_fmt_create_A(&fmt, arena, dylan_fmt_A()), "fmt_create\n");
+  die(dylan_fmt(&fmt, arena), "fmt_create");
   MPS_ARGS_BEGIN(args) {
     MPS_ARGS_ADD(args, MPS_KEY_FORMAT, fmt);
     if (mode == ModePOLL) {

code/fmtdy.c

@@ -52,7 +52,6 @@
 
 
 #include "fmtdy.h"
-#include "fmtno.h"
 #include "mps.h"
 #include <assert.h>
 #include <string.h>
@@ -516,8 +515,7 @@ mps_res_t dylan_scan1(mps_ss_t mps_ss, mps_addr_t *object_io)
   return MPS_RES_OK;
 }
 
-static mps_res_t dylan_scan(mps_ss_t mps_ss,
-                            mps_addr_t base, mps_addr_t limit)
+mps_res_t dylan_scan(mps_ss_t mps_ss, mps_addr_t base, mps_addr_t limit)
 {
   mps_res_t res;
   mps_addr_t prev = base;
@@ -534,21 +532,6 @@ static mps_res_t dylan_scan(mps_ss_t mps_ss,
   return MPS_RES_OK;
 }
 
-/* dylan_class -- return pointer indicating class of object
- *
- * Return wrapper pointer, except for broken hearts or padding
- */
-
-static mps_addr_t dylan_class(mps_addr_t obj)
-{
-  mps_word_t first_word = ((mps_word_t *)obj)[0];
-
-  if((first_word & 3) != 0) /* broken heart or padding */
-    return NULL;
-  else
-    return (mps_addr_t)first_word;
-}
-
 mps_res_t dylan_scan1_weak(mps_ss_t mps_ss, mps_addr_t *object_io)
 {
   mps_addr_t *assoc;
@@ -695,20 +678,7 @@ mps_addr_t dylan_skip(mps_addr_t object)
   return (mps_addr_t)p;
 }
 
-static void dylan_copy(mps_addr_t old, mps_addr_t new)
-{
-  char *base = (char *)old;
-  char *limit = (char *)dylan_skip(old);
-  size_t length;
-  assert(base < limit);
-  length = (size_t)(limit - base);
-  assert(dylan_wrapper_check(*(mps_word_t **)old));
-  /* .improve.memcpy: Can do better here as we know that new and old
-     will be aligned (to MPS_PF_ALIGN) */
-  (void)memcpy(new, old, length);
-}
-
-static mps_addr_t dylan_isfwd(mps_addr_t object)
+mps_addr_t dylan_isfwd(mps_addr_t object)
 {
   mps_word_t h, tag;
 
@@ -720,7 +690,7 @@ static mps_addr_t dylan_isfwd(mps_addr_t object)
     return NULL;
 }
 
-static void dylan_fwd(mps_addr_t old, mps_addr_t new)
+void dylan_fwd(mps_addr_t old, mps_addr_t new)
 {
   mps_word_t *p;
   mps_addr_t limit;
@@ -761,101 +731,39 @@ mps_bool_t dylan_ispad(mps_addr_t addr)
 }
 
 
-/* The dylan format structures */
-
-static struct mps_fmt_A_s dylan_fmt_A_s =
-{
-  ALIGN,
-  dylan_scan,
-  dylan_skip,
-  dylan_copy,
-  dylan_fwd,
-  dylan_isfwd,
-  dylan_pad
-};
-
-static struct mps_fmt_B_s dylan_fmt_B_s =
-{
-  ALIGN,
-  dylan_scan,
-  dylan_skip,
-  dylan_copy,
-  dylan_fwd,
-  dylan_isfwd,
-  dylan_pad,
-  dylan_class
-};
-
-/* Functions returning the dylan format structures */
-
-mps_fmt_A_s *dylan_fmt_A(void)
-{
-  return &dylan_fmt_A_s;
-}
-
-mps_fmt_B_s *dylan_fmt_B(void)
-{
-  return &dylan_fmt_B_s;
-}
-
-/* Format variety-independent version that picks the right format
- * variety and creates it.  */
+/* Create Dylan object format.  */
 
 mps_res_t dylan_fmt(mps_fmt_t *mps_fmt_o, mps_arena_t arena)
 {
-  return mps_fmt_create_B(mps_fmt_o, arena, dylan_fmt_B());
-}
-
-/* The weak format structures */
-
-static struct mps_fmt_A_s dylan_fmt_A_weak_s =
-{
-  ALIGN,
-  dylan_scan_weak,
-  dylan_skip,
-  no_copy,
-  no_fwd,
-  no_isfwd,
-  no_pad
-};
-
-static struct mps_fmt_B_s dylan_fmt_B_weak_s =
-{
-  ALIGN,
-  dylan_scan_weak,
-  dylan_skip,
-  no_copy,
-  no_fwd,
-  no_isfwd,
-  no_pad,
-  dylan_class
-};
-
-/* Functions returning the weak format structures */
-
-mps_fmt_A_s *dylan_fmt_A_weak(void)
-{
-  return &dylan_fmt_A_weak_s;
-}
-
-
-mps_fmt_B_s *dylan_fmt_B_weak(void)
-{
-  return &dylan_fmt_B_weak_s;
+  mps_res_t res;
+  MPS_ARGS_BEGIN(args) {
+    MPS_ARGS_ADD(args, MPS_KEY_ALIGN, ALIGN);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_SCAN, dylan_scan);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_SKIP, dylan_skip);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_FWD, dylan_fwd);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_ISFWD, dylan_isfwd);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_PAD, dylan_pad);
+    res = mps_fmt_create_k(mps_fmt_o, arena, args);
+  } MPS_ARGS_END(args);
+  return res;
 }
 
 
-/* Format variety-independent version that picks the right format
- * variety and creates it.  */
+/* Create Dylan weak object format.  */
 
 mps_res_t dylan_fmt_weak(mps_fmt_t *mps_fmt_o, mps_arena_t arena)
 {
-  return mps_fmt_create_B(mps_fmt_o, arena, dylan_fmt_B_weak());
+  mps_res_t res;
+  MPS_ARGS_BEGIN(args) {
+    MPS_ARGS_ADD(args, MPS_KEY_ALIGN, ALIGN);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_SCAN, dylan_scan_weak);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_SKIP, dylan_skip);
+    res = mps_fmt_create_k(mps_fmt_o, arena, args);
+  } MPS_ARGS_END(args);
+  return res;
 }
 
 
-
-
 /* C. COPYRIGHT AND LICENSE
  *
  * Copyright (C) 2001-2020 Ravenbrook Limited <https://www.ravenbrook.com/>.

code/fmtdy.h

@@ -16,15 +16,15 @@ extern mps_res_t dylan_scan1_weak(mps_ss_t, mps_addr_t *);
 
 /* Format */
 extern mps_fmt_A_s *dylan_fmt_A(void);
-extern mps_fmt_A_s *dylan_fmt_A_weak(void);
-extern mps_fmt_B_s *dylan_fmt_B(void);
-extern mps_fmt_B_s *dylan_fmt_B_weak(void);
 extern mps_res_t dylan_fmt(mps_fmt_t *, mps_arena_t);
 extern mps_res_t dylan_fmt_weak(mps_fmt_t *, mps_arena_t);
 
 extern mps_addr_t dylan_weak_dependent(mps_addr_t);
 
+extern mps_res_t dylan_scan(mps_ss_t mps_ss, mps_addr_t base, mps_addr_t limit);
 extern mps_addr_t dylan_skip(mps_addr_t);
+extern void dylan_fwd(mps_addr_t old, mps_addr_t new);
+extern mps_addr_t dylan_isfwd(mps_addr_t object);
 extern void dylan_pad(mps_addr_t, size_t);
 extern mps_bool_t dylan_ispad(mps_addr_t);
 extern int dylan_wrapper_check(mps_word_t *);

code/fmthe.c

@@ -9,7 +9,6 @@
  */
 
 #include "fmtdy.h"
-#include "fmtno.h"
 #include "fmthe.h"
 #include "mps.h"
 
@@ -24,8 +23,6 @@
 
 #define AddHeader(p) ((mps_addr_t)((char*)(p) + headerSIZE))
 
-static mps_fmt_A_s *dylan_format;
-
 static mps_res_t dylan_header_scan(mps_ss_t mps_ss,
                                    mps_addr_t base, mps_addr_t limit)
 {
@@ -103,7 +100,7 @@ static mps_addr_t dylan_header_skip(mps_addr_t object)
       break;
   }
 
-  p = dylan_format->skip(object);
+  p = dylan_skip(object);
   p = AddHeader(p);
   return p;
 }
@@ -119,7 +116,7 @@ static mps_addr_t dylan_header_isfwd(mps_addr_t object)
 
   assert(header == realHeader);
 
-  return dylan_format->isfwd(object);
+  return dylan_isfwd(object);
 }
 
 
@@ -129,50 +126,41 @@ static void dylan_header_pad(mps_addr_t addr, size_t fullSize)
 }
 
 
-/* HeaderFormat -- format descriptor for this format */
-
-static struct mps_fmt_auto_header_s HeaderFormat =
-{
-  ALIGN,
-  dylan_header_scan,
-  dylan_header_skip,
-  NULL, /* later overwritten by dylan format forward method */
-  dylan_header_isfwd,
-  dylan_header_pad,
-  (size_t)headerSIZE
-};
-
-
-/* HeaderWeakFormat -- format descriptor for this format */
-
-static struct mps_fmt_auto_header_s HeaderWeakFormat =
-{
-  ALIGN,
-  dylan_header_scan_weak,
-  dylan_header_skip,
-  no_fwd,
-  no_isfwd,
-  no_pad,
-  (size_t)headerSIZE
-};
-
-
 /* EnsureHeaderFormat -- create a format object for this format */
 
 mps_res_t EnsureHeaderFormat(mps_fmt_t *mps_fmt_o, mps_arena_t arena)
 {
-    dylan_format = dylan_fmt_A();
-    HeaderFormat.fwd = dylan_format->fwd;
-    return mps_fmt_create_auto_header(mps_fmt_o, arena, &HeaderFormat);
+  mps_res_t res;
+  MPS_ARGS_BEGIN(args) {
+    MPS_ARGS_ADD(args, MPS_KEY_ALIGN, ALIGN);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_HEADER_SIZE, headerSIZE);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_SCAN, dylan_header_scan);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_SKIP, dylan_header_skip);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_FWD, dylan_fwd);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_ISFWD, dylan_header_isfwd);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_PAD, dylan_header_pad);
+    res = mps_fmt_create_k(mps_fmt_o, arena, args);
+  } MPS_ARGS_END(args);
+  return res;
 }
 
 
 /* EnsureHeaderWeakFormat -- create a format object for the weak format */
 
 mps_res_t EnsureHeaderWeakFormat(mps_fmt_t *mps_fmt_o, mps_arena_t arena)
 {
-    dylan_format = dylan_fmt_A();
-    return mps_fmt_create_auto_header(mps_fmt_o, arena, &HeaderWeakFormat);
+  mps_res_t res;
+  MPS_ARGS_BEGIN(args) {
+    MPS_ARGS_ADD(args, MPS_KEY_ALIGN, ALIGN);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_HEADER_SIZE, headerSIZE);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_SCAN, dylan_header_scan_weak);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_SKIP, dylan_header_skip);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_FWD, dylan_fwd);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_ISFWD, dylan_header_isfwd);
+    MPS_ARGS_ADD(args, MPS_KEY_FMT_PAD, dylan_header_pad);
+    res = mps_fmt_create_k(mps_fmt_o, arena, args);
+  } MPS_ARGS_END(args);
+  return res;
 }