Constness and global namespace patrol.
[pspp] / src / language / dictionary / modify-variables.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
3    Written by Ben Pfaff <blp@gnu.org>.
4
5    This program is free software; you can redistribute it and/or
6    modify it under the terms of the GNU General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    This program is distributed in the hope that it will be useful, but
11    WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18    02110-1301, USA. */
19
20 #include <config.h>
21
22 #include <stdlib.h>
23
24 #include <data/dictionary.h>
25 #include <data/procedure.h>
26 #include <data/variable.h>
27 #include <language/command.h>
28 #include <language/lexer/lexer.h>
29 #include <language/lexer/variable-parser.h>
30 #include <libpspp/alloc.h>
31 #include <libpspp/assertion.h>
32 #include <libpspp/array.h>
33 #include <libpspp/bit-vector.h>
34 #include <libpspp/compiler.h>
35 #include <libpspp/hash.h>
36 #include <libpspp/message.h>
37 #include <libpspp/message.h>
38 #include <libpspp/misc.h>
39 #include <libpspp/str.h>
40
41 #include "gettext.h"
42 #define _(msgid) gettext (msgid)
43
44 /* FIXME: should change weighting variable, etc. */
45 /* These control the ordering produced by
46    compare_variables_given_ordering(). */
47 struct ordering
48   {
49     int forward;                /* 1=FORWARD, 0=BACKWARD. */
50     int positional;             /* 1=POSITIONAL, 0=ALPHA. */
51   };
52
53 /* Increasing order of variable index. */
54 static struct ordering forward_positional_ordering = {1, 1};
55
56 static int compare_variables_given_ordering (const void *, const void *,
57                                              void *ordering);
58
59 /* Explains how to modify the variables in a dictionary. */
60 struct var_modification
61   {
62     /* New variable ordering. */
63     struct variable **reorder_vars;
64     size_t reorder_cnt;
65
66     /* DROP/KEEP information. */
67     struct variable **drop_vars;
68     size_t drop_cnt;
69
70     /* New variable names. */
71     struct variable **rename_vars;
72     char **new_names;
73     size_t rename_cnt;
74   };
75
76 static bool rearrange_dict (struct dictionary *d,
77                            const struct var_modification *vm);
78
79 /* Performs MODIFY VARS command. */
80 int
81 cmd_modify_vars (void)
82 {
83   /* Bits indicated whether we've already encountered a subcommand of
84      this type. */
85   unsigned already_encountered = 0;
86
87   /* What we're gonna do to the active file. */
88   struct var_modification vm;
89
90   /* Return code. */
91   int ret_code = CMD_CASCADING_FAILURE;
92
93   size_t i;
94
95   if (proc_make_temporary_transformations_permanent (current_dataset))
96     msg (SE, _("MODIFY VARS may not be used after TEMPORARY.  "
97                "Temporary transformations will be made permanent."));
98
99   vm.reorder_vars = NULL;
100   vm.reorder_cnt = 0;
101   vm.rename_vars = NULL;
102   vm.new_names = NULL;
103   vm.rename_cnt = 0;
104   vm.drop_vars = NULL;
105   vm.drop_cnt = 0;
106
107   /* Parse each subcommand. */
108   lex_match ('/');
109   for (;;)
110     {
111       if (lex_match_id ("REORDER"))
112         {
113           struct variable **v = NULL;
114           size_t nv = 0;
115
116           if (already_encountered & 1)
117             {
118               msg (SE, _("REORDER subcommand may be given at most once."));
119               goto done;
120             }
121           already_encountered |= 1;
122
123           lex_match ('=');
124           do
125             {
126               struct ordering ordering;
127               size_t prev_nv = nv;
128
129               ordering.forward = ordering.positional = 1;
130               if (lex_match_id ("FORWARD"));
131               else if (lex_match_id ("BACKWARD"))
132                 ordering.forward = 0;
133               if (lex_match_id ("POSITIONAL"));
134               else if (lex_match_id ("ALPHA"))
135                 ordering.positional = 0;
136
137               if (lex_match (T_ALL) || token == '/' || token == '.')
138                 {
139                   if (prev_nv != 0)
140                     {
141                       msg (SE, _("Cannot specify ALL after specifying a set "
142                            "of variables."));
143                       goto done;
144                     }
145                   dict_get_vars (dataset_dict (current_dataset), &v, &nv, 1u << DC_SYSTEM);
146                 }
147               else
148                 {
149                   if (!lex_match ('('))
150                     {
151                       msg (SE, _("`(' expected on REORDER subcommand."));
152                       free (v);
153                       goto done;
154                     }
155                   if (!parse_variables (dataset_dict (current_dataset), &v, &nv,
156                                         PV_APPEND | PV_NO_DUPLICATE))
157                     {
158                       free (v);
159                       goto done;
160                     }
161                   if (!lex_match (')'))
162                     {
163                       msg (SE, _("`)' expected following variable names on "
164                            "REORDER subcommand."));
165                       free (v);
166                       goto done;
167                     }
168                 }
169               sort (&v[prev_nv], nv - prev_nv, sizeof *v,
170                     compare_variables_given_ordering, &ordering);
171             }
172           while (token != '/' && token != '.');
173
174           vm.reorder_vars = v;
175           vm.reorder_cnt = nv;
176         }
177       else if (lex_match_id ("RENAME"))
178         {
179           if (already_encountered & 2)
180             {
181               msg (SE, _("RENAME subcommand may be given at most once."));
182               goto done;
183             }
184           already_encountered |= 2;
185
186           lex_match ('=');
187           do
188             {
189               size_t prev_nv_1 = vm.rename_cnt;
190               size_t prev_nv_2 = vm.rename_cnt;
191
192               if (!lex_match ('('))
193                 {
194                   msg (SE, _("`(' expected on RENAME subcommand."));
195                   goto done;
196                 }
197               if (!parse_variables (dataset_dict (current_dataset), &vm.rename_vars, &vm.rename_cnt,
198                                     PV_APPEND | PV_NO_DUPLICATE))
199                 goto done;
200               if (!lex_match ('='))
201                 {
202                   msg (SE, _("`=' expected between lists of new and old variable "
203                        "names on RENAME subcommand."));
204                   goto done;
205                 }
206               if (!parse_DATA_LIST_vars (&vm.new_names, &prev_nv_1, PV_APPEND))
207                 goto done;
208               if (prev_nv_1 != vm.rename_cnt)
209                 {
210                   msg (SE, _("Differing number of variables in old name list "
211                        "(%d) and in new name list (%d)."),
212                        vm.rename_cnt - prev_nv_2, prev_nv_1 - prev_nv_2);
213                   for (i = 0; i < prev_nv_1; i++)
214                     free (vm.new_names[i]);
215                   free (vm.new_names);
216                   vm.new_names = NULL;
217                   goto done;
218                 }
219               if (!lex_match (')'))
220                 {
221                   msg (SE, _("`)' expected after variable lists on RENAME "
222                        "subcommand."));
223                   goto done;
224                 }
225             }
226           while (token != '.' && token != '/');
227         }
228       else if (lex_match_id ("KEEP"))
229         {
230           struct variable **keep_vars, **all_vars, **drop_vars;
231           size_t keep_cnt, all_cnt, drop_cnt;
232
233           if (already_encountered & 4)
234             {
235               msg (SE, _("KEEP subcommand may be given at most once.  It may not"
236                    "be given in conjunction with the DROP subcommand."));
237               goto done;
238             }
239           already_encountered |= 4;
240
241           lex_match ('=');
242           if (!parse_variables (dataset_dict (current_dataset), &keep_vars, &keep_cnt, PV_NONE))
243             goto done;
244
245           /* Transform the list of variables to keep into a list of
246              variables to drop.  First sort the keep list, then figure
247              out which variables are missing. */
248           sort (keep_vars, keep_cnt, sizeof *keep_vars,
249                 compare_variables_given_ordering, &forward_positional_ordering);
250
251           dict_get_vars (dataset_dict (current_dataset), &all_vars, &all_cnt, 0);
252           assert (all_cnt >= keep_cnt);
253
254           drop_cnt = all_cnt - keep_cnt;
255           drop_vars = xnmalloc (drop_cnt, sizeof *keep_vars);
256           if (set_difference (all_vars, all_cnt,
257                               keep_vars, keep_cnt,
258                               sizeof *all_vars,
259                               drop_vars,
260                               compare_variables_given_ordering,
261                               &forward_positional_ordering)
262               != drop_cnt)
263             NOT_REACHED ();
264
265           free (keep_vars);
266           free (all_vars);
267
268           vm.drop_vars = drop_vars;
269           vm.drop_cnt = drop_cnt;
270         }
271       else if (lex_match_id ("DROP"))
272         {
273           struct variable **drop_vars;
274           size_t drop_cnt;
275
276           if (already_encountered & 4)
277             {
278               msg (SE, _("DROP subcommand may be given at most once.  It may "
279                          "not be given in conjunction with the KEEP "
280                          "subcommand."));
281               goto done;
282             }
283           already_encountered |= 4;
284
285           lex_match ('=');
286           if (!parse_variables (dataset_dict (current_dataset), &drop_vars, &drop_cnt, PV_NONE))
287             goto done;
288           vm.drop_vars = drop_vars;
289           vm.drop_cnt = drop_cnt;
290         }
291       else if (lex_match_id ("MAP"))
292         {
293           struct dictionary *temp = dict_clone (dataset_dict (current_dataset));
294           int success = rearrange_dict (temp, &vm);
295           if (success) 
296             {
297               /* FIXME: display new dictionary. */ 
298             }
299           dict_destroy (temp);
300         }
301       else
302         {
303           if (token == T_ID)
304             msg (SE, _("Unrecognized subcommand name `%s'."), tokid);
305           else
306             msg (SE, _("Subcommand name expected."));
307           goto done;
308         }
309
310       if (token == '.')
311         break;
312       if (token != '/')
313         {
314           msg (SE, _("`/' or `.' expected."));
315           goto done;
316         }
317       lex_get ();
318     }
319
320   if (already_encountered & (1 | 4))
321     {
322       /* Read the data. */
323       if (!procedure (current_dataset,NULL, NULL)) 
324         goto done; 
325     }
326
327   if (!rearrange_dict (dataset_dict (current_dataset), &vm))
328     goto done; 
329
330   ret_code = CMD_SUCCESS;
331
332 done:
333   free (vm.reorder_vars);
334   free (vm.rename_vars);
335   for (i = 0; i < vm.rename_cnt; i++)
336     free (vm.new_names[i]);
337   free (vm.new_names);
338   free (vm.drop_vars);
339   return ret_code;
340 }
341
342 /* Compares A and B according to the settings in
343    ORDERING, returning a strcmp()-type result. */
344 static int
345 compare_variables_given_ordering (const void *a_, const void *b_,
346                                   void *ordering_)
347 {
348   struct variable *const *pa = a_;
349   struct variable *const *pb = b_;
350   const struct variable *a = *pa;
351   const struct variable *b = *pb;
352   const struct ordering *ordering = ordering_;
353
354   int result;
355   if (ordering->positional)
356     result = a->index < b->index ? -1 : a->index > b->index;
357   else
358     result = strcasecmp (a->name, b->name);
359   if (!ordering->forward)
360     result = -result;
361   return result;
362 }
363
364 /* Pairs a variable with a new name. */
365 struct var_renaming
366   {
367     struct variable *var;
368     char new_name[LONG_NAME_LEN + 1];
369   };
370
371 /* A algo_compare_func that compares new_name members in struct
372    var_renaming structures A and B. */
373 static int
374 compare_var_renaming_by_new_name (const void *a_, const void *b_,
375                                   void *foo UNUSED) 
376 {
377   const struct var_renaming *a = a_;
378   const struct var_renaming *b = b_;
379
380   return strcasecmp (a->new_name, b->new_name);
381 }
382
383 /* Returns true if performing VM on dictionary D would not cause
384    problems such as duplicate variable names.  Returns false
385    otherwise, and issues an error message. */
386 static int
387 validate_var_modification (const struct dictionary *d,
388                            const struct var_modification *vm) 
389 {
390   /* Variable reordering can't be a problem, so we don't simulate
391      it.  Variable renaming can cause duplicate names, but
392      dropping variables can eliminate them, so we simulate both
393      of those. */
394   struct variable **all_vars;
395   struct variable **keep_vars;
396   struct variable **drop_vars;
397   size_t keep_cnt, drop_cnt;
398   size_t all_cnt;
399
400   struct var_renaming *var_renaming;
401   int valid;
402   size_t i;
403
404   /* All variables, in index order. */
405   dict_get_vars (d, &all_vars, &all_cnt, 0);
406
407   /* Drop variables, in index order. */
408   drop_cnt = vm->drop_cnt;
409   drop_vars = xnmalloc (drop_cnt, sizeof *drop_vars);
410   memcpy (drop_vars, vm->drop_vars, drop_cnt * sizeof *drop_vars);
411   sort (drop_vars, drop_cnt, sizeof *drop_vars,
412         compare_variables_given_ordering, &forward_positional_ordering);
413
414   /* Keep variables, in index order. */
415   assert (all_cnt >= drop_cnt);
416   keep_cnt = all_cnt - drop_cnt;
417   keep_vars = xnmalloc (keep_cnt, sizeof *keep_vars);
418   if (set_difference (all_vars, all_cnt,
419                       drop_vars, drop_cnt,
420                       sizeof *all_vars,
421                       keep_vars,
422                       compare_variables_given_ordering,
423                       &forward_positional_ordering) != keep_cnt)
424     NOT_REACHED ();
425
426   /* Copy variables into var_renaming array. */
427   var_renaming = xnmalloc (keep_cnt, sizeof *var_renaming);
428   for (i = 0; i < keep_cnt; i++) 
429     {
430       var_renaming[i].var = keep_vars[i];
431       strcpy (var_renaming[i].new_name, keep_vars[i]->name);
432     }
433   
434   /* Rename variables in var_renaming array. */
435   for (i = 0; i < vm->rename_cnt; i++) 
436     {
437       struct variable *const *kv;
438       struct var_renaming *vr;
439
440       /* Get the var_renaming element. */
441       kv = binary_search (keep_vars, keep_cnt, sizeof *keep_vars,
442                           &vm->rename_vars[i],
443                           compare_variables_given_ordering,
444                           &forward_positional_ordering);
445       if (kv == NULL)
446         continue;
447       vr = var_renaming + (kv - keep_vars);
448
449       strcpy (vr->new_name, vm->new_names[i]);
450     }
451
452   /* Sort var_renaming array by new names and check for
453      duplicates. */
454   sort (var_renaming, keep_cnt, sizeof *var_renaming,
455         compare_var_renaming_by_new_name, NULL);
456   valid = adjacent_find_equal (var_renaming, keep_cnt, sizeof *var_renaming,
457                                compare_var_renaming_by_new_name, NULL) == NULL;
458
459   /* Clean up. */
460   free (all_vars);
461   free (keep_vars);
462   free (drop_vars);
463   free (var_renaming);
464
465   return valid;
466 }
467
468 /* Reoders, removes, and renames variables in dictionary D
469    according to VM.  Returns true if successful, false if there
470    would have been duplicate variable names if the modifications
471    had been carried out.  In the latter case, the dictionary is
472    not modified. */
473 static bool
474 rearrange_dict (struct dictionary *d, const struct var_modification *vm)
475 {
476   char **rename_old_names;
477
478   struct variable **rename_vars;
479   char **rename_new_names;
480   size_t rename_cnt;
481
482   size_t i;
483
484   /* Check whether the modifications will cause duplicate
485      names. */
486   if (!validate_var_modification (d, vm))
487     return false;
488
489   /* Record the old names of variables to rename.  After
490      variables are deleted, we can't depend on the variables to
491      still exist, but we can still look them up by name. */
492   rename_old_names = xnmalloc (vm->rename_cnt, sizeof *rename_old_names);
493   for (i = 0; i < vm->rename_cnt; i++)
494     rename_old_names[i] = xstrdup (vm->rename_vars[i]->name);
495
496   /* Reorder and delete variables. */
497   dict_reorder_vars (d, vm->reorder_vars, vm->reorder_cnt);
498   dict_delete_vars (d, vm->drop_vars, vm->drop_cnt);
499
500   /* Compose lists of variables to rename and their new names. */
501   rename_vars = xnmalloc (vm->rename_cnt, sizeof *rename_vars);
502   rename_new_names = xnmalloc (vm->rename_cnt, sizeof *rename_new_names);
503   rename_cnt = 0;
504   for (i = 0; i < vm->rename_cnt; i++)
505     {
506       struct variable *var = dict_lookup_var (d, rename_old_names[i]);
507       if (var == NULL)
508         continue;
509       
510       rename_vars[rename_cnt] = var;
511       rename_new_names[rename_cnt] = vm->new_names[i];
512       rename_cnt++;
513     }
514
515   /* Do renaming. */
516   if (dict_rename_vars (d, rename_vars, rename_new_names, rename_cnt,
517                         NULL) == 0)
518     NOT_REACHED ();
519
520   /* Clean up. */
521   for (i = 0; i < vm->rename_cnt; i++)
522     free (rename_old_names[i]);
523   free (rename_old_names);
524   free (rename_vars);
525   free (rename_new_names);
526
527   return true;
528 }