X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=inline;f=src%2Flanguage%2Fexpressions%2Foptimize.c;h=28ba85f206a45f9ae38f0aca8093ab303af39e30;hb=faef2451e5aaeb4841a7b8a42a0e8386e591d257;hp=b0abd946c57b9868b6346f77d45d68cf5a45ccc3;hpb=9f087e7aa4cdff1d5d46d5e188c0017a9d2d0029;p=pspp
diff --git a/src/language/expressions/optimize.c b/src/language/expressions/optimize.c
index b0abd946c5..28ba85f206 100644
--- a/src/language/expressions/optimize.c
+++ b/src/language/expressions/optimize.c
@@ -1,5 +1,5 @@
/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2011 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@@ -15,24 +15,27 @@
along with this program. If not, see . */
#include
-#include "private.h"
+
+#include "language/expressions/private.h"
+
#include
#include
#include
#include
-#include
-#include
-#include
-#include
+
+#include "data/calendar.h"
+#include "data/data-in.h"
+#include "data/variable.h"
#include "evaluate.h"
-#include "helpers.h"
-#include
-#include
-#include "public.h"
-#include
-#include
+#include "language/expressions/helpers.h"
+#include "language/expressions/public.h"
+#include "libpspp/assertion.h"
+#include "libpspp/message.h"
+#include "libpspp/misc.h"
+#include "libpspp/pool.h"
+#include "libpspp/str.h"
-#include "xalloc.h"
+#include "gl/xalloc.h"
static union any_node *evaluate_tree (struct composite_node *,
struct expression *);
@@ -41,8 +44,8 @@ static union any_node *optimize_tree (union any_node *, struct expression *);
union any_node *
expr_optimize (union any_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;
@@ -53,21 +56,21 @@ expr_optimize (union any_node *node, struct expression *e)
/* Start by optimizing all the children. */
c = &node->composite;
- for (i = 0; i < c->arg_cnt; i++)
+ for (i = 0; i < c->n_args; i++)
{
c->args[i] = expr_optimize (c->args[i], e);
if (c->args[i]->type == OP_number)
{
if (c->args[i]->number.n == SYSMIS)
- sysmis_cnt++;
+ n_sysmis++;
}
if (!is_atom (c->args[i]->type))
- nonconst_cnt++;
+ n_nonconst++;
}
op = &operations[c->type];
- if (sysmis_cnt && (op->flags & OPF_ABSORB_MISS) == 0)
+ if (n_sysmis && (op->flags & OPF_ABSORB_MISS) == 0)
{
/* Most operations produce SYSMIS given any SYSMIS
argument. */
@@ -77,7 +80,7 @@ expr_optimize (union any_node *node, struct expression *e)
else
return 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);
@@ -138,12 +141,12 @@ optimize_tree (union any_node *node, struct expression *e)
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,
+ size_t arg_idx, size_t n_args,
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,
+ size_t arg_idx, size_t n_args,
struct expression *);
static const struct fmt_spec *get_format_arg (struct composite_node *,
size_t arg_idx);
@@ -165,21 +168,21 @@ evaluate_tree (struct composite_node *node, struct expression *e)
static double
get_number_arg (struct composite_node *c, size_t arg_idx)
{
- assert (arg_idx < c->arg_cnt);
+ assert (arg_idx < c->n_args);
assert (c->args[arg_idx]->type == OP_number
|| c->args[arg_idx]->type == OP_boolean);
return c->args[arg_idx]->number.n;
}
static double *
-get_number_args (struct composite_node *c, size_t arg_idx, size_t arg_cnt,
+get_number_args (struct composite_node *c, 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 = pool_alloc (e->expr_pool, sizeof *d * n_args);
+ for (i = 0; i < n_args; i++)
d[i] = get_number_arg (c, i + arg_idx);
return d;
}
@@ -187,20 +190,20 @@ get_number_args (struct composite_node *c, size_t arg_idx, size_t arg_cnt,
static struct substring
get_string_arg (struct composite_node *c, size_t arg_idx)
{
- assert (arg_idx < c->arg_cnt);
+ assert (arg_idx < c->n_args);
assert (c->args[arg_idx]->type == OP_string);
return c->args[arg_idx]->string.s;
}
static struct substring *
-get_string_args (struct composite_node *c, size_t arg_idx, size_t arg_cnt,
+get_string_args (struct composite_node *c, 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 = pool_alloc (e->expr_pool, sizeof *s * n_args);
+ for (i = 0; i < n_args; i++)
s[i] = get_string_arg (c, i + arg_idx);
return s;
}
@@ -208,7 +211,7 @@ get_string_args (struct composite_node *c, size_t arg_idx, size_t arg_cnt,
static const struct fmt_spec *
get_format_arg (struct composite_node *c, size_t arg_idx)
{
- assert (arg_idx < c->arg_cnt);
+ assert (arg_idx < c->n_args);
assert (c->args[arg_idx]->type == OP_ni_format
|| c->args[arg_idx]->type == OP_no_format);
return &c->args[arg_idx]->format.f;
@@ -309,13 +312,13 @@ flatten_composite (union any_node *n, struct expression *e)
const struct operation *op = &operations[n->type];
size_t i;
- for (i = 0; i < n->composite.arg_cnt; i++)
+ for (i = 0; i < n->composite.n_args; i++)
flatten_node (n->composite.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->composite.n_args; i++)
{
union any_node *arg = n->composite.args[i];
switch (arg->type)
@@ -345,7 +348,7 @@ flatten_composite (union any_node *n, struct expression *e)
}
if (op->flags & OPF_ARRAY_OPERAND)
- emit_integer (e, n->composite.arg_cnt - op->arg_cnt + 1);
+ emit_integer (e, n->composite.n_args - op->n_args + 1);
if (op->flags & OPF_MIN_VALID)
emit_integer (e, n->composite.min_valid);
}
@@ -366,14 +369,15 @@ flatten_node (union any_node *n, struct expression *e)
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++];
}