dssopen.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 2002-2012 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                 Eclipse Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*          http://www.eclipse.org/org/documents/epl-v10.html           *
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <[email protected]>                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * dss open/close/library/method implementation
 *
 * Glenn Fowler
 * AT&T Research
 */

static const char usage[] =
"[-1ls5P?\n@(#)$Id: dss library (AT&T Research) 2012-05-31 $\n]"
USAGE_LICENSE
"[+PLUGIN?\findex\f]"
"[+DESCRIPTION?The \bdss\b default method provides types, global "
    "variables, and a schema available for all other methods.]"
"{\fvariables\f}"
"[+?The schema is a pure XML (tags "
    "only) file that specifies the \bdss\b method and optional field value "
    "maps and constraints. Public schemas are usually placed in a "
    "\b../lib/dss\b sibling directory on \b$PATH\b. The supported tags are:]"
"{"
;

#include "dsshdr.h"

#include <dlldefs.h>
#include <pzip.h>
#include <stak.h>

typedef Dsslib_t* (*Dsslib_f)(const char*, Dssdisc_t*);

static const char	id[] = DSS_ID;

static Dssstate_t	state;

#define DSS_MEM_file		1
#define DSS_MEM_format		2
#define DSS_MEM_length		3
#define DSS_MEM_offset		4
#define DSS_MEM_queried		5
#define DSS_MEM_record		6
#define DSS_MEM_selected	7

static Cxvariable_t dss_mem_struct[] =
{
CXV("file",     "string", DSS_MEM_file,     "Current record file name.")
CXV("format",   "string", DSS_MEM_format,   "Current record format.")
CXV("length",   "number", DSS_MEM_length,   "Current record length (always 0 for some formats.)")
CXV("offset",   "number", DSS_MEM_offset,   "Current record offset (always 0 for some formats.).")
CXV("queried",  "number", DSS_MEM_queried,  "Current queried record count.")
CXV("record",   "number", DSS_MEM_record,   "Current record number.")
CXV("selected", "number", DSS_MEM_selected, "Current selected record count.")
{0}
};

/*
 * find and open file for read
 */

Sfio_t*
dssfind(const char* name, const char* suffix, Dssflags_t flags, char* path, size_t size, Dssdisc_t* disc)
{
	Sfio_t*		sp;

	if (!suffix)
		suffix = id;
	if (*name == ':')
	{
		sfsprintf(path, size, "%s", "schema-string");
		sp = sfnew(NiL, (char*)name + 1, strlen(name) - 1, -1, SF_READ|SF_STRING);
	}
	else if (!pathfind(name, id, suffix, path, size))
	{
		if ((flags & DSS_VERBOSE) && disc->errorf)
			(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "%s: %s file not found", name, suffix);
		return 0;
	}
	else
		sp = sfopen(NiL, path, "r");
	if (!sp)
	{
		if ((flags & DSS_VERBOSE) && disc->errorf)
			(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "%s: cannot read %s file", path, suffix);
		return 0;
	}
	return sp;
}

/*
 * load tags file
 */

static Dssmeth_t*
loadtags(const char* name, const char* suffix, Dssdisc_t* disc, Dssmeth_t* meth)
{
	Sfio_t*		sp;
	char		path[PATH_MAX];

	if (streq(name, DSS_ID))
		return meth;
	if (!(sp = dssfind(name, suffix, DSS_VERBOSE, path, sizeof(path), disc)))
		return 0;
	return dsstags(sp, path, 1, 0, disc, meth);
}

/*
 * dss identf
 */

static int
dssidentf(Dssfile_t* file, void* buf, size_t size, Dssdisc_t* disc)
{
	register char*	s;
	register char*	e;

	s = (char*)buf;
	e = s + size;
	while (s < e && isspace(*s))
		s++;
	if (*s++ != '<')
		return 0;
	if (*s == '!')
		while (s < e && *s++ != '!');
	else
		while (s < e && isalpha(*s))
			s++;
	return s < e && *s == '>';
}

/*
 * dss openf
 */

static int
dssopenf(Dssfile_t* file, Dssdisc_t* disc)
{
	return 0;
}

/*
 * dss readf
 */

static int
dssreadf(Dssfile_t* file, Dssrecord_t* record, Dssdisc_t* disc)
{
	return 0;
}

/*
 * dss writef
 */

static int
dsswritef(Dssfile_t* file, Dssrecord_t* record, Dssdisc_t* disc)
{
	return 0;
}

/*
 * dss seekf
 */

static Sfoff_t
dssseekf(Dssfile_t* file, Sfoff_t offset, Dssdisc_t* disc)
{
	return 0;
}

/*
 * dss closef
 */

static int
dssclosef(Dssfile_t* file, Dssdisc_t* disc)
{
	return 0;
}

static Dssformat_t	dss_format =
{
	&id[0],
	"pseudo-format that treats all files as /dev/null",
	CXH,
	dssidentf,
	dssopenf,
	dssreadf,
	dsswritef,
	dssseekf,
	dssclosef
};

static Dssmeth_t*	dssmethf(const char*, const char*, const char*, Dssdisc_t*, Dssmeth_t*);

static Dssmeth_t	dss_method =
{
	&id[0],
	"meta-method that specifies a method, value maps and constraints",
	CXH,
	dssmethf
};

/*
 * dss methf
 */

static Dssmeth_t*
dssmethf(const char* name, const char* options, const char* schema, Dssdisc_t* disc, Dssmeth_t* meth)
{
	Sfio_t*		up;
	char*		us;
	Tagdisc_t	tagdisc;

	if (options)
	{
		if (!(up = sfstropen()))
		{
			if (disc->errorf)
				(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
			return 0;
		}
		sfprintf(up, "%s", usage);
		taginit(&tagdisc, disc->errorf);
		if (tagusage(dss_tags, up, &tagdisc))
		{
			sfclose(up);
			return 0;
		}
		sfputc(up, '}');
		sfputc(up, '\n');
		if (!(us = sfstruse(up)))
		{
			sfclose(up);
			return 0;
		}
		dss_method.data = dss_mem_struct;
		state.global = &dss_method;
		for (;;)
		{
			switch (optstr(options, us))
			{
			case '?':
				if (disc->errorf)
					(*disc->errorf)(NiL, disc, ERROR_USAGE|4, "%s", opt_info.arg);
				return 0;
			case ':':
				if (disc->errorf)
					(*disc->errorf)(NiL, disc, 2, "%s", opt_info.arg);
				return 0;
			}
			break;
		}
		state.global = 0;
		sfclose(up);
	}
	if (schema)
		return loadtags(schema, NiL, disc, meth);
	dtinsert(meth->formats, &dss_format);
	return meth;
}

#include "dss-compress.h"
#include "dss-count.h"
#include "dss-null.h"
#include "dss-print.h"
#include "dss-return.h"
#include "dss-scan.h"
#include "dss-write.h"

static Cxquery_t	queries[] =
{
	QUERY_compress,
	QUERY_count,
	QUERY_null,
	QUERY_print,
	QUERY_return,
	QUERY_scan,
	QUERY_write,
	{0},
};

static Dsslib_t		dss_library =
{
	&id[0],
	"dss method",
	CXH,
	0,
	&dss_method,
	0,
	0,
	0,
	0,
	&queries[0],
	0,
	0,
	0
};

/*
 * initialize library given name and dlopen() handle
 */

static Dsslib_t*
init(void* dll, Dsslib_t* lib, const char* path, Dssflags_t flags, Dssdisc_t* disc)
{
	Dsslib_f	libf;
	char		buf[64];

	/*
	 * check for the Dsslib_t* function
	 */

	if (dll)
	{
		sfsprintf(buf, sizeof(buf), "%s_lib", id);
		lib = (libf = (Dsslib_f)dlllook(dll, buf)) ? (*libf)(path, disc) : (Dsslib_t*)0;
	}
	if (lib)
	{
		if (!(lib->path = (const char*)strdup(path)))
		{
			if (disc && disc->errorf)
				(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
			return 0;
		}
		if (!dtsearch(state.cx->libraries, lib))
			dtinsert(state.cx->libraries, lib);
		return lib;
	}
	if ((flags & DSS_VERBOSE) && disc && disc->errorf)
		(*disc->errorf)(NiL, disc, 2, "%s: %s: initialization function not found in library", path, buf);
	return 0;
}

/*
 * open and return library info for name
 * name==0 scans for all related libraries on $PATH
 */

Dsslib_t*
dsslib(const char* name, Dssflags_t flags, Dssdisc_t* disc)
{
	register Dsslib_t*	lib;
	Dllscan_t*		dls;
	Dllent_t*		dle;
	void*			dll;
	Dllnames_t		names;

	dssstate(disc);
	if (!name)
	{
		if (!state.scanned)
		{
			state.scanned++;
			if (dtsize(state.cx->libraries) == 1 && (dls = dllsopen(id, NiL, NiL)))
			{
				while (dle = dllsread(dls))
					if (dll = dlopen(dle->path, RTLD_LAZY))
						init(dll, NiL, dle->path, 0, disc);
					else if (disc && disc->errorf)
						(*disc->errorf)(NiL, disc, 1, "%s: %s", dle->path, dlerror());
				dllsclose(dls);
			}
		}
		return (Dsslib_t*)dtfirst(state.cx->libraries);
	}
	if (!dllnames(id, name, &names))
		return 0;
	if ((lib = (Dsslib_t*)dtmatch(state.cx->libraries, names.base)) ||
	    (lib = (Dsslib_t*)dll_lib(&names, DSS_PLUGIN_VERSION, (flags & DSS_VERBOSE) ? (Error_f)disc->errorf : (Error_f)0, disc)))
		init(NiL, lib, names.path, flags|DSS_VERBOSE, disc);
	return lib;
}

/*
 * add lib tables
 */

int
dssadd(register Dsslib_t* lib, Dssdisc_t* disc)
{
	register int	i;

	if (lib->header.flags & CX_INITIALIZED)
		return 0;
	lib->header.flags |= CX_INITIALIZED;
	if (lib->libraries)
		for (i = 0; lib->libraries[i]; i++)
			if (!dssload(lib->libraries[i], disc))
				return -1;
	if (lib->types)
		for (i = 0; lib->types[i].name; i++)
			if (cxaddtype(NiL, &lib->types[i], disc))
				return -1;
	if (lib->callouts)
		for (i = 0; lib->callouts[i].callout; i++)
			if (cxaddcallout(NiL, &lib->callouts[i], disc))
				return -1;
	if (lib->recodes)
		for (i = 0; lib->recodes[i].recode; i++)
			if (cxaddrecode(NiL, &lib->recodes[i], disc))
				return -1;
	if (lib->maps)
		for (i = 0; lib->maps[i]; i++)
			if (cxaddmap(NiL, lib->maps[i], disc))
				return -1;
	if (lib->queries)
		for (i = 0; lib->queries[i].name; i++)
			if (cxaddquery(NiL, &lib->queries[i], disc))
				return -1;
	if (lib->constraints)
		for (i = 0; lib->constraints[i].name; i++)
			if (cxaddconstraint(NiL, &lib->constraints[i], disc))
				return -1;
	if (lib->edits)
		for (i = 0; lib->edits[i].name; i++)
			if (cxaddedit(NiL, &lib->edits[i], disc))
				return -1;
	if (!dtsearch(state.cx->libraries, lib))
		dtinsert(state.cx->libraries, lib);
	return 0;
}

/*
 * find and add library name
 */

Dsslib_t*
dssload(const char* name, Dssdisc_t* disc)
{
	Dsslib_t*	lib;

	if (!(lib = dsslib(name, DSS_VERBOSE, disc)))
		return 0;
	return dssadd(lib, disc) ? 0 : lib;
}

/*
 * return the input location string for data
 * suitable for errorf
 */

static char*
location(Cx_t* cx, void* data, Cxdisc_t* disc)
{
	register Dssfile_t*	file = DSSRECORD(data)->file;
	char*			path;
	char*			sep;
	char*			loc;
	char*			nxt;
	char*			end;
	size_t			n;

	if (!file)
		return "";
	if (path = strrchr(file->path, '/'))
		path++;
	else
		path = file->path;
	n = strlen(path) + 3;
	sep = ": ";
	if (file->count || file->offset)
	{
		sep = ", ";
		n += 64;
	}
	loc = nxt = fmtbuf(n);
	end = loc + n;
	nxt += sfsprintf(nxt, end - nxt, "%s%s", path, sep);
	if (file->count || file->offset)
		sfsprintf(nxt, end - nxt, "%s %I*u, %s %I*d: ", ERROR_translate(NiL, NiL, id, "record"), sizeof(file->count), file->count, ERROR_translate(NiL, NiL, id, "offset"), sizeof(file->offset), file->offset);
	return loc;
}

static int
dss_mem_get(Cx_t* cx, Cxinstruction_t* pc, Cxoperand_t* r, Cxoperand_t* a, Cxoperand_t* b, void* data, Cxdisc_t* disc)
{
	Dssfile_t*	file = DSSRECORD(data)->file;

	switch (pc->data.variable->index)
	{
	case DSS_MEM_file:
		r->value.string.data = (char*)file->path;
		r->value.string.size = strlen(file->path);
		break;
	case DSS_MEM_format:
		r->value.string.data = (char*)file->format->name;
		r->value.string.size = strlen(file->format->name);
		break;
	case DSS_MEM_length:
		r->value.number = file->length;
		break;
	case DSS_MEM_offset:
		r->value.number = file->offset;
		break;
	case DSS_MEM_queried:
		r->value.number = cx->expr ? cx->expr->parent->queried : 0;
		break;
	case DSS_MEM_record:
		r->value.number = file->count;
		break;
	case DSS_MEM_selected:
		r->value.number = cx->expr ? cx->expr->parent->selected : 0;
		break;
	default:
		return -1;
	}
	return 0;
}

static Cxmember_t	dss_mem =
{
	dss_mem_get,
	0,
	(Dt_t*)&dss_mem_struct[0]
};

static Cxtype_t		dss_type[] =
{
	{ DSS_ID "_s", "Global state struct.", CXH, (Cxtype_t*)"void", 0, 0, 0, 0, 0, 0, 0, {0}, 0, &dss_mem },
	{ DSS_ID "_t", "Global state.", CXH, (Cxtype_t*)DSS_ID "_s" },
};

static Cxvariable_t	dss_var[] =
{
	CXV(".",	DSS_ID "_t",	0,	"Global State.")
	CXV(DSS_ID,	DSS_ID "_t",	0,	"Global State.")
};

/*
 * open a dss session
 */

Dss_t*
dssopen(Dssflags_t flags, Dssflags_t test, Dssdisc_t* disc, Dssmeth_t* meth)
{
	register Dss_t*		dss;
	register Vmalloc_t*	vm;
	Cxvariable_t*		var;
	Dsslib_t*		lib;
	int			i;

	if (!disc)
		return 0;
	dssstate(disc);
	if (!meth)
	{
		/*
		 * find the first user library that defines a method
		 */

		lib = (Dsslib_t*)dtfirst(state.cx->libraries);
		while ((lib = (Dsslib_t*)dtnext(state.cx->libraries, lib)) && !lib->meth);
		if (lib)
			meth = lib->meth;
		else
		{
			if (!(flags & DSS_QUIET) && disc->errorf)
				(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "a method must be specified");
			return 0;
		}
	}
	if (!(vm = vmopen(Vmdcheap, Vmbest, 0)))
	{
		if (disc->errorf)
			(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
		return 0;
	}
	if (!(dss = vmnewof(vm, 0, Dss_t, 1, 0)))
	{
		if (disc->errorf)
			(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
		vmclose(vm);
		return 0;
	}
	if (!disc->loadf)
		disc->loadf = dssload;
	if (!disc->locationf)
		disc->locationf = location;
	dss->id = id;
	dss->vm = vm;
	dss->disc = disc;
	if (!meth->cx || (meth->flags & DSS_BASE))
		meth = dssmethinit(NiL, NiL, NiL, disc, meth);
	dss->meth = meth;
	dss->flags = flags;
	dss->test = test;
	dss->state = &state;
	if (!(dss->cx = cxscope(NiL, meth->cx, flags & DSS_CX_FLAGS, test, disc)) || disc->map && !loadtags(disc->map, "map", disc, meth))
		goto bad;
	dss->cx->caller = dss;
	if (meth->openf && (*meth->openf)(dss, dss->disc))
		goto bad;
	for (var = (Cxvariable_t*)dtfirst(dss->cx->variables); var; var = (Cxvariable_t*)dtnext(dss->cx->variables, var))
		if (var->format.map)
			var->format.map->header.flags |= CX_REFERENCED;
	for (i = 0; i < elementsof(dss_type); i++)
		if (!cxtype(NiL, dss_type[i].name, disc) && cxaddtype(NiL, &dss_type[i], disc))
			goto bad;
	for (i = 0; i < elementsof(dss_var); i++)
	{
		if (!(var = vmnewof(vm, 0, Cxvariable_t, 1, 0)))
			goto bad;
		*var = dss_var[i];
		var->header.flags |= CX_INITIALIZED;
		if (cxaddvariable(dss->cx, var, disc))
			goto bad;
	}
	return state.dss = dss;
 bad:
	dssclose(dss);
	return 0;
}

/*
 * close a dss session
 */

int
dssclose(register Dss_t* dss)
{
	int	r;

	if (!dss)
		return -1;
	if (dss->meth->closef)
		r = (*dss->meth->closef)(dss, dss->disc);
	else
		r = 0;
	if (dss == state.dss)
		state.dss = 0;
	if (!dss->vm)
		r = -1;
	else
		vmclose(dss->vm);
	return r;
}

/*
 * initialize method given pointer
 * this is a library private global for dssmeth() and dssstatic()
 */

Dssmeth_t*
dssmethinit(const char* name, const char* options, const char* schema, Dssdisc_t* disc, Dssmeth_t* meth)
{
	Dssmeth_t*	ometh;
	Opt_t		opt;

	if (meth->flags & DSS_BASE)
	{
		if (!(ometh = newof(0, Dssmeth_t, 1, 0)))
		{
			if (disc->errorf)
				(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
			return 0;
		}
		*ometh = *meth;
		meth = ometh;
		meth->flags &= ~DSS_BASE;
		meth->cx = 0;
	}
	if (!meth->cx && !(meth->cx = cxopen(0, 0, disc)))
		return 0;
	if (!meth->formats && !(meth->formats = dtopen(&state.cx->namedisc, Dtoset)))
	{
		cxclose(meth->cx);
		if (disc->errorf)
			(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
		return 0;
	}
	if (name)
	{
		if (meth->methf)
		{
			ometh = meth;
			opt = opt_info;
			state.cx->header = (Cxheader_t*)meth;
			state.meth = meth;
			meth = (*meth->methf)(name, options, schema, disc, meth);
			opt_info = opt;
			if (!meth)
				return 0;
			if (meth != ometh)
				meth->reference++;
		}
		else if (options)
			return 0;
	}
	return state.meth = meth;
}

/*
 * return method given name
 */

Dssmeth_t*
dssmeth(const char* name, Dssdisc_t* disc)
{
	register char*	s;
	const char*	options;
	const char*	schema;
	Dsslib_t*	lib;
	Dssmeth_t*	meth;
	char		buf[1024];
	char		path[1024];

	buf[sfsprintf(buf, sizeof(buf) - 1, "%s", name)] = 0;
	options = schema = 0;
	for (s = buf; *s; s++)
		if (*s == ',' || *s == '\t' || *s == '\r' || *s == '\n')
		{
			if (!options)
			{
				*s++ = 0;
				options = (char*)s;
			}
		}
		else if (*s == ':')
		{
			*s++ = 0;
			schema = name + (s - buf);
			break;
		}
	name = (const char*)buf;
	if (!*name)
		name = id;
	if (!(meth = (Dssmeth_t*)dtmatch(state.cx->methods, name)))
	{
		if (pathfind(name, id, id, path, sizeof(path)))
		{
			meth = &dss_method;
			name = id;
			schema = path;
		}
		else if (!(lib = dsslib(name, 0, disc)) || !(meth = lib->meth) || dssadd(lib, disc))
			return 0;
	}
	return dssmethinit(name, options, schema, disc, meth);
}

/*
 * return initialized global state pointer
 */

Dssstate_t*
dssstate(Dssdisc_t* disc)
{
	if (!state.initialized && !state.initialized++)
	{
		error(-1, "%s", fmtident(usage));
		state.cx = cxstate(disc);
		dtinsert(state.cx->libraries, &dss_library);
		if (dssadd(&dss_library, disc))
			error(ERROR_PANIC, "%s library initialization error", id);
	}
	return &state;
}

/*
 * return 1 if expr contains a query
 */

static int
hasquery(register Dssexpr_t* expr)
{
	do
	{
		if (!expr->query->prog)
			return 1;
		if (expr->pass && hasquery(expr->pass))
			return 1;
		if (expr->fail && hasquery(expr->fail))
			return 1;
		if (expr->group && hasquery(expr->group))
			return 1;
	} while (expr = expr->next);
	return 0;
}

/*
 * apply expression with optional head and tail queries to files in argv
 */

int
dssrun(Dss_t* dss, const char* expression, const char* head, const char* tail, char** argv)
{
	register Dssexpr_t*	x;
	Dssexpr_t*		expr;
	Dssexpr_t*		xh;
	Dssexpr_t*		xt;
	int			errors;
	int			r;

	errors = error_info.errors;
	if (!expression || !*expression || *expression == '-' && !*(expression + 1))
		expression = tail ? tail : "{write}";
	if (!(expr = dsscomp(dss, expression, NiL)))
		return -1;
	xh = xt = 0;
	r = -1;
	if (expression == tail)
		tail = 0;
	else if (!tail && !hasquery(expr))
		tail = "{write}";
	if (tail)
	{
		if (!(xt = dsscomp(dss, tail, NiL)))
			goto bad;
		if (xt->query->beg == null_beg)
		{
			dssfree(dss, xt);
			xt = 0;
		}
	}
	for (x = expr; x->group; x = x->group);
	if (!x->query->head)
	{
		if (!head)
			head = "{scan}";
		if (!(xh = dsscomp(dss, head, NiL)))
			goto bad;
		if (!xh->query->head)
		{
			if (dss->disc->errorf)
				(*dss->disc->errorf)(dss, dss->disc, 2, "%s: not a head query", head);
			goto bad;
		}
		xh->files = argv;
	}
	else if (head)
	{
		if (dss->disc->errorf)
			(*dss->disc->errorf)(dss, dss->disc, 2, "%s: expression already has %s head", head, x->query->name);
		goto bad;
	}
	else
		x->files = argv;
	if (xh || xt)
	{
		if (expr->pass || expr->fail || expr->next)
		{
			if (!(x = vmnewof(expr->vm, 0, Cxexpr_t, 1, sizeof(Cxquery_t))))
			{
				if (dss->disc->errorf)
					(*dss->disc->errorf)(dss, dss->disc, ERROR_SYSTEM|2, "out of space");
				goto bad;
			}
			x->vm = expr->vm;
			x->done = expr->done;
			x->stack = expr->stack;
			x->op = expr->op;
			x->query = (Cxquery_t*)(x + 1);
			x->group = expr;
			expr = x;
		}
		if (xt)
		{
			expr->pass = xt;
			xt->parent = expr;
		}
		if (xh)
		{
			x = xh->pass = expr;
			expr = xh;
			xh = x;
		}
	}
	if (expr->pass)
		expr->pass->parent = expr->pass;
	if (dss->test & 0x00000100)
		dsslist(dss, expr, sfstdout);
	if (dssbeg(dss, expr) || dssend(dss, expr))
		goto bad;
	dssfree(dss, expr);
	r = error_info.errors != errors ? -1 : 0;
 bad:
	if (xh)
		dssfree(dss, xh);
	if (xt)
		dssfree(dss, xt);
	dssfree(dss, expr);
	return r;
}