2ef156a0387d93764565a12fbdee734dced62bb7
[pspp] / src / modify-vars.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., 59 Temple Place - Suite 330, Boston, MA
18    02111-1307, USA. */
19
20 /* AIX requires this to be the first thing in the file.  */
21 #include <config.h>
22 #if __GNUC__
23 #define alloca __builtin_alloca
24 #else
25 #if HAVE_ALLOCA_H
26 #include <alloca.h>
27 #else
28 #ifdef _AIX
29 #pragma alloca
30 #else
31 #ifndef alloca                  /* predefined by HP cc +Olibcalls */
32 char *alloca ();
33 #endif
34 #endif
35 #endif
36 #endif
37
38 #include <stdlib.h>
39 #include <assert.h>
40 #include "algorithm.h"
41 #include "alloc.h"
42 #include "bitvector.h"
43 #include "command.h"
44 #include "error.h"
45 #include "hash.h"
46 #include "lexer.h"
47 #include "misc.h"
48 #include "str.h"
49 #include "var.h"
50 #include "vfm.h"
51
52 /* FIXME: should change weighting variable, etc. */
53 /* These control the ordering produced by
54    compare_variables_given_ordering(). */
55 struct ordering
56   {
57     int forward;                /* 1=FORWARD, 0=BACKWARD. */
58     int positional;             /* 1=POSITIONAL, 0=ALPHA. */
59   };
60
61 static int compare_variables_given_ordering (const void *, const void *,
62                                              void *ordering);
63
64 /* Explains how to modify the variables in a dictionary in conjunction
65    with the p.mfv field of `variable'. */
66 struct var_modification
67   {
68     /* REORDER information. */
69     struct variable **reorder_list;
70
71     /* RENAME information. */
72     struct variable **old_names;
73     char **new_names;
74     int n_rename;
75
76     /* DROP/KEEP information. */
77     int n_drop;                 /* Number of variables being dropped. */
78   };
79
80 static struct dictionary *rearrange_dict (struct dictionary *d,
81                                           struct var_modification *vm,
82                                           int permanent);
83
84 /* Performs MODIFY VARS command. */
85 int
86 cmd_modify_vars (void)
87 {
88   /* Bits indicated whether we've already encountered a subcommand of
89      this type. */
90   unsigned already_encountered = 0;
91
92   /* What we're gonna do to the active file. */
93   struct var_modification vm;
94
95   lex_match_id ("MODIFY");
96   lex_match_id ("VARS");
97
98   vm.reorder_list = NULL;
99   vm.old_names = NULL;
100   vm.new_names = NULL;
101   vm.n_rename = 0;
102   vm.n_drop = 0;
103
104   /* Parse each subcommand. */
105   lex_match ('/');
106   for (;;)
107     {
108       if (lex_match_id ("REORDER"))
109         {
110           struct variable **v = NULL;
111           int nv = 0;
112
113           if (already_encountered & 1)
114             {
115               msg (SE, _("REORDER subcommand may be given at most once."));
116               goto lossage;
117             }
118           already_encountered |= 1;
119
120           lex_match ('=');
121           do
122             {
123               struct ordering ordering;
124               int prev_nv = nv;
125
126               ordering.forward = ordering.positional = 1;
127               if (lex_match_id ("FORWARD"));
128               else if (lex_match_id ("BACKWARD"))
129                 ordering.forward = 0;
130               if (lex_match_id ("POSITIONAL"));
131               else if (lex_match_id ("ALPHA"))
132                 ordering.positional = 0;
133
134               if (lex_match (T_ALL) || token == '/' || token == '.')
135                 {
136                   if (prev_nv != 0)
137                     {
138                       msg (SE, _("Cannot specify ALL after specifying a set "
139                            "of variables."));
140                       goto lossage;
141                     }
142                   fill_all_vars (&v, &nv, FV_NO_SYSTEM);
143                 }
144               else
145                 {
146                   if (!lex_match ('('))
147                     {
148                       msg (SE, _("`(' expected on REORDER subcommand."));
149                       free (v);
150                       goto lossage;
151                     }
152                   if (!parse_variables (&default_dict, &v, &nv,
153                                         PV_APPEND | PV_NO_DUPLICATE))
154                     {
155                       free (v);
156                       goto lossage;
157                     }
158                   if (!lex_match (')'))
159                     {
160                       msg (SE, _("`)' expected following variable names on "
161                            "REORDER subcommand."));
162                       free (v);
163                       goto lossage;
164                     }
165                 }
166               sort (&v[prev_nv], nv - prev_nv, sizeof *v,
167                     compare_variables_given_ordering, &ordering);
168             }
169           while (token != '/' && token != '.');
170
171           if (nv != default_dict.nvar)
172             {
173               size_t nbytes = DIV_RND_UP (default_dict.nvar, 8);
174               unsigned char *bits = local_alloc (nbytes);
175               int i;
176
177               memset (bits, 0, nbytes);
178               for (i = 0; i < nv; i++)
179                 SET_BIT (bits, v[i]->index);
180               v = xrealloc (v, sizeof *v * default_dict.nvar);
181               for (i = 0; i < default_dict.nvar; i++)
182                 if (!TEST_BIT (bits, i))
183                   v[nv++] = default_dict.var[i];
184               local_free (bits);
185             }
186
187           vm.reorder_list = v;
188         }
189       else if (lex_match_id ("RENAME"))
190         {
191           if (already_encountered & 2)
192             {
193               msg (SE, _("RENAME subcommand may be given at most once."));
194               goto lossage;
195             }
196           already_encountered |= 2;
197
198           lex_match ('=');
199           do
200             {
201               int prev_nv_1 = vm.n_rename;
202               int prev_nv_2 = vm.n_rename;
203
204               if (!lex_match ('('))
205                 {
206                   msg (SE, _("`(' expected on RENAME subcommand."));
207                   goto lossage;
208                 }
209               if (!parse_variables (&default_dict, &vm.old_names, &vm.n_rename,
210                                     PV_APPEND | PV_NO_DUPLICATE))
211                 goto lossage;
212               if (!lex_match ('='))
213                 {
214                   msg (SE, _("`=' expected between lists of new and old variable "
215                        "names on RENAME subcommand."));
216                   goto lossage;
217                 }
218               if (!parse_DATA_LIST_vars (&vm.new_names, &prev_nv_1, PV_APPEND))
219                 goto lossage;
220               if (prev_nv_1 != vm.n_rename)
221                 {
222                   int i;
223
224                   msg (SE, _("Differing number of variables in old name list "
225                        "(%d) and in new name list (%d)."),
226                        vm.n_rename - prev_nv_2, prev_nv_1 - prev_nv_2);
227                   for (i = 0; i < prev_nv_1; i++)
228                     free (&vm.new_names[i]);
229                   free (&vm.new_names);
230                   vm.new_names = NULL;
231                   goto lossage;
232                 }
233               if (!lex_match (')'))
234                 {
235                   msg (SE, _("`)' expected after variable lists on RENAME "
236                        "subcommand."));
237                   goto lossage;
238                 }
239             }
240           while (token != '.' && token != '/');
241         }
242       else if (lex_match_id ("KEEP"))
243         {
244           struct ordering ordering;
245           struct variable **keep_vars;
246           int nv;
247           int counter;
248           int i;
249
250           if (already_encountered & 4)
251             {
252               msg (SE, _("KEEP subcommand may be given at most once.  It may not"
253                    "be given in conjunction with the DROP subcommand."));
254               goto lossage;
255             }
256           already_encountered |= 4;
257
258           lex_match ('=');
259           if (!parse_variables (&default_dict, &keep_vars, &nv, PV_NONE))
260             goto lossage;
261
262           /* Transform the list of variables to keep into a list of
263              variables to drop.  First sort the keep list, then figure
264              out which variables are missing. */
265           ordering.forward = ordering.positional = 1;
266           sort (keep_vars, nv, sizeof *keep_vars,
267                  compare_variables_given_ordering, &ordering);
268
269           vm.n_drop = default_dict.nvar - nv;
270
271           counter = 0;
272           for (i = 0; i < nv; i++)
273             {
274               while (counter < keep_vars[i]->index)
275                 default_dict.var[counter++]->p.mfv.drop_this_var = 1;
276               default_dict.var[counter++]->p.mfv.drop_this_var = 0;
277             }
278           while (counter < nv)
279             default_dict.var[counter++]->p.mfv.drop_this_var = 1;
280
281           free (keep_vars);
282         }
283       else if (lex_match_id ("DROP"))
284         {
285           struct variable **drop_vars;
286           int nv;
287           int i;
288
289           if (already_encountered & 4)
290             {
291               msg (SE, _("DROP subcommand may be given at most once.  It may not"
292                    "be given in conjunction with the KEEP subcommand."));
293               goto lossage;
294             }
295           already_encountered |= 4;
296
297           lex_match ('=');
298           if (!parse_variables (&default_dict, &drop_vars, &nv, PV_NONE))
299             goto lossage;
300           for (i = 0; i < default_dict.nvar; i++)
301             default_dict.var[i]->p.mfv.drop_this_var = 0;
302           for (i = 0; i < nv; i++)
303             drop_vars[i]->p.mfv.drop_this_var = 1;
304           vm.n_drop = nv;
305           free (drop_vars);
306         }
307       else if (lex_match_id ("MAP"))
308         {
309           struct dictionary *new_dict = rearrange_dict (&default_dict, &vm, 0);
310           if (!new_dict)
311             goto lossage;
312           /* FIXME: display new dictionary. */
313         }
314       else
315         {
316           if (token == T_ID)
317             msg (SE, _("Unrecognized subcommand name `%s'."), tokid);
318           else
319             msg (SE, _("Subcommand name expected."));
320           goto lossage;
321         }
322
323       if (token == '.')
324         break;
325       if (token != '/')
326         {
327           msg (SE, _("`/' or `.' expected."));
328           goto lossage;
329         }
330       lex_get ();
331     }
332
333   {
334     int i;
335
336     if (already_encountered & (1 | 4))
337       {
338         /* Read the data. */
339         procedure (NULL, NULL, NULL);
340       }
341
342     if (NULL == rearrange_dict (&default_dict, &vm, 1))
343       goto lossage;
344
345     free (vm.reorder_list);
346     free (vm.old_names);
347     for (i = 0; i < vm.n_rename; i++)
348       free (vm.new_names[i]);
349     free (vm.new_names);
350
351     return CMD_SUCCESS;
352   }
353
354 lossage:
355   {
356     int i;
357
358     free (vm.reorder_list);
359     free (vm.old_names);
360     for (i = 0; i < vm.n_rename; i++)
361       free (vm.new_names[i]);
362     free (vm.new_names);
363     return CMD_FAILURE;
364   }
365 }
366
367 /* Compares A and B according to the settings in
368    ORDERING, returning a strcmp()-type result. */
369 static int
370 compare_variables_given_ordering (const void *a_, const void *b_,
371                                   void *ordering_)
372 {
373   struct variable *const *pa = a_;
374   struct variable *const *pb = b_;
375   const struct variable *a = *pa;
376   const struct variable *b = *pb;
377   const struct ordering *ordering = ordering_;
378
379   int result;
380   if (ordering->positional)
381     result = a->index < b->index ? -1 : a->index > b->index;
382   else
383     result = strcmp (a->name, b->name);
384   if (!ordering->forward)
385     result = -result;
386   return result;
387 }
388
389 /* (Possibly) rearranges variables and (possibly) removes some
390    variables and (possibly) renames some more variables in dictionary
391    D.  There are two modes of operation, distinguished by the value of
392    PERMANENT:
393
394    If PERMANENT is nonzero, then the dictionary is modified in place.
395    Returns the new dictionary on success or NULL if there would have
396    been duplicate variable names in the resultant dictionary (in this
397    case the dictionary has not been modified).
398
399    If PERMANENT is zero, then the dictionary is copied to a new
400    dictionary structure that retains most of the same deep structure
401    as D.  The p.mfv.new_name field of each variable is set to what
402    would become the variable's new name if PERMANENT were nonzero.
403    Returns the new dictionary. */
404 static struct dictionary *
405 rearrange_dict (struct dictionary * d, struct var_modification * vm, int permanent)
406 {
407   struct dictionary *n;
408
409   struct variable **save_var;
410
411   /* Linked list of variables for deletion. */
412   struct variable *head, *tail;
413
414   int i;
415
416   /* First decide what dictionary to modify. */
417   if (permanent == 0)
418     {
419       n = xmalloc (sizeof *n);
420       *n = *d;
421     }
422   else
423     n = d;
424   save_var = n->var;
425
426   /* Perform first half of renaming. */
427   if (permanent)
428     {
429       for (i = 0; i < d->nvar; i++)
430         d->var[i]->p.mfv.new_name[0] = 0;
431       d->var = xmalloc (sizeof *d->var * d->nvar);
432     }
433   else
434     for (i = 0; i < d->nvar; i++)
435       strcpy (d->var[i]->p.mfv.new_name, d->var[i]->name);
436   for (i = 0; i < vm->n_rename; i++)
437     strcpy (vm->old_names[i]->p.mfv.new_name, vm->new_names[i]);
438
439   /* Copy the variable list, reordering if appropriate. */
440   if (vm->reorder_list)
441     memcpy (n->var, vm->reorder_list, sizeof *n->var * d->nvar);
442   else if (!permanent)
443     for (i = 0; i < d->nvar; i++)
444       n->var[i] = d->var[i];
445
446   /* Drop all the unwanted variables. */
447   head = NULL;
448   if (vm->n_drop)
449     {
450       int j;
451
452       n->nvar = d->nvar - vm->n_drop;
453       for (i = j = 0; i < n->nvar; i++)
454         {
455           while (n->var[j]->p.mfv.drop_this_var != 0)
456             {
457               if (permanent)
458                 {
459                   /* If this is permanent, then we have to keep a list
460                      of all the dropped variables because they must be
461                      free()'d, but can't be until we know that there
462                      aren't any duplicate variable names. */
463                   if (head)
464                     tail = tail->p.mfv.next = n->var[j];
465                   else
466                     head = tail = n->var[j];
467                 }
468               j++;
469             }
470           n->var[i] = n->var[j++];
471         }
472       if (permanent)
473         tail->p.mfv.next = NULL;
474     }
475
476   /* Check for duplicate variable names if appropriate. */
477   if (permanent && vm->n_rename)
478     {
479       struct ordering ordering;
480       struct variable **v;
481
482       if (vm->reorder_list)
483         v = vm->reorder_list;   /* Reuse old buffer if possible. */
484       else
485         v = xmalloc (sizeof *v * n->nvar);
486       memcpy (v, n->var, sizeof *v * n->nvar);
487       ordering.forward = 1;
488       ordering.positional = 0;
489       sort (v, n->nvar, sizeof *v,
490             compare_variables_given_ordering, &ordering);
491       for (i = 1; i < n->nvar; i++)
492         if (!strcmp (n->var[i]->name, n->var[i - 1]->name))
493           {
494             msg (SE, _("Duplicate variable name `%s' after renaming."),
495                  n->var[i]->name);
496             if (vm->reorder_list == NULL)
497               free (v);
498             n->var = save_var;
499             return NULL;
500           }
501       if (vm->reorder_list == NULL)
502         free (v);
503     }
504
505   /* Delete unwanted variables and finalize renaming if
506      appropriate. */
507   if (permanent)
508     {
509       /* Delete dropped variables for good. */
510       for (; head; head = tail)
511         {
512           tail = head->p.mfv.next;
513           clear_variable (n, head);
514           free (head);
515         }
516
517       /* Remove names from all renamed variables. */
518       head = NULL;
519       for (i = 0; i < n->nvar; i++)
520         if (n->var[i]->p.mfv.new_name[0])
521           {
522             hsh_force_delete (n->name_tab, n->var[i]);
523             if (head)
524               tail = tail->p.mfv.next = n->var[i];
525             else
526               head = tail = n->var[i];
527           }
528       if (head)
529         tail->p.mfv.next = NULL;
530
531       /* Put names onto renamed variables. */
532       for (; head; head = head->p.mfv.next)
533         {
534           strcpy (head->name, head->p.mfv.new_name);
535           hsh_force_insert (n->name_tab, head);
536         }
537       free (save_var);
538
539       /* As a final step the index fields must be redone. */
540       for (i = 0; i < n->nvar; i++)
541         n->var[i]->index = i;
542     }
543
544   return n;
545 }