1// Protocol Buffers - Google's data interchange format 2// Copyright 2008 Google Inc. All rights reserved. 3// https://developers.google.com/protocol-buffers/ 4// 5// Redistribution and use in source and binary forms, with or without 6// modification, are permitted provided that the following conditions are 7// met: 8// 9// * Redistributions of source code must retain the above copyright 10// notice, this list of conditions and the following disclaimer. 11// * Redistributions in binary form must reproduce the above 12// copyright notice, this list of conditions and the following disclaimer 13// in the documentation and/or other materials provided with the 14// distribution. 15// * Neither the name of Google Inc. nor the names of its 16// contributors may be used to endorse or promote products derived from 17// this software without specific prior written permission. 18// 19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31#include <google/protobuf/io/strtod.h> 32 33#include <cstdio> 34#include <cstring> 35#include <limits> 36#include <string> 37 38#include <google/protobuf/stubs/logging.h> 39#include <google/protobuf/stubs/common.h> 40 41namespace google { 42namespace protobuf { 43namespace io { 44 45// ---------------------------------------------------------------------- 46// NoLocaleStrtod() 47// This code will make you cry. 48// ---------------------------------------------------------------------- 49 50namespace { 51 52// Returns a string identical to *input except that the character pointed to 53// by radix_pos (which should be '.') is replaced with the locale-specific 54// radix character. 55string LocalizeRadix(const char* input, const char* radix_pos) { 56 // Determine the locale-specific radix character by calling sprintf() to 57 // print the number 1.5, then stripping off the digits. As far as I can 58 // tell, this is the only portable, thread-safe way to get the C library 59 // to divuldge the locale's radix character. No, localeconv() is NOT 60 // thread-safe. 61 char temp[16]; 62 int size = sprintf(temp, "%.1f", 1.5); 63 GOOGLE_CHECK_EQ(temp[0], '1'); 64 GOOGLE_CHECK_EQ(temp[size-1], '5'); 65 GOOGLE_CHECK_LE(size, 6); 66 67 // Now replace the '.' in the input with it. 68 string result; 69 result.reserve(strlen(input) + size - 3); 70 result.append(input, radix_pos); 71 result.append(temp + 1, size - 2); 72 result.append(radix_pos + 1); 73 return result; 74} 75 76} // namespace 77 78double NoLocaleStrtod(const char* text, char** original_endptr) { 79 // We cannot simply set the locale to "C" temporarily with setlocale() 80 // as this is not thread-safe. Instead, we try to parse in the current 81 // locale first. If parsing stops at a '.' character, then this is a 82 // pretty good hint that we're actually in some other locale in which 83 // '.' is not the radix character. 84 85 char* temp_endptr; 86 double result = strtod(text, &temp_endptr); 87 if (original_endptr != NULL) *original_endptr = temp_endptr; 88 if (*temp_endptr != '.') return result; 89 90 // Parsing halted on a '.'. Perhaps we're in a different locale? Let's 91 // try to replace the '.' with a locale-specific radix character and 92 // try again. 93 string localized = LocalizeRadix(text, temp_endptr); 94 const char* localized_cstr = localized.c_str(); 95 char* localized_endptr; 96 result = strtod(localized_cstr, &localized_endptr); 97 if ((localized_endptr - localized_cstr) > 98 (temp_endptr - text)) { 99 // This attempt got further, so replacing the decimal must have helped. 100 // Update original_endptr to point at the right location. 101 if (original_endptr != NULL) { 102 // size_diff is non-zero if the localized radix has multiple bytes. 103 int size_diff = localized.size() - strlen(text); 104 // const_cast is necessary to match the strtod() interface. 105 *original_endptr = const_cast<char*>( 106 text + (localized_endptr - localized_cstr - size_diff)); 107 } 108 } 109 110 return result; 111} 112 113float SafeDoubleToFloat(double value) { 114 if (value > std::numeric_limits<float>::max()) { 115 return std::numeric_limits<float>::infinity(); 116 } else if (value < -std::numeric_limits<float>::max()) { 117 return -std::numeric_limits<float>::infinity(); 118 } else { 119 return static_cast<float>(value); 120 } 121} 122 123} // namespace io 124} // namespace protobuf 125} // namespace google 126