#include "dawg.h"

long *dawg, root;
long dictroot;

setdawg (space, len) long *space; long len;
{
	dawg = space;
	root = dawg[(len / sizeof (long)) - 1];
}

long lookup (t, s) register long t; register char *s;
{
    register long *p;
    register c;

    while (c = *s++) {
	t = ptr(t);
	if (!t)
	    return 0L;
	p = dawg + t;
	c = chr (c);
	while (chrl (*p++) < c);
	if (chr (*--p) == c)
	    t = *p;
	else
	    return 0L;
    }
    return t;
}

long dictlookup (s) char *s;
{
	return lookup (root, s);
}

isword (s) char *s;
{
	return term (lookup (dictroot, s));
}

static char work[16];

nextword (word, next) char *word, *next;
{
	if (findnext (work, word, dictroot)) {
		strcpy (next, work);
		return 1;
	}
	return 0;
}

prevword (word, prev) char *word, *prev;
{
	if (findprev (work, word, dictroot)) {
		strcpy (prev, work);
		return 1;
	}
	return 0;
}

findprev (buf, w, n) register char *buf; char *w; long n;
{
	register long *p;
	long *startp;
	register char c;
	register long e;

	e = ptr (n);
	c = *w;
	if (e) {
		startp = p = dawg + e;
		while (chrl (*p++) < c);
		if (chr (*--p) == c) {
			*buf = c;
			if (findprev (buf + 1, w + 1, *p))
				return 1;
		}
		if (chr (*p) < c || --p  >= startp) {
			findlast (buf, *p);
			return 1;
		}
	}
	if (term (n) && c) {
	    *buf = '\0';
	    return 1;
	}
	return 0;
}		

findnext (buf, w, n) register char *buf; char *w; register long n;
{
	register long *p;
	register char c;

	n = ptr (n);
	if (!n)
		return 0;

	c = *w;
	p = dawg + n;
	while (chrl (*p++) < c);
	if (chr (*--p) == c) {
		*buf = c;
		if (findnext (buf + 1, w + 1, *p))
			return 1;
		if (!last (*p)) {
			findfirst (buf, p[1]);
			return 1;
		}
	}
	else if (chr(*p) > c) {
		findfirst (buf, *p);
		return 1;
	}
	return 0;
}

findfirst (buf, e) register char *buf; register long e;
{
	*buf++ = chr (e);
	if (term (e))
		*buf = '\0';
	else
		findfirst (buf, dawg[ptr(e)]);
}

findlast (buf, e) register char *buf; register long e;
{
	register long n;
	register long *p;

	*buf++ = chr (e);
	n = ptr (e);
	if (!n)
		*buf = '\0';
	else {
		p = dawg + n;
		while (!last(*p++));
		findlast (buf, *--p);
	}
}