third-party/benchmark/src/commandlineflags.cc

   1 // Copyright 2015 Google Inc. All rights reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include "commandlineflags.h"
  16
  17 #include <algorithm>
  18 #include <cctype>
  19 #include <cstdlib>
  20 #include <cstring>
  21 #include <iostream>
  22 #include <limits>
  23 #include <map>
  24 #include <utility>
  25
  26 #include "../src/string_util.h"
  27
  28 namespace benchmark {
  29 namespace {
  30
  31 // Parses 'str' for a 32-bit signed integer.  If successful, writes
  32 // the result to *value and returns true; otherwise leaves *value
  33 // unchanged and returns false.
  34 bool ParseInt32(const std::string& src_text, const char* str, int32_t* value) {
  35   // Parses the environment variable as a decimal integer.
  36   char* end = nullptr;
  37   const long long_value = strtol(str, &end, 10);  // NOLINT
  38
  39   // Has strtol() consumed all characters in the string?
  40   if (*end != '\0') {
  41     // No - an invalid character was encountered.
  42     std::cerr << src_text << " is expected to be a 32-bit integer, "
  43               << "but actually has value \"" << str << "\".\n";
  44     return false;
  45   }
  46
  47   // Is the parsed value in the range of an Int32?
  48   const int32_t result = static_cast<int32_t>(long_value);
  49   if (long_value == std::numeric_limits<long>::max() ||
  50       long_value == std::numeric_limits<long>::min() ||
  51       // The parsed value overflows as a long.  (strtol() returns
  52       // LONG_MAX or LONG_MIN when the input overflows.)
  53       result != long_value
  54       // The parsed value overflows as an Int32.
  55   ) {
  56     std::cerr << src_text << " is expected to be a 32-bit integer, "
  57               << "but actually has value \"" << str << "\", "
  58               << "which overflows.\n";
  59     return false;
  60   }
  61
  62   *value = result;
  63   return true;
  64 }
  65
  66 // Parses 'str' for a double.  If successful, writes the result to *value and
  67 // returns true; otherwise leaves *value unchanged and returns false.
  68 bool ParseDouble(const std::string& src_text, const char* str, double* value) {
  69   // Parses the environment variable as a decimal integer.
  70   char* end = nullptr;
  71   const double double_value = strtod(str, &end);  // NOLINT
  72
  73   // Has strtol() consumed all characters in the string?
  74   if (*end != '\0') {
  75     // No - an invalid character was encountered.
  76     std::cerr << src_text << " is expected to be a double, "
  77               << "but actually has value \"" << str << "\".\n";
  78     return false;
  79   }
  80
  81   *value = double_value;
  82   return true;
  83 }
  84
  85 // Parses 'str' into KV pairs. If successful, writes the result to *value and
  86 // returns true; otherwise leaves *value unchanged and returns false.
  87 bool ParseKvPairs(const std::string& src_text, const char* str,
  88                   std::map<std::string, std::string>* value) {
  89   std::map<std::string, std::string> kvs;
  90   for (const auto& kvpair : StrSplit(str, ',')) {
  91     const auto kv = StrSplit(kvpair, '=');
  92     if (kv.size() != 2) {
  93       std::cerr << src_text << " is expected to be a comma-separated list of "
  94                 << "<key>=<value> strings, but actually has value \"" << str
  95                 << "\".\n";
  96       return false;
  97     }
  98     if (!kvs.emplace(kv[0], kv[1]).second) {
  99       std::cerr << src_text << " is expected to contain unique keys but key \""
 100                 << kv[0] << "\" was repeated.\n";
 101       return false;
 102     }
 103   }
 104
 105   *value = kvs;
 106   return true;
 107 }
 108
 109 // Returns the name of the environment variable corresponding to the
 110 // given flag.  For example, FlagToEnvVar("foo") will return
 111 // "BENCHMARK_FOO" in the open-source version.
 112 static std::string FlagToEnvVar(const char* flag) {
 113   const std::string flag_str(flag);
 114
 115   std::string env_var;
 116   for (size_t i = 0; i != flag_str.length(); ++i)
 117     env_var += static_cast<char>(::toupper(flag_str.c_str()[i]));
 118
 119   return env_var;
 120 }
 121
 122 }  // namespace
 123
 124 bool BoolFromEnv(const char* flag, bool default_val) {
 125   const std::string env_var = FlagToEnvVar(flag);
 126   const char* const value_str = getenv(env_var.c_str());
 127   return value_str == nullptr ? default_val : IsTruthyFlagValue(value_str);
 128 }
 129
 130 int32_t Int32FromEnv(const char* flag, int32_t default_val) {
 131   const std::string env_var = FlagToEnvVar(flag);
 132   const char* const value_str = getenv(env_var.c_str());
 133   int32_t value = default_val;
 134   if (value_str == nullptr ||
 135       !ParseInt32(std::string("Environment variable ") + env_var, value_str,
 136                   &value)) {
 137     return default_val;
 138   }
 139   return value;
 140 }
 141
 142 double DoubleFromEnv(const char* flag, double default_val) {
 143   const std::string env_var = FlagToEnvVar(flag);
 144   const char* const value_str = getenv(env_var.c_str());
 145   double value = default_val;
 146   if (value_str == nullptr ||
 147       !ParseDouble(std::string("Environment variable ") + env_var, value_str,
 148                    &value)) {
 149     return default_val;
 150   }
 151   return value;
 152 }
 153
 154 const char* StringFromEnv(const char* flag, const char* default_val) {
 155   const std::string env_var = FlagToEnvVar(flag);
 156   const char* const value = getenv(env_var.c_str());
 157   return value == nullptr ? default_val : value;
 158 }
 159
 160 std::map<std::string, std::string> KvPairsFromEnv(
 161     const char* flag, std::map<std::string, std::string> default_val) {
 162   const std::string env_var = FlagToEnvVar(flag);
 163   const char* const value_str = getenv(env_var.c_str());
 164
 165   if (value_str == nullptr) return default_val;
 166
 167   std::map<std::string, std::string> value;
 168   if (!ParseKvPairs("Environment variable " + env_var, value_str, &value)) {
 169     return default_val;
 170   }
 171   return value;
 172 }
 173
 174 // Parses a string as a command line flag.  The string should have
 175 // the format "--flag=value".  When def_optional is true, the "=value"
 176 // part can be omitted.
 177 //
 178 // Returns the value of the flag, or nullptr if the parsing failed.
 179 const char* ParseFlagValue(const char* str, const char* flag,
 180                            bool def_optional) {
 181   // str and flag must not be nullptr.
 182   if (str == nullptr || flag == nullptr) return nullptr;
 183
 184   // The flag must start with "--".
 185   const std::string flag_str = std::string("--") + std::string(flag);
 186   const size_t flag_len = flag_str.length();
 187   if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
 188
 189   // Skips the flag name.
 190   const char* flag_end = str + flag_len;
 191
 192   // When def_optional is true, it's OK to not have a "=value" part.
 193   if (def_optional && (flag_end[0] == '\0')) return flag_end;
 194
 195   // If def_optional is true and there are more characters after the
 196   // flag name, or if def_optional is false, there must be a '=' after
 197   // the flag name.
 198   if (flag_end[0] != '=') return nullptr;
 199
 200   // Returns the string after "=".
 201   return flag_end + 1;
 202 }
 203
 204 bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
 205   // Gets the value of the flag as a string.
 206   const char* const value_str = ParseFlagValue(str, flag, true);
 207
 208   // Aborts if the parsing failed.
 209   if (value_str == nullptr) return false;
 210
 211   // Converts the string value to a bool.
 212   *value = IsTruthyFlagValue(value_str);
 213   return true;
 214 }
 215
 216 bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
 217   // Gets the value of the flag as a string.
 218   const char* const value_str = ParseFlagValue(str, flag, false);
 219
 220   // Aborts if the parsing failed.
 221   if (value_str == nullptr) return false;
 222
 223   // Sets *value to the value of the flag.
 224   return ParseInt32(std::string("The value of flag --") + flag, value_str,
 225                     value);
 226 }
 227
 228 bool ParseDoubleFlag(const char* str, const char* flag, double* value) {
 229   // Gets the value of the flag as a string.
 230   const char* const value_str = ParseFlagValue(str, flag, false);
 231
 232   // Aborts if the parsing failed.
 233   if (value_str == nullptr) return false;
 234
 235   // Sets *value to the value of the flag.
 236   return ParseDouble(std::string("The value of flag --") + flag, value_str,
 237                      value);
 238 }
 239
 240 bool ParseStringFlag(const char* str, const char* flag, std::string* value) {
 241   // Gets the value of the flag as a string.
 242   const char* const value_str = ParseFlagValue(str, flag, false);
 243
 244   // Aborts if the parsing failed.
 245   if (value_str == nullptr) return false;
 246
 247   *value = value_str;
 248   return true;
 249 }
 250
 251 bool ParseKeyValueFlag(const char* str, const char* flag,
 252                        std::map<std::string, std::string>* value) {
 253   const char* const value_str = ParseFlagValue(str, flag, false);
 254
 255   if (value_str == nullptr) return false;
 256
 257   for (const auto& kvpair : StrSplit(value_str, ',')) {
 258     const auto kv = StrSplit(kvpair, '=');
 259     if (kv.size() != 2) return false;
 260     value->emplace(kv[0], kv[1]);
 261   }
 262
 263   return true;
 264 }
 265
 266 bool IsFlag(const char* str, const char* flag) {
 267   return (ParseFlagValue(str, flag, true) != nullptr);
 268 }
 269
 270 bool IsTruthyFlagValue(const std::string& value) {
 271   if (value.size() == 1) {
 272     char v = value[0];
 273     return isalnum(v) &&
 274            !(v == '0' || v == 'f' || v == 'F' || v == 'n' || v == 'N');
 275   } else if (!value.empty()) {
 276     std::string value_lower(value);
 277     std::transform(value_lower.begin(), value_lower.end(), value_lower.begin(),
 278                    [](char c) { return static_cast<char>(::tolower(c)); });
 279     return !(value_lower == "false" || value_lower == "no" ||
 280              value_lower == "off");
 281   } else
 282     return true;
 283 }
 284
 285 }  // end namespace benchmark