%{
/*********************************************************************
 *   Copyright 1993, UCAR/Unidata
 *   See netcdf/COPYRIGHT file for copying and redistribution conditions.
 *   $Id: ncgen.l,v 1.24 2009/09/25 18:22:35 dmh Exp $
 *********************************************************************/

/* Problems:
1. We assume the input is true utf8.
   Unfortunately, we may actually get iso-latin-8859-1.
   This means that there will be ambiguity about the characters
   in the range 128-255 because they will look like n-byte unicode
   when they are 1-byte 8859 characters. Because of our encoding,
   8859 characters above 128 will be handles as n-byte utf8 and so
   will probably not lex correctly.
   Solution: assume utf8 and note in the documentation that
   ISO8859 is specifically unsupported.
2. The netcdf function NC_check_name in string.c must be modified to
   conform to the use of UTF8.
3. We actually have three tests for UTF8 of increasing correctness
   (in the sense that the least correct will allow some sequences that
    are technically illegal UTF8).
   The tests are derived from the table at
	    http://www.w3.org/2005/03/23-lex-U
   We include lexical definitions for all three, but use the second version.
4. Single character constants enclosed in '...' cannot be
   utf-8, so we assume they are by default encoded using the 1-byte
   subset of utf-8. It turns out that this subset is in fact
   equivalent to US-Ascii (7-bit).
   We could use ISO-8859-1, but that conflicts with UTF-8 above value 127.
*/

/* lex specification for tokens for ncgen */

/* Fill value used by ncdump from version 2.4 and later.  Should match
   definition of FILL_STRING in ../ncdump/vardata.h */
#define FILL_STRING "_"
#define XDR_INT32_MIN (-2147483647-1)
#define XDR_INT32_MAX 2147483647
#define XDR_INT64_MIN  (-9223372036854775807LL-1)
#define XDR_INT64_MAX  (9223372036854775807LL)

/*Mnemonics*/
#define ISIDENT 1

char errstr[100];		/* for short error messages */

int lineno;              /* line number for error messages */
Bytebuffer* lextext;           /* name or string with escapes removed */

#define YY_BREAK                /* defining as nothing eliminates unreachable
				   statement warnings from flex output, 
                                   but make sure every action ends with
                                   "return" or "break"! */

int specialconstants;		/* 1 if nan, nanf, infinity, etc is used */
double double_val;             /* last double value read */
float float_val;               /* last float value read */
long long int64_val;           /* last int64 value read */
int int32_val;                 /* last int32 value read */
short int16_val;               /* last short value read */
unsigned long long uint64_val; /* last int64 value read */
unsigned int uint32_val;       /* last int32 value read */
unsigned short uint16_val;     /* last short value read */
char char_val;                 /* last char value read */
signed char byte_val;                 /* last byte value read */
unsigned char ubyte_val;       /* last byte value read */

static Symbol* makepath(char* text);
static int lexdebug(int);
static int parseLL(char* text);

static struct Specialtoken {
    char* name;
    int   token;
} specials[] = {
{"_FillValue",_FILLVALUE},
{"_Format",_FORMAT},
{"_Storage",_STORAGE},
{"_ChunkSizes",_CHUNKSIZES},
{"_Fletcher32",_FLETCHER32},
{"_DeflateLevel",_DEFLATELEVEL},
{"_Shuffle",_SHUFFLE},
{"_Endianness",_ENDIANNESS},
{"_NoFill",_NOFILL},
{NULL,0} /* null terminate */
};

%}
%x ST_C_COMMENT
%x TEXT
%p 6000

/* The most correct (validating) version of UTF8 character set
   (Taken from: http://www.w3.org/2005/03/23-lex-U)

The lines of the expression cover the UTF8 characters as follows:
1. non-overlong 2-byte
2. excluding overlongs
3. straight 3-byte
4. excluding surrogates
5. straight 3-byte
6. planes 1-3
7. planes 4-15
8. plane 16

UTF8   ([\xC2-\xDF][\x80-\xBF])                       \
     | (\xE0[\xA0-\xBF][\x80-\xBF])                   \
     | ([\xE1-\xEC][\x80-\xBF][\x80-\xBF])            \
     | (\xED[\x80-\x9F][\x80-\xBF])                   \
     | ([\xEE-\xEF][\x80-\xBF][\x80-\xBF])            \
     | (\xF0[\x90-\xBF][\x80-\xBF][\x80-\xBF])        \
     | ([\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF]) \
     | (\xF4[\x80-\x8F][\x80-\xBF][\x80-\xBF])        \

*/

/* Wish there was some way to ifdef lex files */

/*The most relaxed version of UTF8 (not used)
UTF8 ([\xC0-\xD6].)|([\xE0-\xEF]..)|([\xF0-\xF7]...)
*/

/*The partially relaxed version of UTF8, and the one used here */
UTF8 ([\xC0-\xD6][\x80-\xBF])|([\xE0-\xEF][\x80-\xBF][\x80-\xBF])|([\xF0-\xF7][\x80-\xBF][\x80-\xBF][\x80-\xBF])

/* The old definition of ID
ID ([A-Za-z_]|{UTF8})([A-Z.@#\[\]a-z_0-9+-]|{UTF8})*
*/

/* Don't permit control characters or '/' in names, but other special
   chars OK if escaped.  Note that to preserve backwards
   compatibility, none of the characters _.@+- should be escaped, as
   they were previously permitted in names without escaping.  */

idescaped \\[ !"#$%&'()*,:;<=>?\[\\\]^`{|}~]
numescaped \\[0-9]

/* New definition to conform to a subset of string.c */
ID ([a-zA-Z_]|{UTF8}|{numescaped})([a-zA-Z0-9_.@+-]|{UTF8}|{idescaped})*

escaped		\\.

/* Capture a datasetidentifier */
/* DATASETID ([a-zA-Z0-9!#$%&*:;<=>?/^|~_.@+-]|{UTF8})* */
DATASETID [^{][^{]*


/* Note: this definition of string will work for utf8 as well,
   although it is a very relaxed definition
*/
nonquotes	([^"\\]|{escaped})*
exp		([eE][+-]?[0-9]+)

OPAQUESTRING	(0[xX][0-9A-Fa-f][0-9A-Fa-f]*)

PATH    ([/]|([/]{ID})([/]{ID})*)

SIMPLENUMBER [+-]?[0-9][0-9]*
XUNUMBER     {OPAQUESTRING}[SsLl]
UNUMBER      [0-9][0-9]*[Uu][BbSsLl]?
NUMBER       [+-]?[0-9][0-9]*[BbSsLl]
DBLNUMBER    [+-]?[0-9]*\.[0-9]*{exp}?[LlDd]?|[+-]?[0-9]*{exp}[LlDd]?
FLTNUMBER    [+-]?[0-9]*\.[0-9]*{exp}?[Ff]|[+-]?[0-9]*{exp}[Ff]

SPECIAL "_FillValue"|"_Format"|"_Storage"|"_ChunkSizes"|"_Fletcher32"|"_DeflateLevel"|"_Shuffle"|"_Endianness"|"_NoFill"

USASCII   [\x01-\x7F]

%%
[ \r\t\f]+	{ /* whitespace */ 
		  break;        
		}

\/\/.*		        { /* comment */ 
                          break;
                        }

\"{nonquotes}\"		{int len;
			 /* In netcdf4, this will be used in a variety
                            of places, so only remove escapes */
/*
if(yyleng > MAXTRST) {
yyerror("string too long, truncated\n");
yytext[MAXTRST-1] = '\0';
}
*/
		        /* FIX: Assumes unescape also does normalization */
			bbSetalloc(lextext,yyleng+1); /*+1 for nul */
			/* Adjust length */
		        bbSetlength(lextext,yyleng-2); /*-2 for quotes */
			len = unescape(bbContents(lextext),
                                       (char *)yytext+1,yyleng-2,!ISIDENT);
			if(len < 0) {
			    sprintf(errstr,"Illegal character: %s",yytext);
			    yyerror(errstr);
			}
			bbSetlength(lextext,len);
			bbNull(lextext);
		 	return lexdebug(TERMSTRING);
		        }

{OPAQUESTRING}	{ /* drop leading 0x; pad to even number of chars */
		char* p = yytext+2;
		int len = yyleng - 2;
		bbClear(lextext);
	        bbAppendn(lextext,p,len);
	        if((len % 2) == 1) bbAppend(lextext,'0');
		bbNull(lextext);
		/* convert all chars to lower case */
		for(p=bbContents(lextext);*p;p++) *p = tolower(*p);
		return lexdebug(OPAQUESTRING);
		}

compound|struct|structure {return lexdebug(COMPOUND);}
enum				{return lexdebug(ENUM);}
opaque				{return lexdebug(OPAQUE);}

float|real		{return lexdebug(FLOAT_K);}
char			{return lexdebug(CHAR_K);}
byte			{return lexdebug(BYTE_K);}
ubyte			{return lexdebug(UBYTE_K);}
short			{return lexdebug(SHORT_K);}
ushort			{return lexdebug(USHORT_K);}
long|int|integer	{return lexdebug(INT_K);}
ulong|uint|uinteger	{return lexdebug(UINT_K);}
int64			{return lexdebug(INT64_K);}
uint64			{return lexdebug(UINT64_K);}
double			{return lexdebug(DOUBLE_K);}
unlimited|UNLIMITED	{int32_val = -1;
			 return lexdebug(NC_UNLIMITED_K);}

types:			{return lexdebug(TYPES);}
dimensions:		{return lexdebug(DIMENSIONS);}
variables:		{return lexdebug(VARIABLES);}
data:			{return lexdebug(DATA);}
group:			{return lexdebug(GROUP);}

(netcdf|NETCDF|netCDF)  {BEGIN(TEXT);return lexdebug(NETCDF);}

DoubleInf|-?Infinity { /* missing value (pre-2.4 backward compatibility) */
                if (yytext[0] == '-') {
		    double_val = NEGNC_INFINITE;
                } else {
		    double_val = NC_INFINITE;
                }
		specialconstants = 1;
		return lexdebug(DOUBLE_CONST);
		}
NaN|nan { /* missing value (pre-2.4 backward compatibility) */
		double_val = NAN;
		specialconstants = 1;
		return lexdebug(DOUBLE_CONST);
		}

FloatInf|-?Infinityf|-?Inff {/* missing value (pre-2.4 backward compatibility)*/
                if (yytext[0] == '-') {
		    float_val = NEGNC_INFINITEF;
                } else {
		    float_val = NC_INFINITEF;
                }
		specialconstants = 1;
		return lexdebug(FLOAT_CONST);
		}
NaNf|nanf { /* missing value (pre-2.4 backward compatibility) */
		float_val = NANF;
		specialconstants = 1;
		return lexdebug(FLOAT_CONST);
		}

NIL|nil|Nil {
#ifdef USE_NETCDF4
		if(l_flag == L_C || l_flag == L_BINARY)
		    return lexdebug(NIL);
		yyerror("NIL only allowed for netcdf-4 and for -lc or -lb");
#else
		yyerror("NIL only allowed for netcdf-4 and for -lc or -lb");
#endif
		}

{PATH}		{
		bbClear(lextext);
		bbAppendn(lextext,(char*)yytext,yyleng+1); /* include null */
	        bbNull(lextext);
		yylval.sym = makepath(bbContents(lextext));
		return lexdebug(PATH);
		}


{SPECIAL}      {struct Specialtoken* st;
		bbClear(lextext);
		bbAppendn(lextext,(char*)yytext,yyleng+1); /* include null */
		bbNull(lextext);
		for(st=specials;st->name;st++) {
		    if(strcmp(bbContents(lextext),st->name)==0) {return lexdebug(st->token);}
		}
		return 0;
		}

<TEXT>{DATASETID} {
		    int c;
		    char* p; char* q;
		    /* copy the trimmed name */
		    bbClear(lextext);
		    bbAppendn(lextext,(char*)yytext,yyleng+1); /* include null */
		    bbNull(lextext);
		    p = bbContents(lextext);
		    q = p;
		    while((c=*p++)) {if(c > ' ') *q++ = c;}
		    *q = '\0';
		    datasetname = bbDup(lextext);
		    BEGIN(INITIAL);
		    return lexdebug(DATASETID);
		}

{ID}		{ char* id; int len;
		    bbClear(lextext);
		    bbAppendn(lextext,(char*)yytext,yyleng+1); /* include null */
		    bbNull(lextext);
		    id = bbContents(lextext);
		    len = unescape(id,id,bbLength(lextext),ISIDENT);
		    bbSetlength(lextext,len);
		    if (STREQ(id, FILL_STRING)) return lexdebug(FILLMARKER);
		    yylval.sym = install(id);
		    return lexdebug(IDENT);
		}

{SIMPLENUMBER}	{
		    /* We need to try to see what size of integer ((u)int). */
		    /* Technically, the user should specify, but... */
		    /* If out of any integer range, then complain */
		    switch (parseLL(yytext)) {
		    case 0:
			return lexdebug(INT64_CONST); /* meaningless */
		    case -1:
#ifdef USE_NETCDF4
		        if(int64_val >= NC_MIN_INT) {
			    int32_val = (int)int64_val;
		            return lexdebug(INT_CONST);
			} else
		            return lexdebug(INT64_CONST);
#else
			/* Convert to int32, unless overflow then complain  */
			if(int64_val >=NC_MIN_INT) {
			    int32_val = (int)int64_val;
			} else {
			   sprintf(errstr,"32 bit integer constant out of range: %s",(char*)yytext);
			   yyerror(errstr);
			}
		        return lexdebug(INT_CONST);		    
#endif
		    case 1:
#ifdef USE_NETCDF4
 		        if(uint64_val <= NC_MAX_INT) {
			    int32_val = (int)uint64_val;
		            return lexdebug(INT_CONST);
 		        } else if(uint64_val <= NC_MAX_UINT) {
			    uint32_val = (unsigned int)uint64_val;
		            return lexdebug(UINT_CONST);
 		        } else if(uint64_val <= NC_MAX_INT64) {
			    int64_val = (long long)uint64_val;
		            return lexdebug(INT64_CONST);
			} else
		            return lexdebug(UINT64_CONST);
#else
			/* Convert to int32 but complain if overflow */
			if(uint64_val > NC_MAX_INT) {
			    sprintf(errstr,"32 bit integer constant out of range: %s",(char*)yytext);
			    yyerror(errstr);
			}
			int32_val = (int)uint64_val;
			return lexdebug(INT_CONST);
#endif
                     default:
                         yyerror("Unknown integer size");
		    }
		}

{NUMBER}    { /* The number may be signed or unsigned (signed has priority) */
		int slen = strlen(yytext);
		int tag = yytext[slen-1];
		int token = 0;
		switch (tag) {
		case 'B': case 'b':
		    if (sscanf((char*)yytext, "%d", &int32_val) != 1) {
		        sprintf(errstr,"bad byte constant: %s",(char*)yytext);
		        yyerror(errstr);
		    } else if(int32_val >= NC_MIN_BYTE && int32_val <= NC_MAX_BYTE) {
		        byte_val = (signed char)int32_val;
		        token = BYTE_CONST;
		    } else if(int32_val >= 0 && int32_val <= NC_MAX_UBYTE) {
		        ubyte_val = (unsigned char)int32_val;
		        token = UBYTE_CONST;
		    } else {
		        sprintf(errstr,"bad byte constant: %s",(char*)yytext);
		        yyerror(errstr);
		    }
		    break;
		case 'S': case 's':
		    if (sscanf((char*)yytext, "%d", &int32_val) != 1) {
		        sprintf(errstr,"bad short constant: %s",(char*)yytext);
		        yyerror(errstr);
		    } else if(int32_val >= NC_MIN_SHORT && int32_val <= NC_MAX_SHORT) {
		        int16_val = (signed short)int32_val;
		        token = SHORT_CONST;
		    } else if(int32_val >= 0 && int32_val <= NC_MAX_USHORT) {
		        uint16_val = (unsigned short)int32_val;
		        token = USHORT_CONST;
		    } else {
		        sprintf(errstr,"bad short constant: %s",(char*)yytext);
		        yyerror(errstr);
		    }
		    break;
		case 'L': case 'l':
		    switch(parseLL(yytext)) {
		    case 0:
		        sprintf(errstr,"bad int64 constant: %s",(char*)yytext);
		        yyerror(errstr);
			break;
		    case -1: token = INT64_CONST; break;
		    case 1:
			/* if value is too big, complain */
			/* cannot actually test this.
		        if(uint64_val > NC_MAX_INT64) {
			   sprintf(errstr,"64 bit integer constant out of range: %s",(char*)yytext);
			   yyerror(errstr);
			}
                        */
		        int64_val = (long long)(uint64_val & 0x7fffffffffffffffLL);
			token = INT64_CONST;
			break;
		    }
		    break;
		default:/*(optionally)signed string of digits; treat like int*/
		    sprintf(errstr,"bad numeric constant: %s",(char*)yytext);
		    yyerror(errstr);
		}
		return lexdebug(token);
	    }

{UNUMBER}    {
		int slen = strlen(yytext);
		int tag = yytext[slen-1];
		int token = 0;
		switch (tag) {
		case 'B': case 'b':
		    if (sscanf((char*)yytext, "%u", &uint32_val) != 1
		        || uint32_val > NC_MAX_UBYTE) {
		        sprintf(errstr,"bad unsigned byte constant: %s",(char*)yytext);
		        yyerror(errstr);
		    }
		    ubyte_val = (unsigned char)uint32_val;
		    token = UBYTE_CONST;
		    break;
		case 'S': case 's':
		    if (sscanf((char*)yytext, "%u", &uint32_val) != 1
		        || uint32_val > NC_MAX_USHORT) {
		        sprintf(errstr,"bad unsigned short constant: %s",(char*)yytext);
		        yyerror(errstr);
		    }
		    uint16_val = (unsigned short)uint32_val;
		    token = USHORT_CONST;
		    break;
		case 'L': case 'l':
		    if (sscanf((char*)yytext, "%llu", &uint64_val) != 1) {
		        sprintf(errstr,"bad unsigned int64 constant: %s",(char*)yytext);
		        yyerror(errstr);
		    }
		    token = UINT64_CONST;
		    break;
		default: /* string of digits; treat like int */
		    if (sscanf((char*)yytext, "%u", &uint32_val) != 1) {
		        sprintf(errstr,"bad unsigned int constant: %s",(char*)yytext);
		        yyerror(errstr);
		    }
		    token = UINT_CONST;
		}
		return lexdebug(token);
	    }
{XUNUMBER}    {
		int c;
		int token = 0;
		int slen = strlen(yytext);
		int tag = yytext[slen-1];
		char* hex = yytext+2; /* point to first true hex digit */
		int xlen = (slen - 3);  /* true hex length */
		yytext[slen-1] = '\0';
	        if(xlen > 16) { /* truncate hi order digits */
		    hex += (xlen - 16);
		}
		/* convert to an unsigned long long */
		uint64_val = 0;
		while((c=*hex++)) {
		    unsigned int hexdigit = (c <= '9'?(c-'0'):(c-'a')+0xa);
		    uint64_val = ((uint64_val << 4) | hexdigit);
		}
		switch (tag) {
		case 'S': case 's':
		    uint16_val = (unsigned short)uint64_val;
		    token = USHORT_CONST;
		    break;
		case 'L': case 'l':
		    token = UINT64_CONST;
		    break;
		default: /* should never happen */
		    if (sscanf((char*)yytext, "%i", &uint32_val) != 1) {
		        sprintf(errstr,"bad unsigned int constant: %s",(char*)yytext);
		        yyerror(errstr);
		    }
		    token = UINT_CONST;
		}
		return lexdebug(token);
	    }
{DBLNUMBER}	{
		if (sscanf((char*)yytext, "%le", &double_val) != 1) {
		    sprintf(errstr,"bad long or double constant: %s",(char*)yytext);
		    yyerror(errstr);
		}
                return lexdebug(DOUBLE_CONST);
                }
{FLTNUMBER}  {
		if (sscanf((char*)yytext, "%e", &float_val) != 1) {
		    sprintf(errstr,"bad float constant: %s",(char*)yytext);
		    yyerror(errstr);
		}
                return lexdebug(FLOAT_CONST);
                }
\'[^\\]\'          {
	        (void) sscanf((char*)&yytext[1],"%c",&byte_val);
		return lexdebug(BYTE_CONST);
                }
\'\\[0-7][0-7][0-7]\'  {
		int oct = unescapeoct(&yytext[2]);
		if(oct < 0) {
		    sprintf(errstr,"bad octal character constant: %s",(char*)yytext);
		    yyerror(errstr);
		}		    		    
	        byte_val = (unsigned int)oct;
		return lexdebug(BYTE_CONST);
                }
\'\\[xX][0-9a-fA-F][0-9a-fA-F]\'  {
		int hex = unescapehex(&yytext[3]);
		if(byte_val < 0) {
		    sprintf(errstr,"bad hex character constant: %s",(char*)yytext);
		    yyerror(errstr);
		}		    		    
		byte_val = (unsigned int)hex;
		return lexdebug(BYTE_CONST);
                }
\'\\.\'        {
	       switch ((char)yytext[2]) {
	          case 'a': byte_val = '\007'; break; /* not everyone under-
						       * stands '\a' yet */
     	          case 'b': byte_val = '\b'; break;
		  case 'f': byte_val = '\f'; break;
		  case 'n': byte_val = '\n'; break;
		  case 'r': byte_val = '\r'; break;
		  case 't': byte_val = '\t'; break;
		  case 'v': byte_val = '\v'; break;
		  case '\\': byte_val = '\\'; break;
		  case '?': byte_val = '\177'; break;
		  case '\'': byte_val = '\''; break;
		  default: byte_val = (char)yytext[2];
	           }
		return lexdebug(BYTE_CONST);
                }

\n		{
		lineno++ ;
                break;
		}

"/""*"	{/*initial*/
	    BEGIN(ST_C_COMMENT);
	    break;
	}

<ST_C_COMMENT>([^*]|"*"[^/])*	{/* continuation */
				     break;
				}

<ST_C_COMMENT>"*/"	{/* final */
			    BEGIN(INITIAL);
			    break;
			}

<ST_C_COMMENT><<EOF>>	{/* final, error */
			    fprintf(stderr,"unterminated /**/ comment");
			    BEGIN(INITIAL);
			    break;
			}

.		{/* Note: this next rule will not work for UTF8 characters */
		return lexdebug(yytext[0]) ;
		}
%%
static int
lexdebug(int token)
{
    if(debug >= 2)
    {
	char* text = yytext;
	text[yyleng] = 0;
        fprintf(stderr,"Token=%d |%s| line=%d\n",token,text,lineno);
    }
    return token;
}

int
lex_init(void)
{
    lineno = 1;
    lextext = bbNew();
    if(0) unput(0); /* keep -Wall quiet */
    return 0;
}

static Symbol*
makepath(char* text0)
{
    /* Create a reference symbol.
       Convert path to a sequence of symbols.
       Use last name as symbol name (with root group reference ('/') as exception).
    */
    Symbol* refsym = NULL;
    /* walk the path converting to a sequence of symbols */
    if(strcmp(text0,"/")==0) {
	/* special case of root reference */
	refsym = rootgroup;
    } else {
        List* prefix = listnew();
	/* split the text into IDENT chunks, convert to symbols */
        Symbol* container = rootgroup;
	char *ident, *p;
        char* text = strdup(text0);
	int c,lastident;
	ident=text+1; p=ident; /* skip leading '/' */
	do {
	    lastident = 0;
	    switch ((c=*p)) {
	    default: p++; break;
	    case '\\': p++; if(*p == '/') p++; break;
	    case '\0': /* treat null terminator like trailing '/' (mostly) */
		lastident=1; /* this is the last ident in the path */
		/*fall thru */
	    case '/':
		*p='\0';
		if(!lastident) {
		    unescape(ident,ident,strlen(ident),ISIDENT);
		    refsym = lookupingroup(NC_GRP,ident,container);
		    if(refsym == NULL) {
		        sprintf(errstr,"Undefined or forward referenced group: %s",ident);
		        yyerror(errstr);
			refsym = rootgroup;
		    } else {
		        listpush(prefix,(void*)refsym);
		    }
		} else { /* lastident is true */
		    unescape(ident,ident,strlen(ident),ISIDENT);
		    refsym = install(ident);
		    refsym->objectclass = NC_GRP;/* tentative */
		    refsym->ref.is_ref = 1;
		    refsym->container = container;
		    refsym->subnodes = listnew();
		}
		container = refsym;
	        ident=p+1; p=ident;		
	        break;
	    }
	} while(c != '\0');
        refsym->prefix = prefix;
	free(text);
    }
    return refsym;
}


static int
parseLL(char* text)
{
    int result = 0;
#if defined(HAVE_STRTOLL) && defined(HAVE_STRTOULL)
    extern int errno;
    char* endptr;
    errno = 0; endptr = NULL;
    if(text[0] == '-') {
        int64_val = strtoll(text,&endptr,10);
	result = -1; /* negative int64_val */	
    } else {
        uint64_val = strtoull(text,&endptr,10);
	result = 1; /* positive uint64_val */	
    }
    if(result == 0) {
	sprintf(errstr,"Unparseable 64 bit integer constant: %s",(char*)text);
	yyerror(errstr);
    } else if(errno == ERANGE) {
	sprintf(errstr,"64 bit integer constant out of range: %s",(char*)text);
	yyerror(errstr);
	result = 0; /* out of range */
    }			
#else /*!(defined HAVE_STRTOLL && defined HAVE_STRTOULL)*/
    if(text[0] == '-') {
        sscanf((char*)text, "%lld", &int64_val);
	result = -1; /* negative int64_val */	
    } else {
	sscanf((char*)text, "%llu", &uint64_val);
	result = 1; /* positive uint64_val */	
    }
    /* Have no useful way to detect out of range */
#endif /*!(defined HAVE_STRTOLL && defined HAVE_STRTOULL)*/
    return result;
}


