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

[Paul J. Lucas]

1. Added atoll( char const *buf, char const *end, char const **last );
2. Added more aton() functions.
3. Fixed handling of integer overflow.

1. Added atoll( char const *buf, char const *end, char const **last );
2. Added more aton() functions.
3. Fixed handling of integer overflow.

[Paul J. Lucas (paul-lucas)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/pjl-misc-2013-04-16T02-57-42.841Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~paul-lucas/zorba/pjl-misc into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job pjl-misc-2013-04-16T02-57-42.841Z is finished. The
  final status was:

  4 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/pjl-misc-2013-04-16T03-53-40.529Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job pjl-misc-2013-04-16T03-53-40.529Z 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, Needs Information < 1, Resubmit < 1. Got: 1 Approve.

[lp:~paul-lucas/zorba/pjl-misc]

11178. By Paul J. Lucas on 2013-04-16

Added test.

11179. By Paul J. Lucas on 2013-04-16

Merge from trunk.

11180. By Paul J. Lucas on 2013-04-16

Removed unnecessary #include.

[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-04-16T20-02-45.412Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job pjl-misc-2013-04-16T20-02-45.412Z is finished. The final status was:

All tests succeeded!

=== modified file 'src/unit_tests/CMakeLists.txt'
--- src/unit_tests/CMakeLists.txt	2013-03-21 00:54:36 +0000
+++ src/unit_tests/CMakeLists.txt	2013-04-16 18:41:25 +0000
@@ -14,6 +14,7 @@
 
 SET(UNIT_TEST_SRCS
   instantiate_string.cpp
+  test_ato_.cpp
   test_base64.cpp
   test_base64_streambuf.cpp
   test_hashmaps.cpp

=== added file 'src/unit_tests/test_ato_.cpp'
--- src/unit_tests/test_ato_.cpp	1970-01-01 00:00:00 +0000
+++ src/unit_tests/test_ato_.cpp	2013-04-16 18:41:25 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "stdafx.h"
+#include <iostream>
+#include <stdexcept>
+#include <string>
+
+#include "util/cxx_util.h"
+#include "util/string_util.h"
+
+using namespace std;
+using namespace zorba;
+
+///////////////////////////////////////////////////////////////////////////////
+
+static int failures;
+
+static bool assert_true( int no, char const *expr, int line, bool result ) {
+  if ( !result ) {
+    cout << '#' << no << " FAILED, line " << line << ": " << expr << endl;
+    ++failures;
+  }
+  return result;
+}
+
+static void print_exception( int no, char const *expr, int line,
+                             std::exception const &e ) {
+  assert_true( no, expr, line, false );
+  cout << "+ exception: " << e.what() << endl;
+}
+
+#define ASSERT_TRUE( NO, EXPR ) assert_true( NO, #EXPR, __LINE__, !!(EXPR) )
+
+#define ASSERT_NO_EXCEPTION( NO, EXPR ) \
+  try { EXPR; } \
+  catch ( exception const &e ) { print_exception( NO, #EXPR, __LINE__, e ); } \
+  catch ( ... ) { assert_true( NO, #EXPR, __LINE__, false ); }
+
+#define ASSERT_EXCEPTION( NO, EXPR, EXCEPTION ) \
+  try { EXPR; assert_true( NO, #EXPR, __LINE__, false ); } \
+  catch ( EXCEPTION const& ) { } \
+  catch ( ... ) { assert_true( NO, #EXPR, __LINE__, false ); }
+
+///////////////////////////////////////////////////////////////////////////////}
+
+static void test_atoll( int no, string const &s ) {
+  char const *last;
+  ASSERT_EXCEPTION(
+    no, ztd::atoll( s.data(), s.data() + s.size(), &last ), range_error
+  );
+}
+
+static void test_atoull( int no, string const &s ) {
+  char const *last;
+  ASSERT_EXCEPTION(
+    no, ztd::atoull( s.data(), s.data() + s.size(), &last ), range_error
+  );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+namespace zorba {
+namespace UnitTests {
+
+int test_ato_( int, char*[] ) {
+  ascii::itoa_buf_type buf;
+  string s;
+  int test_no = 0;
+
+  // test overflow
+  s = ascii::itoa( numeric_limits<long long>::max(), buf );
+  s += '0';
+  test_atoll( test_no++, s );
+
+  // test underflow
+  s = ascii::itoa( numeric_limits<long long>::min(), buf );
+  s += '0';
+  test_atoll( test_no++, s );
+
+  // test overflow
+  s = ascii::itoa( numeric_limits<unsigned long long>::max(), buf );
+  s += '0';
+  test_atoull( test_no++, s );
+
+  cout << failures << " test(s) failed\n";
+  return failures ? 1 : 0;
+}
+
+} // namespace UnitTests
+} // namespace zorba
+
+/* vim:set et sw=2 ts=2: */

=== modified file 'src/unit_tests/unit_test_list.h'
--- src/unit_tests/unit_test_list.h	2013-03-21 00:54:36 +0000
+++ src/unit_tests/unit_test_list.h	2013-04-16 18:41:25 +0000
@@ -28,6 +28,7 @@
 
   int runDebuggerProtocolTest(int argc, char* argv[]);
 
+  int test_ato_( int, char*[] );
   int test_base64( int, char*[] );
   int test_base64_streambuf( int, char*[] );
   int test_hashmaps( int argc, char* argv[] );

=== modified file 'src/unit_tests/unit_tests.cpp'
--- src/unit_tests/unit_tests.cpp	2013-03-21 00:54:36 +0000
+++ src/unit_tests/unit_tests.cpp	2013-04-16 18:41:25 +0000
@@ -37,6 +37,7 @@
  */
 void initializeTestList() 
 {
+  libunittests["ato"] = test_ato_;
   libunittests["base64"] = test_base64;
   libunittests["base64_streambuf"] = test_base64_streambuf;
 

=== modified file 'src/util/string_util.cpp'
--- src/util/string_util.cpp	2013-03-31 15:53:11 +0000
+++ src/util/string_util.cpp	2013-04-16 18:41:25 +0000
@@ -56,14 +56,15 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static void too_big_or_small( char const *buf, char const *last ) {
+static void throw_range_error( char const *buf, char const *last ) {
+  errno = ERANGE;
   zstring const s( buf, last );
   throw std::range_error( BUILD_STRING( '"', s, "\": number too big/small" ) );
 }
 
 inline void check_errno( char const *buf, char const *last ) {
   if ( errno == ERANGE )
-    too_big_or_small( buf, last );
+    throw_range_error( buf, last );
 }
 
 static void check_trailing_chars_impl( char const *last ) {
@@ -149,20 +150,65 @@
   return result;
 }
 
+long long atoll( char const *buf, char const *end, char const **last ) {
+  aton_context const ctx( last );
+  long long n = 0;
+  char const *s0 = ascii::trim_start_whitespace( buf, end - buf );
+  char const *s = s0;
+
+  if ( s < end ) {
+    bool minus = false;
+    switch ( *s ) {
+      case '-':
+        minus = true;
+        // no break;
+      case '+':
+        s0 = ++s;
+        break;
+    }
+    for ( ; s < end && ascii::is_digit( *s ); ++s ) {
+      long long const n_prev = n;
+      n *= 10;
+      if ( n / 10 != n_prev ) // see <http://stackoverflow.com/q/199333/99089>
+        throw_range_error( buf, end );
+      n += *s - '0';
+      if ( n < n_prev )
+        throw_range_error( buf, end );
+    }
+    if ( s == s0 )
+      s = buf;
+    else if ( minus )
+      n = -n;
+  }
+
+  *last = s;
+  check_parse_number( buf, *last, ctx.check_trailing_chars() );
+  return n;
+}
+
 unsigned long long atoull( char const *buf, char const *end,
                            char const **last ) {
   aton_context const ctx( last );
   unsigned long long n = 0;
-  char const *s = ascii::trim_start_whitespace( buf, end - buf );
+  char const *s0 = ascii::trim_start_whitespace( buf, end - buf );
+  char const *s = s0;
 
-  for ( ; s < end && ascii::is_digit( *s ); ++s ) {
-    unsigned long long const n_prev = n;
-    n = n * 10 + *s - '0';
-    if ( n < n_prev ) {
-      errno = ERANGE;
-      too_big_or_small( buf, end );
+  if ( s < end ) {
+    if ( *s == '+' )
+      s0 = ++s;
+    for ( ; s < end && ascii::is_digit( *s ); ++s ) {
+      unsigned long long const n_prev = n;
+      n *= 10;
+      if ( n / 10 != n_prev ) // see <http://stackoverflow.com/q/199333/99089>
+        throw_range_error( buf, end );
+      n += *s - '0';
+      if ( n < n_prev )
+        throw_range_error( buf, end );
     }
+    if ( s == s0 )
+      s = buf;
   }
+
   *last = s;
   check_parse_number( buf, *last, ctx.check_trailing_chars() );
   return n;

=== modified file 'src/util/string_util.h'
--- src/util/string_util.h	2013-03-26 00:25:41 +0000
+++ src/util/string_util.h	2013-04-16 18:41:25 +0000
@@ -414,13 +414,17 @@
  * Parses the given string for a \c double.
  *
  * @param buf The null-terminated C string to parse.  Leading and trailing
- * whitespace is ignored.
+ * whitespace is ignored.  After any leading whitespace, there may be a \c + or
+ * \c - sign, followed by a sequence of decimal digits optionally containing a
+ * single single \c . (decimal-point), optionally followed by an exponent
+ * consisting of an \c e or \c E followed by an optional \c + or \c - sign
+ * followed by a sequence of decimal digits.
  * @param last 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 buf contains characters other than digits or
- * leading/trailing whitespace, or contains no digits at all.
+ * @throws invalid_argument if \a buf contains characters other than as
+ * described or contains no digits at all.
  * @throws range_error if the number overflows/underflows.
  */
 double atod( char const *buf, char const **last = nullptr );
@@ -429,13 +433,17 @@
  * Parses the given string for a \c float.
  *
  * @param buf The null-terminated C string to parse.  Leading and trailing
- * whitespace is ignored.
+ * whitespace is ignored.  After any leading whitespace, there may be a \c + or
+ * \c - sign, followed by a sequence of decimal digits optionally containing a
+ * single single \c . (decimal-point), optionally followed by an exponent
+ * consisting of an \c e or \c E followed by an optional \c + or \c - sign
+ * followed by a sequence of decimal digits.
  * @param last 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 buf contains characters other than digits or
- * leading/trailing whitespace, or contains no digits at all.
+ * @throws invalid_argument if \a buf contains characters other than as
+ * described or contains no digits at all.
  * @throws range_error if the number overflows/underflows.
  */
 float atof( char const *buf, char const **last = nullptr );
@@ -444,28 +452,47 @@
  * Parses the given string for a <code>long long</code>.
  *
  * @param buf The null-terminated C string to parse.  Leading and trailing
- * whitespace is ignored.
+ * whitespace is ignored.  After any leading whitespace, there may be a \c + or
+ * \c - sign, followed by a sequence of decimal digits.
  * @param last 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 buf contains characters other than digits or
- * leading/trailing whitespace, or contains no digits at all.
+ * @throws invalid_argument if \a buf contains characters other than as
+ * described or contains no digits at all.
  * @throws range_error if the number overflows/underflows.
  */
 long long atoll( char const *buf, char const **last = nullptr );
 
 /**
+ * Parses the given string for a <code>long long</code>.
+ *
+ * @param buf The C string to parse; it need not be null-terminated.  Leading
+ * and trailing whitespace is ignored.  After any leading whitespace, there may
+ * be a \c + or \c - sign, followed by a sequence of decimal digits.
+ * @param end A pointer to one past the last character to parse.
+ * @param last 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 buf contains characters other than as
+ * described or contains no digits at all.
+ * @throws range_error if the number overflows.
+ */
+long long atoll( char const *buf, char const *end, char const **last );
+
+/**
  * Parses the given string for an <code>unsigned long long</code>.
  *
  * @param buf The null-terminated C string to parse.  Leading and trailing
- * whitespace is ignored.
+ * whitespace is ignored.  After any leading whitespace, there may be a \c +
+ * sign, followed by a sequence of decimal digits.
  * @param last 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 buf contains characters other than digits or
- * leading/trailing whitespace, or contains no digits at all.
+ * @throws invalid_argument if \a buf contains characters other than as
+ * described or contains no digits at all.
  * @throws range_error if the number overflows.
  */
 unsigned long long atoull( char const *buf, char const **last = nullptr );
@@ -474,14 +501,15 @@
  * Parses the given string for an <code>unsigned long long</code>.
  *
  * @param buf The C string to parse; it need not be null-terminated.  Leading
- * and trailing whitespace is ignored.
+ * and trailing whitespace is ignored.  After any leading whitespace, there may
+ * be a \c + sign, followed by a sequence of decimal digits.
  * @param end A pointer to one past the last character to parse.
  * @param last 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 buf contains characters other than digits or
- * leading/trailing whitespace, or contains no digits at all.
+ * @throws invalid_argument if \a buf contains characters other than as
+ * described or contains no digits at all.
  * @throws range_error if the number overflows.
  */
 unsigned long long atoull( char const *buf, char const *end,
@@ -492,117 +520,254 @@
  *
  * @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 last 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, char const **last = nullptr ) {
-  long long const result = atoll( buf, last );
-  if ( result < std::numeric_limits<IntegralType>::min() ||
-       result > std::numeric_limits<IntegralType>::max() )
-    throw std::range_error(
-      BUILD_STRING( '"', result, "\": number too big/small" )
-    );
-  return static_cast<IntegralType>( result );
-}
-
-/**
- * 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 last 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 **last = nullptr ) {
-  long long const result = atoll( buf, last );
-  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 buf The null-terminated C string to parse.  Leading and trailing
- * whitespace is ignored.
- * @param last 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
-typename std::enable_if<ZORBA_TR1_NS::is_unsigned<IntegralType>::value,
-                        IntegralType>::type
-aton( char const *buf, char const **last = nullptr ) {
-  unsigned long long const result = atoull( buf, last );
-  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 last 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 **last = nullptr ) {
-  unsigned long long const result = atoull( buf, last );
+ * whitespace is ignored.  After any leading whitespace, there may be a \c + or
+ * \c - sign, followed by a sequence of decimal digits.
+ * @param last 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 as
+ * described 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, char const **last = nullptr ) {
+  long long const result = atoll( buf, last );
+  if ( result < std::numeric_limits<IntegralType>::min() ||
+       result > std::numeric_limits<IntegralType>::max() )
+    throw std::range_error(
+      BUILD_STRING( '"', result, "\": number too big/small" )
+    );
+  return static_cast<IntegralType>( result );
+}
+
+/**
+ * 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.  After any leading whitespace, there may be a \c + or
+ * \c - sign, followed by a sequence of decimal digits.
+ * @param low The lower acceptable bound.
+ * @param high the higher acceptable bound.
+ * @param last 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 as
+ * described 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 **last = nullptr ) {
+  long long const result = atoll( buf, last );
+  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++ signed integral type.
+ *
+ * @tparam IntegralType The C++ signed integral type to parse for.
+ * @param buf The C string to parse; it need not be null-terminated.  Leading
+ * and trailing whitespace is ignored.  After any leading whitespace, there may
+ * be a \c + or \c - sign, followed by a sequence of decimal digits.
+ * @param end A pointer to one past the last character to parse.
+ * @param last 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 as
+ * described 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, char const *end, char const **last = nullptr ) {
+  long long const result = atoll( buf, end, last );
+  if ( result < std::numeric_limits<IntegralType>::min() ||
+       result > std::numeric_limits<IntegralType>::max() )
+    throw std::range_error(
+      BUILD_STRING( '"', result, "\": number too big/small" )
+    );
+  return static_cast<IntegralType>( result );
+}
+
+/**
+ * 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.  After any leading whitespace, there may be a \c + or
+ * \c - sign, followed by a sequence of decimal digits.
+ * @param end A pointer to one past the last character to parse.
+ * @param low The lower acceptable bound.
+ * @param high the higher acceptable bound.
+ * @param last 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 as
+ * described 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, char const *end, IntegralType low, IntegralType high,
+      char const **last = nullptr ) {
+  long long const result = atoll( buf, end, last );
+  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 buf The null-terminated C string to parse.  Leading and trailing
+ * whitespace is ignored.  After any leading whitespace, there may be a \c +
+ * sign, followed by a sequence of decimal digits.
+ * @param last 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 as
+ * described 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, char const **last = nullptr ) {
+  unsigned long long const result = atoull( buf, last );
+  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.  After any leading whitespace, there may be a \c +
+ * sign, followed by a sequence of decimal digits.
+ * @param low The lower acceptable bound.
+ * @param high the higher acceptable bound.
+ * @param last 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 as
+ * described 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 **last = nullptr ) {
+  unsigned long long const result = atoull( buf, last );
+  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 buf The C string to parse; it need not be null-terminated.  Leading
+ * and trailing whitespace is ignored.  After any leading whitespace, there may
+ * be a \c + sign, followed by a sequence of decimal digits.
+ * @param end A pointer to one past the last character to parse.
+ * @param last 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 as
+ * described 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, char const *end, char const **last = nullptr ) {
+  unsigned long long const result = atoull( buf, end, last );
+  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 C string to parse; it need not be null-terminated.  Leading
+ * and trailing whitespace is ignored.  After any leading whitespace, there may
+ * be a \c + sign, followed by a sequence of decimal digits.
+ * @param end A pointer to one past the last character to parse.
+ * @param low The lower acceptable bound.
+ * @param high the higher acceptable bound.
+ * @param last 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 as
+ * described 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, char const *end, IntegralType low, IntegralType high,
+      char const **last = nullptr ) {
+  unsigned long long const result = atoull( buf, end, last );
   if ( result < low || result > high )
     throw std::range_error(
       BUILD_STRING(
@@ -616,14 +781,17 @@
  * Parses the given string for a C++ \c double type.
  *
  * @param buf The null-terminated C string to parse.  Leading and trailing
- * whitespace is ignored.
+ * whitespace is ignored.  After any leading whitespace, there may be a \c + or
+ * \c - sign, followed by a sequence of decimal digits optionally containing a
+ * single single \c . (decimal-point), optionally followed by an exponent
+ * consisting of an \c e or \c E followed by an optional \c + or \c - sign
+ * followed by a sequence of decimal digits.
  * @param last 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 buf 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 as
+ * described or contains no digits at all.
  * @throws range_error if the number overflows/underflows.
  */
 template<typename NumericType> inline
@@ -637,14 +805,17 @@
  * Parses the given string for a C++ \c float type.
  *
  * @param buf The null-terminated C string to parse.  Leading and trailing
- * whitespace is ignored.
+ * whitespace is ignored.  After any leading whitespace, there may be a \c + or
+ * \c - sign, followed by a sequence of decimal digits optionally containing a
+ * single single \c . (decimal-point), optionally followed by an exponent
+ * consisting of an \c e or \c E followed by an optional \c + or \c - sign
+ * followed by a sequence of decimal digits.
  * @param last 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 buf contains characters other than those for
- * a valid \c float value or leading/trailing whitespace, or contains no digits
- * at all.
+ * @throws invalid_argument if \a buf contains characters other than as
+ * described or contains no digits at all.
  * @throws range_error if the number overflows/underflows.
  */
 template<typename NumericType> inline