template<class Ty>
LocationClass<Ty> location(Ty &L) { return LocationClass<Ty>(L); }
+// opposite_of - Allow the user to specify which other option this
+// option is the opposite of.
+//
+template<class Ty>
+LocationClass<bool> opposite_of(Ty &O) { return location(O.getValue()); }
+
//===----------------------------------------------------------------------===//
// Enum valued command line option
EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>);
+//--------------------------------------------------
+// parser<boolInverse>
+class boolInverse { };
+template<>
+class parser<boolInverse> : public basic_parser<bool> {
+public:
+ typedef bool parser_data_type;
+ // parse - Return true on error.
+ bool parse(Option &O, const char *ArgName, const std::string &Arg,
+ bool &Val);
+
+ enum ValueExpected getValueExpectedFlagDefault() const {
+ return ValueOptional;
+ }
+
+ // getValueName - Do not print =<value> at all.
+ virtual const char *getValueName() const { return 0; }
+
+ // An out-of-line virtual method to provide a 'home' for this class.
+ virtual void anchor();
+};
+
+EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<bool>);
+
//--------------------------------------------------
// parser<int>
//
EXTERN_TEMPLATE_INSTANTIATION(class opt<std::string>);
EXTERN_TEMPLATE_INSTANTIATION(class opt<bool>);
+class boolInverse;
+typedef opt<bool, true, parser<boolInverse> > inverse_opt;
+
//===----------------------------------------------------------------------===//
// list_storage class
//
TEMPLATE_INSTANTIATION(class basic_parser<bool>);
TEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>);
+TEMPLATE_INSTANTIATION(class basic_parser<boolInverse>);
TEMPLATE_INSTANTIATION(class basic_parser<int>);
TEMPLATE_INSTANTIATION(class basic_parser<unsigned>);
TEMPLATE_INSTANTIATION(class basic_parser<double>);
void basic_parser_impl::anchor() {}
void parser<bool>::anchor() {}
void parser<boolOrDefault>::anchor() {}
+void parser<boolInverse>::anchor() {}
void parser<int>::anchor() {}
void parser<unsigned>::anchor() {}
void parser<double>::anchor() {}
if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||
Arg == "1") {
Value = BOU_TRUE;
- } else if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") {
+ } else if (Arg == "false" || Arg == "FALSE"
+ || Arg == "False" || Arg == "0") {
Value = BOU_FALSE;
} else {
return O.error(": '" + Arg +
return false;
}
+// parser<boolInverse> implementation
+//
+bool parser<boolInverse>::parse(Option &O, const char *ArgName,
+ const std::string &Arg, bool &Value) {
+ if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||
+ Arg == "1") {
+ Value = false;
+ } else if (Arg == "false" || Arg == "FALSE"
+ || Arg == "False" || Arg == "0") {
+ Value = true;
+ } else {
+ return O.error(": '" + Arg +
+ "' is invalid value for boolean argument! Try 0 or 1");
+ }
+ return false;
+}
+
// parser<int> implementation
//
bool parser<int>::parse(Option &O, const char *ArgName,