/** BEGIN COPYRIGHT BLOCK
 * This Program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation; version 2 of the License.
 * 
 * This Program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along with
 * this Program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place, Suite 330, Boston, MA 02111-1307 USA.
 * 
 * In addition, as a special exception, Red Hat, Inc. gives You the additional
 * right to link the code of this Program with code not covered under the GNU
 * General Public License ("Non-GPL Code") and to distribute linked combinations
 * including the two, subject to the limitations in this paragraph. Non-GPL Code
 * permitted under this exception must only link to the code of this Program
 * through those well defined interfaces identified in the file named EXCEPTION
 * found in the source code files (the "Approved Interfaces"). The files of
 * Non-GPL Code may instantiate templates or use macros or inline functions from
 * the Approved Interfaces without causing the resulting work to be covered by
 * the GNU General Public License. Only Red Hat, Inc. may make changes or
 * additions to the list of Approved Interfaces. You must obey the GNU General
 * Public License in all respects for all of the Program code and other code used
 * in conjunction with the Program except the Non-GPL Code covered by this
 * exception. If you modify this file, you may extend this exception to your
 * version of the file, but you are not obligated to do so. If you do not wish to
 * provide this exception without modification, you must delete this exception
 * statement from your version and license this file solely under the GPL without
 * exception. 
 * 
 * 
 * Copyright (C) 2001 Sun Microsystems, Inc. Used by permission.
 * Copyright (C) 2005 Red Hat, Inc.
 * All rights reserved.
 * END COPYRIGHT BLOCK **/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif


/*
 * Description (lexer.c)
 *
 *	This module provides functions to assist parsers in lexical
 *	analysis.  The idea is to provide a slightly higher-level
 *	interface than that of ctype.h.
 */

#include "netsite.h"
#include "prlog.h"

#include "lexer_pvt.h"
#include "base/lexer.h"

/*
 * Description (lex_class_check)
 *
 *	This function checks whether a given character belongs to one or
 *	specified character classes.
 *
 * Arguments:
 *
 *	chtab			- character class table pointer
 *	code			- character code to be tested
 *	cbits			- bit mask of character classes
 *
 * Returns:
 *
 *	The return value is zero if the code is not in any of the character
 *	classes.  It is non-zero, if the code is in at least one of the
 *	classes.
 */
NSAPI_PUBLIC 
int lex_class_check(void * chtab, char code, unsigned long cbits)
{
    LEXClassTab_t * lct;		/* character class table pointer */
    unsigned char * bp;			/* bit vector pointer */
    int rv = 0;				/* return value */
    int i;				/* loop index */

    lct = (LEXClassTab_t *)chtab;

    bp = lct->lct_bv + code * lct->lct_bvbytes;

    for (i = 0; i < lct->lct_bvbytes; ++i) {
	if (*bp++ & cbits) {
	    rv = 1;
	    break;
	}
	cbits >>= 8;
    }

    return rv;
}

/*
 * Description (lex_class_create)
 *
 *	This function creates a new character class table.  A
 *	character class table is used to map a character code to a
 *	set of character classes.  The mapping for a given character
 *	is expressed as a bit vector, where each bit indicates the
 *	membership of that character in one of the character classes.
 *
 * Arguments:
 *
 *	classc		- the number of character classes being defined
 *	classv		- pointers to null-terminated strings containing
 *			  the character codes in each character class
 *	pchtab		- indicates where to store a returned handle for
 *			  the character class table
 *
 * Returns:
 *
 *	If successful, the return value is the number of character
 *	classes specified (classc), and a handle for the created table
 *	is returned through pchtab.
 *
 * Usage Notes:
 *
 *	Null (\000) can never be in any character classes, since it
 *	marks the end of the classv[] strings.
 *
 *	classv[] can included NULL pointers, in which case bits will be
 *	allocated for corresponding empty character classes.
 */
NSAPI_PUBLIC 
int lex_class_create(int classc, char * classv[], void **pchtab)
{
    int ncodes = 128;			/* number of character encodings */
    int bvbytes;			/* bytes per bit vector */
    LEXClassTab_t * ct;			/* class table pointer */
    unsigned char * bp;			/* bit vector pointer */
    char * cp;				/* class string pointer */
    int bitmask;			/* class bit mask */
    int bnum;				/* byte number in bit vector */
    int ci;				/* character index */
    int i;				/* class index */

    /* Get number of bytes per bit vector */
    PR_ASSERT(classc > 0);
    bvbytes = (classc + 7) >> 3;

    /* Allocate the character class table */
    ct = (LEXClassTab_t *)calloc(1, sizeof(LEXClassTab_t) + ncodes * bvbytes);
    if (ct == NULL) {

	/* Error - insufficient memory */
	return LEXERR_MALLOC;
    }

    /* Initialize the class table */
    ct->lct_classc = classc;
    ct->lct_bvbytes = bvbytes;
    ct->lct_bv = (unsigned char *)(ct + 1);

    /* Initialize the bit vectors */
    for (i = 0; i < classc; ++i) {

	cp = classv[i];
	if (cp != NULL) {

	    bitmask = 1 << (i & 7);
	    bnum = i >> 7;

	    while ((ci = *cp++) != 0) {
		bp = ct->lct_bv + ci + bnum;
		*bp |= bitmask;
	    }
	}
    }

    /* Return pointer to table */
    PR_ASSERT(pchtab != NULL);
    *pchtab = (void *)ct;

    return classc;
}

NSAPI_PUBLIC 
void lex_class_destroy(void * chtab)
{
    FREE((void *)chtab);
}

NSAPI_PUBLIC 
LEXStream_t * lex_stream_create(LEXStreamGet_t strmget, void * strmid,
				char * buf, int buflen)
{
    LEXStream_t * lst;		/* stream structure pointer */

    /* Allocate the stream structure */
    lst = (LEXStream_t *)MALLOC(sizeof(LEXStream_t));
    if (lst == NULL) {
	/* Error - insufficient memory */
	return 0;
    }

    lst->lst_strmid = strmid;
    lst->lst_get = strmget;

    /*
     * Allocate a buffer for the stream if there's a positive length
     * but a NULL buffer pointer.
     */
    if ((buflen > 0) && (buf == NULL)) {

	buf = (char *)MALLOC(buflen);
	if (buf == NULL) {
	    FREE((void *)lst);
	    return 0;
	}

	/* Also initialize the current position and residual length */
	lst->lst_cp = buf;
	lst->lst_len = 0;
	lst->lst_flags = LST_FREEBUF;
    }

    lst->lst_buf = buf;
    lst->lst_buflen = buflen;

    return lst;
}

NSAPI_PUBLIC 
void lex_stream_destroy(LEXStream_t * lst)
{
    if ((lst->lst_flags & LST_FREEBUF) && (lst->lst_buf != NULL)) {
	FREE(lst->lst_buf);
    }
    FREE((void *)lst);
}

/*
 * Description (lex_token_new)
 *
 *      This function creates a new token object.  A token object is
 *      used to accumulate text in an associated buffer.  If the
 *      'growlen' argument is specified as a value that is greater
 *      than zero, then the token buffer will be reallocated as
 *      necessary to accomodate more text.  The initial size of
 *      the token buffer is given by 'initlen', which may be zero,
 *      and should be zero if lex_token_setbuf() is used.
 *
 *      The token object is allocated from the memory pool given
 *      by the 'pool' argument.  The default pool for the current
 *      thread is used if 'pool' is null.
 *
 * Arguments:
 *
 *      pool                    - handle for memory pool to be used
 *      initlen                 - initial length of token buffer
 *      growlen                 - amount to grow a full token buffer
 *      token                   - pointer to returned token handle
 *
 * Returns:
 *
 *      If successful, the function return value is zero and a handle
 *      for the new token is returned via 'token'.  Otherwise a negative
 *      error code is returned.
 */

NSAPI_PUBLIC
int lex_token_new(pool_handle_t * pool, int initlen, int growlen, void **token)
{
    LEXToken_t * lt;			/* new token pointer */

    /* Allocate the token structure */
    if (pool) {
        lt = (LEXToken_t *)pool_calloc(pool, 1, sizeof(LEXToken_t));
    }
    else {
        lt = (LEXToken_t *)CALLOC(sizeof(LEXToken_t));
    }
    if (lt == NULL) {
	/* Error - insufficient memory */
	return LEXERR_MALLOC;
    }

    /* Save the memory pool handle for future allocations */
    lt->lt_mempool = pool;

    /* Allocate the initial token buffer if initlen > 0 */
    if (initlen > 0) {
        if (pool) {
            lt->lt_buf = (char *)pool_malloc(pool, initlen);
        }
        else {
            lt->lt_buf = (char *)MALLOC(initlen);
        }
        if (lt->lt_buf == NULL) {
            /* Error - insufficient memory */
            if (pool) {
                pool_free(pool, (void *)lt);
            }
            else {
                FREE((void *)lt);
            }
            return LEXERR_MALLOC;
        }

        lt->lt_initlen = initlen;
        lt->lt_buflen = initlen;
        lt->lt_buf[0] = 0;
    }

    if (growlen > 0) lt->lt_inclen = growlen;

    PR_ASSERT(token != NULL);
    *token = (void *)lt;

    return 0;
}

/*
 * Description (lex_token_start)
 *
 *      This function discards any current contents of the token buffer
 *      associated with a specified token object, so that any new data
 *      appended to the token will start at the beginning of the token
 *      buffer.  If there is no token buffer currently associated with
 *      the token, and the 'initlen' value specified to lex_token_new()
 *      was greater than zero, then a new token buffer is allocated.
 *      This function enables a token and optionally its token buffer
 *      to be reused.
 *
 * Arguments:
 *
 *      token                           - handle for token object
 *
 * Returns:
 *
 *      If successful, the function return value is zero.  Otherwise
 *      a negative error code is returned.
 */

NSAPI_PUBLIC int
lex_token_start(void * token)
{
    LEXToken_t * lt = (LEXToken_t *)token;	/* token pointer */

    /* Do we need to allocate a token buffer? */
    if ((lt->lt_buf == NULL) && (lt->lt_initlen > 0)) {

	/* Allocate the initial token buffer */
        if (lt->lt_mempool) {
            lt->lt_buf = (char *)pool_malloc(lt->lt_mempool, lt->lt_initlen);
        }
        else {
            lt->lt_buf = (char *)MALLOC(lt->lt_initlen);
        }
	if (lt->lt_buf == NULL) {
	    /* Error - insufficient memory */
	    return LEXERR_MALLOC;
	}
	lt->lt_buflen = lt->lt_initlen;
    }

    lt->lt_len = 0;
    lt->lt_buf[0] = 0;

    return 0;
}

/*
 * Description (lex_token_info)
 *
 *      This function returns information about the token buffer currently
 *      associated with a token object.  This includes a pointer to the
 *      token data, if any, the current length of the token data, and the
 *      current size of the token buffer.
 *
 * Arguments:
 *
 *      token                   - handle for token object
 *      tdatalen                - pointer to returned token data length
 *                                (may be null)
 *      tbufflen                - pointer to returned token buffer length
 *                                (may be null)
 *
 * Returns:
 *
 *      The function return value is a pointer to the beginning of the
 *      token data, or null if there is no token buffer associated with
 *      the token.  The token data length and token buffer length are
 *      returned via 'tdatalen' and 'tbufflen', respectively.
 */

NSAPI_PUBLIC
char * lex_token_info(void * token, int * tdatalen, int * tbufflen)
{
    LEXToken_t * lt = (LEXToken_t *)token;      /* token pointer */

    if (tdatalen) *tdatalen = lt->lt_len;
    if (tbufflen) *tbufflen = lt->lt_buflen;

    return lt->lt_buf;
}

/*
 * Description (lex_token)
 *
 *      This function returns a pointer to the current token buffer, if any.
 *      If the length of the token is also needed, use lex_token_info().
 *      This function would normally be used when the token is a
 *      null-terminated string.  See also lex_token_take().
 *
 * Arguments:
 *
 *      token                           - handle for token object
 *
 * Returns:
 *
 *      A pointer to the beginning of the current token is returned.
 *      The pointer is null if no token buffer is currently associated
 *      with the token object.
 */

NSAPI_PUBLIC 
char * lex_token(void * token)
{
    LEXToken_t * lt = (LEXToken_t *)token;      /* token pointer */

    return lt->lt_buf;
}

/*
 * Description (lex_token_destroy)
 *
 *      This function destroys a specified token object.  The memory
 *      associated with the token object and its token buffer, if any,
 *      is freed to whence it came.  Note that token objects can be
 *      associated with a memory pool, and destroyed implicitly when
 *      the pool is destroyed via pool_destroy().
 *
 * Arguments:
 *
 *      token                           - handle for token object
 */

NSAPI_PUBLIC 
void lex_token_destroy(void * token)
{
    LEXToken_t * lt = (LEXToken_t *)token;      /* token pointer */

    if (lt) {
        if (lt->lt_mempool) {
            if (lt->lt_buf) {
                pool_free(lt->lt_mempool, (void *)(lt->lt_buf));
            }
            pool_free(lt->lt_mempool, (void *)lt);
        }
        else {
            if (lt->lt_buf) {
                FREE(lt->lt_buf);
            }
            FREE(lt);
        }
    }
}

/*
 * Description (lex_token_get)
 *
 *      This function returns a pointer to the current token buffer,
 *      leaving the token with no associated token buffer.  The caller
 *      assumes ownership of the returned token buffer.  The length
 *      of the token data and the length of the token buffer are returned
 *      if requested.  Note that lex_token_take() performs a similar
 *      operation.
 *
 * Arguments:
 *
 *      token                           - handle for token object
 *      tdatalen                - pointer to returned token data length
 *                                (may be null)
 *      tbufflen                - pointer to returned token buffer length
 *                                (may be null)
 *
 * Returns:
 *
 *      The function return value is a pointer to the beginning of the
 *      token data, or null if there is no token buffer associated with
 *      the token.  The token data length and token buffer length are
 *      returned via 'tdatalen' and 'tbufflen', respectively.
 */

NSAPI_PUBLIC 
char * lex_token_get(void * token, int * tdatalen, int * tbufflen)
{
    LEXToken_t * lt = (LEXToken_t *)token;      /* token pointer */
    char * tokenstr;

    tokenstr = lt->lt_buf;
    if (tdatalen) *tdatalen = lt->lt_len;
    if (tbufflen) *tbufflen = lt->lt_buflen;

    lt->lt_buf = NULL;
    lt->lt_buflen = 0;
    lt->lt_len = 0;

    return tokenstr;
}

/*
 * Description (lex_token_take)
 *
 *      This function returns a pointer to the current token buffer,
 *      leaving the token with no associated token buffer.  The caller
 *      assumes ownership of the returned token buffer.  Note that
 *      lex_token_get() performs a similar operation, but returns more
 *      information.
 *
 * Arguments:
 *
 *      token                           - handle for token object
 *
 * Returns:
 *
 *      A pointer to the beginning of the current token is returned.
 *      The pointer is null if no token buffer is currently associated
 *      with the token object.
 */

NSAPI_PUBLIC 
char * lex_token_take(void * token)
{
    LEXToken_t * lt = (LEXToken_t *)token;      /* token pointer */
    char * tokenstr;

    tokenstr = lt->lt_buf;

    lt->lt_buf = NULL;
    lt->lt_buflen = 0;
    lt->lt_len = 0;

    return tokenstr;
}

/*
 * Description (lex_token_append)
 *
 *      This function appends data to the end of a token.  If 'growlen'
 *      was specified as a greater-than-zero value for lex_token_new(),
 *      then the token buffer may be reallocated to accomodate the
 *      new data if necessary.  A null byte is maintained in the token
 *      buffer following the token data, but it is not included in the
 *      token data length.
 *
 * Arguments:
 *
 *      token                           - handle for token object
 *      nbytes                          - number of bytes of new data
 *      src                             - pointer to new data
 *
 * Returns:
 *
 *      If successful, the function return value is the new length of
 *      the token data.  Otherwise a negative error code is returned.
 */

NSAPI_PUBLIC 
int lex_token_append(void * token, int nbytes, char * src)
{
    LEXToken_t * lt = (LEXToken_t *)token;      /* token pointer */
    int bufsize;
    int length;

    PR_ASSERT(nbytes >= 0);
    PR_ASSERT((src != NULL) || (nbytes == 0));

    if (nbytes > 0) {

	bufsize = lt->lt_buflen;
	length = lt->lt_len + nbytes;

	if (length >= bufsize) {

	    while (length >= bufsize) {
		bufsize += lt->lt_inclen;
	    }

            if (lt->lt_mempool) {
                if (lt->lt_buf) {
                    lt->lt_buf = (char *)pool_realloc(lt->lt_mempool,
                                                      lt->lt_buf, bufsize);
                }
                else {
                    lt->lt_buf = (char *)pool_malloc(lt->lt_mempool, bufsize);
                }
            }
            else {
                if (lt->lt_buf) {
                    lt->lt_buf = (char *)REALLOC(lt->lt_buf, bufsize);
                }
                else {
                    lt->lt_buf = (char *)MALLOC(bufsize);
                }
            }
        }

	if (lt->lt_buf) {

	    memcpy((void *)(lt->lt_buf + lt->lt_len), (void *)src, nbytes);
	    lt->lt_buf[length] = 0;
	    lt->lt_len = length;
	    lt->lt_buflen = bufsize;
	}
        else {
            /* Error - insufficient memory */
            return LEXERR_MALLOC;
        }
    }

    return lt->lt_len;
}

NSAPI_PUBLIC 
int lex_next_char(LEXStream_t * lst, void * chtab, unsigned long cbits)
{
    LEXClassTab_t * lct;		/* character class table pointer */
    unsigned char * bp;			/* bit vector pointer */
    unsigned long bitmask;		/* class bit mask temporary */
    int rv;				/* return value */
    int i;				/* loop index */

    lct = (LEXClassTab_t *)chtab;

    /* Go get more stream data if none left in the buffer */
    if (lst->lst_len <= 0) {
	rv = (*lst->lst_get)(lst);
	if (rv <= 0) {
	    return rv;
	}
    }

    /* Get the next character from the buffer */
    rv = *lst->lst_cp;

    bitmask = cbits;
    bp = lct->lct_bv + rv * lct->lct_bvbytes;

    for (i = 0; i < lct->lct_bvbytes; ++i) {
	if (*bp++ & bitmask) {
	    /* Update the buffer pointer and length */
	    lst->lst_cp += 1;
	    lst->lst_len -= 1;
	    break;
	}
	bitmask >>= 8;
    }

    return rv;
}

NSAPI_PUBLIC 
int lex_scan_over(LEXStream_t * lst, void * chtab, unsigned long cbits,
		  void * token)
{
    LEXClassTab_t * lct;		/* character class table pointer */
    char * cp;				/* current pointer in stream buffer */
    unsigned char * bp;			/* bit vector pointer */
    unsigned long bitmask;		/* class bit mask temporary */
    int cv = 0;				/* current character value */
    int rv = 0;				/* return value */
    int slen;				/* token segment length */
    int done = 0;			/* done indication */
    int i;				/* loop index */

    lct = (LEXClassTab_t *)chtab;

    while (!done) {

	/* Go get more stream data if none left in the buffer */
	if (lst->lst_len <= 0) {
	    rv = (*lst->lst_get)(lst);
	    if (rv <= 0) {
		return rv;
	    }
	}

	slen = 0;
	cp = lst->lst_cp;

	while (slen < lst->lst_len) {
	    cv = *cp;
	    bitmask = cbits;
	    bp = lct->lct_bv + cv * lct->lct_bvbytes;
	    for (i = 0; i < lct->lct_bvbytes; ++i) {
		if (*bp++ & bitmask) goto more_token;
		bitmask >>= 8;
	    }

	    done = 1;
	    break;

	  more_token:
	    slen += 1;
	    cp += 1;
	}

	/* If the current segment is not empty, append it to the token */
	if (slen > 0) {
	    rv = lex_token_append(token, slen, lst->lst_cp);
	    if (rv < 0) break;

	    /* Update the stream buffer pointer and length */
	    lst->lst_cp += slen;
	    lst->lst_len -= slen;
	}
    }

    return ((rv < 0) ? rv : cv);
}

/*
 * Description (lex_scan_string)
 *
 *	This function parses a quoted string into the specified token.
 *	The current character in the LEX stream is taken to be the
 *	beginning quote character.  The quote character may be included
 *	in the string by preceding it with a '\'.  Any newline
 *	characters to be included in the string must also be preceded
 *	by '\'.  The string is terminated by another occurrence of the
 *	quote character, or an unquoted newline, or EOF.
 *
 * Arguments:
 *
 *	lst			- pointer to LEX stream structure
 *	token			- handle for token
 *	flags			- bit flags (unused - must be zero)
 *
 * Returns:
 *
 *	The terminating character is returned, or zero if EOF.  The
 *	string is returned in the token, without the beginning and
 *	ending quote characters.  An error is indicated by a negative
 *	return value.
 */

NSAPI_PUBLIC 
int lex_scan_string(LEXStream_t * lst, void * token, int flags)
{
    char * cp;				/* current pointer in stream buffer */
    int cv;				/* current character value */
    int rv;				/* return value */
    int slen;				/* token segment length */
    int done = 0;			/* done indication */
    int cquote = 0;			/* character quote indication */
    int qchar = -1;			/* quote character */

    while (!done) {

	/* Go get more stream data if none left in the buffer */
	if (lst->lst_len <= 0) {
	    rv = (*lst->lst_get)(lst);
	    if (rv <= 0) {
		return rv;
	    }
	}

	slen = 0;
	cp = lst->lst_cp;

	while (slen < lst->lst_len) {

	    /* Get the next character */
	    cv = *cp;

	    /* Pick up the quote character if we don't have it yet */
	    if (qchar < 0) {
		qchar = cv;

		/* Don't include it in the string */
		lst->lst_cp += 1;
		lst->lst_len -= 1;
		cp += 1;
		continue;
	    }

	    /* cquote is 1 if the last character was '\' */
	    if (cquote == 0) {

		/* Is this a string terminator? */
		if ((cv == qchar) || (cv == '\n')) {

		    /* Append whatever we have to this point */
		    if (slen > 0) goto append_it;

		    /*
		     * If the terminator is the expected quote character,
		     * just skip it.  If it's anything else, leave it as
		     * the current character.
		     */
		    if (cv == qchar) {
			lst->lst_cp += 1;
			lst->lst_len -= 1;
		    }

		    done = 1;
		    goto append_it;
		}

		/* Got the character quote character? */
		if (cv == '\\') {

		    /* Append anything we have so far first */
		    if (slen > 0) goto append_it;

		    /* Then skip the character */
		    cquote = 1;
		    lst->lst_cp += 1;
		    lst->lst_len -= 1;
		    cp += 1;
		    continue;
		}
	    }
	    else {

		/* Include any character following '\' */
		cquote = 0;
	    }

	    /* Include this character in the string */
	    slen += 1;
	    cp += 1;
	}

      append_it:

	/* If the current segment is not empty, append it to the token */
	if (slen > 0) {
	    rv = lex_token_append(token, slen, lst->lst_cp);
	    if (rv < 0) break;

	    /* Update the stream buffer pointer and length */
	    lst->lst_cp += slen;
	    lst->lst_len -= slen;
	}
    }

    return ((rv < 0) ? rv : cv);
}

NSAPI_PUBLIC 
int lex_scan_to(LEXStream_t * lst, void * chtab, unsigned long cbits,
		void * token)
{
    LEXClassTab_t * lct;		/* character class table pointer */
    unsigned char * bp;			/* bit vector pointer */
    char * cp;				/* current pointer in stream buffer */
    unsigned long bitmask;		/* class bit mask temporary */
    int cv = 0;				/* current character value */
    int rv = 0;				/* return value */
    int slen;				/* token segment length */
    int done = 0;			/* done indication */
    int i;				/* loop index */

    lct = (LEXClassTab_t *)chtab;

    while (!done) {

	/* Go get more stream data if none left in the buffer */
	if (lst->lst_len <= 0) {
	    rv = (*lst->lst_get)(lst);
	    if (rv <= 0) {
		return rv;
	    }
	}

	slen = 0;
	cp = lst->lst_cp;

	while (slen < lst->lst_len) {
	    cv = *cp;
	    bitmask = cbits;
	    bp = lct->lct_bv + cv * lct->lct_bvbytes;
	    for (i = 0; i < lct->lct_bvbytes; ++i) {
		if (*bp++ & bitmask) {
		    done = 1;
		    goto append_it;
		}
		bitmask >>= 8;
	    }

	    slen += 1;
	    cp += 1;
	}

      append_it:

	/* If the current segment is not empty, append it to the token */
	if (slen > 0) {
	    rv = lex_token_append(token, slen, lst->lst_cp);
	    if (rv < 0) break;

	    /* Update the stream buffer pointer and length */
	    lst->lst_cp += slen;
	    lst->lst_len -= slen;
	}
    }

    return ((rv < 0) ? rv : cv);
}

NSAPI_PUBLIC 
int lex_skip_over(LEXStream_t * lst, void * chtab, unsigned long cbits)
{
    LEXClassTab_t * lct;		/* character class table pointer */
    unsigned char * bp;			/* bit vector pointer */
    char * cp;				/* current pointer in stream buffer */
    unsigned long bitmask;		/* class bit mask temporary */
    int rv = 0;				/* return value */
    int slen;				/* token segment length */
    int done = 0;			/* done indication */
    int i;				/* loop index */

    lct = (LEXClassTab_t *)chtab;

    while (!done) {

	/* Go get more stream data if none left in the buffer */
	if (lst->lst_len <= 0) {
	    rv = (*lst->lst_get)(lst);
	    if (rv <= 0) {
		return rv;
	    }
	}

	slen = 0;
	cp = lst->lst_cp;

	while (slen < lst->lst_len) {
	    rv = *cp;
	    bitmask = cbits;
	    bp = lct->lct_bv + rv * lct->lct_bvbytes;
	    for (i = 0; i < lct->lct_bvbytes; ++i) {
		if (*bp++ & bitmask) goto next_ch;
		bitmask >>= 8;
	    }

	    done = 1;
	    break;

	  next_ch:
	    slen += 1;
	    cp += 1;
	}

	if (slen > 0) {
	    /* Update the stream buffer pointer and length */
	    lst->lst_cp += slen;
	    lst->lst_len -= slen;
	}
    }

    return rv;
}

NSAPI_PUBLIC 
int lex_skip_to(LEXStream_t * lst, void * chtab, unsigned long cbits)
{
    LEXClassTab_t * lct;		/* character class table pointer */
    unsigned char * bp;			/* bit vector pointer */
    char * cp;				/* current pointer in stream buffer */
    unsigned long bitmask;		/* class bit mask temporary */
    int rv;				/* return value */
    int slen;				/* token segment length */
    int done = 0;			/* done indication */
    int i;				/* loop index */

    lct = (LEXClassTab_t *)chtab;

    while (!done) {

	/* Go get more stream data if none left in the buffer */
	if (lst->lst_len <= 0) {
	    rv = (*lst->lst_get)(lst);
	    if (rv <= 0) {
		return rv;
	    }
	}

	slen = 0;
	cp = lst->lst_cp;

	while (slen < lst->lst_len) {
	    rv = *cp;
	    bitmask = cbits;
	    bp = lct->lct_bv + rv * lct->lct_bvbytes;
	    for (i = 0; i < lct->lct_bvbytes; ++i) {
		if (*bp++ & bitmask) {
		    done = 1;
		    goto update_it;
		}
		bitmask >>= 8;
	    }
	    slen += 1;
	    cp += 1;
	}

      update_it:
	/* Update the stream buffer pointer and length */
	if (slen > 0) {
	    lst->lst_cp += slen;
	    lst->lst_len -= slen;
	}
    }

    return rv;
}