/ray/src/lib/lex/fastval2str.cc

Go to the documentation of this file.

/*
 * lib/lex/fastval2str.cc
 * 
 * Fast integer / floating point string writing 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 "fastval2str.h"
#include <lib/numerics/num_math.h>


// These are the hex chars. I added 4 more to be on the safe side for 
// strange things which are not supposed to happen...
static const char *_hexdig="YZ0123456789abcdefGH";
static const char *hexdig=_hexdig+2;


// Used to format integer into string. 
// Only base values 8, 10 and 16 are supported; base 8 gets 0 prefix and 
// base 16 gets 0x prefix. 
// Special value 0 is base 16 without prefix. 
template<typename T>static char *_UInt2String(char *dest,T val,char base)
{
    // These are optimized version for each supported base. 
    switch(base)
    {
        case 8:
        {
            *dest++='0';
            if(!val)  break;
            // Make sure shift is dividable by 3. 
            int shift = 
                (sizeof(T)*8)%3==0 ? (sizeof(T)*8) : 
                (sizeof(T)*8+1)%3==0 ? (sizeof(T)*8+1) : (sizeof(T)*8+2);
            Assert(!(shift%3));
            while(shift)
            {
                shift-=3;
                uchar c=(uchar)((val>>shift)&7U);  
                if(c)
                {  *dest++=(char)c+'0';  break;  }
            }
            while(shift)
            {
                shift-=3;
                *dest++=(char)((val>>shift)&0x7U)+'0';
            }
        }   break;
        case 10:
        {
            if(!val)
            {  *dest++='0';  break;  }
            static const T div0 = 
                sizeof(T)==1 ? (T)100U : 
                sizeof(T)==2 ? (T)10000U : 
                sizeof(T)==4 ? (T)1000000000LU : 
                               (T)10000000000000000000LLU;
            T div=div0;
            uchar c;
            while(div)
            {
                c=(uchar)(val/div);
                if(c)  goto start;
                div/=10;
            }
            while(div)
            {
                c=(uchar)(val/div);
                start:
                *dest++=(char)c+'0';
                val-=c*div;
                div/=10;
            }
        }   break;
        case 16:
            *dest++='0';
            *dest++='x';
            // Fall through
        case 0:  // <-- special case: base 0 is base 16 without prefix
        {
            if(!val)
            {  *dest++='0';  break;  }
            int shift=sizeof(T)*8;
            while(shift)
            {
                shift-=4;
                uchar c=(uchar)((val>>shift)&0xfU);  
                if(c)
                {  *dest++=hexdig[c];  break;  }
            }
            while(shift)
            {
                shift-=4;
                *dest++=hexdig[(val>>shift)&0xfU];
            }
        }   break;
        default: Assert(0);
    }
    
    return(dest);
}

// Generate the exported instantiations. 
char *FastInt2String(char *dest,uint8 val,char base)
    {  return(_UInt2String<uint8>(dest,val,base));  }
char *FastInt2String(char *dest,uint16 val,char base)
    {  return(_UInt2String<uint16>(dest,val,base));  }
char *FastInt2String(char *dest,uint32 val,char base)
    {  return(_UInt2String<uint32>(dest,val,base));  }
char *FastInt2String(char *dest,uint64 val,char base)
    {  return(_UInt2String<uint64>(dest,val,base));  }


template<typename T,typename UT>static inline char *_SInt2String(
    char *dest,T val,char base)
{
    UT uval;
    
    if(val<0)
    {  *dest++='-';  uval=(UT)(-val);  }
    else
    {  uval=(UT)val;  }
    
    return(_UInt2String<UT>(dest,uval,base));
}

// Generate the exported instantiations. 
char *FastInt2String(char *dest,int8 val,char base)
    {  return(_SInt2String<int8,uint8>(dest,val,base));  }
char *FastInt2String(char *dest,int16 val,char base)
    {  return(_SInt2String<int16,uint16>(dest,val,base));  }
char *FastInt2String(char *dest,int32 val,char base)
    {  return(_SInt2String<int32,uint32>(dest,val,base));  }
char *FastInt2String(char *dest,int64 val,char base)
    {  return(_SInt2String<int64,uint64>(dest,val,base));  }


template<typename T>static char *_Float2String(char *dest,T val)
{
    if(val==0)
    {  *dest++='0';  }
    
    if(val<0)
    {  *dest++='-';  val=-val;  }
    *dest++='0';
    *dest++='x';
    *dest++='.';
    
    int exp=0;
    val=NUM::frexp(val,&exp);
    
    // This worls well for IEEE-754, IEEE-854. 
    // IEEE FP numbers: double: m=52 bits (13 hexdig), exp=11 bits (3 hexdig)
    // IEEE FP numbers: float:  m=23 bits (6 hexdig), exp=8 bits (2 hexdig)
    // The m_digs values have been verified to catch exactly the whole 
    // IEEE precision. Following digits are all 0. 
    static const int m_digs = 
        sizeof(T)==8 ? 13 : 
        sizeof(T)==4 ? 6 : 0;
    
    // This has been verified to work correctly with IEEE FP numbers. 
    for(int i=0; i<m_digs; i++)
    {
        val*=16.0;
        int iv=(int)val;
        *dest++=hexdig[iv];
        val-=(T)iv;
        if(val==0.0)  break;  // <-- Avoid trailing zeros. 
    }
    // Remove trailing zeros: 
    //while(*--dest=='0');
    //if(*++dest=='.')  ++dest;
    
    *dest++='p';
    
    dest=_SInt2String<int,uint>(dest,exp,10);
    
    return(dest);
}

char *FastFloat2String(char *dest,flt val)
    {  return(_Float2String<flt>(dest,val));  }
char *FastFloat2String(char *dest,dbl val)
    {  return(_Float2String<dbl>(dest,val));  }


#if 0   /* test program */
// gcc fastval2str.o -o test -lm && ./test

#include <stdio.h>

int main()
{
    char tmp[256];
    
    char *s=tmp;
    //s=FastInt2String(s,18446744073709551615LLU,16);
    //s=FastInt2String(s,(uint8)0xf,8);
    //s=FastFloat2String(s,0x.edcba987654321p-77);
    //s=FastFloat2String(s,0.1f);
    s=FastFloat2String(s,0x.81201p0);
    *s='\0';
    
    fprintf(stderr,"out=<%s>\n",tmp);
    
    return(0);
}
#endif

---