X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fcase-map.c;h=f9dc67851441ea462601362705e344c7fa3bf9e2;hb=d26105c398be227dc38668ce3e742c31adef15f7;hp=411b9f0d49904cc118f3052c35c096c70c0e8376;hpb=5c3291dc396b795696e94f47780308fd7ace6fc4;p=pspp diff --git a/src/data/case-map.c b/src/data/case-map.c index 411b9f0d49..f9dc678514 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 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 @@ -16,19 +16,21 @@ #include -#include +#include "data/case-map.h" #include #include -#include -#include -#include -#include -#include -#include +#include "data/casereader.h" +#include "data/casewriter.h" +#include "data/dictionary.h" +#include "data/variable.h" +#include "data/case.h" +#include "libpspp/assertion.h" +#include "libpspp/hash-functions.h" +#include "libpspp/hmap.h" -#include "xalloc.h" +#include "gl/xalloc.h" /* A case map. */ struct case_map @@ -100,7 +102,7 @@ case_map_execute (const struct case_map *map, struct ccase *src) { int src_idx = map->map[dst_idx]; if (src_idx != -1) - *case_data_rw_idx (dst, dst_idx) = *case_data_idx (src, src_idx); + value_copy (case_data_rw_idx (dst, dst_idx), case_data_idx (src, src_idx), caseproto_get_width (map->proto, dst_idx)); } case_unref (src); return dst; @@ -118,7 +120,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,7 +129,7 @@ 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, case_map_get_proto (map), @@ -147,7 +149,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), @@ -209,57 +211,115 @@ case_map_to_compact_dict (const struct dictionary *d, 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; + }; -/* 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 +struct case_map_stage + { + const struct dictionary *dict; + struct hmap stage_vars; + }; + +/* 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_var_cnt (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_var_cnt (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) @@ -304,6 +364,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]); }