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