GFlags: Fix usage of unused attribute
[blender.git] / extern / gflags / src / gflags / gflags.h
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
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 uint32*      flag, bool (*validate_fn)(const char*, uint32));
132 extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const int64*       flag, bool (*validate_fn)(const char*, int64));
133 extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const uint64*      flag, bool (*validate_fn)(const char*, uint64));
134 extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const double*      flag, bool (*validate_fn)(const char*, double));
135 extern 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.
155 struct 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
174 extern GFLAGS_DLL_DECL void GetAllFlags(std::vector<CommandLineFlagInfo>* OUTPUT);
175 // These two are actually defined in gflags_reporting.cc.
176 extern GFLAGS_DLL_DECL void ShowUsageWithFlags(const char *argv0);  // what --help does
177 extern 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.
181 extern GFLAGS_DLL_DECL std::string DescribeOneFlag(const CommandLineFlagInfo& flag);
182
183 // Thread-hostile; meant to be called before any threads are spawned.
184 extern 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.
188 extern GFLAGS_DLL_DECL const std::vector<std::string>& GetArgvs();
189 extern GFLAGS_DLL_DECL const char* GetArgv();                      // all of argv as a string
190 extern GFLAGS_DLL_DECL const char* GetArgv0();                     // only argv0
191 extern GFLAGS_DLL_DECL uint32 GetArgvSum();                        // simple checksum of argv
192 extern GFLAGS_DLL_DECL const char* ProgramInvocationName();        // argv0, or "UNKNOWN" if not set
193 extern 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.
197 extern 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.
201 extern 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.
215 extern 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.
219 extern 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) ...
224 extern GFLAGS_DLL_DECL CommandLineFlagInfo GetCommandLineFlagInfoOrDie(const char* name);
225
226 enum 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)
246 extern GFLAGS_DLL_DECL std::string SetCommandLineOption        (const char* name, const char* value);
247 extern 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
278 class 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 }
289 #ifdef __GNUC__
290 __attribute((unused))
291 #endif
292 ;
293
294 // --------------------------------------------------------------------
295 // Some deprecated or hopefully-soon-to-be-deprecated functions.
296
297 // This is often used for logging.  TODO(csilvers): figure out a better way
298 extern GFLAGS_DLL_DECL std::string CommandlineFlagsIntoString();
299 // Usually where this is used, a FlagSaver should be used instead.
300 extern GFLAGS_DLL_DECL
301 bool ReadFlagsFromString(const std::string& flagfilecontents,
302                          const char* prog_name,
303                          bool errors_are_fatal);  // uses SET_FLAGS_VALUE
304
305 // These let you manually implement --flagfile functionality.
306 // DEPRECATED.
307 extern GFLAGS_DLL_DECL bool AppendFlagsIntoFile(const std::string& filename, const char* prog_name);
308 extern GFLAGS_DLL_DECL bool ReadFromFlagsFile(const std::string& filename, const char* prog_name, bool errors_are_fatal);   // uses SET_FLAGS_VALUE
309
310
311 // --------------------------------------------------------------------
312 // Useful routines for initializing flags from the environment.
313 // In each case, if 'varname' does not exist in the environment
314 // return defval.  If 'varname' does exist but is not valid
315 // (e.g., not a number for an int32 flag), abort with an error.
316 // Otherwise, return the value.  NOTE: for booleans, for true use
317 // 't' or 'T' or 'true' or '1', for false 'f' or 'F' or 'false' or '0'.
318
319 extern GFLAGS_DLL_DECL bool BoolFromEnv(const char *varname, bool defval);
320 extern GFLAGS_DLL_DECL int32 Int32FromEnv(const char *varname, int32 defval);
321 extern GFLAGS_DLL_DECL uint32 Uint32FromEnv(const char *varname, uint32 defval);
322 extern GFLAGS_DLL_DECL int64 Int64FromEnv(const char *varname, int64 defval);
323 extern GFLAGS_DLL_DECL uint64 Uint64FromEnv(const char *varname, uint64 defval);
324 extern GFLAGS_DLL_DECL double DoubleFromEnv(const char *varname, double defval);
325 extern GFLAGS_DLL_DECL const char *StringFromEnv(const char *varname, const char *defval);
326
327
328 // --------------------------------------------------------------------
329 // The next two functions parse gflags from main():
330
331 // Set the "usage" message for this program.  For example:
332 //   string usage("This program does nothing.  Sample usage:\n");
333 //   usage += argv[0] + " <uselessarg1> <uselessarg2>";
334 //   SetUsageMessage(usage);
335 // Do not include commandline flags in the usage: we do that for you!
336 // Thread-hostile; meant to be called before any threads are spawned.
337 extern GFLAGS_DLL_DECL void SetUsageMessage(const std::string& usage);
338
339 // Sets the version string, which is emitted with --version.
340 // For instance: SetVersionString("1.3");
341 // Thread-hostile; meant to be called before any threads are spawned.
342 extern GFLAGS_DLL_DECL void SetVersionString(const std::string& version);
343
344
345 // Looks for flags in argv and parses them.  Rearranges argv to put
346 // flags first, or removes them entirely if remove_flags is true.
347 // If a flag is defined more than once in the command line or flag
348 // file, the last definition is used.  Returns the index (into argv)
349 // of the first non-flag argument.
350 // See top-of-file for more details on this function.
351 #ifndef SWIG   // In swig, use ParseCommandLineFlagsScript() instead.
352 extern GFLAGS_DLL_DECL uint32 ParseCommandLineFlags(int *argc, char*** argv, bool remove_flags);
353 #endif
354
355
356 // Calls to ParseCommandLineNonHelpFlags and then to
357 // HandleCommandLineHelpFlags can be used instead of a call to
358 // ParseCommandLineFlags during initialization, in order to allow for
359 // changing default values for some FLAGS (via
360 // e.g. SetCommandLineOptionWithMode calls) between the time of
361 // command line parsing and the time of dumping help information for
362 // the flags as a result of command line parsing.  If a flag is
363 // defined more than once in the command line or flag file, the last
364 // definition is used.  Returns the index (into argv) of the first
365 // non-flag argument.  (If remove_flags is true, will always return 1.)
366 extern GFLAGS_DLL_DECL uint32 ParseCommandLineNonHelpFlags(int *argc, char*** argv, bool remove_flags);
367
368 // This is actually defined in gflags_reporting.cc.
369 // This function is misnamed (it also handles --version, etc.), but
370 // it's too late to change that now. :-(
371 extern GFLAGS_DLL_DECL void HandleCommandLineHelpFlags();   // in gflags_reporting.cc
372
373 // Allow command line reparsing.  Disables the error normally
374 // generated when an unknown flag is found, since it may be found in a
375 // later parse.  Thread-hostile; meant to be called before any threads
376 // are spawned.
377 extern GFLAGS_DLL_DECL void AllowCommandLineReparsing();
378
379 // Reparse the flags that have not yet been recognized.  Only flags
380 // registered since the last parse will be recognized.  Any flag value
381 // must be provided as part of the argument using "=", not as a
382 // separate command line argument that follows the flag argument.
383 // Intended for handling flags from dynamically loaded libraries,
384 // since their flags are not registered until they are loaded.
385 extern GFLAGS_DLL_DECL void ReparseCommandLineNonHelpFlags();
386
387 // Clean up memory allocated by flags.  This is only needed to reduce
388 // the quantity of "potentially leaked" reports emitted by memory
389 // debugging tools such as valgrind.  It is not required for normal
390 // operation, or for the google perftools heap-checker.  It must only
391 // be called when the process is about to exit, and all threads that
392 // might access flags are quiescent.  Referencing flags after this is
393 // called will have unexpected consequences.  This is not safe to run
394 // when multiple threads might be running: the function is
395 // thread-hostile.
396 extern GFLAGS_DLL_DECL void ShutDownCommandLineFlags();
397
398
399 // --------------------------------------------------------------------
400 // Now come the command line flag declaration/definition macros that
401 // will actually be used.  They're kind of hairy.  A major reason
402 // for this is initialization: we want people to be able to access
403 // variables in global constructors and have that not crash, even if
404 // their global constructor runs before the global constructor here.
405 // (Obviously, we can't guarantee the flags will have the correct
406 // default value in that case, but at least accessing them is safe.)
407 // The only way to do that is have flags point to a static buffer.
408 // So we make one, using a union to ensure proper alignment, and
409 // then use placement-new to actually set up the flag with the
410 // correct default value.  In the same vein, we have to worry about
411 // flag access in global destructors, so FlagRegisterer has to be
412 // careful never to destroy the flag-values it constructs.
413 //
414 // Note that when we define a flag variable FLAGS_<name>, we also
415 // preemptively define a junk variable, FLAGS_no<name>.  This is to
416 // cause a link-time error if someone tries to define 2 flags with
417 // names like "logging" and "nologging".  We do this because a bool
418 // flag FLAG can be set from the command line to true with a "-FLAG"
419 // argument, and to false with a "-noFLAG" argument, and so this can
420 // potentially avert confusion.
421 //
422 // We also put flags into their own namespace.  It is purposefully
423 // named in an opaque way that people should have trouble typing
424 // directly.  The idea is that DEFINE puts the flag in the weird
425 // namespace, and DECLARE imports the flag from there into the current
426 // namespace.  The net result is to force people to use DECLARE to get
427 // access to a flag, rather than saying "extern GFLAGS_DLL_DECL bool FLAGS_whatever;"
428 // or some such instead.  We want this so we can put extra
429 // functionality (like sanity-checking) in DECLARE if we want, and
430 // make sure it is picked up everywhere.
431 //
432 // We also put the type of the variable in the namespace, so that
433 // people can't DECLARE_int32 something that they DEFINE_bool'd
434 // elsewhere.
435
436 class GFLAGS_DLL_DECL FlagRegisterer {
437  public:
438   // We instantiate this template ctor for all supported types,
439   // so it is possible to place implementation of the FlagRegisterer ctor in
440   // .cc file.
441   // Calling this constructor with unsupported type will produce linker error.
442   template <typename FlagType>
443   FlagRegisterer(const char* name,
444                  const char* help, const char* filename,
445                  FlagType* current_storage, FlagType* defvalue_storage);
446 };
447
448 // If your application #defines STRIP_FLAG_HELP to a non-zero value
449 // before #including this file, we remove the help message from the
450 // binary file. This can reduce the size of the resulting binary
451 // somewhat, and may also be useful for security reasons.
452
453 extern GFLAGS_DLL_DECL const char kStrippedFlagHelp[];
454
455
456 } // namespace GFLAGS_NAMESPACE
457
458
459 #ifndef SWIG  // In swig, ignore the main flag declarations
460
461 #if defined(STRIP_FLAG_HELP) && STRIP_FLAG_HELP > 0
462 // Need this construct to avoid the 'defined but not used' warning.
463 #define MAYBE_STRIPPED_HELP(txt) \
464    (false ? (txt) : GFLAGS_NAMESPACE::kStrippedFlagHelp)
465 #else
466 #define MAYBE_STRIPPED_HELP(txt) txt
467 #endif
468
469 // Each command-line flag has two variables associated with it: one
470 // with the current value, and one with the default value.  However,
471 // we have a third variable, which is where value is assigned; it's a
472 // constant.  This guarantees that FLAG_##value is initialized at
473 // static initialization time (e.g. before program-start) rather than
474 // than global construction time (which is after program-start but
475 // before main), at least when 'value' is a compile-time constant.  We
476 // use a small trick for the "default value" variable, and call it
477 // FLAGS_no<name>.  This serves the second purpose of assuring a
478 // compile error if someone tries to define a flag named no<name>
479 // which is illegal (--foo and --nofoo both affect the "foo" flag).
480 #define DEFINE_VARIABLE(type, shorttype, name, value, help)             \
481   namespace fL##shorttype {                                             \
482     static const type FLAGS_nono##name = value;                         \
483     /* We always want to export defined variables, dll or no */         \
484     GFLAGS_DLL_DEFINE_FLAG type FLAGS_##name = FLAGS_nono##name;        \
485     type FLAGS_no##name = FLAGS_nono##name;                             \
486     static GFLAGS_NAMESPACE::FlagRegisterer o_##name(                   \
487       #name, MAYBE_STRIPPED_HELP(help), __FILE__,                       \
488       &FLAGS_##name, &FLAGS_no##name);                                  \
489   }                                                                     \
490   using fL##shorttype::FLAGS_##name
491
492 // For DEFINE_bool, we want to do the extra check that the passed-in
493 // value is actually a bool, and not a string or something that can be
494 // coerced to a bool.  These declarations (no definition needed!) will
495 // help us do that, and never evaluate From, which is important.
496 // We'll use 'sizeof(IsBool(val))' to distinguish. This code requires
497 // that the compiler have different sizes for bool & double. Since
498 // this is not guaranteed by the standard, we check it with a
499 // COMPILE_ASSERT.
500 namespace fLB {
501 struct CompileAssert {};
502 typedef CompileAssert expected_sizeof_double_neq_sizeof_bool[
503                       (sizeof(double) != sizeof(bool)) ? 1 : -1];
504 template<typename From> double GFLAGS_DLL_DECL IsBoolFlag(const From& from);
505 GFLAGS_DLL_DECL bool IsBoolFlag(bool from);
506 }  // namespace fLB
507
508 // Here are the actual DEFINE_*-macros. The respective DECLARE_*-macros
509 // are in a separate include, gflags_declare.h, for reducing
510 // the physical transitive size for DECLARE use.
511 #define DEFINE_bool(name, val, txt)                                     \
512   namespace fLB {                                                       \
513     typedef ::fLB::CompileAssert FLAG_##name##_value_is_not_a_bool[     \
514             (sizeof(::fLB::IsBoolFlag(val)) != sizeof(double))? 1: -1]; \
515   }                                                                     \
516   DEFINE_VARIABLE(bool, B, name, val, txt)
517
518 #define DEFINE_int32(name, val, txt) \
519    DEFINE_VARIABLE(GFLAGS_NAMESPACE::int32, I, \
520                    name, val, txt)
521
522 #define DEFINE_uint32(name,val, txt) \
523    DEFINE_VARIABLE(GFLAGS_NAMESPACE::uint32, U, \
524                    name, val, txt)
525
526 #define DEFINE_int64(name, val, txt) \
527    DEFINE_VARIABLE(GFLAGS_NAMESPACE::int64, I64, \
528                    name, val, txt)
529
530 #define DEFINE_uint64(name,val, txt) \
531    DEFINE_VARIABLE(GFLAGS_NAMESPACE::uint64, U64, \
532                    name, val, txt)
533
534 #define DEFINE_double(name, val, txt) \
535    DEFINE_VARIABLE(double, D, name, val, txt)
536
537 // Strings are trickier, because they're not a POD, so we can't
538 // construct them at static-initialization time (instead they get
539 // constructed at global-constructor time, which is much later).  To
540 // try to avoid crashes in that case, we use a char buffer to store
541 // the string, which we can static-initialize, and then placement-new
542 // into it later.  It's not perfect, but the best we can do.
543
544 namespace fLS {
545
546 inline clstring* dont_pass0toDEFINE_string(char *stringspot,
547                                            const char *value) {
548   return new(stringspot) clstring(value);
549 }
550 inline clstring* dont_pass0toDEFINE_string(char *stringspot,
551                                            const clstring &value) {
552   return new(stringspot) clstring(value);
553 }
554 inline clstring* dont_pass0toDEFINE_string(char *stringspot,
555                                            int value);
556
557 // Auxiliary class used to explicitly call destructor of string objects
558 // allocated using placement new during static program deinitialization.
559 // The destructor MUST be an inline function such that the explicit
560 // destruction occurs in the same compilation unit as the placement new.
561 class StringFlagDestructor {
562   void *current_storage_;
563   void *defvalue_storage_;
564
565 public: 
566
567   StringFlagDestructor(void *current, void *defvalue)
568   : current_storage_(current), defvalue_storage_(defvalue) {}
569
570   ~StringFlagDestructor() {
571     reinterpret_cast<clstring*>(current_storage_ )->~clstring();
572     reinterpret_cast<clstring*>(defvalue_storage_)->~clstring();
573   }
574 };
575
576 }  // namespace fLS
577
578 // We need to define a var named FLAGS_no##name so people don't define
579 // --string and --nostring.  And we need a temporary place to put val
580 // so we don't have to evaluate it twice.  Two great needs that go
581 // great together!
582 // The weird 'using' + 'extern' inside the fLS namespace is to work around
583 // an unknown compiler bug/issue with the gcc 4.2.1 on SUSE 10.  See
584 //    http://code.google.com/p/google-gflags/issues/detail?id=20
585 #define DEFINE_string(name, val, txt)                                       \
586   namespace fLS {                                                           \
587     using ::fLS::clstring;                                                  \
588     using ::fLS::StringFlagDestructor;                                      \
589     static union { void* align; char s[sizeof(clstring)]; } s_##name[2];    \
590     clstring* const FLAGS_no##name = ::fLS::                                \
591                                    dont_pass0toDEFINE_string(s_##name[0].s, \
592                                                              val);          \
593     static GFLAGS_NAMESPACE::FlagRegisterer o_##name(                       \
594         #name, MAYBE_STRIPPED_HELP(txt), __FILE__,                          \
595         FLAGS_no##name, new (s_##name[1].s) clstring(*FLAGS_no##name));     \
596     static StringFlagDestructor d_##name(s_##name[0].s, s_##name[1].s);     \
597     extern GFLAGS_DLL_DEFINE_FLAG clstring& FLAGS_##name;                   \
598     using fLS::FLAGS_##name;                                                \
599     clstring& FLAGS_##name = *FLAGS_no##name;                               \
600   }                                                                         \
601   using fLS::FLAGS_##name
602
603 #endif  // SWIG
604
605
606 // Import gflags library symbols into alternative/deprecated namespace(s)
607 #include "gflags_gflags.h"
608
609
610 #endif  // GFLAGS_GFLAGS_H_