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