#include <config.h>
+#include <language/lexer/variable-parser.h>
+
#include <ctype.h>
#include <stdbool.h>
#include <stdlib.h>
#include "lexer.h"
#include <data/dictionary.h>
-#include <procedure.h>
+#include <data/procedure.h>
#include <data/variable.h>
#include <libpspp/alloc.h>
#include <libpspp/bit-vector.h>
return success;
}
+/* Parses a set of variables from dictionary D given options
+ OPTS. Resulting list of variables stored in *VARS and the
+ number of variables into *VAR_CNT. Returns nonzero only if
+ successful. Same behavior as parse_variables, except that all
+ allocations are taken from the given POOL. */
+int
+parse_variables_pool (struct pool *pool, const struct dictionary *dict,
+ struct variable ***vars, size_t *var_cnt, int opts)
+{
+ int retval;
+
+ /* PV_APPEND is unsafe because parse_variables would free the
+ existing names on failure, but those names are presumably
+ already in the pool, which would attempt to re-free it
+ later. */
+ assert (!(opts & PV_APPEND));
+
+ retval = parse_variables (dict, vars, var_cnt, opts);
+ if (retval)
+ pool_register (pool, free, *vars);
+ return retval;
+}
+
/* 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
(*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
+ else if ((pv_opts & PV_DUPLICATE) || !included[idx])
{
if (*nv >= *mv)
{
*mv = 2 * (*nv + 1);
*v = xnrealloc (*v, *mv, sizeof **v);
}
-
- if ((pv_opts & PV_DUPLICATE) || !included[idx])
- {
- (*v)[(*nv)++] = add;
- if (!(pv_opts & PV_DUPLICATE))
- included[idx] = 1;
- }
+ (*v)[(*nv)++] = add;
+ if (included != NULL)
+ included[idx] = 1;
}
}
else
included = NULL;
- if (lex_match (T_ALL))
- add_variables (v, nv, &mv, included, pv_opts,
- vs, 0, var_set_get_cnt (vs) - 1, DC_ORDINARY);
- else
+ do
{
- 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
{
enum dict_class class;
size_t first_idx;
-
+
if (!parse_var_idx_class (vs, &first_idx, &class))
goto fail;
add_variables (v, nv, &mv, included, pv_opts,
vs, first_idx, last_idx, class);
- }
- if (pv_opts & PV_SINGLE)
- break;
- lex_match (',');
+ }
}
- while (token == T_ID && var_set_lookup_var (vs, tokid) != NULL);
+
+ if (pv_opts & PV_SINGLE)
+ break;
+ lex_match (',');
}
+ while (token == T_ALL
+ || (token == T_ID && var_set_lookup_var (vs, tokid) != NULL));
if (*nv == 0)
goto fail;
return success;
}
+/* Registers each of the NAMES[0...NNAMES - 1] in POOL, as well
+ as NAMES itself. */
+static void
+register_vars_pool (struct pool *pool, char **names, size_t nnames)
+{
+ size_t i;
+
+ for (i = 0; i < nnames; i++)
+ pool_register (pool, free, names[i]);
+ pool_register (pool, free, names);
+}
+
+/* Parses a list of variable names according to the DATA LIST
+ version of the TO convention. Same args as
+ parse_DATA_LIST_vars(), except that all allocations are taken
+ from the given POOL. */
+int
+parse_DATA_LIST_vars_pool (struct pool *pool,
+ char ***names, size_t *nnames, int pv_opts)
+{
+ int retval;
+
+ /* PV_APPEND is unsafe because parse_DATA_LIST_vars would free
+ the existing names on failure, but those names are
+ presumably already in the pool, which would attempt to
+ re-free it later. */
+ assert (!(pv_opts & PV_APPEND));
+
+ retval = parse_DATA_LIST_vars (names, nnames, pv_opts);
+ if (retval)
+ register_vars_pool (pool, *names, *nnames);
+ return retval;
+}
+
/* Parses a list of variables where some of the variables may be
existing and the rest are to be created. Same args as
parse_DATA_LIST_vars(). */
/* Parses a list of variables where some of the variables may be
existing and the rest are to be created. Same args as
- parse_DATA_LIST_vars(), except that all allocations are taken
+ parse_mixed_vars(), except that all allocations are taken
from the given POOL. */
int
parse_mixed_vars_pool (struct pool *pool,
char ***names, size_t *nnames, int pv_opts)
{
- int retval = parse_mixed_vars (names, nnames, pv_opts);
- if (retval)
- {
- size_t i;
+ int retval;
- for (i = 0; i < *nnames; i++)
- pool_register (pool, free, (*names)[i]);
- pool_register (pool, free, *names);
- }
+ /* PV_APPEND is unsafe because parse_mixed_vars_pool would free
+ the existing names on failure, but those names are
+ presumably already in the pool, which would attempt to
+ re-free it later. */
+ assert (!(pv_opts & PV_APPEND));
+
+ retval = parse_mixed_vars (names, nnames, pv_opts);
+ if (retval)
+ register_vars_pool (pool, *names, *nnames);
return retval;
}
-
\f
/* A set of variables. */
struct var_set
projects / pspp-builds.git / blobdiff