#include <config.h>
-#include "language/control/control-stack.h"
+#include <limits.h>
#include "data/case.h"
#include "data/dataset.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
-/* LOOP outputs a transformation that is executed only on the
- first pass through the loop. On this trip, it initializes for
- the first pass by resetting the pass number, setting up the
- indexing clause, and testing the LOOP IF clause. If the loop
- is not to be entered at all, it jumps forward just past the
- END LOOP transformation; otherwise, it continues to the
- transformation following LOOP.
-
- END LOOP outputs a transformation that executes at the end of
- each trip through the loop. It checks the END LOOP IF clause,
- then updates the pass number, increments the indexing clause,
- and tests the LOOP IF clause. If another pass through the
- loop is due, it jumps backward to just after the LOOP
- transformation; otherwise, it continues to the transformation
- following END LOOP. */
-
struct loop_trns
{
- struct pool *pool;
- struct dataset *ds;
-
- /* Iteration limit. */
- int max_pass_count; /* Maximum number of passes (-1=unlimited). */
- int pass; /* Number of passes through the loop so far. */
-
/* a=a TO b [BY c]. */
struct variable *index_var; /* Index variable. */
- struct expression *first_expr; /* Starting index. */
- struct expression *by_expr; /* Index increment (default 1.0 if null). */
- struct expression *last_expr; /* Terminal index. */
- double cur, by, last; /* Current value, increment, last value. */
+ struct expression *first; /* Starting index. */
+ struct expression *by; /* Index increment (or NULL). */
+ struct expression *last; /* Terminal index. */
/* IF condition for LOOP or END LOOP. */
struct expression *loop_condition;
struct expression *end_loop_condition;
- /* Transformation indexes. */
- int past_LOOP_index; /* Just past LOOP transformation. */
- int past_END_LOOP_index; /* Just past END LOOP transformation. */
+ /* Inner transformations. */
+ struct transformation *xforms;
+ size_t n_xforms;
};
-static const struct ctl_class loop_class;
-
-static trns_finalize_func loop_trns_finalize;
-static trns_proc_func loop_trns_proc, end_loop_trns_proc, break_trns_proc;
+static trns_proc_func loop_trns_proc;
static trns_free_func loop_trns_free;
-static struct loop_trns *create_loop_trns (struct dataset *);
-static bool parse_if_clause (struct lexer *,
- struct loop_trns *, struct expression **);
+static bool parse_if_clause (struct lexer *, struct dataset *,
+ struct expression **);
static bool parse_index_clause (struct dataset *, struct lexer *,
- struct loop_trns *, bool *created_index_var);
-static void close_loop (void *);
+ struct loop_trns *);
\f
/* LOOP. */
int
cmd_loop (struct lexer *lexer, struct dataset *ds)
{
- struct loop_trns *loop;
- bool created_index_var = false;
- bool ok = true;
+ struct loop_trns *loop = xmalloc (sizeof *loop);
+ *loop = (struct loop_trns) { .index_var = NULL };
- loop = create_loop_trns (ds);
+ bool ok = true;
while (lex_token (lexer) != T_ENDCMD && ok)
{
if (lex_match_id (lexer, "IF"))
- ok = parse_if_clause (lexer, loop, &loop->loop_condition);
+ ok = parse_if_clause (lexer, ds, &loop->loop_condition);
else
- ok = parse_index_clause (ds, lexer, loop, &created_index_var);
+ ok = parse_index_clause (ds, lexer, loop);
}
+ lex_end_of_command (lexer);
- /* Clean up if necessary. */
- if (!ok)
+ proc_push_transformations (ds);
+ for (;;)
{
- loop->max_pass_count = 0;
- if (loop->index_var != NULL && created_index_var)
+ if (lex_token (lexer) == T_STOP)
{
- dict_delete_var (dataset_dict (ds), loop->index_var);
- loop->index_var = NULL;
+ lex_error (lexer, NULL);
+ ok = false;
+ break;
}
+ else if (lex_match_phrase (lexer, "END LOOP"))
+ {
+ if (lex_match_id (lexer, "IF"))
+ ok = parse_if_clause (lexer, ds, &loop->end_loop_condition) && ok;
+ break;
+ }
+ else
+ cmd_parse_in_state (lexer, ds, CMD_STATE_NESTED);
}
+ proc_pop_transformations (ds, &loop->xforms, &loop->n_xforms);
- return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
-}
-
-/* Parses END LOOP. */
-int
-cmd_end_loop (struct lexer *lexer, struct dataset *ds)
-{
- struct loop_trns *loop;
- bool ok = true;
-
- loop = ctl_stack_top (&loop_class);
- if (loop == NULL)
- return CMD_CASCADING_FAILURE;
-
- assert (loop->ds == ds);
-
- /* Parse syntax. */
- if (lex_match_id (lexer, "IF"))
- ok = parse_if_clause (lexer, loop, &loop->end_loop_condition);
- if (ok)
- ok = lex_end_of_command (lexer) == CMD_SUCCESS;
+ add_transformation (ds, loop_trns_proc, loop_trns_free, loop);
- if (!ok)
- loop->max_pass_count = 0;
-
- ctl_stack_pop (loop);
-
- return ok ? CMD_SUCCESS : CMD_FAILURE;
+ return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
}
/* Parses BREAK. */
int
-cmd_break (struct lexer *lexer UNUSED, struct dataset *ds)
+cmd_break (struct lexer *lexer UNUSED, struct dataset *ds UNUSED)
{
- struct ctl_stmt *loop = ctl_stack_search (&loop_class);
- if (loop == NULL)
- return CMD_CASCADING_FAILURE;
-
- add_transformation (ds, break_trns_proc, NULL, loop);
+ //add_transformation (ds, break_trns_proc, NULL, NULL);
return CMD_SUCCESS;
}
-/* Closes a LOOP construct by emitting the END LOOP
- transformation and finalizing its members appropriately. */
-static void
-close_loop (void *loop_)
-{
- struct loop_trns *loop = loop_;
-
- add_transformation (loop->ds, end_loop_trns_proc, NULL, loop);
- loop->past_END_LOOP_index = next_transformation (loop->ds);
-
- /* If there's nothing else limiting the number of loops, use
- MXLOOPS as a limit. */
- if (loop->max_pass_count == -1 && loop->index_var == NULL)
- loop->max_pass_count = settings_get_mxloops ();
-}
-
/* Parses an IF clause for LOOP or END LOOP and stores the
resulting expression to *CONDITION.
Returns true if successful, false on failure. */
static bool
-parse_if_clause (struct lexer *lexer,
- struct loop_trns *loop, struct expression **condition)
+parse_if_clause (struct lexer *lexer, struct dataset *ds,
+ struct expression **condition)
{
if (*condition != NULL)
{
return false;
}
- *condition = expr_parse_bool (lexer, loop->pool, loop->ds);
+ *condition = expr_parse_bool (lexer, ds);
return *condition != NULL;
}
-/* Parses an indexing clause into LOOP.
- Stores true in *CREATED_INDEX_VAR if the index clause created
- a new variable, false otherwise.
- Returns true if successful, false on failure. */
+/* Parses an indexing clause into LOOP. Returns true if successful, false on
+ failure. */
static bool
parse_index_clause (struct dataset *ds, struct lexer *lexer,
- struct loop_trns *loop, bool *created_index_var)
+ struct loop_trns *loop)
{
if (loop->index_var != NULL)
{
}
loop->index_var = dict_lookup_var (dataset_dict (ds), lex_tokcstr (lexer));
- if (loop->index_var != NULL)
- *created_index_var = false;
- else
- {
- loop->index_var = dict_create_var_assert (dataset_dict (ds),
- lex_tokcstr (lexer), 0);
- *created_index_var = true;
- }
+ if (!loop->index_var)
+ loop->index_var = dict_create_var_assert (dataset_dict (ds),
+ lex_tokcstr (lexer), 0);
lex_get (lexer);
if (!lex_force_match (lexer, T_EQUALS))
return false;
- loop->first_expr = expr_parse (lexer, loop->pool, loop->ds, VAL_NUMERIC);
- if (loop->first_expr == NULL)
+ loop->first = expr_parse (lexer, ds, VAL_NUMERIC);
+ if (loop->first == NULL)
return false;
for (;;)
{
struct expression **e;
if (lex_match (lexer, T_TO))
- e = &loop->last_expr;
+ e = &loop->last;
else if (lex_match (lexer, T_BY))
- e = &loop->by_expr;
+ e = &loop->by;
else
break;
if (*e != NULL)
{
- lex_sbc_only_once (e == &loop->last_expr ? "TO" : "BY");
+ lex_sbc_only_once (e == &loop->last ? "TO" : "BY");
return false;
}
- *e = expr_parse (lexer, loop->pool, loop->ds, VAL_NUMERIC);
+ *e = expr_parse (lexer, ds, VAL_NUMERIC);
if (*e == NULL)
return false;
}
- if (loop->last_expr == NULL)
+ if (loop->last == NULL)
{
lex_sbc_missing ("TO");
return false;
}
- if (loop->by_expr == NULL)
- loop->by = 1.0;
return true;
}
-/* Creates, initializes, and returns a new loop_trns. */
-static struct loop_trns *
-create_loop_trns (struct dataset *ds)
-{
- struct loop_trns *loop = pool_create_container (struct loop_trns, pool);
- loop->max_pass_count = -1;
- loop->pass = 0;
- loop->index_var = NULL;
- loop->first_expr = loop->by_expr = loop->last_expr = NULL;
- loop->loop_condition = loop->end_loop_condition = NULL;
- loop->ds = ds;
-
- add_transformation_with_finalizer (ds, loop_trns_finalize,
- loop_trns_proc, loop_trns_free, loop);
- loop->past_LOOP_index = next_transformation (ds);
-
- ctl_stack_push (&loop_class, loop);
-
- return loop;
-}
-
-/* Finalizes LOOP by clearing the control stack, thus ensuring
- that all open LOOPs are closed. */
-static void
-loop_trns_finalize (void *do_if_ UNUSED)
-{
- /* This will be called multiple times if multiple LOOPs were
- executed, which is slightly unclean, but at least it's
- idempotent. */
- ctl_stack_clear ();
-}
-
/* Sets up LOOP for the first pass. */
-static int
+static enum trns_result
loop_trns_proc (void *loop_, struct ccase **c, casenumber case_num)
{
struct loop_trns *loop = loop_;
- if (loop->index_var != NULL)
+ double cur, by, last;
+ if (loop->index_var)
{
/* Evaluate loop index expressions. */
- loop->cur = expr_evaluate_num (loop->first_expr, *c, case_num);
- if (loop->by_expr != NULL)
- loop->by = expr_evaluate_num (loop->by_expr, *c, case_num);
- loop->last = expr_evaluate_num (loop->last_expr, *c, case_num);
+ cur = expr_evaluate_num (loop->first, *c, case_num);
+ by = loop->by ? expr_evaluate_num (loop->by, *c, case_num) : 1.0;
+ last = expr_evaluate_num (loop->last, *c, case_num);
/* Even if the loop is never entered, set the index
variable to the initial value. */
*c = case_unshare (*c);
- *case_num_rw (*c, loop->index_var) = loop->cur;
+ *case_num_rw (*c, loop->index_var) = cur;
/* Throw out pathological cases. */
- if (!isfinite (loop->cur) || !isfinite (loop->by)
- || !isfinite (loop->last)
- || loop->by == 0.0
- || (loop->by > 0.0 && loop->cur > loop->last)
- || (loop->by < 0.0 && loop->cur < loop->last))
- goto zero_pass;
+ if (!isfinite (cur) || !isfinite (by) || !isfinite (last)
+ || by == 0.0
+ || (by > 0.0 && cur > last)
+ || (by < 0.0 && cur < last))
+ return TRNS_CONTINUE;
}
+ else
+ cur = by = last = 0.0;
+
+ int max_pass = loop->index_var ? settings_get_mxloops () : -1;
+ for (int i = 0; max_pass < 0 || i < max_pass; i++)
+ {
+ if (loop->loop_condition
+ && expr_evaluate_num (loop->loop_condition, *c, case_num) != 1.0)
+ break;
- /* Initialize pass count. */
- loop->pass = 0;
- if (loop->max_pass_count >= 0 && loop->pass >= loop->max_pass_count)
- goto zero_pass;
+ enum trns_result r = transformations_execute (
+ loop->xforms, loop->n_xforms, c, case_num);
+ if (r != TRNS_CONTINUE)
+ return r == TRNS_BREAK ? TRNS_CONTINUE : r;
- /* Check condition. */
- if (loop->loop_condition != NULL
- && expr_evaluate_num (loop->loop_condition, *c, case_num) != 1.0)
- goto zero_pass;
+ if (loop->end_loop_condition != NULL
+ && expr_evaluate_num (loop->end_loop_condition, *c, case_num) != 0.0)
+ break;
- return loop->past_LOOP_index;
+ if (loop->index_var)
+ {
+ cur += by;
+ if (by > 0.0 ? cur > last : cur < last)
+ break;
- zero_pass:
- return loop->past_END_LOOP_index;
+ *c = case_unshare (*c);
+ *case_num_rw (*c, loop->index_var) = cur;
+ }
+ }
+ return TRNS_CONTINUE;
}
/* Frees LOOP. */
{
struct loop_trns *loop = loop_;
- pool_destroy (loop->pool);
- return true;
-}
-
-/* Finishes a pass through the loop and starts the next. */
-static int
-end_loop_trns_proc (void *loop_, struct ccase **c, casenumber case_num UNUSED)
-{
- struct loop_trns *loop = loop_;
-
- if (loop->end_loop_condition != NULL
- && expr_evaluate_num (loop->end_loop_condition, *c, case_num) != 0.0)
- goto break_out;
-
- /* MXLOOPS limiter. */
- if (loop->max_pass_count >= 0 && ++loop->pass >= loop->max_pass_count)
- goto break_out;
-
- /* Indexing clause limiter: counting downward. */
- if (loop->index_var != NULL)
- {
- loop->cur += loop->by;
- if ((loop->by > 0.0 && loop->cur > loop->last)
- || (loop->by < 0.0 && loop->cur < loop->last))
- goto break_out;
- *c = case_unshare (*c);
- *case_num_rw (*c, loop->index_var) = loop->cur;
- }
-
- if (loop->loop_condition != NULL
- && expr_evaluate_num (loop->loop_condition, *c, case_num) != 1.0)
- goto break_out;
-
- return loop->past_LOOP_index;
+ expr_free (loop->first);
+ expr_free (loop->by);
+ expr_free (loop->last);
- break_out:
- return loop->past_END_LOOP_index;
-}
+ expr_free (loop->loop_condition);
+ expr_free (loop->end_loop_condition);
-/* Executes BREAK. */
-static int
-break_trns_proc (void *loop_, struct ccase **c UNUSED,
- casenumber case_num UNUSED)
-{
- struct loop_trns *loop = loop_;
+ transformations_destroy (loop->xforms, loop->n_xforms);
- return loop->past_END_LOOP_index;
+ free (loop);
+ return true;
}
-
-/* LOOP control structure class definition. */
-static const struct ctl_class loop_class =
- {
- "LOOP",
- "END LOOP",
- close_loop,
- };
projects / pspp / blobdiff