OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2006, Google Inc. |
| 2 // All rights reserved. |
| 3 // |
| 4 // Redistribution and use in source and binary forms, with or without |
| 5 // modification, are permitted provided that the following conditions are |
| 6 // met: |
| 7 // |
| 8 // * Redistributions of source code must retain the above copyright |
| 9 // notice, this list of conditions and the following disclaimer. |
| 10 // * Redistributions in binary form must reproduce the above |
| 11 // copyright notice, this list of conditions and the following disclaimer |
| 12 // in the documentation and/or other materials provided with the |
| 13 // distribution. |
| 14 // * Neither the name of Google Inc. nor the names of its |
| 15 // contributors may be used to endorse or promote products derived from |
| 16 // this software without specific prior written permission. |
| 17 // |
| 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 29 |
| 30 // --- |
| 31 // Author: Ray Sidney |
| 32 // Revamped and reorganized by Craig Silverstein |
| 33 // |
| 34 // This is the file that should be included by any file which declares |
| 35 // or defines a command line flag or wants to parse command line flags |
| 36 // or print a program usage message (which will include information about |
| 37 // flags). Executive summary, in the form of an example foo.cc file: |
| 38 // |
| 39 // #include "foo.h" // foo.h has a line "DECLARE_int32(start);" |
| 40 // #include "validators.h" // hypothetical file defining ValidateIsFile() |
| 41 // |
| 42 // DEFINE_int32(end, 1000, "The last record to read"); |
| 43 // |
| 44 // DEFINE_string(filename, "my_file.txt", "The file to read"); |
| 45 // // Crash if the specified file does not exist. |
| 46 // static bool dummy = RegisterFlagValidator(&FLAGS_filename, |
| 47 // &ValidateIsFile); |
| 48 // |
| 49 // DECLARE_bool(verbose); // some other file has a DEFINE_bool(verbose, ...) |
| 50 // |
| 51 // void MyFunc() { |
| 52 // if (FLAGS_verbose) printf("Records %d-%d\n", FLAGS_start, FLAGS_end); |
| 53 // } |
| 54 // |
| 55 // Then, at the command-line: |
| 56 // ./foo --noverbose --start=5 --end=100 |
| 57 // |
| 58 // For more details, see |
| 59 // doc/gflags.html |
| 60 // |
| 61 // --- A note about thread-safety: |
| 62 // |
| 63 // We describe many functions in this routine as being thread-hostile, |
| 64 // thread-compatible, or thread-safe. Here are the meanings we use: |
| 65 // |
| 66 // thread-safe: it is safe for multiple threads to call this routine |
| 67 // (or, when referring to a class, methods of this class) |
| 68 // concurrently. |
| 69 // thread-hostile: it is not safe for multiple threads to call this |
| 70 // routine (or methods of this class) concurrently. In gflags, |
| 71 // most thread-hostile routines are intended to be called early in, |
| 72 // or even before, main() -- that is, before threads are spawned. |
| 73 // thread-compatible: it is safe for multiple threads to read from |
| 74 // this variable (when applied to variables), or to call const |
| 75 // methods of this class (when applied to classes), as long as no |
| 76 // other thread is writing to the variable or calling non-const |
| 77 // methods of this class. |
| 78 |
| 79 #ifndef GOOGLE_GFLAGS_H_ |
| 80 #define GOOGLE_GFLAGS_H_ |
| 81 |
| 82 #include <string> |
| 83 #include <vector> |
| 84 |
| 85 // We care a lot about number of bits things take up. Unfortunately, |
| 86 // systems define their bit-specific ints in a lot of different ways. |
| 87 // We use our own way, and have a typedef to get there. |
| 88 // Note: these commands below may look like "#if 1" or "#if 0", but |
| 89 // that's because they were constructed that way at ./configure time. |
| 90 // Look at gflags.h.in to see how they're calculated (based on your config). |
| 91 #if 1 |
| 92 #include <stdint.h> // the normal place uint16_t is defined |
| 93 #endif |
| 94 #if 1 |
| 95 #include <sys/types.h> // the normal place u_int16_t is defined |
| 96 #endif |
| 97 #if 1 |
| 98 #include <inttypes.h> // a third place for uint16_t or u_int16_t |
| 99 #endif |
| 100 |
| 101 namespace google { |
| 102 |
| 103 #if 1 // the C99 format |
| 104 typedef int32_t int32; |
| 105 typedef uint32_t uint32; |
| 106 typedef int64_t int64; |
| 107 typedef uint64_t uint64; |
| 108 #elif 1 // the BSD format |
| 109 typedef int32_t int32; |
| 110 typedef u_int32_t uint32; |
| 111 typedef int64_t int64; |
| 112 typedef u_int64_t uint64; |
| 113 #elif 0 // the windows (vc7) format |
| 114 typedef __int32 int32; |
| 115 typedef unsigned __int32 uint32; |
| 116 typedef __int64 int64; |
| 117 typedef unsigned __int64 uint64; |
| 118 #else |
| 119 #error Do not know how to define a 32-bit integer quantity on your system |
| 120 #endif |
| 121 |
| 122 // TODO(kjellander): update generated .h's for new gflags. |
| 123 // https://code.google.com/p/webrtc/issues/detail?id=2251 |
| 124 extern const char* VersionString(); |
| 125 extern void SetVersionString(const std::string& version); |
| 126 |
| 127 // -------------------------------------------------------------------- |
| 128 // To actually define a flag in a file, use DEFINE_bool, |
| 129 // DEFINE_string, etc. at the bottom of this file. You may also find |
| 130 // it useful to register a validator with the flag. This ensures that |
| 131 // when the flag is parsed from the commandline, or is later set via |
| 132 // SetCommandLineOption, we call the validation function. It is _not_ |
| 133 // called when you assign the value to the flag directly using the = operator. |
| 134 // |
| 135 // The validation function should return true if the flag value is valid, and |
| 136 // false otherwise. If the function returns false for the new setting of the |
| 137 // flag, the flag will retain its current value. If it returns false for the |
| 138 // default value, ParseCommandLineFlags() will die. |
| 139 // |
| 140 // This function is safe to call at global construct time (as in the |
| 141 // example below). |
| 142 // |
| 143 // Example use: |
| 144 // static bool ValidatePort(const char* flagname, int32 value) { |
| 145 // if (value > 0 && value < 32768) // value is ok |
| 146 // return true; |
| 147 // printf("Invalid value for --%s: %d\n", flagname, (int)value); |
| 148 // return false; |
| 149 // } |
| 150 // DEFINE_int32(port, 0, "What port to listen on"); |
| 151 // static bool dummy = RegisterFlagValidator(&FLAGS_port, &ValidatePort); |
| 152 |
| 153 // Returns true if successfully registered, false if not (because the |
| 154 // first argument doesn't point to a command-line flag, or because a |
| 155 // validator is already registered for this flag). |
| 156 bool RegisterFlagValidator(const bool* flag, |
| 157 bool (*validate_fn)(const char*, bool)); |
| 158 bool RegisterFlagValidator(const int32* flag, |
| 159 bool (*validate_fn)(const char*, int32)); |
| 160 bool RegisterFlagValidator(const int64* flag, |
| 161 bool (*validate_fn)(const char*, int64)); |
| 162 bool RegisterFlagValidator(const uint64* flag, |
| 163 bool (*validate_fn)(const char*, uint64)); |
| 164 bool RegisterFlagValidator(const double* flag, |
| 165 bool (*validate_fn)(const char*, double)); |
| 166 bool RegisterFlagValidator(const std::string* flag, |
| 167 bool (*validate_fn)(const char*, const std::string&))
; |
| 168 |
| 169 |
| 170 // -------------------------------------------------------------------- |
| 171 // These methods are the best way to get access to info about the |
| 172 // list of commandline flags. Note that these routines are pretty slow. |
| 173 // GetAllFlags: mostly-complete info about the list, sorted by file. |
| 174 // ShowUsageWithFlags: pretty-prints the list to stdout (what --help does) |
| 175 // ShowUsageWithFlagsRestrict: limit to filenames with restrict as a substr |
| 176 // |
| 177 // In addition to accessing flags, you can also access argv[0] (the program |
| 178 // name) and argv (the entire commandline), which we sock away a copy of. |
| 179 // These variables are static, so you should only set them once. |
| 180 |
| 181 struct CommandLineFlagInfo { |
| 182 std::string name; // the name of the flag |
| 183 std::string type; // the type of the flag: int32, etc |
| 184 std::string description; // the "help text" associated with the flag |
| 185 std::string current_value; // the current value, as a string |
| 186 std::string default_value; // the default value, as a string |
| 187 std::string filename; // 'cleaned' version of filename holding the flag |
| 188 bool has_validator_fn; // true if RegisterFlagValidator called on flag |
| 189 bool is_default; // true if the flag has the default value and |
| 190 // has not been set explicitly from the cmdline |
| 191 // or via SetCommandLineOption |
| 192 const void* flag_ptr; |
| 193 |
| 194 }; |
| 195 |
| 196 // Using this inside of a validator is a recipe for a deadlock. |
| 197 // TODO(wojtekm) Fix locking when validators are running, to make it safe to |
| 198 // call validators during ParseAllFlags. |
| 199 // Also make sure then to uncomment the corresponding unit test in |
| 200 // commandlineflags_unittest.sh |
| 201 extern void GetAllFlags(std::vector<CommandLineFlagInfo>* OUTPUT); |
| 202 // These two are actually defined in commandlineflags_reporting.cc. |
| 203 extern void ShowUsageWithFlags(const char *argv0); // what --help does |
| 204 extern void ShowUsageWithFlagsRestrict(const char *argv0, const char *restrict); |
| 205 |
| 206 // Create a descriptive string for a flag. |
| 207 // Goes to some trouble to make pretty line breaks. |
| 208 extern std::string DescribeOneFlag(const CommandLineFlagInfo& flag); |
| 209 |
| 210 // Thread-hostile; meant to be called before any threads are spawned. |
| 211 extern void SetArgv(int argc, const char** argv); |
| 212 // The following functions are thread-safe as long as SetArgv() is |
| 213 // only called before any threads start. |
| 214 extern const std::vector<std::string>& GetArgvs(); // all of argv as a vector |
| 215 extern const char* GetArgv(); // all of argv as a string |
| 216 extern const char* GetArgv0(); // only argv0 |
| 217 extern uint32 GetArgvSum(); // simple checksum of argv |
| 218 extern const char* ProgramInvocationName(); // argv0, or "UNKNOWN" if not set |
| 219 extern const char* ProgramInvocationShortName(); // basename(argv0) |
| 220 // ProgramUsage() is thread-safe as long as SetUsageMessage() is only |
| 221 // called before any threads start. |
| 222 extern const char* ProgramUsage(); // string set by SetUsageMessage() |
| 223 |
| 224 |
| 225 // -------------------------------------------------------------------- |
| 226 // Normally you access commandline flags by just saying "if (FLAGS_foo)" |
| 227 // or whatever, and set them by calling "FLAGS_foo = bar" (or, more |
| 228 // commonly, via the DEFINE_foo macro). But if you need a bit more |
| 229 // control, we have programmatic ways to get/set the flags as well. |
| 230 // These programmatic ways to access flags are thread-safe, but direct |
| 231 // access is only thread-compatible. |
| 232 |
| 233 // Return true iff the flagname was found. |
| 234 // OUTPUT is set to the flag's value, or unchanged if we return false. |
| 235 extern bool GetCommandLineOption(const char* name, std::string* OUTPUT); |
| 236 |
| 237 // Return true iff the flagname was found. OUTPUT is set to the flag's |
| 238 // CommandLineFlagInfo or unchanged if we return false. |
| 239 extern bool GetCommandLineFlagInfo(const char* name, |
| 240 CommandLineFlagInfo* OUTPUT); |
| 241 |
| 242 // Return the CommandLineFlagInfo of the flagname. exit() if name not found. |
| 243 // Example usage, to check if a flag's value is currently the default value: |
| 244 // if (GetCommandLineFlagInfoOrDie("foo").is_default) ... |
| 245 extern CommandLineFlagInfo GetCommandLineFlagInfoOrDie(const char* name); |
| 246 |
| 247 enum FlagSettingMode { |
| 248 // update the flag's value (can call this multiple times). |
| 249 SET_FLAGS_VALUE, |
| 250 // update the flag's value, but *only if* it has not yet been updated |
| 251 // with SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef". |
| 252 SET_FLAG_IF_DEFAULT, |
| 253 // set the flag's default value to this. If the flag has not yet updated |
| 254 // yet (via SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef") |
| 255 // change the flag's current value to the new default value as well. |
| 256 SET_FLAGS_DEFAULT |
| 257 }; |
| 258 |
| 259 // Set a particular flag ("command line option"). Returns a string |
| 260 // describing the new value that the option has been set to. The |
| 261 // return value API is not well-specified, so basically just depend on |
| 262 // it to be empty if the setting failed for some reason -- the name is |
| 263 // not a valid flag name, or the value is not a valid value -- and |
| 264 // non-empty else. |
| 265 |
| 266 // SetCommandLineOption uses set_mode == SET_FLAGS_VALUE (the common case) |
| 267 extern std::string SetCommandLineOption(const char* name, const char* value); |
| 268 extern std::string SetCommandLineOptionWithMode(const char* name, const char* va
lue, |
| 269 FlagSettingMode set_mode); |
| 270 |
| 271 |
| 272 // -------------------------------------------------------------------- |
| 273 // Saves the states (value, default value, whether the user has set |
| 274 // the flag, registered validators, etc) of all flags, and restores |
| 275 // them when the FlagSaver is destroyed. This is very useful in |
| 276 // tests, say, when you want to let your tests change the flags, but |
| 277 // make sure that they get reverted to the original states when your |
| 278 // test is complete. |
| 279 // |
| 280 // Example usage: |
| 281 // void TestFoo() { |
| 282 // FlagSaver s1; |
| 283 // FLAG_foo = false; |
| 284 // FLAG_bar = "some value"; |
| 285 // |
| 286 // // test happens here. You can return at any time |
| 287 // // without worrying about restoring the FLAG values. |
| 288 // } |
| 289 // |
| 290 // Note: This class is marked with __attribute__((unused)) because all the |
| 291 // work is done in the constructor and destructor, so in the standard |
| 292 // usage example above, the compiler would complain that it's an |
| 293 // unused variable. |
| 294 // |
| 295 // This class is thread-safe. |
| 296 |
| 297 class FlagSaver { |
| 298 public: |
| 299 FlagSaver(); |
| 300 ~FlagSaver(); |
| 301 |
| 302 private: |
| 303 class FlagSaverImpl* impl_; // we use pimpl here to keep API steady |
| 304 |
| 305 FlagSaver(const FlagSaver&); // no copying! |
| 306 void operator=(const FlagSaver&); |
| 307 } __attribute__ ((unused)); |
| 308 |
| 309 // -------------------------------------------------------------------- |
| 310 // Some deprecated or hopefully-soon-to-be-deprecated functions. |
| 311 |
| 312 // This is often used for logging. TODO(csilvers): figure out a better way |
| 313 extern std::string CommandlineFlagsIntoString(); |
| 314 // Usually where this is used, a FlagSaver should be used instead. |
| 315 extern bool ReadFlagsFromString(const std::string& flagfilecontents, |
| 316 const char* prog_name, |
| 317 bool errors_are_fatal); // uses SET_FLAGS_VALUE |
| 318 |
| 319 // These let you manually implement --flagfile functionality. |
| 320 // DEPRECATED. |
| 321 extern bool AppendFlagsIntoFile(const std::string& filename, const char* prog_na
me); |
| 322 extern bool SaveCommandFlags(); // actually defined in google.cc ! |
| 323 extern bool ReadFromFlagsFile(const std::string& filename, const char* prog_name
, |
| 324 bool errors_are_fatal); // uses SET_FLAGS_VALUE |
| 325 |
| 326 |
| 327 // -------------------------------------------------------------------- |
| 328 // Useful routines for initializing flags from the environment. |
| 329 // In each case, if 'varname' does not exist in the environment |
| 330 // return defval. If 'varname' does exist but is not valid |
| 331 // (e.g., not a number for an int32 flag), abort with an error. |
| 332 // Otherwise, return the value. NOTE: for booleans, for true use |
| 333 // 't' or 'T' or 'true' or '1', for false 'f' or 'F' or 'false' or '0'. |
| 334 |
| 335 extern bool BoolFromEnv(const char *varname, bool defval); |
| 336 extern int32 Int32FromEnv(const char *varname, int32 defval); |
| 337 extern int64 Int64FromEnv(const char *varname, int64 defval); |
| 338 extern uint64 Uint64FromEnv(const char *varname, uint64 defval); |
| 339 extern double DoubleFromEnv(const char *varname, double defval); |
| 340 extern const char *StringFromEnv(const char *varname, const char *defval); |
| 341 |
| 342 |
| 343 // -------------------------------------------------------------------- |
| 344 // The next two functions parse commandlineflags from main(): |
| 345 |
| 346 // Set the "usage" message for this program. For example: |
| 347 // string usage("This program does nothing. Sample usage:\n"); |
| 348 // usage += argv[0] + " <uselessarg1> <uselessarg2>"; |
| 349 // SetUsageMessage(usage); |
| 350 // Do not include commandline flags in the usage: we do that for you! |
| 351 // Thread-hostile; meant to be called before any threads are spawned. |
| 352 extern void SetUsageMessage(const std::string& usage); |
| 353 |
| 354 // Looks for flags in argv and parses them. Rearranges argv to put |
| 355 // flags first, or removes them entirely if remove_flags is true. |
| 356 // If a flag is defined more than once in the command line or flag |
| 357 // file, the last definition is used. Returns the index (into argv) |
| 358 // of the first non-flag argument. |
| 359 // See top-of-file for more details on this function. |
| 360 #ifndef SWIG // In swig, use ParseCommandLineFlagsScript() instead. |
| 361 extern uint32 ParseCommandLineFlags(int *argc, char*** argv, |
| 362 bool remove_flags); |
| 363 #endif |
| 364 |
| 365 |
| 366 // Calls to ParseCommandLineNonHelpFlags and then to |
| 367 // HandleCommandLineHelpFlags can be used instead of a call to |
| 368 // ParseCommandLineFlags during initialization, in order to allow for |
| 369 // changing default values for some FLAGS (via |
| 370 // e.g. SetCommandLineOptionWithMode calls) between the time of |
| 371 // command line parsing and the time of dumping help information for |
| 372 // the flags as a result of command line parsing. If a flag is |
| 373 // defined more than once in the command line or flag file, the last |
| 374 // definition is used. Returns the index (into argv) of the first |
| 375 // non-flag argument. (If remove_flags is true, will always return 1.) |
| 376 extern uint32 ParseCommandLineNonHelpFlags(int *argc, char*** argv, |
| 377 bool remove_flags); |
| 378 // This is actually defined in commandlineflags_reporting.cc. |
| 379 // This function is misnamed (it also handles --version, etc.), but |
| 380 // it's too late to change that now. :-( |
| 381 extern void HandleCommandLineHelpFlags(); // in commandlineflags_reporting.cc |
| 382 |
| 383 // Allow command line reparsing. Disables the error normally |
| 384 // generated when an unknown flag is found, since it may be found in a |
| 385 // later parse. Thread-hostile; meant to be called before any threads |
| 386 // are spawned. |
| 387 extern void AllowCommandLineReparsing(); |
| 388 |
| 389 // Reparse the flags that have not yet been recognized. Only flags |
| 390 // registered since the last parse will be recognized. Any flag value |
| 391 // must be provided as part of the argument using "=", not as a |
| 392 // separate command line argument that follows the flag argument. |
| 393 // Intended for handling flags from dynamically loaded libraries, |
| 394 // since their flags are not registered until they are loaded. |
| 395 // Returns the index (into the original argv) of the first non-flag |
| 396 // argument. (If remove_flags is true, will always return 1.) |
| 397 extern void ReparseCommandLineNonHelpFlags(); |
| 398 |
| 399 // Clean up memory allocated by flags. This is only needed to reduce |
| 400 // the quantity of "potentially leaked" reports emitted by memory |
| 401 // debugging tools such as valgrind. It is not required for normal |
| 402 // operation, or for the perftools heap-checker. It must only be called |
| 403 // when the process is about to exit, and all threads that might |
| 404 // access flags are quiescent. Referencing flags after this is called |
| 405 // will have unexpected consequences. This is not safe to run when |
| 406 // multiple threads might be running: the function is thread-hostile. |
| 407 extern void ShutDownCommandLineFlags(); |
| 408 |
| 409 |
| 410 // -------------------------------------------------------------------- |
| 411 // Now come the command line flag declaration/definition macros that |
| 412 // will actually be used. They're kind of hairy. A major reason |
| 413 // for this is initialization: we want people to be able to access |
| 414 // variables in global constructors and have that not crash, even if |
| 415 // their global constructor runs before the global constructor here. |
| 416 // (Obviously, we can't guarantee the flags will have the correct |
| 417 // default value in that case, but at least accessing them is safe.) |
| 418 // The only way to do that is have flags point to a static buffer. |
| 419 // So we make one, using a union to ensure proper alignment, and |
| 420 // then use placement-new to actually set up the flag with the |
| 421 // correct default value. In the same vein, we have to worry about |
| 422 // flag access in global destructors, so FlagRegisterer has to be |
| 423 // careful never to destroy the flag-values it constructs. |
| 424 // |
| 425 // Note that when we define a flag variable FLAGS_<name>, we also |
| 426 // preemptively define a junk variable, FLAGS_no<name>. This is to |
| 427 // cause a link-time error if someone tries to define 2 flags with |
| 428 // names like "logging" and "nologging". We do this because a bool |
| 429 // flag FLAG can be set from the command line to true with a "-FLAG" |
| 430 // argument, and to false with a "-noFLAG" argument, and so this can |
| 431 // potentially avert confusion. |
| 432 // |
| 433 // We also put flags into their own namespace. It is purposefully |
| 434 // named in an opaque way that people should have trouble typing |
| 435 // directly. The idea is that DEFINE puts the flag in the weird |
| 436 // namespace, and DECLARE imports the flag from there into the current |
| 437 // namespace. The net result is to force people to use DECLARE to get |
| 438 // access to a flag, rather than saying "extern bool FLAGS_whatever;" |
| 439 // or some such instead. We want this so we can put extra |
| 440 // functionality (like sanity-checking) in DECLARE if we want, and |
| 441 // make sure it is picked up everywhere. |
| 442 // |
| 443 // We also put the type of the variable in the namespace, so that |
| 444 // people can't DECLARE_int32 something that they DEFINE_bool'd |
| 445 // elsewhere. |
| 446 |
| 447 class FlagRegisterer { |
| 448 public: |
| 449 FlagRegisterer(const char* name, const char* type, |
| 450 const char* help, const char* filename, |
| 451 void* current_storage, void* defvalue_storage); |
| 452 }; |
| 453 |
| 454 extern bool FlagsTypeWarn(const char *name); |
| 455 |
| 456 // If your application #defines STRIP_FLAG_HELP to a non-zero value |
| 457 // before #including this file, we remove the help message from the |
| 458 // binary file. This can reduce the size of the resulting binary |
| 459 // somewhat, and may also be useful for security reasons. |
| 460 |
| 461 extern const char kStrippedFlagHelp[]; |
| 462 |
| 463 } |
| 464 |
| 465 #ifndef SWIG // In swig, ignore the main flag declarations |
| 466 |
| 467 #if defined(STRIP_FLAG_HELP) && STRIP_FLAG_HELP > 0 |
| 468 // Need this construct to avoid the 'defined but not used' warning. |
| 469 #define MAYBE_STRIPPED_HELP(txt) (false ? (txt) : ::google::kStrippedFlagHelp) |
| 470 #else |
| 471 #define MAYBE_STRIPPED_HELP(txt) txt |
| 472 #endif |
| 473 |
| 474 // Each command-line flag has two variables associated with it: one |
| 475 // with the current value, and one with the default value. However, |
| 476 // we have a third variable, which is where value is assigned; it's a |
| 477 // constant. This guarantees that FLAG_##value is initialized at |
| 478 // static initialization time (e.g. before program-start) rather than |
| 479 // than global construction time (which is after program-start but |
| 480 // before main), at least when 'value' is a compile-time constant. We |
| 481 // use a small trick for the "default value" variable, and call it |
| 482 // FLAGS_no<name>. This serves the second purpose of assuring a |
| 483 // compile error if someone tries to define a flag named no<name> |
| 484 // which is illegal (--foo and --nofoo both affect the "foo" flag). |
| 485 #define DEFINE_VARIABLE(type, shorttype, name, value, help) \ |
| 486 namespace fL##shorttype { \ |
| 487 static const type FLAGS_nono##name = value; \ |
| 488 type FLAGS_##name = FLAGS_nono##name; \ |
| 489 type FLAGS_no##name = FLAGS_nono##name; \ |
| 490 static ::google::FlagRegisterer o_##name( \ |
| 491 #name, #type, MAYBE_STRIPPED_HELP(help), __FILE__, \ |
| 492 &FLAGS_##name, &FLAGS_no##name); \ |
| 493 } \ |
| 494 using fL##shorttype::FLAGS_##name |
| 495 |
| 496 #define DECLARE_VARIABLE(type, shorttype, name) \ |
| 497 namespace fL##shorttype { \ |
| 498 extern type FLAGS_##name; \ |
| 499 } \ |
| 500 using fL##shorttype::FLAGS_##name |
| 501 |
| 502 // For DEFINE_bool, we want to do the extra check that the passed-in |
| 503 // value is actually a bool, and not a string or something that can be |
| 504 // coerced to a bool. These declarations (no definition needed!) will |
| 505 // help us do that, and never evaluate From, which is important. |
| 506 // We'll use 'sizeof(IsBool(val))' to distinguish. This code requires |
| 507 // that the compiler have different sizes for bool & double. Since |
| 508 // this is not guaranteed by the standard, we check it with a |
| 509 // compile-time assert (msg[-1] will give a compile-time error). |
| 510 namespace fLB { |
| 511 struct CompileAssert {}; |
| 512 typedef CompileAssert expected_sizeof_double_neq_sizeof_bool[ |
| 513 (sizeof(double) != sizeof(bool)) ? 1 : -1]; |
| 514 template<typename From> double IsBoolFlag(const From& from); |
| 515 bool IsBoolFlag(bool from); |
| 516 } // namespace fLB |
| 517 |
| 518 #define DECLARE_bool(name) DECLARE_VARIABLE(bool, B, name) |
| 519 #define DEFINE_bool(name, val, txt) \ |
| 520 namespace fLB { \ |
| 521 typedef ::fLB::CompileAssert FLAG_##name##_value_is_not_a_bool[ \ |
| 522 (sizeof(::fLB::IsBoolFlag(val)) != sizeof(double)) ? 1 : -1]; \ |
| 523 } \ |
| 524 DEFINE_VARIABLE(bool, B, name, val, txt) |
| 525 |
| 526 #define DECLARE_int32(name) DECLARE_VARIABLE(::google::int32, I, name) |
| 527 #define DEFINE_int32(name,val,txt) DEFINE_VARIABLE(::google::int32, I, name, va
l, txt) |
| 528 |
| 529 #define DECLARE_int64(name) DECLARE_VARIABLE(::google::int64, I64, name) |
| 530 #define DEFINE_int64(name,val,txt) DEFINE_VARIABLE(::google::int64, I64, name,
val, txt) |
| 531 |
| 532 #define DECLARE_uint64(name) DECLARE_VARIABLE(::google::uint64, U64, name
) |
| 533 #define DEFINE_uint64(name,val,txt) DEFINE_VARIABLE(::google::uint64, U64, name,
val, txt) |
| 534 |
| 535 #define DECLARE_double(name) DECLARE_VARIABLE(double, D, name) |
| 536 #define DEFINE_double(name, val, txt) DEFINE_VARIABLE(double, D, name, val, txt) |
| 537 |
| 538 // Strings are trickier, because they're not a POD, so we can't |
| 539 // construct them at static-initialization time (instead they get |
| 540 // constructed at global-constructor time, which is much later). To |
| 541 // try to avoid crashes in that case, we use a char buffer to store |
| 542 // the string, which we can static-initialize, and then placement-new |
| 543 // into it later. It's not perfect, but the best we can do. |
| 544 |
| 545 namespace fLS { |
| 546 // The meaning of "string" might be different between now and when the |
| 547 // macros below get invoked (e.g., if someone is experimenting with |
| 548 // other string implementations that get defined after this file is |
| 549 // included). Save the current meaning now and use it in the macros. |
| 550 typedef std::string clstring; |
| 551 |
| 552 inline clstring* dont_pass0toDEFINE_string(char *stringspot, |
| 553 const char *value) { |
| 554 return new(stringspot) clstring(value); |
| 555 } |
| 556 inline clstring* dont_pass0toDEFINE_string(char *stringspot, |
| 557 const clstring &value) { |
| 558 return new(stringspot) clstring(value); |
| 559 } |
| 560 inline clstring* dont_pass0toDEFINE_string(char *stringspot, |
| 561 int value); |
| 562 } // namespace fLS |
| 563 |
| 564 #define DECLARE_string(name) namespace fLS { extern ::fLS::clstring& FLAGS_##na
me; } \ |
| 565 using fLS::FLAGS_##name |
| 566 |
| 567 // We need to define a var named FLAGS_no##name so people don't define |
| 568 // --string and --nostring. And we need a temporary place to put val |
| 569 // so we don't have to evaluate it twice. Two great needs that go |
| 570 // great together! |
| 571 // The weird 'using' + 'extern' inside the fLS namespace is to work around |
| 572 // an unknown compiler bug/issue with the gcc 4.2.1 on SUSE 10. See |
| 573 // http://code.google.com/p/google-gflags/issues/detail?id=20 |
| 574 #define DEFINE_string(name, val, txt) \ |
| 575 namespace fLS { \ |
| 576 using ::fLS::clstring; \ |
| 577 static union { void* align; char s[sizeof(clstring)]; } s_##name[2]; \ |
| 578 clstring* const FLAGS_no##name = ::fLS:: \ |
| 579 dont_pass0toDEFINE_string(s_##name[0].s, \ |
| 580 val); \ |
| 581 static ::google::FlagRegisterer o_##name( \ |
| 582 #name, "string", MAYBE_STRIPPED_HELP(txt), __FILE__, \ |
| 583 s_##name[0].s, new (s_##name[1].s) clstring(*FLAGS_no##name)); \ |
| 584 extern clstring& FLAGS_##name; \ |
| 585 using fLS::FLAGS_##name; \ |
| 586 clstring& FLAGS_##name = *FLAGS_no##name; \ |
| 587 } \ |
| 588 using fLS::FLAGS_##name |
| 589 |
| 590 #endif // SWIG |
| 591 |
| 592 #endif // GOOGLE_GFLAGS_H_ |
OLD | NEW |