| /* |
| * Copyright 2014 Google Inc. All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef FLATBUFFERS_UTIL_H_ |
| #define FLATBUFFERS_UTIL_H_ |
| |
| #include <fstream> |
| #include <iomanip> |
| #include <string> |
| #include <sstream> |
| #include <stdint.h> |
| #include <stdlib.h> |
| #include <assert.h> |
| #ifdef _WIN32 |
| #ifndef WIN32_LEAN_AND_MEAN |
| #define WIN32_LEAN_AND_MEAN |
| #endif |
| #ifndef NOMINMAX |
| #define NOMINMAX |
| #endif |
| #include <windows.h> |
| #include <winbase.h> |
| #include <direct.h> |
| #else |
| #include <limits.h> |
| #endif |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| |
| #include "flatbuffers/base.h" |
| |
| |
| namespace flatbuffers { |
| |
| // Convert an integer or floating point value to a string. |
| // In contrast to std::stringstream, "char" values are |
| // converted to a string of digits, and we don't use scientific notation. |
| template<typename T> std::string NumToString(T t) { |
| std::stringstream ss; |
| ss << t; |
| return ss.str(); |
| } |
| // Avoid char types used as character data. |
| template<> inline std::string NumToString<signed char>(signed char t) { |
| return NumToString(static_cast<int>(t)); |
| } |
| template<> inline std::string NumToString<unsigned char>(unsigned char t) { |
| return NumToString(static_cast<int>(t)); |
| } |
| #if defined(FLATBUFFERS_CPP98_STL) |
| template <> inline std::string NumToString<long long>(long long t) { |
| char buf[21]; // (log((1 << 63) - 1) / log(10)) + 2 |
| snprintf(buf, sizeof(buf), "%lld", t); |
| return std::string(buf); |
| } |
| |
| template <> inline std::string NumToString<unsigned long long>( |
| unsigned long long t) { |
| char buf[22]; // (log((1 << 63) - 1) / log(10)) + 1 |
| snprintf(buf, sizeof(buf), "%llu", t); |
| return std::string(buf); |
| } |
| #endif // defined(FLATBUFFERS_CPP98_STL) |
| |
| // Special versions for floats/doubles. |
| template<> inline std::string NumToString<double>(double t) { |
| // to_string() prints different numbers of digits for floats depending on |
| // platform and isn't available on Android, so we use stringstream |
| std::stringstream ss; |
| // Use std::fixed to surpress scientific notation. |
| ss << std::fixed << t; |
| auto s = ss.str(); |
| // Sadly, std::fixed turns "1" into "1.00000", so here we undo that. |
| auto p = s.find_last_not_of('0'); |
| if (p != std::string::npos) { |
| // Strip trailing zeroes. If it is a whole number, keep one zero. |
| s.resize(p + (s[p] == '.' ? 2 : 1)); |
| } |
| return s; |
| } |
| template<> inline std::string NumToString<float>(float t) { |
| return NumToString(static_cast<double>(t)); |
| } |
| |
| // Convert an integer value to a hexadecimal string. |
| // The returned string length is always xdigits long, prefixed by 0 digits. |
| // For example, IntToStringHex(0x23, 8) returns the string "00000023". |
| inline std::string IntToStringHex(int i, int xdigits) { |
| std::stringstream ss; |
| ss << std::setw(xdigits) |
| << std::setfill('0') |
| << std::hex |
| << std::uppercase |
| << i; |
| return ss.str(); |
| } |
| |
| // Portable implementation of strtoll(). |
| inline int64_t StringToInt(const char *str, char **endptr = nullptr, |
| int base = 10) { |
| #ifdef _MSC_VER |
| return _strtoi64(str, endptr, base); |
| #else |
| return strtoll(str, endptr, base); |
| #endif |
| } |
| |
| // Portable implementation of strtoull(). |
| inline uint64_t StringToUInt(const char *str, char **endptr = nullptr, |
| int base = 10) { |
| #ifdef _MSC_VER |
| return _strtoui64(str, endptr, base); |
| #else |
| return strtoull(str, endptr, base); |
| #endif |
| } |
| |
| typedef bool (*LoadFileFunction)(const char *filename, bool binary, |
| std::string *dest); |
| typedef bool (*FileExistsFunction)(const char *filename); |
| |
| LoadFileFunction SetLoadFileFunction(LoadFileFunction load_file_function); |
| |
| FileExistsFunction SetFileExistsFunction(FileExistsFunction |
| file_exists_function); |
| |
| |
| // Check if file "name" exists. |
| bool FileExists(const char *name); |
| |
| // Check if "name" exists and it is also a directory. |
| bool DirExists(const char *name); |
| |
| // Load file "name" into "buf" returning true if successful |
| // false otherwise. If "binary" is false data is read |
| // using ifstream's text mode, otherwise data is read with |
| // no transcoding. |
| bool LoadFile(const char *name, bool binary, std::string *buf); |
| |
| // Save data "buf" of length "len" bytes into a file |
| // "name" returning true if successful, false otherwise. |
| // If "binary" is false data is written using ifstream's |
| // text mode, otherwise data is written with no |
| // transcoding. |
| inline bool SaveFile(const char *name, const char *buf, size_t len, |
| bool binary) { |
| std::ofstream ofs(name, binary ? std::ofstream::binary : std::ofstream::out); |
| if (!ofs.is_open()) return false; |
| ofs.write(buf, len); |
| return !ofs.bad(); |
| } |
| |
| // Save data "buf" into file "name" returning true if |
| // successful, false otherwise. If "binary" is false |
| // data is written using ifstream's text mode, otherwise |
| // data is written with no transcoding. |
| inline bool SaveFile(const char *name, const std::string &buf, bool binary) { |
| return SaveFile(name, buf.c_str(), buf.size(), binary); |
| } |
| |
| // Functionality for minimalistic portable path handling. |
| |
| // The functions below behave correctly regardless of whether posix ('/') or |
| // Windows ('/' or '\\') separators are used. |
| |
| // Any new separators inserted are always posix. |
| |
| // We internally store paths in posix format ('/'). Paths supplied |
| // by the user should go through PosixPath to ensure correct behavior |
| // on Windows when paths are string-compared. |
| |
| static const char kPathSeparator = '/'; |
| static const char kPathSeparatorWindows = '\\'; |
| static const char *PathSeparatorSet = "\\/"; // Intentionally no ':' |
| |
| // Returns the path with the extension, if any, removed. |
| inline std::string StripExtension(const std::string &filepath) { |
| size_t i = filepath.find_last_of("."); |
| return i != std::string::npos ? filepath.substr(0, i) : filepath; |
| } |
| |
| // Returns the extension, if any. |
| inline std::string GetExtension(const std::string &filepath) { |
| size_t i = filepath.find_last_of("."); |
| return i != std::string::npos ? filepath.substr(i + 1) : ""; |
| } |
| |
| // Return the last component of the path, after the last separator. |
| inline std::string StripPath(const std::string &filepath) { |
| size_t i = filepath.find_last_of(PathSeparatorSet); |
| return i != std::string::npos ? filepath.substr(i + 1) : filepath; |
| } |
| |
| // Strip the last component of the path + separator. |
| inline std::string StripFileName(const std::string &filepath) { |
| size_t i = filepath.find_last_of(PathSeparatorSet); |
| return i != std::string::npos ? filepath.substr(0, i) : ""; |
| } |
| |
| // Concatenates a path with a filename, regardless of wether the path |
| // ends in a separator or not. |
| inline std::string ConCatPathFileName(const std::string &path, |
| const std::string &filename) { |
| std::string filepath = path; |
| if (filepath.length()) { |
| char filepath_last_character = string_back(filepath); |
| if (filepath_last_character == kPathSeparatorWindows) { |
| filepath_last_character = kPathSeparator; |
| } else if (filepath_last_character != kPathSeparator) { |
| filepath += kPathSeparator; |
| } |
| } |
| filepath += filename; |
| return filepath; |
| } |
| |
| // Replaces any '\\' separators with '/' |
| inline std::string PosixPath(const char *path) { |
| std::string p = path; |
| std::replace(p.begin(), p.end(), '\\', '/'); |
| return p; |
| } |
| |
| // This function ensure a directory exists, by recursively |
| // creating dirs for any parts of the path that don't exist yet. |
| inline void EnsureDirExists(const std::string &filepath) { |
| auto parent = StripFileName(filepath); |
| if (parent.length()) EnsureDirExists(parent); |
| #ifdef _WIN32 |
| (void)_mkdir(filepath.c_str()); |
| #else |
| mkdir(filepath.c_str(), S_IRWXU|S_IRGRP|S_IXGRP); |
| #endif |
| } |
| |
| // Obtains the absolute path from any other path. |
| // Returns the input path if the absolute path couldn't be resolved. |
| inline std::string AbsolutePath(const std::string &filepath) { |
| #ifdef FLATBUFFERS_NO_ABSOLUTE_PATH_RESOLUTION |
| return filepath; |
| #else |
| #ifdef _WIN32 |
| char abs_path[MAX_PATH]; |
| return GetFullPathNameA(filepath.c_str(), MAX_PATH, abs_path, nullptr) |
| #else |
| char abs_path[PATH_MAX]; |
| return realpath(filepath.c_str(), abs_path) |
| #endif |
| ? abs_path |
| : filepath; |
| #endif // FLATBUFFERS_NO_ABSOLUTE_PATH_RESOLUTION |
| } |
| |
| // To and from UTF-8 unicode conversion functions |
| |
| // Convert a unicode code point into a UTF-8 representation by appending it |
| // to a string. Returns the number of bytes generated. |
| inline int ToUTF8(uint32_t ucc, std::string *out) { |
| assert(!(ucc & 0x80000000)); // Top bit can't be set. |
| // 6 possible encodings: http://en.wikipedia.org/wiki/UTF-8 |
| for (int i = 0; i < 6; i++) { |
| // Max bits this encoding can represent. |
| uint32_t max_bits = 6 + i * 5 + static_cast<int>(!i); |
| if (ucc < (1u << max_bits)) { // does it fit? |
| // Remaining bits not encoded in the first byte, store 6 bits each |
| uint32_t remain_bits = i * 6; |
| // Store first byte: |
| (*out) += static_cast<char>((0xFE << (max_bits - remain_bits)) | |
| (ucc >> remain_bits)); |
| // Store remaining bytes: |
| for (int j = i - 1; j >= 0; j--) { |
| (*out) += static_cast<char>(((ucc >> (j * 6)) & 0x3F) | 0x80); |
| } |
| return i + 1; // Return the number of bytes added. |
| } |
| } |
| assert(0); // Impossible to arrive here. |
| return -1; |
| } |
| |
| // Converts whatever prefix of the incoming string corresponds to a valid |
| // UTF-8 sequence into a unicode code. The incoming pointer will have been |
| // advanced past all bytes parsed. |
| // returns -1 upon corrupt UTF-8 encoding (ignore the incoming pointer in |
| // this case). |
| inline int FromUTF8(const char **in) { |
| int len = 0; |
| // Count leading 1 bits. |
| for (int mask = 0x80; mask >= 0x04; mask >>= 1) { |
| if (**in & mask) { |
| len++; |
| } else { |
| break; |
| } |
| } |
| if ((**in << len) & 0x80) return -1; // Bit after leading 1's must be 0. |
| if (!len) return *(*in)++; |
| // UTF-8 encoded values with a length are between 2 and 4 bytes. |
| if (len < 2 || len > 4) { |
| return -1; |
| } |
| // Grab initial bits of the code. |
| int ucc = *(*in)++ & ((1 << (7 - len)) - 1); |
| for (int i = 0; i < len - 1; i++) { |
| if ((**in & 0xC0) != 0x80) return -1; // Upper bits must 1 0. |
| ucc <<= 6; |
| ucc |= *(*in)++ & 0x3F; // Grab 6 more bits of the code. |
| } |
| // UTF-8 cannot encode values between 0xD800 and 0xDFFF (reserved for |
| // UTF-16 surrogate pairs). |
| if (ucc >= 0xD800 && ucc <= 0xDFFF) { |
| return -1; |
| } |
| // UTF-8 must represent code points in their shortest possible encoding. |
| switch (len) { |
| case 2: |
| // Two bytes of UTF-8 can represent code points from U+0080 to U+07FF. |
| if (ucc < 0x0080 || ucc > 0x07FF) { |
| return -1; |
| } |
| break; |
| case 3: |
| // Three bytes of UTF-8 can represent code points from U+0800 to U+FFFF. |
| if (ucc < 0x0800 || ucc > 0xFFFF) { |
| return -1; |
| } |
| break; |
| case 4: |
| // Four bytes of UTF-8 can represent code points from U+10000 to U+10FFFF. |
| if (ucc < 0x10000 || ucc > 0x10FFFF) { |
| return -1; |
| } |
| break; |
| } |
| return ucc; |
| } |
| |
| // Wraps a string to a maximum length, inserting new lines where necessary. Any |
| // existing whitespace will be collapsed down to a single space. A prefix or |
| // suffix can be provided, which will be inserted before or after a wrapped |
| // line, respectively. |
| inline std::string WordWrap(const std::string in, size_t max_length, |
| const std::string wrapped_line_prefix, |
| const std::string wrapped_line_suffix) { |
| std::istringstream in_stream(in); |
| std::string wrapped, line, word; |
| |
| in_stream >> word; |
| line = word; |
| |
| while (in_stream >> word) { |
| if ((line.length() + 1 + word.length() + wrapped_line_suffix.length()) < |
| max_length) { |
| line += " " + word; |
| } else { |
| wrapped += line + wrapped_line_suffix + "\n"; |
| line = wrapped_line_prefix + word; |
| } |
| } |
| wrapped += line; |
| |
| return wrapped; |
| } |
| |
| inline bool EscapeString(const char *s, size_t length, std::string *_text, |
| bool allow_non_utf8) { |
| std::string &text = *_text; |
| text += "\""; |
| for (uoffset_t i = 0; i < length; i++) { |
| char c = s[i]; |
| switch (c) { |
| case '\n': text += "\\n"; break; |
| case '\t': text += "\\t"; break; |
| case '\r': text += "\\r"; break; |
| case '\b': text += "\\b"; break; |
| case '\f': text += "\\f"; break; |
| case '\"': text += "\\\""; break; |
| case '\\': text += "\\\\"; break; |
| default: |
| if (c >= ' ' && c <= '~') { |
| text += c; |
| } else { |
| // Not printable ASCII data. Let's see if it's valid UTF-8 first: |
| const char *utf8 = s + i; |
| int ucc = FromUTF8(&utf8); |
| if (ucc < 0) { |
| if (allow_non_utf8) { |
| text += "\\x"; |
| text += IntToStringHex(static_cast<uint8_t>(c), 2); |
| } else { |
| // There are two cases here: |
| // |
| // 1) We reached here by parsing an IDL file. In that case, |
| // we previously checked for non-UTF-8, so we shouldn't reach |
| // here. |
| // |
| // 2) We reached here by someone calling GenerateText() |
| // on a previously-serialized flatbuffer. The data might have |
| // non-UTF-8 Strings, or might be corrupt. |
| // |
| // In both cases, we have to give up and inform the caller |
| // they have no JSON. |
| return false; |
| } |
| } else { |
| if (ucc <= 0xFFFF) { |
| // Parses as Unicode within JSON's \uXXXX range, so use that. |
| text += "\\u"; |
| text += IntToStringHex(ucc, 4); |
| } else if (ucc <= 0x10FFFF) { |
| // Encode Unicode SMP values to a surrogate pair using two \u escapes. |
| uint32_t base = ucc - 0x10000; |
| auto high_surrogate = (base >> 10) + 0xD800; |
| auto low_surrogate = (base & 0x03FF) + 0xDC00; |
| text += "\\u"; |
| text += IntToStringHex(high_surrogate, 4); |
| text += "\\u"; |
| text += IntToStringHex(low_surrogate, 4); |
| } |
| // Skip past characters recognized. |
| i = static_cast<uoffset_t>(utf8 - s - 1); |
| } |
| } |
| break; |
| } |
| } |
| text += "\""; |
| return true; |
| } |
| |
| } // namespace flatbuffers |
| |
| #endif // FLATBUFFERS_UTIL_H_ |