/ray/src/lib/lex/basicparse.cc

Go to the documentation of this file.

/*
 * lib/lex/basicparse.cc
 * 
 * Basic integer / floating point parsing routines. 
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#include "basicparse.h"
#include <ctype.h>

#if HAVE_ERRNO_H
#include <errno.h>
#endif


// Internally used string to integer conversion function which can handle 
// 8,16,32 and 64 bit signed integers. To parse a value of type T 
// (with T being int8,int16,int32,int64), supply the corresponding unsigned 
// type as UT. 
// (Large but inline as only used once in the file.)
// By Wolfgang Wieser, part of algorithm from glibc. 
template<typename T,typename UT>
    static inline char *_ParseInt(T *rv,const char *str,
        SError &error,bool may_continue)
{
    error.clear();
    
    const char *s=str;
    if(!s)  return((char*)s);
    
    // First, skip any whitespace. 
    while(isspace(*s))  ++s;
    
    // Skip sign, if any. 
    bool neg=0;
    if(*s=='-')
    {  neg=1;  ++s;  }
    else if(*s=='+')
    {  ++s;  }
    
    // Then, determine base. 
    char base=10;
    if(*s=='0')
    {
        ++s;
        if(*s=='x' || *s=='X')
        {  base=16;  ++s;  }
        else if(*s=='b' || *s=='B')
        {  base=2;  ++s;  }
        else
        {  base=8;  --s;  }
    }
    
    // Read in the value. 
    static const UT min_val=
        sizeof(T)==1 ? (UT)0x80U : 
        sizeof(T)==2 ? (UT)0x8000U : 
        sizeof(T)==4 ? (UT)0x80000000LU : 
                       (UT)0x8000000000000000LLU ;
    static const UT max_val=
        sizeof(T)==1 ? (UT)0x7fU : 
        sizeof(T)==2 ? (UT)0x7fffU : 
        sizeof(T)==4 ? (UT)0x7fffffffLU : 
                       (UT)0x7fffffffffffffffLLU ;
    
    // cutoff and limit are used to detect overflow. This code is based 
    // upon strtol.c found in glibc-2.1.2 (GNU C Library), Copyright (C) 
    // 1991,92,94,95, 96,97,98,99 Free Software Foundation, Inc.
    // (No authors were mentioned in the file.)
    UT cutoff = neg ? min_val : max_val;
    char limit = (char)(cutoff % UT(base));
    cutoff/=UT(base);
    bool overflow=0;
    unsigned char consumed=0;  // max 63 for binary parsing of int64
    register char c=*s;
    UT val=0;
    
    // There are now optimized versions for base <=10 and 16. 
    // Expect runtime savings of <=7% with GCC-3.4.2 (pre) on AthlonXP for 
    // int32 (decimal/hex); depending on optimization. 
    if(base==16) for(;;c=*++s)
    {
        if(c>='0' && c<='9')  c-='0';
        else if(c>='a' && c<='f')  c-='a'-10;
        else if(c>='A' && c<='F')  c-='A'-10;
        else break;
        if(val>cutoff || (val==cutoff && c>limit))
        {  overflow=1;  }
        else if(!overflow)
        {  val=(val<<4)|((unsigned char)c);  ++consumed;  }
    }
    else if(base<=10)
    {
        char lastchar='0'+base;
        for(;;c=*++s)
        {
            if(c>='0' && c<lastchar)  c-='0';
            else break;
            if(val>cutoff || (val==cutoff && c>limit))
            {  overflow=1;  }
            else if(!overflow)
            {  val=val*base+c;  ++consumed;  }
        }
    }
    else for(;;c=*++s)
    {
        if(c>='0' && c<='9')  c-='0';
        else if(c>='a' && c<='z')  c-='a'-10;
        else if(c>='A' && c<='Z')  c-='A'-10;
        else break;
        if(c>=base)  break;
        if(val>cutoff || (val==cutoff && c>limit))
        {  overflow=1;  }
        else if(!overflow)
        {  val=val*base+c;  ++consumed;  }
    }
    
    if(overflow)
    {
        *rv = neg ? (T)-min_val : (T)max_val;
        TLString tmp;
        tmp.sprintf("%dbit signed integer %serflow",
            sizeof(T)*8,neg ? "und" : "ov");
        error=SError(tmp,1);
    }
    else
    {  *rv = neg ? -val : val;  }
    
    // Parsing ended at c, see if it is end of string. 
    if(!c && !consumed)
    {
        Assert(!error);
        error=SError("expected integer missing",1);
    }
    else if(!may_continue)
    {
        TLString tmp;
        tmp.sprintf("illegal char '%c' in integer (base %d)",c,(int)base);
        if(error)  tmp.prepend(error.msg()+"; ");
        error=SError(tmp,1);
    }
    
    return((char*)(consumed ? s : str));
}


char *ParseInt(int8 *val,const char *str,SError &error,bool may_continue)
    {  return(_ParseInt<int8,uint8>(val,str,error,may_continue));  }

char *ParseInt(int16 *val,const char *str,SError &error,bool may_continue)
    {  return(_ParseInt<int16,uint16>(val,str,error,may_continue));  }

char *ParseInt(int32 *val,const char *str,SError &error,bool may_continue)
    {  return(_ParseInt<int32,uint32>(val,str,error,may_continue));  }

char *ParseInt(int64 *val,const char *str,SError &error,bool may_continue)
    {  return(_ParseInt<int64,uint64>(val,str,error,may_continue));  }


// This is pretty much the same as the _ParseInt() template but for 
// unsigned types. Only the unsigned type needs to be specified as template 
// parameter. 
// By Wolfgang Wieser, part of algorithm from glibc.
template<typename UT>
    static inline char *_ParseUInt(UT *rv,const char *str,
        SError &error,bool may_continue)
{
    error.clear();
    
    const char *s=str;
    if(!s)  return((char*)s);
    
    // First, skip any whitespace. 
    while(isspace(*s))  ++s;
    
    // Skip sign, if any. 
    if(*s=='+')  ++s;
    
    // Then, determine base. 
    char base=10;
    if(*s=='0')
    {
        ++s;
        if(*s=='x' || *s=='X')
        {  base=16;  ++s;  }
        else if(*s=='b' || *s=='B')
        {  base=2;  ++s;  }
        else
        {  base=8;  --s;  }
    }
    
    // Read in the value. 
    static const UT max_val=~((UT)0);
    // See the signed integer version for info on the cutoff thingy. 
    UT cutoff = max_val/UT(base);
    char limit = (char)(max_val % UT(base));
    bool overflow=0;
    unsigned char consumed=0;  // max 64 for binary parsing of uint64
    register char c=*s;
    UT val=0;
    
    // There are now optimized versions for base <=10 and 16. 
    // Expect runtime savings of nearly 10% with GCC-3.4.2 (pre) on AthlonXP 
    // for uint64 (decimal/hex average) with -O2. 
    if(base==16) for(;;c=*++s)
    {
        // Using a conversion array cv[256] to map chars to values resulted 
        // in a slight performance decrease with above mentioned setup. (WW)
        if(c>='0' && c<='9')  c-='0';
        else if(c>='a' && c<='f')  c-='a'-10;
        else if(c>='A' && c<='F')  c-='A'-10;
        else break;
        if(val>cutoff || (val==cutoff && c>limit))
        {  overflow=1;  }
        else if(!overflow)
        {  val=(val<<4)|((unsigned char)c);  ++consumed;  }
    }
    else if(base<=10)
    {
        char lastchar='0'+base;
        for(;;c=*++s)
        {
            if(c>='0' && c<lastchar)  c-='0';
            else break;
            if(val>cutoff || (val==cutoff && c>limit))
            {  overflow=1;  }
            else if(!overflow)
            {  val=val*base+c;  ++consumed;  }
        }
    }
    else for(;;c=*++s)
    {
        if(c>='0' && c<='9')  c-='0';
        else if(c>='a' && c<='z')  c-='a'-10;
        else if(c>='A' && c<='Z')  c-='A'-10;
        else break;
        if(c>=base)  break;
        if(val>cutoff || (val==cutoff && c>limit))
        {  overflow=1;  }
        else if(!overflow)
        {  val=val*base+c;  ++consumed;  }
    }
    
    if(overflow)
    {
        *rv = max_val;
        TLString tmp;
        tmp.sprintf("%dbit unsigned integer overflow",sizeof(UT)*8);
        error=SError(tmp,1);
    }
    else
    {  *rv = val;  }
    
    // Parsing ended at c, see if it is end of string. 
    if(!c && !consumed)
    {
        Assert(!error);
        error=SError("expected integer missing",1);
    }
    else if(!may_continue)
    {
        TLString tmp;
        tmp.sprintf("illegal char '%c' in integer (base %d)",c,(int)base);
        if(error)  tmp.prepend(error.msg()+"; ");
        error=SError(tmp,1);
    }
    
    return((char*)(consumed ? s : str));
}


char *ParseInt(uint8 *val,const char *str,SError &error,bool may_continue)
    {  return(_ParseUInt<uint8>(val,str,error,may_continue));  }

char *ParseInt(uint16 *val,const char *str,SError &error,bool may_continue)
    {  return(_ParseUInt<uint16>(val,str,error,may_continue));  }

char *ParseInt(uint32 *val,const char *str,SError &error,bool may_continue)
    {  return(_ParseUInt<uint32>(val,str,error,may_continue));  }

char *ParseInt(uint64 *val,const char *str,SError &error,bool may_continue)
    {  return(_ParseUInt<uint64>(val,str,error,may_continue));  }



// Like that the compiler will automatically select the correct 
// function from libc. 
int _Str2FP(dbl *rv,const char *str,char **end)
    {  errno=0;  *rv=strtod(str,end);  return(errno);  }
int _Str2FP(flt *rv,const char *str,char **end)
    {  errno=0;  *rv=strtof(str,end);  return(errno);  }

// Parse flt/dbl values. 
// Basically a wrapper around the libc functions strtod() and strtof(). 
// By Wolfgang Wieser. 
template<typename F>
    char *_ParseFloat(F *val,const char *str,SError &error,bool may_continue)
{
    char *end;
    int e=_Str2FP(val,str,&end);
    if(e==ERANGE || (*end && !may_continue))
    {
        TLString tmp;
        if(*end && !may_continue)
        {  tmp.sprintf("parse error in float at '%c'",*end);  }
        if(e==ERANGE)
        {
            if(tmp)  tmp+="; ";
            tmp+="floating point value out of range";
        }
        error=SError(tmp,1);
    }
    return(end);
}

char *ParseFloat(flt *val,const char *str,SError &error,bool may_continue)
    {  return(_ParseFloat<flt>(val,str,error,may_continue));  }
char *ParseFloat(dbl *val,const char *str,SError &error,bool may_continue)
    {  return(_ParseFloat<dbl>(val,str,error,may_continue));  }


struct ParsedIntegerValue
{
    int64 val;          
    uint16 size : 8;    
    uint16 unsig : 3;   
};


int ParseIntegerSpec(const char *str,ParsedIntegerValue *si,SError &error)
{
}


char ParseCharacterSpec(const char *str,SError &error)
{
}

struct ParsedFloatValue
{
    union {
        dbl dval;   
        flt fval;   
    };
    int16 size;   
};

int ParseFloatSpec(const char *str,ParsedFloatValue *sf,SError &error)
{
    if(!str) return(0);
    
    // This is tricky as the float value may end before the end of the 
    // string. So, I parse it as dbl and then convert to flt if the 
    // f suffix is present. 
    dbl tmp;
    const char *end=ParseFloat(&tmp,str,error,/*may_continue=*/1);
    if(*end=='f' || *end=='F')
    {
        if(tmp>FLT_MAX || tmp<FLT_MIN)
        {
            error.AppendMsg("floating point value out of (flt) range");
            sf->fval = tmp>FLT_MAX ? FLT_MAX : FLT_MIN;
        }
        else
        {  sf->fval=(flt)tmp;  }
        sf->size=sizeof(flt);
        ++end;
    }
    else
    {
        sf->dval=tmp;
        sf->size=sizeof(dbl);
    }
    
    if(*end)
    {  error.AppendMsg("garbage at end of float spec");  }
    
    return(error ? 1 : 0);
}


#if 0  /* Test program */

// gcc lib_lex.a -o test -lm ../lib_misc.a ../tl/lib_tl.a ../threads/lib_threads.a -lpthread
#include <stdio.h>  /* test program */


template<typename T,typename UT>
    void TestParseInt(const char *str)
{
    T val;
    SError error;
    fprintf(stderr,"%s: ",str);
    const char *end=ParseInt(&val,str,error,0);
    fprintf(stderr," %lld; %s  (error=%s)\n",
        (long long)val,end,error ? error.msg().str() : "success");
}

template<typename UT>
    void TestParseUInt(const char *str)
{
    UT val;
    SError error;
    fprintf(stderr,"%s: ",str);
    const char *end=ParseInt(&val,str,error,0);
    fprintf(stderr," %llu; %s  (error=%s)\n",
        (unsigned long long)val,end,
        error ? error.msg().str() : "success");
}

int main(int argc,char **arg)
{
    for(int i=1; i<argc; i++)
    {
        TestParseInt<int16,uint16>(arg[i]);
        TestParseInt<int32,uint32>(arg[i]);
        TestParseInt<int64,uint64>(arg[i]);
        TestParseUInt<int16>(arg[i]);
        TestParseUInt<int32>(arg[i]);
        TestParseUInt<int64>(arg[i]);
    }
    
    /*char tmp[32];
    SError error;
    for(int i=0; i<1000; i++)
    {
        int32 val=rand();
        uint64 rval;
        
        sprintf(tmp,"0x%x",val);
        const char *end;
        for(int j=0; j<2000; j++)
        {  end=ParseInt(&rval,tmp,error,0);  }
        CritAssert(!error); CritAssert(!*end); CritAssert(val==rval);  // test app
        
        //if(val & (1<<3))  val=-val;
        
        sprintf(tmp,"%d",val);
        for(int j=0; j<2000; j++)
        {  end=ParseInt(&rval,tmp,error,0);  }
        CritAssert(!error); CritAssert(!*end); CritAssert(val==rval);  // test app
    }*/
    
    return(0);
}

#endif

---