1// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5// Architecture-neutral plug compatible replacements for strtol() friends. 6// 7// Long's have different lengths on ILP-32 and LP-64 platforms, and so overflow 8// behavior across the two varies when strtol() and similar are used to parse 9// 32-bit integers. Similar problems exist with atoi(), because although it 10// has an all-integer interface, it uses strtol() internally, and so suffers 11// from the same narrowing problems on assignments to int. 12// 13// Examples: 14// errno = 0; 15// i = strtol("3147483647", NULL, 10); 16// printf("%d, errno %d\n", i, errno); 17// // 32-bit platform: 2147483647, errno 34 18// // 64-bit platform: -1147483649, errno 0 19// 20// printf("%d\n", atoi("3147483647")); 21// // 32-bit platform: 2147483647 22// // 64-bit platform: -1147483649 23// 24// A way round this is to define local replacements for these, and use them 25// instead of the standard libc functions. 26// 27// In most 32-bit cases the replacements can be inlined away to a call to the 28// libc function. In a couple of 64-bit cases, however, adapters are required, 29// to provide the right overflow and errno behavior. 30// 31 32#ifndef BASE_STRTOINT_H_ 33#define BASE_STRTOINT_H_ 34 35#include <stdlib.h> // For strtol* functions. 36#include <string> 37#include "base/port.h" 38#include "base/basictypes.h" 39 40// Adapter functions for handling overflow and errno. 41int32 strto32_adapter(const char *nptr, char **endptr, int base); 42uint32 strtou32_adapter(const char *nptr, char **endptr, int base); 43 44// Conversions to a 32-bit integer can pass the call to strto[u]l on 32-bit 45// platforms, but need a little extra work on 64-bit platforms. 46inline int32 strto32(const char *nptr, char **endptr, int base) { 47 if (sizeof(int32) == sizeof(long)) 48 return strtol(nptr, endptr, base); 49 else 50 return strto32_adapter(nptr, endptr, base); 51} 52 53inline uint32 strtou32(const char *nptr, char **endptr, int base) { 54 if (sizeof(uint32) == sizeof(unsigned long)) 55 return strtoul(nptr, endptr, base); 56 else 57 return strtou32_adapter(nptr, endptr, base); 58} 59 60// For now, long long is 64-bit on all the platforms we care about, so these 61// functions can simply pass the call to strto[u]ll. 62inline int64 strto64(const char *nptr, char **endptr, int base) { 63 COMPILE_ASSERT(sizeof(int64) == sizeof(long long), 64 sizeof_int64_is_not_sizeof_long_long); 65 return strtoll(nptr, endptr, base); 66} 67 68inline uint64 strtou64(const char *nptr, char **endptr, int base) { 69 COMPILE_ASSERT(sizeof(uint64) == sizeof(unsigned long long), 70 sizeof_uint64_is_not_sizeof_long_long); 71 return strtoull(nptr, endptr, base); 72} 73 74// Although it returns an int, atoi() is implemented in terms of strtol, and 75// so has differing overflow and underflow behavior. atol is the same. 76inline int32 atoi32(const char *nptr) { 77 return strto32(nptr, NULL, 10); 78} 79 80inline int64 atoi64(const char *nptr) { 81 return strto64(nptr, NULL, 10); 82} 83 84// Convenience versions of the above that take a string argument. 85inline int32 atoi32(const string &s) { 86 return atoi32(s.c_str()); 87} 88 89inline int64 atoi64(const string &s) { 90 return atoi64(s.c_str()); 91} 92 93#endif // BASE_STRTOINT_H_ 94