Merge lp:~paul-lucas/zorba/pjl-misc into lp:zorba

[Paul J. Lucas]

aton() enhancement.

aton() enhancement.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/pjl-misc-2013-01-10T23-45-42.555Z/log.html

[Paul J. Lucas (paul-lucas)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue job pjl-misc-2013-01-10T23-45-42.555Z is finished. The final status was:

All tests succeeded!

[Zorba Build Bot (zorba-buildbot)]

Voting does not meet specified criteria. Required: Approve > 1, Disapprove < 1, Needs Fixing < 1, Pending < 1. Got: 1 Approve.

[Matthias Brantner (matthias-brantner)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/pjl-misc-2013-01-11T00-34-37.392Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job pjl-misc-2013-01-11T00-34-37.392Z is finished. The final status was:

All tests succeeded!

=== modified file 'src/util/string_util.cpp'
--- src/util/string_util.cpp	2013-01-07 14:49:20 +0000
+++ src/util/string_util.cpp	2013-01-10 23:41:23 +0000
@@ -21,6 +21,7 @@
 #include "ascii_util.h"
 #include "cxx_util.h"
 #include "string_util.h"
+#include "zorbatypes/zstring.h"
 
 #ifdef WIN32
 namespace std {
@@ -55,67 +56,73 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#define ENABLE_CLIPPING 0
-
-template<typename T>
-static void check_parse_number( char const *s, char *end,  T *result ) {
+static void check_errno( char const *buf, char const *end ) {
   if ( errno == ERANGE ) {
-    if ( result ) {
-#if ENABLE_CLIPPING
-      if ( *ascii::trim_start_whitespace( s ) == '-' )
-        *result = numeric_limits<T>::min();
-      else
-        *result = numeric_limits<T>::max();
-#endif /* ENABLE_CLIPPING */
-    } else
-      throw std::range_error(
-        BUILD_STRING( '"', s, "\": number too big/small" )
-      );
+    zstring const s( buf, end );
+    throw std::range_error(
+      BUILD_STRING( '"', s, "\": number too big/small" )
+    );
   }
-  if ( end == s )
-    throw std::invalid_argument( BUILD_STRING( '"', s, "\": no digits" ) );
-  for ( ; *end; ++end )                 // remaining characters, if any, ...
-    if ( !ascii::is_space( *end ) )     // ... may only be whitespace
-      throw std::invalid_argument(
-        BUILD_STRING( '"', *end, "\": invalid character" )
-      );
-}
-
-double atod( char const *s ) {
-  char *end;
-  errno = 0;
-  double result = std::strtod( s, &end );
-  check_parse_number( s, end, &result );
-  return result;
-}
-
-float atof( char const *s ) {
-  char *end;
-  errno = 0;
-  float result = std::strtof( s, &end );
-  check_parse_number( s, end, &result );
-  return result;
-}
-
-long long atoll( char const *s ) {
-  char *end;
-  errno = 0;
-  long long const result = std::strtoll( s, &end, 10 );
-  check_parse_number( s, end, static_cast<long long*>( nullptr ) );
-  return result;
-}
-
-unsigned long long atoull( char const *s ) {
+}
+
+static void check_parse_number( char const *buf, char const *end,
+                                bool check_trailing_chars ) {
+  if ( end == buf )
+    throw std::invalid_argument( BUILD_STRING( '"', buf, "\": no digits" ) );
+  if ( check_trailing_chars )
+    for ( ; *end; ++end )               // remaining characters, if any, ...
+      if ( !ascii::is_space( *end ) )   // ... may only be whitespace
+        throw std::invalid_argument(
+          BUILD_STRING( '"', *end, "\": invalid character" )
+        );
+}
+
+#define ATON_PREAMBLE()           \
+  bool check_trailing_chars;      \
+  char const *pc;                 \
+  if ( end ) {                    \
+    check_trailing_chars = false; \
+  } else {                        \
+    end = &pc;                    \
+    check_trailing_chars = true;  \
+  }                               \
+  errno = 0
+
+///////////////////////////////////////////////////////////////////////////////
+
+double atod( char const *buf, char const **end ) {
+  ATON_PREAMBLE();
+  double const result = std::strtod( buf, (char**)end );
+  check_parse_number( buf, *end, check_trailing_chars );
+  return result;
+}
+
+float atof( char const *buf, char const **end ) {
+  ATON_PREAMBLE();
+  float const result = std::strtof( buf, (char**)end );
+  check_parse_number( buf, *end, check_trailing_chars );
+  return result;
+}
+
+long long atoll( char const *buf, char const **end ) {
+  ATON_PREAMBLE();
+  long long const result = std::strtoll( buf, (char**)end, 10 );
+  check_errno( buf, *end );
+  check_parse_number( buf, *end, check_trailing_chars );
+  return result;
+}
+
+unsigned long long atoull( char const *buf, char const **end ) {
+  ATON_PREAMBLE();
   //
   // We have to check for '-' ourselves since strtoull(3) allows it (oddly).
   //
-  s = ascii::trim_start_whitespace( s );
-  bool const minus = *s == '-';
+  buf = ascii::trim_start_whitespace( buf );
+  bool const minus = *buf == '-';
 
-  char *end;
-  errno = 0;
-  unsigned long long const result = std::strtoull( s, &end, 10 );
-  check_parse_number( s, end, static_cast<unsigned long long*>( nullptr ) );
+  unsigned long long const result = std::strtoull( buf, (char**)end, 10 );
+  check_errno( buf, *end );
+  check_parse_number( buf, *end, check_trailing_chars );
 
   if ( minus && result ) {
     //
@@ -123,7 +130,7 @@
     // Hence, this allows "-0" and treats it as "0".
     //
     throw std::invalid_argument(
-      "\"-\": invalid character for unsigned integer"
+      "'-': invalid character for unsigned integer"
     );
   }
   return result;

=== modified file 'src/util/string_util.h'
--- src/util/string_util.h	2013-01-07 14:49:20 +0000
+++ src/util/string_util.h	2013-01-10 23:41:23 +0000
@@ -408,61 +408,76 @@
 /**
  * Parses the given string for a \c double.
  *
- * @param s The null-terminated C string to parse.  Leading and trailing
+ * @param buf The null-terminated C string to parse.  Leading and trailing
  * whitespace is ignored.
+ * @param end If not \c null, this is set to point to the character after the
+ * last numeric character parsed; if \c null, characters past the last numeric
+ * character may only be whitespace.
  * @return Returns the \c double value.
- * @throws invalid_argument if \a s contains characters other than digits or
+ * @throws invalid_argument if \a buf contains characters other than digits or
  * leading/trailing whitespace, or contains no digits at all.
  * @throws range_error if the number overflows/underflows.
  */
-double atod( char const *s );
+double atod( char const *buf, char const **end = nullptr );
 
 /**
  * Parses the given string for a \c float.
  *
- * @param s The null-terminated C string to parse.  Leading and trailing
+ * @param buf The null-terminated C string to parse.  Leading and trailing
  * whitespace is ignored.
+ * @param end If not \c null, this is set to point to the character after the
+ * last numeric character parsed; if \c null, characters past the last numeric
+ * character may only be whitespace.
  * @return Returns the \c float value.
- * @throws invalid_argument if \a s contains characters other than digits or
+ * @throws invalid_argument if \a buf contains characters other than digits or
  * leading/trailing whitespace, or contains no digits at all.
  * @throws range_error if the number overflows/underflows.
  */
-float atof( char const *s );
+float atof( char const *buf, char const **end = nullptr );
 
 /**
  * Parses the given string for a <code>long lomg</code>.
  *
- * @param s The null-terminated C string to parse.  Leading and trailing
+ * @param buf The null-terminated C string to parse.  Leading and trailing
  * whitespace is ignored.
+ * @param end If not \c null, this is set to point to the character after the
+ * last numeric character parsed; if \c null, characters past the last numeric
+ * character may only be whitespace.
  * @return Returns the <code>long long</code> value.
- * @throws invalid_argument if \a s contains characters other than digits or
+ * @throws invalid_argument if \a buf contains characters other than digits or
  * leading/trailing whitespace, or contains no digits at all.
  * @throws range_error if the number overflows/underflows.
  */
-long long atoll( char const *s );
+long long atoll( char const *buf, char const **end = nullptr );
 
 /**
  * Parses the given string for an <code>unsigned long lomg</code>.
  *
- * @param s The null-terminated C string to parse.  Leading and trailing
+ * @param buf The null-terminated C string to parse.  Leading and trailing
  * whitespace is ignored.
+ * @param end If not \c null, this is set to point to the character after the
+ * last numeric character parsed; if \c null, characters past the last numeric
+ * character may only be whitespace.
  * @return Returns the <code>unsigned long long</code> value.
- * @throws invalid_argument if \a s contains characters other than digits or
+ * @throws invalid_argument if \a buf contains characters other than digits or
  * leading/trailing whitespace, or contains no digits at all.
  * @throws range_error if the number overflows/underflows.
  */
-unsigned long long atoull( char const *s );
+unsigned long long atoull( char const *buf, char const **end = nullptr );
 
 /**
  * Parses the given string for a C++ signed integral type.
  *
  * @tparam IntegralType The C++ signed integral type to parse for.
- * @param s The null-terminated C string to parse.  Leading and trailing
+ * @param buf The null-terminated C string to parse.  Leading and trailing
  * whitespace is ignored.
+ * @param end If not \c null, this is set to point to the character after the
+ * last numeric character parsed; if \c null, characters past the last numeric
+ * character may only be whitespace.
  * @return Returns the \c IntegralType value.
- * @throws invalid_argument if \a s contains characters other than digits or
- * leading/trailing whitespace, or contains no digits at all.
- * @throws range_error if the number overflows/underflows.
+ * @throws invalid_argument if \a buf contains characters other than digits, a
+ * sign, or leading/trailing whitespace, or contains no digits at all.
+ * @throws range_error if the number is either too small or too big.
  */
 template<typename IntegralType> inline
 //
@@ -473,8 +488,8 @@
 typename std::enable_if<ZORBA_TR1_NS::is_integral<IntegralType>::value
                      && ZORBA_TR1_NS::is_signed<IntegralType>::value,
                         IntegralType>::type
-aton( char const *s ) {
-  long long const result = atoll( s );
+aton( char const *buf, char const **end = nullptr ) {
+  long long const result = atoll( buf, end );
   if ( result < std::numeric_limits<IntegralType>::min() ||
        result > std::numeric_limits<IntegralType>::max() )
     throw std::range_error(
@@ -484,60 +499,137 @@
 }
 
 /**
+ * Parses the given string for a C++ signed integral type.
+ *
+ * @tparam IntegralType The C++ signed integral type to parse for.
+ * @param buf The null-terminated C string to parse.  Leading and trailing
+ * whitespace is ignored.
+ * @param low The lower acceptable bound.
+ * @param high the higher acceptable bound.
+ * @param end If not \c null, this is set to point to the character after the
+ * last numeric character parsed; if \c null, characters past the last numeric
+ * character may only be whitespace.
+ * @return Returns the \c IntegralType value.
+ * @throws invalid_argument if \a buf contains characters other than digits, a
+ * sign, or leading/trailing whitespace, or contains no digits at all.
+ * @throws range_error if the number is either too small or too big.
+ */
+template<typename IntegralType> inline
+//
+// Note that the is_integral shouldn't be needed since is_signed means "is a
+// signed integral type", but Microsoft's implementation is broken and returns
+// true for floating point types as well.
+//
+typename std::enable_if<ZORBA_TR1_NS::is_integral<IntegralType>::value
+                     && ZORBA_TR1_NS::is_signed<IntegralType>::value,
+                        IntegralType>::type
+aton( char const *buf, IntegralType low, IntegralType high,
+      char const **end = nullptr ) {
+  long long const result = atoll( buf, end );
+  if ( result < low || result > high )
+    throw std::range_error(
+      BUILD_STRING(
+        '"', result, "\": number not in range ", low, '-', high
+      )
+    );
+  return static_cast<IntegralType>( result );
+}
+
+/**
  * Parses the given string for a C++ unsigned integral types.
  *
  * @tparam IntegralType The C++ unsigned integral type to parse for.
- * @param s The null-terminated C string to parse.  Leading and trailing
+ * @param buf The null-terminated C string to parse.  Leading and trailing
  * whitespace is ignored.
+ * @param end If not \c null, this is set to point to the character after the
+ * last numeric character parsed; if \c null, characters past the last numeric
+ * character may only be whitespace.
  * @return Returns the \c IntegralType value.
- * @throws invalid_argument if \a s contains characters other than digits or
- * leading/trailing whitespace, or contains no digits at all.
- * @throws range_error if the number overflows/underflows.
+ * @throws invalid_argument if \a buf contains characters other than digits, a
+ * sign, or leading/trailing whitespace, or contains no digits at all.
+ * @throws range_error if the number is either too small or too big.
  */
 template<typename IntegralType> inline
 typename std::enable_if<ZORBA_TR1_NS::is_unsigned<IntegralType>::value,
                         IntegralType>::type
-aton( char const *s ) {
-  unsigned long long const result = atoull( s );
+aton( char const *buf, char const **end = nullptr ) {
+  unsigned long long const result = atoull( buf, end );
   if ( result > std::numeric_limits<IntegralType>::max() )
     throw std::range_error( BUILD_STRING( '"', result, "\": number too big" ) );
   return static_cast<IntegralType>( result );
 }
 
 /**
+ * Parses the given string for a C++ unsigned integral types.
+ *
+ * @tparam IntegralType The C++ unsigned integral type to parse for.
+ * @param buf The null-terminated C string to parse.  Leading and trailing
+ * whitespace is ignored.
+ * @param low The lower acceptable bound.
+ * @param high the higher acceptable bound.
+ * @param end If not \c null, this is set to point to the character after the
+ * last numeric character parsed; if \c null, characters past the last numeric
+ * character may only be whitespace.
+ * @return Returns the \c IntegralType value.
+ * @throws invalid_argument if \a buf contains characters other than digits or
+ * leading/trailing whitespace, or contains no digits at all.
+ * @throws range_error if the number is either too small or too big.
+ */
+template<typename IntegralType> inline
+typename std::enable_if<ZORBA_TR1_NS::is_unsigned<IntegralType>::value,
+                        IntegralType>::type
+aton( char const *buf, IntegralType low, IntegralType high,
+      char const **end = nullptr ) {
+  unsigned long long const result = atoull( buf, end );
+  if ( result < low || result > high )
+    throw std::range_error(
+      BUILD_STRING(
+        '"', result, "\": number not in range ", low, '-', high
+      )
+    );
+  return static_cast<IntegralType>( result );
+}
+
+/**
  * Parses the given string for a C++ \c double type.
  *
- * @param s The null-terminated C string to parse.  Leading and trailing
+ * @param buf The null-terminated C string to parse.  Leading and trailing
  * whitespace is ignored.
+ * @param end If not \c null, this is set to point to the character after the
+ * last numeric character parsed; if \c null, characters past the last numeric
+ * character may only be whitespace.
  * @return Returns the \c double value.
- * @throws invalid_argument if \a s contains characters other than those for a
- * valid \c double value or leading/trailing whitespace, or contains no digits
- * at all.
+ * @throws invalid_argument if \a buf contains characters other than those for
+ * a valid \c double value or leading/trailing whitespace, or contains no
+ * digits at all.
  * @throws range_error if the number overflows/underflows.
  */
 template<typename NumericType> inline
 typename std::enable_if<ZORBA_TR1_NS::is_same<NumericType,double>::value,
                         NumericType>::type
-aton( char const *s ) {
-  return atod( s );
+aton( char const *buf, char const **end = nullptr ) {
+  return atod( buf, end );
 }
 
 /**
  * Parses the given string for a C++ \c float type.
  *
- * @param s The null-terminated C string to parse.  Leading and trailing
+ * @param buf The null-terminated C string to parse.  Leading and trailing
  * whitespace is ignored.
+ * @param end If not \c null, this is set to point to the character after the
+ * last numeric character parsed; if \c null, characters past the last numeric
+ * character may only be whitespace.
  * @return Returns the \c float value.
- * @throws invalid_argument if \a s contains characters other than those for a
- * valid \c float value or leading/trailing whitespace, or contains no digits
+ * @throws invalid_argument if \a buf contains characters other than those for
+ * a valid \c float value or leading/trailing whitespace, or contains no digits
  * at all.
  * @throws range_error if the number overflows/underflows.
  */
 template<typename NumericType> inline
 typename std::enable_if<ZORBA_TR1_NS::is_same<NumericType,float>::value,
                         NumericType>::type
-aton( char const *s ) {
-  return atof( s );
+aton( char const *buf, char const **end = nullptr ) {
+  return atof( buf, end );
 }
 
 ////////// To-string conversion ////////////////////////////////////////////////