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