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
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 int64* flag, bool (*validate_fn)(const char*, int64));
132extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const uint64* flag, bool (*validate_fn)(const char*, uint64));
133extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const double* flag, bool (*validate_fn)(const char*, double));
134extern 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.
154struct 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
173extern GFLAGS_DLL_DECL void GetAllFlags(std::vector<CommandLineFlagInfo>* OUTPUT);
174// These two are actually defined in gflags_reporting.cc.
175extern GFLAGS_DLL_DECL void ShowUsageWithFlags(const char *argv0); // what --help does
176extern 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.
180extern GFLAGS_DLL_DECL std::string DescribeOneFlag(const CommandLineFlagInfo& flag);
181
182// Thread-hostile; meant to be called before any threads are spawned.
183extern 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.
187extern GFLAGS_DLL_DECL const std::vector<std::string>& GetArgvs();
188extern GFLAGS_DLL_DECL const char* GetArgv(); // all of argv as a string
189extern GFLAGS_DLL_DECL const char* GetArgv0(); // only argv0
190extern GFLAGS_DLL_DECL uint32 GetArgvSum(); // simple checksum of argv
191extern GFLAGS_DLL_DECL const char* ProgramInvocationName(); // argv0, or "UNKNOWN" if not set
192extern 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.
196extern 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.
200extern 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.
214extern 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.
218extern 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) ...
223extern GFLAGS_DLL_DECL CommandLineFlagInfo GetCommandLineFlagInfoOrDie(const char* name);
224
225enum 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)
245extern GFLAGS_DLL_DECL std::string SetCommandLineOption (const char* name, const char* value);
246extern 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
277class 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
293extern GFLAGS_DLL_DECL std::string CommandlineFlagsIntoString();
294// Usually where this is used, a FlagSaver should be used instead.
295extern GFLAGS_DLL_DECL
296bool 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.
302extern GFLAGS_DLL_DECL bool AppendFlagsIntoFile(const std::string& filename, const char* prog_name);
303extern 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
314extern GFLAGS_DLL_DECL bool BoolFromEnv(const char *varname, bool defval);
315extern GFLAGS_DLL_DECL int32 Int32FromEnv(const char *varname, int32 defval);
316extern GFLAGS_DLL_DECL int64 Int64FromEnv(const char *varname, int64 defval);
317extern GFLAGS_DLL_DECL uint64 Uint64FromEnv(const char *varname, uint64 defval);
318extern GFLAGS_DLL_DECL double DoubleFromEnv(const char *varname, double defval);
319extern 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.
331extern 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.
336extern 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.
346extern 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.)
360extern 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. :-(
365extern 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.
371extern 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.
379extern 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.
390extern 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
430class 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
442extern 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.
489namespace fLB {
490struct CompileAssert {};
491typedef CompileAssert expected_sizeof_double_neq_sizeof_bool[
492 (sizeof(double) != sizeof(bool)) ? 1 : -1];
493template<typename From> double GFLAGS_DLL_DECL IsBoolFlag(const From& from);
494GFLAGS_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
529namespace fLS {
530
531inline clstring* dont_pass0toDEFINE_string(char *stringspot,
532 const char *value) {
533 return new(stringspot) clstring(value);
534}
535inline clstring* dont_pass0toDEFINE_string(char *stringspot,
536 const clstring &value) {
537 return new(stringspot) clstring(value);
538}
539inline 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