/* Generated by re2c 0.13.5 */
/*
* Lex source for Fed-X lexical analyzer.
*
* This software was developed by U.S. Government employees as part of
* their official duties and is not subject to copyright.
*
* $Log: expscan.l,v $
* Revision 1.12 1997/05/29 20:17:34 sauderd
* Made some changes to Symbol (to be Symbol_) and false and true to be False
* and True. These changes affect the generated expscan.c file so that it will
* compile.
*
* Revision 1.11 1994/11/22 18:32:39 clark
* Part 11 IS; group reference
*
* Revision 1.10 1994/05/12 17:22:23 libes
* added #ifdefs for flex
*
* Revision 1.9 1994/05/12 17:18:10 libes
* made flex understand multiple files
*
* Revision 1.8 1994/05/11 19:50:00 libes
* numerous fixes
*
* Revision 1.7 1993/10/15 18:47:26 libes
* CADDETC certified
*
* Revision 1.5 1993/02/22 21:46:33 libes
* fixed unmatched_open_comment handler
*
* Revision 1.4 1992/08/18 17:11:36 libes
* rm'd extraneous error messages
*
* Revision 1.3 1992/06/08 18:05:20 libes
* prettied up interface to print_objects_when_running
*
* Revision 1.2 1992/05/31 08:30:54 libes
* multiple files
*
* Revision 1.1 1992/05/28 03:52:25 libes
* Initial revision
*
* Revision 1.4 1992/05/05 19:49:03 libes
* final alpha
*
* Revision 1.3 1992/02/12 07:02:49 libes
* do sub/supertypes
*
* Revision 1.2 1992/02/09 00:49:04 libes
* does ref/use correctly
*
* Revision 1.1 1992/02/05 08:40:30 libes
* Initial revision
*
* Revision 1.0.1.1 1992/01/22 02:47:57 libes
* copied from ~pdes
*
* Revision 4.9 1991/06/14 20:49:12 libes
* removed old infinity, added backslash
*
* Revision 4.8.1.1 1991/05/16 04:07:57 libes
* made scanner (under lex) understand hooks for doing include directive
*
* Revision 4.8.1.0 1991/05/16 01:10:15 libes
* branch for fixes to old code
*
* Revision 4.8 1991/05/03 21:09:02 libes
* Added sanity check to make sure lex/flex match -DLEX/FLEX
*
* Revision 4.7 1991/05/02 05:49:18 libes
* fixed bug in testing for exceeding open_comment[nesting_level]
*
* Revision 4.6 1991/04/29 19:44:40 libes
* Print all open comments rather than just one.
*
* Revision 4.5 1991/04/29 15:39:02 libes
* Changed commenting style (back) as per SNC who claims that N9 meant to
* say that tail remarks cannot occur in an open comment, nor can nested
* comments begin in a tail remark.
*
* Revision 4.4 1991/04/29 15:01:46 libes
* Add bounds checking to nesting level history
*
* Revision 4.3 1991/04/26 20:12:50 libes
* Made scanner work with lex
* Simulated exclusive states with inclusive states
* Fixed line counting
* Speeded up whitespace matching
* Convert unknown chars to whitespace
* Disabled default rule matching (enabled "jamming")
* Enabled detection/diagnostics of unterminated comments and strings literals
* Enabled detection/diagnostics of unexpected close comments
* Disabled detection/diagnostics of nested comments
*
* Revision 4.2 1990/12/18 14:00:04 clark
* Cosmetic changes
*
* Revision 4.1 90/09/13 16:29:00 clark
* BPR 2.1 alpha
* */
#include <ctype.h>
#if !defined(isascii) && defined(__isascii)
#  define isascii __isascii
#endif
#include "express/basic.h"
#include "express/error.h"
#include "express/lexact.h"
#include "express/express.h"
#include "expparse.h"
#include "expscan.h"
enum { INITIAL, code, comment, return_end_schema };
extern int	yylineno;
extern bool	yyeof;
static int	nesting_level = 0;
/* can't imagine this will ever be more than 2 or 3 - DEL */
#define MAX_NESTED_COMMENTS 20
static struct Symbol_ open_comment[MAX_NESTED_COMMENTS];
static_inline
int
SCANnextchar(char* buffer)
{
extern bool SCANread(void);
#ifdef keep_nul
static int escaped = 0;
#endif
if (SCANtext_ready || SCANread()) {
#ifdef keep_nul
if (!*SCANcurrent) {
buffer[0] = SCAN_ESCAPE;
*SCANcurrent = '0';
return 1;
} else if ((*SCANcurrent == SCAN_ESCAPE) && !escaped) {
escaped = 1;
buffer[0] = SCAN_ESCAPE;
return 1;
}
SCANbuffer.numRead--;
#endif
buffer[0] = *(SCANcurrent++);
if (!isascii(buffer[0])) {
ERRORreport_with_line(NONASCII_CHAR,yylineno,
0xff & buffer[0]);
buffer[0] = ' ';	/* substitute space */
}
return 1;
} else
return 0;
}
#define NEWLINE (yylineno++)
/* when lex looks ahead over a newline, error messages get thrown off */
/* Fortunately, we know when that occurs, so adjust for it by this hack */
#define LINENO_FUDGE (yylineno - 1)
/* added for re-initializing parser -snc 22-Apr-1992 */
void
SCAN_lex_init(char *filename, FILE *fp) {
/* return to initial scan buffer */
SCAN_current_buffer = 0;
*(SCANcurrent = SCANbuffer.text) = '\0';
SCANbuffer.readEof = false;
SCANbuffer.file = fp;
SCANbuffer.filename = (filename ? filename : "");
current_filename = SCANbuffer.filename;
}
#define PERPLEX_USING_CONDITIONS


/*              S C A N N E R _ T E M P L A T E . C
 * BRL-CAD
 *
 * Copyright (c) 1990-2011 United States Government as represented by
 * the U.S. Army Research Laboratory.
 *
 * Copyright (c) 1990 The Regents of the University of California.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following
 * disclaimer in the documentation and/or other materials provided
 * with the distribution.
 *
 * 3. The name of the author may not be used to endorse or promote
 * products derived from this software without specific prior written
 * permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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.
 */
/*  Parts of this file are based on sources from the flex project.
 *
 *  This code is derived from software contributed to Berkeley by
 *  Vern Paxson.
 *
 *  The United States Government has rights in this work pursuant
 *  to contract no. DE-AC03-76SF00098 between the United States
 *  Department of Energy and the University of California.
 */
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* --- from flex's flexdef.h --- */
void buf_init(struct Buf * buf, size_t elem_size);
void buf_destroy(struct Buf * buf);
struct Buf *buf_append(struct Buf * buf, const void *ptr, int n_elem);
struct Buf *buf_concat(struct Buf* dest, const struct Buf* src);
struct Buf *buf_strappend(struct Buf *, const char *str);
struct Buf *buf_strnappend(struct Buf *, const char *str, int nchars);
struct Buf *buf_strdefine(struct Buf * buf, const char *str, const char *def);
struct Buf *buf_prints(struct Buf *buf, const char *fmt, const char* s);
struct Buf *buf_m4_define(struct Buf *buf, const char* def, const char* val);
struct Buf *buf_m4_undefine(struct Buf *buf, const char* def);
struct Buf *buf_print_strings(struct Buf * buf, FILE* out);
struct Buf *buf_linedir(struct Buf *buf, const char* filename, int lineno);

/* --- from flex's misc.c --- */
static void*
allocate_array(int size, size_t element_size)
{
    return malloc(element_size * size);
}

static void*
reallocate_array(void *array, int size, size_t element_size)
{
    return realloc(array, element_size * size);
}

/* --- from flex's buf.c --- */
/* Take note: The buffer object is sometimes used as a String buffer (one
 * continuous string), and sometimes used as a list of strings, usually line by
 * line.
 * 
 * The type is specified in buf_init by the elt_size. If the elt_size is
 * sizeof(char), then the buffer should be treated as string buffer. If the
 * elt_size is sizeof(char*), then the buffer should be treated as a list of
 * strings.
 *
 * Certain functions are only appropriate for one type or the other. 
 */

struct Buf*
buf_print_strings(struct Buf * buf, FILE* out)
{
    int i;

    if(!buf || !out) {
        return buf;
    }

    for (i = 0; i < buf->nelts; i++) {
        const char *s = ((char**)buf->elts)[i];
        if(s) {
            fprintf(out, "%s", s);
	}
    }
    return buf;
}

/* Append a "%s" formatted string to a string buffer */
struct Buf*
buf_prints(struct Buf *buf, const char *fmt, const char *s)
{
    char *t;

    t = (char*)malloc(strlen(fmt) + strlen(s) + 1);
    sprintf(t, fmt, s);
    buf = buf_strappend(buf, t);
    free(t);
    return buf;
}

int numDigits(int n)
{
    int digits;

    /* take absolute value of n */
    n = n >= 0 ? n : -n;

    if (n == 0) {
	return 1;
    }

    for (digits = 0; n > 0; digits++) {
	n /= 10;
    }

    return digits;
}

/** Append a line directive to the string buffer.
 * @param buf A string buffer.
 * @param filename file name
 * @param lineno line number
 * @return buf
 */
struct Buf*
buf_linedir(struct Buf *buf, const char* filename, int lineno)
{
    char *t;
    const char fmt[] = "#line %d \"%s\"\n";
    
    t = (char*)malloc(strlen(fmt) + strlen(filename) + numDigits(lineno) + 1);
    sprintf(t, fmt, lineno, filename);
    buf = buf_strappend(buf, t);
    free(t);
    return buf;
}


/** Append the contents of @a src to @a dest.
 * @param @a dest the destination buffer
 * @param @a dest the source buffer
 * @return @a dest
 */
struct Buf*
buf_concat(struct Buf* dest, const struct Buf* src)
{
    buf_append(dest, src->elts, src->nelts);
    return dest;
}


/* Appends n characters in str to buf. */
struct Buf*
buf_strnappend(struct Buf *buf, const char *str, int n)
{
    buf_append(buf, str, n + 1);

    /* "undo" the '\0' character that buf_append() already copied. */
    buf->nelts--;

    return buf;
}

/* Appends characters in str to buf. */
struct Buf*
buf_strappend(struct Buf *buf, const char *str)
{
    return buf_strnappend(buf, str, strlen(str));
}

/* appends "#define str def\n" */
struct Buf*
buf_strdefine(struct Buf *buf, const char *str, const char *def)
{
    buf_strappend(buf, "#define ");
    buf_strappend(buf, " ");
    buf_strappend(buf, str);
    buf_strappend(buf, " ");
    buf_strappend(buf, def);
    buf_strappend(buf, "\n");
    return buf;
}

/** Pushes "m4_define( [[def]], [[val]])m4_dnl" to end of buffer.
 * @param buf A buffer as a list of strings.
 * @param def The m4 symbol to define.
 * @param val The definition; may be NULL.
 * @return buf
 */
struct Buf*
buf_m4_define(struct Buf *buf, const char* def, const char* val)
{
    const char *fmt = "m4_define( [[%s]], [[%s]])m4_dnl\n";
    char *str;

    val = val ? val : "";
    str = (char*)malloc(strlen(fmt) + strlen(def) + strlen(val) + 2);

    sprintf(str, fmt, def, val);
    buf_append(buf, &str, 1);
    return buf;
}

/** Pushes "m4_undefine([[def]])m4_dnl" to end of buffer.
 * @param buf A buffer as a list of strings.
 * @param def The m4 symbol to undefine.
 * @return buf
 */
struct Buf*
buf_m4_undefine(struct Buf *buf, const char* def)
{
    const char *fmt = "m4_undefine( [[%s]])m4_dnl\n";
    char *str;

    str = (char*)malloc(strlen(fmt) + strlen(def) + 2);

    sprintf(str, fmt, def);
    buf_append(buf, &str, 1);
    return buf;
}

/* create buf with 0 elements, each of size elem_size. */
void
buf_init(struct Buf *buf, size_t elem_size)
{
    buf->elts = (void*)0;
    buf->nelts = 0;
    buf->elt_size = elem_size;
    buf->nmax = 0;
}

/* frees memory */
void
buf_destroy(struct Buf *buf)
{
    if (buf && buf->elts) {
	free(buf->elts);
    }
    if (buf)
	buf->elts = (void*)0;
}

/* appends ptr[] to buf, grow if necessary.
 * n_elem is number of elements in ptr[], NOT bytes.
 * returns buf.
 * We grow by mod(512) boundaries.
 */
struct Buf*
buf_append(struct Buf *buf, const void *ptr, int n_elem)
{
    int n_alloc = 0;

    if (!ptr || n_elem == 0) {
	return buf;
    }

    /* May need to alloc more. */
    if (n_elem + buf->nelts > buf->nmax) {
	/* exact amount needed... */
	n_alloc = (n_elem + buf->nelts) * buf->elt_size;

	/* ...plus some extra */
	if (((n_alloc * buf->elt_size) % 512) != 0 && buf->elt_size < 512) {
	    n_alloc += (512 - ((n_alloc * buf->elt_size) % 512)) / buf->elt_size;
	}
	if (!buf->elts) {
	    buf->elts = allocate_array(n_alloc, buf->elt_size);
	} else {
	    buf->elts = reallocate_array(buf->elts, n_alloc, buf->elt_size);
	}
	buf->nmax = n_alloc;
    }
    memcpy((char*)buf->elts + buf->nelts * buf->elt_size, ptr,
	n_elem * buf->elt_size);

    buf->nelts += n_elem;

    return buf;
}

/* --- */
/* input buffering support
 * note that these routines assume buf->elt_size == sizeof(char)
 */

/* get pointer to the start of the first element */
static char*
bufferFirstElt(struct Buf *buf)
{
    return (char*)buf->elts;
}

/* get pointer to the start of the last element */
static char*
bufferLastElt(struct Buf *buf)
{
    if (buf->nelts < 1) {
	return NULL;
    }
    return bufferFirstElt(buf) + buf->nelts - 1;
}

static void
bufferAppendChar(struct Buf *buf, char c)
{
    char *cp = &c;
    buf_append(buf, cp, 1);
}

/* Copy up to n input characters to the end of scanner buffer. If EOF is
 * encountered before n characters are copied, scanner->atEOI flag is set.
 */
static void
bufferAppend(perplex_t scanner, size_t n)
{
    struct Buf *buf;
    FILE *in;
    size_t i;
    int c;
    char *bufStart;
    size_t markerOffset, tokenStartOffset, cursorOffset;

    buf = scanner->buffer;
    in = scanner->inFile;

    /* save marker offsets */
    bufStart = (char*)buf->elts;
    cursorOffset = (size_t)(scanner->cursor - bufStart);
    markerOffset = (size_t)(scanner->marker - bufStart);
    tokenStartOffset = (size_t)(scanner->tokenStart - bufStart);

    /* remove last (null) element */
    buf->nelts--;

    for (i = 0; i < n; i++) {
	if ((c = fgetc(in)) == EOF) {
	    scanner->atEOI = 1;
	    break;
	}
	bufferAppendChar(buf, c);
    }

    /* (scanner->null - eltSize) should be the last input element,
     * we put a literal null after this element for debugging
     */
    bufferAppendChar(buf, '\0');
    scanner->null = bufferLastElt(buf);

    /* update markers in case append caused buffer to be reallocated */
    bufStart = (char*)buf->elts;
    scanner->cursor = bufStart + cursorOffset;
    scanner->marker = bufStart + markerOffset;
    scanner->tokenStart = bufStart + tokenStartOffset;
}

/* Appends up to n characters of input to scanner buffer. */
static void
bufferFill(perplex_t scanner, size_t n)
{
    struct Buf *buf;
    size_t totalElts, usedElts, freeElts;

    if (scanner->atEOI) {
	/* nothing to add to buffer */
	return;
    }

    buf = scanner->buffer;

    totalElts = (size_t)buf->nmax;
    usedElts = (size_t)buf->nelts;
    freeElts = totalElts - usedElts;

    /* not enough room for append, shift buffer contents to avoid realloc */
    if (n > freeElts) {
	void *bufFirst, *scannerFirst, *tokenStart, *marker, *null;
	size_t bytesInUse, shiftSize;

	tokenStart = (void*)scanner->tokenStart;
	marker = (void*)scanner->marker;
	null = (void*)scanner->null;

	bufFirst = bufferFirstElt(buf);

	/* Find first buffer element still in use by scanner. Will be
	 * tokenStart unless backtracking marker is in use.
	 */
	scannerFirst = tokenStart;
	if (marker >= bufFirst && marker < tokenStart) {
	    scannerFirst = marker;
	}

	/* bytes of input being used by scanner */
	bytesInUse = (size_t)null - (size_t)scannerFirst + 1;

	/* copy in-use elements to start of buffer */
	memmove(bufFirst, scannerFirst, bytesInUse);

	/* update number of elements */
        buf->nelts = bytesInUse / buf->elt_size;

	/* update markers */
	shiftSize = (size_t)scannerFirst - (size_t)bufFirst;
	scanner->marker     -= shiftSize;
	scanner->cursor     -= shiftSize;
	scanner->null       -= shiftSize;
	scanner->tokenStart -= shiftSize;
    }
    bufferAppend(scanner, n);
}

static char*
getTokenText(perplex_t scanner)
{
    int tokenChars = scanner->cursor - scanner->tokenStart;

    if (scanner->tokenText != NULL) {
	free(scanner->tokenText);
    }

    scanner->tokenText = (char*)malloc(sizeof(char) * (tokenChars + 1));

    memcpy(scanner->tokenText, scanner->tokenStart, tokenChars);
    scanner->tokenText[tokenChars] = '\0';

    return scanner->tokenText;
}

/* scanner helpers */
#define UPDATE_START  scanner->tokenStart = scanner->cursor;
#define IGNORE_TOKEN  UPDATE_START; continue;
#define       yytext  getTokenText(scanner)
#define      yyextra  scanner->extra

static perplex_t
newScanner(void)
{
    perplex_t scanner;
    scanner = (perplex_t)calloc(1, sizeof(struct perplex));

    return scanner;
}

static void
initBuffer(perplex_t scanner)
{
    scanner->buffer = (struct Buf*)malloc(sizeof(struct Buf));
    buf_init(scanner->buffer, sizeof(char));
}

/* public functions */

perplex_t
perplexStringScanner(char *firstChar, size_t numChars)
{
    size_t i;
    struct Buf *buf;
    perplex_t scanner = newScanner();

    scanner->inFile = NULL;

    initBuffer(scanner);
    buf = scanner->buffer;

    /* copy string to buffer */
    for (i = 0; i < numChars; i++) {
	bufferAppendChar(buf, firstChar[i]);
    }
    bufferAppendChar(buf, '\0');

    scanner->marker = scanner->cursor = bufferFirstElt(buf);
    scanner->null = bufferLastElt(buf);
    scanner->atEOI = 1;

    return scanner;
}

perplex_t
perplexFileScanner(FILE *input)
{
    char *bufFirst;
    perplex_t scanner = newScanner();

    scanner->inFile = input;

    initBuffer(scanner);
    bufferAppendChar(scanner->buffer, '\0');

    bufFirst = bufferFirstElt(scanner->buffer);
    scanner->null = scanner->marker = scanner->cursor = bufFirst;

    return scanner;
}

void
perplexFree(perplex_t scanner)
{
    if (scanner->buffer != NULL) {
	buf_destroy(scanner->buffer);
	free(scanner->buffer);
    }

    free(scanner);
}

void
perplexSetExtra(perplex_t scanner, void *extra)
{
    scanner->extra = extra;
}

void*
perplexGetExtra(perplex_t scanner)
{
    return scanner->extra;
}

/* Make c the next character to be scanned.
 *
 * This performs an insert, leaving the input buffer prior to the cursor
*  unchanged.
 */
void
perplexUnput(perplex_t scanner, char c)
{
    struct Buf *buf;
    char *curr, *cursor, *bufStart;
    size_t markerOffset, tokenStartOffset, cursorOffset;

    buf = scanner->buffer;

    /* save marker offsets */
    bufStart = bufferFirstElt(buf);
    cursorOffset = (size_t)(scanner->cursor - bufStart);
    markerOffset = (size_t)(scanner->marker - bufStart);
    tokenStartOffset = (size_t)(scanner->tokenStart - bufStart);

    /* append character to create room for shift */
    bufferAppendChar(buf, '\0');
    scanner->null = bufferLastElt(buf);

    /* update markers in case append caused buffer to be reallocated */
    bufStart = bufferFirstElt(buf);
    scanner->cursor = bufStart + cursorOffset;
    scanner->marker = bufStart + markerOffset;
    scanner->tokenStart = bufStart + tokenStartOffset;

    /* input from cursor to null is shifted to the right */
    cursor = scanner->cursor;
    for (curr = scanner->null; curr != cursor; curr--) {
	curr[0] = curr[-1];
    }

    /* insert c */
    *curr = c;
}

#ifdef PERPLEX_USING_CONDITIONS
/* start-condition support */
static void
setCondition(perplex_t scanner, int cond)
{
    scanner->condition = cond;
}

static int
getCondition(perplex_t scanner)
{
    return scanner->condition;
}

/* required re2c macros */
#define YYGETCONDITION     getCondition(scanner)
#define YYSETCONDITION(c)  setCondition(scanner, c)
#endif

/* required re2c macro */
#define YYFILL(n)          bufferFill(scanner, n)

/* scanner */
static int PERPLEX_PRIVATE_LEXER;

int
PERPLEX_PUBLIC_LEXER {
    int ret;

    UPDATE_START;

    scanner->tokenText = NULL;

    ret = PERPLEX_LEXER_private(scanner);

    if (scanner->tokenText != NULL) {
	free(scanner->tokenText);
	scanner->tokenText = NULL;
    }

    return ret;
}

static int
PERPLEX_PRIVATE_LEXER {
    char yych;

    PERPLEX_ON_ENTER;

    while (1) {
	if (scanner->atEOI && scanner->cursor >= scanner->null) {
	    return YYEOF;
	}

	{
		unsigned int yyaccept = 0;
		switch (YYGETCONDITION) {
		case 0: goto yyc_0;
		case code: goto yyc_code;
		case comment: goto yyc_comment;
		case return_end_schema: goto yyc_return_end_schema;
		}
/* *********************************** */
yyc_0:

		YYSETCONDITION(code);
		{
}
/* *********************************** */
yyc_code:
		if ((scanner->null - scanner->cursor) < 4) YYFILL(4);
		yych = *scanner->cursor;
		switch (yych) {
		case '\t':
		case ' ':	goto yy8;
		case '\n':	goto yy9;
		case '"':	goto yy11;
		case '$':
		case '&':
		case '@':
		case '^':
		case '~':	goto yy12;
		case '%':	goto yy14;
		case '\'':	goto yy15;
		case '(':	goto yy16;
		case ')':	goto yy18;
		case '*':	goto yy20;
		case '+':	goto yy22;
		case ',':	goto yy24;
		case '-':	goto yy26;
		case '.':	goto yy28;
		case '/':	goto yy30;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':	goto yy32;
		case ':':	goto yy34;
		case ';':	goto yy36;
		case '<':	goto yy38;
		case '=':	goto yy40;
		case '>':	goto yy42;
		case '?':	goto yy44;
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'G':
		case 'H':
		case 'I':
		case 'J':
		case 'K':
		case 'L':
		case 'M':
		case 'N':
		case 'O':
		case 'P':
		case 'Q':
		case 'R':
		case 'S':
		case 'T':
		case 'U':
		case 'V':
		case 'W':
		case 'X':
		case 'Y':
		case 'Z':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f':
		case 'g':
		case 'h':
		case 'i':
		case 'j':
		case 'k':
		case 'l':
		case 'm':
		case 'n':
		case 'o':
		case 'p':
		case 'q':
		case 'r':
		case 's':
		case 't':
		case 'u':
		case 'v':
		case 'w':
		case 'x':
		case 'y':
		case 'z':	goto yy46;
		case '[':	goto yy48;
		case '\\':	goto yy50;
		case ']':	goto yy52;
		case '_':	goto yy54;
		case '{':	goto yy56;
		case '|':	goto yy58;
		case '}':	goto yy60;
		default:	goto yy6;
		}
yy5:
		{
IGNORE_TOKEN; }
yy6:
		++scanner->cursor;
yy7:
		{
IGNORE_TOKEN; }
yy8:
		yych = *++scanner->cursor;
		goto yy127;
yy9:
		++scanner->cursor;
		{
NEWLINE;
IGNORE_TOKEN;
}
yy11:
		yyaccept = 0;
		yych = *(scanner->marker = ++scanner->cursor);
		goto yy121;
yy12:
		++scanner->cursor;
yy13:
		{
ERRORreport_with_line(UNEXPECTED_CHARACTER,yylineno,yytext[0]);
IGNORE_TOKEN;
}
yy14:
		yych = *++scanner->cursor;
		switch (yych) {
		case '0':
		case '1':	goto yy117;
		default:	goto yy13;
		}
yy15:
		yyaccept = 0;
		yych = *(scanner->marker = ++scanner->cursor);
		goto yy112;
yy16:
		++scanner->cursor;
		switch ((yych = *scanner->cursor)) {
		case '*':	goto yy109;
		default:	goto yy17;
		}
yy17:
		{
return TOK_LEFT_PAREN; }
yy18:
		++scanner->cursor;
		{
return TOK_RIGHT_PAREN; }
yy20:
		++scanner->cursor;
		switch ((yych = *scanner->cursor)) {
		case ')':	goto yy105;
		case '*':	goto yy107;
		default:	goto yy21;
		}
yy21:
		{
return TOK_TIMES; }
yy22:
		++scanner->cursor;
		{
return TOK_PLUS; }
yy24:
		++scanner->cursor;
		{
return TOK_COMMA; }
yy26:
		yyaccept = 1;
		yych = *(scanner->marker = ++scanner->cursor);
		switch (yych) {
		case '-':	goto yy101;
		default:	goto yy27;
		}
yy27:
		{
return TOK_MINUS; }
yy28:
		++scanner->cursor;
		{
return TOK_DOT; }
yy30:
		++scanner->cursor;
		{
return TOK_REAL_DIV; }
yy32:
		++scanner->cursor;
		switch ((yych = *scanner->cursor)) {
		case '.':	goto yy94;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':	goto yy92;
		default:	goto yy33;
		}
yy33:
		{
return SCANprocess_integer_literal(yytext);
}
yy34:
		yyaccept = 2;
		yych = *(scanner->marker = ++scanner->cursor);
		switch (yych) {
		case '<':	goto yy84;
		case '=':	goto yy85;
		default:	goto yy35;
		}
yy35:
		{
return TOK_COLON; }
yy36:
		yyaccept = 3;
		yych = *(scanner->marker = ++scanner->cursor);
		switch (yych) {
		case '\t':
		case ' ':	goto yy76;
		case '-':	goto yy79;
		default:	goto yy37;
		}
yy37:
		{
return SCANprocess_semicolon(yytext, 0); }
yy38:
		++scanner->cursor;
		switch ((yych = *scanner->cursor)) {
		case '*':	goto yy74;
		case '=':	goto yy72;
		case '>':	goto yy70;
		default:	goto yy39;
		}
yy39:
		{
return TOK_LESS_THAN; }
yy40:
		++scanner->cursor;
		{
return TOK_EQUAL; }
yy42:
		++scanner->cursor;
		switch ((yych = *scanner->cursor)) {
		case '=':	goto yy68;
		default:	goto yy43;
		}
yy43:
		{
return TOK_GREATER_THAN; }
yy44:
		++scanner->cursor;
		{
return TOK_QUESTION_MARK; }
yy46:
		++scanner->cursor;
		yych = *scanner->cursor;
		goto yy67;
yy47:
		{
return SCANprocess_identifier_or_keyword(yytext);
}
yy48:
		++scanner->cursor;
		{
return TOK_LEFT_BRACKET; }
yy50:
		++scanner->cursor;
		{
return TOK_BACKSLASH; }
yy52:
		++scanner->cursor;
		{
return TOK_RIGHT_BRACKET; }
yy54:
		++scanner->cursor;
		yych = *scanner->cursor;
		goto yy65;
yy55:
		{
ERRORreport_with_line(BAD_IDENTIFIER, yylineno, yytext);
return SCANprocess_identifier_or_keyword(yytext);
}
yy56:
		++scanner->cursor;
		{
return TOK_LEFT_CURL; }
yy58:
		++scanner->cursor;
		switch ((yych = *scanner->cursor)) {
		case '|':	goto yy62;
		default:	goto yy59;
		}
yy59:
		{
return TOK_SUCH_THAT; }
yy60:
		++scanner->cursor;
		{
return TOK_RIGHT_CURL; }
yy62:
		++scanner->cursor;
		{
return TOK_CONCAT_OP; }
yy64:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
yy65:
		switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'G':
		case 'H':
		case 'I':
		case 'J':
		case 'K':
		case 'L':
		case 'M':
		case 'N':
		case 'O':
		case 'P':
		case 'Q':
		case 'R':
		case 'S':
		case 'T':
		case 'U':
		case 'V':
		case 'W':
		case 'X':
		case 'Y':
		case 'Z':
		case '_':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f':
		case 'g':
		case 'h':
		case 'i':
		case 'j':
		case 'k':
		case 'l':
		case 'm':
		case 'n':
		case 'o':
		case 'p':
		case 'q':
		case 'r':
		case 's':
		case 't':
		case 'u':
		case 'v':
		case 'w':
		case 'x':
		case 'y':
		case 'z':	goto yy64;
		default:	goto yy55;
		}
yy66:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
yy67:
		switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'G':
		case 'H':
		case 'I':
		case 'J':
		case 'K':
		case 'L':
		case 'M':
		case 'N':
		case 'O':
		case 'P':
		case 'Q':
		case 'R':
		case 'S':
		case 'T':
		case 'U':
		case 'V':
		case 'W':
		case 'X':
		case 'Y':
		case 'Z':
		case '_':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f':
		case 'g':
		case 'h':
		case 'i':
		case 'j':
		case 'k':
		case 'l':
		case 'm':
		case 'n':
		case 'o':
		case 'p':
		case 'q':
		case 'r':
		case 's':
		case 't':
		case 'u':
		case 'v':
		case 'w':
		case 'x':
		case 'y':
		case 'z':	goto yy66;
		default:	goto yy47;
		}
yy68:
		++scanner->cursor;
		{
return TOK_GREATER_EQUAL; }
yy70:
		++scanner->cursor;
		{
return TOK_NOT_EQUAL; }
yy72:
		++scanner->cursor;
		{
return TOK_LESS_EQUAL; }
yy74:
		++scanner->cursor;
		{
return TOK_ALL_IN; }
yy76:
		++scanner->cursor;
		if ((scanner->null - scanner->cursor) < 2) YYFILL(2);
		yych = *scanner->cursor;
		switch (yych) {
		case '\t':
		case ' ':	goto yy76;
		case '-':	goto yy79;
		default:	goto yy78;
		}
yy78:
		scanner->cursor = scanner->marker;
		switch (yyaccept) {
		case 0: 	goto yy7;
		case 1: 	goto yy27;
		case 2: 	goto yy35;
		case 3: 	goto yy37;
		case 4: 	goto yy96;
		case 5: 	goto yy114;
		}
yy79:
		yych = *++scanner->cursor;
		switch (yych) {
		case '-':	goto yy80;
		default:	goto yy78;
		}
yy80:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
		switch (yych) {
		case '\n':	goto yy82;
		default:	goto yy80;
		}
yy82:
		++scanner->cursor;
		{
NEWLINE;
return SCANprocess_semicolon(yytext, 1);
}
yy84:
		yych = *++scanner->cursor;
		switch (yych) {
		case '>':	goto yy89;
		default:	goto yy78;
		}
yy85:
		++scanner->cursor;
		switch ((yych = *scanner->cursor)) {
		case ':':	goto yy87;
		default:	goto yy86;
		}
yy86:
		{
return TOK_ASSIGNMENT; }
yy87:
		++scanner->cursor;
		{
return TOK_INST_EQUAL; }
yy89:
		yych = *++scanner->cursor;
		switch (yych) {
		case ':':	goto yy90;
		default:	goto yy78;
		}
yy90:
		++scanner->cursor;
		{
return TOK_INST_NOT_EQUAL; }
yy92:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
		switch (yych) {
		case '.':	goto yy94;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':	goto yy92;
		default:	goto yy33;
		}
yy94:
		yyaccept = 4;
		scanner->marker = ++scanner->cursor;
		if ((scanner->null - scanner->cursor) < 3) YYFILL(3);
		yych = *scanner->cursor;
		switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':	goto yy94;
		case 'E':
		case 'e':	goto yy97;
		default:	goto yy96;
		}
yy96:
		{
return SCANprocess_real_literal(yytext);
}
yy97:
		yych = *++scanner->cursor;
		switch (yych) {
		case '+':
		case '-':	goto yy98;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':	goto yy99;
		default:	goto yy78;
		}
yy98:
		yych = *++scanner->cursor;
		switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':	goto yy99;
		default:	goto yy78;
		}
yy99:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
		switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':	goto yy99;
		default:	goto yy96;
		}
yy101:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
		switch (yych) {
		case '\n':	goto yy103;
		default:	goto yy101;
		}
yy103:
		++scanner->cursor;
		{
NEWLINE;
SCANsave_comment(yytext);
IGNORE_TOKEN;
}
yy105:
		++scanner->cursor;
		{
ERRORreport_with_line(UNMATCHED_CLOSE_COMMENT, yylineno);
IGNORE_TOKEN;
}
yy107:
		++scanner->cursor;
		{
return TOK_EXP; }
yy109:
		++scanner->cursor;
		YYSETCONDITION(comment);
		{
if (nesting_level <MAX_NESTED_COMMENTS) {
open_comment[nesting_level].line = yylineno;
open_comment[nesting_level].filename = current_filename;
}
nesting_level++;
IGNORE_TOKEN;
}
yy111:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
yy112:
		switch (yych) {
		case '\n':	goto yy115;
		case '\'':	goto yy113;
		default:	goto yy111;
		}
yy113:
		yyaccept = 5;
		scanner->marker = ++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
		switch (yych) {
		case '\'':	goto yy111;
		default:	goto yy114;
		}
yy114:
		{
return SCANprocess_string(yytext);
}
yy115:
		++scanner->cursor;
		{
ERRORreport_with_line(UNTERMINATED_STRING, LINENO_FUDGE);
NEWLINE;
return SCANprocess_string(yytext);
}
yy117:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
		switch (yych) {
		case '0':
		case '1':	goto yy117;
		default:	goto yy119;
		}
yy119:
		{
return SCANprocess_binary_literal(yytext);
}
yy120:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
yy121:
		switch (yych) {
		case '\n':	goto yy122;
		case '"':	goto yy124;
		default:	goto yy120;
		}
yy122:
		++scanner->cursor;
		{
ERRORreport_with_line(UNTERMINATED_STRING, LINENO_FUDGE);
NEWLINE;
return SCANprocess_encoded_string(yytext);
}
yy124:
		++scanner->cursor;
		{
return SCANprocess_encoded_string(yytext);
}
yy126:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
yy127:
		switch (yych) {
		case '\t':
		case ' ':	goto yy126;
		default:	goto yy5;
		}
/* *********************************** */
yyc_comment:
		if ((scanner->null - scanner->cursor) < 2) YYFILL(2);
		yych = *scanner->cursor;
		switch (yych) {
		case '\t':
		case ' ':	goto yy132;
		case '\n':	goto yy133;
		case '(':	goto yy135;
		case ')':	goto yy137;
		case '*':	goto yy138;
		default:	goto yy131;
		}
yy130:
		{
IGNORE_TOKEN; }
yy131:
		yych = *++scanner->cursor;
		goto yy144;
yy132:
		yych = *++scanner->cursor;
		switch (yych) {
		case '\t':
		case ' ':	goto yy145;
		default:	goto yy144;
		}
yy133:
		++scanner->cursor;
		{
NEWLINE;
IGNORE_TOKEN;
}
yy135:
		++scanner->cursor;
		switch ((yych = *scanner->cursor)) {
		case '*':	goto yy141;
		default:	goto yy136;
		}
yy136:
		{
IGNORE_TOKEN; }
yy137:
		yych = *++scanner->cursor;
		goto yy136;
yy138:
		yych = *++scanner->cursor;
		switch (yych) {
		case ')':	goto yy139;
		default:	goto yy136;
		}
yy139:
		++scanner->cursor;
		{
if (0 == --nesting_level) {
YYSETCONDITION(code);
}
IGNORE_TOKEN;
}
yy141:
		++scanner->cursor;
		{
if (nesting_level <MAX_NESTED_COMMENTS) {
open_comment[nesting_level].line = yylineno;
open_comment[nesting_level].filename = current_filename;
}
nesting_level++;
IGNORE_TOKEN;
}
yy143:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
yy144:
		switch (yych) {
		case '\n':
		case '(':
		case ')':
		case '*':	goto yy130;
		default:	goto yy143;
		}
yy145:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
		switch (yych) {
		case '\t':
		case ' ':	goto yy145;
		case '\n':
		case '(':
		case ')':
		case '*':	goto yy130;
		default:	goto yy143;
		}
/* *********************************** */
yyc_return_end_schema:
		if ((scanner->null - scanner->cursor) < 2) YYFILL(2);
		yych = *scanner->cursor;
		switch (yych) {
		case '\t':
		case ' ':	goto yy152;
		case '\n':	goto yy153;
		case '(':	goto yy155;
		case 'X':
		case 'x':	goto yy156;
		default:	goto yy150;
		}
yy149:
		{
IGNORE_TOKEN; }
yy150:
		++scanner->cursor;
yy151:
		{
IGNORE_TOKEN; }
yy152:
		yych = *++scanner->cursor;
		goto yy161;
yy153:
		++scanner->cursor;
		{
NEWLINE;
IGNORE_TOKEN;
}
yy155:
		yych = *++scanner->cursor;
		switch (yych) {
		case '*':	goto yy158;
		default:	goto yy151;
		}
yy156:
		++scanner->cursor;
		YYSETCONDITION(code);
		{
return TOK_END_SCHEMA;
}
yy158:
		++scanner->cursor;
		YYSETCONDITION(comment);
		{
if (nesting_level <MAX_NESTED_COMMENTS) {
open_comment[nesting_level].line = yylineno;
open_comment[nesting_level].filename = current_filename;
}
nesting_level++;
IGNORE_TOKEN;
}
yy160:
		++scanner->cursor;
		if (scanner->null <= scanner->cursor) YYFILL(1);
		yych = *scanner->cursor;
yy161:
		switch (yych) {
		case '\t':
		case ' ':	goto yy160;
		default:	goto yy149;
		}
	}

    }
}

/* start code */
void
SCANskip_to_end_schema(perplex_t scanner)
{
while (yylex(scanner) != TOK_END_SCHEMA);
perplexUnput(scanner, 'X');	/* any old character */
YYSETCONDITION(return_end_schema);
}
