cqlutilities.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

      if (x < PEGASUS_SINT64_MIN/16)
      {
        MessageLoaderParms mload(String("CQL.CQLUtilities.OVERFLOW"),
                                 String("Error converting string to $0.  String '$1' caused an overflow."),
                                 String("Sint64"),
                                 stringNum);
        throw CQLRuntimeException(mload);    
      }

      x = x << 4;

      // We can't overflow when we add the next digit
      Sint64 newDigit = Sint64(_CQLUtilities_hexCharToNumeric(*p++));
      if (PEGASUS_SINT64_MIN - x > -newDigit)
      {
        MessageLoaderParms mload(String("CQL.CQLUtilities.OVERFLOW"),
                                 String("Error converting string to $0.  String '$1' caused an overflow."),
                                 String("Sint64"),
                                 stringNum);
        throw CQLRuntimeException(mload);    
      }

      x = x - newDigit;
    }

    // If we found a non-hexidecimal digit, report an error
    if (*p)
    {
      MessageLoaderParms mload(String("CQL.CQLUtilities.INVALID_HEX_CHAR"),
                               String("Error converting string to $0.  Character '$1' in string '$2' is not a hexidecimal digit."),
                               String("Sint64"),
                             String(p, 1), stringNum);
      throw CQLRuntimeException(mload);    
    }

    // Return the integer to positive, if necessary, checking for an
    // overflow error
    if (!invert)
    {
      if (x == PEGASUS_SINT64_MIN)
      {
        MessageLoaderParms mload(String("CQL.CQLUtilities.OVERFLOW"),
                                 String("Error converting string to $0.  String '$1' caused an overflow."),
                                 String("Sint64"),
                                 stringNum);
        throw CQLRuntimeException(mload);    
      }
      x = -x;
    }
    
    // return value from the hex string
    PEG_METHOD_EXIT();
    return x;
  }  // end if hexidecimal     

  // if binary
  Uint32 endString = stringNum.size() - 1;
  if ( (pStart[endString] == 'b') || (pStart[endString] == 'B') )
  {
    // Add on each digit, checking for overflow errors
    while ((*p == '0') || (*p == '1'))
    {
      // Make sure we won't overflow when we multiply by 2
      if (x < PEGASUS_SINT64_MIN/2)
      {
        MessageLoaderParms mload(String("CQL.CQLUtilities.OVERFLOW"),
                                 String("Error converting string to $0.  String '$1' caused an overflow."),
                                 String("Sint64"),
                                  stringNum);
        throw CQLRuntimeException(mload);    
      }

      x = x << 1;

      // We can't overflow when we add the next digit
      Sint64 newDigit = 0;
      if (*p++ == '1')
        newDigit = 1;
      if (PEGASUS_SINT64_MIN - x > -newDigit)
      {
        MessageLoaderParms mload(String("CQL.CQLUtilities.OVERFLOW"),
                                 String("Error converting string to $0.  String '$1' caused an overflow."),
                                 String("Sint64"),
                                 stringNum);
        throw CQLRuntimeException(mload);    
      }

      x = x - newDigit;
    }

    // If we found a non-binary digit before the terminating 'b', then report an error
    if (*p && (p-pStart < (Sint32)endString || (*p != 'b' && *p != 'B')))
    {
      MessageLoaderParms mload(String("CQL.CQLUtilities.INVALID_BIN_CHAR"),
                               String("Error converting string to $0.  Character '$1' in string '$2' is not a binary digit."),
                               String("Sint64"),
                               String(p, 1), stringNum);
      throw CQLRuntimeException(mload);    
    }

    // Return the integer to positive, if necessary, checking for an
    // overflow error
    if (!invert)
    {
      if (x == PEGASUS_SINT64_MIN)
      {
        MessageLoaderParms mload(String("CQL.CQLUtilities.OVERFLOW"),
                                 String("Error converting string to $0.  String '$1' caused an overflow."),
                                 String("Sint64"),
                                 stringNum);
        throw CQLRuntimeException(mload);    
      }
      x = -x;
    }
    
    // return value from the binary string
    PEG_METHOD_EXIT();
    return x;      
  }  // end if binary

  // Expect a positive decimal digit:

  // Add on each digit, checking for overflow errors
  while ((*p >= '0') && (*p <= '9'))
  {
    // Make sure we won't overflow when we multiply by 10
    if (x < PEGASUS_SINT64_MIN/10)
    {
        MessageLoaderParms mload(String("CQL.CQLUtilities.OVERFLOW"),
                                 String("Error converting string to $0.  String '$1' caused an overflow."),
                                 String("Sint64"),
                                 stringNum);
        throw CQLRuntimeException(mload);    
    }
    x = 10 * x;

    // Make sure we won't overflow when we add the next digit
    Sint64 newDigit = (*p++ - '0');
    if (PEGASUS_SINT64_MIN - x > -newDigit)
    {
        MessageLoaderParms mload(String("CQL.CQLUtilities.OVERFLOW"),
                                 String("Error converting string to $0.  String '$1' caused an overflow."),
                                 String("Sint64"),
                                 stringNum);
        throw CQLRuntimeException(mload);    
    }

    x = x - newDigit;
  }

  // If we found a non-decimal digit, report an error
  if (*p)
  {
    MessageLoaderParms mload(String("CQL.CQLUtilities.INVALID_DECIMAL_CHAR"),
                             String("Error converting string to $0.  Character '$1' in string '$2' is not a decimal digit."),
                             String("Sint64"),
                             String(p, 1), stringNum);
    throw CQLRuntimeException(mload);    
  }

  // Return the integer to positive, if necessary, checking for an
  // overflow error
  if (!invert)
  {
    if (x == PEGASUS_SINT64_MIN)
    {
        MessageLoaderParms mload(String("CQL.CQLUtilities.OVERFLOW"),
                                 String("Error converting string to $0.  String '$1' caused an overflow."),
                                 String("Sint64"),
                                 stringNum);
        throw CQLRuntimeException(mload);    
    }
    x = -x;
  }

  // return the value for the decimal string
  PEG_METHOD_EXIT();
  return x;  
}

Real64 CQLUtilities::stringToReal64(const String &stringNum)
{
  PEG_METHOD_ENTER(TRC_CQL,"CQLUtilities::stringToReal64()");
  
  Real64 x = 0;
  const Char16* p = stringNum.getChar16Data();
  Boolean neg = false;
  const Char16* pStart = p;

  if (String::equal(stringNum, String::EMPTY))
  {
    MessageLoaderParms mload(String("CQL.CQLUtilities.EMPTY_STRING"),
                             String("Error converting string to $0.  String cannot be $1."),
                             String("Real64"), String("empty"));
    throw CQLRuntimeException(mload);    
  }
  
  if (!p)
  {
    MessageLoaderParms mload(String("CQL.CQLUtilities.EMPTY_STRING"),
                             String("Error converting string to $0.  String cannot be $1."),
                             String("Real64"), String("NULL"));
    throw CQLRuntimeException(mload);    
  }

  
  // Skip optional sign:

  if (*p == '+')
    p++;
  
  if (*p  == '-')
  {
    neg = true;
    p++;
  };
  
  // Check if it it is a binary or hex integer
  Uint32 endString = stringNum.size() - 1;
  if ((*p == '0' && (p[1] == 'x' || p[1] == 'X')) ||  // hex OR
      pStart[endString] == 'b' || pStart[endString] == 'B')  // binary
  {
    if (neg)
      x = stringToSint64(stringNum);
    else

// Check if the complier is MSVC 6, which does not support the conversion operator from Uint64 to Real64      
#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC) && (_MSC_VER < 1300)
    {
      Uint64 num = stringToUint64(stringNum);
      Sint64 half = num / 2;
      x = half;
      x += half;
      if (num % 2)  // if odd, then add the lost remainder
        x += 1;
    }
#else
      x = stringToUint64(stringNum);
#endif    
    PEG_METHOD_EXIT();
    return x;
  }  
  
  // Skip optional first set of digits:

  while ((*p >= '0') && (*p <= '9'))
    p++;

  // Test if optional dot is there
  if (*p++ == '.')
  {
    // One or more digits required:
    if (!((*p >= '0') && (*p <= '9')))
    {
      MessageLoaderParms mload(String("CQL.CQLUtilities.INVALID_CHAR_POST_DOT"),
                               String("Error converting string to Real64.  String '$0' must have a digit character following the decimal point."),
                               stringNum);
      throw CQLRuntimeException(mload);    
    }
    p++;

    while ((*p >= '0') && (*p <= '9'))
      p++;

    // If there is an exponent now:
    if (*p)
    {
      // Test exponent:

      if (*p != 'e' && *p != 'E')
      {
        MessageLoaderParms mload(String("CQL.CQLUtilities.INVALID_REAL_CHAR"),
                                 String("Error converting string to $0.  Character '$1' in string '$2` is invalid."),
                                 String("Real64"),
                                 String(p, 1), stringNum);
        throw CQLRuntimeException(mload);    
      }
      p++;

      // Skip optional sign:

      if (*p == '+' || *p  == '-')
        p++;

      // One or more digits required:
      if (!((*p >= '0') && (*p <= '9')))
      {
        MessageLoaderParms mload(String("CQL.CQLUtilities.INVALID_REAL_EXP"),
                                 String("Error converting string to Real64.  String '$0' has a badly formed exponent.  Character '$1' is invalid."),
                                 stringNum, String(p, 1));
        throw CQLRuntimeException(mload);    
      }
      p++;

      while ((*p >= '0') && (*p <= '9'))
        p++;
    }
  } // end-if optional decimal point
  if (*p && p - pStart <= (Sint32) stringNum.size())
  {
  //  printf("This is char # %d\n", p - pStart);
    MessageLoaderParms mload(String("CQL.CQLUtilities.INVALID_DECIMAL_CHAR"),
                             String("Error converting string to $0.  Character '$1' in string '$2' is not a decimal digit."),
                             String("Real64"),
                             String(p-1, 1), stringNum);
    throw CQLRuntimeException(mload);    
  }
  //
  // Do the conversion
  //
  char* end;
  errno = 0;
  CString temp = stringNum.getCString();
  x = strtod((const char *) temp, &end);
  if (*end || (errno == ERANGE))
  {
    MessageLoaderParms mload(String("CQL.CQLUtilities.CONVERSION_REAL_ERROR"),
                             String("String '$0' was unable to be converted to a Real64.  It could be out of range."),
                             stringNum);
    throw CQLRuntimeException(mload);    
  }
  PEG_METHOD_EXIT();
//  printf("String %s = %.16e\n", (const char *)stringNum.getCString(), x);
  return x;
}

String CQLUtilities::formatRealStringExponent(const String &realString)
{
  String newString(realString);
  Uint32 expIndex = PEG_NOT_FOUND;
  Uint32 index = newString.size() - 1;
  
  expIndex = newString.find('E');
  if (expIndex == PEG_NOT_FOUND)
    expIndex = newString.find('e');

  if (expIndex == PEG_NOT_FOUND)
    return newString;  // no exponent symbol, so just return

  // format the exponent
  index = expIndex + 1;  // start index at next character
  if (newString[index] == '+')
    newString.remove(index, 1);  // remove the '+' symbol

  if (newString[index] == '-')
    index++;   // skip the '-' exponent sign

  while (newString[index] == '0' && index < newString.size())
  {
    newString.remove(index, 1);
  }

  // If only an 'e' is left (only 0's behind it) then strip the 'e'
  if (index >= newString.size())
    newString.remove(expIndex, 1);

  return newString;
}

Boolean CQLUtilities::isReal(const String &numString)
{
  // If there is a decimal point, we consider it to be a real.
  if (numString.find('.') == PEG_NOT_FOUND)
    return false;
  return true;
}

PEGASUS_NAMESPACE_END