#include <config.h>
#include "var.h"
-#include <assert.h>
#include <ctype.h>
#include <stdlib.h>
#include "alloc.h"
#include "bitvector.h"
+#include "dictionary.h"
#include "error.h"
#include "hash.h"
#include "lexer.h"
#include "misc.h"
#include "str.h"
-static struct variable *
-parse_vs_variable (struct var_set *vs)
+/* Parses a name as a variable within VS and returns the
+ variable's index if successful. On failure emits an error
+ message and returns a null pointer. */
+static int
+parse_vs_variable_idx (const struct var_set *vs)
{
- struct variable *vp;
+ int idx;
if (token != T_ID)
{
- lex_error ("expecting variable name");
- return NULL;
+ lex_error (_("expecting variable name"));
+ return -1;
}
- vp = var_set_lookup_var (vs, tokid);
- if (vp == NULL)
+ idx = var_set_lookup_var_idx (vs, tokid);
+ if (idx < 0)
msg (SE, _("%s is not a variable name."), tokid);
lex_get ();
- return vp;
+ return idx;
+}
+
+/* Parses a name as a variable within VS and returns the variable
+ if successful. On failure emits an error message and returns
+ a null pointer. */
+static struct variable *
+parse_vs_variable (const struct var_set *vs)
+{
+ int idx = parse_vs_variable_idx (vs);
+ return idx >= 0 ? var_set_get_var (vs, idx) : NULL;
}
+/* Parses a variable name in dictionary D and returns the
+ variable if successful. On failure emits an error message and
+ returns a null pointer. */
struct variable *
-parse_dict_variable (struct dictionary *d)
+parse_dict_variable (const struct dictionary *d)
{
struct var_set *vs = var_set_create_from_dict (d);
struct variable *var = parse_vs_variable (vs);
return var;
}
+/* Parses a variable name in default_dict and returns the
+ variable if successful. On failure emits an error message and
+ returns a null pointer. */
struct variable *
parse_variable (void)
{
return parse_dict_variable (default_dict);
}
-
+/* Returns the dictionary class corresponding to a variable named
+ NAME. */
enum dict_class
dict_class_from_id (const char *name)
{
}
}
+/* Returns the name of dictionary class DICT_CLASS. */
const char *
dict_class_to_name (enum dict_class dict_class)
{
switch (dict_class)
{
case DC_ORDINARY:
- return "ordinary";
+ return _("ordinary");
case DC_SYSTEM:
- return "system";
+ return _("system");
case DC_SCRATCH:
- return "scratch";
+ return _("scratch");
default:
assert (0);
+ abort ();
}
}
+/* Parses a set of variables from dictionary D given options
+ OPTS. Resulting list of variables stored in *VAR and the
+ number of variables into *CNT. Returns nonzero only if
+ successful. */
int
-parse_variables (struct dictionary *d, struct variable ***var, int *cnt,
- int opts)
+parse_variables (const struct dictionary *d, struct variable ***var,
+ int *cnt, int opts)
{
struct var_set *vs;
int success;
assert (var != NULL);
assert (cnt != NULL);
+
vs = var_set_create_from_dict (d);
success = parse_var_set_vars (vs, var, cnt, opts);
+ if ( success == 0 )
+ free ( *var ) ;
var_set_destroy (vs);
return success;
}
+/* Parses a variable name from VS. If successful, sets *IDX to
+ the variable's index in VS, *CLASS to the variable's
+ dictionary class, and returns nonzero. Returns zero on
+ failure. */
+static int
+parse_var_idx_class (const struct var_set *vs, int *idx,
+ enum dict_class *class)
+{
+ *idx = parse_vs_variable_idx (vs);
+ if (*idx < 0)
+ return 0;
+
+ *class = dict_class_from_id (var_set_get_var (vs, *idx)->name);
+ return 1;
+}
+
+/* Add the variable from VS with index IDX to the list of
+ variables V that has *NV elements and room for *MV.
+ Uses and updates INCLUDED to avoid duplicates if indicated by
+ PV_OPTS, which also affects what variables are allowed in
+ appropriate ways. */
+static void
+add_variable (struct variable ***v, int *nv, int *mv,
+ char *included, int pv_opts,
+ const struct var_set *vs, int idx)
+{
+ struct variable *add = var_set_get_var (vs, idx);
+
+ if ((pv_opts & PV_NUMERIC) && add->type != NUMERIC)
+ 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) && add->type != ALPHA)
+ 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)
+ && dict_class_from_id (add->name) == DC_SCRATCH)
+ msg (SE, _("Scratch variables (such as %s) are not allowed "
+ "here."), add->name);
+ else if ((pv_opts & PV_SAME_TYPE) && *nv && add->type != (*v)[0]->type)
+ 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 list."),
+ (*v)[0]->name, add->name, add->name);
+ else if ((pv_opts & PV_NO_DUPLICATE) && included[idx])
+ msg (SE, _("Variable %s appears twice in variable list."), add->name);
+ else
+ {
+ if (*nv >= *mv)
+ {
+ *mv = 2 * (*nv + 1);
+ *v = xrealloc (*v, *mv * sizeof **v);
+ }
+
+ if ((pv_opts & PV_DUPLICATE) || !included[idx])
+ {
+ (*v)[(*nv)++] = add;
+ if (!(pv_opts & PV_DUPLICATE))
+ included[idx] = 1;
+ }
+ }
+}
+
+/* Adds the variables in VS with indexes FIRST_IDX through
+ LAST_IDX, inclusive, to the list of variables V that has *NV
+ elements and room for *MV. Uses and updates INCLUDED to avoid
+ duplicates if indicated by PV_OPTS, which also affects what
+ variables are allowed in appropriate ways. */
+static void
+add_variables (struct variable ***v, int *nv, int *mv, char *included,
+ int pv_opts,
+ const struct var_set *vs, int first_idx, int last_idx,
+ enum dict_class class)
+{
+ int i;
+
+ for (i = first_idx; i <= last_idx; i++)
+ if (dict_class_from_id (var_set_get_var (vs, i)->name) == class)
+ add_variable (v, nv, mv, included, pv_opts, vs, i);
+}
+
/* Note that if parse_variables() returns 0, *v is free()'d.
Conversely, if parse_variables() returns non-zero, then *nv is
nonzero and *v is non-NULL. */
int
-parse_var_set_vars (struct var_set *vs,
+parse_var_set_vars (const struct var_set *vs,
struct variable ***v, int *nv,
int pv_opts)
{
- size_t vs_var_cnt;
- int i;
+ int mv;
char *included;
- struct variable *v1, *v2;
- int count, mv;
- enum dict_class dict_class;
-
assert (vs != NULL);
assert (v != NULL);
assert (nv != NULL);
/* PV_DUPLICATE and PV_NO_DUPLICATE are incompatible. */
assert (!(pv_opts & PV_DUPLICATE) || !(pv_opts & PV_NO_DUPLICATE));
- vs_var_cnt = var_set_get_cnt (vs);
-
if (!(pv_opts & PV_APPEND))
{
*v = NULL;
if (!(pv_opts & PV_DUPLICATE))
{
- included = xmalloc (vs_var_cnt);
- memset (included, 0, vs_var_cnt);
+ int i;
+
+ included = xcalloc (var_set_get_cnt (vs));
for (i = 0; i < *nv; i++)
included[(*v)[i]->index] = 1;
}
+ else
+ included = NULL;
- do
+if (lex_match (T_ALL))
+ add_variables (v, nv, &mv, included, pv_opts,
+ vs, 0, var_set_get_cnt (vs) - 1, DC_ORDINARY);
+ else
{
- if (lex_match (T_ALL))
- {
- v1 = var_set_get_var (vs, 0);
- v2 = var_set_get_var (vs, vs_var_cnt - 1);
- count = vs_var_cnt;
- dict_class = DC_ORDINARY;
- }
- else
- {
- v1 = parse_vs_variable (vs);
- if (!v1)
- goto fail;
+ do
+ {
+ enum dict_class class;
+ int first_idx;
+
+ if (!parse_var_idx_class (vs, &first_idx, &class))
+ goto fail;
- if (lex_match (T_TO))
- {
- enum dict_class dict_class_2;
-
- v2 = parse_vs_variable (vs);
- if (!v2)
- {
- lex_error ("expecting variable name");
- goto fail;
- }
-
- count = v2->index - v1->index + 1;
- if (count < 1)
- {
- msg (SE, _("%s TO %s is not valid syntax since %s "
- "precedes %s in the dictionary."),
- v1->name, v2->name, v2->name, v1->name);
- goto fail;
- }
-
- dict_class = dict_class_from_id (v1->name);
- dict_class_2 = dict_class_from_id (v2->name);
- if (dict_class != dict_class_2)
- {
- msg (SE, _("When using the TO keyword to specify several "
+ if (!lex_match (T_TO))
+ add_variable (v, nv, &mv, included, pv_opts,
+ vs, first_idx);
+ else
+ {
+ int last_idx;
+ enum dict_class last_class;
+ struct variable *first_var, *last_var;
+
+ if (!parse_var_idx_class (vs, &last_idx, &last_class))
+ goto fail;
+
+ first_var = var_set_get_var (vs, first_idx);
+ last_var = var_set_get_var (vs, last_idx);
+
+ if (last_idx < first_idx)
+ {
+ msg (SE, _("%s TO %s is not valid syntax since %s "
+ "precedes %s in the dictionary."),
+ first_var->name, last_var->name,
+ first_var->name, last_var->name);
+ goto fail;
+ }
+ if (class != last_class)
+ {
+ msg (SE, _("When using the TO keyword to specify several "
"variables, both variables must be from "
"the same variable dictionaries, of either "
"ordinary, scratch, or system variables. "
"%s is a %s variable, whereas %s is %s."),
- v1->name, dict_class_to_name (dict_class),
- v2->name, dict_class_to_name (dict_class_2));
- goto fail;
- }
- }
- else
- {
- v2 = v1;
- count = 1;
- dict_class = dict_class_from_id (v1->name);
- }
- if (dict_class == DC_SCRATCH && (pv_opts & PV_NO_SCRATCH))
- {
- msg (SE, _("Scratch variables (such as %s) are not allowed "
- "here."), v1->name);
- goto fail;
- }
- }
-
- if (*nv + count > mv)
- {
- mv += ROUND_UP (count, 16);
- *v = xrealloc (*v, mv * sizeof **v);
- }
-
- /* Add v1...v2 to the list. */
- for (i = v1->index; i <= v2->index; i++)
- {
- struct variable *add = var_set_get_var (vs, i);
-
- /* Skip over other dictionaries. */
- if (dict_class != dict_class_from_id (add->name))
- continue;
-
- /* Different kinds of errors. */
- if ((pv_opts & PV_NUMERIC) && add->type != NUMERIC)
- 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) && add->type != ALPHA)
- msg (SE, _("%s is not a string variable. It will not be "
- "included in the variable list."), add->name);
- else if ((pv_opts & PV_SAME_TYPE) && *nv
- && add->type != (*v)[0]->type)
- 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 list."),
- (*v)[0]->name, add->name, add->name);
- else if ((pv_opts & PV_NO_DUPLICATE) && included[add->index])
- msg (SE, _("Variable %s appears twice in variable list."),
- add->name);
- else {
- /* Success--add the variable to the list. */
- if ((pv_opts & PV_DUPLICATE) || !included[add->index])
- {
- (*v)[(*nv)++] = var_set_get_var (vs, i);
- if (!(pv_opts & PV_DUPLICATE))
- included[add->index] = 1;
- }
-
- /* Next. */
- continue;
- }
-
- /* Arrive here only on failure. */
+ first_var->name, dict_class_to_name (class),
+ last_var->name, dict_class_to_name (last_class));
+ goto fail;
+ }
+
+ add_variables (v, nv, &mv, included, pv_opts,
+ vs, first_idx, last_idx, class);
+ }
if (pv_opts & PV_SINGLE)
- goto fail;
- }
-
- /* We finished adding v1...v2 to the list. */
- if (pv_opts & PV_SINGLE)
- return 1;
- lex_match (',');
+ break;
+ lex_match (',');
+ }
+ while (token == T_ID && var_set_lookup_var (vs, tokid) != NULL);
}
- while ((token == T_ID && var_set_lookup_var (vs, tokid) != NULL)
- || token == T_ALL);
-
- if (!(pv_opts & PV_DUPLICATE))
- free (included);
- if (!*nv)
+
+ if (*nv == 0)
goto fail;
+
+ free (included);
return 1;
fail:
+ free (included);
free (*v);
*v = NULL;
*nv = 0;
- if (!(pv_opts & PV_DUPLICATE))
- free (included);
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. */
static int
extract_num (char *s, char *r, int *n, int *d)
{
*names = NULL;
}
- name1 = xmalloc (36);
- name2 = &name1[1 * 9];
- root1 = &name1[2 * 9];
- root2 = &name1[3 * 9];
+ name1 = xmalloc (4 * (SHORT_NAME_LEN + 1));
+ name2 = &name1[1 * SHORT_NAME_LEN + 1];
+ root1 = &name1[2 * SHORT_NAME_LEN + 1];
+ root2 = &name1[3 * SHORT_NAME_LEN + 1];
do
{
if (token != T_ID)
lex_error ("expecting variable name");
goto fail;
}
- if (tokid[0] == '#' && (pv_opts & PV_NO_SCRATCH))
+ if (dict_class_from_id (tokid) == DC_SCRATCH
+ && (pv_opts & PV_NO_SCRATCH))
{
msg (SE, _("Scratch variables not allowed here."));
goto fail;
for (n = n1; n <= n2; n++)
{
- (*names)[nvar] = xmalloc (9);
+ (*names)[nvar] = xmalloc (SHORT_NAME_LEN + 1);
sprintf ((*names)[nvar], "%s%0*d", root1, d1, n);
nvar++;
}
return 0;
}
\f
+/* A set of variables. */
struct var_set
{
- size_t (*get_cnt) (struct var_set *);
- struct variable *(*get_var) (struct var_set *, size_t idx);
- struct variable *(*lookup_var) (struct var_set *, const char *);
+ size_t (*get_cnt) (const struct var_set *);
+ struct variable *(*get_var) (const struct var_set *, size_t idx);
+ int (*lookup_var_idx) (const struct var_set *, const char *);
void (*destroy) (struct var_set *);
void *aux;
};
+/* Returns the number of variables in VS. */
size_t
-var_set_get_cnt (struct var_set *vs)
+var_set_get_cnt (const struct var_set *vs)
{
assert (vs != NULL);
return vs->get_cnt (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 (struct var_set *vs, size_t idx)
+var_set_get_var (const struct var_set *vs, size_t idx)
{
assert (vs != NULL);
assert (idx < var_set_get_cnt (vs));
return vs->get_var (vs, 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 (struct var_set *vs, const char *name)
+var_set_lookup_var (const struct var_set *vs, const char *name)
+{
+ int idx = var_set_lookup_var_idx (vs, name);
+ return idx >= 0 ? var_set_get_var (vs, idx) : NULL;
+}
+
+/* Returns the index in VS of the variable named NAME, or -1 if
+ VS contains no variable with that name. */
+int
+var_set_lookup_var_idx (const struct var_set *vs, const char *name)
{
assert (vs != NULL);
assert (name != NULL);
- assert (strlen (name) < 9);
+ assert (strlen (name) <= LONG_NAME_LEN );
- return vs->lookup_var (vs, name);
+ return vs->lookup_var_idx (vs, name);
}
+/* Destroys VS. */
void
var_set_destroy (struct var_set *vs)
{
vs->destroy (vs);
}
\f
+/* Returns the number of variables in VS. */
static size_t
-dict_var_set_get_cnt (struct var_set *vs)
+dict_var_set_get_cnt (const struct var_set *vs)
{
struct dictionary *d = vs->aux;
return dict_get_var_cnt (d);
}
+/* 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 (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;
return dict_get_var (d, idx);
}
-static struct variable *
-dict_var_set_lookup_var (struct var_set *vs, const char *name)
+/* Returns the index of the variable in VS named NAME, or -1 if
+ VS contains no variable with that name. */
+static int
+dict_var_set_lookup_var_idx (const struct var_set *vs, const char *name)
{
struct dictionary *d = vs->aux;
-
- return dict_lookup_var (d, name);
+ struct variable *v = dict_lookup_var (d, name);
+ return v != NULL ? v->index : -1;
}
+/* Destroys VS. */
static void
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 (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;
vs->get_var = dict_var_set_get_var;
- vs->lookup_var = dict_var_set_lookup_var;
+ vs->lookup_var_idx = dict_var_set_lookup_var_idx;
vs->destroy = dict_var_set_destroy;
- vs->aux = d;
+ vs->aux = (void *) d;
return vs;
}
\f
+/* A variable set based on an array. */
struct array_var_set
{
- struct variable **var;
- size_t var_cnt;
- struct hsh_table *name_tab;
+ 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 hsh_table *longname_tab; /* Hash of short names indexed by long names */
};
+/* Returns the number of variables in VS. */
static size_t
-array_var_set_get_cnt (struct var_set *vs)
+array_var_set_get_cnt (const struct var_set *vs)
{
struct array_var_set *avs = vs->aux;
return avs->var_cnt;
}
+/* 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 (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 avs->var[idx];
+ return (struct variable *) avs->var[idx];
}
-static struct variable *
-array_var_set_lookup_var (struct var_set *vs, const char *name)
+/* Returns the index of the variable in VS named NAME, or -1 if
+ VS contains no variable with that name. */
+static int
+array_var_set_lookup_var_idx (const struct var_set *vs, const char *name)
{
+ char *short_name ;
struct array_var_set *avs = vs->aux;
- struct variable v;
+ struct variable v, *vp, *const *vpp;
+
+ struct name_table_entry key;
+ key.longname = name;
+
+ struct name_table_entry *nte;
+
+ assert (avs->longname_tab);
+
- strcpy (v.name, name);
+ nte = hsh_find (avs->longname_tab, &key);
- return hsh_find (avs->name_tab, &v);
+ if (!nte)
+ return -1;
+
+ short_name = nte->name;
+
+ strcpy (v.name, short_name);
+ vp = &v;
+ vpp = hsh_find (avs->name_tab, &vp);
+ return vpp != NULL ? vpp - avs->var : -1;
}
+/* Destroys VS. */
static void
array_var_set_destroy (struct var_set *vs)
{
struct array_var_set *avs = vs->aux;
hsh_destroy (avs->name_tab);
+ hsh_destroy (avs->longname_tab);
free (avs);
free (vs);
}
+/* Returns a variable set based on the VAR_CNT variables in
+ VAR. */
struct var_set *
-var_set_create_from_array (struct variable **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;
vs = xmalloc (sizeof *vs);
vs->get_cnt = array_var_set_get_cnt;
vs->get_var = array_var_set_get_var;
- vs->lookup_var = array_var_set_lookup_var;
+ vs->lookup_var_idx = array_var_set_lookup_var_idx;
vs->destroy = array_var_set_destroy;
vs->aux = avs = xmalloc (sizeof *avs);
avs->var = var;
avs->var_cnt = var_cnt;
avs->name_tab = hsh_create (2 * var_cnt,
- compare_variables, hash_variable, NULL,
- NULL);
- for (i = 0; i < var_cnt; i++)
- if (hsh_insert (avs->name_tab, var[i]) != NULL)
- {
- var_set_destroy (vs);
- return NULL;
- }
+ compare_var_ptr_names, hash_var_ptr_name,
+ NULL, NULL);
+
+ avs->longname_tab = hsh_create (2 * var_cnt,
+ compare_long_names, hash_long_name,
+ NULL, NULL);
+ for (i = 0; i < var_cnt; i++)
+ {
+ struct name_table_entry *nte ;
+
+ if (hsh_insert (avs->name_tab, &var[i]) != NULL)
+ {
+ var_set_destroy (vs);
+ return NULL;
+ }
+
+ nte = xmalloc (sizeof (*nte));
+ nte->name = strdup(var[i]->name);
+ nte->longname = strdup(var[i]->longname);
+
+ if (hsh_insert (avs->longname_tab, nte) != NULL)
+ {
+ var_set_destroy (vs);
+ free (nte);
+ return NULL;
+ }
+
+ }
+
return vs;
}
projects / pspp-builds.git / blobdiff