#include "gl/xalloc.h"
-static union any_node *evaluate_tree (struct composite_node *,
- struct expression *);
-static union any_node *optimize_tree (union any_node *, struct expression *);
+static struct expr_node *evaluate_tree (struct expr_node *, struct expression *);
+static struct expr_node *optimize_tree (struct expr_node *, struct expression *);
-union any_node *
-expr_optimize (union any_node *node, struct expression *e)
+struct expr_node *
+expr_optimize (struct expr_node *node, struct expression *e)
{
- int nonconst_cnt = 0; /* Number of nonconstant children. */
- int sysmis_cnt = 0; /* Number of system-missing children. */
+ int n_nonconst = 0; /* Number of nonconstant children. */
+ int n_sysmis = 0; /* Number of system-missing children. */
const struct operation *op;
- struct composite_node *c;
int i;
/* We can't optimize an atom. */
return node;
/* Start by optimizing all the children. */
- c = &node->composite;
- for (i = 0; i < c->arg_cnt; i++)
+ for (i = 0; i < node->n_args; i++)
{
- c->args[i] = expr_optimize (c->args[i], e);
- if (c->args[i]->type == OP_number)
+ node->args[i] = expr_optimize (node->args[i], e);
+ if (node->args[i]->type == OP_number)
{
- if (c->args[i]->number.n == SYSMIS)
- sysmis_cnt++;
+ if (node->args[i]->number == SYSMIS)
+ n_sysmis++;
}
- if (!is_atom (c->args[i]->type))
- nonconst_cnt++;
+ if (!is_atom (node->args[i]->type))
+ n_nonconst++;
}
- op = &operations[c->type];
- if (sysmis_cnt && (op->flags & OPF_ABSORB_MISS) == 0)
+ op = &operations[node->type];
+
+ struct expr_node *new;
+ if (n_sysmis && (op->flags & OPF_ABSORB_MISS) == 0)
{
/* Most operations produce SYSMIS given any SYSMIS
argument. */
assert (op->returns == OP_number || op->returns == OP_boolean);
- if (op->returns == OP_number)
- return expr_allocate_number (e, SYSMIS);
- else
- return expr_allocate_boolean (e, SYSMIS);
+ new = (op->returns == OP_number
+ ? expr_allocate_number (e, SYSMIS)
+ : expr_allocate_boolean (e, SYSMIS));
}
- else if (!nonconst_cnt && (op->flags & OPF_NONOPTIMIZABLE) == 0)
+ else if (!n_nonconst && (op->flags & OPF_NONOPTIMIZABLE) == 0)
{
/* Evaluate constant expressions. */
- return evaluate_tree (&node->composite, e);
+ new = evaluate_tree (node, e);
}
else
{
/* A few optimization possibilities are still left. */
- return optimize_tree (node, e);
+ new = optimize_tree (node, e);
}
+
+ if (new != node && !new->location)
+ {
+ const struct msg_location *loc = expr_location (e, node);
+ new->location = CONST_CAST (struct msg_location *, loc);
+ }
+ return new;
}
static int
-eq_double (union any_node *node, double n)
+eq_double (struct expr_node *node, double n)
{
- return node->type == OP_number && node->number.n == n;
+ return node->type == OP_number && node->number == n;
}
-static union any_node *
-optimize_tree (union any_node *node, struct expression *e)
+static struct expr_node *
+optimize_tree (struct expr_node *n, struct expression *e)
{
- struct composite_node *n = &node->composite;
- assert (is_composite (node->type));
+ assert (is_composite (n->type));
/* If you add to these optimizations, please also add a
correctness test in tests/expressions/expressions.sh. */
/* Otherwise, nothing to do. */
else
- return node;
-}
-
-static double get_number_arg (struct composite_node *, size_t arg_idx);
-static double *get_number_args (struct composite_node *,
- size_t arg_idx, size_t arg_cnt,
- struct expression *);
-static struct substring get_string_arg (struct composite_node *,
- size_t arg_idx);
-static struct substring *get_string_args (struct composite_node *,
- size_t arg_idx, size_t arg_cnt,
- struct expression *);
-static const struct fmt_spec *get_format_arg (struct composite_node *,
- size_t arg_idx);
-
-static union any_node *
-evaluate_tree (struct composite_node *node, struct expression *e)
-{
- switch (node->type)
- {
-#include "optimize.inc"
-
- default:
- NOT_REACHED ();
- }
-
- NOT_REACHED ();
+ return n;
}
static double
-get_number_arg (struct composite_node *c, size_t arg_idx)
+get_number_arg (struct expr_node *n, size_t arg_idx)
{
- assert (arg_idx < c->arg_cnt);
- assert (c->args[arg_idx]->type == OP_number
- || c->args[arg_idx]->type == OP_boolean);
- return c->args[arg_idx]->number.n;
+ assert (arg_idx < n->n_args);
+ assert (n->args[arg_idx]->type == OP_number
+ || n->args[arg_idx]->type == OP_boolean
+ || n->args[arg_idx]->type == OP_integer);
+ return n->args[arg_idx]->number;
}
static double *
-get_number_args (struct composite_node *c, size_t arg_idx, size_t arg_cnt,
+get_number_args (struct expr_node *n, size_t arg_idx, size_t n_args,
struct expression *e)
{
- double *d;
- size_t i;
-
- d = pool_alloc (e->expr_pool, sizeof *d * arg_cnt);
- for (i = 0; i < arg_cnt; i++)
- d[i] = get_number_arg (c, i + arg_idx);
+ double *d = pool_alloc (e->expr_pool, sizeof *d * n_args);
+ for (size_t i = 0; i < n_args; i++)
+ d[i] = get_number_arg (n, i + arg_idx);
return d;
}
+static int
+get_integer_arg (struct expr_node *n, size_t arg_idx)
+{
+ double number = n->args[arg_idx]->number;
+ return number == SYSMIS ? INT_MIN : number;
+}
+
static struct substring
-get_string_arg (struct composite_node *c, size_t arg_idx)
+get_string_arg (struct expr_node *n, size_t arg_idx)
{
- assert (arg_idx < c->arg_cnt);
- assert (c->args[arg_idx]->type == OP_string);
- return c->args[arg_idx]->string.s;
+ assert (arg_idx < n->n_args);
+ assert (n->args[arg_idx]->type == OP_string);
+ return n->args[arg_idx]->string;
}
static struct substring *
-get_string_args (struct composite_node *c, size_t arg_idx, size_t arg_cnt,
+get_string_args (struct expr_node *n, size_t arg_idx, size_t n_args,
struct expression *e)
{
struct substring *s;
size_t i;
- s = pool_alloc (e->expr_pool, sizeof *s * arg_cnt);
- for (i = 0; i < arg_cnt; i++)
- s[i] = get_string_arg (c, i + arg_idx);
+ s = pool_alloc (e->expr_pool, sizeof *s * n_args);
+ for (i = 0; i < n_args; i++)
+ s[i] = get_string_arg (n, i + arg_idx);
return s;
}
-static const struct fmt_spec *
-get_format_arg (struct composite_node *c, size_t arg_idx)
+static struct fmt_spec
+get_format_arg (struct expr_node *n, size_t arg_idx)
+{
+ assert (arg_idx < n->n_args);
+ assert (n->args[arg_idx]->type == OP_ni_format
+ || n->args[arg_idx]->type == OP_no_format);
+ return n->args[arg_idx]->format;
+}
+
+static const struct expr_node *
+get_expr_node_arg (struct expr_node *n, size_t arg_idx)
{
- assert (arg_idx < c->arg_cnt);
- assert (c->args[arg_idx]->type == OP_ni_format
- || c->args[arg_idx]->type == OP_no_format);
- return &c->args[arg_idx]->format.f;
+ assert (arg_idx < n->n_args);
+ assert (n->args[arg_idx]->type == OP_expr_node);
+ return n->args[arg_idx]->expr_node;
+}
+
+static struct expr_node *
+evaluate_tree (struct expr_node *node, struct expression *e)
+{
+ switch (node->type)
+ {
+#include "optimize.inc"
+
+ default:
+ NOT_REACHED ();
+ }
+
+ NOT_REACHED ();
}
\f
/* Expression flattening. */
static union operation_data *allocate_aux (struct expression *,
operation_type);
-static void flatten_node (union any_node *, struct expression *);
+static void flatten_node (struct expr_node *, struct expression *);
static void
emit_operation (struct expression *e, operation_type type)
}
static void
-emit_format (struct expression *e, const struct fmt_spec *f)
+emit_format (struct expression *e, struct fmt_spec f)
{
- allocate_aux (e, OP_format)->format = pool_clone (e->expr_pool,
- f, sizeof *f);
+ allocate_aux (e, OP_format)->format = f;
}
static void
}
void
-expr_flatten (union any_node *n, struct expression *e)
+expr_flatten (struct expr_node *n, struct expression *e)
{
flatten_node (n, e);
e->type = expr_node_returns (n);
}
static void
-flatten_atom (union any_node *n, struct expression *e)
+flatten_atom (struct expr_node *n, struct expression *e)
{
switch (n->type)
{
case OP_number:
case OP_boolean:
emit_operation (e, OP_number);
- emit_number (e, n->number.n);
+ emit_number (e, n->number);
break;
case OP_string:
emit_operation (e, OP_string);
- emit_string (e, n->string.s);
+ emit_string (e, n->string);
break;
case OP_num_var:
case OP_no_format:
case OP_ni_format:
case OP_pos_int:
+ case OP_expr_node:
/* These are passed as aux data following the
operation. */
break;
}
static void
-flatten_composite (union any_node *n, struct expression *e)
+flatten_composite (struct expr_node *n, struct expression *e)
{
const struct operation *op = &operations[n->type];
size_t i;
- for (i = 0; i < n->composite.arg_cnt; i++)
- flatten_node (n->composite.args[i], e);
+ for (i = 0; i < n->n_args; i++)
+ flatten_node (n->args[i], e);
if (n->type != OP_BOOLEAN_TO_NUM)
emit_operation (e, n->type);
- for (i = 0; i < n->composite.arg_cnt; i++)
+ for (i = 0; i < n->n_args; i++)
{
- union any_node *arg = n->composite.args[i];
+ struct expr_node *arg = n->args[i];
switch (arg->type)
{
case OP_num_var:
case OP_str_var:
- emit_variable (e, arg->variable.v);
+ emit_variable (e, arg->variable);
break;
case OP_vector:
- emit_vector (e, arg->vector.v);
+ emit_vector (e, arg->vector);
break;
case OP_ni_format:
case OP_no_format:
- emit_format (e, &arg->format.f);
+ emit_format (e, arg->format);
break;
case OP_pos_int:
- emit_integer (e, arg->integer.i);
+ emit_integer (e, arg->integer);
+ break;
+
+ case OP_expr_node:
+ allocate_aux (e, OP_expr_node)->expr_node = arg->expr_node;
break;
default:
}
if (op->flags & OPF_ARRAY_OPERAND)
- emit_integer (e, n->composite.arg_cnt - op->arg_cnt + 1);
+ emit_integer (e, n->n_args - op->n_args + 1);
if (op->flags & OPF_MIN_VALID)
- emit_integer (e, n->composite.min_valid);
+ emit_integer (e, n->min_valid);
+ if (op->flags & OPF_EXPR_NODE)
+ allocate_aux (e, OP_expr_node)->expr_node = n;
}
void
-flatten_node (union any_node *n, struct expression *e)
+flatten_node (struct expr_node *n, struct expression *e)
{
assert (is_operation (n->type));
static union operation_data *
allocate_aux (struct expression *e, operation_type type)
{
- if (e->op_cnt >= e->op_cap)
+ if (e->n_ops >= e->allocated_ops)
{
- e->op_cap = (e->op_cap + 8) * 3 / 2;
- e->ops = pool_realloc (e->expr_pool, e->ops, sizeof *e->ops * e->op_cap);
+ e->allocated_ops = (e->allocated_ops + 8) * 3 / 2;
+ e->ops = pool_realloc (e->expr_pool, e->ops,
+ sizeof *e->ops * e->allocated_ops);
e->op_types = pool_realloc (e->expr_pool, e->op_types,
- sizeof *e->op_types * e->op_cap);
+ sizeof *e->op_types * e->allocated_ops);
}
- e->op_types[e->op_cnt] = type;
- return &e->ops[e->op_cnt++];
+ e->op_types[e->n_ops] = type;
+ return &e->ops[e->n_ops++];
}