X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fcase-map.c;h=b47d38e1dd1346df17454ed4c20f4dff432da806;hb=refs%2Fheads%2Fvariable-sets;hp=c54e6753fe74bab580984479e4573dabe9988c04;hpb=fe8dc2171009e90d2335f159d05f7e6660e24780;p=pspp

diff --git a/src/data/case-map.c b/src/data/case-map.c
index c54e6753fe..b47d38e1dd 100644
--- a/src/data/case-map.c
+++ b/src/data/case-map.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 1997-9, 2000, 2006, 2007, 2009, 2011 Free Software Foundation, Inc.
+   Copyright (C) 1997-9, 2000, 2006, 2007, 2009, 2011, 2013 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
@@ -27,6 +27,8 @@
 #include "data/variable.h"
 #include "data/case.h"
 #include "libpspp/assertion.h"
+#include "libpspp/hash-functions.h"
+#include "libpspp/hmap.h"
 
 #include "gl/xalloc.h"
 
@@ -70,6 +72,22 @@ insert_mapping (struct case_map *map, size_t from, size_t to)
   map->map[to] = from;
 }
 
+/* Returns a copy of OLD, if OLD is nonnull, and otherwise returns NULL.  */
+struct case_map *
+case_map_clone (const struct case_map *old)
+{
+  if (!old)
+    return NULL;
+
+  size_t n_values = caseproto_get_n_widths (old->proto);
+  struct case_map *new = xmalloc (sizeof *new);
+  *new = (struct case_map) {
+    .proto = caseproto_ref (old->proto),
+    .map = xmemdup (old->proto, n_values * sizeof *new->map),
+  };
+  return new;
+}
+
 /* Destroys case map MAP. */
 void
 case_map_destroy (struct case_map *map)
@@ -118,7 +136,7 @@ case_map_get_proto (const struct case_map *map)
 }
 
 /* Creates and returns a new casereader whose cases are produced
-   by reading from SUBREADER and executing the actions of MAP.  
+   by reading from SUBREADER and executing the actions of MAP.
    The casereader will have as many `union value's as MAP.  When
    the new casereader is destroyed, MAP will be destroyed too.
 
@@ -127,13 +145,14 @@ case_map_get_proto (const struct case_map *map)
    when the returned casereader is destroyed. */
 struct casereader *
 case_map_create_input_translator (struct case_map *map,
-                                  struct casereader *subreader) 
+                                  struct casereader *subreader)
 {
-    return casereader_create_translator (subreader,
+  static const struct casereader_translator_class class = {
+    translate_case, destroy_case_map,
+  };
+  return casereader_translate_stateless (subreader,
                                          case_map_get_proto (map),
-                                         translate_case,
-                                         destroy_case_map,
-                                         map);
+                                         &class, map);
 }
 
 /* Creates and returns a new casewriter.  Cases written to the
@@ -147,7 +166,7 @@ case_map_create_input_translator (struct case_map *map,
    when the returned casewriter is destroyed. */
 struct casewriter *
 case_map_create_output_translator (struct case_map *map,
-                                   struct casewriter *subwriter) 
+                                   struct casewriter *subwriter)
 {
     return casewriter_create_translator (subwriter,
                                          case_map_get_proto (map),
@@ -180,14 +199,14 @@ destroy_case_map (void *map_)
    the last value.  (Holes are created by deleting variables.)
 
    All variables are compacted if EXCLUDE_CLASSES is 0, or it may
-   contain one or more of (1u << DC_ORDINARY), (1u << DC_SYSTEM),
-   or (1u << DC_SCRATCH) to cause the corresponding type of
-   variable to be deleted during compaction. */
+   contain one or more of DC_ORDINARY, DC_SYSTEM, or DC_SCRATCH
+   to cause the corresponding type of variable to be deleted
+   during compaction. */
 struct case_map *
 case_map_to_compact_dict (const struct dictionary *d,
                           unsigned int exclude_classes)
 {
-  size_t n_vars = dict_get_var_cnt (d);
+  size_t n_vars = dict_get_n_vars (d);
   struct caseproto *proto;
   struct case_map *map;
   size_t n_values;
@@ -203,63 +222,121 @@ case_map_to_compact_dict (const struct dictionary *d,
   for (i = 0; i < n_vars; i++)
     {
       struct variable *v = dict_get_var (d, i);
-      if (!(exclude_classes & (1u << var_get_dict_class (v))))
+      if (!(exclude_classes & var_get_dict_class (v)))
         insert_mapping (map, var_get_case_index (v), n_values++);
     }
 
   return map;
 }
+
+struct stage_var
+  {
+    struct hmap_node hmap_node; /* In struct case_map_stage's 'stage_vars'. */
+    const struct variable *var;
+    int case_index;
+  };
+
+struct case_map_stage
+  {
+    const struct dictionary *dict;
+    struct hmap stage_vars;
+  };
 
-/* Prepares dictionary D for producing a case map.  Afterward,
-   the caller may delete, reorder, or rename variables within D
-   at will before using case_map_from_dict() to produce the case
+/* Prepares and returns a "struct case_map_stage" for producing a case map for
+   DICT.  Afterward, the caller may delete, reorder, or rename variables within
+   DICT at will before using case_map_stage_get_case_map() to produce the case
    map.
 
-   Uses D's aux members, which must otherwise not be in use. */
-void
-case_map_prepare_dict (const struct dictionary *d)
+   The caller must *not* add new variables to DICT. */
+struct case_map_stage *
+case_map_stage_create (const struct dictionary *dict)
 {
-  size_t var_cnt = dict_get_var_cnt (d);
+  size_t n_vars = dict_get_n_vars (dict);
+  struct case_map_stage *stage;
   size_t i;
 
-  for (i = 0; i < var_cnt; i++)
+  stage = xmalloc (sizeof *stage);
+  stage->dict = dict;
+  hmap_init (&stage->stage_vars);
+
+  for (i = 0; i < n_vars; i++)
     {
-      struct variable *v = dict_get_var (d, i);
-      int *src_fv = xmalloc (sizeof *src_fv);
-      *src_fv = var_get_case_index (v);
-      var_attach_aux (v, src_fv, var_dtor_free);
+      const struct variable *var = dict_get_var (dict, i);
+      struct stage_var *stage_var;
+
+      stage_var = xmalloc (sizeof *stage_var);
+      stage_var->var = var;
+      stage_var->case_index = var_get_case_index (var);
+      hmap_insert (&stage->stage_vars, &stage_var->hmap_node,
+                   hash_pointer (var, 0));
+    }
+
+  return stage;
+}
+
+/* Destroys STAGE, which was created by case_map_stage_create(). */
+void
+case_map_stage_destroy (struct case_map_stage *stage)
+{
+  if (stage != NULL)
+    {
+      struct stage_var *stage_var, *next_stage_var;
+
+      HMAP_FOR_EACH_SAFE (stage_var, next_stage_var,
+                          struct stage_var, hmap_node, &stage->stage_vars)
+        {
+          hmap_delete (&stage->stage_vars, &stage_var->hmap_node);
+          free (stage_var);
+        }
+      hmap_destroy (&stage->stage_vars);
+      free (stage);
     }
 }
 
-/* Produces a case map from dictionary D, which must have been
-   previously prepared with case_map_prepare_dict().
+static const struct stage_var *
+case_map_stage_find_var (const struct case_map_stage *stage,
+                         const struct variable *var)
+{
+  const struct stage_var *stage_var;
+
+  HMAP_FOR_EACH_IN_BUCKET (stage_var, struct stage_var, hmap_node,
+                           hash_pointer (var, 0), &stage->stage_vars)
+    if (stage_var->var == var)
+      return stage_var;
+
+  /* If the following assertion is reached, it indicates a bug in the
+     case_map_stage client: the client allowed a new variable to be added to
+     the dictionary.  This is not allowed, because of the risk that the new
+     varaible might have the same address as an old variable that has been
+     deleted. */
+  NOT_REACHED ();
+}
 
-   Does not retain any reference to D, and clears the aux members
-   set up by case_map_prepare_dict().
+/* Produces a case map from STAGE, which must have been previously created with
+   case_map_stage_create().  The case map maps from the original case index of
+   the variables in STAGE's dictionary to their current case indexes.
 
-   Returns the new case map, or a null pointer if no mapping is
-   required (that is, no data has changed position). */
+   Returns the new case map, or a null pointer if no mapping is required (that
+   is, no data has changed position). */
 struct case_map *
-case_map_from_dict (const struct dictionary *d)
+case_map_stage_get_case_map (const struct case_map_stage *stage)
 {
   struct case_map *map;
-  size_t var_cnt = dict_get_var_cnt (d);
+  size_t n_vars = dict_get_n_vars (stage->dict);
   size_t n_values;
   size_t i;
   bool identity_map = true;
 
-  map = create_case_map (dict_get_proto (d));
-  for (i = 0; i < var_cnt; i++)
+  map = create_case_map (dict_get_proto (stage->dict));
+  for (i = 0; i < n_vars; i++)
     {
-      struct variable *v = dict_get_var (d, i);
-      int *src_fv = var_detach_aux (v);
+      const struct variable *var = dict_get_var (stage->dict, i);
+      const struct stage_var *stage_var = case_map_stage_find_var (stage, var);
 
-      if (var_get_case_index (v) != *src_fv)
+      if (var_get_case_index (var) != stage_var->case_index)
         identity_map = false;
 
-      insert_mapping (map, *src_fv, var_get_case_index (v));
-
-      free (src_fv);
+      insert_mapping (map, stage_var->case_index, var_get_case_index (var));
     }
 
   if (identity_map)
@@ -283,12 +360,9 @@ struct case_map *
 case_map_by_name (const struct dictionary *old,
                   const struct dictionary *new)
 {
-  struct case_map *map;
-  size_t var_cnt = dict_get_var_cnt (new);
-  size_t i;
-
-  map = create_case_map (dict_get_proto (new));
-  for (i = 0; i < var_cnt; i++)
+  size_t n_vars = dict_get_n_vars (new);
+  struct case_map *map = create_case_map (dict_get_proto (new));
+  for (size_t i = 0; i < n_vars; i++)
     {
       struct variable *nv = dict_get_var (new, i);
       struct variable *ov = dict_lookup_var_assert (old, var_get_name (nv));
@@ -304,6 +378,6 @@ void
 case_map_dump (const struct case_map *cm)
 {
   int i;
-  for (i = 0 ; i < caseproto_get_n_widths (cm->proto); ++i )
+  for (i = 0 ; i < caseproto_get_n_widths (cm->proto); ++i)
     printf ("%d -> %d\n", i, cm->map[i]);
 }