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