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