Index: tools/nixysa/third_party/gflags-1.0/src/gflags.cc |
=================================================================== |
--- tools/nixysa/third_party/gflags-1.0/src/gflags.cc (revision 0) |
+++ tools/nixysa/third_party/gflags-1.0/src/gflags.cc (revision 0) |
@@ -0,0 +1,1984 @@ |
+// Copyright (c) 2006, Google Inc. |
+// All rights reserved. |
+// |
+// Redistribution and use in source and binary forms, with or without |
+// modification, are permitted provided that the following conditions are |
+// met: |
+// |
+// * Redistributions of source code must retain the above copyright |
+// notice, this list of conditions and the following disclaimer. |
+// * Redistributions in binary form must reproduce the above |
+// copyright notice, this list of conditions and the following disclaimer |
+// in the documentation and/or other materials provided with the |
+// distribution. |
+// * Neither the name of Google Inc. nor the names of its |
+// contributors may be used to endorse or promote products derived from |
+// this software without specific prior written permission. |
+// |
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
+ |
+// --- |
+// Author: Ray Sidney |
+// Revamped and reorganized by Craig Silverstein |
+// |
+// This file contains the implementation of all our command line flags |
+// stuff. Here's how everything fits together |
+// |
+// * FlagRegistry owns CommandLineFlags owns FlagValue. |
+// * FlagSaver holds a FlagRegistry (saves it at construct time, |
+// restores it at destroy time). |
+// * CommandLineFlagParser lives outside that hierarchy, but works on |
+// CommandLineFlags (modifying the FlagValues). |
+// * Free functions like SetCommandLineOption() work via one of the |
+// above (such as CommandLineFlagParser). |
+// |
+// In more detail: |
+// |
+// -- The main classes that hold flag data: |
+// |
+// FlagValue holds the current value of a flag. It's |
+// pseudo-templatized: every operation on a FlagValue is typed. It |
+// also deals with storage-lifetime issues (so flag values don't go |
+// away in a destructor), which is why we need a whole class to hold a |
+// variable's value. |
+// |
+// CommandLineFlag is all the information about a single command-line |
+// flag. It has a FlagValue for the flag's current value, but also |
+// the flag's name, type, etc. |
+// |
+// FlagRegistry is a collection of CommandLineFlags. There's the |
+// global registry, which is where flags defined via DEFINE_foo() |
+// live. But it's possible to define your own flag, manually, in a |
+// different registry you create. (In practice, multiple registries |
+// are used only by FlagSaver). |
+// |
+// A given FlagValue is owned by exactly one CommandLineFlag. A given |
+// CommandLineFlag is owned by exactly one FlagRegistry. FlagRegistry |
+// has a lock; any operation that writes to a FlagValue or |
+// CommandLineFlag owned by that registry must acquire the |
+// FlagRegistry lock before doing so. |
+// |
+// --- Some other classes and free functions: |
+// |
+// CommandLineFlagInfo is a client-exposed version of CommandLineFlag. |
+// Once it's instantiated, it has no dependencies or relationships |
+// with any other part of this file. |
+// |
+// FlagRegisterer is the helper class used by the DEFINE_* macros to |
+// allow work to be done at global initialization time. |
+// |
+// CommandLineFlagParser is the class that reads from the commandline |
+// and instantiates flag values based on that. It needs to poke into |
+// the innards of the FlagValue->CommandLineFlag->FlagRegistry class |
+// hierarchy to do that. It's careful to acquire the FlagRegistry |
+// lock before doing any writing or other non-const actions. |
+// |
+// GetCommandLineOption is just a hook into registry routines to |
+// retrieve a flag based on its name. SetCommandLineOption, on the |
+// other hand, hooks into CommandLineFlagParser. Other API functions |
+// are, similarly, mostly hooks into the functionality described above. |
+ |
+#include "config.h" |
+// This comes first to ensure we define __STDC_FORMAT_MACROS in time. |
+#ifdef HAVE_INTTYPES_H |
+#ifndef __STDC_FORMAT_MACROS |
+# define __STDC_FORMAT_MACROS 1 // gcc requires this to get PRId64, etc. |
+#endif |
+#include <inttypes.h> |
+#endif // HAVE_INTTYPES_H |
+#include <stdio.h> // for snprintf |
+#include <ctype.h> |
+#include <errno.h> |
+#include <string.h> |
+#include <assert.h> |
+#ifdef HAVE_FNMATCH_H |
+#include <fnmatch.h> |
+#endif // HAVE_FNMATCH_H |
+#ifdef HAVE_PTHREAD |
+#include <pthread.h> |
+#endif // HAVE_PTHREAD |
+#ifdef HAVE_WINDOWS_H |
+#include <windows.h> |
+#endif // HAVE_WINDOWS_H |
+#include <iostream> // for cerr |
+#include <string> |
+#include <map> |
+#include <vector> |
+#include <utility> // for pair<> |
+#include <algorithm> |
+#include "gflags/gflags.h" |
+ |
+#ifndef PATH_SEPARATOR |
+#define PATH_SEPARATOR '/' |
+#endif |
+ |
+// Work properly if either strtoll or strtoq is on this system |
+#ifdef HAVE_STRTOLL |
+# define strtoint64 strtoll |
+# define strtouint64 strtoull |
+#elif HAVE_STRTOQ |
+# define strtoint64 strtoq |
+# define strtouint64 strtouq |
+#else |
+// Neither strtoll nor strtoq are defined. I hope strtol works! |
+# define strtoint64 strtol |
+# define strtouint64 strtoul |
+#endif |
+ |
+// If we have inttypes.h, it will have defined PRId32/etc for us. If |
+// not, take our best guess. |
+#ifndef PRId32 |
+# define PRId32 "d" |
+#endif |
+#ifndef PRId64 |
+# define PRId64 "lld" |
+#endif |
+#ifndef PRIu64 |
+# define PRIu64 "llu" |
+#endif |
+ |
+using std::string; |
+using std::map; |
+using std::vector; |
+using std::pair; |
+using std::cerr; |
+using std::sort; |
+ |
+// Special flags, type 1: the 'recursive' flags. They set another flag's val. |
+DEFINE_string(flagfile, "", |
+ "load flags from file"); |
+DEFINE_string(fromenv, "", |
+ "set flags from the environment" |
+ " [use 'export FLAGS_flag1=value']"); |
+DEFINE_string(tryfromenv, "", |
+ "set flags from the environment if present"); |
+ |
+// Special flags, type 2: the 'parsing' flags. They modify how we parse. |
+DEFINE_string(undefok, "", |
+ "comma-separated list of flag names that it is okay to specify " |
+ "on the command line even if the program does not define a flag " |
+ "with that name. IMPORTANT: flags in this list that have " |
+ "arguments MUST use the flag=value format"); |
+ |
+_START_GOOGLE_NAMESPACE_ |
+ |
+// The help message indicating that the commandline flag has been |
+// 'stripped'. It will not show up when doing "-help" and its |
+// variants. The flag is stripped if STRIP_FLAG_HELP is set to 1 |
+// before including gflags/gflags.h. |
+ |
+// This is used by this file, and also in commandlineflags_reporting.cc |
+const char kStrippedFlagHelp[] = "\001\002\003\004 (unknown) \004\003\002\001"; |
+ |
+// This is used by the unittest to test error-exit code |
+void (*commandlineflags_exitfunc)(int) = &exit; // from stdlib.h |
+ |
+namespace { |
+ |
+// There are also 'reporting' flags, in commandlineflags_reporting.cc. |
+ |
+static const char kError[] = "ERROR: "; |
+ |
+// Indicates that undefined options are to be ignored. |
+// Enables deferred processing of flags in dynamically loaded libraries. |
+static bool allow_command_line_reparsing = false; |
+ |
+static bool logging_is_probably_set_up = false; |
+ |
+// This is a 'prototype' validate-function. 'Real' validate |
+// functions, take a flag-value as an argument: ValidateFn(bool) or |
+// ValidateFn(uint64). However, for easier storage, we strip off this |
+// argument and then restore it when actually calling the function on |
+// a flag value. |
+typedef bool (*ValidateFnProto)(); |
+ |
+ |
+// -------------------------------------------------------------------- |
+// FlagValue |
+// This represent the value a single flag might have. The major |
+// functionality is to convert from a string to an object of a |
+// given type, and back. Thread-compatible. |
+// -------------------------------------------------------------------- |
+ |
+class CommandLineFlag; |
+class FlagValue { |
+ public: |
+ FlagValue(void* valbuf, const char* type); |
+ ~FlagValue(); |
+ |
+ bool ParseFrom(const char* spec); |
+ string ToString() const; |
+ |
+ private: |
+ friend class CommandLineFlag; // for many things, including Validate() |
+ friend class GOOGLE_NAMESPACE::FlagSaverImpl; // calls New() |
+ friend class FlagRegistry; // checks value_buffer_ for flags_by_ptr_ map |
+ template <typename T> friend T GetFromEnv(const char*, const char*, T); |
+ friend bool TryParseLocked(const CommandLineFlag*, FlagValue*, |
+ const char*, string*); // for New(), CopyFrom() |
+ |
+ enum ValueType {FV_BOOL, FV_INT32, FV_INT64, FV_UINT64, FV_DOUBLE, FV_STRING}; |
+ |
+ const char* TypeName() const; |
+ bool Equal(const FlagValue& x) const; |
+ FlagValue* New() const; // creates a new one with default value |
+ void CopyFrom(const FlagValue& x); |
+ |
+ // Calls the given validate-fn on value_buffer_, and returns |
+ // whatever it returns. But first casts validate_fn_proto to a |
+ // function that takes our value as an argument (eg void |
+ // (*validate_fn)(bool) for a bool flag). |
+ bool Validate(const char* flagname, ValidateFnProto validate_fn_proto) const; |
+ |
+ void* value_buffer_; // points to the buffer holding our data |
+ ValueType type_; // how to interpret value_ |
+ |
+ FlagValue(const FlagValue&); // no copying! |
+ void operator=(const FlagValue&); |
+}; |
+ |
+ |
+// This could be a templated method of FlagValue, but doing so adds to the |
+// size of the .o. Since there's no type-safety here anyway, macro is ok. |
+#define VALUE_AS(type) *reinterpret_cast<type*>(value_buffer_) |
+#define OTHER_VALUE_AS(fv, type) *reinterpret_cast<type*>(fv.value_buffer_) |
+#define SET_VALUE_AS(type, value) VALUE_AS(type) = (value) |
+ |
+FlagValue::FlagValue(void* valbuf, const char* type) : value_buffer_(valbuf) { |
+ if (strcmp(type, "bool") == 0) type_ = FV_BOOL; |
+ else if (strcmp(type, "int32") == 0) type_ = FV_INT32; |
+ else if (strcmp(type, "int64") == 0) type_ = FV_INT64; |
+ else if (strcmp(type, "uint64") == 0) type_ = FV_UINT64; |
+ else if (strcmp(type, "double") == 0) type_ = FV_DOUBLE; |
+ else if (strcmp(type, "string") == 0) type_ = FV_STRING; |
+ else assert(false); // Unknown typename |
+} |
+ |
+FlagValue::~FlagValue() { |
+ switch (type_) { |
+ case FV_BOOL: delete reinterpret_cast<bool*>(value_buffer_); break; |
+ case FV_INT32: delete reinterpret_cast<int32*>(value_buffer_); break; |
+ case FV_INT64: delete reinterpret_cast<int64*>(value_buffer_); break; |
+ case FV_UINT64: delete reinterpret_cast<uint64*>(value_buffer_); break; |
+ case FV_DOUBLE: delete reinterpret_cast<double*>(value_buffer_); break; |
+ case FV_STRING: delete reinterpret_cast<string*>(value_buffer_); break; |
+ } |
+} |
+ |
+bool FlagValue::ParseFrom(const char* value) { |
+ if (type_ == FV_BOOL) { |
+ const char* kTrue[] = { "1", "t", "true", "y", "yes" }; |
+ const char* kFalse[] = { "0", "f", "false", "n", "no" }; |
+ for (size_t i = 0; i < sizeof(kTrue)/sizeof(*kTrue); ++i) { |
+ if (strcasecmp(value, kTrue[i]) == 0) { |
+ SET_VALUE_AS(bool, true); |
+ return true; |
+ } else if (strcasecmp(value, kFalse[i]) == 0) { |
+ SET_VALUE_AS(bool, false); |
+ return true; |
+ } |
+ } |
+ return false; // didn't match a legal input |
+ |
+ } else if (type_ == FV_STRING) { |
+ SET_VALUE_AS(string, value); |
+ return true; |
+ } |
+ |
+ // OK, it's likely to be numeric, and we'll be using a strtoXXX method. |
+ if (value[0] == '\0') // empty-string is only allowed for string type. |
+ return false; |
+ char* end; |
+ // Leading 0x puts us in base 16. But leading 0 does not put us in base 8! |
+ // It caused too many bugs when we had that behavior. |
+ int base = 10; // by default |
+ if (value[0] == '0' && (value[1] == 'x' || value[1] == 'X')) |
+ base = 16; |
+ errno = 0; |
+ |
+ switch (type_) { |
+ case FV_INT32: { |
+ const int64 r = strtoint64(value, &end, base); |
+ if (errno || end != value + strlen(value)) return false; // bad parse |
+ if (static_cast<int32>(r) != r) // worked, but number out of range |
+ return false; |
+ SET_VALUE_AS(int32, r); |
+ return true; |
+ } |
+ case FV_INT64: { |
+ const int64 r = strtoint64(value, &end, base); |
+ if (errno || end != value + strlen(value)) return false; // bad parse |
+ SET_VALUE_AS(int64, r); |
+ return true; |
+ } |
+ case FV_UINT64: { |
+ while (*value == ' ') value++; |
+ if (*value == '-') return false; // negative number |
+ const uint64 r = strtouint64(value, &end, base); |
+ if (errno || end != value + strlen(value)) return false; // bad parse |
+ SET_VALUE_AS(uint64, r); |
+ return true; |
+ } |
+ case FV_DOUBLE: { |
+ const double r = strtod(value, &end); |
+ if (errno || end != value + strlen(value)) return false; // bad parse |
+ SET_VALUE_AS(double, r); |
+ return true; |
+ } |
+ default: { |
+ assert(false); // unknown type |
+ return false; |
+ } |
+ } |
+} |
+ |
+string FlagValue::ToString() const { |
+ char intbuf[64]; // enough to hold even the biggest number |
+ switch (type_) { |
+ case FV_BOOL: |
+ return VALUE_AS(bool) ? "true" : "false"; |
+ case FV_INT32: |
+ snprintf(intbuf, sizeof(intbuf), "%"PRId32, VALUE_AS(int32)); |
+ return intbuf; |
+ case FV_INT64: |
+ snprintf(intbuf, sizeof(intbuf), "%"PRId64, VALUE_AS(int64)); |
+ return intbuf; |
+ case FV_UINT64: |
+ snprintf(intbuf, sizeof(intbuf), "%"PRIu64, VALUE_AS(uint64)); |
+ return intbuf; |
+ case FV_DOUBLE: |
+ snprintf(intbuf, sizeof(intbuf), "%.17g", VALUE_AS(double)); |
+ return intbuf; |
+ case FV_STRING: |
+ return VALUE_AS(string); |
+ default: |
+ assert(false); |
+ return ""; // unknown type |
+ } |
+} |
+ |
+bool FlagValue::Validate(const char* flagname, |
+ ValidateFnProto validate_fn_proto) const { |
+ switch (type_) { |
+ case FV_BOOL: |
+ return reinterpret_cast<bool (*)(const char*, bool)>( |
+ validate_fn_proto)(flagname, VALUE_AS(bool)); |
+ case FV_INT32: |
+ return reinterpret_cast<bool (*)(const char*, int32)>( |
+ validate_fn_proto)(flagname, VALUE_AS(int32)); |
+ case FV_INT64: |
+ return reinterpret_cast<bool (*)(const char*, int64)>( |
+ validate_fn_proto)(flagname, VALUE_AS(int64)); |
+ case FV_UINT64: |
+ return reinterpret_cast<bool (*)(const char*, uint64)>( |
+ validate_fn_proto)(flagname, VALUE_AS(uint64)); |
+ case FV_DOUBLE: |
+ return reinterpret_cast<bool (*)(const char*, double)>( |
+ validate_fn_proto)(flagname, VALUE_AS(double)); |
+ case FV_STRING: |
+ return reinterpret_cast<bool (*)(const char*, const string&)>( |
+ validate_fn_proto)(flagname, VALUE_AS(string)); |
+ default: |
+ assert(false); // unknown type |
+ return false; |
+ } |
+} |
+ |
+const char* FlagValue::TypeName() const { |
+ switch (type_) { |
+ case FV_BOOL: return "bool"; |
+ case FV_INT32: return "int32"; |
+ case FV_INT64: return "int64"; |
+ case FV_UINT64: return "uint64"; |
+ case FV_DOUBLE: return "double"; |
+ case FV_STRING: return "string"; |
+ default: assert(false); return ""; // unknown type |
+ } |
+} |
+ |
+bool FlagValue::Equal(const FlagValue& x) const { |
+ if (type_ != x.type_) |
+ return false; |
+ switch (type_) { |
+ case FV_BOOL: return VALUE_AS(bool) == OTHER_VALUE_AS(x, bool); |
+ case FV_INT32: return VALUE_AS(int32) == OTHER_VALUE_AS(x, int32); |
+ case FV_INT64: return VALUE_AS(int64) == OTHER_VALUE_AS(x, int64); |
+ case FV_UINT64: return VALUE_AS(uint64) == OTHER_VALUE_AS(x, uint64); |
+ case FV_DOUBLE: return VALUE_AS(double) == OTHER_VALUE_AS(x, double); |
+ case FV_STRING: return VALUE_AS(string) == OTHER_VALUE_AS(x, string); |
+ default: assert(false); return false; // unknown type |
+ } |
+} |
+ |
+FlagValue* FlagValue::New() const { |
+ switch (type_) { |
+ case FV_BOOL: return new FlagValue(new bool(false), "bool"); |
+ case FV_INT32: return new FlagValue(new int32(0), "int32"); |
+ case FV_INT64: return new FlagValue(new int64(0), "int64"); |
+ case FV_UINT64: return new FlagValue(new uint64(0), "uint64"); |
+ case FV_DOUBLE: return new FlagValue(new double(0.0), "double"); |
+ case FV_STRING: return new FlagValue(new string, "string"); |
+ default: assert(false); return NULL; // unknown type |
+ } |
+} |
+ |
+void FlagValue::CopyFrom(const FlagValue& x) { |
+ assert(type_ == x.type_); |
+ switch (type_) { |
+ case FV_BOOL: SET_VALUE_AS(bool, OTHER_VALUE_AS(x, bool)); break; |
+ case FV_INT32: SET_VALUE_AS(int32, OTHER_VALUE_AS(x, int32)); break; |
+ case FV_INT64: SET_VALUE_AS(int64, OTHER_VALUE_AS(x, int64)); break; |
+ case FV_UINT64: SET_VALUE_AS(uint64, OTHER_VALUE_AS(x, uint64)); break; |
+ case FV_DOUBLE: SET_VALUE_AS(double, OTHER_VALUE_AS(x, double)); break; |
+ case FV_STRING: SET_VALUE_AS(string, OTHER_VALUE_AS(x, string)); break; |
+ default: assert(false); // unknown type |
+ } |
+} |
+ |
+// -------------------------------------------------------------------- |
+// CommandLineFlag |
+// This represents a single flag, including its name, description, |
+// default value, and current value. Mostly this serves as a |
+// struct, though it also knows how to register itself. |
+// All CommandLineFlags are owned by a (exactly one) |
+// FlagRegistry. If you wish to modify fields in this class, you |
+// should acquire the FlagRegistry lock for the registry that owns |
+// this flag. |
+// -------------------------------------------------------------------- |
+ |
+class CommandLineFlag { |
+ public: |
+ // Note: we take over memory-ownership of current_val and default_val. |
+ CommandLineFlag(const char* name, const char* help, const char* filename, |
+ FlagValue* current_val, FlagValue* default_val); |
+ ~CommandLineFlag(); |
+ |
+ const char* name() const { return name_; } |
+ const char* help() const { return help_; } |
+ const char* filename() const { return file_; } |
+ const char* CleanFileName() const; // nixes irrelevant prefix such as homedir |
+ string current_value() const { return current_->ToString(); } |
+ string default_value() const { return defvalue_->ToString(); } |
+ const char* type_name() const { return defvalue_->TypeName(); } |
+ ValidateFnProto validate_function() const { return validate_fn_proto_; } |
+ |
+ void FillCommandLineFlagInfo(struct CommandLineFlagInfo* result); |
+ |
+ // If validate_fn_proto_ is non-NULL, calls it on value, returns result. |
+ bool Validate(const FlagValue& value) const; |
+ bool ValidateCurrent() const { return Validate(*current_); } |
+ |
+ private: |
+ // for SetFlagLocked() and setting flags_by_ptr_ |
+ friend class FlagRegistry; |
+ friend class GOOGLE_NAMESPACE::FlagSaverImpl; // for cloning the values |
+ friend bool GetCommandLineOption(const char*, string*, bool*); |
+ // set validate_fn |
+ friend bool AddFlagValidator(const void*, ValidateFnProto); |
+ |
+ // This copies all the non-const members: modified, processed, defvalue, etc. |
+ void CopyFrom(const CommandLineFlag& src); |
+ |
+ void UpdateModifiedBit(); |
+ |
+ const char* const name_; // Flag name |
+ const char* const help_; // Help message |
+ const char* const file_; // Which file did this come from? |
+ bool modified_; // Set after default assignment? |
+ FlagValue* defvalue_; // Default value for flag |
+ FlagValue* current_; // Current value for flag |
+ // This is a casted, 'generic' version of validate_fn, which actually |
+ // takes a flag-value as an arg (void (*validate_fn)(bool), say). |
+ // When we pass this to current_->Validate(), it will cast it back to |
+ // the proper type. This may be NULL to mean we have no validate_fn. |
+ ValidateFnProto validate_fn_proto_; |
+ |
+ CommandLineFlag(const CommandLineFlag&); // no copying! |
+ void operator=(const CommandLineFlag&); |
+}; |
+ |
+CommandLineFlag::CommandLineFlag(const char* name, const char* help, |
+ const char* filename, |
+ FlagValue* current_val, FlagValue* default_val) |
+ : name_(name), help_(help), file_(filename), modified_(false), |
+ defvalue_(default_val), current_(current_val), validate_fn_proto_(NULL) { |
+} |
+ |
+CommandLineFlag::~CommandLineFlag() { |
+ delete current_; |
+ delete defvalue_; |
+} |
+ |
+const char* CommandLineFlag::CleanFileName() const { |
+ // Compute top-level directory & file that this appears in |
+ // search full path backwards. |
+ // Stop going backwards at kRootDir; and skip by the first slash. |
+ static const char kRootDir[] = ""; // can set this to root directory, |
+ // e.g. "myproject" |
+ |
+ if (sizeof(kRootDir)-1 == 0) // no prefix to strip |
+ return filename(); |
+ |
+ const char* clean_name = filename() + strlen(filename()) - 1; |
+ while ( clean_name > filename() ) { |
+ if (*clean_name == PATH_SEPARATOR) { |
+ if (strncmp(clean_name, kRootDir, sizeof(kRootDir)-1) == 0) { |
+ // ".../myproject/base/logging.cc" ==> "base/logging.cc" |
+ clean_name += sizeof(kRootDir)-1; // past "/myproject/" |
+ break; |
+ } |
+ } |
+ --clean_name; |
+ } |
+ while ( *clean_name == PATH_SEPARATOR ) ++clean_name; // Skip any slashes |
+ return clean_name; |
+} |
+ |
+void CommandLineFlag::FillCommandLineFlagInfo( |
+ CommandLineFlagInfo* result) { |
+ result->name = name(); |
+ result->type = type_name(); |
+ result->description = help(); |
+ result->current_value = current_value(); |
+ result->default_value = default_value(); |
+ result->filename = CleanFileName(); |
+ UpdateModifiedBit(); |
+ result->is_default = !modified_; |
+ result->has_validator_fn = validate_function() != NULL; |
+} |
+ |
+void CommandLineFlag::UpdateModifiedBit() { |
+ // Update the "modified" bit in case somebody bypassed the |
+ // Flags API and wrote directly through the FLAGS_name variable. |
+ if (!modified_ && !current_->Equal(*defvalue_)) { |
+ modified_ = true; |
+ } |
+} |
+ |
+void CommandLineFlag::CopyFrom(const CommandLineFlag& src) { |
+ // Note we only copy the non-const members; others are fixed at construct time |
+ if (modified_ != src.modified_) modified_ = src.modified_; |
+ if (!current_->Equal(*src.current_)) current_->CopyFrom(*src.current_); |
+ if (!defvalue_->Equal(*src.defvalue_)) defvalue_->CopyFrom(*src.defvalue_); |
+ if (validate_fn_proto_ != src.validate_fn_proto_) |
+ validate_fn_proto_ = src.validate_fn_proto_; |
+} |
+ |
+bool CommandLineFlag::Validate(const FlagValue& value) const { |
+ if (validate_function() == NULL) |
+ return true; |
+ else |
+ return value.Validate(name(), validate_function()); |
+} |
+ |
+ |
+// -------------------------------------------------------------------- |
+// FlagRegistry |
+// A FlagRegistry singleton object holds all flag objects indexed |
+// by their names so that if you know a flag's name (as a C |
+// string), you can access or set it. If the function is named |
+// FooLocked(), you must own the registry lock before calling |
+// the function; otherwise, you should *not* hold the lock, and |
+// the function will acquire it itself if needed. |
+// -------------------------------------------------------------------- |
+ |
+struct StringCmp { // Used by the FlagRegistry map class to compare char*'s |
+ bool operator() (const char* s1, const char* s2) const { |
+ return (strcmp(s1, s2) < 0); |
+ } |
+}; |
+ |
+class FlagRegistry { |
+ public: |
+ FlagRegistry(); |
+ ~FlagRegistry(); |
+ |
+ void Lock(); |
+ void Unlock(); |
+ |
+ // Store a flag in this registry. Takes ownership of the given pointer. |
+ void RegisterFlag(CommandLineFlag* flag); |
+ |
+ // Returns the flag object for the specified name, or NULL if not found. |
+ CommandLineFlag* FindFlagLocked(const char* name); |
+ |
+ // Returns the flag object whose current-value is stored at flag_ptr. |
+ // That is, for whom current_->value_buffer_ == flag_ptr |
+ CommandLineFlag* FindFlagViaPtrLocked(const void* flag_ptr); |
+ |
+ // A fancier form of FindFlag that works correctly if name is of the |
+ // form flag=value. In that case, we set key to point to flag, and |
+ // modify v to point to the value (if present), and return the flag |
+ // with the given name. If the flag does not exist, returns NULL |
+ // and sets error_message. |
+ CommandLineFlag* SplitArgumentLocked(const char* argument, |
+ string* key, const char** v, |
+ string* error_message); |
+ |
+ // Set the value of a flag. If the flag was successfully set to |
+ // value, set msg to indicate the new flag-value, and return true. |
+ // Otherwise, set msg to indicate the error, leave flag unchanged, |
+ // and return false. msg can be NULL. |
+ bool SetFlagLocked(CommandLineFlag* flag, const char* value, |
+ FlagSettingMode set_mode, string* msg); |
+ |
+ static FlagRegistry* GlobalRegistry(); // returns a singleton registry |
+ |
+ private: |
+ friend class GOOGLE_NAMESPACE::FlagSaverImpl; // reads all the flags in order to copy them |
+ friend class CommandLineFlagParser; // for ValidateAllFlags |
+ friend void GOOGLE_NAMESPACE::GetAllFlags(vector<CommandLineFlagInfo>*); |
+ |
+ // The map from name to flag, for FindFlagLocked(). |
+ typedef map<const char*, CommandLineFlag*, StringCmp> FlagMap; |
+ typedef FlagMap::iterator FlagIterator; |
+ typedef FlagMap::const_iterator FlagConstIterator; |
+ FlagMap flags_; |
+ |
+ // The map from current-value pointer to flag, fo FindFlagViaPtrLocked(). |
+ typedef map<const void*, CommandLineFlag*> FlagPtrMap; |
+ FlagPtrMap flags_by_ptr_; |
+ |
+#if defined(HAVE_PTHREAD) |
+ pthread_mutex_t lock_; |
+#elif defined(HAVE_INITIALIZECRITICALSECTION) |
+ CRITICAL_SECTION lock_; |
+#else |
+#error "Need to define a mutual-exclusion object for your system" |
+#endif |
+ |
+ static FlagRegistry* global_registry_; // a singleton registry |
+ |
+ // If global_registry_ has not yet been initialized, this function allocates |
+ // a new global registry. If InterlockedCompareExchange() is available, it |
+ // does so in a thread-safe manner; otherwise, single-threaded execution (or |
+ // serialization using pthread_once) is assumed. |
+ static void InitGlobalRegistry(); |
+ |
+ // Disallow |
+ FlagRegistry(const FlagRegistry&); |
+ FlagRegistry& operator=(const FlagRegistry&); |
+}; |
+ |
+#if defined(HAVE_PTHREAD) |
+// The pthread.h header is available. The pthreads library may or may not be |
+// linked in with -lpthread. If that library is not linked in, then it is |
+// assumed that all operations involving command-line flags will be |
+// single-threaded. |
+ |
+#define SAFE_PTHREAD(fncall) do { if ((fncall) != 0) abort(); } while (0) |
+ |
+inline FlagRegistry::FlagRegistry() { |
+ SAFE_PTHREAD(pthread_mutex_init(&lock_, NULL)); |
+} |
+inline FlagRegistry::~FlagRegistry() { |
+ SAFE_PTHREAD(pthread_mutex_destroy(&lock_)); |
+} |
+ |
+inline void FlagRegistry::Lock() { |
+ SAFE_PTHREAD(pthread_mutex_lock(&lock_)); |
+} |
+inline void FlagRegistry::Unlock() { |
+ SAFE_PTHREAD(pthread_mutex_unlock(&lock_)); |
+} |
+ |
+// We want to use pthread_once here, for safety, but have to worry about |
+// whether libpthread is linked in or not. We declare a weak version of |
+// the function, so we'll always compile (if the weak version is the only |
+// one that ends up existing, then pthread_once will be equal to NULL). |
+#ifdef HAVE___ATTRIBUTE__ |
+ // __THROW is defined in glibc systems. It means, counter-intuitively, |
+ // "This function will never throw an exception." It's an optional |
+ // optimization tool, but we may need to use it to match glibc prototypes. |
+# ifndef __THROW // I guess we're not on a glibc system |
+# define __THROW // __THROW is just an optimization, so ok to make it "" |
+# endif |
+extern "C" int pthread_once(pthread_once_t *, void (*)(void)) |
+ __THROW __attribute__((weak)); |
+#endif |
+ |
+FlagRegistry* FlagRegistry::GlobalRegistry() { |
+ if (pthread_once) { // means we're linked with -lpthread |
+ static pthread_once_t global_registry_once = PTHREAD_ONCE_INIT; |
+ pthread_once(&global_registry_once, &InitGlobalRegistry); |
+ } else { |
+ // Assume single-threaded execution. |
+ InitGlobalRegistry(); |
+ } |
+ return global_registry_; |
+} |
+ |
+#elif defined(HAVE_INITIALIZECRITICALSECTION) |
+// The Windows version of the thread-safe code uses EnterCriticalSection and |
+// LeaveCriticalSection to serialize access to the registry. |
+ |
+#ifndef HAVE_INTERLOCKEDCOMPAREEXCHANGE |
+// InitializeCriticalSection is available, but InterlockedCompareExchange |
+// is not. On a Windows system both should be available, and on Unix, neither |
+// one should be available. |
+#error "Please check settings for HAVE_INTERLOCKED... and HAVE_INITIALIZE..." |
+#endif // !HAVE_INTERLOCKEDCOMPAREEXCHANGE |
+ |
+inline FlagRegistry::FlagRegistry() { InitializeCriticalSection(&lock_); } |
+inline FlagRegistry::~FlagRegistry() { DeleteCriticalSection(&lock_); } |
+ |
+inline void FlagRegistry::Lock() { EnterCriticalSection(&lock_); } |
+inline void FlagRegistry::Unlock() { LeaveCriticalSection(&lock_); } |
+ |
+FlagRegistry* FlagRegistry::GlobalRegistry() { |
+ InitGlobalRegistry(); |
+ return global_registry_; |
+} |
+#endif // !HAVE_PTHREAD && HAVE_INITIALIZECRITICALSECTION |
+ |
+// Get the singleton FlagRegistry object |
+FlagRegistry* FlagRegistry::global_registry_ = NULL; |
+ |
+void FlagRegistry::InitGlobalRegistry() { |
+ if (!global_registry_) { |
+#ifdef HAVE_INTERLOCKEDCOMPAREEXCHANGE |
+ FlagRegistry* new_global_registry = new FlagRegistry; |
+ if (InterlockedCompareExchangePointer( |
+ reinterpret_cast<void* volatile *>(&global_registry_), |
+ new_global_registry, |
+ NULL) != NULL) { |
+ // Some other thread initialized global_registry_ first. |
+ delete new_global_registry; |
+ } |
+#else // !HAVE_INTERLOCKEDCOMPAREEXCHANGE |
+ // Assume single-threaded execution, or else that this function call was |
+ // serialized using pthread_once. |
+ global_registry_ = new FlagRegistry; |
+#endif // HAVE_INTERLOCKEDCOMPAREEXCHANGE |
+ } |
+} |
+ |
+void FlagRegistry::RegisterFlag(CommandLineFlag* flag) { |
+ Lock(); |
+ pair<FlagIterator, bool> ins = |
+ flags_.insert(pair<const char*, CommandLineFlag*>(flag->name(), flag)); |
+ if (ins.second == false) { // means the name was already in the map |
+ if (strcmp(ins.first->second->filename(), flag->filename()) != 0) { |
+ fprintf(stderr, |
+ "ERROR: flag '%s' was defined more than once " |
+ "(in files '%s' and '%s').\n", |
+ flag->name(), |
+ ins.first->second->filename(), |
+ flag->filename()); |
+ } else { |
+ fprintf(stderr, |
+ "ERROR: something wrong with flag '%s' in file '%s'. " |
+ "One possibility: file '%s' is being linked both statically " |
+ "and dynamically into this executable.\n", |
+ flag->name(), |
+ flag->filename(), flag->filename()); |
+ } |
+ commandlineflags_exitfunc(1); // almost certainly exit() |
+ } |
+ // Also add to the flags_by_ptr_ map. |
+ flags_by_ptr_[flag->current_->value_buffer_] = flag; |
+ Unlock(); |
+} |
+ |
+CommandLineFlag* FlagRegistry::FindFlagLocked(const char* name) { |
+ FlagConstIterator i = flags_.find(name); |
+ if (i == flags_.end()) { |
+ return NULL; |
+ } else { |
+ return i->second; |
+ } |
+} |
+ |
+CommandLineFlag* FlagRegistry::FindFlagViaPtrLocked(const void* flag_ptr) { |
+ FlagPtrMap::const_iterator i = flags_by_ptr_.find(flag_ptr); |
+ if (i == flags_by_ptr_.end()) { |
+ return NULL; |
+ } else { |
+ return i->second; |
+ } |
+} |
+ |
+CommandLineFlag* FlagRegistry::SplitArgumentLocked(const char* arg, |
+ string* key, |
+ const char** v, |
+ string* error_message) { |
+ // Find the flag object for this option |
+ const char* flag_name; |
+ const char* value = strchr(arg, '='); |
+ if (value == NULL) { |
+ key->assign(arg); |
+ *v = NULL; |
+ } else { |
+ // Strip out the "=value" portion from arg |
+ key->assign(arg, value-arg); |
+ *v = ++value; // advance past the '=' |
+ } |
+ flag_name = key->c_str(); |
+ |
+ CommandLineFlag* flag = FindFlagLocked(flag_name); |
+ |
+ if (flag == NULL) { |
+ // If we can't find the flag-name, then we should return an error. |
+ // The one exception is if 1) the flag-name is 'nox', 2) there |
+ // exists a flag named 'x', and 3) 'x' is a boolean flag. |
+ // In that case, we want to return flag 'x'. |
+ if (!(flag_name[0] == 'n' && flag_name[1] == 'o')) { |
+ // flag-name is not 'nox', so we're not in the exception case. |
+ *error_message = (string(kError) + |
+ "unknown command line flag '" + *key + "'\n"); |
+ return NULL; |
+ } |
+ flag = FindFlagLocked(flag_name+2); |
+ if (flag == NULL) { |
+ // No flag named 'x' exists, so we're not in the exception case. |
+ *error_message = (string(kError) + |
+ "unknown command line flag '" + *key + "'\n"); |
+ return NULL; |
+ } |
+ if (strcmp(flag->type_name(), "bool") != 0) { |
+ // 'x' exists but is not boolean, so we're not in the exception case. |
+ *error_message = (string(kError) + |
+ "boolean value (" + *key + ") specified for " + |
+ flag->type_name() + " command line flag\n"); |
+ return NULL; |
+ } |
+ // We're in the exception case! |
+ // Make up a fake value to replace the "no" we stripped out |
+ key->assign(flag_name+2); // the name without the "no" |
+ *v = "0"; |
+ } |
+ |
+ // Assign a value if this is a boolean flag |
+ if (*v == NULL && strcmp(flag->type_name(), "bool") == 0) { |
+ *v = "1"; // the --nox case was already handled, so this is the --x case |
+ } |
+ |
+ return flag; |
+} |
+ |
+bool TryParseLocked(const CommandLineFlag* flag, FlagValue* flag_value, |
+ const char* value, string* msg) { |
+ // Use tenative_value, not flag_value, until we know value is valid. |
+ FlagValue* tentative_value = flag_value->New(); |
+ if (!tentative_value->ParseFrom(value)) { |
+ if (msg) { |
+ *msg += (string(kError) + "illegal value '" + value + |
+ + "' specified for " + flag->type_name() + " flag '" |
+ + flag->name() + "'\n"); |
+ } |
+ delete tentative_value; |
+ return false; |
+ } else if (!flag->Validate(*tentative_value)) { |
+ if (msg) { |
+ *msg += (string(kError) + "failed validation of new value " |
+ + "'" + tentative_value->ToString() + "' for flag '" + |
+ + flag->name() + "'\n"); |
+ } |
+ delete tentative_value; |
+ return false; |
+ } else { |
+ flag_value->CopyFrom(*tentative_value); |
+ if (msg) { |
+ *msg += (string(flag->name()) + " set to " + flag_value->ToString() |
+ + "\n"); |
+ } |
+ delete tentative_value; |
+ return true; |
+ } |
+} |
+ |
+bool FlagRegistry::SetFlagLocked(CommandLineFlag* flag, |
+ const char* value, |
+ FlagSettingMode set_mode, |
+ string* msg) { |
+ flag->UpdateModifiedBit(); |
+ switch (set_mode) { |
+ case SET_FLAGS_VALUE: { |
+ // set or modify the flag's value |
+ if (!TryParseLocked(flag, flag->current_, value, msg)) |
+ return false; |
+ flag->modified_ = true; |
+ break; |
+ } |
+ case SET_FLAG_IF_DEFAULT: { |
+ // set the flag's value, but only if it hasn't been set by someone else |
+ if (!flag->modified_) { |
+ if (!TryParseLocked(flag, flag->current_, value, msg)) |
+ return false; |
+ flag->modified_ = true; |
+ } else { |
+ *msg = string(flag->name()) + " set to " + flag->current_value(); |
+ } |
+ break; |
+ } |
+ case SET_FLAGS_DEFAULT: { |
+ // modify the flag's default-value |
+ if (!TryParseLocked(flag, flag->defvalue_, value, msg)) |
+ return false; |
+ if (!flag->modified_) { |
+ // Need to set both defvalue *and* current, in this case |
+ TryParseLocked(flag, flag->current_, value, NULL); |
+ } |
+ break; |
+ } |
+ default: { |
+ // unknown set_mode |
+ assert(false); |
+ return false; |
+ } |
+ } |
+ |
+ return true; |
+} |
+ |
+class FlagRegistryLock { |
+ public: |
+ explicit FlagRegistryLock(FlagRegistry* fr) : fr_(fr) { fr_->Lock(); } |
+ ~FlagRegistryLock() { fr_->Unlock(); } |
+ private: |
+ FlagRegistry *const fr_; |
+}; |
+ |
+// -------------------------------------------------------------------- |
+// CommandLineFlagParser |
+// Parsing is done in two stages. In the first, we go through |
+// argv. For every flag-like arg we can make sense of, we parse |
+// it and set the appropriate FLAGS_* variable. For every flag- |
+// like arg we can't make sense of, we store it in a vector, |
+// along with an explanation of the trouble. In stage 2, we |
+// handle the 'reporting' flags like --help and --mpm_version. |
+// (This is via a call to HandleCommandLineHelpFlags(), in |
+// gflags_reporting.cc.) |
+// An optional stage 3 prints out the error messages. |
+// This is a bit of a simplification. For instance, --flagfile |
+// is handled as soon as it's seen in stage 1, not in stage 2. |
+// -------------------------------------------------------------------- |
+ |
+class CommandLineFlagParser { |
+ public: |
+ // The argument is the flag-registry to register the parsed flags in |
+ explicit CommandLineFlagParser(FlagRegistry* reg) : registry_(reg) {} |
+ ~CommandLineFlagParser() {} |
+ |
+ // Stage 1: Every time this is called, it reads all flags in argv. |
+ // However, it ignores all flags that have been successfully set |
+ // before. Typically this is only called once, so this 'reparsing' |
+ // behavior isn't important. It can be useful when trying to |
+ // reparse after loading a dll, though. |
+ uint32 ParseNewCommandLineFlags(int* argc, char*** argv, bool remove_flags); |
+ |
+ // Stage 2: print reporting info and exit, if requested. |
+ // In gflags_reporting.cc:HandleCommandLineHelpFlags(). |
+ |
+ // Stage 3: validate all the commandline flags that have validators |
+ // registered. |
+ void ValidateAllFlags(); |
+ |
+ // Stage 4: report any errors and return true if any were found. |
+ bool ReportErrors(); |
+ |
+ // Set a particular command line option. "newval" is a string |
+ // describing the new value that the option has been set to. If |
+ // option_name does not specify a valid option name, or value is not |
+ // a valid value for option_name, newval is empty. Does recursive |
+ // processing for --flagfile and --fromenv. Returns the new value |
+ // if everything went ok, or empty-string if not. (Actually, the |
+ // return-string could hold many flag/value pairs due to --flagfile.) |
+ // NB: Must have called registry_->Lock() before calling this function. |
+ string ProcessSingleOptionLocked(CommandLineFlag* flag, |
+ const char* value, |
+ FlagSettingMode set_mode); |
+ |
+ // Set a whole batch of command line options as specified by contentdata, |
+ // which is in flagfile format (and probably has been read from a flagfile). |
+ // Returns the new value if everything went ok, or empty-string if |
+ // not. (Actually, the return-string could hold many flag/value |
+ // pairs due to --flagfile.) |
+ // NB: Must have called registry_->Lock() before calling this function. |
+ string ProcessOptionsFromStringLocked(const string& contentdata, |
+ FlagSettingMode set_mode); |
+ |
+ // These are the 'recursive' flags, defined at the top of this file. |
+ // Whenever we see these flags on the commandline, we must take action. |
+ // These are called by ProcessSingleOptionLocked and, similarly, return |
+ // new values if everything went ok, or the empty-string if not. |
+ string ProcessFlagfileLocked(const string& flagval, FlagSettingMode set_mode); |
+ // diff fromenv/tryfromenv |
+ string ProcessFromenvLocked(const string& flagval, FlagSettingMode set_mode, |
+ bool errors_are_fatal); |
+ |
+ private: |
+ FlagRegistry* const registry_; |
+ map<string, string> error_flags_; // map from name to error message |
+ // This could be a set<string>, but we reuse the map to minimize the .o size |
+ map<string, string> undefined_names_; // --[flag] name was not registered |
+}; |
+ |
+ |
+// Parse a list of (comma-separated) flags. |
+static void ParseFlagList(const char* value, vector<string>* flags) { |
+ for (const char *p = value; p && *p; value = p) { |
+ p = strchr(value, ','); |
+ int len; |
+ if (p) { |
+ len = static_cast<int>(p - value); |
+ p++; |
+ } else { |
+ len = static_cast<int>(strlen(value)); |
+ } |
+ |
+ if (len == 0) { |
+ fprintf(stderr, "ERROR: empty flaglist entry\n"); |
+ commandlineflags_exitfunc(1); // almost certainly exit() |
+ } |
+ if (value[0] == '-') { |
+ fprintf(stderr, "ERROR: flag \"%*s\" begins with '-'\n", len, value); |
+ commandlineflags_exitfunc(1); |
+ } |
+ |
+ flags->push_back(string(value, len)); |
+ } |
+} |
+ |
+// Snarf an entire file into a C++ string. This is just so that we |
+// can do all the I/O in one place and not worry about it everywhere. |
+// Plus, it's convenient to have the whole file contents at hand. |
+// Adds a newline at the end of the file. |
+#define PFATAL(s) do { perror(s); commandlineflags_exitfunc(1); } while (0) |
+ |
+static string ReadFileIntoString(const char* filename) { |
+ const int kBufSize = 8092; |
+ char buffer[kBufSize]; |
+ string s; |
+ FILE* fp = fopen(filename, "r"); |
+ if (!fp) PFATAL(filename); |
+ size_t n; |
+ while ( (n=fread(buffer, 1, kBufSize, fp)) > 0 ) { |
+ if (ferror(fp)) PFATAL(filename); |
+ s.append(buffer, n); |
+ } |
+ fclose(fp); |
+ return s; |
+} |
+ |
+uint32 CommandLineFlagParser::ParseNewCommandLineFlags(int* argc, char*** argv, |
+ bool remove_flags) { |
+ const char *program_name = strrchr((*argv)[0], PATH_SEPARATOR); // nix path |
+ program_name = (program_name == NULL ? (*argv)[0] : program_name+1); |
+ |
+ int first_nonopt = *argc; // for non-options moved to the end |
+ |
+ registry_->Lock(); |
+ for (int i = 1; i < first_nonopt; i++) { |
+ char* arg = (*argv)[i]; |
+ |
+ // Like getopt(), we permute non-option flags to be at the end. |
+ if (arg[0] != '-' || // must be a program argument |
+ (arg[0] == '-' && arg[1] == '\0')) { // "-" is an argument, not a flag |
+ memmove((*argv) + i, (*argv) + i+1, (*argc - (i+1)) * sizeof((*argv)[i])); |
+ (*argv)[*argc-1] = arg; // we go last |
+ first_nonopt--; // we've been pushed onto the stack |
+ i--; // to undo the i++ in the loop |
+ continue; |
+ } |
+ |
+ if (arg[0] == '-') arg++; // allow leading '-' |
+ if (arg[0] == '-') arg++; // or leading '--' |
+ |
+ // -- alone means what it does for GNU: stop options parsing |
+ if (*arg == '\0') { |
+ first_nonopt = i+1; |
+ break; |
+ } |
+ |
+ // Find the flag object for this option |
+ string key; |
+ const char* value; |
+ string error_message; |
+ CommandLineFlag* flag = registry_->SplitArgumentLocked(arg, &key, &value, |
+ &error_message); |
+ if (flag == NULL) { |
+ undefined_names_[key] = ""; // value isn't actually used |
+ error_flags_[key] = error_message; |
+ continue; |
+ } |
+ |
+ if (value == NULL) { |
+ // Boolean options are always assigned a value by SplitArgumentLocked() |
+ assert(strcmp(flag->type_name(), "bool") != 0); |
+ if (i+1 >= first_nonopt) { |
+ // This flag needs a value, but there is nothing available |
+ error_flags_[key] = (string(kError) + "flag '" + (*argv)[i] + "'" |
+ + " is missing its argument"); |
+ if (flag->help() && flag->help()[0] > '\001') { |
+ // Be useful in case we have a non-stripped description. |
+ error_flags_[key] += string("; flag description: ") + flag->help(); |
+ } |
+ error_flags_[key] += "\n"; |
+ break; // we treat this as an unrecoverable error |
+ } else { |
+ value = (*argv)[++i]; // read next arg for value |
+ } |
+ } |
+ |
+ // TODO(csilvers): only set a flag if we hadn't set it before here |
+ ProcessSingleOptionLocked(flag, value, SET_FLAGS_VALUE); |
+ } |
+ registry_->Unlock(); |
+ |
+ if (remove_flags) { // Fix up argc and argv by removing command line flags |
+ (*argv)[first_nonopt-1] = (*argv)[0]; |
+ (*argv) += (first_nonopt-1); |
+ (*argc) -= (first_nonopt-1); |
+ first_nonopt = 1; // because we still don't count argv[0] |
+ } |
+ |
+ logging_is_probably_set_up = true; // because we've parsed --logdir, etc. |
+ |
+ return first_nonopt; |
+} |
+ |
+string CommandLineFlagParser::ProcessFlagfileLocked(const string& flagval, |
+ FlagSettingMode set_mode) { |
+ if (flagval.empty()) |
+ return ""; |
+ |
+ string msg; |
+ vector<string> filename_list; |
+ ParseFlagList(flagval.c_str(), &filename_list); // take a list of filenames |
+ for (size_t i = 0; i < filename_list.size(); ++i) { |
+ const char* file = filename_list[i].c_str(); |
+ msg += ProcessOptionsFromStringLocked(ReadFileIntoString(file), set_mode); |
+ } |
+ return msg; |
+} |
+ |
+string CommandLineFlagParser::ProcessFromenvLocked(const string& flagval, |
+ FlagSettingMode set_mode, |
+ bool errors_are_fatal) { |
+ if (flagval.empty()) |
+ return ""; |
+ |
+ string msg; |
+ vector<string> flaglist; |
+ ParseFlagList(flagval.c_str(), &flaglist); |
+ |
+ for (size_t i = 0; i < flaglist.size(); ++i) { |
+ const char* flagname = flaglist[i].c_str(); |
+ CommandLineFlag* flag = registry_->FindFlagLocked(flagname); |
+ if (flag == NULL) { |
+ error_flags_[flagname] = (string(kError) + "unknown command line flag" |
+ + " '" + flagname + "'" |
+ + " (via --fromenv or --tryfromenv)\n"); |
+ undefined_names_[flagname] = ""; |
+ continue; |
+ } |
+ |
+ const string envname = string("FLAGS_") + string(flagname); |
+ const char* envval = getenv(envname.c_str()); |
+ if (!envval) { |
+ if (errors_are_fatal) { |
+ error_flags_[flagname] = (string(kError) + envname + |
+ " not found in environment\n"); |
+ } |
+ continue; |
+ } |
+ |
+ // Avoid infinite recursion. |
+ if ((strcmp(envval, "fromenv") == 0) || |
+ (strcmp(envval, "tryfromenv") == 0)) { |
+ error_flags_[flagname] = (string(kError) + "infinite recursion on " + |
+ "environment flag '" + envval + "'\n"); |
+ continue; |
+ } |
+ |
+ msg += ProcessSingleOptionLocked(flag, envval, set_mode); |
+ } |
+ return msg; |
+} |
+ |
+string CommandLineFlagParser::ProcessSingleOptionLocked( |
+ CommandLineFlag* flag, const char* value, FlagSettingMode set_mode) { |
+ string msg; |
+ if (value && !registry_->SetFlagLocked(flag, value, set_mode, &msg)) { |
+ error_flags_[flag->name()] = msg; |
+ return ""; |
+ } |
+ |
+ // The recursive flags, --flagfile and --fromenv and --tryfromenv, |
+ // must be dealt with as soon as they're seen. They will emit |
+ // messages of their own. |
+ if (strcmp(flag->name(), "flagfile") == 0) { |
+ msg += ProcessFlagfileLocked(FLAGS_flagfile, set_mode); |
+ |
+ } else if (strcmp(flag->name(), "fromenv") == 0) { |
+ // last arg indicates envval-not-found is fatal (unlike in --tryfromenv) |
+ msg += ProcessFromenvLocked(FLAGS_fromenv, set_mode, true); |
+ |
+ } else if (strcmp(flag->name(), "tryfromenv") == 0) { |
+ msg += ProcessFromenvLocked(FLAGS_tryfromenv, set_mode, false); |
+ } |
+ |
+ return msg; |
+} |
+ |
+void CommandLineFlagParser::ValidateAllFlags() { |
+ FlagRegistryLock frl(registry_); |
+ for (FlagRegistry::FlagConstIterator i = registry_->flags_.begin(); |
+ i != registry_->flags_.end(); ++i) { |
+ if (!i->second->ValidateCurrent()) { |
+ // only set a message if one isn't already there. (If there's |
+ // an error message, our job is done, even if it's not exactly |
+ // the same error.) |
+ if (error_flags_[i->second->name()].empty()) |
+ error_flags_[i->second->name()] = |
+ string(kError) + "--" + i->second->name() + |
+ " must be set on the commandline" |
+ " (default value fails validation)\n"; |
+ } |
+ } |
+} |
+ |
+bool CommandLineFlagParser::ReportErrors() { |
+ // error_flags_ indicates errors we saw while parsing. |
+ // But we ignore undefined-names if ok'ed by --undef_ok |
+ if (!FLAGS_undefok.empty()) { |
+ vector<string> flaglist; |
+ ParseFlagList(FLAGS_undefok.c_str(), &flaglist); |
+ for (size_t i = 0; i < flaglist.size(); ++i) |
+ if (undefined_names_.find(flaglist[i]) != undefined_names_.end()) { |
+ error_flags_[flaglist[i]] = ""; // clear the error message |
+ } |
+ } |
+ // Likewise, if they decided to allow reparsing, all undefined-names |
+ // are ok; we just silently ignore them now, and hope that a future |
+ // parse will pick them up somehow. |
+ if (allow_command_line_reparsing) { |
+ for (map<string, string>::const_iterator it = undefined_names_.begin(); |
+ it != undefined_names_.end(); ++it) |
+ error_flags_[it->first] = ""; // clear the error message |
+ } |
+ |
+ bool found_error = false; |
+ for (map<string, string>::const_iterator it = error_flags_.begin(); |
+ it != error_flags_.end(); ++it) { |
+ if (!it->second.empty()) { |
+ fprintf(stderr, "%s", it->second.c_str()); |
+ found_error = true; |
+ } |
+ } |
+ return found_error; |
+} |
+ |
+string CommandLineFlagParser::ProcessOptionsFromStringLocked( |
+ const string& contentdata, FlagSettingMode set_mode) { |
+ string retval; |
+ const char* flagfile_contents = contentdata.c_str(); |
+ bool flags_are_relevant = true; // set to false when filenames don't match |
+ bool in_filename_section = false; |
+ |
+ const char* line_end = flagfile_contents; |
+ // We read this file a line at a time. |
+ for (; line_end; flagfile_contents = line_end + 1) { |
+ while (*flagfile_contents && isspace(*flagfile_contents)) |
+ ++flagfile_contents; |
+ line_end = strchr(flagfile_contents, '\n'); |
+ size_t len = line_end ? static_cast<size_t>(line_end - flagfile_contents) |
+ : strlen(flagfile_contents); |
+ string line(flagfile_contents, len); |
+ |
+ // Each line can be one of four things: |
+ // 1) A comment line -- we skip it |
+ // 2) An empty line -- we skip it |
+ // 3) A list of filenames -- starts a new filenames+flags section |
+ // 4) A --flag=value line -- apply if previous filenames match |
+ if (line.empty() || line[0] == '#') { |
+ // comment or empty line; just ignore |
+ |
+ } else if (line[0] == '-') { // flag |
+ in_filename_section = false; // instead, it was a flag-line |
+ if (!flags_are_relevant) // skip this flag; applies to someone else |
+ continue; |
+ |
+ const char* name_and_val = line.c_str() + 1; // skip the leading - |
+ if (*name_and_val == '-') |
+ name_and_val++; // skip second - too |
+ string key; |
+ const char* value; |
+ string error_message; |
+ CommandLineFlag* flag = registry_->SplitArgumentLocked(name_and_val, |
+ &key, &value, |
+ &error_message); |
+ // By API, errors parsing flagfile lines are silently ignored. |
+ if (flag == NULL) { |
+ // "WARNING: flagname '" + key + "' not found\n" |
+ } else if (value == NULL) { |
+ // "WARNING: flagname '" + key + "' missing a value\n" |
+ } else { |
+ retval += ProcessSingleOptionLocked(flag, value, set_mode); |
+ } |
+ |
+ } else { // a filename! |
+ if (!in_filename_section) { // start over: assume filenames don't match |
+ in_filename_section = true; |
+ flags_are_relevant = false; |
+ } |
+ |
+ // Split the line up at spaces into glob-patterns |
+ const char* space = line.c_str(); // just has to be non-NULL |
+ for (const char* word = line.c_str(); *space; word = space+1) { |
+ if (flags_are_relevant) // we can stop as soon as we match |
+ break; |
+ space = strchr(word, ' '); |
+ if (space == NULL) |
+ space = word + strlen(word); |
+ const string glob(word, space - word); |
+ // We try matching both against the full argv0 and basename(argv0) |
+#ifdef HAVE_FNMATCH_H |
+ if (fnmatch(glob.c_str(), |
+ ProgramInvocationName(), |
+ FNM_PATHNAME) == 0 || |
+ fnmatch(glob.c_str(), |
+ ProgramInvocationShortName(), |
+ FNM_PATHNAME) == 0) { |
+#else // !HAVE_FNMATCH_H |
+ if ((glob == ProgramInvocationName()) || |
+ (glob == ProgramInvocationShortName())) { |
+#endif // HAVE_FNMATCH_H |
+ flags_are_relevant = true; |
+ } |
+ } |
+ } |
+ } |
+ return retval; |
+} |
+ |
+// -------------------------------------------------------------------- |
+// GetFromEnv() |
+// AddFlagValidator() |
+// These are helper functions for routines like BoolFromEnv() and |
+// RegisterFlagValidator, defined below. They're defined here so |
+// they can live in the unnamed namespace (which makes friendship |
+// declarations for these classes possible). |
+// -------------------------------------------------------------------- |
+ |
+template<typename T> |
+T GetFromEnv(const char *varname, const char* type, T dflt) { |
+ const char* const valstr = getenv(varname); |
+ if (!valstr) |
+ return dflt; |
+ FlagValue ifv(new T, type); |
+ if (!ifv.ParseFrom(valstr)) { |
+ fprintf(stderr, "ERROR: error parsing env variable '%s' with value '%s'\n", |
+ varname, valstr); |
+ commandlineflags_exitfunc(1); |
+ } |
+ return OTHER_VALUE_AS(ifv, T); |
+} |
+ |
+bool AddFlagValidator(const void* flag_ptr, ValidateFnProto validate_fn_proto) { |
+ // We want a lock around this routine, in case two threads try to |
+ // add a validator (hopefully the same one!) at once. We could use |
+ // our own thread, but we need to loook at the registry anyway, so |
+ // we just steal that one. |
+ FlagRegistry* const registry = FlagRegistry::GlobalRegistry(); |
+ FlagRegistryLock frl(registry); |
+ // First, find the flag whose current-flag storage is 'flag'. |
+ // This is the CommandLineFlag whose current_->value_buffer_ == flag |
+ CommandLineFlag* flag = registry->FindFlagViaPtrLocked(flag_ptr); |
+ if (!flag) { |
+ // WARNING << "Ignoring RegisterValidateFunction() for flag pointer " |
+ // << flag_ptr << ": no flag found at that address"; |
+ return false; |
+ } else if (validate_fn_proto == flag->validate_function()) { |
+ return true; // ok to register the same function over and over again |
+ } else if (validate_fn_proto != NULL && flag->validate_function() != NULL) { |
+ // WARNING << "Ignoring RegisterValidateFunction() for flag '" |
+ // << flag->name() << "': validate-fn already registered"; |
+ return false; |
+ } else { |
+ flag->validate_fn_proto_ = validate_fn_proto; |
+ return true; |
+ } |
+} |
+ |
+} // end unnamed namespaces |
+ |
+ |
+// Now define the functions that are exported via the .h file |
+ |
+// -------------------------------------------------------------------- |
+// FlagRegisterer |
+// This class exists merely to have a global constructor (the |
+// kind that runs before main(), that goes an initializes each |
+// flag that's been declared. Note that it's very important we |
+// don't have a destructor that deletes flag_, because that would |
+// cause us to delete current_storage/defvalue_storage as well, |
+// which can cause a crash if anything tries to access the flag |
+// values in a global destructor. |
+// -------------------------------------------------------------------- |
+ |
+// TODO(csilvers): When we're ready to have this error be a fatal one, |
+// change this to give a compilation error (via COMPILE_ASSERT(false)). |
+bool FlagsTypeWarn(const char *name) { |
+ cerr << "Flag " << name << " is of type bool, but its default" |
+ << " value is not a boolean. NOTE: This will soon be a" |
+ << " compilations error!"; |
+ return false; |
+} |
+ |
+FlagRegisterer::FlagRegisterer(const char* name, const char* type, |
+ const char* help, const char* filename, |
+ void* current_storage, void* defvalue_storage) { |
+ if (help == NULL) |
+ help = ""; |
+ // FlagValue expects the type-name to not include any namespace |
+ // components, so we get rid of those, if any. |
+ if (strchr(type, ':')) |
+ type = strrchr(type, ':') + 1; |
+ FlagValue* current = new FlagValue(current_storage, type); |
+ FlagValue* defvalue = new FlagValue(defvalue_storage, type); |
+ // Importantly, flag_ will never be deleted, so storage is always good. |
+ CommandLineFlag* flag = new CommandLineFlag(name, help, filename, |
+ current, defvalue); |
+ FlagRegistry::GlobalRegistry()->RegisterFlag(flag); // default registry |
+} |
+ |
+// -------------------------------------------------------------------- |
+// GetAllFlags() |
+// The main way the FlagRegistry class exposes its data. This |
+// returns, as strings, all the info about all the flags in |
+// the main registry, sorted first by filename they are defined |
+// in, and then by flagname. |
+// -------------------------------------------------------------------- |
+ |
+struct FilenameFlagnameCmp { |
+ bool operator()(const CommandLineFlagInfo& a, |
+ const CommandLineFlagInfo& b) const { |
+ int cmp = strcmp(a.filename.c_str(), b.filename.c_str()); |
+ if (cmp == 0) |
+ cmp = strcmp(a.name.c_str(), b.name.c_str()); // secondary sort key |
+ return cmp < 0; |
+ } |
+}; |
+ |
+void GetAllFlags(vector<CommandLineFlagInfo>* OUTPUT) { |
+ FlagRegistry* const registry = FlagRegistry::GlobalRegistry(); |
+ registry->Lock(); |
+ for (FlagRegistry::FlagConstIterator i = registry->flags_.begin(); |
+ i != registry->flags_.end(); ++i) { |
+ CommandLineFlagInfo fi; |
+ i->second->FillCommandLineFlagInfo(&fi); |
+ OUTPUT->push_back(fi); |
+ } |
+ registry->Unlock(); |
+ // Now sort the flags, first by filename they occur in, then alphabetically |
+ sort(OUTPUT->begin(), OUTPUT->end(), FilenameFlagnameCmp()); |
+} |
+ |
+// -------------------------------------------------------------------- |
+// SetArgv() |
+// GetArgvs() |
+// GetArgv() |
+// GetArgv0() |
+// ProgramInvocationName() |
+// ProgramInvocationShortName() |
+// SetUsageMessage() |
+// ProgramUsage() |
+// Functions to set and get argv. Typically the setter is called |
+// by ParseCommandLineFlags. Also can get the ProgramUsage string, |
+// set by SetUsageMessage. |
+// -------------------------------------------------------------------- |
+ |
+// These values are not protected by a Mutex because they are normally |
+// set only once during program startup. |
+static const char* argv0 = "UNKNOWN"; // just the program name |
+static const char* cmdline = ""; // the entire command-line |
+static vector<string> argvs; |
+static uint32 argv_sum = 0; |
+static const char* program_usage = NULL; |
+ |
+void SetArgv(int argc, const char** argv) { |
+ static bool called_set_argv = false; |
+ if (called_set_argv) // we already have an argv for you |
+ return; |
+ |
+ called_set_argv = true; |
+ |
+ assert(argc > 0); // every program has at least a progname |
+ argv0 = strdup(argv[0]); // small memory leak, but fn only called once |
+ assert(argv0); |
+ |
+ string cmdline_string; // easier than doing strcats |
+ for (int i = 0; i < argc; i++) { |
+ if (i != 0) { |
+ cmdline_string += " "; |
+ } |
+ cmdline_string += argv[i]; |
+ argvs.push_back(argv[i]); |
+ } |
+ cmdline = strdup(cmdline_string.c_str()); // another small memory leak |
+ assert(cmdline); |
+ |
+ // Compute a simple sum of all the chars in argv |
+ for (const char* c = cmdline; *c; c++) |
+ argv_sum += *c; |
+} |
+ |
+const vector<string>& GetArgvs() { return argvs; } |
+const char* GetArgv() { return cmdline; } |
+const char* GetArgv0() { return argv0; } |
+uint32 GetArgvSum() { return argv_sum; } |
+const char* ProgramInvocationName() { // like the GNU libc fn |
+ return GetArgv0(); |
+} |
+const char* ProgramInvocationShortName() { // like the GNU libc fn |
+ const char* slash = strrchr(argv0, '/'); |
+#ifdef OS_WINDOWS |
+ if (!slash) slash = strrchr(argv0, '\\'); |
+#endif |
+ return slash ? slash + 1 : argv0; |
+} |
+ |
+void SetUsageMessage(const string& usage) { |
+ if (program_usage != NULL) { |
+ fprintf(stderr, "ERROR: SetUsageMessage() called twice\n"); |
+ exit(1); |
+ } |
+ program_usage = strdup(usage.c_str()); // small memory leak |
+} |
+ |
+const char* ProgramUsage() { |
+ if (program_usage) { |
+ return program_usage; |
+ } |
+ return "Warning: SetUsageMessage() never called"; |
+} |
+ |
+// -------------------------------------------------------------------- |
+// GetCommandLineOption() |
+// GetCommandLineFlagInfo() |
+// GetCommandLineFlagInfoOrDie() |
+// SetCommandLineOption() |
+// SetCommandLineOptionWithMode() |
+// The programmatic way to set a flag's value, using a string |
+// for its name rather than the variable itself (that is, |
+// SetCommandLineOption("foo", x) rather than FLAGS_foo = x). |
+// There's also a bit more flexibility here due to the various |
+// set-modes, but typically these are used when you only have |
+// that flag's name as a string, perhaps at runtime. |
+// All of these work on the default, global registry. |
+// For GetCommandLineOption, return false if no such flag |
+// is known, true otherwise. We clear "value" if a suitable |
+// flag is found. |
+// -------------------------------------------------------------------- |
+ |
+ |
+bool GetCommandLineOption(const char* name, string* value) { |
+ if (NULL == name) |
+ return false; |
+ assert(value); |
+ |
+ FlagRegistry* const registry = FlagRegistry::GlobalRegistry(); |
+ FlagRegistryLock frl(registry); |
+ CommandLineFlag* flag = registry->FindFlagLocked(name); |
+ if (flag == NULL) { |
+ return false; |
+ } else { |
+ *value = flag->current_value(); |
+ return true; |
+ } |
+} |
+ |
+bool GetCommandLineFlagInfo(const char* name, CommandLineFlagInfo* OUTPUT) { |
+ if (NULL == name) return false; |
+ FlagRegistry* const registry = FlagRegistry::GlobalRegistry(); |
+ FlagRegistryLock frl(registry); |
+ CommandLineFlag* flag = registry->FindFlagLocked(name); |
+ if (flag == NULL) { |
+ return false; |
+ } else { |
+ assert(OUTPUT); |
+ flag->FillCommandLineFlagInfo(OUTPUT); |
+ return true; |
+ } |
+} |
+ |
+CommandLineFlagInfo GetCommandLineFlagInfoOrDie(const char* name) { |
+ CommandLineFlagInfo info; |
+ if (!GetCommandLineFlagInfo(name, &info)) { |
+ fprintf(stderr, "FATAL ERROR: flag name '%s' doesn't exit", name); |
+ commandlineflags_exitfunc(1); // almost certainly exit() |
+ } |
+ return info; |
+} |
+ |
+string SetCommandLineOptionWithMode(const char* name, const char* value, |
+ FlagSettingMode set_mode) { |
+ string result; |
+ FlagRegistry* const registry = FlagRegistry::GlobalRegistry(); |
+ FlagRegistryLock frl(registry); |
+ CommandLineFlag* flag = registry->FindFlagLocked(name); |
+ if (flag) { |
+ CommandLineFlagParser parser(registry); |
+ result = parser.ProcessSingleOptionLocked(flag, value, set_mode); |
+ if (!result.empty()) { // in the error case, we've already logged |
+ // You could consider logging this change, if you wanted to know it: |
+ //fprintf(stderr, "%sFLAGS_%s\n", |
+ // (set_mode == SET_FLAGS_DEFAULT ? "default value of " : ""), |
+ // result); |
+ } |
+ } |
+ // The API of this function is that we return empty string on error |
+ return result; |
+} |
+ |
+string SetCommandLineOption(const char* name, const char* value) { |
+ return SetCommandLineOptionWithMode(name, value, SET_FLAGS_VALUE); |
+} |
+ |
+// -------------------------------------------------------------------- |
+// FlagSaver |
+// FlagSaverImpl |
+// This class stores the states of all flags at construct time, |
+// and restores all flags to that state at destruct time. |
+// Its major implementation challenge is that it never modifies |
+// pointers in the 'main' registry, so global FLAG_* vars always |
+// point to the right place. |
+// -------------------------------------------------------------------- |
+ |
+class FlagSaverImpl { |
+ public: |
+ // Constructs an empty FlagSaverImpl object. |
+ explicit FlagSaverImpl(FlagRegistry* main_registry) |
+ : main_registry_(main_registry) { } |
+ ~FlagSaverImpl() { |
+ // reclaim memory from each of our CommandLineFlags |
+ vector<CommandLineFlag*>::const_iterator it; |
+ for (it = backup_registry_.begin(); it != backup_registry_.end(); ++it) |
+ delete *it; |
+ } |
+ |
+ // Saves the flag states from the flag registry into this object. |
+ // It's an error to call this more than once. |
+ // Must be called when the registry mutex is not held. |
+ void SaveFromRegistry() { |
+ FlagRegistryLock frl(main_registry_); |
+ assert(backup_registry_.empty()); // call only once! |
+ for (FlagRegistry::FlagConstIterator it = main_registry_->flags_.begin(); |
+ it != main_registry_->flags_.end(); |
+ ++it) { |
+ const CommandLineFlag* main = it->second; |
+ // Sets up all the const variables in backup correctly |
+ CommandLineFlag* backup = new CommandLineFlag( |
+ main->name(), main->help(), main->filename(), |
+ main->current_->New(), main->defvalue_->New()); |
+ // Sets up all the non-const variables in backup correctly |
+ backup->CopyFrom(*main); |
+ backup_registry_.push_back(backup); // add it to a convenient list |
+ } |
+ } |
+ |
+ // Restores the saved flag states into the flag registry. We |
+ // assume no flags were added or deleted from the registry since |
+ // the SaveFromRegistry; if they were, that's trouble! Must be |
+ // called when the registry mutex is not held. |
+ void RestoreToRegistry() { |
+ FlagRegistryLock frl(main_registry_); |
+ vector<CommandLineFlag*>::const_iterator it; |
+ for (it = backup_registry_.begin(); it != backup_registry_.end(); ++it) { |
+ CommandLineFlag* main = main_registry_->FindFlagLocked((*it)->name()); |
+ if (main != NULL) { // if NULL, flag got deleted from registry(!) |
+ main->CopyFrom(**it); |
+ } |
+ } |
+ } |
+ |
+ private: |
+ FlagRegistry* const main_registry_; |
+ vector<CommandLineFlag*> backup_registry_; |
+ |
+ FlagSaverImpl(const FlagSaverImpl&); // no copying! |
+ void operator=(const FlagSaverImpl&); |
+}; |
+ |
+FlagSaver::FlagSaver() |
+ : impl_(new FlagSaverImpl(FlagRegistry::GlobalRegistry())) { |
+ impl_->SaveFromRegistry(); |
+} |
+ |
+FlagSaver::~FlagSaver() { |
+ impl_->RestoreToRegistry(); |
+ delete impl_; |
+} |
+ |
+ |
+// -------------------------------------------------------------------- |
+// CommandlineFlagsIntoString() |
+// ReadFlagsFromString() |
+// AppendFlagsIntoFile() |
+// ReadFromFlagsFile() |
+// These are mostly-deprecated routines that stick the |
+// commandline flags into a file/string and read them back |
+// out again. I can see a use for CommandlineFlagsIntoString, |
+// for creating a flagfile, but the rest don't seem that useful |
+// -- some, I think, are a poor-man's attempt at FlagSaver -- |
+// and are included only until we can delete them from callers. |
+// Note they don't save --flagfile flags (though they do save |
+// the result of having called the flagfile, of course). |
+// -------------------------------------------------------------------- |
+ |
+static string TheseCommandlineFlagsIntoString( |
+ const vector<CommandLineFlagInfo>& flags) { |
+ vector<CommandLineFlagInfo>::const_iterator i; |
+ |
+ size_t retval_space = 0; |
+ for (i = flags.begin(); i != flags.end(); ++i) { |
+ // An (over)estimate of how much space it will take to print this flag |
+ retval_space += i->name.length() + i->current_value.length() + 5; |
+ } |
+ |
+ string retval; |
+ retval.reserve(retval_space); |
+ for (i = flags.begin(); i != flags.end(); ++i) { |
+ retval += "--"; |
+ retval += i->name; |
+ retval += "="; |
+ retval += i->current_value; |
+ retval += "\n"; |
+ } |
+ return retval; |
+} |
+ |
+string CommandlineFlagsIntoString() { |
+ vector<CommandLineFlagInfo> sorted_flags; |
+ GetAllFlags(&sorted_flags); |
+ return TheseCommandlineFlagsIntoString(sorted_flags); |
+} |
+ |
+bool ReadFlagsFromString(const string& flagfilecontents, |
+ const char* /*prog_name*/, // TODO(csilvers): nix this |
+ bool errors_are_fatal) { |
+ FlagRegistry* const registry = FlagRegistry::GlobalRegistry(); |
+ FlagSaverImpl saved_states(registry); |
+ saved_states.SaveFromRegistry(); |
+ |
+ CommandLineFlagParser parser(registry); |
+ registry->Lock(); |
+ parser.ProcessOptionsFromStringLocked(flagfilecontents, SET_FLAGS_VALUE); |
+ registry->Unlock(); |
+ // Should we handle --help and such when reading flags from a string? Sure. |
+ HandleCommandLineHelpFlags(); |
+ if (parser.ReportErrors()) { |
+ // Error. Restore all global flags to their previous values. |
+ if (errors_are_fatal) |
+ commandlineflags_exitfunc(1); // almost certainly exit() |
+ saved_states.RestoreToRegistry(); |
+ return false; |
+ } |
+ return true; |
+} |
+ |
+// TODO(csilvers): nix prog_name in favor of ProgramInvocationShortName() |
+bool AppendFlagsIntoFile(const string& filename, const char *prog_name) { |
+ FILE *fp = fopen(filename.c_str(), "a"); |
+ if (!fp) { |
+ return false; |
+ } |
+ |
+ if (prog_name) |
+ fprintf(fp, "%s\n", prog_name); |
+ |
+ vector<CommandLineFlagInfo> flags; |
+ GetAllFlags(&flags); |
+ // But we don't want --flagfile, which leads to weird recursion issues |
+ vector<CommandLineFlagInfo>::iterator i; |
+ for (i = flags.begin(); i != flags.end(); ++i) { |
+ if (strcmp(i->name.c_str(), "flagfile") == 0) { |
+ flags.erase(i); |
+ break; |
+ } |
+ } |
+ fprintf(fp, "%s", TheseCommandlineFlagsIntoString(flags).c_str()); |
+ |
+ fclose(fp); |
+ return true; |
+} |
+ |
+bool ReadFromFlagsFile(const string& filename, const char* prog_name, |
+ bool errors_are_fatal) { |
+ return ReadFlagsFromString(ReadFileIntoString(filename.c_str()), |
+ prog_name, errors_are_fatal); |
+} |
+ |
+ |
+// -------------------------------------------------------------------- |
+// BoolFromEnv() |
+// Int32FromEnv() |
+// Int64FromEnv() |
+// Uint64FromEnv() |
+// DoubleFromEnv() |
+// StringFromEnv() |
+// Reads the value from the environment and returns it. |
+// We use an FlagValue to make the parsing easy. |
+// Example usage: |
+// DEFINE_bool(myflag, BoolFromEnv("MYFLAG_DEFAULT", false), "whatever"); |
+// -------------------------------------------------------------------- |
+ |
+bool BoolFromEnv(const char *v, bool dflt) { |
+ return GetFromEnv(v, "bool", dflt); |
+} |
+int32 Int32FromEnv(const char *v, int32 dflt) { |
+ return GetFromEnv(v, "int32", dflt); |
+} |
+int64 Int64FromEnv(const char *v, int64 dflt) { |
+ return GetFromEnv(v, "int64", dflt); |
+} |
+uint64 Uint64FromEnv(const char *v, uint64 dflt) { |
+ return GetFromEnv(v, "uint64", dflt); |
+} |
+double DoubleFromEnv(const char *v, double dflt) { |
+ return GetFromEnv(v, "double", dflt); |
+} |
+const char *StringFromEnv(const char *varname, const char *dflt) { |
+ const char* const val = getenv(varname); |
+ return val ? val : dflt; |
+} |
+ |
+ |
+// -------------------------------------------------------------------- |
+// RegisterFlagValidator() |
+// RegisterFlagValidator() is the function that clients use to |
+// 'decorate' a flag with a validation function. Once this is |
+// done, every time the flag is set (including when the flag |
+// is parsed from argv), the validator-function is called. |
+// These functions return true if the validator was added |
+// successfully, or false if not: the flag already has a validator, |
+// (only one allowed per flag), the 1st arg isn't a flag, etc. |
+// This function is not thread-safe. |
+// -------------------------------------------------------------------- |
+ |
+bool RegisterFlagValidator(const bool* flag, |
+ bool (*validate_fn)(const char*, bool)) { |
+ return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn)); |
+} |
+bool RegisterFlagValidator(const int32* flag, |
+ bool (*validate_fn)(const char*, int32)) { |
+ return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn)); |
+} |
+bool RegisterFlagValidator(const int64* flag, |
+ bool (*validate_fn)(const char*, int64)) { |
+ return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn)); |
+} |
+bool RegisterFlagValidator(const uint64* flag, |
+ bool (*validate_fn)(const char*, uint64)) { |
+ return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn)); |
+} |
+bool RegisterFlagValidator(const double* flag, |
+ bool (*validate_fn)(const char*, double)) { |
+ return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn)); |
+} |
+bool RegisterFlagValidator(const string* flag, |
+ bool (*validate_fn)(const char*, const string&)) { |
+ return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn)); |
+} |
+ |
+ |
+// -------------------------------------------------------------------- |
+// ParseCommandLineFlags() |
+// ParseCommandLineNonHelpFlags() |
+// HandleCommandLineHelpFlags() |
+// This is the main function called from main(), to actually |
+// parse the commandline. It modifies argc and argv as described |
+// at the top of gflags.h. You can also divide this |
+// function into two parts, if you want to do work between |
+// the parsing of the flags and the printing of any help output. |
+// -------------------------------------------------------------------- |
+ |
+static uint32 ParseCommandLineFlagsInternal(int* argc, char*** argv, |
+ bool remove_flags, bool do_report) { |
+ SetArgv(*argc, const_cast<const char**>(*argv)); // save it for later |
+ |
+ FlagRegistry* const registry = FlagRegistry::GlobalRegistry(); |
+ CommandLineFlagParser parser(registry); |
+ |
+ // When we parse the commandline flags, we'll handle --flagfile, |
+ // --tryfromenv, etc. as we see them (since flag-evaluation order |
+ // may be important). But sometimes apps set FLAGS_tryfromenv/etc. |
+ // manually before calling ParseCommandLineFlags. We want to evaluate |
+ // those too, as if they were the first flags on the commandline. |
+ registry->Lock(); |
+ parser.ProcessFlagfileLocked(FLAGS_flagfile, SET_FLAGS_VALUE); |
+ // Last arg here indicates whether flag-not-found is a fatal error or not |
+ parser.ProcessFromenvLocked(FLAGS_fromenv, SET_FLAGS_VALUE, true); |
+ parser.ProcessFromenvLocked(FLAGS_tryfromenv, SET_FLAGS_VALUE, false); |
+ registry->Unlock(); |
+ |
+ // Now get the flags specified on the commandline |
+ const int r = parser.ParseNewCommandLineFlags(argc, argv, remove_flags); |
+ |
+ if (do_report) |
+ HandleCommandLineHelpFlags(); // may cause us to exit on --help, etc. |
+ |
+ // See if any of the unset flags fail their validation checks |
+ parser.ValidateAllFlags(); |
+ |
+ if (parser.ReportErrors()) // may cause us to exit on illegal flags |
+ commandlineflags_exitfunc(1); // almost certainly exit() |
+ return r; |
+} |
+ |
+uint32 ParseCommandLineFlags(int* argc, char*** argv, bool remove_flags) { |
+ return ParseCommandLineFlagsInternal(argc, argv, remove_flags, true); |
+} |
+ |
+uint32 ParseCommandLineNonHelpFlags(int* argc, char*** argv, |
+ bool remove_flags) { |
+ return ParseCommandLineFlagsInternal(argc, argv, remove_flags, false); |
+} |
+ |
+// -------------------------------------------------------------------- |
+// AllowCommandLineReparsing() |
+// ReparseCommandLineNonHelpFlags() |
+// This is most useful for shared libraries. The idea is if |
+// a flag is defined in a shared library that is dlopen'ed |
+// sometime after main(), you can ParseCommandLineFlags before |
+// the dlopen, then ReparseCommandLineNonHelpFlags() after the |
+// dlopen, to get the new flags. But you have to explicitly |
+// Allow() it; otherwise, you get the normal default behavior |
+// of unrecognized flags calling a fatal error. |
+// TODO(csilvers): this isn't used. Just delete it? |
+// -------------------------------------------------------------------- |
+ |
+void AllowCommandLineReparsing() { |
+ allow_command_line_reparsing = true; |
+} |
+ |
+uint32 ReparseCommandLineNonHelpFlags() { |
+ // We make a copy of argc and argv to pass in |
+ const vector<string>& argvs = GetArgvs(); |
+ int tmp_argc = static_cast<int>(argvs.size()); |
+ char** tmp_argv = new char* [tmp_argc + 1]; |
+ for (int i = 0; i < tmp_argc; ++i) |
+ tmp_argv[i] = strdup(argvs[i].c_str()); // TODO(csilvers): don't dup |
+ |
+ const int retval = ParseCommandLineNonHelpFlags(&tmp_argc, &tmp_argv, false); |
+ |
+ for (int i = 0; i < tmp_argc; ++i) |
+ free(tmp_argv[i]); |
+ delete[] tmp_argv; |
+ |
+ return retval; |
+} |
+ |
+_END_GOOGLE_NAMESPACE_ |
Property changes on: tools/nixysa/third_party/gflags-1.0/src/gflags.cc |
___________________________________________________________________ |
Added: svn:eol-style |
+ LF |