1fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Protocol Buffers - Google's data interchange format 2fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Copyright 2008 Google Inc. All rights reserved. 3fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// http://code.google.com/p/protobuf/ 4fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 5fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Redistribution and use in source and binary forms, with or without 6fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// modification, are permitted provided that the following conditions are 7fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// met: 8fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 9fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions of source code must retain the above copyright 10fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// notice, this list of conditions and the following disclaimer. 11fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions in binary form must reproduce the above 12fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// copyright notice, this list of conditions and the following disclaimer 13fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in the documentation and/or other materials provided with the 14fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// distribution. 15fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Neither the name of Google Inc. nor the names of its 16fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// contributors may be used to endorse or promote products derived from 17fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// this software without specific prior written permission. 18fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 19fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 31fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// from google3/strings/strutil.h 32fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 33fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GOOGLE_PROTOBUF_STUBS_STRUTIL_H__ 34fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_PROTOBUF_STUBS_STRUTIL_H__ 35fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 36d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#include <stdlib.h> 37fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <vector> 38fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <google/protobuf/stubs/common.h> 39fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 40fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace google { 41fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace protobuf { 42fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 43fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef _MSC_VER 44fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define strtoll _strtoi64 45fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define strtoull _strtoui64 46fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#elif defined(__DECCXX) && defined(__osf__) 47fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// HP C++ on Tru64 does not have strtoll, but strtol is already 64-bit. 48fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define strtoll strtol 49fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define strtoull strtoul 50fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 51fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 52fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 53fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ascii_isalnum() 54fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Check if an ASCII character is alphanumeric. We can't use ctype's 55fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// isalnum() because it is affected by locale. This function is applied 56fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to identifiers in the protocol buffer language, not to natural-language 57fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// strings, so locale should not be taken into account. 58fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ascii_isdigit() 59fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Like above, but only accepts digits. 60fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 61fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 62fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline bool ascii_isalnum(char c) { 63fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return ('a' <= c && c <= 'z') || 64fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ('A' <= c && c <= 'Z') || 65fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ('0' <= c && c <= '9'); 66fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 67fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 68fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline bool ascii_isdigit(char c) { 69fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return ('0' <= c && c <= '9'); 70fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 71fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 72fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 73fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// HasPrefixString() 74fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Check if a string begins with a given prefix. 75fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// StripPrefixString() 76fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Given a string and a putative prefix, returns the string minus the 77fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// prefix string if the prefix matches, otherwise the original 78fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// string. 79fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 80fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline bool HasPrefixString(const string& str, 81fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const string& prefix) { 82fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return str.size() >= prefix.size() && 83fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville str.compare(0, prefix.size(), prefix) == 0; 84fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 85fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 86fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline string StripPrefixString(const string& str, const string& prefix) { 87fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (HasPrefixString(str, prefix)) { 88fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return str.substr(prefix.size()); 89fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } else { 90fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return str; 91fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 92fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 93fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 94fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 95fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// HasSuffixString() 96fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Return true if str ends in suffix. 97fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// StripSuffixString() 98fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Given a string and a putative suffix, returns the string minus the 99fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// suffix string if the suffix matches, otherwise the original 100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// string. 101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline bool HasSuffixString(const string& str, 103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const string& suffix) { 104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return str.size() >= suffix.size() && 105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0; 106fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 107fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 108fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline string StripSuffixString(const string& str, const string& suffix) { 109fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (HasSuffixString(str, suffix)) { 110fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return str.substr(0, str.size() - suffix.size()); 111fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } else { 112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return str; 113fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 114fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 115fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 116fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 117fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// StripString 118fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Replaces any occurrence of the character 'remove' (or the characters 119fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in 'remove') with the character 'replacewith'. 120fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Good for keeping html characters or protocol characters (\t) out 121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// of places where they might cause a problem. 122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT void StripString(string* s, const char* remove, 124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville char replacewith); 125fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LowerString() 128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// UpperString() 129fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Convert the characters in "s" to lowercase or uppercase. ASCII-only: 130fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// these functions intentionally ignore locale because they are applied to 131fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// identifiers used in the Protocol Buffer language, not to natural-language 132fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// strings. 133fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline void LowerString(string * s) { 136fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville string::iterator end = s->end(); 137fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (string::iterator i = s->begin(); i != end; ++i) { 138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // tolower() changes based on locale. We don't want this! 139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if ('A' <= *i && *i <= 'Z') *i += 'a' - 'A'; 140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 141fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 143fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline void UpperString(string * s) { 144fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville string::iterator end = s->end(); 145fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (string::iterator i = s->begin(); i != end; ++i) { 146fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // toupper() changes based on locale. We don't want this! 147fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if ('a' <= *i && *i <= 'z') *i += 'A' - 'a'; 148fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 149fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 150fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 151fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 152fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// StringReplace() 153fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Give me a string and two patterns "old" and "new", and I replace 154fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the first instance of "old" in the string with "new", if it 155fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// exists. RETURN a new string, regardless of whether the replacement 156fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// happened or not. 157fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 158fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 159fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT string StringReplace(const string& s, const string& oldsub, 160fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const string& newsub, bool replace_all); 161fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 162fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 163fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SplitStringUsing() 164fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Split a string using a character delimiter. Append the components 165fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to 'result'. If there are consecutive delimiters, this function skips 166fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// over all of them. 167fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 168fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT void SplitStringUsing(const string& full, const char* delim, 169fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville vector<string>* res); 170fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 171fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 172fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// JoinStrings() 173fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// These methods concatenate a vector of strings into a C++ string, using 174fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the C-string "delim" as a separator between components. There are two 175fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// flavors of the function, one flavor returns the concatenated string, 176fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// another takes a pointer to the target string. In the latter case the 177fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// target string is cleared and overwritten. 178fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 179fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT void JoinStrings(const vector<string>& components, 180fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* delim, string* result); 181fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 182fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline string JoinStrings(const vector<string>& components, 183fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* delim) { 184fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville string result; 185fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville JoinStrings(components, delim, &result); 186fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return result; 187fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 188fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 189fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 190fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// UnescapeCEscapeSequences() 191fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Copies "source" to "dest", rewriting C-style escape sequences 192fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// -- '\n', '\r', '\\', '\ooo', etc -- to their ASCII 193fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// equivalents. "dest" must be sufficiently large to hold all 194fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the characters in the rewritten string (i.e. at least as large 195fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// as strlen(source) + 1 should be safe, since the replacements 196fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// are always shorter than the original escaped sequences). It's 197fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// safe for source and dest to be the same. RETURNS the length 198fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// of dest. 199fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 200fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// It allows hex sequences \xhh, or generally \xhhhhh with an 201fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// arbitrary number of hex digits, but all of them together must 202fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// specify a value of a single byte (e.g. \x0045 is equivalent 203fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to \x45, and \x1234 is erroneous). 204fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 205fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// It also allows escape sequences of the form \uhhhh (exactly four 206fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// hex digits, upper or lower case) or \Uhhhhhhhh (exactly eight 207fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// hex digits, upper or lower case) to specify a Unicode code 208fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// point. The dest array will contain the UTF8-encoded version of 209fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// that code-point (e.g., if source contains \u2019, then dest will 210fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// contain the three bytes 0xE2, 0x80, and 0x99). For the inverse 211fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// transformation, use UniLib::UTF8EscapeString 212fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (util/utf8/unilib.h), not CEscapeString. 213fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 214fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Errors: In the first form of the call, errors are reported with 215fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LOG(ERROR). The same is true for the second form of the call if 216fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the pointer to the string vector is NULL; otherwise, error 217fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// messages are stored in the vector. In either case, the effect on 218fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the dest array is not defined, but rest of the source will be 219fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// processed. 220fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 221fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 222fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest); 223fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest, 224fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville vector<string> *errors); 225fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 226fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 227fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// UnescapeCEscapeString() 228fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This does the same thing as UnescapeCEscapeSequences, but creates 229fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// a new string. The caller does not need to worry about allocating 230fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// a dest buffer. This should be used for non performance critical 231fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// tasks such as printing debug messages. It is safe for src and dest 232fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to be the same. 233fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 234fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The second call stores its errors in a supplied string vector. 235fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// If the string vector pointer is NULL, it reports the errors with LOG(). 236fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 237fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// In the first and second calls, the length of dest is returned. In the 238fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the third call, the new string is returned. 239fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 240fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 241fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT int UnescapeCEscapeString(const string& src, string* dest); 242fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT int UnescapeCEscapeString(const string& src, string* dest, 243fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville vector<string> *errors); 244fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT string UnescapeCEscapeString(const string& src); 245fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 246fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 247fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// CEscapeString() 248fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Copies 'src' to 'dest', escaping dangerous characters using 249fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// C-style escape sequences. This is very useful for preparing query 250fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// flags. 'src' and 'dest' should not overlap. 251fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Returns the number of bytes written to 'dest' (not including the \0) 252fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// or -1 if there was insufficient space. 253fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 254fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Currently only \n, \r, \t, ", ', \ and !isprint() chars are escaped. 255fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 256fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT int CEscapeString(const char* src, int src_len, 257fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville char* dest, int dest_len); 258fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 259fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 260fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// CEscape() 261fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// More convenient form of CEscapeString: returns result as a "string". 262fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This version is slower than CEscapeString() because it does more 263fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// allocation. However, it is much more convenient to use in 264fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// non-speed-critical code like logging messages etc. 265fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 266fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT string CEscape(const string& src); 267fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 268d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savillenamespace strings { 269d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// Like CEscape() but does not escape bytes with the upper bit set. 270d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink SavilleLIBPROTOBUF_EXPORT string Utf8SafeCEscape(const string& src); 271d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 272d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// Like CEscape() but uses hex (\x) escapes instead of octals. 273d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink SavilleLIBPROTOBUF_EXPORT string CHexEscape(const string& src); 274d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville} // namespace strings 275d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 276fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 277fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// strto32() 278fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// strtou32() 279fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// strto64() 280fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// strtou64() 281fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Architecture-neutral plug compatible replacements for strtol() and 282fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// strtoul(). Long's have different lengths on ILP-32 and LP-64 283fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// platforms, so using these is safer, from the point of view of 284fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// overflow behavior, than using the standard libc functions. 285fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 286fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT int32 strto32_adaptor(const char *nptr, char **endptr, 287fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int base); 288fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT uint32 strtou32_adaptor(const char *nptr, char **endptr, 289fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int base); 290fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 291fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int32 strto32(const char *nptr, char **endptr, int base) { 292fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (sizeof(int32) == sizeof(long)) 293fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return strtol(nptr, endptr, base); 294fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville else 295fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return strto32_adaptor(nptr, endptr, base); 296fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 297fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 298fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline uint32 strtou32(const char *nptr, char **endptr, int base) { 299fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (sizeof(uint32) == sizeof(unsigned long)) 300fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return strtoul(nptr, endptr, base); 301fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville else 302fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return strtou32_adaptor(nptr, endptr, base); 303fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 304fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 305fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// For now, long long is 64-bit on all the platforms we care about, so these 306fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// functions can simply pass the call to strto[u]ll. 307fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline int64 strto64(const char *nptr, char **endptr, int base) { 308fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GOOGLE_COMPILE_ASSERT(sizeof(int64) == sizeof(long long), 309fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville sizeof_int64_is_not_sizeof_long_long); 310fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return strtoll(nptr, endptr, base); 311fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 312fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 313fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline uint64 strtou64(const char *nptr, char **endptr, int base) { 314fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GOOGLE_COMPILE_ASSERT(sizeof(uint64) == sizeof(unsigned long long), 315fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville sizeof_uint64_is_not_sizeof_long_long); 316fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return strtoull(nptr, endptr, base); 317fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 318fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 319fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 320fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FastIntToBuffer() 321fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FastHexToBuffer() 322fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FastHex64ToBuffer() 323fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FastHex32ToBuffer() 324fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FastTimeToBuffer() 325fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// These are intended for speed. FastIntToBuffer() assumes the 326fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// integer is non-negative. FastHexToBuffer() puts output in 327fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// hex rather than decimal. FastTimeToBuffer() puts the output 328fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// into RFC822 format. 329fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 330fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FastHex64ToBuffer() puts a 64-bit unsigned value in hex-format, 331fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// padded to exactly 16 bytes (plus one byte for '\0') 332fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 333fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FastHex32ToBuffer() puts a 32-bit unsigned value in hex-format, 334fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// padded to exactly 8 bytes (plus one byte for '\0') 335fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 336fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// All functions take the output buffer as an arg. 337fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// They all return a pointer to the beginning of the output, 338fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// which may not be the beginning of the input buffer. 339fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 340fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 341fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Suggested buffer size for FastToBuffer functions. Also works with 342fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// DoubleToBuffer() and FloatToBuffer(). 343fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic const int kFastToBufferSize = 32; 344fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 345fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT char* FastInt32ToBuffer(int32 i, char* buffer); 346fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT char* FastInt64ToBuffer(int64 i, char* buffer); 347fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillechar* FastUInt32ToBuffer(uint32 i, char* buffer); // inline below 348fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillechar* FastUInt64ToBuffer(uint64 i, char* buffer); // inline below 349fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT char* FastHexToBuffer(int i, char* buffer); 350fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT char* FastHex64ToBuffer(uint64 i, char* buffer); 351fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT char* FastHex32ToBuffer(uint32 i, char* buffer); 352fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 353fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// at least 22 bytes long 354fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline char* FastIntToBuffer(int i, char* buffer) { 355fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (sizeof(i) == 4 ? 356fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer)); 357fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 358fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline char* FastUIntToBuffer(unsigned int i, char* buffer) { 359fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (sizeof(i) == 4 ? 360fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer)); 361fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 362fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline char* FastLongToBuffer(long i, char* buffer) { 363fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (sizeof(i) == 4 ? 364fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer)); 365fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 366fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline char* FastULongToBuffer(unsigned long i, char* buffer) { 367fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return (sizeof(i) == 4 ? 368fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer)); 369fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 370fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 371fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 372fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FastInt32ToBufferLeft() 373fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FastUInt32ToBufferLeft() 374fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FastInt64ToBufferLeft() 375fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FastUInt64ToBufferLeft() 376fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 377fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Like the Fast*ToBuffer() functions above, these are intended for speed. 378fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Unlike the Fast*ToBuffer() functions, however, these functions write 379fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// their output to the beginning of the buffer (hence the name, as the 380fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// output is left-aligned). The caller is responsible for ensuring that 381fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the buffer has enough space to hold the output. 382fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 383fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Returns a pointer to the end of the string (i.e. the null character 384fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// terminating the string). 385fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 386fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 387fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT char* FastInt32ToBufferLeft(int32 i, char* buffer); 388fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT char* FastUInt32ToBufferLeft(uint32 i, char* buffer); 389fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT char* FastInt64ToBufferLeft(int64 i, char* buffer); 390fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT char* FastUInt64ToBufferLeft(uint64 i, char* buffer); 391fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 392fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Just define these in terms of the above. 393fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline char* FastUInt32ToBuffer(uint32 i, char* buffer) { 394fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FastUInt32ToBufferLeft(i, buffer); 395fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return buffer; 396fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 397fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline char* FastUInt64ToBuffer(uint64 i, char* buffer) { 398fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FastUInt64ToBufferLeft(i, buffer); 399fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return buffer; 400fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 401fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 402fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 403fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SimpleItoa() 404fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Description: converts an integer to a string. 405fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 406fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Return value: string 407fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 408fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT string SimpleItoa(int i); 409fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT string SimpleItoa(unsigned int i); 410fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT string SimpleItoa(long i); 411fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT string SimpleItoa(unsigned long i); 412fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT string SimpleItoa(long long i); 413fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT string SimpleItoa(unsigned long long i); 414fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 415fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 416fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SimpleDtoa() 417fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SimpleFtoa() 418fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// DoubleToBuffer() 419fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// FloatToBuffer() 420fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Description: converts a double or float to a string which, if 421fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// passed to NoLocaleStrtod(), will produce the exact same original double 422fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (except in case of NaN; all NaNs are considered the same value). 423fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// We try to keep the string short but it's not guaranteed to be as 424fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// short as possible. 425fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 426fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// DoubleToBuffer() and FloatToBuffer() write the text to the given 427fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// buffer and return it. The buffer must be at least 428fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// kDoubleToBufferSize bytes for doubles and kFloatToBufferSize 429fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// bytes for floats. kFastToBufferSize is also guaranteed to be large 430fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// enough to hold either. 431fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 432fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Return value: string 433fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 434fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT string SimpleDtoa(double value); 435fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT string SimpleFtoa(float value); 436fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 437fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT char* DoubleToBuffer(double i, char* buffer); 438fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT char* FloatToBuffer(float i, char* buffer); 439fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 440fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// In practice, doubles should never need more than 24 bytes and floats 441fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// should never need more than 14 (including null terminators), but we 442fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// overestimate to be safe. 443fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic const int kDoubleToBufferSize = 32; 444fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic const int kFloatToBufferSize = 24; 445fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 446fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 447fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// NoLocaleStrtod() 448fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Exactly like strtod(), except it always behaves as if in the "C" 449fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// locale (i.e. decimal points must be '.'s). 450fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ---------------------------------------------------------------------- 451fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 452fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT double NoLocaleStrtod(const char* text, char** endptr); 453fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 454fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace protobuf 455fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace google 456fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 457fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GOOGLE_PROTOBUF_STUBS_STRUTIL_H__ 458fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 459fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 460