EDK: Add functions for converting between strings and numbers.

mojo/edk/util/string_number_conversions.cc

+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "mojo/edk/util/string_number_conversions.h"
+
+#include <assert.h>
+#include <stdint.h>
+
+#include <limits>
+#include <type_traits>
+
+namespace mojo {
+namespace util {
+namespace {
+
+// Helper for |StringToNumberWithError()|. Note that this may modify |*number|
+// even on failure.
+template <typename NumberType>
+bool StringToPositiveNumberWithError(const char* s,
+                                     size_t length,
+                                     NumberType* number) {
+  constexpr NumberType kBase = static_cast<NumberType>(10);
+  constexpr NumberType kMaxAllowed = std::numeric_limits<NumberType>::max();
+
+  assert(s);
+  assert(length > 0u);
+  assert(number);
+
+  *number = 0;
+  for (size_t i = 0; i < length; i++) {
+    if (s[i] < '0' || s[i] > '9')
+      return false;
+    NumberType new_digit = static_cast<NumberType>(s[i] - '0');
+    // This is really a check of "*number * kBase + new_digit > kMaxAllowed":
+    if (*number > kMaxAllowed / kBase ||
+        (*number == kMaxAllowed / kBase && new_digit > kMaxAllowed % kBase))
+      return false;
+    *number = *number * kBase + new_digit;
+  }
+
+  return true;
+}
+
+// Helper for |StringToNumberWithError()|. Note that this may modify |*number|
+// even on failure.
+template <typename NumberType>
+bool StringToNegativeNumberWithError(const char* s,
+                                     size_t length,
+                                     NumberType* number) {
+  constexpr NumberType kBase = static_cast<NumberType>(10);
+  constexpr NumberType kMinAllowed = std::numeric_limits<NumberType>::min();
+
+  assert(s);
+  assert(length > 0u);
+  assert(number);
+
+  *number = 0;
+  for (size_t i = 0; i < length; i++) {
+    if (s[i] < '0' || s[i] > '9')
+      return false;
+    NumberType new_digit = static_cast<NumberType>(s[i] - '0');
+    // This is really a check of "*number * kBase - new_digit > kMinAllowed":
+    if (*number < kMinAllowed / kBase ||
+        (kMinAllowed / kBase == *number && new_digit > -(kMinAllowed % kBase)))
+      return false;
+    *number = *number * kBase - new_digit;
+  }
+
+  return true;
+}
+
+}  // namespace
+
+template <typename NumberType>
+std::string NumberToString(NumberType number) {
+  // Special-case zero (since nonzero cases naturally produce digits).
+  if (!number)
+    return std::string("0");
+
+  using UnsignedNumberType = typename std::make_unsigned<NumberType>::type;
+  // Note: The negative case is safe, since the standard requires that, e.g.,
+  // for n a negative int32_t, |static_cast<uint32_t>(n)| = 2^32 - n and for a
+  // uint32_t m, |-m| = 2^32 - m.
+  bool number_is_negative = (number < static_cast<NumberType>(0));
+  UnsignedNumberType abs_number = number_is_negative
+                                      ? -static_cast<UnsignedNumberType>(number)
+                                      : static_cast<UnsignedNumberType>(number);
+
+  char buf[50];  // Big enough to hold the result from even a 128-bit number.
+  size_t i = sizeof(buf);
+  while (abs_number) {
+    i--;
+    buf[i] = '0' + abs_number % 10u;
+    abs_number /= 10u;
+  }
+  if (number_is_negative) {
+    i--;
+    buf[i] = '-';
+  }
+
+  return std::string(buf + i, buf + sizeof(buf));
+}
+
+template <typename NumberType>
+bool StringToNumberWithError(const std::string& string, NumberType* number) {
+  assert(number);
+
+  if (string.empty())
+    return false;
+
+  const char* s = &string[0];
+  size_t length = string.length();
+  NumberType result = 0;
+  if (std::is_signed<NumberType>::value && string[0] == '-') {
+    if (length < 2)
+      return false;
+    if (!StringToNegativeNumberWithError<NumberType>(s + 1, length - 1u,
+                                                     &result))
+      return false;
+  } else {
+    if (!StringToPositiveNumberWithError<NumberType>(s, length, &result))
+      return false;
+  }
+
+  *number = result;
+  return true;
+}
+
+// Explicit instantiatiations for (u)intN_t; count on (unsigned) int being one
+// of these:
+template std::string NumberToString<int8_t>(int8_t number);
+template std::string NumberToString<uint8_t>(uint8_t number);
+template std::string NumberToString<int16_t>(int16_t number);
+template std::string NumberToString<uint16_t>(uint16_t number);
+template std::string NumberToString<int32_t>(int32_t number);
+template std::string NumberToString<uint32_t>(uint32_t number);
+template std::string NumberToString<int64_t>(int64_t number);
+template std::string NumberToString<uint64_t>(uint64_t number);
+template bool StringToNumberWithError<int8_t>(const std::string& string,
+                                              int8_t* number);
+template bool StringToNumberWithError<uint8_t>(const std::string& string,
+                                               uint8_t* number);
+template bool StringToNumberWithError<int16_t>(const std::string& string,
+                                               int16_t* number);
+template bool StringToNumberWithError<uint16_t>(const std::string& string,
+                                                uint16_t* number);
+template bool StringToNumberWithError<int32_t>(const std::string& string,
+                                               int32_t* number);
+template bool StringToNumberWithError<uint32_t>(const std::string& string,
+                                                uint32_t* number);
+template bool StringToNumberWithError<int64_t>(const std::string& string,
+                                               int64_t* number);
+template bool StringToNumberWithError<uint64_t>(const std::string& string,
+                                                uint64_t* number);
+
+}  // namespace util
+}  // namespace mojo