text: /*
   * 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 <assert.h>
  #include <stdint.h>
  #include <stdlib.h>
  #include <fstream>
  #include <iomanip>
  #include <sstream>
  #include <string>
  #ifdef _WIN32
  #ifndef WIN32_LEAN_AND_MEAN
  #define WIN32_LEAN_AND_MEAN
  #endif
  #ifndef NOMINMAX
  #define NOMINMAX
  #endif
  #include <direct.h>
  #include <winbase.h>
  #include <windows.h>  // Must be included before <direct.h>
  #undef interface      // This is also important because of reasons
  #else
  #include <limits.h>
  #endif
  #include <sys/stat.h>
  #include <sys/types.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 <typename T>
  std::string FloatToString(T t, int precision) {
    // 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;
    // Default precision is 6, we want that to be higher for doubles.
    ss << std::setprecision(precision);
    ss << 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<double>(double t) {
    return FloatToString(t, 12);
  }
  template <>
  inline std::string NumToString<float>(float t) {
    return FloatToString(t, 6);
  }
  
  // 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) {
  // clang-format off
    #ifdef _MSC_VER
      return _strtoi64(str, endptr, base);
    #else
      return strtoll(str, endptr, base);
    #endif
    // clang-format on
  }
  
  // Portable implementation of strtoull().
  inline uint64_t StringToUInt(const char *str, char **endptr = nullptr,
                               int base = 10) {
  // clang-format off
    #ifdef _MSC_VER
      return _strtoui64(str, endptr, base);
    #else
      return strtoull(str, endptr, base);
    #endif
    // clang-format on
  }
  
  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;
    // Ignore './' at the start of filepath.
    if (filepath[0] == '.' && filepath[1] == kPathSeparator) {
      filepath.erase(0, 2);
    }
    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);
      // clang-format off
    #ifdef _WIN32
      (void)_mkdir(filepath.c_str());
    #else
      mkdir(filepath.c_str(), S_IRWXU|S_IRGRP|S_IXGRP);
    #endif
    // clang-format on
  }
  
  // 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) {
  // clang-format off
    #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
    // clang-format on
  }
  
  // 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 ((static_cast<const unsigned char>(**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_
  