X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fcase.c;h=9c42107de226dc76bc5c21e6f149ee35892f6db4;hb=65e61cc92b48297625bc71cf31b8a19e301eb6c1;hp=6fad874d0c71482086c0387c1cf390e4f75708d0;hpb=dcf9b154cbcaa35c3d8459a201b77eec8bcb30bd;p=pspp

diff --git a/src/data/case.c b/src/data/case.c
index 6fad874d0c..9c42107de2 100644
--- a/src/data/case.c
+++ b/src/data/case.c
@@ -22,11 +22,11 @@
 #include <limits.h>
 #include <stdlib.h>
 #include "value.h"
-#include "alloc.h"
-#include "str.h"
+#include <libpspp/alloc.h>
+#include <libpspp/str.h>
 #include "variable.h"
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 #undef NDEBUG
 #else
 #ifndef NDEBUG
@@ -45,9 +45,6 @@ case_unshare (struct ccase *c)
 {
   struct case_data *cd;
   
-  assert (c != NULL);
-  assert (c->this == c);
-  assert (c->case_data != NULL);
   assert (c->case_data->ref_cnt > 1);
 
   cd = c->case_data;
@@ -66,24 +63,23 @@ case_size (size_t value_cnt)
           + value_cnt * sizeof (union value));
 }
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 /* Initializes C as a null case. */
 void
 case_nullify (struct ccase *c) 
 {
   c->case_data = NULL;
-  c->this = c;
 }
-#endif /* GLOBAL_DEBUGGING */
+#endif /* DEBUGGING */
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 /* Returns true iff C is a null case. */
 int
 case_is_null (const struct ccase *c) 
 {
   return c->case_data == NULL;
 }
-#endif /* GLOBAL_DEBUGGING */
+#endif /* DEBUGGING */
 
 /* Initializes C as a new case that can store VALUE_CNT values.
    The values have indeterminate contents until explicitly
@@ -95,45 +91,36 @@ case_create (struct ccase *c, size_t value_cnt)
     xalloc_die ();
 }
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 /* Initializes CLONE as a copy of ORIG. */
 void
 case_clone (struct ccase *clone, const struct ccase *orig)
 {
-  assert (orig != NULL);
-  assert (orig->this == orig);
-  assert (orig->case_data != NULL);
   assert (orig->case_data->ref_cnt > 0);
-  assert (clone != NULL);
 
   if (clone != orig) 
-    {
-      *clone = *orig;
-      clone->this = clone;
-    }
+    *clone = *orig;
   orig->case_data->ref_cnt++;
 }
-#endif /* GLOBAL_DEBUGGING */
+#endif /* DEBUGGING */
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 /* Replaces DST by SRC and nullifies SRC.
    DST and SRC must be initialized cases at entry. */
 void
 case_move (struct ccase *dst, struct ccase *src) 
 {
-  assert (src != NULL);
-  assert (src->this == src);
-  assert (src->case_data != NULL);
   assert (src->case_data->ref_cnt > 0);
-  assert (dst != NULL);
-
-  *dst = *src;
-  dst->this = dst;
-  case_nullify (src);
+  
+  if (dst != src) 
+    {
+      *dst = *src;
+      case_nullify (src); 
+    }
 }
-#endif /* GLOBAL_DEBUGGING */
+#endif /* DEBUGGING */
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 /* Destroys case C. */
 void
 case_destroy (struct ccase *c) 
@@ -141,7 +128,6 @@ case_destroy (struct ccase *c)
   struct case_data *cd;
   
   assert (c != NULL);
-  assert (c->this == c);
 
   cd = c->case_data;
   if (cd != NULL && --cd->ref_cnt == 0) 
@@ -151,7 +137,7 @@ case_destroy (struct ccase *c)
       free (cd); 
     }
 }
-#endif /* GLOBAL_DEBUGGING */
+#endif /* DEBUGGING */
 
 /* Resizes case C from OLD_CNT to NEW_CNT values. */
 void
@@ -175,41 +161,33 @@ case_swap (struct ccase *a, struct ccase *b)
 }
 
 /* Attempts to create C as a new case that holds VALUE_CNT
-   values.  Returns nonzero if successful, zero if memory
+   values.  Returns true if successful, false if memory
    allocation failed. */
-int
+bool
 case_try_create (struct ccase *c, size_t value_cnt) 
 {
   c->case_data = malloc (case_size (value_cnt));
   if (c->case_data != NULL) 
     {
-#ifdef GLOBAL_DEBUGGING
-      c->this = c;
-#endif
       c->case_data->value_cnt = value_cnt;
       c->case_data->ref_cnt = 1;
-      return 1;
-    }
-  else 
-    {
-#ifdef GLOBAL_DEBUGGING
-      c->this = c;
-#endif
-      return 0;
+      return true;
     }
+  
+  return false;
 }
 
 /* Tries to initialize CLONE as a copy of ORIG.
-   Returns nonzero if successful, zero if memory allocation
+   Returns true if successful, false if memory allocation
    failed. */
-int
+bool
 case_try_clone (struct ccase *clone, const struct ccase *orig) 
 {
   case_clone (clone, orig);
-  return 1;
+  return true;
 }
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 /* Copies VALUE_CNT values from SRC (starting at SRC_IDX) to DST
    (starting at DST_IDX). */
 void
@@ -217,28 +195,24 @@ case_copy (struct ccase *dst, size_t dst_idx,
            const struct ccase *src, size_t src_idx,
            size_t value_cnt)
 {
-  assert (dst != NULL);
-  assert (dst->this == dst);
-  assert (dst->case_data != NULL);
   assert (dst->case_data->ref_cnt > 0);
   assert (dst_idx + value_cnt <= dst->case_data->value_cnt);
 
-  assert (src != NULL);
-  assert (src->this == src);
-  assert (src->case_data != NULL);
   assert (src->case_data->ref_cnt > 0);
-  assert (src_idx + value_cnt <= dst->case_data->value_cnt);
+  assert (src_idx + value_cnt <= src->case_data->value_cnt);
 
-  if (dst->case_data->ref_cnt > 1)
-    case_unshare (dst);
   if (dst->case_data != src->case_data || dst_idx != src_idx) 
-    memmove (dst->case_data->values + dst_idx,
-             src->case_data->values + src_idx,
-             sizeof *dst->case_data->values * value_cnt); 
+    {
+      if (dst->case_data->ref_cnt > 1)
+        case_unshare (dst);
+      memmove (dst->case_data->values + dst_idx,
+               src->case_data->values + src_idx,
+               sizeof *dst->case_data->values * value_cnt); 
+    }
 }
-#endif /* GLOBAL_DEBUGGING */
+#endif /* DEBUGGING */
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 /* Copies case C to OUTPUT.
    OUTPUT_SIZE is the number of `union values' in OUTPUT,
    which must match the number of `union values' in C. */
@@ -246,9 +220,6 @@ void
 case_to_values (const struct ccase *c, union value *output,
                 size_t output_size UNUSED) 
 {
-  assert (c != NULL);
-  assert (c->this == c);
-  assert (c->case_data != NULL);
   assert (c->case_data->ref_cnt > 0);
   assert (output_size == c->case_data->value_cnt);
   assert (output != NULL || output_size == 0);
@@ -256,9 +227,9 @@ case_to_values (const struct ccase *c, union value *output,
   memcpy (output, c->case_data->values,
           c->case_data->value_cnt * sizeof *output);
 }
-#endif /* GLOBAL_DEBUGGING */
+#endif /* DEBUGGING */
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 /* Copies INPUT into case C.
    INPUT_SIZE is the number of `union values' in INPUT,
    which must match the number of `union values' in C. */
@@ -267,7 +238,6 @@ case_from_values (struct ccase *c, const union value *input,
                   size_t input_size UNUSED) 
 {
   assert (c != NULL);
-  assert (c->this == c);
   assert (c->case_data != NULL);
   assert (c->case_data->ref_cnt > 0);
   assert (input_size == c->case_data->value_cnt);
@@ -278,9 +248,9 @@ case_from_values (struct ccase *c, const union value *input,
   memcpy (c->case_data->values, input,
           c->case_data->value_cnt * sizeof *input);
 }
-#endif /* GLOBAL_DEBUGGING */
+#endif /* DEBUGGING */
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 /* Returns a pointer to the `union value' used for the
    element of C numbered IDX.
    The caller must not modify the returned data. */
@@ -288,32 +258,30 @@ const union value *
 case_data (const struct ccase *c, size_t idx) 
 {
   assert (c != NULL);
-  assert (c->this == c);
   assert (c->case_data != NULL);
   assert (c->case_data->ref_cnt > 0);
   assert (idx < c->case_data->value_cnt);
 
   return &c->case_data->values[idx];
 }
-#endif /* GLOBAL_DEBUGGING */
+#endif /* DEBUGGING */
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 /* Returns the numeric value of the `union value' in C numbered
    IDX. */
 double
 case_num (const struct ccase *c, size_t idx) 
 {
   assert (c != NULL);
-  assert (c->this == c);
   assert (c->case_data != NULL);
   assert (c->case_data->ref_cnt > 0);
   assert (idx < c->case_data->value_cnt);
 
   return c->case_data->values[idx].f;
 }
-#endif /* GLOBAL_DEBUGGING */
+#endif /* DEBUGGING */
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 /* Returns the string value of the `union value' in C numbered
    IDX.
    (Note that the value is not null-terminated.)
@@ -322,16 +290,15 @@ const char *
 case_str (const struct ccase *c, size_t idx) 
 {
   assert (c != NULL);
-  assert (c->this == c);
   assert (c->case_data != NULL);
   assert (c->case_data->ref_cnt > 0);
   assert (idx < c->case_data->value_cnt);
 
   return c->case_data->values[idx].s;
 }
-#endif /* GLOBAL_DEBUGGING */
+#endif /* DEBUGGING */
 
-#ifdef GLOBAL_DEBUGGING
+#ifdef DEBUGGING
 /* Returns a pointer to the `union value' used for the
    element of C numbered IDX.
    The caller is allowed to modify the returned data. */
@@ -339,7 +306,6 @@ union value *
 case_data_rw (struct ccase *c, size_t idx) 
 {
   assert (c != NULL);
-  assert (c->this == c);
   assert (c->case_data != NULL);
   assert (c->case_data->ref_cnt > 0);
   assert (idx < c->case_data->value_cnt);
@@ -348,7 +314,7 @@ case_data_rw (struct ccase *c, size_t idx)
     case_unshare (c);
   return &c->case_data->values[idx];
 }
-#endif /* GLOBAL_DEBUGGING */
+#endif /* DEBUGGING */
 
 /* Compares the values of the VAR_CNT variables in VP
    in cases A and B and returns a strcmp()-type result. */
@@ -405,7 +371,6 @@ const union value *
 case_data_all (const struct ccase *c) 
 {
   assert (c != NULL);
-  assert (c->this == c);
   assert (c->case_data != NULL);
   assert (c->case_data->ref_cnt > 0);
 
@@ -421,7 +386,6 @@ union value *
 case_data_all_rw (struct ccase *c) 
 {
   assert (c != NULL);
-  assert (c->this == c);
   assert (c->case_data != NULL);
   assert (c->case_data->ref_cnt > 0);