#include "private.h"
#include <ctype.h>
-#include "alloc.h"
-#include "message.h"
+#include <libpspp/alloc.h>
+#include <libpspp/assertion.h>
+#include <libpspp/message.h>
#include "helpers.h"
#include "evaluate.h"
-#include "pool.h"
+#include <libpspp/pool.h>
static void
expr_evaluate (struct expression *e, const struct ccase *c, int case_idx,
void *result)
{
+ struct dataset *ds = e->ds;
union operation_data *op = e->ops;
double *ns = e->number_stack;
- struct fixed_string *ss = e->string_stack;
+ struct substring *ss = e->string_stack;
+
+ /* Without a dictionary/dataset, the expression can't refer to variables,
+ and you don't need to specify a case when you evaluate the
+ expression. With a dictionary/dataset, the expression can refer
+ to variables, so you must specify a case when you evaluate the
+ expression. */
+ assert ((c != NULL) == (e->ds != NULL));
- assert ((c != NULL) == (e->dict != NULL));
pool_clear (e->eval_pool);
for (;;)
case OP_string:
{
- const struct fixed_string *s = &op++->string;
+ const struct substring *s = &op++->string;
*ss++ = copy_string (e, s->string, s->length);
}
break;
return;
case OP_return_string:
- *(struct fixed_string *) result = ss[-1];
+ *(struct substring *) result = ss[-1];
return;
#include "evaluate.inc"
default:
- abort ();
+ NOT_REACHED ();
}
}
}
return d;
}
+
+
void
expr_evaluate_str (struct expression *e, const struct ccase *c, int case_idx,
char *dst, size_t dst_size)
{
- struct fixed_string s;
+ struct substring s;
assert (e->type == OP_string);
assert ((dst == NULL) == (dst_size == 0));
expr_evaluate (e, c, case_idx, &s);
+
buf_copy_rpad (dst, dst_size, s.string, s.length);
}
\f
-#include "lexer.h"
-#include "command.h"
+#include <language/lexer/lexer.h>
+#include <language/command.h>
int
-cmd_debug_evaluate (void)
+cmd_debug_evaluate (struct dataset *dsother UNUSED)
{
bool optimize = true;
int retval = CMD_FAILURE;
bool dump_postfix = false;
- struct dictionary *d = NULL;
+
struct ccase *c = NULL;
+ struct dataset *ds = NULL;
+
struct expression *expr;
for (;;)
{
+ struct dictionary *d = NULL;
if (lex_match_id ("NOOPTIMIZE"))
optimize = 0;
else if (lex_match_id ("POSTFIX"))
else if (token == T_STRING)
{
width = ds_length (&tokstr);
- fprintf (stderr, "(%s = \"%.2s\")", name, ds_c_str (&tokstr));
+ fprintf (stderr, "(%s = \"%.2s\")", name, ds_cstr (&tokstr));
}
else
{
lex_error (_("expecting number or string"));
goto done;
}
-
- if (d == NULL)
- d = dict_create ();
+
+ if ( ds == NULL )
+ {
+ ds = create_dataset ();
+ d = dataset_dict (ds);
+ }
old_value_cnt = dict_get_next_value_idx (d);
v = dict_create_var (d, name, width);
if (c == NULL)
{
c = xmalloc (sizeof *c);
- case_nullify (c);
+ case_create (c, dict_get_next_value_idx (d));
}
- case_resize (c, old_value_cnt, dict_get_next_value_idx (d));
+ else
+ case_resize (c, old_value_cnt, dict_get_next_value_idx (d));
if (lex_is_number ())
case_data_rw (c, v->fv)->f = tokval;
lex_force_match ('/');
goto done;
}
- if (d != NULL)
- fprintf (stderr, "; ");
+
+ if ( ds != NULL )
+ fprintf(stderr, "; ");
fprintf (stderr, "%s => ", lex_rest_of_line (NULL));
lex_get ();
- expr = expr_parse_any (d, optimize);
+ expr = expr_parse_any (ds, optimize);
if (!expr || lex_end_of_command () != CMD_SUCCESS)
{
if (expr != NULL)
case OP_string:
{
- struct fixed_string s;
+ struct substring s;
expr_evaluate (expr, c, 0, &s);
fputc ('"', stderr);
}
default:
- assert (0);
+ NOT_REACHED ();
}
expr_free (expr);
retval = CMD_SUCCESS;
done:
+ if (ds)
+ destroy_dataset (ds);
+
if (c != NULL)
{
case_destroy (c);
free (c);
}
- dict_destroy (d);
+
return retval;
}
fprintf (stderr, "i<%d>", op->integer);
break;
default:
- abort ();
+ NOT_REACHED ();
}
}
fprintf (stderr, "\n");