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 41 namespace google { 42 namespace protobuf { 43 namespace io { 44 45 // ---------------------------------------------------------------------- 46 // NoLocaleStrtod() 47 // This code will make you cry. 48 // ---------------------------------------------------------------------- 49 50 namespace { 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. 55 string 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 78 double 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 113 float 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