02111-1307, USA. */
#include <config.h>
+#include "expr.h"
+#include "exprP.h"
#include <assert.h>
#include <ctype.h>
#include <float.h>
#include <stdlib.h>
+#include "algorithm.h"
#include "alloc.h"
#include "error.h"
-#include "expr.h"
-#include "exprP.h"
#include "lexer.h"
#include "misc.h"
#include "str.h"
#include "var.h"
-#include "vector.h"
#include "vfm.h"
+#include "pool.h"
\f
/* Declarations. */
union any_node *);
static int type_check (union any_node **n, int type, int flags);
+static algo_compare_func compare_functions;
static void init_func_tab (void);
-static int cmp_func (const void *a, const void *b);
#if DEBUGGING
static void debug_print_tree (union any_node *, int);
free (e->num);
free (e->str);
free (e->stack);
- free (e->str_stack);
+ pool_destroy (e->pool);
free (e);
}
}
/* Otherwise, it must be a user variable. */
- v = find_variable (tokid);
+ v = dict_lookup_var (default_dict, tokid);
lex_get ();
if (v == NULL)
{
static int get_num_args (struct function *, int, union any_node **);
static int
-unary_func (struct function * f, int x unused, union any_node ** n)
+unary_func (struct function * f, int x UNUSED, union any_node ** n)
{
double divisor;
struct nonterm_node *c;
}
static int
-binary_func (struct function * f, int x unused, union any_node ** n)
+binary_func (struct function * f, int x UNUSED, union any_node ** n)
{
if (!get_num_args (f, 2, n))
return EX_ERROR;
}
static int
-ternary_func (struct function * f, int x unused, union any_node ** n)
+ternary_func (struct function * f, int x UNUSED, union any_node ** n)
{
if (!get_num_args (f, 3, n))
return EX_ERROR;
}
static int
-MISSING_func (struct function * f, int x unused, union any_node ** n)
+MISSING_func (struct function * f, int x UNUSED, union any_node ** n)
{
- if (token == T_ID && is_varname (tokid) && lex_look_ahead () == ')')
+ if (token == T_ID
+ && dict_lookup_var (default_dict, tokid) != NULL
+ && lex_look_ahead () == ')')
{
struct var_node *c = xmalloc (sizeof *c);
c->v = parse_variable ();
}
static int
-SYSMIS_func (struct function * f unused, int x unused, union any_node ** n)
+SYSMIS_func (struct function * f UNUSED, int x UNUSED, union any_node ** n)
{
int t;
- if (token == T_ID && is_varname (tokid) && lex_look_ahead () == ')')
+ if (token == T_ID
+ && dict_lookup_var (default_dict, tokid)
+ && lex_look_ahead () == ')')
{
struct variable *v;
v = parse_variable ();
}
static int
-VALUE_func (struct function *f unused, int x unused, union any_node **n)
+VALUE_func (struct function *f UNUSED, int x UNUSED, union any_node **n)
{
struct variable *v = parse_variable ();
}
static int
-LAG_func (struct function *f unused, int x unused, union any_node **n)
+LAG_func (struct function *f UNUSED, int x UNUSED, union any_node **n)
{
struct variable *v = parse_variable ();
int nlag = 1;
/* FIXME: Is this condition failsafe? Can we _ever_ have two
juxtaposed identifiers otherwise? */
- if (token == T_ID && is_varname (tokid)
+ if (token == T_ID && dict_lookup_var (default_dict, tokid) != NULL
&& toupper (lex_look_ahead ()) == 'T')
{
struct variable **v;
opts |= PV_NUMERIC;
else if (type == ALPHA)
opts |= PV_STRING;
- if (!parse_variables (NULL, &v, &nv, opts))
+ if (!parse_variables (default_dict, &v, &nv, opts))
goto fail;
if (nv + (*n)->nonterm.n >= m)
{
}
static int
-CONCAT_func (struct function * f unused, int x unused, union any_node ** n)
+CONCAT_func (struct function * f UNUSED, int x UNUSED, union any_node ** n)
{
int m = 0;
arg; and `f', format spec (this must be the last arg). If the
optional args are included, the type becomes f->t+1. */
static int
-generic_str_func (struct function *f, int x unused, union any_node ** n)
+generic_str_func (struct function *f, int x UNUSED, union any_node ** n)
{
int max_args = 0;
int type;
char fname[32], *cp;
int t;
int min_args;
- struct vector *v;
+ const struct vector *v;
/* Check for a vector with this name. */
- v = find_vector (tokid);
+ v = dict_lookup_vector (default_dict, tokid);
if (v)
{
lex_get ();
*n = xmalloc (sizeof (struct nonterm_node)
+ sizeof (union any_node *[2]));
- (*n)->nonterm.type = (v->v[0]->type == NUMERIC
+ (*n)->nonterm.type = (v->var[0]->type == NUMERIC
? OP_VEC_ELEM_NUM : OP_VEC_ELEM_STR);
(*n)->nonterm.n = 0;
msg (SE, _("`)' expected after a vector index value."));
goto fail;
}
- ((*n)->nonterm.arg[1]) = (union any_node *) v->index;
+ ((*n)->nonterm.arg[1]) = (union any_node *) v->idx;
- return v->v[0]->type == NUMERIC ? EX_NUMERIC : EX_STRING;
+ return v->var[0]->type == NUMERIC ? EX_NUMERIC : EX_STRING;
}
ds_truncate (&tokstr, 31);
struct function f;
f.s = fname;
- fp = bsearch (&f, func_tab, func_count, sizeof *func_tab, cmp_func);
+ fp = binary_search (func_tab, func_count, sizeof *func_tab, &f,
+ compare_functions, NULL);
}
if (!fp)
default:
assert (0);
+ return 0;
}
-#if __GNUC__ || __BORLANDC__
- return 0;
-#endif
}
static const char *
return _("string");
default:
assert (0);
+ return 0;
}
-#if __GNUC__ || __BORLANDC__
- return 0;
-#endif
}
static void
{"SUBSTR", OP_SUBSTR, generic_str_func, "ssn/n"},
};
+/* An algo_compare_func that compares functions A and B based on
+ their names. */
static int
-cmp_func (const void *a, const void *b)
+compare_functions (const void *a_, const void *b_, void *aux UNUSED)
{
- return strcmp (*(char **) a, *(char **) b);
+ const struct function *a = a_;
+ const struct function *b = b_;
+
+ return strcmp (a->s, b->s);
}
static void
}
func_count = sizeof func_tab / sizeof *func_tab;
- qsort (func_tab, func_count, sizeof *func_tab, cmp_func);
+ sort (func_tab, func_count, sizeof *func_tab, compare_functions, NULL);
}
\f
/* Debug output. */