← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/gflags/gen/arch/linux/x64/include/gflags/gflags.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

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