Set atom to a numeric data type and value if the supplied string amounts to a numberic value, i.e. is of the form [sign] digits [[.] digits] [[e][sign]digits]

Declared in file: hzDatabase.h
Defined in file : hzAtom.cpp

Function Logic:

Function body:

hzEcode hzAtom::SetNumber (const char* s)
{
   //  Set atom to a numeric data type and value if the supplied string amounts to a numberic value, i.e. is of the form
   //  [sign] digits [[.] digits] [[e][sign]digits]
   //  
   //  Arguments: 1) s The supplied string.
   //  
   //  Returns: E_NOINIT If the anticipated data type is not specified.
   //     E_BADVALUE If the supplied string does not represent a valid value for the anticipated data type.
   //     E_OK  If the operation was successful.
   _hzfunc("hzAtom::SetNumber") ;
   const char* i ;                 //  Iterator
   uint64_t    valA ;              //  For digits past the decimal point
   double      valD ;              //  For double value
   uint32_t    valB ;              //  For digits past the decimal point
   uint32_t    valE ;              //  For digits past the exponent
   uint32_t    nDigits = 0;        //  Digit counter
   int32_t     nBytes = 0;     //  Byte count
   bool        bNeg = false ;      //  Minus operator indicator
   Clear() ;
   i = s ;
   if (!i)
       return E_NODATA ;
   //  Deal with leading sign
   if (*i == CHAR_MINUS)
       { bNeg = true ; i++ ; }
   else if (*i == CHAR_PLUS)
       i++ ;
   else if (i[0]== ''0''&&(i[1]== ''x''||i[1]== ''X''))
   {
       //  Whole token must be hex and limited to 16 bytes - otherwise fail.
       for (i += 2; IsHex(*i) ; nBytes++, i++)
       {
           valA *= 16;
           if (*i >&eq; ''0''&&*i <&eq; ''9''){valA += (*i - ''0'');continue ; }
           if (*i >&eq; ''A''&&*i <&eq; ''F''){valA += 10;valA += (*i - ''A'');continue ; }
           if (*i >&eq; ''a''&&*i <&eq; ''f''){valA += 10;valA += (*i - ''a'');continue ; }
           break ;
       }
       if (*i)
           { m_eType = BASETYPE_UNDEF ; return E_FORMAT ; }
       if (!nBytes || nBytes > 16)
           { m_eType = BASETYPE_UNDEF ; return E_FORMAT ; }
       if      (nBytes > 8){ m_eType = BASETYPE_UINT64 ; m_Data.m_uInt64 = valA ; }
       else if (nBytes > 4){ m_eType = BASETYPE_UINT32 ; m_Data.m_uInt32 = valA & 0xffffffff;}
       else if (nBytes > 2){ m_eType = BASETYPE_UINT16 ; m_Data.m_uInt16 = valA & 0xffff;}
       else
           { m_eType = BASETYPE_UBYTE ; m_Data.m_uByte = valA & 0xff;}
       return E_OK ;
   }
   //  Expect a series of at least one digit
   for (nDigits = 0; IsDigit(*i) ; nBytes++, nDigits++, i++)
   {
       valA *= 10;
       if (*i >&eq; ''0''&&*i <&eq; ''9'')
           { valA += (*i - ''0'');continue ; }
       break ;
   }
   if (!nDigits)
       return BASETYPE_UNDEF ;
   //  Test for a period that is followed by at least one digit
   if (*i == CHAR_PERIOD)
   {
       i++ ;
       for (nDigits = 0; IsDigit(*i) ; nBytes++, nDigits++, i++)
       {
           valD *= 10.0;
           if (*i >&eq; ''0''&&*i <&eq; ''9'')
               { valB += (*i - ''0'');continue ; }
           break ;
       }
       if (!nDigits)
           return BASETYPE_UNDEF ;
       for (; nBytes ; nBytes--)
           valD /= 10.0;
       valD += (double) valA ;
       //  Test for the 'e' followed by at least one digit or a +/- followed by at least one digit
       if (*i == ''e'')
       {
           i++ ;
           if (*i == CHAR_MINUS || *i == CHAR_PLUS)
               { nBytes++ ; i++ ; }
           for (nDigits = 0; IsDigit(*i) ; nBytes++, nDigits++, i++)
           {
               valE *= 10;
               if (*i >&eq; ''0''&&*i <&eq; ''9'')
                   { valE += (*i - ''0'');continue ; }
               break ;
           }
           if (!nDigits)
               return BASETYPE_UNDEF ;
       }
       m_Data.m_Double = valD ;
       m_eType = BASETYPE_DOUBLE ;
       return E_OK ;
   }
   //  Not a double
   if (nDigits > 8)
   {
       if (bNeg)
           { m_Data.m_sInt64 = valA ; m_eType = BASETYPE_INT64 ; }
       else
           { m_Data.m_uInt64 = valA ; m_eType = BASETYPE_UINT64 ; }
   }
   else if (nDigits > 4)
   {
       if (bNeg)
           { m_Data.m_sInt32 = valA ; m_eType = BASETYPE_INT32 ; }
       else
           { m_Data.m_uInt32 = valA ; m_eType = BASETYPE_UINT32 ; }
   }
   else if (nDigits > 2)
   {
       if (bNeg)
           { m_Data.m_sInt16 = valA ; m_eType = BASETYPE_INT16 ; }
       else
           { m_Data.m_uInt16 = valA ; m_eType = BASETYPE_UINT16 ; }
   }
   else
   {
       if (bNeg)
           { m_Data.m_sByte = valA ; m_eType = BASETYPE_BYTE ; }
       else
           { m_Data.m_uByte = valA ; m_eType = BASETYPE_UBYTE ; }
   }
   m_eStatus = ATOM_SET ;
   return E_OK ;
}