Fix memory leak in data_in
[pspp] / src / language / lexer / variable-parser.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-9, 2000, 2009, 2010 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 #include "language/lexer/variable-parser.h"
20
21 #include <ctype.h>
22 #include <stdbool.h>
23 #include <stdlib.h>
24
25 #include "data/dictionary.h"
26 #include "data/procedure.h"
27 #include "data/variable.h"
28 #include "language/lexer/lexer.h"
29 #include "libpspp/assertion.h"
30 #include "libpspp/cast.h"
31 #include "libpspp/hash-functions.h"
32 #include "libpspp/hmapx.h"
33 #include "libpspp/message.h"
34 #include "libpspp/misc.h"
35 #include "libpspp/pool.h"
36 #include "libpspp/str.h"
37 #include "libpspp/stringi-set.h"
38
39 #include "gl/xalloc.h"
40
41 #include "gettext.h"
42 #define _(msgid) gettext (msgid)
43
44 static struct variable * var_set_get_var (const struct var_set *, size_t );
45
46 static struct variable *var_set_lookup_var (const struct var_set *,
47                                             const char *);
48
49 static bool var_set_lookup_var_idx (const struct var_set *, const char *,
50                                     size_t *);
51
52
53
54 /* Parses a name as a variable within VS.  Sets *IDX to the
55    variable's index and returns true if successful.  On failure
56    emits an error message and returns false. */
57 static bool
58 parse_vs_variable_idx (struct lexer *lexer, const struct var_set *vs,
59                 size_t *idx)
60 {
61   assert (idx != NULL);
62
63   if (lex_token (lexer) != T_ID)
64     {
65       lex_error (lexer, _("expecting variable name"));
66       return false;
67     }
68   else if (var_set_lookup_var_idx (vs, lex_tokid (lexer), idx))
69     {
70       lex_get (lexer);
71       return true;
72     }
73   else
74     {
75       msg (SE, _("%s is not a variable name."), lex_tokid (lexer));
76       return false;
77     }
78 }
79
80 /* Parses a name as a variable within VS and returns the variable
81    if successful.  On failure emits an error message and returns
82    a null pointer. */
83 static struct variable *
84 parse_vs_variable (struct lexer *lexer, const struct var_set *vs)
85 {
86   size_t idx;
87   return parse_vs_variable_idx (lexer, vs, &idx) ? var_set_get_var (vs, idx) : NULL;
88 }
89
90 /* Parses a variable name in dictionary D and returns the
91    variable if successful.  On failure emits an error message and
92    returns a null pointer. */
93 struct variable *
94 parse_variable (struct lexer *lexer, const struct dictionary *d)
95 {
96   struct var_set *vs = var_set_create_from_dict (d);
97   struct variable *var = parse_vs_variable (lexer, vs);
98   var_set_destroy (vs);
99   return var;
100 }
101
102 /* Parses a set of variables from dictionary D given options
103    OPTS.  Resulting list of variables stored in *VAR and the
104    number of variables into *CNT.  Returns true only if
105    successful. */
106 bool
107 parse_variables (struct lexer *lexer, const struct dictionary *d,
108                         struct variable ***var,
109                         size_t *cnt, int opts)
110 {
111   struct var_set *vs;
112   int success;
113
114   assert (d != NULL);
115   assert (var != NULL);
116   assert (cnt != NULL);
117
118   vs = var_set_create_from_dict (d);
119   success = parse_var_set_vars (lexer, vs, var, cnt, opts);
120   var_set_destroy (vs);
121   return success;
122 }
123
124 /* Parses a set of variables from dictionary D given options
125    OPTS.  Resulting list of variables stored in *VARS and the
126    number of variables into *VAR_CNT.  Returns true only if
127    successful.  Same behavior as parse_variables, except that all
128    allocations are taken from the given POOL. */
129 bool
130 parse_variables_pool (struct lexer *lexer, struct pool *pool,
131                 const struct dictionary *dict,
132                 struct variable ***vars, size_t *var_cnt, int opts)
133 {
134   int retval;
135
136   /* PV_APPEND is unsafe because parse_variables would free the
137      existing names on failure, but those names are presumably
138      already in the pool, which would attempt to re-free it
139      later. */
140   assert (!(opts & PV_APPEND));
141
142   retval = parse_variables (lexer, dict, vars, var_cnt, opts);
143   if (retval)
144     pool_register (pool, free, *vars);
145   return retval;
146 }
147
148 /* Parses a variable name from VS.  If successful, sets *IDX to
149    the variable's index in VS, *CLASS to the variable's
150    dictionary class, and returns true.  Returns false on
151    failure. */
152 static bool
153 parse_var_idx_class (struct lexer *lexer, const struct var_set *vs,
154                         size_t *idx,
155                         enum dict_class *class)
156 {
157   if (!parse_vs_variable_idx (lexer, vs, idx))
158     return false;
159
160   *class = dict_class_from_id (var_get_name (var_set_get_var (vs, *idx)));
161   return true;
162 }
163
164 /* Add the variable from VS with index IDX to the list of
165    variables V that has *NV elements and room for *MV.
166    Uses and updates INCLUDED to avoid duplicates if indicated by
167    PV_OPTS, which also affects what variables are allowed in
168    appropriate ways. */
169 static void
170 add_variable (struct variable ***v, size_t *nv, size_t *mv,
171               char *included, int pv_opts,
172               const struct var_set *vs, size_t idx)
173 {
174   struct variable *add = var_set_get_var (vs, idx);
175   const char *add_name = var_get_name (add);
176
177   if ((pv_opts & PV_NUMERIC) && !var_is_numeric (add))
178     msg (SW, _("%s is not a numeric variable.  It will not be "
179                "included in the variable list."), add_name);
180   else if ((pv_opts & PV_STRING) && !var_is_alpha (add))
181     msg (SE, _("%s is not a string variable.  It will not be "
182                "included in the variable list."), add_name);
183   else if ((pv_opts & PV_NO_SCRATCH)
184            && dict_class_from_id (add_name) == DC_SCRATCH)
185     msg (SE, _("Scratch variables (such as %s) are not allowed "
186                "here."), add_name);
187   else if ((pv_opts & (PV_SAME_TYPE | PV_SAME_WIDTH)) && *nv
188            && var_get_type (add) != var_get_type ((*v)[0]))
189     msg (SE, _("%s and %s are not the same type.  All variables in "
190                "this variable list must be of the same type.  %s "
191                "will be omitted from the list."),
192          var_get_name ((*v)[0]), add_name, add_name);
193   else if ((pv_opts & PV_SAME_WIDTH) && *nv
194            && var_get_width (add) != var_get_width ((*v)[0]))
195     msg (SE, _("%s and %s are string variables with different widths.  "
196                "All variables in this variable list must have the "
197                "same width.  %s will be omitted from the list."),
198          var_get_name ((*v)[0]), add_name, add_name);
199   else if ((pv_opts & PV_NO_DUPLICATE) && included[idx])
200     msg (SE, _("Variable %s appears twice in variable list."), add_name);
201   else if ((pv_opts & PV_DUPLICATE) || !included[idx])
202     {
203       if (*nv >= *mv)
204         {
205           *mv = 2 * (*nv + 1);
206           *v = xnrealloc (*v, *mv, sizeof **v);
207         }
208       (*v)[(*nv)++] = add;
209       if (included != NULL)
210         included[idx] = 1;
211     }
212 }
213
214 /* Adds the variables in VS with indexes FIRST_IDX through
215    LAST_IDX, inclusive, to the list of variables V that has *NV
216    elements and room for *MV.  Uses and updates INCLUDED to avoid
217    duplicates if indicated by PV_OPTS, which also affects what
218    variables are allowed in appropriate ways. */
219 static void
220 add_variables (struct variable ***v, size_t *nv, size_t *mv, char *included,
221                int pv_opts,
222                const struct var_set *vs, int first_idx, int last_idx,
223                enum dict_class class)
224 {
225   size_t i;
226
227   for (i = first_idx; i <= last_idx; i++)
228     if (dict_class_from_id (var_get_name (var_set_get_var (vs, i))) == class)
229       add_variable (v, nv, mv, included, pv_opts, vs, i);
230 }
231
232 /* Note that if parse_variables() returns false, *v is free()'d.
233    Conversely, if parse_variables() returns true, then *nv is
234    nonzero and *v is non-NULL. */
235 bool
236 parse_var_set_vars (struct lexer *lexer, const struct var_set *vs,
237                     struct variable ***v, size_t *nv,
238                     int pv_opts)
239 {
240   size_t mv;
241   char *included;
242
243   assert (vs != NULL);
244   assert (v != NULL);
245   assert (nv != NULL);
246
247   /* At most one of PV_NUMERIC, PV_STRING, PV_SAME_TYPE,
248      PV_SAME_WIDTH may be specified. */
249   assert (((pv_opts & PV_NUMERIC) != 0)
250           + ((pv_opts & PV_STRING) != 0)
251           + ((pv_opts & PV_SAME_TYPE) != 0)
252           + ((pv_opts & PV_SAME_WIDTH) != 0) <= 1);
253
254   /* PV_DUPLICATE and PV_NO_DUPLICATE are incompatible. */
255   assert (!(pv_opts & PV_DUPLICATE) || !(pv_opts & PV_NO_DUPLICATE));
256
257   if (!(pv_opts & PV_APPEND))
258     {
259       *v = NULL;
260       *nv = 0;
261       mv = 0;
262     }
263   else
264     mv = *nv;
265
266   if (!(pv_opts & PV_DUPLICATE))
267     {
268       size_t i;
269
270       included = xcalloc (var_set_get_cnt (vs), sizeof *included);
271       for (i = 0; i < *nv; i++)
272         {
273           size_t index;
274           if (!var_set_lookup_var_idx (vs, var_get_name ((*v)[i]), &index))
275             NOT_REACHED ();
276           included[index] = 1;
277         }
278     }
279   else
280     included = NULL;
281
282   do
283     {
284       if (lex_match (lexer, T_ALL))
285         add_variables (v, nv, &mv, included, pv_opts,
286                        vs, 0, var_set_get_cnt (vs) - 1, DC_ORDINARY);
287       else
288         {
289           enum dict_class class;
290           size_t first_idx;
291
292           if (!parse_var_idx_class (lexer, vs, &first_idx, &class))
293             goto fail;
294
295           if (!lex_match (lexer, T_TO))
296             add_variable (v, nv, &mv, included, pv_opts, vs, first_idx);
297           else
298             {
299               size_t last_idx;
300               enum dict_class last_class;
301               struct variable *first_var, *last_var;
302
303               if (!parse_var_idx_class (lexer, vs, &last_idx, &last_class))
304                 goto fail;
305
306               first_var = var_set_get_var (vs, first_idx);
307               last_var = var_set_get_var (vs, last_idx);
308
309               if (last_idx < first_idx)
310                 {
311                   const char *first_name = var_get_name (first_var);
312                   const char *last_name = var_get_name (last_var);
313                   msg (SE, _("%s TO %s is not valid syntax since %s "
314                              "precedes %s in the dictionary."),
315                        first_name, last_name, first_name, last_name);
316                   goto fail;
317                 }
318
319               if (class != last_class)
320                 {
321                   msg (SE, _("When using the TO keyword to specify several "
322                              "variables, both variables must be from "
323                              "the same variable dictionaries, of either "
324                              "ordinary, scratch, or system variables.  "
325                              "%s is a %s variable, whereas %s is %s."),
326                        var_get_name (first_var), dict_class_to_name (class),
327                        var_get_name (last_var),
328                        dict_class_to_name (last_class));
329                   goto fail;
330                 }
331
332               add_variables (v, nv, &mv, included, pv_opts,
333                              vs, first_idx, last_idx, class);
334             }
335         }
336
337       if (pv_opts & PV_SINGLE)
338         break;
339       lex_match (lexer, ',');
340     }
341   while (lex_token (lexer) == T_ALL
342          || (lex_token (lexer) == T_ID && var_set_lookup_var (vs, lex_tokid (lexer)) != NULL));
343
344   if (*nv == 0)
345     goto fail;
346
347   free (included);
348   return 1;
349
350 fail:
351   free (included);
352   free (*v);
353   *v = NULL;
354   *nv = 0;
355   return 0;
356 }
357
358 /* Extracts a numeric suffix from variable name S, copying it
359    into string R.  Sets *D to the length of R and *N to its
360    value. */
361 static int
362 extract_num (char *s, char *r, int *n, int *d)
363 {
364   char *cp;
365
366   /* Find first digit. */
367   cp = s + strlen (s) - 1;
368   while (isdigit ((unsigned char) *cp) && cp > s)
369     cp--;
370   cp++;
371
372   /* Extract root. */
373   strncpy (r, s, cp - s);
374   r[cp - s] = 0;
375
376   /* Count initial zeros. */
377   *n = *d = 0;
378   while (*cp == '0')
379     {
380       (*d)++;
381       cp++;
382     }
383
384   /* Extract value. */
385   while (isdigit ((unsigned char) *cp))
386     {
387       (*d)++;
388       *n = (*n * 10) + (*cp - '0');
389       cp++;
390     }
391
392   /* Sanity check. */
393   if (*n == 0 && *d == 0)
394     {
395       msg (SE, _("incorrect use of TO convention"));
396       return 0;
397     }
398   return 1;
399 }
400
401 /* Parses a list of variable names according to the DATA LIST version
402    of the TO convention.  */
403 bool
404 parse_DATA_LIST_vars (struct lexer *lexer, char ***names,
405                       size_t *nnames, int pv_opts)
406 {
407   int n1, n2;
408   int d1, d2;
409   int n;
410   size_t nvar, mvar;
411   char name1[VAR_NAME_LEN + 1], name2[VAR_NAME_LEN + 1];
412   char root1[VAR_NAME_LEN + 1], root2[VAR_NAME_LEN + 1];
413   struct stringi_set set;
414   int success = 0;
415
416   assert (names != NULL);
417   assert (nnames != NULL);
418   assert ((pv_opts & ~(PV_APPEND | PV_SINGLE
419                        | PV_NO_SCRATCH | PV_NO_DUPLICATE)) == 0);
420   stringi_set_init (&set);
421
422   if (pv_opts & PV_APPEND)
423     {
424       nvar = mvar = *nnames;
425
426       if (pv_opts & PV_NO_DUPLICATE)
427         {
428           size_t i;
429
430           for (i = 0; i < nvar; i++)
431             stringi_set_insert (&set, (*names)[i]);
432         }
433     }
434   else
435     {
436       nvar = mvar = 0;
437       *names = NULL;
438     }
439
440   do
441     {
442       if (lex_token (lexer) != T_ID)
443         {
444           lex_error (lexer, "expecting variable name");
445           goto fail;
446         }
447       if (dict_class_from_id (lex_tokid (lexer)) == DC_SCRATCH
448           && (pv_opts & PV_NO_SCRATCH))
449         {
450           msg (SE, _("Scratch variables not allowed here."));
451           goto fail;
452         }
453       strcpy (name1, lex_tokid (lexer));
454       lex_get (lexer);
455       if (lex_token (lexer) == T_TO)
456         {
457           lex_get (lexer);
458           if (lex_token (lexer) != T_ID)
459             {
460               lex_error (lexer, "expecting variable name");
461               goto fail;
462             }
463           strcpy (name2, lex_tokid (lexer));
464           lex_get (lexer);
465
466           if (!extract_num (name1, root1, &n1, &d1)
467               || !extract_num (name2, root2, &n2, &d2))
468             goto fail;
469
470           if (strcasecmp (root1, root2))
471             {
472               msg (SE, _("Prefixes don't match in use of TO convention."));
473               goto fail;
474             }
475           if (n1 > n2)
476             {
477               msg (SE, _("Bad bounds in use of TO convention."));
478               goto fail;
479             }
480           if (d2 > d1)
481             d2 = d1;
482
483           if (mvar < nvar + (n2 - n1 + 1))
484             {
485               mvar += ROUND_UP (n2 - n1 + 1, 16);
486               *names = xnrealloc (*names, mvar, sizeof **names);
487             }
488
489           for (n = n1; n <= n2; n++)
490             {
491               char name[VAR_NAME_LEN + 1];
492               sprintf (name, "%s%0*d", root1, d1, n);
493
494               if (pv_opts & PV_NO_DUPLICATE && !stringi_set_insert (&set, name))
495                 {
496                   msg (SE, _("Variable %s appears twice in variable list."),
497                        name);
498                   goto fail;
499                 }
500               (*names)[nvar] = xstrdup (name);
501               nvar++;
502             }
503         }
504       else
505         {
506           if (nvar >= mvar)
507             {
508               mvar += 16;
509               *names = xnrealloc (*names, mvar, sizeof **names);
510             }
511           (*names)[nvar++] = xstrdup (name1);
512         }
513
514       lex_match (lexer, ',');
515
516       if (pv_opts & PV_SINGLE)
517         break;
518     }
519   while (lex_token (lexer) == T_ID);
520   success = 1;
521
522 fail:
523   *nnames = nvar;
524   stringi_set_destroy (&set);
525   if (!success)
526     {
527       int i;
528       for (i = 0; i < nvar; i++)
529         free ((*names)[i]);
530       free (*names);
531       *names = NULL;
532       *nnames = 0;
533     }
534   return success;
535 }
536
537 /* Registers each of the NAMES[0...NNAMES - 1] in POOL, as well
538    as NAMES itself. */
539 static void
540 register_vars_pool (struct pool *pool, char **names, size_t nnames)
541 {
542   size_t i;
543
544   for (i = 0; i < nnames; i++)
545     pool_register (pool, free, names[i]);
546   pool_register (pool, free, names);
547 }
548
549 /* Parses a list of variable names according to the DATA LIST
550    version of the TO convention.  Same args as
551    parse_DATA_LIST_vars(), except that all allocations are taken
552    from the given POOL. */
553 bool
554 parse_DATA_LIST_vars_pool (struct lexer *lexer, struct pool *pool,
555                            char ***names, size_t *nnames, int pv_opts)
556 {
557   int retval;
558
559   /* PV_APPEND is unsafe because parse_DATA_LIST_vars would free
560      the existing names on failure, but those names are
561      presumably already in the pool, which would attempt to
562      re-free it later. */
563   assert (!(pv_opts & PV_APPEND));
564
565   retval = parse_DATA_LIST_vars (lexer, names, nnames, pv_opts);
566   if (retval)
567     register_vars_pool (pool, *names, *nnames);
568   return retval;
569 }
570
571 /* Parses a list of variables where some of the variables may be
572    existing and the rest are to be created.  Same args as
573    parse_DATA_LIST_vars(). */
574 bool
575 parse_mixed_vars (struct lexer *lexer, const struct dictionary *dict,
576                   char ***names, size_t *nnames, int pv_opts)
577 {
578   size_t i;
579
580   assert (names != NULL);
581   assert (nnames != NULL);
582   assert ((pv_opts & ~PV_APPEND) == 0);
583
584   if (!(pv_opts & PV_APPEND))
585     {
586       *names = NULL;
587       *nnames = 0;
588     }
589   while (lex_token (lexer) == T_ID || lex_token (lexer) == T_ALL)
590     {
591       if (lex_token (lexer) == T_ALL || dict_lookup_var (dict, lex_tokid (lexer)) != NULL)
592         {
593           struct variable **v;
594           size_t nv;
595
596           if (!parse_variables (lexer, dict, &v, &nv, PV_NONE))
597             goto fail;
598           *names = xnrealloc (*names, *nnames + nv, sizeof **names);
599           for (i = 0; i < nv; i++)
600             (*names)[*nnames + i] = xstrdup (var_get_name (v[i]));
601           free (v);
602           *nnames += nv;
603         }
604       else if (!parse_DATA_LIST_vars (lexer, names, nnames, PV_APPEND))
605         goto fail;
606     }
607   return 1;
608
609 fail:
610   for (i = 0; i < *nnames; i++)
611     free ((*names)[i]);
612   free (*names);
613   *names = NULL;
614   *nnames = 0;
615   return 0;
616 }
617
618 /* Parses a list of variables where some of the variables may be
619    existing and the rest are to be created.  Same args as
620    parse_mixed_vars(), except that all allocations are taken
621    from the given POOL. */
622 bool
623 parse_mixed_vars_pool (struct lexer *lexer, const struct dictionary *dict, struct pool *pool,
624                        char ***names, size_t *nnames, int pv_opts)
625 {
626   int retval;
627
628   /* PV_APPEND is unsafe because parse_mixed_vars_pool would free
629      the existing names on failure, but those names are
630      presumably already in the pool, which would attempt to
631      re-free it later. */
632   assert (!(pv_opts & PV_APPEND));
633
634   retval = parse_mixed_vars (lexer, dict, names, nnames, pv_opts);
635   if (retval)
636     register_vars_pool (pool, *names, *nnames);
637   return retval;
638 }
639 \f
640 /* A set of variables. */
641 struct var_set
642   {
643     size_t (*get_cnt) (const struct var_set *);
644     struct variable *(*get_var) (const struct var_set *, size_t idx);
645     bool (*lookup_var_idx) (const struct var_set *, const char *, size_t *);
646     void (*destroy) (struct var_set *);
647     void *aux;
648   };
649
650 /* Returns the number of variables in VS. */
651 size_t
652 var_set_get_cnt (const struct var_set *vs)
653 {
654   assert (vs != NULL);
655
656   return vs->get_cnt (vs);
657 }
658
659 /* Return variable with index IDX in VS.
660    IDX must be less than the number of variables in VS. */
661 static struct variable *
662 var_set_get_var (const struct var_set *vs, size_t idx)
663 {
664   assert (vs != NULL);
665   assert (idx < var_set_get_cnt (vs));
666
667   return vs->get_var (vs, idx);
668 }
669
670 /* Returns the variable in VS named NAME, or a null pointer if VS
671    contains no variable with that name. */
672 struct variable *
673 var_set_lookup_var (const struct var_set *vs, const char *name)
674 {
675   size_t idx;
676   return (var_set_lookup_var_idx (vs, name, &idx)
677           ? var_set_get_var (vs, idx)
678           : NULL);
679 }
680
681 /* If VS contains a variable named NAME, sets *IDX to its index
682    and returns true.  Otherwise, returns false. */
683 bool
684 var_set_lookup_var_idx (const struct var_set *vs, const char *name,
685                         size_t *idx)
686 {
687   assert (vs != NULL);
688   assert (name != NULL);
689   assert (strlen (name) <= VAR_NAME_LEN);
690
691   return vs->lookup_var_idx (vs, name, idx);
692 }
693
694 /* Destroys VS. */
695 void
696 var_set_destroy (struct var_set *vs)
697 {
698   if (vs != NULL)
699     vs->destroy (vs);
700 }
701 \f
702 /* Returns the number of variables in VS. */
703 static size_t
704 dict_var_set_get_cnt (const struct var_set *vs)
705 {
706   struct dictionary *d = vs->aux;
707
708   return dict_get_var_cnt (d);
709 }
710
711 /* Return variable with index IDX in VS.
712    IDX must be less than the number of variables in VS. */
713 static struct variable *
714 dict_var_set_get_var (const struct var_set *vs, size_t idx)
715 {
716   struct dictionary *d = vs->aux;
717
718   return dict_get_var (d, idx);
719 }
720
721 /* If VS contains a variable named NAME, sets *IDX to its index
722    and returns true.  Otherwise, returns false. */
723 static bool
724 dict_var_set_lookup_var_idx (const struct var_set *vs, const char *name,
725                              size_t *idx)
726 {
727   struct dictionary *d = vs->aux;
728   struct variable *v = dict_lookup_var (d, name);
729   if (v != NULL)
730     {
731       *idx = var_get_dict_index (v);
732       return true;
733     }
734   else
735     return false;
736 }
737
738 /* Destroys VS. */
739 static void
740 dict_var_set_destroy (struct var_set *vs)
741 {
742   free (vs);
743 }
744
745 /* Returns a variable set based on D. */
746 struct var_set *
747 var_set_create_from_dict (const struct dictionary *d)
748 {
749   struct var_set *vs = xmalloc (sizeof *vs);
750   vs->get_cnt = dict_var_set_get_cnt;
751   vs->get_var = dict_var_set_get_var;
752   vs->lookup_var_idx = dict_var_set_lookup_var_idx;
753   vs->destroy = dict_var_set_destroy;
754   vs->aux = (void *) d;
755   return vs;
756 }
757 \f
758 /* A variable set based on an array. */
759 struct array_var_set
760   {
761     struct variable *const *var;/* Array of variables. */
762     size_t var_cnt;             /* Number of elements in var. */
763     struct hmapx vars_by_name;  /* Variables hashed by name. */
764   };
765
766 /* Returns the number of variables in VS. */
767 static size_t
768 array_var_set_get_cnt (const struct var_set *vs)
769 {
770   struct array_var_set *avs = vs->aux;
771
772   return avs->var_cnt;
773 }
774
775 /* Return variable with index IDX in VS.
776    IDX must be less than the number of variables in VS. */
777 static struct variable *
778 array_var_set_get_var (const struct var_set *vs, size_t idx)
779 {
780   struct array_var_set *avs = vs->aux;
781
782   return CONST_CAST (struct variable *, avs->var[idx]);
783 }
784
785 /* If VS contains a variable named NAME, sets *IDX to its index
786    and returns true.  Otherwise, returns false. */
787 static bool
788 array_var_set_lookup_var_idx (const struct var_set *vs, const char *name,
789                               size_t *idx)
790 {
791   struct array_var_set *avs = vs->aux;
792   struct hmapx_node *node;
793   struct variable **varp;
794
795   HMAPX_FOR_EACH_WITH_HASH (varp, node, hash_case_string (name, 0),
796                             &avs->vars_by_name)
797     if (!strcasecmp (name, var_get_name (*varp)))
798       {
799         *idx = varp - avs->var;
800         return true;
801       }
802
803   return false;
804 }
805
806 /* Destroys VS. */
807 static void
808 array_var_set_destroy (struct var_set *vs)
809 {
810   struct array_var_set *avs = vs->aux;
811
812   hmapx_destroy (&avs->vars_by_name);
813   free (avs);
814   free (vs);
815 }
816
817 /* Returns a variable set based on the VAR_CNT variables in VAR. */
818 struct var_set *
819 var_set_create_from_array (struct variable *const *var, size_t var_cnt)
820 {
821   struct var_set *vs;
822   struct array_var_set *avs;
823   size_t i;
824
825   vs = xmalloc (sizeof *vs);
826   vs->get_cnt = array_var_set_get_cnt;
827   vs->get_var = array_var_set_get_var;
828   vs->lookup_var_idx = array_var_set_lookup_var_idx;
829   vs->destroy = array_var_set_destroy;
830   vs->aux = avs = xmalloc (sizeof *avs);
831   avs->var = var;
832   avs->var_cnt = var_cnt;
833   hmapx_init (&avs->vars_by_name);
834   for (i = 0; i < var_cnt; i++)
835     {
836       const char *name = var_get_name (var[i]);
837       size_t idx;
838
839       if (array_var_set_lookup_var_idx (vs, name, &idx))
840         {
841           var_set_destroy (vs);
842           return NULL;
843         }
844       hmapx_insert (&avs->vars_by_name, CONST_CAST (void *, &avs->var[i]),
845                     hash_case_string (name, 0));
846     }
847
848   return vs;
849 }
850