src/util.cpp

   1 /*
   2  * Copyright 2016 Google Inc. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 // clang-format off
  18 // Dont't remove `format off`, it prevent reordering of win-includes.
  19 #ifdef _WIN32
  20 #  ifndef WIN32_LEAN_AND_MEAN
  21 #    define WIN32_LEAN_AND_MEAN
  22 #  endif
  23 #  ifndef NOMINMAX
  24 #    define NOMINMAX
  25 #  endif
  26 #  include <windows.h>  // Must be included before <direct.h>
  27 #  include <direct.h>
  28 #  include <winbase.h>
  29 #  undef interface  // This is also important because of reasons
  30 #else
  31 #  include <limits.h>
  32 #endif
  33 // clang-format on
  34
  35 #include "flatbuffers/base.h"
  36 #include "flatbuffers/util.h"
  37
  38 #include <sys/stat.h>
  39 #include <clocale>
  40 #include <fstream>
  41
  42 namespace flatbuffers {
  43
  44 bool FileExistsRaw(const char *name) {
  45   std::ifstream ifs(name);
  46   return ifs.good();
  47 }
  48
  49 bool LoadFileRaw(const char *name, bool binary, std::string *buf) {
  50   if (DirExists(name)) return false;
  51   std::ifstream ifs(name, binary ? std::ifstream::binary : std::ifstream::in);
  52   if (!ifs.is_open()) return false;
  53   if (binary) {
  54     // The fastest way to read a file into a string.
  55     ifs.seekg(0, std::ios::end);
  56     auto size = ifs.tellg();
  57     (*buf).resize(static_cast<size_t>(size));
  58     ifs.seekg(0, std::ios::beg);
  59     ifs.read(&(*buf)[0], (*buf).size());
  60   } else {
  61     // This is slower, but works correctly on all platforms for text files.
  62     std::ostringstream oss;
  63     oss << ifs.rdbuf();
  64     *buf = oss.str();
  65   }
  66   return !ifs.bad();
  67 }
  68
  69 static LoadFileFunction g_load_file_function = LoadFileRaw;
  70 static FileExistsFunction g_file_exists_function = FileExistsRaw;
  71
  72 bool LoadFile(const char *name, bool binary, std::string *buf) {
  73   FLATBUFFERS_ASSERT(g_load_file_function);
  74   return g_load_file_function(name, binary, buf);
  75 }
  76
  77 bool FileExists(const char *name) {
  78   FLATBUFFERS_ASSERT(g_file_exists_function);
  79   return g_file_exists_function(name);
  80 }
  81
  82 bool DirExists(const char *name) {
  83   // clang-format off
  84
  85   #ifdef _WIN32
  86     #define flatbuffers_stat _stat
  87     #define FLATBUFFERS_S_IFDIR _S_IFDIR
  88   #else
  89     #define flatbuffers_stat stat
  90     #define FLATBUFFERS_S_IFDIR S_IFDIR
  91   #endif
  92   // clang-format on
  93   struct flatbuffers_stat file_info;
  94   if (flatbuffers_stat(name, &file_info) != 0) return false;
  95   return (file_info.st_mode & FLATBUFFERS_S_IFDIR) != 0;
  96 }
  97
  98 LoadFileFunction SetLoadFileFunction(LoadFileFunction load_file_function) {
  99   LoadFileFunction previous_function = g_load_file_function;
 100   g_load_file_function = load_file_function ? load_file_function : LoadFileRaw;
 101   return previous_function;
 102 }
 103
 104 FileExistsFunction SetFileExistsFunction(
 105     FileExistsFunction file_exists_function) {
 106   FileExistsFunction previous_function = g_file_exists_function;
 107   g_file_exists_function =
 108       file_exists_function ? file_exists_function : FileExistsRaw;
 109   return previous_function;
 110 }
 111
 112 bool SaveFile(const char *name, const char *buf, size_t len, bool binary) {
 113   std::ofstream ofs(name, binary ? std::ofstream::binary : std::ofstream::out);
 114   if (!ofs.is_open()) return false;
 115   ofs.write(buf, len);
 116   return !ofs.bad();
 117 }
 118
 119 // We internally store paths in posix format ('/'). Paths supplied
 120 // by the user should go through PosixPath to ensure correct behavior
 121 // on Windows when paths are string-compared.
 122
 123 static const char kPathSeparatorWindows = '\\';
 124 static const char *PathSeparatorSet = "\\/";  // Intentionally no ':'
 125
 126 std::string StripExtension(const std::string &filepath) {
 127   size_t i = filepath.find_last_of(".");
 128   return i != std::string::npos ? filepath.substr(0, i) : filepath;
 129 }
 130
 131 std::string GetExtension(const std::string &filepath) {
 132   size_t i = filepath.find_last_of(".");
 133   return i != std::string::npos ? filepath.substr(i + 1) : "";
 134 }
 135
 136 std::string StripPath(const std::string &filepath) {
 137   size_t i = filepath.find_last_of(PathSeparatorSet);
 138   return i != std::string::npos ? filepath.substr(i + 1) : filepath;
 139 }
 140
 141 std::string StripFileName(const std::string &filepath) {
 142   size_t i = filepath.find_last_of(PathSeparatorSet);
 143   return i != std::string::npos ? filepath.substr(0, i) : "";
 144 }
 145
 146 std::string ConCatPathFileName(const std::string &path,
 147                                const std::string &filename) {
 148   std::string filepath = path;
 149   if (filepath.length()) {
 150     char &filepath_last_character = string_back(filepath);
 151     if (filepath_last_character == kPathSeparatorWindows) {
 152       filepath_last_character = kPathSeparator;
 153     } else if (filepath_last_character != kPathSeparator) {
 154       filepath += kPathSeparator;
 155     }
 156   }
 157   filepath += filename;
 158   // Ignore './' at the start of filepath.
 159   if (filepath[0] == '.' && filepath[1] == kPathSeparator) {
 160     filepath.erase(0, 2);
 161   }
 162   return filepath;
 163 }
 164
 165 std::string PosixPath(const char *path) {
 166   std::string p = path;
 167   std::replace(p.begin(), p.end(), '\\', '/');
 168   return p;
 169 }
 170
 171 void EnsureDirExists(const std::string &filepath) {
 172   auto parent = StripFileName(filepath);
 173   if (parent.length()) EnsureDirExists(parent);
 174     // clang-format off
 175
 176   #ifdef _WIN32
 177     (void)_mkdir(filepath.c_str());
 178   #else
 179     mkdir(filepath.c_str(), S_IRWXU|S_IRGRP|S_IXGRP);
 180   #endif
 181   // clang-format on
 182 }
 183
 184 std::string AbsolutePath(const std::string &filepath) {
 185   // clang-format off
 186
 187   #ifdef FLATBUFFERS_NO_ABSOLUTE_PATH_RESOLUTION
 188     return filepath;
 189   #else
 190     #ifdef _WIN32
 191       char abs_path[MAX_PATH];
 192       return GetFullPathNameA(filepath.c_str(), MAX_PATH, abs_path, nullptr)
 193     #else
 194       char abs_path[PATH_MAX];
 195       return realpath(filepath.c_str(), abs_path)
 196     #endif
 197       ? abs_path
 198       : filepath;
 199   #endif // FLATBUFFERS_NO_ABSOLUTE_PATH_RESOLUTION
 200   // clang-format on
 201 }
 202
 203 // Locale-independent code.
 204 #if defined(FLATBUFFERS_LOCALE_INDEPENDENT) && \
 205     (FLATBUFFERS_LOCALE_INDEPENDENT > 0)
 206
 207 // clang-format off
 208 // Allocate locale instance at startup of application.
 209 ClassicLocale ClassicLocale::instance_;
 210
 211 #ifdef _MSC_VER
 212   ClassicLocale::ClassicLocale()
 213     : locale_(_create_locale(LC_ALL, "C")) {}
 214   ClassicLocale::~ClassicLocale() { _free_locale(locale_); }
 215 #else
 216   ClassicLocale::ClassicLocale()
 217     : locale_(newlocale(LC_ALL, "C", nullptr)) {}
 218   ClassicLocale::~ClassicLocale() { freelocale(locale_); }
 219 #endif
 220 // clang-format on
 221
 222 #endif  // !FLATBUFFERS_LOCALE_INDEPENDENT
 223
 224 std::string RemoveStringQuotes(const std::string &s) {
 225   auto ch = *s.c_str();
 226   return ((s.size() >= 2) && (ch == '\"' || ch == '\'') &&
 227           (ch == string_back(s)))
 228              ? s.substr(1, s.length() - 2)
 229              : s;
 230 }
 231
 232 bool SetGlobalTestLocale(const char *locale_name, std::string *_value) {
 233   const auto the_locale = setlocale(LC_ALL, locale_name);
 234   if (!the_locale) return false;
 235   if (_value) *_value = std::string(the_locale);
 236   return true;
 237 }
 238 bool ReadEnvironmentVariable(const char *var_name, std::string *_value) {
 239   #ifdef _MSC_VER
 240   __pragma(warning(disable : 4996)); // _CRT_SECURE_NO_WARNINGS
 241   #endif
 242   auto env_str = std::getenv(var_name);
 243   if (!env_str) return false;
 244   if (_value) *_value = std::string(env_str);
 245   return true;
 246 }
 247
 248 }  // namespace flatbuffers