X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fautorecode.c;h=a4d34ccf608e7c784334d6a23546da546df1f095;hb=2be9bee9da6a2ce27715e58128569594319abfa2;hp=de9416821c15bf5fa8c37d5e9a241d7a647fd804;hpb=9a331fe64eb814ae5c1322e21717a04fb254bf65;p=pspp-builds.git

diff --git a/src/language/stats/autorecode.c b/src/language/stats/autorecode.c
index de941682..a4d34ccf 100644
--- a/src/language/stats/autorecode.c
+++ b/src/language/stats/autorecode.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 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,41 +15,42 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
 
 #include <config.h>
+
 #include <stdlib.h>
 
-#include <data/case.h>
-#include <data/casereader.h>
-#include <data/dictionary.h>
-#include <data/procedure.h>
-#include <data/transformations.h>
-#include <data/variable.h>
-#include <language/command.h>
-#include <language/lexer/lexer.h>
-#include <language/lexer/variable-parser.h>
-#include <libpspp/compiler.h>
-#include <libpspp/hash.h>
-#include <libpspp/message.h>
-#include <libpspp/pool.h>
-#include <libpspp/str.h>
-
-#include "xalloc.h"
+#include "data/case.h"
+#include "data/casereader.h"
+#include "data/dataset.h"
+#include "data/dictionary.h"
+#include "data/transformations.h"
+#include "data/variable.h"
+#include "language/command.h"
+#include "language/lexer/lexer.h"
+#include "language/lexer/variable-parser.h"
+#include "libpspp/array.h"
+#include "libpspp/compiler.h"
+#include "libpspp/hash-functions.h"
+#include "libpspp/hmap.h"
+#include "libpspp/i18n.h"
+#include "libpspp/message.h"
+#include "libpspp/pool.h"
+#include "libpspp/str.h"
+
+#include "gl/xalloc.h"
+#include "gl/vasnprintf.h"
 
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
 
 /* FIXME: Implement PRINT subcommand. */
 
-/* An AUTORECODE variable's original value. */
-union arc_value
-  {
-    double f;                   /* Numeric. */
-    char *c;                    /* Short or long string. */
-  };
-
-/* Explains how to recode one value.  `from' must be first element.  */
+/* Explains how to recode one value. */
 struct arc_item
   {
-    union arc_value from;	/* Original value. */
+    struct hmap_node hmap_node; /* Element in "struct arc_spec" hash table. */
+    union value from;           /* Original value. */
+    int width;                  /* Width of the original value */
+
     double to;			/* Recoded value. */
   };
 
@@ -57,20 +58,12 @@ struct arc_item
 struct arc_spec
   {
     const struct variable *src;	/* Source variable. */
-    struct variable *dest;	/* Target variable. */
-    struct hsh_table *items;	/* Hash table of `freq's. */
-  };
-
-/* AUTORECODE transformation. */
-struct autorecode_trns
-  {
-    struct pool *pool;		/* Contains AUTORECODE specs. */
-    struct arc_spec *specs;	/* AUTORECODE specifications. */
-    size_t spec_cnt;		/* Number of specifications. */
+    struct variable *dst;	/* Target variable. */
+    struct hmap *items;         /* Hash table of "struct arc_item"s. */
   };
 
 /* Descending or ascending sort order. */
-enum direction
+enum arc_direction
   {
     ASCENDING,
     DESCENDING
@@ -78,299 +71,323 @@ enum direction
 
 /* AUTORECODE data. */
 struct autorecode_pgm
-  {
-    const struct variable **src_vars;    /* Source variables. */
-    char **dst_names;              /* Target variable names. */
-    struct variable **dst_vars;    /* Target variables. */
-    struct hsh_table **src_values; /* `union arc_value's of source vars. */
-    size_t var_cnt;                /* Number of variables. */
-    struct pool *src_values_pool;  /* Pool used by src_values. */
-    enum direction direction;      /* Sort order. */
-    int print;                     /* Print mapping table if nonzero. */
-  };
+{
+  struct arc_spec *specs;
+  size_t n_specs;
+
+  /* Hash table of "struct arc_item"s. */
+  struct hmap *global_items;
+};
 
 static trns_proc_func autorecode_trns_proc;
 static trns_free_func autorecode_trns_free;
-static hsh_compare_func compare_alpha_value, compare_numeric_value;
-static hsh_hash_func hash_alpha_value, hash_numeric_value;
 
-static void recode (struct dataset *, const struct autorecode_pgm *);
+static int compare_arc_items (const void *, const void *, const void *aux);
 static void arc_free (struct autorecode_pgm *);
+static struct arc_item *find_arc_item (const struct arc_spec *, const union value *,
+                                       size_t hash);
 
 /* Performs the AUTORECODE procedure. */
 int
 cmd_autorecode (struct lexer *lexer, struct dataset *ds)
 {
-  struct autorecode_pgm arc;
+  struct autorecode_pgm *arc = NULL;
+  struct dictionary *dict = dataset_dict (ds);
+
+  const struct variable **src_vars = NULL;
+  char **dst_names = NULL;
+  size_t n_srcs = 0;
+  size_t n_dsts = 0;
+
+  enum arc_direction direction = ASCENDING;
+  bool print = true;
+
   struct casereader *input;
   struct ccase *c;
-  size_t dst_cnt;
+
   size_t i;
   bool ok;
 
-  arc.src_vars = NULL;
-  arc.dst_names = NULL;
-  arc.dst_vars = NULL;
-  arc.src_values = NULL;
-  arc.var_cnt = 0;
-  arc.src_values_pool = NULL;
-  arc.direction = ASCENDING;
-  arc.print = 0;
-  dst_cnt = 0;
+  /* Create procedure. */
+  arc = xzalloc (sizeof *arc);
 
+  /* Parse variable lists. */
   lex_match_id (lexer, "VARIABLES");
-  lex_match (lexer, '=');
-  if (!parse_variables_const (lexer, dataset_dict (ds), &arc.src_vars,
-			      &arc.var_cnt,
-                        PV_NO_DUPLICATE))
-    goto lossage;
+  lex_match (lexer, T_EQUALS);
+  if (!parse_variables_const (lexer, dict, &src_vars, &n_srcs,
+                              PV_NO_DUPLICATE))
+    goto error;
   if (!lex_force_match_id (lexer, "INTO"))
-    goto lossage;
-  lex_match (lexer, '=');
-  if (!parse_DATA_LIST_vars (lexer, &arc.dst_names, &dst_cnt, PV_NONE))
-    goto lossage;
-  if (dst_cnt != arc.var_cnt)
+    goto error;
+  lex_match (lexer, T_EQUALS);
+  if (!parse_DATA_LIST_vars (lexer, dict, &dst_names, &n_dsts,
+                             PV_NO_DUPLICATE))
+    goto error;
+  if (n_dsts != n_srcs)
     {
-      size_t i;
-
       msg (SE, _("Source variable count (%zu) does not match "
                  "target variable count (%zu)."),
-           arc.var_cnt, dst_cnt);
+           n_srcs, n_dsts);
 
-      for (i = 0; i < dst_cnt; i++)
-        free (arc.dst_names[i]);
-      free (arc.dst_names);
-      arc.dst_names = NULL;
+      goto error;
+    }
+  for (i = 0; i < n_dsts; i++)
+    {
+      const char *name = dst_names[i];
+
+      if (dict_lookup_var (dict, name) != NULL)
+        {
+          msg (SE, _("Target variable %s duplicates existing variable %s."),
+               name, name);
+          goto error;
+        }
+    }
 
-      goto lossage;
+  /* Parse options. */
+  while (lex_match (lexer, T_SLASH))
+    {
+      if (lex_match_id (lexer, "DESCENDING"))
+	direction = DESCENDING;
+      else if (lex_match_id (lexer, "PRINT"))
+	print = true;
+      else if (lex_match_id (lexer, "GROUP"))
+	{
+	  arc->global_items = xmalloc (sizeof (*arc->global_items));
+	  hmap_init (arc->global_items);
+	}
     }
-  while (lex_match (lexer, '/'))
-    if (lex_match_id (lexer, "DESCENDING"))
-      arc.direction = DESCENDING;
-    else if (lex_match_id (lexer, "PRINT"))
-      arc.print = 1;
-  if (lex_token (lexer) != '.')
+
+  if (lex_token (lexer) != T_ENDCMD)
     {
       lex_error (lexer, _("expecting end of command"));
-      goto lossage;
+      goto error;
     }
 
-  for (i = 0; i < arc.var_cnt; i++)
+  arc->specs = xmalloc (n_dsts * sizeof *arc->specs);
+  arc->n_specs = n_dsts;
+
+  for (i = 0; i < n_dsts; i++)
     {
-      int j;
+      struct arc_spec *spec = &arc->specs[i];
 
-      if (dict_lookup_var (dataset_dict (ds), arc.dst_names[i]) != NULL)
+      spec->src = src_vars[i];
+      if (arc->global_items)
 	{
-	  msg (SE, _("Target variable %s duplicates existing variable %s."),
-	       arc.dst_names[i], arc.dst_names[i]);
-	  goto lossage;
+	  spec->items = arc->global_items;
+	}
+      else
+	{
+	  spec->items = xmalloc (sizeof (*spec->items));
+	  hmap_init (spec->items);
 	}
-      for (j = 0; j < i; j++)
-	if (!strcasecmp (arc.dst_names[i], arc.dst_names[j]))
-	  {
-	    msg (SE, _("Duplicate variable name %s among target variables."),
-		 arc.dst_names[i]);
-	    goto lossage;
-	  }
     }
 
-  arc.src_values_pool = pool_create ();
-  arc.dst_vars = xnmalloc (arc.var_cnt, sizeof *arc.dst_vars);
-  arc.src_values = xnmalloc (arc.var_cnt, sizeof *arc.src_values);
-  for (i = 0; i < dst_cnt; i++)
-    {
-	/* FIXME: consolodate this hsh_create */
-    if (var_is_alpha (arc.src_vars[i]))
-      arc.src_values[i] = hsh_create (10, compare_alpha_value,
-                                      hash_alpha_value, NULL, arc.src_vars[i]);
-    else
-      arc.src_values[i] = hsh_create (10, compare_numeric_value,
-                                      hash_numeric_value, NULL, NULL);
-   }
 
+  /* Execute procedure. */
   input = proc_open (ds);
   for (; (c = casereader_read (input)) != NULL; case_unref (c))
-    for (i = 0; i < arc.var_cnt; i++)
+    for (i = 0; i < arc->n_specs; i++)
       {
-        union arc_value v, *vp, **vpp;
-
-        if (var_is_numeric (arc.src_vars[i]))
-          v.f = case_num (c, arc.src_vars[i]);
-        else
-          v.c = (char *) case_str (c, arc.src_vars[i]);
-
-        vpp = (union arc_value **) hsh_probe (arc.src_values[i], &v);
-        if (*vpp == NULL)
+        struct arc_spec *spec = &arc->specs[i];
+        int width = var_get_width (spec->src);
+        const union value *value = case_data (c, spec->src);
+        size_t hash = value_hash (value, width, 0);
+        struct arc_item *item;
+
+        item = find_arc_item (spec, value, hash);
+        if (item == NULL)
           {
-            vp = pool_alloc (arc.src_values_pool, sizeof *vp);
-            if (var_is_numeric (arc.src_vars[i]))
-              vp->f = v.f;
-            else
-              vp->c = pool_clone (arc.src_values_pool,
-                                  v.c, var_get_width (arc.src_vars[i]));
-            *vpp = vp;
+            item = xmalloc (sizeof *item);
+	    item->width = width;
+            value_clone (&item->from, value, width);
+            hmap_insert (spec->items, &item->hmap_node, hash);
           }
       }
   ok = casereader_destroy (input);
   ok = proc_commit (ds) && ok;
 
-  for (i = 0; i < arc.var_cnt; i++)
-    arc.dst_vars[i] = dict_create_var_assert (dataset_dict (ds),
-                                              arc.dst_names[i], 0);
+  /* Create transformation. */
+  for (i = 0; i < arc->n_specs; i++)
+    {
+      struct arc_spec *spec = &arc->specs[i];
+      struct arc_item **items;
+      struct arc_item *item;
+      size_t n_items;
+      size_t j;
+
+      /* Create destination variable. */
+      spec->dst = dict_create_var_assert (dict, dst_names[i], 0);
+
+      /* Create array of pointers to items. */
+      n_items = hmap_count (spec->items);
+      items = xmalloc (n_items * sizeof *items);
+      j = 0;
+      HMAP_FOR_EACH (item, struct arc_item, hmap_node, spec->items)
+        items[j++] = item;
+
+      assert (j == n_items);
+
+      /* Sort array by value. */
+      sort (items, n_items, sizeof *items, compare_arc_items, NULL);
+
+      /* Assign recoded values in sorted order. */
+      for (j = 0; j < n_items; j++)
+	{
+	  const union value *from = &items[j]->from;
+	  size_t len;
+	  char *recoded_value  = NULL;
+	  char *c;
+	  const int src_width = items[j]->width;
+	  union value to_val;
+	  value_init (&to_val, 0);
+
+	  items[j]->to = direction == ASCENDING ? j + 1 : n_items - j;
+	  
+	  to_val.f = items[j]->to;
+
+	  /* Add value labels to the destination variable which indicate
+	     the source value from whence the new value comes. */
+	  if (src_width > 0)
+	    {
+	      const char *str = CHAR_CAST_BUG (const char*, value_str (from, src_width));
+
+	      recoded_value = recode_string (UTF8, dict_get_encoding (dict), str, src_width);
+	    }
+	  else
+	    recoded_value = asnprintf (NULL, &len, "%g", from->f);
+	  
+	  /* Remove trailing whitespace */
+	  for (c = recoded_value; *c != '\0'; c++)
+	    if ( *c == ' ')
+	      {
+		*c = '\0';
+		break;
+	      }
+
+	  var_add_value_label (spec->dst, &to_val, recoded_value);
+	  value_destroy (&to_val, 0);
+	  free (recoded_value);
+	}
+
+      /* Free array. */
+      free (items);
+    }
+  add_transformation (ds, autorecode_trns_proc, autorecode_trns_free, arc);
 
-  recode (ds, &arc);
-  arc_free (&arc);
   return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
 
-lossage:
-  arc_free (&arc);
+error:
+  for (i = 0; i < n_dsts; i++)
+    free (dst_names[i]);
+  free (dst_names);
+  free (src_vars);
+  arc_free (arc);
   return CMD_CASCADING_FAILURE;
 }
 
 static void
 arc_free (struct autorecode_pgm *arc)
 {
-  free (arc->src_vars);
-  if (arc->dst_names != NULL)
+  if (arc != NULL)
     {
       size_t i;
 
-      for (i = 0; i < arc->var_cnt; i++)
-        free (arc->dst_names[i]);
-      free (arc->dst_names);
-    }
-  free (arc->dst_vars);
-  if (arc->src_values != NULL)
-    {
-      size_t i;
+      for (i = 0; i < arc->n_specs; i++)
+        {
+          struct arc_spec *spec = &arc->specs[i];
+          struct arc_item *item, *next;
+
+	  HMAP_FOR_EACH_SAFE (item, next, struct arc_item, hmap_node,
+			      spec->items)
+	    {
+	      value_destroy (&item->from, item->width);
+	      hmap_delete (spec->items, &item->hmap_node);
+	      free (item);
+	    }
+        }
+
+      if (arc->global_items)
+	{
+	  free (arc->global_items);
+	}
+      else
+	{
+	  for (i = 0; i < arc->n_specs; i++)
+	    {
+	      struct arc_spec *spec = &arc->specs[i];
+	      if (spec->items)
+		{
+		  hmap_destroy (spec->items);
+		  free (spec->items);
+		}
+	    }
+	}
 
-      for (i = 0; i < arc->var_cnt; i++)
-        hsh_destroy (arc->src_values[i]);
-      free (arc->src_values);
+      free (arc->specs);
+      free (arc);
     }
-  pool_destroy (arc->src_values_pool);
 }
 
-
-/* AUTORECODE transformation. */
+static struct arc_item *
+find_arc_item (const struct arc_spec *spec, const union value *value,
+               size_t hash)
+{
+  struct arc_item *item;
 
-static void
-recode (struct dataset *ds, const struct autorecode_pgm *arc)
+  HMAP_FOR_EACH_WITH_HASH (item, struct arc_item, hmap_node, hash, spec->items)
+    if (value_equal (value, &item->from, var_get_width (spec->src)))
+      return item;
+  return NULL;
+}
+
+static int
+compare_arc_items (const void *a_, const void *b_, const void *aux UNUSED)
 {
-  struct autorecode_trns *trns;
-  size_t i;
+  const struct arc_item *const *a = a_;
+  const struct arc_item *const *b = b_;
+  int width_a = (*a)->width;
+  int width_b = (*b)->width;
 
-  trns = pool_create_container (struct autorecode_trns, pool);
-  trns->specs = pool_nalloc (trns->pool, arc->var_cnt, sizeof *trns->specs);
-  trns->spec_cnt = arc->var_cnt;
-  for (i = 0; i < arc->var_cnt; i++)
-    {
-      struct arc_spec *spec = &trns->specs[i];
-      void *const *p = hsh_sort (arc->src_values[i]);
-      int count = hsh_count (arc->src_values[i]);
-      int j;
+  if ( width_a == width_b)
+    return value_compare_3way (&(*a)->from, &(*b)->from, width_a);
 
-      spec->src = arc->src_vars[i];
-      spec->dest = arc->dst_vars[i];
+  if ( width_a == 0 && width_b != 0)
+    return -1;
 
-      if (var_is_alpha (arc->src_vars[i]))
-	spec->items = hsh_create (2 * count, compare_alpha_value,
-				  hash_alpha_value, NULL, arc->src_vars[i]);
-      else
-	spec->items = hsh_create (2 * count, compare_numeric_value,
-				  hash_numeric_value, NULL, NULL);
+  if ( width_b == 0 && width_a != 0)
+    return +1;
 
-      for (j = 0; *p; p++, j++)
-	{
-	  struct arc_item *item = pool_alloc (trns->pool, sizeof *item);
-          union arc_value *vp = *p;
-
-	  if (var_is_numeric (arc->src_vars[i]))
-            item->from.f = vp->f;
-          else
-	    item->from.c = pool_clone (trns->pool, vp->c,
-                                       var_get_width (arc->src_vars[i]));
-	  item->to = arc->direction == ASCENDING ? j + 1 : count - j;
-	  hsh_force_insert (spec->items, item);
-	}
-    }
-  add_transformation (ds,
-		      autorecode_trns_proc, autorecode_trns_free, trns);
+  return buf_compare_rpad (CHAR_CAST_BUG (const char *, value_str (&(*a)->from, width_a)), width_a,
+			   CHAR_CAST_BUG (const char *, value_str (&(*b)->from, width_b)), width_b);
 }
 
-/* Executes an AUTORECODE transformation. */
 static int
-autorecode_trns_proc (void *trns_, struct ccase **c,
+autorecode_trns_proc (void *arc_, struct ccase **c,
                       casenumber case_idx UNUSED)
 {
-  struct autorecode_trns *trns = trns_;
+  struct autorecode_pgm *arc = arc_;
   size_t i;
 
   *c = case_unshare (*c);
-  for (i = 0; i < trns->spec_cnt; i++)
+  for (i = 0; i < arc->n_specs; i++)
     {
-      struct arc_spec *spec = &trns->specs[i];
+      const struct arc_spec *spec = &arc->specs[i];
+      int width = var_get_width (spec->src);
+      const union value *value = case_data (*c, spec->src);
       struct arc_item *item;
-      union arc_value v;
-
-      if (var_is_numeric (spec->src))
-        v.f = case_num (*c, spec->src);
-      else
-        v.c = (char *) case_str (*c, spec->src);
-      item = hsh_force_find (spec->items, &v);
 
-      case_data_rw (*c, spec->dest)->f = item->to;
+      item = find_arc_item (spec, value, value_hash (value, width, 0));
+      case_data_rw (*c, spec->dst)->f = item ? item->to : SYSMIS;
     }
+
   return TRNS_CONTINUE;
 }
 
-/* Frees an AUTORECODE transformation. */
 static bool
-autorecode_trns_free (void *trns_)
+autorecode_trns_free (void *arc_)
 {
-  struct autorecode_trns *trns = trns_;
-  size_t i;
+  struct autorecode_pgm *arc = arc_;
 
-  for (i = 0; i < trns->spec_cnt; i++)
-    hsh_destroy (trns->specs[i].items);
-  pool_destroy (trns->pool);
+  arc_free (arc);
   return true;
 }
-
-/* AUTORECODE procedure. */
-
-static int
-compare_alpha_value (const void *a_, const void *b_, const void *v_)
-{
-  const union arc_value *a = a_;
-  const union arc_value *b = b_;
-  const struct variable *v = v_;
-
-  return memcmp (a->c, b->c, var_get_width (v));
-}
-
-static unsigned
-hash_alpha_value (const void *a_, const void *v_)
-{
-  const union arc_value *a = a_;
-  const struct variable *v = v_;
-
-  return hsh_hash_bytes (a->c, var_get_width (v));
-}
-
-static int
-compare_numeric_value (const void *a_, const void *b_, const void *aux UNUSED)
-{
-  const union arc_value *a = a_;
-  const union arc_value *b = b_;
-
-  return a->f < b->f ? -1 : a->f > b->f;
-}
-
-static unsigned
-hash_numeric_value (const void *a_, const void *aux UNUSED)
-{
-  const union arc_value *a = a_;
-
-  return hsh_hash_double (a->f);
-}