/* If VAR_NAME is non-NULL, attempts to create a
variable named VAR_NAME, with format F1.0, in DICT, and stores
a pointer to the variable in *VAR. Returns true if
successful, false if the variable name is a duplicate (in
which case a message saying that the variable specified on the
given SUBCOMMAND is a duplicate is emitted).
Does nothing and returns true if VAR_NAME is null. */
static bool
create_flag_var (const char *subcommand, const char *var_name,
struct dictionary *dict, struct variable **var)
{
if (var_name != NULL)
{
struct fmt_spec format = fmt_for_output (FMT_F, 1, 0);
*var = dict_create_var (dict, var_name, 0);
if (*var == NULL)
{
msg (SE, _("Variable name %s specified on %s subcommand "
"duplicates an existing variable name."),
subcommand, var_name);
return false;
}
var_set_both_formats (*var, &format);
}
else
*var = NULL;
return true;
}
/* Parses the STRING command. */
int
cmd_string (struct lexer *lexer, struct dataset *ds)
{
size_t i;
/* Names of variables to create. */
char **v;
size_t nv;
/* Format spec for variables to create. */
struct fmt_spec f;
/* Width of variables to create. */
int width;
do
{
if (!parse_DATA_LIST_vars (lexer, dataset_dict (ds),
&v, &nv, PV_NO_DUPLICATE))
return CMD_FAILURE;
if (!lex_force_match (lexer, T_LPAREN)
|| !parse_format_specifier (lexer, &f)
|| !lex_force_match (lexer, T_RPAREN))
goto fail;
if (!fmt_is_string (f.type))
{
char str[FMT_STRING_LEN_MAX + 1];
msg (SE, _("Format type %s may not be used with a string "
"variable."), fmt_to_string (&f, str));
goto fail;
}
if (!fmt_check_output (&f))
goto fail;
width = fmt_var_width (&f);
/* Create each variable. */
for (i = 0; i < nv; i++)
{
struct variable *new_var = dict_create_var (dataset_dict (ds), v[i],
width);
if (!new_var)
msg (SE, _("There is already a variable named %s."), v[i]);
else
var_set_both_formats (new_var, &f);
}
/* Clean up. */
for (i = 0; i < nv; i++)
free (v[i]);
free (v);
}
while (lex_match (lexer, T_SLASH));
return CMD_SUCCESS;
/* If we have an error at a point where cleanup is required,
flow-of-control comes here. */
fail:
for (i = 0; i < nv; i++)
free (v[i]);
free (v);
return CMD_FAILURE;
}
/* Parses the NUMERIC command. */
int
cmd_numeric (struct lexer *lexer, struct dataset *ds)
{
size_t i;
/* Names of variables to create. */
char **v;
size_t nv;
do
{
/* Format spec for variables to create. f.type==-1 if default is to
be used. */
struct fmt_spec f;
if (!parse_DATA_LIST_vars (lexer, dataset_dict (ds),
&v, &nv, PV_NO_DUPLICATE))
return CMD_FAILURE;
/* Get the optional format specification. */
if (lex_match (lexer, T_LPAREN))
{
if (!parse_format_specifier (lexer, &f))
goto fail;
if ( ! fmt_check_output (&f))
goto fail;
if (fmt_is_string (f.type))
{
char str[FMT_STRING_LEN_MAX + 1];
msg (SE, _("Format type %s may not be used with a numeric "
"variable."), fmt_to_string (&f, str));
goto fail;
}
if (!lex_match (lexer, T_RPAREN))
{
lex_error_expecting (lexer, "`)'", NULL_SENTINEL);
goto fail;
}
}
else
f.type = -1;
/* Create each variable. */
for (i = 0; i < nv; i++)
{
struct variable *new_var = dict_create_var (dataset_dict (ds), v[i], 0);
if (!new_var)
msg (SE, _("There is already a variable named %s."), v[i]);
else
{
if (f.type != -1)
var_set_both_formats (new_var, &f);
}
}
/* Clean up. */
for (i = 0; i < nv; i++)
free (v[i]);
free (v);
}
while (lex_match (lexer, T_SLASH));
return CMD_SUCCESS;
/* If we have an error at a point where cleanup is required,
flow-of-control comes here. */
fail:
for (i = 0; i < nv; i++)
free (v[i]);
free (v);
return CMD_FAILURE;
}
/* Parse all the aggregate functions. */
static bool
parse_aggregate_functions (struct lexer *lexer, const struct dictionary *dict,
struct agr_proc *agr)
{
struct agr_var *tail; /* Tail of linked list starting at agr->vars. */
/* Parse everything. */
tail = NULL;
for (;;)
{
char **dest;
char **dest_label;
size_t n_dest;
struct string function_name;
enum mv_class exclude;
const struct agr_func *function;
int func_index;
union agr_argument arg[2];
const struct variable **src;
size_t n_src;
size_t i;
dest = NULL;
dest_label = NULL;
n_dest = 0;
src = NULL;
function = NULL;
n_src = 0;
arg[0].c = NULL;
arg[1].c = NULL;
ds_init_empty (&function_name);
/* Parse the list of target variables. */
while (!lex_match (lexer, T_EQUALS))
{
size_t n_dest_prev = n_dest;
if (!parse_DATA_LIST_vars (lexer, dict, &dest, &n_dest,
(PV_APPEND | PV_SINGLE | PV_NO_SCRATCH
| PV_NO_DUPLICATE)))
goto error;
/* Assign empty labels. */
{
int j;
dest_label = xnrealloc (dest_label, n_dest, sizeof *dest_label);
for (j = n_dest_prev; j < n_dest; j++)
dest_label[j] = NULL;
}
if (lex_is_string (lexer))
{
dest_label[n_dest - 1] = xstrdup (lex_tokcstr (lexer));
lex_get (lexer);
}
}
/* Get the name of the aggregation function. */
if (lex_token (lexer) != T_ID)
{
lex_error (lexer, _("expecting aggregation function"));
goto error;
}
ds_assign_substring (&function_name, lex_tokss (lexer));
exclude = ds_chomp_byte (&function_name, '.') ? MV_SYSTEM : MV_ANY;
for (function = agr_func_tab; function->name; function++)
if (!c_strcasecmp (function->name, ds_cstr (&function_name)))
break;
if (NULL == function->name)
{
msg (SE, _("Unknown aggregation function %s."),
ds_cstr (&function_name));
goto error;
}
ds_destroy (&function_name);
func_index = function - agr_func_tab;
lex_get (lexer);
/* Check for leading lparen. */
if (!lex_match (lexer, T_LPAREN))
{
if (function->src_vars == AGR_SV_YES)
{
lex_force_match (lexer, T_LPAREN);
goto error;
}
}
else
{
/* Parse list of source variables. */
{
int pv_opts = PV_NO_SCRATCH;
if (func_index == SUM || func_index == MEAN || func_index == SD)
pv_opts |= PV_NUMERIC;
else if (function->n_args)
pv_opts |= PV_SAME_TYPE;
if (!parse_variables_const (lexer, dict, &src, &n_src, pv_opts))
goto error;
}
/* Parse function arguments, for those functions that
require arguments. */
if (function->n_args != 0)
for (i = 0; i < function->n_args; i++)
{
int type;
lex_match (lexer, T_COMMA);
if (lex_is_string (lexer))
{
arg[i].c = recode_string (dict_get_encoding (agr->dict),
"UTF-8", lex_tokcstr (lexer),
-1);
type = VAL_STRING;
}
else if (lex_is_number (lexer))
{
arg[i].f = lex_tokval (lexer);
type = VAL_NUMERIC;
}
else
{
msg (SE, _("Missing argument %zu to %s."),
i + 1, function->name);
goto error;
}
lex_get (lexer);
if (type != var_get_type (src[0]))
{
msg (SE, _("Arguments to %s must be of same type as "
"source variables."),
function->name);
goto error;
}
}
/* Trailing rparen. */
if (!lex_force_match (lexer, T_RPAREN))
goto error;
/* Now check that the number of source variables match
the number of target variables. If we check earlier
than this, the user can get very misleading error
message, i.e. `AGGREGATE x=SUM(y t).' will get this
error message when a proper message would be more
like `unknown variable t'. */
if (n_src != n_dest)
{
msg (SE, _("Number of source variables (%zu) does not match "
"number of target variables (%zu)."),
n_src, n_dest);
goto error;
}
if ((func_index == PIN || func_index == POUT
|| func_index == FIN || func_index == FOUT)
&& (var_is_numeric (src[0])
? arg[0].f > arg[1].f
: str_compare_rpad (arg[0].c, arg[1].c) > 0))
{
union agr_argument t = arg[0];
arg[0] = arg[1];
arg[1] = t;
msg (SW, _("The value arguments passed to the %s function "
"are out-of-order. They will be treated as if "
"they had been specified in the correct order."),
function->name);
}
}
/* Finally add these to the linked list of aggregation
variables. */
for (i = 0; i < n_dest; i++)
{
struct agr_var *v = xzalloc (sizeof *v);
/* Add variable to chain. */
if (agr->agr_vars != NULL)
tail->next = v;
else
agr->agr_vars = v;
tail = v;
tail->next = NULL;
v->moments = NULL;
/* Create the target variable in the aggregate
dictionary. */
{
struct variable *destvar;
v->function = func_index;
if (src)
{
v->src = src[i];
if (var_is_alpha (src[i]))
{
v->function |= FSTRING;
v->string = xmalloc (var_get_width (src[i]));
}
if (function->alpha_type == VAL_STRING)
destvar = dict_clone_var_as (agr->dict, v->src, dest[i]);
else
{
assert (var_is_numeric (v->src)
|| function->alpha_type == VAL_NUMERIC);
destvar = dict_create_var (agr->dict, dest[i], 0);
if (destvar != NULL)
{
struct fmt_spec f;
if ((func_index == N || func_index == NMISS)
&& dict_get_weight (dict) != NULL)
f = fmt_for_output (FMT_F, 8, 2);
else
f = function->format;
var_set_both_formats (destvar, &f);
}
}
} else {
struct fmt_spec f;
v->src = NULL;
destvar = dict_create_var (agr->dict, dest[i], 0);
if (destvar != NULL)
{
if ((func_index == N || func_index == NMISS)
&& dict_get_weight (dict) != NULL)
f = fmt_for_output (FMT_F, 8, 2);
else
f = function->format;
var_set_both_formats (destvar, &f);
}
}
if (!destvar)
{
msg (SE, _("Variable name %s is not unique within the "
"aggregate file dictionary, which contains "
"the aggregate variables and the break "
"variables."),
dest[i]);
goto error;
}
free (dest[i]);
if (dest_label[i])
var_set_label (destvar, dest_label[i]);
v->dest = destvar;
}
v->exclude = exclude;
if (v->src != NULL)
{
int j;
if (var_is_numeric (v->src))
for (j = 0; j < function->n_args; j++)
v->arg[j].f = arg[j].f;
else
for (j = 0; j < function->n_args; j++)
v->arg[j].c = xstrdup (arg[j].c);
}
}
if (src != NULL && var_is_alpha (src[0]))
for (i = 0; i < function->n_args; i++)
{
free (arg[i].c);
arg[i].c = NULL;
}
free (src);
free (dest);
free (dest_label);
if (!lex_match (lexer, T_SLASH))
{
if (lex_token (lexer) == T_ENDCMD)
return true;
lex_error (lexer, "expecting end of command");
return false;
}
continue;
error:
ds_destroy (&function_name);
for (i = 0; i < n_dest; i++)
{
free (dest[i]);
free (dest_label[i]);
}
free (dest);
free (dest_label);
free (arg[0].c);
free (arg[1].c);
if (src && n_src && var_is_alpha (src[0]))
for (i = 0; i < function->n_args; i++)
{
free (arg[i].c);
arg[i].c = NULL;
}
free (src);
return false;
}
}
