X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fvalue.c;h=55a1e55e859952118fa45965d0d376aa85e625d5;hb=refs%2Fheads%2Fctables7;hp=6dbecb11abfca8137bc8fdc763ffc1c0a8568bc2;hpb=8f04b0ced35a66cfdebefbcb53c81979add36ca3;p=pspp

diff --git a/src/data/value.c b/src/data/value.c
index 6dbecb11ab..55a1e55e85 100644
--- a/src/data/value.c
+++ b/src/data/value.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 1997-9, 2000, 2009 Free Software Foundation, Inc.
+   Copyright (C) 1997-9, 2000, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -15,17 +15,18 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
 
 #include <config.h>
-#include <data/value.h>
 
-#include <data/val-type.h>
-#include <data/variable.h>
-#include <libpspp/hash.h>
-#include <libpspp/pool.h>
-#include <libpspp/str.h>
-#include <gl/unistr.h>
+#include "data/value.h"
 
-#include "minmax.h"
-#include "xalloc.h"
+#include "data/val-type.h"
+#include "data/variable.h"
+#include "libpspp/hash-functions.h"
+#include "libpspp/pool.h"
+#include "libpspp/str.h"
+#include "gl/unistr.h"
+
+#include "gl/minmax.h"
+#include "gl/xalloc.h"
 
 /* Copies the contents of string value SRC with width SRC_WIDTH
    to string value DST with width DST_WIDTH.  If SRC_WIDTH is
@@ -45,9 +46,7 @@ value_copy_rpad (union value *dst, int dst_width,
                  const union value *src, int src_width,
                  char pad)
 {
-  u8_buf_copy_rpad (value_str_rw (dst, dst_width), dst_width,
-                 value_str (src, src_width), src_width,
-                 pad);
+  u8_buf_copy_rpad (dst->s, dst_width, src->s, src_width, pad);
 }
 
 /* Copies the contents of null-terminated string SRC to string
@@ -84,7 +83,7 @@ void
 value_copy_buf_rpad (union value *dst, int dst_width,
                      const uint8_t *src, size_t src_len, char pad)
 {
-  u8_buf_copy_rpad (value_str_rw (dst, dst_width), dst_width, src, src_len, pad);
+  u8_buf_copy_rpad (dst->s, dst_width, src, src_len, pad);
 }
 
 /* Sets V to the system-missing value for data of the given
@@ -97,7 +96,7 @@ value_set_missing (union value *v, int width)
       if (width == 0)
         v->f = SYSMIS;
       else
-        memset (value_str_rw (v, width), ' ', width);
+        memset (v->s, ' ', width);
     }
 }
 
@@ -108,7 +107,7 @@ value_compare_3way (const union value *a, const union value *b, int width)
 {
   return (width == -1 ? 0
           : width == 0 ? (a->f < b->f ? -1 : a->f > b->f)
-          : memcmp (value_str (a, width), value_str (b, width), width));
+          : memcmp (a->s, b->s, width));
 }
 
 /* Returns true if A and B, which must both have the given WIDTH,
@@ -118,7 +117,7 @@ value_equal (const union value *a, const union value *b, int width)
 {
   return (width == -1 ? true
           : width == 0 ? a->f == b->f
-          : !memcmp (value_str (a, width), value_str (b, width), width));
+          : !memcmp (a->s, b->s, width));
 }
 
 /* Returns a hash of the data in VALUE, which must have the given
@@ -128,7 +127,7 @@ value_hash (const union value *value, int width, unsigned int basis)
 {
   return (width == -1 ? basis
           : width == 0 ? hash_double (value->f, basis)
-          : hash_bytes (value_str (value, width), width, basis));
+          : hash_bytes (value->s, width, basis));
 }
 
 /* Tests whether VALUE may be resized from OLD_WIDTH to
@@ -146,7 +145,7 @@ value_is_resizable (const union value *value, int old_width, int new_width)
     return false;
   else
     {
-      const uint8_t *str = value_str (value, old_width);
+      const uint8_t *str = value->s;
       int i;
 
       for (i = new_width; i < old_width; i++)
@@ -162,7 +161,7 @@ void
 value_resize (union value *value, int old_width, int new_width)
 {
   assert (value_is_resizable (value, old_width, new_width));
-  if (new_width != old_width)
+  if (new_width != old_width && new_width > 0)
     {
       union value tmp;
       value_init (&tmp, new_width);
@@ -172,6 +171,20 @@ value_resize (union value *value, int old_width, int new_width)
     }
 }
 
+/* Returns true if VALUE, with the given WIDTH, is all spaces, false otherwise.
+   Returns false if VALUE is numeric. */
+bool
+value_is_spaces (const union value *value, int width)
+{
+  int i;
+
+  for (i = 0; i < width; i++)
+    if (value->s[i] != ' ')
+      return false;
+
+  return true;
+}
+
 /* Returns true if resizing a value from OLD_WIDTH to NEW_WIDTH
    actually changes anything, false otherwise.  If false is
    returned, calls to value_resize() with the specified
@@ -185,16 +198,7 @@ value_needs_resize (int old_width, int new_width)
 {
   assert (val_type_from_width (old_width) == val_type_from_width (new_width));
 
-  /* We need to call value_resize if either the new width is
-     longer than the old width (in which case the new characters
-     must be set to spaces) or if either width is a long string.
-     (We could omit resizing if both the old and new widths were
-     long and the new width was shorter, but we choose to do so
-     anyway in hopes of saving memory.) */
-  return (old_width != new_width
-           && (new_width > old_width
-               || old_width > MAX_SHORT_STRING
-               || new_width > MAX_SHORT_STRING));
+  return old_width != new_width;
 }
 
 /* Same as value_init, except that memory for VALUE (if
@@ -207,8 +211,24 @@ value_needs_resize (int old_width, int new_width)
 void
 value_init_pool (struct pool *pool, union value *value, int width)
 {
-  if (width > MAX_SHORT_STRING)
-    value->long_string = pool_alloc_unaligned (pool, width);
+  if (width > 0)
+    value->s = pool_alloc_unaligned (pool, width);
+}
+
+/* Same as value_clone(), except that memory for VALUE (if necessary) is
+   allocated from POOL and will be freed automatically when POOL is destroyed.
+
+   VALUE must not be freed manually by calling value_destroy().  If it needs to
+   be resized, it must be done using value_resize_pool() instead of
+   value_resize(). */
+void
+value_clone_pool (struct pool *pool,
+                  union value *value, const union value *src, int width)
+{
+  if (width > 0)
+    value->s = pool_clone_unaligned (pool, src->s, width);
+  else
+    value->f = src->f;
 }
 
 /* Same as value_resize, except that VALUE must have been
@@ -224,13 +244,10 @@ value_resize_pool (struct pool *pool, union value *value,
   assert (value_is_resizable (value, old_width, new_width));
   if (new_width > old_width)
     {
-      if (new_width > MAX_SHORT_STRING)
-        {
-          uint8_t *new_long_string = pool_alloc_unaligned (pool, new_width);
-          memcpy (new_long_string, value_str (value, old_width), old_width);
-          value->long_string = new_long_string;
-        }
-      memset (value_str_rw (value, new_width) + old_width, ' ',
-              new_width - old_width);
+      uint8_t *new_string = pool_alloc_unaligned (pool, new_width);
+      memcpy (new_string, value->s, old_width);
+      value->s = new_string;
+
+      memset (value->s + old_width, ' ', new_width - old_width);
     }
 }