Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
-/* AIX requires this to be the first thing in the file. */
#include <config.h>
-#if __GNUC__
-#define alloca __builtin_alloca
-#else
-#if HAVE_ALLOCA_H
-#include <alloca.h>
-#else
-#ifdef _AIX
-#pragma alloca
-#else
-#ifndef alloca /* predefined by HP cc +Olibcalls */
-char *alloca ();
-#endif
-#endif
-#endif
-#endif
#if TIME_WITH_SYS_TIME
#include <sys/time.h>
#endif
#include <ctype.h>
+#include "expr.h"
+#include "exprP.h"
#include <assert.h>
#include <math.h>
#include <errno.h>
#include "approx.h"
#include "data-in.h"
#include "error.h"
-#include "expr.h"
-#include "exprP.h"
#include "julcal/julcal.h"
#include "magic.h"
+#include "pool.h"
#include "random.h"
#include "stats.h"
#include "str.h"
#include "var.h"
-#include "vector.h"
#include "vfm.h"
#include "vfmP.h"
efficient if I hand-coded it in assembly for a dozen processors,
but I'm not going to do that either. */
-/* These macros are defined differently depending on the way that
- the stack is managed. (i.e., I have to adapt the code to inferior
- environments.)
-
- void CHECK_STRING_SPACE(int x): Assure that at least X+1 bytes of
- space are available in the string evaluation stack.
-
- unsigned char *ALLOC_STRING_SPACE(int x): Return a pointer to X+1
- bytes of space. CHECK_STRING_SPACE must have previously been
- called with an argument of at least X. */
-
-#if PAGED_STACK
-#define CHECK_STRING_SPACE(X) /* nothing to do! */
-#define ALLOC_STRING_SPACE(X) \
- alloca((X) + 1)
-#else /* !PAGED_STACK */
-#define CHECK_STRING_SPACE(X) \
- do \
- { \
- if (str_stk + X >= str_end) \
- { \
- e->str_size += 1024; \
- e->str_stk = xrealloc (e->str_stk, e->str_size); \
- str_end = e->str_stk + e->str_size - 1; \
- } \
- } \
- while (0)
-
-#define ALLOC_STRING_SPACE(X) \
- (str_stk += X + 1, str_stk - X - 1)
-#endif /* !PAGED_STACK */
-
double
expr_evaluate (struct expression *e, struct ccase *c, union value *v)
{
unsigned char *op = e->op;
double *dbl = e->num;
unsigned char *str = e->str;
-#if !PAGED_STACK
- unsigned char *str_stk = e->str_stk;
- unsigned char *str_end = e->str_stk + e->str_size - 1;
-#endif
struct variable **vars = e->var;
int i, j;
/* Stack pointer. */
union value *sp = e->stack;
+ pool_clear (e->pool);
+
for (;;)
{
switch (*op++)
sp->f *= 60. * 60. * 24.;
break;
case OP_DATE_MOYR:
- (--sp)->f = yrmoda (sp[1].f, sp[0].f, 1);
+ sp--;
+ sp->f = yrmoda (sp[1].f, sp[0].f, 1);
if (sp->f != SYSMIS)
sp->f *= 60. * 60. * 24.;
break;
int n_args = *op++;
unsigned char *dest;
- CHECK_STRING_SPACE (255);
- dest = ALLOC_STRING_SPACE (255);
+ dest = pool_alloc (e->pool, 256);
dest[0] = 0;
sp -= n_args - 1;
{
unsigned char *dest;
- CHECK_STRING_SPACE (len);
- dest = ALLOC_STRING_SPACE (len);
+ dest = pool_alloc (e->pool, len + 1);
dest[0] = len;
memset (&dest[1], ' ', len - sp->c[0]);
memcpy (&dest[len - sp->c[0] + 1], &sp->c[1], sp->c[0]);
{
unsigned char *dest;
- CHECK_STRING_SPACE (len);
- dest = ALLOC_STRING_SPACE (len);
+ dest = pool_alloc (e->pool, len + 1);
dest[0] = len;
memset (&dest[1], sp[2].c[1], len - sp->c[0]);
memcpy (&dest[len - sp->c[0] + 1], &sp->c[1], sp->c[0]);
{
unsigned char *dest;
- CHECK_STRING_SPACE (len);
- dest = ALLOC_STRING_SPACE (len);
+ dest = pool_alloc (e->pool, len + 1);
dest[0] = len;
memcpy (&dest[1], &sp->c[1], sp->c[0]);
memset (&dest[sp->c[0] + 1], ' ', len - sp->c[0]);
{
unsigned char *dest;
- CHECK_STRING_SPACE (len);
- dest = ALLOC_STRING_SPACE (len);
+ dest = pool_alloc (e->pool, len + 1);
dest[0] = len;
memcpy (&dest[1], &sp->c[1], sp->c[0]);
memset (&dest[sp->c[0] + 1], sp[2].c[1], len - sp->c[0]);
f.w = *op++;
f.d = *op++;
- CHECK_STRING_SPACE (f.w);
- dest = ALLOC_STRING_SPACE (f.w);
+ dest = pool_alloc (e->pool, f.w + 1);
dest[0] = f.w;
data_out (&dest[1], &f, sp);
break;
case OP_NORMAL:
if (sp->f != SYSMIS)
- sp->f = rand_normal (sp->f);
+ sp->f *= rng_get_double_normal (pspp_rng ());
break;
case OP_UNIFORM:
if (sp->f != SYSMIS)
- sp->f = rand_uniform (sp->f);
+ sp->f *= rng_get_double (pspp_rng ());
break;
case OP_SYSMIS:
if (sp[0].f == SYSMIS || !finite (sp[0].f))
case OP_VEC_ELEM_NUM:
{
int rindx = sp[0].f + EPSILON;
- struct vector *v = &vec[*op++];
+ const struct vector *v = dict_get_vector (default_dict, *op++);
- if (sp[0].f == SYSMIS || rindx < 1 || rindx > v->nv)
+ if (sp[0].f == SYSMIS || rindx < 1 || rindx > v->cnt)
{
if (sp[0].f == SYSMIS)
msg (SE, _("SYSMIS is not a valid index value for vector "
sp->f = SYSMIS;
break;
}
- sp->f = c->data[v->v[rindx - 1]->fv].f;
+ sp->f = c->data[v->var[rindx - 1]->fv].f;
}
break;
case OP_VEC_ELEM_STR:
{
int rindx = sp[0].f + EPSILON;
- struct vector *vect = &vec[*op++];
+ const struct vector *vect = dict_get_vector (default_dict, *op++);
struct variable *v;
- if (sp[0].f == SYSMIS || rindx < 1 || rindx > vect->nv)
+ if (sp[0].f == SYSMIS || rindx < 1 || rindx > vect->cnt)
{
if (sp[0].f == SYSMIS)
msg (SE, _("SYSMIS is not a valid index value for vector "
msg (SE, _("%g is not a valid index value for vector %s. "
"The result will be set to the empty string."),
sp[0].f, vect->name);
- CHECK_STRING_SPACE (0);
- sp->c = ALLOC_STRING_SPACE (0);
+ sp->c = pool_alloc (e->pool, 1);
sp->c[0] = 0;
break;
}
- v = vect->v[rindx - 1];
- CHECK_STRING_SPACE (v->width);
- sp->c = ALLOC_STRING_SPACE (v->width);
+ v = vect->var[rindx - 1];
+ sp->c = pool_alloc (e->pool, v->width + 1);
sp->c[0] = v->width;
memcpy (&sp->c[1], c->data[v->fv].s, v->width);
}
break;
case OP_STR_CON:
sp++;
- CHECK_STRING_SPACE (*str);
- sp->c = ALLOC_STRING_SPACE (*str);
+ sp->c = pool_alloc (e->pool, *str + 1);
memcpy (sp->c, str, *str + 1);
str += *str + 1;
break;
int width = (*vars)->width;
sp++;
- CHECK_STRING_SPACE (width);
- sp->c = ALLOC_STRING_SPACE (width);
+ sp->c = pool_alloc (e->pool, width + 1);
sp->c[0] = width;
memcpy (&sp->c[1], &c->data[(*vars)->fv], width);
vars++;
int width = (*vars)->width;
sp++;
- CHECK_STRING_SPACE (width);
- sp->c = ALLOC_STRING_SPACE (width);
+ sp->c = pool_alloc (e->pool, width + 1);
sp->c[0] = width;
if (c == NULL)
case OP_SENTINEL:
goto finished;
-#if __CHECKER__
- /* This case prevents Checker from choking. */
- case 42000:
- assert (0);
-#endif
-
default:
#if GLOBAL_DEBUGGING
printf (_("evaluate_expression(): not implemented: %s\n"),
{
assert (v);
-#if PAGED_STACK
- memcpy (e->str_stack, sp->c, sp->c[0] + 1);
- v->c = e->str_stack;
-#else
v->c = sp->c;
-#endif
return 0.0;
}
projects / pspp / blobdiff