/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2009 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2009, 2010 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
#include <config.h>
-#include <language/lexer/variable-parser.h>
+#include "language/lexer/variable-parser.h"
#include <ctype.h>
#include <stdbool.h>
#include <stdlib.h>
-#include "lexer.h"
-#include <data/dictionary.h>
-#include <data/procedure.h>
-#include <data/variable.h>
-#include <libpspp/assertion.h>
-#include <libpspp/bit-vector.h>
-#include <libpspp/hash.h>
-#include <libpspp/message.h>
-#include <libpspp/misc.h>
-#include <libpspp/pool.h>
-#include <libpspp/str.h>
-
-#include "xalloc.h"
+#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/xalloc.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
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
{
- msg (SE, _("%s is not a variable name."), lex_tokid (lexer));
+ msg (SE, _("%s is not a variable name."), lex_tokcstr (lexer));
return false;
}
}
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;
/* 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, char ***names,
+ size_t *nnames, int pv_opts)
{
int n1, n2;
int d1, d2;
size_t nvar, mvar;
char name1[VAR_NAME_LEN + 1], name2[VAR_NAME_LEN + 1];
char root1[VAR_NAME_LEN + 1], root2[VAR_NAME_LEN + 1];
+ struct stringi_set set;
int success = 0;
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;
+ {
+ nvar = mvar = *nnames;
+
+ if (pv_opts & PV_NO_DUPLICATE)
+ {
+ size_t i;
+
+ for (i = 0; i < nvar; i++)
+ stringi_set_insert (&set, (*names)[i]);
+ }
+ }
else
{
nvar = mvar = 0;
lex_error (lexer, "expecting variable name");
goto fail;
}
- 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;
}
- strcpy (name1, lex_tokid (lexer));
+ strcpy (name1, lex_tokcstr (lexer));
lex_get (lexer);
if (lex_token (lexer) == T_TO)
{
lex_error (lexer, "expecting variable name");
goto fail;
}
- strcpy (name2, lex_tokid (lexer));
+ strcpy (name2, lex_tokcstr (lexer));
lex_get (lexer);
if (!extract_num (name1, root1, &n1, &d1)
{
char name[VAR_NAME_LEN + 1];
sprintf (name, "%s%0*d", root1, d1, n);
+
+ if (pv_opts & PV_NO_DUPLICATE && !stringi_set_insert (&set, name))
+ {
+ msg (SE, _("Variable %s appears twice in variable list."),
+ name);
+ goto fail;
+ }
(*names)[nvar] = xstrdup (name);
nvar++;
}
(*names)[nvar++] = xstrdup (name1);
}
- lex_match (lexer, ',');
+ lex_match (lexer, T_COMMA);
if (pv_opts & PV_SINGLE)
break;
fail:
*nnames = nvar;
+ stringi_set_destroy (&set);
if (!success)
{
int i;
}
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;
{
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. */
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);
+ 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;
+ }
- if (vpp != NULL)
- {
- *idx = vpp - avs->var;
- return true;
- }
- else
- return false;
+ return false;
}
/* Destroys 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)
{
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;
}