src/language/lexer/variable-parser.c

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