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