pintos-os.org Git - pspp/blob - src/language/lexer/variable-parser.c

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