Removed my authorship lines.

[pspp-builds.git] / src / language / stats / rank.q

diff --git a/src/language/stats/rank.q b/src/language/stats/rank.q
index 2ab8307d54abb004d5d2c561986e6ad8ccd11667..10ad7715c7556a0333c5698b157e20e87c8cee5c 100644 (file)
--- a/src/language/stats/rank.q
+++ b/src/language/stats/rank.q
@@ -1,7 +1,6 @@
 /* PSPP - RANK. -*-c-*-
 
 Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-Author: John Darrington <john@darrington.wattle.id.au>, 
         Ben Pfaff <blp@gnu.org>.
 
 This program is free software; you can redistribute it and/or
@@ -24,6 +23,8 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 #include "sort-criteria.h"
 
 #include <data/dictionary.h>
+#include <data/format.h>
+#include <data/missing-values.h>
 #include <data/procedure.h>
 #include <data/variable.h>
 #include <data/case.h>
@@ -148,7 +149,7 @@ struct rank_spec
 
 
 /* Function to use for testing for missing values */
-static is_missing_func *value_is_missing;
+static mv_is_missing_func *value_is_missing;
 
 static struct rank_spec *rank_specs;
 static size_t n_rank_specs;
@@ -216,17 +217,18 @@ create_var_label (struct variable *dest_var,
       for (g = 0 ; g < n_group_vars ; ++g ) 
        {
          if ( g > 0 ) ds_put_cstr (&group_var_str, " ");
-         ds_put_cstr (&group_var_str, group_vars[g]->name);
+         ds_put_cstr (&group_var_str, var_get_name (group_vars[g]));
        }
 
       ds_put_format (&label, _("%s of %s by %s"), function_name[f], 
-                    src_var->name, ds_cstr (&group_var_str));
+                    var_get_name (src_var), ds_cstr (&group_var_str));
       ds_destroy (&group_var_str);
     }
   else
-    ds_put_format (&label,_("%s of %s"), function_name[f], src_var->name);  
+    ds_put_format (&label, _("%s of %s"),
+                   function_name[f], var_get_name (src_var));  
 
-  dest_var->label = strdup (ds_cstr (&label) );
+  var_set_label (dest_var, ds_cstr (&label));
 
   ds_destroy (&label);
 }
@@ -246,14 +248,14 @@ rank_cmd (struct dataset *ds, const struct sort_criteria *sc,
   for (i = 0; i < n_splits ; i++) 
     {
       struct variable *v = dict_get_split_vars (dataset_dict (ds))[i];
-      criteria.crits[i].fv = v->fv;
-      criteria.crits[i].width = v->width;
+      criteria.crits[i].fv = var_get_case_index (v);
+      criteria.crits[i].width = var_get_width (v);
       criteria.crits[i].dir = SRT_ASCEND;
     }
   for (i = 0; i < n_group_vars; i++) 
     {
-      criteria.crits[i + n_splits].fv = group_vars[i]->fv;
-      criteria.crits[i + n_splits].width = group_vars[i]->width;
+      criteria.crits[i + n_splits].fv = var_get_case_index (group_vars[i]);
+      criteria.crits[i + n_splits].width = var_get_width (group_vars[i]);
       criteria.crits[i + n_splits].dir = SRT_ASCEND;
     }
   for (i = 0 ; i < sc->crit_cnt ; ++i )
@@ -272,14 +274,14 @@ rank_cmd (struct dataset *ds, const struct sort_criteria *sc,
       /* Sort CF into SORTED_CF. */
       reader = casefile_get_destructive_reader (cf) ;
       criteria.crits[criteria.crit_cnt - 1] = sc->crits[i];
-      assert ( sc->crits[i].fv == src_vars[i]->fv );
+      assert ( sc->crits[i].fv == var_get_case_index (src_vars[i]) );
       sorted_cf = sort_execute (reader, &criteria);
       casefile_destroy (cf);
 
       out = rank_sorted_casefile (sorted_cf, &criteria,
                                  dataset_dict (ds),
                                   rank_specs, n_rank_specs, 
-                                 i, &src_vars[i]->miss)  ;
+                                 i, var_get_missing_values (src_vars[i]));
       if ( NULL == out ) 
        {
          result = false ;
@@ -518,7 +520,7 @@ rank_cases (struct casereader *cr,
       if (!casereader_read_xfer (cr, &this_case))
         break;
       
-      this_value = case_data (&this_case, fv);
+      this_value = case_data_idx (&this_case, fv);
       c = dict_get_case_weight (dict, &this_case, &warn);
               
       lookahead = casereader_clone (cr);
@@ -526,7 +528,7 @@ rank_cases (struct casereader *cr,
       while (casereader_cnum (lookahead) < end
              && casereader_read_xfer (lookahead, &lookahead_case))
         {
-          const union value *lookahead_value = case_data (&lookahead_case, fv);
+          const union value *lookahead_value = case_data_idx (&lookahead_case, fv);
           int diff = compare_values (this_value, lookahead_value, width);
 
           if (diff != 0) 
@@ -552,12 +554,12 @@ rank_cases (struct casereader *cr,
         {
           for (i = 0; i < n_rank_specs; ++i) 
             {
-              const int dest_idx = rs[i].destvars[dest_var_index]->fv;
+              const struct variable *dst_var = rs[i].destvars[dest_var_index];
 
              if  ( value_is_missing (mv, this_value) )
-               case_data_rw (&this_case, dest_idx)->f = SYSMIS;
+               case_data_rw (&this_case, dst_var)->f = SYSMIS;
              else
-               case_data_rw (&this_case, dest_idx)->f = 
+               case_data_rw (&this_case, dst_var)->f = 
                  rank_func[rs[i].rfunc](c, cc, cc_1, iter, w);
             }
           casefile_append_xfer (dest, &this_case); 
@@ -581,8 +583,8 @@ same_group (const struct ccase *a, const struct ccase *b,
   for (i = 0; i < crit->crit_cnt - 1; i++)
     {
       struct sort_criterion *c = &crit->crits[i];
-      if (compare_values (case_data (a, c->fv), case_data (b, c->fv),
-                          c->width) != 0)
+      if (compare_values (case_data_idx (a, c->fv),
+                          case_data_idx (b, c->fv), c->width) != 0)
         return false;
     }
 
@@ -611,7 +613,7 @@ rank_sorted_casefile (struct casefile *cf,
       struct ccase this_case;
       const union value *this_value ;
       double w = 0.0;
-      this_value = case_data( &group_case, ultimate_crit->fv);
+      this_value = case_data_idx( &group_case, ultimate_crit->fv);
 
       if ( !value_is_missing(mv, this_value) )
        w = dict_get_case_weight (dict, &group_case, &warn);
@@ -619,7 +621,7 @@ rank_sorted_casefile (struct casefile *cf,
       while (casereader_read (lookahead, &this_case)) 
         {
          const union value *this_value = 
-           case_data(&this_case, ultimate_crit->fv);
+           case_data_idx(&this_case, ultimate_crit->fv);
           double c = dict_get_case_weight (dict, &this_case, &warn);
           if (!same_group (&group_case, &this_case, crit)) 
             {
@@ -660,7 +662,7 @@ create_resort_key (void *key_var_, struct ccase *cc, casenumber case_num)
 {
   struct variable *key_var = key_var_;
 
-  case_data_rw(cc, key_var->fv)->f = case_num;
+  case_data_rw(cc, key_var)->f = case_num;
   
   return TRNS_CONTINUE;
 }
@@ -685,8 +687,8 @@ create_rank_variable (struct dictionary *dict, enum RANK_FUNC f,
 
   if ( NULL == var )
     {
-      snprintf(name, SHORT_NAME_LEN + 1, "%c%s", 
-              function_name[f][0], src_var->name);
+      snprintf (name, SHORT_NAME_LEN + 1, "%c%s", 
+                function_name[f][0], var_get_name (src_var));
   
       var = dict_create_var(dict, name, 0);
     }
@@ -724,7 +726,7 @@ create_rank_variable (struct dictionary *dict, enum RANK_FUNC f,
       return NULL;
     }
 
-  var->write = var->print = dest_format[f];
+  var_set_both_formats (var, &dest_format[f]); 
 
   return var;
 }
@@ -834,7 +836,7 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
                  ds_init_empty (&varlist);
                  for ( g = 0 ; g < n_group_vars ; ++g ) 
                    {
-                     ds_put_cstr (&varlist, group_vars[g]->name);
+                     ds_put_cstr (&varlist, var_get_name (group_vars[g]));
 
                      if ( g < n_group_vars - 1)
                        ds_put_cstr (&varlist, " ");
@@ -844,10 +846,10 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
                       rank_specs[i].rfunc == PROPORTION ) 
                    tab_output_text (TAT_PRINTF,
                                     _("%s into %s(%s of %s using %s BY %s)"), 
-                                    src_vars[v]->name,
-                                    rank_specs[i].destvars[v]->name,
+                                    var_get_name (src_vars[v]),
+                                    var_get_name (rank_specs[i].destvars[v]),
                                     function_name[rank_specs[i].rfunc],
-                                    src_vars[v]->name,
+                                    var_get_name (src_vars[v]),
                                     fraction_name(),
                                     ds_cstr (&varlist)
                                     );
@@ -855,10 +857,10 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
                  else
                    tab_output_text (TAT_PRINTF,
                                     _("%s into %s(%s of %s BY %s)"), 
-                                    src_vars[v]->name,
-                                    rank_specs[i].destvars[v]->name,
+                                    var_get_name (src_vars[v]),
+                                    var_get_name (rank_specs[i].destvars[v]),
                                     function_name[rank_specs[i].rfunc],
-                                    src_vars[v]->name,
+                                    var_get_name (src_vars[v]),
                                     ds_cstr (&varlist)
                                     );
                  ds_destroy (&varlist);
@@ -869,20 +871,20 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
                       rank_specs[i].rfunc == PROPORTION ) 
                    tab_output_text (TAT_PRINTF,
                                     _("%s into %s(%s of %s using %s)"), 
-                                    src_vars[v]->name,
-                                    rank_specs[i].destvars[v]->name,
+                                    var_get_name (src_vars[v]),
+                                    var_get_name (rank_specs[i].destvars[v]),
                                     function_name[rank_specs[i].rfunc],
-                                    src_vars[v]->name,
+                                    var_get_name (src_vars[v]),
                                     fraction_name()
                                     );
                    
                  else
                    tab_output_text (TAT_PRINTF,
                                     _("%s into %s(%s of %s)"), 
-                                    src_vars[v]->name,
-                                    rank_specs[i].destvars[v]->name,
+                                    var_get_name (src_vars[v]),
+                                    var_get_name (rank_specs[i].destvars[v]),
                                     function_name[rank_specs[i].rfunc],
-                                    src_vars[v]->name
+                                    var_get_name (src_vars[v])
                                     );
                }
            }
@@ -906,7 +908,7 @@ cmd_rank (struct lexer *lexer, struct dataset *ds)
   {
     struct sort_criteria criteria;
     struct sort_criterion restore_criterion ;
-    restore_criterion.fv = order->fv;
+    restore_criterion.fv = var_get_case_index (order);
     restore_criterion.width = 0;
     restore_criterion.dir = SRT_ASCEND;