X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Flexer%2Fvariable-parser.c;h=fbcc170d84b34b33f790a852a64853744f27e12c;hb=9ade26c8349b4434008c46cf09bc7473ec743972;hp=731873dca11b060ab353b10dbeb2f77ae5d64fca;hpb=b09b3485e28fba1b07980fd5a5eb6466486b5c07;p=pspp-builds.git
diff --git a/src/language/lexer/variable-parser.c b/src/language/lexer/variable-parser.c
index 731873dc..fbcc170d 100644
--- a/src/language/lexer/variable-parser.c
+++ b/src/language/lexer/variable-parser.c
@@ -1,67 +1,80 @@
-/* PSPP - computes sample statistics.
- Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
+/* PSPP - a program for statistical analysis.
+ Copyright (C) 1997-9, 2000, 2009, 2010, 2011 Free Software Foundation, Inc.
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License as
- published by the Free Software Foundation; either version 2 of the
- License, or (at your option) any later version.
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- 02110-1301, USA. */
+ along with this program. If not, see . */
#include
-#include
+#include "language/lexer/variable-parser.h"
#include
+#include
#include
#include
-#include "lexer.h"
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
+#include "data/dictionary.h"
+#include "data/procedure.h"
+#include "data/variable.h"
+#include "language/lexer/lexer.h"
+#include "libpspp/assertion.h"
+#include "libpspp/cast.h"
+#include "libpspp/hash-functions.h"
+#include "libpspp/hmapx.h"
+#include "libpspp/message.h"
+#include "libpspp/misc.h"
+#include "libpspp/pool.h"
+#include "libpspp/str.h"
+#include "libpspp/stringi-set.h"
+
+#include "gl/c-ctype.h"
+#include "gl/xalloc.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
+static struct variable * var_set_get_var (const struct var_set *, size_t );
+
+static struct variable *var_set_lookup_var (const struct var_set *,
+ const char *);
+
+static bool var_set_lookup_var_idx (const struct var_set *, const char *,
+ size_t *);
+
+
+
/* Parses a name as a variable within VS. Sets *IDX to the
variable's index and returns true if successful. On failure
emits an error message and returns false. */
static bool
-parse_vs_variable_idx (struct lexer *lexer, const struct var_set *vs,
+parse_vs_variable_idx (struct lexer *lexer, const struct var_set *vs,
size_t *idx)
{
assert (idx != NULL);
-
+
if (lex_token (lexer) != T_ID)
{
lex_error (lexer, _("expecting variable name"));
return false;
}
- else if (var_set_lookup_var_idx (vs, lex_tokid (lexer), idx))
+ else if (var_set_lookup_var_idx (vs, lex_tokcstr (lexer), idx))
{
lex_get (lexer);
return true;
}
- else
+ else
{
- msg (SE, _("%s is not a variable name."), lex_tokid (lexer));
+ msg (SE, _("%s is not a variable name."), lex_tokcstr (lexer));
return false;
}
}
@@ -80,7 +93,7 @@ parse_vs_variable (struct lexer *lexer, const struct var_set *vs)
variable if successful. On failure emits an error message and
returns a null pointer. */
struct variable *
-parse_variable (struct lexer *lexer, const struct dictionary *d)
+parse_variable (struct lexer *lexer, const struct dictionary *d)
{
struct var_set *vs = var_set_create_from_dict (d);
struct variable *var = parse_vs_variable (lexer, vs);
@@ -93,9 +106,9 @@ parse_variable (struct lexer *lexer, const struct dictionary *d)
number of variables into *CNT. Returns true only if
successful. */
bool
-parse_variables (struct lexer *lexer, const struct dictionary *d,
+parse_variables (struct lexer *lexer, const struct dictionary *d,
struct variable ***var,
- size_t *cnt, int opts)
+ size_t *cnt, int opts)
{
struct var_set *vs;
int success;
@@ -106,12 +119,6 @@ parse_variables (struct lexer *lexer, const struct dictionary *d,
vs = var_set_create_from_dict (d);
success = parse_var_set_vars (lexer, vs, var, cnt, opts);
- if ( success == 0 )
- {
- free ( *var ) ;
- *var = NULL;
- *cnt = 0;
- }
var_set_destroy (vs);
return success;
}
@@ -122,9 +129,9 @@ parse_variables (struct lexer *lexer, const struct dictionary *d,
successful. Same behavior as parse_variables, except that all
allocations are taken from the given POOL. */
bool
-parse_variables_pool (struct lexer *lexer, struct pool *pool,
+parse_variables_pool (struct lexer *lexer, struct pool *pool,
const struct dictionary *dict,
- struct variable ***vars, size_t *var_cnt, int opts)
+ struct variable ***vars, size_t *var_cnt, int opts)
{
int retval;
@@ -133,7 +140,7 @@ parse_variables_pool (struct lexer *lexer, struct pool *pool,
already in the pool, which would attempt to re-free it
later. */
assert (!(opts & PV_APPEND));
-
+
retval = parse_variables (lexer, dict, vars, var_cnt, opts);
if (retval)
pool_register (pool, free, *vars);
@@ -145,7 +152,7 @@ parse_variables_pool (struct lexer *lexer, struct pool *pool,
dictionary class, and returns true. Returns false on
failure. */
static bool
-parse_var_idx_class (struct lexer *lexer, const struct var_set *vs,
+parse_var_idx_class (struct lexer *lexer, const struct var_set *vs,
size_t *idx,
enum dict_class *class)
{
@@ -169,10 +176,10 @@ add_variable (struct variable ***v, size_t *nv, size_t *mv,
struct variable *add = var_set_get_var (vs, idx);
const char *add_name = var_get_name (add);
- if ((pv_opts & PV_NUMERIC) && !var_is_numeric (add))
+ if ((pv_opts & PV_NUMERIC) && !var_is_numeric (add))
msg (SW, _("%s is not a numeric variable. It will not be "
"included in the variable list."), add_name);
- else if ((pv_opts & PV_STRING) && !var_is_alpha (add))
+ else if ((pv_opts & PV_STRING) && !var_is_alpha (add))
msg (SE, _("%s is not a string variable. It will not be "
"included in the variable list."), add_name);
else if ((pv_opts & PV_NO_SCRATCH)
@@ -180,7 +187,7 @@ add_variable (struct variable ***v, size_t *nv, size_t *mv,
msg (SE, _("Scratch variables (such as %s) are not allowed "
"here."), add_name);
else if ((pv_opts & (PV_SAME_TYPE | PV_SAME_WIDTH)) && *nv
- && var_get_type (add) != var_get_type ((*v)[0]))
+ && var_get_type (add) != var_get_type ((*v)[0]))
msg (SE, _("%s and %s are not the same type. All variables in "
"this variable list must be of the same type. %s "
"will be omitted from the list."),
@@ -189,9 +196,9 @@ add_variable (struct variable ***v, size_t *nv, size_t *mv,
&& var_get_width (add) != var_get_width ((*v)[0]))
msg (SE, _("%s and %s are string variables with different widths. "
"All variables in this variable list must have the "
- "same width. %s will be omttied from the list."),
+ "same width. %s will be omitted from the list."),
var_get_name ((*v)[0]), add_name, add_name);
- else if ((pv_opts & PV_NO_DUPLICATE) && included[idx])
+ else if ((pv_opts & PV_NO_DUPLICATE) && included[idx])
msg (SE, _("Variable %s appears twice in variable list."), add_name);
else if ((pv_opts & PV_DUPLICATE) || !included[idx])
{
@@ -215,10 +222,10 @@ static void
add_variables (struct variable ***v, size_t *nv, size_t *mv, char *included,
int pv_opts,
const struct var_set *vs, int first_idx, int last_idx,
- enum dict_class class)
+ enum dict_class class)
{
size_t i;
-
+
for (i = first_idx; i <= last_idx; i++)
if (dict_class_from_id (var_get_name (var_set_get_var (vs, i))) == class)
add_variable (v, nv, mv, included, pv_opts, vs, i);
@@ -228,7 +235,7 @@ add_variables (struct variable ***v, size_t *nv, size_t *mv, char *included,
Conversely, if parse_variables() returns true, then *nv is
nonzero and *v is non-NULL. */
bool
-parse_var_set_vars (struct lexer *lexer, const struct var_set *vs,
+parse_var_set_vars (struct lexer *lexer, const struct var_set *vs,
struct variable ***v, size_t *nv,
int pv_opts)
{
@@ -261,14 +268,14 @@ parse_var_set_vars (struct lexer *lexer, const struct var_set *vs,
if (!(pv_opts & PV_DUPLICATE))
{
size_t i;
-
+
included = xcalloc (var_set_get_cnt (vs), sizeof *included);
- for (i = 0; i < *nv; i++)
+ for (i = 0; i < *nv; i++)
{
size_t index;
if (!var_set_lookup_var_idx (vs, var_get_name ((*v)[i]), &index))
NOT_REACHED ();
- included[index] = 1;
+ included[index] = 1;
}
}
else
@@ -279,7 +286,7 @@ parse_var_set_vars (struct lexer *lexer, const struct var_set *vs,
if (lex_match (lexer, T_ALL))
add_variables (v, nv, &mv, included, pv_opts,
vs, 0, var_set_get_cnt (vs) - 1, DC_ORDINARY);
- else
+ else
{
enum dict_class class;
size_t first_idx;
@@ -289,7 +296,7 @@ parse_var_set_vars (struct lexer *lexer, const struct var_set *vs,
if (!lex_match (lexer, T_TO))
add_variable (v, nv, &mv, included, pv_opts, vs, first_idx);
- else
+ else
{
size_t last_idx;
enum dict_class last_class;
@@ -326,16 +333,16 @@ parse_var_set_vars (struct lexer *lexer, const struct var_set *vs,
add_variables (v, nv, &mv, included, pv_opts,
vs, first_idx, last_idx, class);
- }
+ }
}
if (pv_opts & PV_SINGLE)
break;
- lex_match (lexer, ',');
+ lex_match (lexer, T_COMMA);
}
while (lex_token (lexer) == T_ALL
- || (lex_token (lexer) == T_ID && var_set_lookup_var (vs, lex_tokid (lexer)) != NULL));
-
+ || (lex_token (lexer) == T_ID && var_set_lookup_var (vs, lex_tokcstr (lexer)) != NULL));
+
if (*nv == 0)
goto fail;
@@ -350,163 +357,206 @@ fail:
return 0;
}
-/* Extracts a numeric suffix from variable name S, copying it
- into string R. Sets *D to the length of R and *N to its
- value. */
+/* Attempts to break UTF-8 encoded NAME into a root (whose contents are
+ arbitrary except that it does not end in a digit) followed by an integer
+ numeric suffix. On success, stores the value of the suffix into *NUMBERP,
+ the number of digits in the suffix into *N_DIGITSP, and returns the number
+ of bytes in the root. On failure, returns 0. */
static int
-extract_num (char *s, char *r, int *n, int *d)
+extract_numeric_suffix (const char *name,
+ unsigned long int *numberp, int *n_digitsp)
{
- char *cp;
-
- /* Find first digit. */
- cp = s + strlen (s) - 1;
- while (isdigit ((unsigned char) *cp) && cp > s)
- cp--;
- cp++;
+ size_t root_len, n_digits;
+ size_t i;
- /* Extract root. */
- strncpy (r, s, cp - s);
- r[cp - s] = 0;
+ /* Count length of root. */
+ root_len = 1; /* Valid identifier never starts with digit. */
+ for (i = 1; name[i] != '\0'; i++)
+ if (!c_isdigit (name[i]))
+ root_len = i + 1;
+ n_digits = i - root_len;
- /* Count initial zeros. */
- *n = *d = 0;
- while (*cp == '0')
+ if (n_digits == 0)
{
- (*d)++;
- cp++;
+ msg (SE, _("`%s' cannot be used with TO because it does not end in "
+ "a digit."), name);
+ return 0;
}
- /* Extract value. */
- while (isdigit ((unsigned char) *cp))
+ *numberp = strtoull (name + root_len, NULL, 10);
+ if (*numberp == ULONG_MAX)
{
- (*d)++;
- *n = (*n * 10) + (*cp - '0');
- cp++;
+ msg (SE, _("Numeric suffix on `%s' is larger than supported with TO."),
+ name);
+ return 0;
}
+ *n_digitsp = n_digits;
+ return root_len;
+}
- /* Sanity check. */
- if (*n == 0 && *d == 0)
+static bool
+add_var_name (char *name,
+ char ***names, size_t *n_vars, size_t *allocated_vars,
+ struct stringi_set *set, int pv_opts)
+{
+ if (pv_opts & PV_NO_DUPLICATE && !stringi_set_insert (set, name))
{
- msg (SE, _("incorrect use of TO convention"));
- return 0;
+ msg (SE, _("Variable %s appears twice in variable list."),
+ name);
+ return false;
}
- return 1;
+
+ if (*n_vars >= *allocated_vars)
+ *names = x2nrealloc (*names, allocated_vars, sizeof **names);
+ (*names)[(*n_vars)++] = name;
+ return true;
}
/* Parses a list of variable names according to the DATA LIST version
of the TO convention. */
bool
-parse_DATA_LIST_vars (struct lexer *lexer, char ***names, size_t *nnames, int pv_opts)
+parse_DATA_LIST_vars (struct lexer *lexer, const struct dictionary *dict,
+ char ***namesp, size_t *n_varsp, int pv_opts)
{
- int n1, n2;
- int d1, d2;
- int n;
- size_t nvar, mvar;
- char name1[LONG_NAME_LEN + 1], name2[LONG_NAME_LEN + 1];
- char root1[LONG_NAME_LEN + 1], root2[LONG_NAME_LEN + 1];
- int success = 0;
+ char **names;
+ size_t n_vars;
+ size_t allocated_vars;
+
+ struct stringi_set set;
+
+ char *name1 = NULL;
+ char *name2 = NULL;
+ bool ok = false;
- assert (names != NULL);
- assert (nnames != NULL);
assert ((pv_opts & ~(PV_APPEND | PV_SINGLE
| PV_NO_SCRATCH | PV_NO_DUPLICATE)) == 0);
- /* FIXME: PV_NO_DUPLICATE is not implemented. */
+ stringi_set_init (&set);
if (pv_opts & PV_APPEND)
- nvar = mvar = *nnames;
+ {
+ n_vars = allocated_vars = *n_varsp;
+ names = *namesp;
+
+ if (pv_opts & PV_NO_DUPLICATE)
+ {
+ size_t i;
+
+ for (i = 0; i < n_vars; i++)
+ stringi_set_insert (&set, names[i]);
+ }
+ }
else
{
- nvar = mvar = 0;
- *names = NULL;
+ n_vars = allocated_vars = 0;
+ names = NULL;
}
do
{
- if (lex_token (lexer) != T_ID)
+ if (lex_token (lexer) != T_ID
+ || !dict_id_is_valid (dict, lex_tokcstr (lexer), true))
{
lex_error (lexer, "expecting variable name");
- goto fail;
+ goto exit;
}
- if (dict_class_from_id (lex_tokid (lexer)) == DC_SCRATCH
+ if (dict_class_from_id (lex_tokcstr (lexer)) == DC_SCRATCH
&& (pv_opts & PV_NO_SCRATCH))
{
msg (SE, _("Scratch variables not allowed here."));
- goto fail;
+ goto exit;
}
- strcpy (name1, lex_tokid (lexer));
+ name1 = xstrdup (lex_tokcstr (lexer));
lex_get (lexer);
if (lex_token (lexer) == T_TO)
{
+ unsigned long int num1, num2;
+ int n_digits1, n_digits2;
+ int root_len1, root_len2;
+ unsigned long int number;
+
lex_get (lexer);
- if (lex_token (lexer) != T_ID)
+ if (lex_token (lexer) != T_ID
+ || !dict_id_is_valid (dict, lex_tokcstr (lexer), true))
{
lex_error (lexer, "expecting variable name");
- goto fail;
+ goto exit;
}
- strcpy (name2, lex_tokid (lexer));
+ name2 = xstrdup (lex_tokcstr (lexer));
lex_get (lexer);
- if (!extract_num (name1, root1, &n1, &d1)
- || !extract_num (name2, root2, &n2, &d2))
- goto fail;
+ root_len1 = extract_numeric_suffix (name1, &num1, &n_digits1);
+ if (root_len1 == 0)
+ goto exit;
+
+ root_len2 = extract_numeric_suffix (name2, &num2, &n_digits2);
+ if (root_len2 == 0)
+ goto exit;
- if (strcasecmp (root1, root2))
+ if (root_len1 != root_len2 || memcasecmp (name1, name2, root_len1))
{
msg (SE, _("Prefixes don't match in use of TO convention."));
- goto fail;
+ goto exit;
}
- if (n1 > n2)
+ if (num1 > num2)
{
msg (SE, _("Bad bounds in use of TO convention."));
- goto fail;
+ goto exit;
}
- if (d2 > d1)
- d2 = d1;
- if (mvar < nvar + (n2 - n1 + 1))
+ for (number = num1; number <= num2; number++)
{
- mvar += ROUND_UP (n2 - n1 + 1, 16);
- *names = xnrealloc (*names, mvar, sizeof **names);
+ char *name = xasprintf ("%.*s%0*lu",
+ root_len1, name1,
+ n_digits1, number);
+ if (!add_var_name (name, &names, &n_vars, &allocated_vars,
+ &set, pv_opts))
+ {
+ free (name);
+ goto exit;
+ }
}
- for (n = n1; n <= n2; n++)
- {
- char name[LONG_NAME_LEN + 1];
- sprintf (name, "%s%0*d", root1, d1, n);
- (*names)[nvar] = xstrdup (name);
- nvar++;
- }
+ free (name1);
+ name1 = NULL;
+ free (name2);
+ name2 = NULL;
}
else
{
- if (nvar >= mvar)
- {
- mvar += 16;
- *names = xnrealloc (*names, mvar, sizeof **names);
- }
- (*names)[nvar++] = xstrdup (name1);
+ if (!add_var_name (name1, &names, &n_vars, &allocated_vars,
+ &set, pv_opts))
+ goto exit;
+ name1 = NULL;
}
- lex_match (lexer, ',');
+ lex_match (lexer, T_COMMA);
if (pv_opts & PV_SINGLE)
break;
}
while (lex_token (lexer) == T_ID);
- success = 1;
+ ok = true;
-fail:
- *nnames = nvar;
- if (!success)
+exit:
+ stringi_set_destroy (&set);
+ if (ok)
+ {
+ *namesp = names;
+ *n_varsp = n_vars;
+ }
+ else
{
int i;
- for (i = 0; i < nvar; i++)
- free ((*names)[i]);
- free (*names);
- *names = NULL;
- *nnames = 0;
+ for (i = 0; i < n_vars; i++)
+ free (names[i]);
+ free (names);
+ *namesp = NULL;
+ *n_varsp = 0;
+
+ free (name1);
+ free (name2);
}
- return success;
+ return ok;
}
/* Registers each of the NAMES[0...NNAMES - 1] in POOL, as well
@@ -526,7 +576,8 @@ register_vars_pool (struct pool *pool, char **names, size_t nnames)
parse_DATA_LIST_vars(), except that all allocations are taken
from the given POOL. */
bool
-parse_DATA_LIST_vars_pool (struct lexer *lexer, struct pool *pool,
+parse_DATA_LIST_vars_pool (struct lexer *lexer, const struct dictionary *dict,
+ struct pool *pool,
char ***names, size_t *nnames, int pv_opts)
{
int retval;
@@ -536,8 +587,8 @@ parse_DATA_LIST_vars_pool (struct lexer *lexer, struct pool *pool,
presumably already in the pool, which would attempt to
re-free it later. */
assert (!(pv_opts & PV_APPEND));
-
- retval = parse_DATA_LIST_vars (lexer, names, nnames, pv_opts);
+
+ retval = parse_DATA_LIST_vars (lexer, dict, names, nnames, pv_opts);
if (retval)
register_vars_pool (pool, *names, *nnames);
return retval;
@@ -547,7 +598,7 @@ parse_DATA_LIST_vars_pool (struct lexer *lexer, struct pool *pool,
existing and the rest are to be created. Same args as
parse_DATA_LIST_vars(). */
bool
-parse_mixed_vars (struct lexer *lexer, const struct dictionary *dict,
+parse_mixed_vars (struct lexer *lexer, const struct dictionary *dict,
char ***names, size_t *nnames, int pv_opts)
{
size_t i;
@@ -563,7 +614,7 @@ parse_mixed_vars (struct lexer *lexer, const struct dictionary *dict,
}
while (lex_token (lexer) == T_ID || lex_token (lexer) == T_ALL)
{
- if (lex_token (lexer) == T_ALL || dict_lookup_var (dict, lex_tokid (lexer)) != NULL)
+ if (lex_token (lexer) == T_ALL || dict_lookup_var (dict, lex_tokcstr (lexer)) != NULL)
{
struct variable **v;
size_t nv;
@@ -576,7 +627,7 @@ parse_mixed_vars (struct lexer *lexer, const struct dictionary *dict,
free (v);
*nnames += nv;
}
- else if (!parse_DATA_LIST_vars (lexer, names, nnames, PV_APPEND))
+ else if (!parse_DATA_LIST_vars (lexer, dict, names, nnames, PV_APPEND))
goto fail;
}
return 1;
@@ -613,7 +664,7 @@ parse_mixed_vars_pool (struct lexer *lexer, const struct dictionary *dict, struc
}
/* A set of variables. */
-struct var_set
+struct var_set
{
size_t (*get_cnt) (const struct var_set *);
struct variable *(*get_var) (const struct var_set *, size_t idx);
@@ -624,7 +675,7 @@ struct var_set
/* Returns the number of variables in VS. */
size_t
-var_set_get_cnt (const struct var_set *vs)
+var_set_get_cnt (const struct var_set *vs)
{
assert (vs != NULL);
@@ -633,8 +684,8 @@ var_set_get_cnt (const struct var_set *vs)
/* Return variable with index IDX in VS.
IDX must be less than the number of variables in VS. */
-struct variable *
-var_set_get_var (const struct var_set *vs, size_t idx)
+static struct variable *
+var_set_get_var (const struct var_set *vs, size_t idx)
{
assert (vs != NULL);
assert (idx < var_set_get_cnt (vs));
@@ -645,7 +696,7 @@ var_set_get_var (const struct var_set *vs, size_t idx)
/* Returns the variable in VS named NAME, or a null pointer if VS
contains no variable with that name. */
struct variable *
-var_set_lookup_var (const struct var_set *vs, const char *name)
+var_set_lookup_var (const struct var_set *vs, const char *name)
{
size_t idx;
return (var_set_lookup_var_idx (vs, name, &idx)
@@ -661,14 +712,13 @@ var_set_lookup_var_idx (const struct var_set *vs, const char *name,
{
assert (vs != NULL);
assert (name != NULL);
- assert (strlen (name) <= LONG_NAME_LEN);
return vs->lookup_var_idx (vs, name, idx);
}
/* Destroys VS. */
void
-var_set_destroy (struct var_set *vs)
+var_set_destroy (struct var_set *vs)
{
if (vs != NULL)
vs->destroy (vs);
@@ -676,7 +726,7 @@ var_set_destroy (struct var_set *vs)
/* Returns the number of variables in VS. */
static size_t
-dict_var_set_get_cnt (const struct var_set *vs)
+dict_var_set_get_cnt (const struct var_set *vs)
{
struct dictionary *d = vs->aux;
@@ -686,7 +736,7 @@ dict_var_set_get_cnt (const struct var_set *vs)
/* Return variable with index IDX in VS.
IDX must be less than the number of variables in VS. */
static struct variable *
-dict_var_set_get_var (const struct var_set *vs, size_t idx)
+dict_var_set_get_var (const struct var_set *vs, size_t idx)
{
struct dictionary *d = vs->aux;
@@ -697,11 +747,11 @@ dict_var_set_get_var (const struct var_set *vs, size_t idx)
and returns true. Otherwise, returns false. */
static bool
dict_var_set_lookup_var_idx (const struct var_set *vs, const char *name,
- size_t *idx)
+ size_t *idx)
{
struct dictionary *d = vs->aux;
struct variable *v = dict_lookup_var (d, name);
- if (v != NULL)
+ if (v != NULL)
{
*idx = var_get_dict_index (v);
return true;
@@ -712,14 +762,14 @@ dict_var_set_lookup_var_idx (const struct var_set *vs, const char *name,
/* Destroys VS. */
static void
-dict_var_set_destroy (struct var_set *vs)
+dict_var_set_destroy (struct var_set *vs)
{
free (vs);
}
/* Returns a variable set based on D. */
struct var_set *
-var_set_create_from_dict (const struct dictionary *d)
+var_set_create_from_dict (const struct dictionary *d)
{
struct var_set *vs = xmalloc (sizeof *vs);
vs->get_cnt = dict_var_set_get_cnt;
@@ -731,16 +781,16 @@ var_set_create_from_dict (const struct dictionary *d)
}
/* A variable set based on an array. */
-struct array_var_set
+struct array_var_set
{
struct variable *const *var;/* Array of variables. */
size_t var_cnt; /* Number of elements in var. */
- struct hsh_table *name_tab; /* Hash from variable names to variables. */
+ struct hmapx vars_by_name; /* Variables hashed by name. */
};
/* Returns the number of variables in VS. */
static size_t
-array_var_set_get_cnt (const struct var_set *vs)
+array_var_set_get_cnt (const struct var_set *vs)
{
struct array_var_set *avs = vs->aux;
@@ -750,50 +800,48 @@ array_var_set_get_cnt (const struct var_set *vs)
/* Return variable with index IDX in VS.
IDX must be less than the number of variables in VS. */
static struct variable *
-array_var_set_get_var (const struct var_set *vs, size_t idx)
+array_var_set_get_var (const struct var_set *vs, size_t idx)
{
struct array_var_set *avs = vs->aux;
- return (struct variable *) avs->var[idx];
+ return CONST_CAST (struct variable *, avs->var[idx]);
}
/* If VS contains a variable named NAME, sets *IDX to its index
and returns true. Otherwise, returns false. */
static bool
array_var_set_lookup_var_idx (const struct var_set *vs, const char *name,
- size_t *idx)
+ size_t *idx)
{
struct array_var_set *avs = vs->aux;
- struct variable *v, *const *vpp;
+ struct hmapx_node *node;
+ struct variable **varp;
- v = var_create (name, 0);
- vpp = hsh_find (avs->name_tab, &v);
- var_destroy (v);
-
- if (vpp != NULL)
- {
- *idx = vpp - avs->var;
- return true;
- }
- else
- return false;
+ HMAPX_FOR_EACH_WITH_HASH (varp, node, hash_case_string (name, 0),
+ &avs->vars_by_name)
+ if (!strcasecmp (name, var_get_name (*varp)))
+ {
+ *idx = varp - avs->var;
+ return true;
+ }
+
+ return false;
}
/* Destroys VS. */
static void
-array_var_set_destroy (struct var_set *vs)
+array_var_set_destroy (struct var_set *vs)
{
struct array_var_set *avs = vs->aux;
- hsh_destroy (avs->name_tab);
+ hmapx_destroy (&avs->vars_by_name);
free (avs);
free (vs);
}
-/* Returns a variable set based on the VAR_CNT variables in
- VAR. */
+/* Returns a variable set based on the VAR_CNT variables in VAR. */
struct var_set *
-var_set_create_from_array (struct variable *const *var, size_t var_cnt)
+var_set_create_from_array (struct variable *const *var, size_t var_cnt)
{
struct var_set *vs;
struct array_var_set *avs;
@@ -807,15 +855,21 @@ var_set_create_from_array (struct variable *const *var, size_t var_cnt)
vs->aux = avs = xmalloc (sizeof *avs);
avs->var = var;
avs->var_cnt = var_cnt;
- avs->name_tab = hsh_create (2 * var_cnt,
- compare_var_ptrs_by_name, hash_var_ptr_by_name,
- NULL, NULL);
+ hmapx_init (&avs->vars_by_name);
for (i = 0; i < var_cnt; i++)
- if (hsh_insert (avs->name_tab, (void *) &var[i]) != NULL)
- {
- var_set_destroy (vs);
- return NULL;
- }
-
+ {
+ const char *name = var_get_name (var[i]);
+ size_t idx;
+
+ if (array_var_set_lookup_var_idx (vs, name, &idx))
+ {
+ var_set_destroy (vs);
+ return NULL;
+ }
+ hmapx_insert (&avs->vars_by_name, CONST_CAST (void *, &avs->var[i]),
+ hash_case_string (name, 0));
+ }
+
return vs;
}
+