/*

 * Utility functions for handling cvecs

 * This file is #included by regcomp.c.

 *

 * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.

 * 

 * Development of this software was funded, in part, by Cray Research Inc.,

 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics

 * Corporation, none of whom are responsible for the results.  The author

 * thanks all of them. 

 * 

 * Redistribution and use in source and binary forms -- with or without

 * modification -- are permitted for any purpose, provided that

 * redistributions in source form retain this entire copyright notice and

 * indicate the origin and nature of any modifications.

 * 

 * I'd appreciate being given credit for this package in the documentation

 * of software which uses it, but that is not a requirement.

 * 

 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,

 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY

 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL

 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 */

/*

 - newcvec - allocate a new cvec

 ^ static struct cvec *newcvec(int, int, int);

 */

static struct cvec *

newcvec(nchrs, nranges, nmcces)

    int nchrs;				/* to hold this many chrs... */

    int nranges;			/* ... and this many ranges... */

    int nmcces;				/* ... and this many MCCEs */

{

    size_t n;

    size_t nc;

    struct cvec *cv;

    nc = (size_t)nchrs + (size_t)nmcces*(MAXMCCE+1) + (size_t)nranges*2;

    n = sizeof(struct cvec) + (size_t)(nmcces-1)*sizeof(chr *)

	    + nc*sizeof(chr);

    cv = (struct cvec *)MALLOC(n);

    if (cv == NULL) {

	return NULL;

    }

    cv->chrspace = nchrs;

    cv->chrs = (chr *)&cv->mcces[nmcces];	/* chrs just after MCCE ptrs */

    cv->mccespace = nmcces;

    cv->ranges = cv->chrs + nchrs + nmcces*(MAXMCCE+1);

    cv->rangespace = nranges;

    return clearcvec(cv);

}

/*

 - clearcvec - clear a possibly-new cvec

 * Returns pointer as convenience.

 ^ static struct cvec *clearcvec(struct cvec *);

 */

static struct cvec *

clearcvec(cv)

    struct cvec *cv;			/* character vector */

{

    int i;

    assert(cv != NULL);

    cv->nchrs = 0;

    assert(cv->chrs == (chr *)&cv->mcces[cv->mccespace]);

    cv->nmcces = 0;

    cv->nmccechrs = 0;

    cv->nranges = 0;

    for (i = 0; i < cv->mccespace; i++) {

	cv->mcces[i] = NULL;

    }

    return cv;

}

/*

 - addchr - add a chr to a cvec

 ^ static VOID addchr(struct cvec *, pchr);

 */

static VOID

addchr(cv, c)

    struct cvec *cv;			/* character vector */

    pchr c;				/* character to add */

{

    assert(cv->nchrs < cv->chrspace - cv->nmccechrs);

    cv->chrs[cv->nchrs++] = (chr)c;

}

/*

 - addrange - add a range to a cvec

 ^ static VOID addrange(struct cvec *, pchr, pchr);

 */

static VOID

addrange(cv, from, to)

    struct cvec *cv;			/* character vector */

    pchr from;				/* first character of range */

    pchr to;				/* last character of range */

{

    assert(cv->nranges < cv->rangespace);

    cv->ranges[cv->nranges*2] = (chr)from;

    cv->ranges[cv->nranges*2 + 1] = (chr)to;

    cv->nranges++;

}

/*

 - addmcce - add an MCCE to a cvec

 ^ static VOID addmcce(struct cvec *, chr *, chr *);

 */

static VOID

addmcce(cv, startp, endp)

    struct cvec *cv;			/* character vector */

    chr *startp;			/* beginning of text */

    chr *endp;				/* just past end of text */

{

    int len;

    int i;

    chr *s;

    chr *d;

    if (startp == NULL && endp == NULL) {

	return;

    }

    len = endp - startp;

    assert(len > 0);

    assert(cv->nchrs + len < cv->chrspace - cv->nmccechrs);

    assert(cv->nmcces < cv->mccespace);

    d = &cv->chrs[cv->chrspace - cv->nmccechrs - len - 1];

    cv->mcces[cv->nmcces++] = d;

    for (s = startp, i = len; i > 0; s++, i--) {

	*d++ = *s;

    }

    *d++ = 0;				/* endmarker */

    assert(d == &cv->chrs[cv->chrspace - cv->nmccechrs]);

    cv->nmccechrs += len + 1;

}

/*

 - haschr - does a cvec contain this chr?

 ^ static int haschr(struct cvec *, pchr);

 */

static int				/* predicate */

haschr(cv, c)

    struct cvec *cv;			/* character vector */

    pchr c;				/* character to test for */

{

    int i;

    chr *p;

    for (p = cv->chrs, i = cv->nchrs; i > 0; p++, i--) {

	if (*p == c) {

	    return 1;

	}

    }

    for (p = cv->ranges, i = cv->nranges; i > 0; p += 2, i--) {

	if ((*p <= c) && (c <= *(p+1))) {

	    return 1;

	}

    }

    return 0;

}

/*

 - getcvec - get a cvec, remembering it as v->cv

 ^ static struct cvec *getcvec(struct vars *, int, int, int);

 */

static struct cvec *

getcvec(v, nchrs, nranges, nmcces)

    struct vars *v;			/* context */

    int nchrs;				/* to hold this many chrs... */

    int nranges;			/* ... and this many ranges... */

    int nmcces;				/* ... and this many MCCEs */

{

    if (v->cv != NULL && nchrs <= v->cv->chrspace &&

	    nranges <= v->cv->rangespace && nmcces <= v->cv->mccespace) {

	return clearcvec(v->cv);

    }

    if (v->cv != NULL) {

	freecvec(v->cv);

    }

    v->cv = newcvec(nchrs, nranges, nmcces);

    if (v->cv == NULL) {

	ERR(REG_ESPACE);

    }

    return v->cv;

}

/*

 - freecvec - free a cvec

 ^ static VOID freecvec(struct cvec *);

 */

static VOID

freecvec(cv)

    struct cvec *cv;			/* character vector */

{

    FREE(cv);

}