/* PSPP - computes sample statistics.
Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
- Written by Ben Pfaff <blp@gnu.org>.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
static bool type_check (struct expression *, union any_node **,
enum expr_type expected_type);
static union any_node *allocate_unary_variable (struct expression *,
- struct variable *);
+ const struct variable *);
\f
/* Public functions. */
}
break;
+ case OP_var:
+ if ((*node)->type == OP_NUM_VAR || (*node)->type == OP_STR_VAR)
+ {
+ if (do_coercion)
+ *node = (*node)->composite.args[0];
+ return true;
+ }
+ break;
+
case OP_pos_int:
if ((*node)->type == OP_number
&& floor ((*node)->number.n) == (*node)->number.n
(union any_node **) node, NULL, false);
}
+/* Returns true if ACTUAL_TYPE is a kind of REQUIRED_TYPE, false
+ otherwise. */
+static bool
+is_compatible (atom_type required_type, atom_type actual_type)
+{
+ return (required_type == actual_type
+ || (required_type == OP_var
+ && (actual_type == OP_num_var || actual_type == OP_str_var)));
+}
+
/* How to parse an operator. */
struct operator
{
assert (o->arg_cnt == arg_cnt);
assert ((o->flags & OPF_ARRAY_OPERAND) == 0);
for (i = 0; i < arg_cnt; i++)
- assert (o->args[i] == arg_type);
+ assert (is_compatible (arg_type, o->args[i]));
return true;
}
}
static int
-compare_names (const char *test, const char *name)
+compare_names (const char *test, const char *name, bool abbrev_ok)
{
+ if (!abbrev_ok)
+ return true;
+
for (;;)
{
if (!word_matches (&test, &name))
}
static int
-compare_strings (const char *test, const char *name)
+compare_strings (const char *test, const char *name, bool abbrev_ok UNUSED)
{
return strcasecmp (test, name);
}
static bool
lookup_function_helper (const char *name,
- int (*compare) (const char *test, const char *name),
+ int (*compare) (const char *test, const char *name,
+ bool abbrev_ok),
const struct operation **first,
const struct operation **last)
{
for (f = operations + OP_function_first;
f <= operations + OP_function_last; f++)
- if (!compare (name, f->name))
+ if (!compare (name, f->name, !(f->flags & OPF_NO_ABBREV)))
{
*first = f;
- while (f <= operations + OP_function_last && !compare (name, f->name))
+ while (f <= operations + OP_function_last
+ && !compare (name, f->name, !(f->flags & OPF_NO_ABBREV)))
f++;
*last = f;
if (lex_token (lexer) != ')')
for (;;)
{
- if (lex_token (lexer) == T_ID && lex_look_ahead (lexer) == 'T')
+ if (lex_token (lexer) == T_ID
+ && toupper (lex_look_ahead (lexer)) == 'T')
{
- struct variable **vars;
+ const struct variable **vars;
size_t var_cnt;
size_t i;
- if (!parse_variables (lexer, dataset_dict (e->ds), &vars, &var_cnt, PV_SINGLE))
+ if (!parse_variables_const (lexer, dataset_dict (e->ds), &vars, &var_cnt, PV_SINGLE))
goto fail;
for (i = 0; i < var_cnt; i++)
add_arg (&args, &arg_cnt, &arg_cap,
n->composite.min_valid = min_valid != -1 ? min_valid : f->array_min_elems;
if (n->type == OP_LAG_Vn || n->type == OP_LAG_Vs)
- {
- if (dataset_n_lag (e->ds) < 1)
- dataset_set_n_lag (e->ds, 1);
- }
+ dataset_need_lag (e->ds, 1);
else if (n->type == OP_LAG_Vnn || n->type == OP_LAG_Vsn)
{
int n_before;
assert (n->composite.arg_cnt == 2);
assert (n->composite.args[1]->type == OP_pos_int);
n_before = n->composite.args[1]->integer.i;
- if ( dataset_n_lag (e->ds) < n_before)
- dataset_set_n_lag (e->ds, n_before);
+ dataset_need_lag (e->ds, n_before);
}
free (args);
assert (is_composite (n->type));
assert (c->arg_cnt >= op->arg_cnt);
for (i = 0; i < op->arg_cnt; i++)
- assert (expr_node_returns (c->args[i]) == op->args[i]);
+ assert (is_compatible (op->args[i], expr_node_returns (c->args[i])));
if (c->arg_cnt > op->arg_cnt && !is_operator (n->type))
{
assert (op->flags & OPF_ARRAY_OPERAND);
for (i = 0; i < c->arg_cnt; i++)
- assert (operations[c->args[i]->type].returns
- == op->args[op->arg_cnt - 1]);
+ assert (is_compatible (op->args[op->arg_cnt - 1],
+ expr_node_returns (c->args[i])));
}
}
}
union any_node *
-expr_allocate_variable (struct expression *e, struct variable *v)
+expr_allocate_variable (struct expression *e, const struct variable *v)
{
union any_node *n = pool_alloc (e->expr_pool, sizeof n->variable);
n->type = var_is_numeric (v) ? OP_num_var : OP_str_var;
/* Allocates a unary composite node that represents the value of
variable V in expression E. */
static union any_node *
-allocate_unary_variable (struct expression *e, struct variable *v)
+allocate_unary_variable (struct expression *e, const struct variable *v)
{
assert (v != NULL);
return expr_allocate_unary (e, var_is_numeric (v) ? OP_NUM_VAR : OP_STR_VAR,