Changeset 1515

Timestamp:

24/08/10 11:23:06 (18 months ago)

Author:

Freddie Akeroyd

Message:

Update to tclap 1.2.0 from  http://tclap.sourceforge.net/
Refs #244

Location:

trunk/third_party/tclap

Files:

• AUTHORS (modified) (1 diff)
• Arg.h (modified) (31 diffs)
• ArgException.h (modified) (3 diffs)
• ArgTraits.h (added)
• ChangeLog (added)
• CmdLine.h (modified) (23 diffs)
• CmdLineInterface.h (modified) (2 diffs)
• CmdLineOutput.h (modified) (1 diff)
• Constraint.h (added)
• DocBookOutput.h (modified) (4 diffs)
• HelpVisitor.h (modified) (1 diff)
• Makefile.am (modified) (1 diff)
• MultiArg.h (modified) (12 diffs)
• MultiSwitchArg.h (added)
• NEWS (added)
• OptionalUnlabeledTracker.h (added)
• StandardTraits.h (added)
• StdOutput.h (modified) (8 diffs)
• SwitchArg.h (modified) (10 diffs)
• UnlabeledMultiArg.h (modified) (18 diffs)
• UnlabeledValueArg.h (modified) (19 diffs)
• ValueArg.h (modified) (18 diffs)
• ValuesConstraint.h (added)
• VersionVisitor.h (modified) (2 diffs)
• Visitor.h (modified) (1 diff)
• XorHandler.h (modified) (3 diffs)
• ZshCompletionOutput.h (added)

trunk/third_party/tclap/AUTHORS

@@ -2 +2 @@
 original author: Michael E. Smoot
 invaluable contributions: Daniel Aarno
+more contributions: Erik Zeek
+more contributions: Fabien Carmagnac (Tinbergen-AM)
 outstanding editing: Carol Smoot

trunk/third_party/tclap/Arg.h

@@ -1 @@
-
-/****************************************************************************** 
- * 
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
+
+/******************************************************************************
+ *
  *  file:  Arg.h
- * 
+ *
  *  Copyright (c) 2003, Michael E. Smoot .
  *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno .
  *  All rights reverved.
- * 
+ *
  *  See the file COPYING in the top directory of this distribution for
  *  more information.
- *  
- *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS 
- *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
- *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
- *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
- *  DEALINGS IN THE SOFTWARE.  
- *  
- *****************************************************************************/ 
+ *
+ *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ *  DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
 
 
 #ifndef TCLAP_ARGUMENT_H
 #define TCLAP_ARGUMENT_H
+
+#ifdef ___HAVE_CONFIG_H
+#include <config.h>
+#else
+#define HAVE_SSTREAM
+#endif
 
 #include <string>
@@ -29 +36 @@
 #include <list>
 #include <iostream>
+#include <iomanip>
+#include <cstdio>
+
+#if defined(HAVE_SSTREAM)
+#include <sstream>
+typedef std::istringstream istringstream;
+#elif defined(HAVE_STRSTREAM)
+#include <strstream>
+typedef std::istrstream istringstream;
+#else
+#error "Need a stringstream (sstream or strstream) to compile!"
+#endif
 
 #include <tclap/ArgException.h>
 #include <tclap/Visitor.h>
 #include <tclap/CmdLineInterface.h>
+#include <tclap/ArgTraits.h>
+#include <tclap/StandardTraits.h>
 
 namespace TCLAP {
 
-/** 
+/**
  * A virtual base class that defines the essential data for all arguments.
  * This class, or one of its existing children, must be subclassed to do
- * anything. 
+ * anything.
  */
 class Arg
 {
-        private: 
+        private:
 
                 /**
@@ -54 +75 @@
                  * value.
                  */
-                static char& delimiterRef() { static char delim = ' '; return delim; } 
+                static char& delimiterRef() { static char delim = ' '; return delim; }
 
         protected:
 
-                /** 
+                /**
                  * The single char flag used to identify the argument.
-                 * This value (preceded by a dash {-}), can be used to identify 
-                 * an argument on the command line.  The _flag can be blank, 
+                 * This value (preceded by a dash {-}), can be used to identify
+                 * an argument on the command line.  The _flag can be blank,
                  * in fact this is how unlabeled args work.  Unlabeled args must
-                 * override appropriate functions to get correct handling. Note 
+                 * override appropriate functions to get correct handling. Note
                  * that the _flag does NOT include the dash as part of the flag.
                  */
@@ -70 +91 @@
                 /**
                  * A single work namd indentifying the argument.
-                 * This value (preceded by two dashed {--}) can also be used 
+                 * This value (preceded by two dashed {--}) can also be used
                  * to identify an argument on the command line.  Note that the
                  * _name does NOT include the two dashes as part of the _name. The
@@ -78 +99 @@
 
                 /**
-                 * Description of the argument. 
+                 * Description of the argument.
                  */
                 std::string _description;
 
-                /** 
+                /**
                  * Indicating whether the argument is required.
                  */
@@ -88 +109 @@
 
                 /**
-                 * Label to be used in usage description.  Normally set to 
+                 * Label to be used in usage description.  Normally set to
                  * "required", but can be changed when necessary.
                  */
@@ -126 +147 @@
                 bool _xorSet;
 
+                bool _acceptsMultipleValues;
+
                 /**
                  * Performs the special handling described by the Vistitor.
@@ -132 +155 @@
 
                 /**
-                 * Primary constructor. YOU (yes you) should NEVER construct an Arg 
+                 * Primary constructor. YOU (yes you) should NEVER construct an Arg
                  * directly, this is a base class that is extended by various children
-                 * that are meant to be used.  Use SwitchArg, ValueArg, MultiArg, 
+                 * that are meant to be used.  Use SwitchArg, ValueArg, MultiArg,
                  * UnlabeledValueArg, or UnlabeledMultiArg instead.
                  *
@@ -144 +167 @@
                  * \param v - The visitor checked by the argument. Defaults to NULL.
                  */
-                Arg( const std::string& flag, 
-                         const std::string& name, 
-                         const std::string& desc, 
-                         bool req, 
+                Arg( const std::string& flag,
+                         const std::string& name,
+                         const std::string& desc,
+                         bool req,
                          bool valreq,
                          Visitor* v = NULL );
@@ -162 +185 @@
                  */
                 virtual void addToList( std::list<Arg*>& argList ) const;
-                
+
                 /**
                  * Begin ignoring arguments since the "--" argument was specified.
                  */
                 static void beginIgnoring() { ignoreRestRef() = true; }
-                
+
                 /**
                  * Whether to ignore the rest.
@@ -177 +200 @@
                  * value.
                  */
-                static char delimiter() { return delimiterRef(); } 
-                
+                static char delimiter() { return delimiterRef(); }
+
                 /**
                  * The char used as a place holder when SwitchArgs are combined.
-                 * Currently set to '*', which shouldn't cause many problems since
-                 * *'s are expanded by most shells on the command line.  
-                 */
-                static const char blankChar() { return '*'; }
-                
+                 * Currently set to the bell char (ASCII 7).
+                 */
+                static char blankChar() { return (char)7; }
+
                 /**
                  * The char that indicates the beginning of a flag.  Currently '-'.
                  */
-                static const char flagStartChar() { return '-'; }
-                
+                static char flagStartChar() { return '-'; }
+
                 /**
                  * The sting that indicates the beginning of a flag.  Currently "-".
@@ -196 +218 @@
                  */
                 static const std::string flagStartString() { return "-"; }
-                
+
                 /**
                  * The sting that indicates the beginning of a name.  Currently "--".
@@ -216 +238 @@
                 /**
                  * Pure virtual method meant to handle the parsing and value assignment
-                 * of the string on the command line. 
+                 * of the string on the command line.
                  * \param i - Pointer the the current argument in the list.
-                 * \param args - Mutable list of strings. What is 
+                 * \param args - Mutable list of strings. What is
                  * passed in from main.
                  */
-                virtual bool processArg(int *i, std::vector<std::string>& args) = 0; 
+                virtual bool processArg(int *i, std::vector<std::string>& args) = 0;
 
                 /**
@@ -228 +250 @@
                  * \param a - The Arg to be compared to this.
                  */
-                virtual bool operator==(const Arg& a);
+                virtual bool operator==(const Arg& a) const;
 
                 /**
@@ -274 +296 @@
 
                 /**
-                 * Indicates whether the argument can be ignored, if desired. 
+                 * Indicates whether the argument can be ignored, if desired.
                  */
                 bool isIgnoreable() const;
@@ -281 +303 @@
                  * A method that tests whether a string matches this argument.
                  * This is generally called by the processArg() method.  This
-                 * method could be re-implemented by a child to change how 
+                 * method could be re-implemented by a child to change how
                  * arguments are specified on the command line.
                  * \param s - The string to be compared to the flag/name to determine
@@ -308 +330 @@
                 /**
                  * Trims a value off of the flag.
-                 * \param flag - The string from which the flag and value will be 
-                 * trimmed. Contains the flag once the value has been trimmed. 
+                 * \param flag - The string from which the flag and value will be
+                 * trimmed. Contains the flag once the value has been trimmed.
                  * \param value - Where the value trimmed from the string will
                  * be stored.
@@ -330 +352 @@
                 void setRequireLabel( const std::string& s );
 
+                /**
+                 * Used for MultiArgs and XorHandler to determine whether args
+                 * can still be set.
+                 */
+                virtual bool allowMore();
+
+                /**
+                 * Use by output classes to determine whether an Arg accepts
+                 * multiple values.
+                 */
+                virtual bool acceptsMultipleValues();
+
+                /**
+                 * Clears the Arg object and allows it to be reused by new
+                 * command lines.
+                 */
+                 virtual void reset();
 };
 
@@ -347 +386 @@
 typedef std::list<Visitor*>::iterator VisitorListIterator;
 
+/*
+ * Extract a value of type T from it's string representation contained
+ * in strVal. The ValueLike parameter used to select the correct
+ * specialization of ExtractValue depending on the value traits of T.
+ * ValueLike traits use operator>> to assign the value from strVal.
+ */
+template<typename T> void
+ExtractValue(T &destVal, const std::string& strVal, ValueLike vl)
+{
+    static_cast<void>(vl); // Avoid warning about unused vl
+    std::istringstream is(strVal);
+
+    int valuesRead = 0;
+    while ( is.good() ) {
+        if ( is.peek() != EOF )
+#ifdef TCLAP_SETBASE_ZERO
+            is >> std::setbase(0) >> destVal;
+#else
+            is >> destVal;
+#endif
+        else
+            break;
+
+        valuesRead++;
+    }
+
+    if ( is.fail() )
+        throw( ArgParseException("Couldn't read argument value "
+                                 "from string '" + strVal + "'"));
+
+
+    if ( valuesRead > 1 )
+        throw( ArgParseException("More than one valid value parsed from "
+                                 "string '" + strVal + "'"));
+
+}
+
+/*
+ * Extract a value of type T from it's string representation contained
+ * in strVal. The ValueLike parameter used to select the correct
+ * specialization of ExtractValue depending on the value traits of T.
+ * StringLike uses assignment (operator=) to assign from strVal.
+ */
+template<typename T> void
+ExtractValue(T &destVal, const std::string& strVal, StringLike sl)
+{
+    static_cast<void>(sl); // Avoid warning about unused sl
+    SetString(destVal, strVal);
+}
 
 //////////////////////////////////////////////////////////////////////
@@ -352 +440 @@
 //////////////////////////////////////////////////////////////////////
 
-inline Arg::Arg(const std::string& flag, 
-         const std::string& name, 
-         const std::string& desc, 
-         bool req, 
+inline Arg::Arg(const std::string& flag,
+         const std::string& name,
+         const std::string& desc,
+         bool req,
          bool valreq,
          Visitor* v) :
@@ -367 +455 @@
   _visitor( v ),
   _ignoreable(true),
-  _xorSet(false)
-{
-        if ( _flag.length() > 1 ) 
+  _xorSet(false),
+  _acceptsMultipleValues(false)
+{
+        if ( _flag.length() > 1 )
                 throw(SpecificationException(
                                 "Argument flag can only be one character long", toString() ) );
 
-        if ( _name != ignoreNameString() &&  
-                 ( _flag == Arg::flagStartString() || 
-                   _flag == Arg::nameStartString() || 
+        if ( _name != ignoreNameString() &&
+                 ( _flag == Arg::flagStartString() ||
+                   _flag == Arg::nameStartString() ||
                    _flag == " " ) )
-                throw(SpecificationException("Argument flag cannot be either '" + 
-                                                        Arg::flagStartString() + "' or '" + 
+                throw(SpecificationException("Argument flag cannot be either '" +
+                                                        Arg::flagStartString() + "' or '" +
                                                         Arg::nameStartString() + "' or a space.",
                                                         toString() ) );
 
-        if ( ( _name.find( Arg::flagStartString(), 0 ) != std::string::npos ) || 
-                 ( _name.find( Arg::nameStartString(), 0 ) != std::string::npos ) ||
+        if ( ( _name.substr( 0, Arg::flagStartString().length() ) == Arg::flagStartString() ) ||
+                 ( _name.substr( 0, Arg::nameStartString().length() ) == Arg::nameStartString() ) ||
                  ( _name.find( " ", 0 ) != std::string::npos ) )
-                throw(SpecificationException("Argument name cannot contain either '" + 
-                                                        Arg::flagStartString() + "' or '" + 
+                throw(SpecificationException("Argument name begin with either '" +
+                                                        Arg::flagStartString() + "' or '" +
                                                         Arg::nameStartString() + "' or space.",
                                                         toString() ) );
@@ -403 +492 @@
                 id = Arg::nameStartString() + _name;
 
-        std::string delim = " "; 
-        delim[0] = Arg::delimiter(); // ugly!!!
-        
         if ( _valueRequired )
-                id += delim + "<" + valueId  + ">";
+                id += std::string( 1, Arg::delimiter() ) + "<" + valueId  + ">";
 
         if ( !_required )
@@ -424 +510 @@
 
                 if ( _valueRequired )
-                        id += " <" + valueId + ">";
-                
+                        id += std::string( 1, Arg::delimiter() ) + "<" + valueId + ">";
+
                 id += ",  ";
         }
@@ -432 +518 @@
 
         if ( _valueRequired )
-                id += " <" + valueId + ">";
-                        
+                id += std::string( 1, Arg::delimiter() ) + "<" + valueId + ">";
+
         return id;
 
 }
 
-inline bool Arg::operator==(const Arg& a)
-{
-        if ( ( _flag != "" && _flag == a._flag ) || 
-                 _name == a._name || 
-                 _description == a._description )
+inline bool Arg::operator==(const Arg& a) const
+{
+        if ( ( _flag != "" && _flag == a._flag ) || _name == a._name)
                 return true;
         else
@@ -448 +532 @@
 }
 
-inline std::string Arg::getDescription() const 
+inline std::string Arg::getDescription() const
 {
         std::string desc = "";
@@ -454 +538 @@
                 desc = "(" + _requireLabel + ")  ";
 
-        if ( _valueRequired )
-                desc += "(value required)  ";
+//      if ( _valueRequired )
+//              desc += "(value required)  ";
 
         desc += _description;
-        return desc; 
+        return desc;
 }
 
 inline const std::string& Arg::getFlag() const { return _flag; }
 
-inline const std::string& Arg::getName() const { return _name; } 
+inline const std::string& Arg::getName() const { return _name; }
 
 inline bool Arg::isRequired() const { return _required; }
@@ -469 +553 @@
 inline bool Arg::isValueRequired() const { return _valueRequired; }
 
-inline bool Arg::isSet() const 
-{ 
+inline bool Arg::isSet() const
+{
         if ( _alreadySet && !_xorSet )
                 return true;
@@ -479 +563 @@
 inline bool Arg::isIgnoreable() const { return _ignoreable; }
 
-inline void Arg::setRequireLabel( const std::string& s) 
-{ 
+inline void Arg::setRequireLabel( const std::string& s)
+{
         _requireLabel = s;
 }
@@ -517 +601 @@
 {
         int stop = 0;
-        for ( int i = 0; (unsigned int)i < flag.length(); i++ )
+        for ( int i = 0; static_cast<unsigned int>(i) < flag.length(); i++ )
                 if ( flag[i] == Arg::delimiter() )
                 {
@@ -537 +621 @@
 inline bool Arg::_hasBlanks( const std::string& s ) const
 {
-        for ( int i = 1; (unsigned int)i < s.length(); i++ )
+        for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
                 if ( s[i] == Arg::blankChar() )
                         return true;
@@ -560 +644 @@
 inline void Arg::addToList( std::list<Arg*>& argList ) const
 {
-        argList.push_front( (Arg*)this );
+        argList.push_front( const_cast<Arg*>(this) );
+}
+
+inline bool Arg::allowMore()
+{
+        return false;
+}
+
+inline bool Arg::acceptsMultipleValues()
+{
+        return _acceptsMultipleValues;
+}
+
+inline void Arg::reset()
+{
+        _xorSet = false;
+        _alreadySet = false;
 }
 

trunk/third_party/tclap/ArgException.h

@@ +1 @@
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
 
 /****************************************************************************** 
@@ -79 +80 @@
                 const char* what() const throw() 
                 {
-                        std::string ex = _argId + " -- " + _errorText;
+                        static std::string ex; 
+                        ex = _argId + " -- " + _errorText;
                         return ex.c_str();
                 }
@@ -183 +185 @@
 };
 
+class ExitException {
+public:
+        ExitException(int estat) : _estat(estat) {}
+
+        int getExitStatus() const { return _estat; }
+
+private:
+        int _estat;
+};
+
 } // namespace TCLAP
 

trunk/third_party/tclap/CmdLine.h

@@ -1 @@
-
-/****************************************************************************** 
- * 
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
+
+/******************************************************************************
+ *
  *  file:  CmdLine.h
- * 
+ *
  *  Copyright (c) 2003, Michael E. Smoot .
  *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
  *  All rights reverved.
- * 
+ *
  *  See the file COPYING in the top directory of this distribution for
  *  more information.
- *  
- *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS 
- *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
- *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
- *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
- *  DEALINGS IN THE SOFTWARE.  
- *  
- *****************************************************************************/ 
+ *
+ *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ *  DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
 
 #ifndef TCLAP_CMDLINE_H
@@ -25 +26 @@
 
 #include <tclap/SwitchArg.h>
+#include <tclap/MultiSwitchArg.h>
 #include <tclap/UnlabeledValueArg.h>
 #include <tclap/UnlabeledMultiArg.h>
@@ -35 +37 @@
 #include <tclap/CmdLineOutput.h>
 #include <tclap/StdOutput.h>
+
+#include <tclap/Constraint.h>
+#include <tclap/ValuesConstraint.h>
 
 #include <string>
@@ -42 +47 @@
 #include <iomanip>
 #include <algorithm>
+#include <stdlib.h> // Needed for exit(), which isn't defined in some envs.
 
 namespace TCLAP {
+
+template<typename T> void DelPtr(T ptr)
+{
+        delete ptr;
+}
+
+template<typename C> void ClearContainer(C &c)
+{
+        typedef typename C::value_type value_type;
+        std::for_each(c.begin(), c.end(), DelPtr<value_type>);
+        c.clear();
+}
+
 
 /**
@@ -75 +94 @@
 
                 /**
-                 * The number of arguments that are required to be present on 
-                 * the command line. This is set dynamically, based on the 
+                 * The number of arguments that are required to be present on
+                 * the command line. This is set dynamically, based on the
                  * Args added to the CmdLine object.
                  */
@@ -82 +101 @@
 
                 /**
-                 * The character that is used to separate the argument flag/name 
+                 * The character that is used to separate the argument flag/name
                  * from the value.  Defaults to ' ' (space).
                  */
@@ -110 +129 @@
                  */
                 CmdLineOutput* _output;
+
+                /**
+                 * Should CmdLine handle parsing exceptions internally?
+                 */
+                bool _handleExceptions;
+
+                /**
+                 * Throws an exception listing the missing args.
+                 */
+                void missingArgsException();
 
                 /**
@@ -119 +148 @@
                 bool _emptyCombined(const std::string& s);
 
-        private:
-
-                /**
-                 * Encapsulates the code common to the constructors (which is all
-                 * of it).
+                /**
+                 * Perform a delete ptr; operation on ptr when this object is deleted.
+                 */
+                void deleteOnExit(Arg* ptr);
+
+                /**
+                 * Perform a delete ptr; operation on ptr when this object is deleted.
+                 */
+                void deleteOnExit(Visitor* ptr);
+
+private:
+
+                /**
+                 * Encapsulates the code common to the constructors
+                 * (which is all of it).
                  */
                 void _constructor();
 
-                /**
-                 * Perform a delete ptr; operation on ptr when this object is deleted.
-                 */
-                void deleteOnExit(Arg* ptr);
-
-                /**
-                 * Perform a delete ptr; operation on ptr when this object is deleted.
-                 */
-                void deleteOnExit(Visitor* ptr);
 
                 /**
@@ -143 +173 @@
                 bool _userSetOutput;
 
+                /**
+                 * Whether or not to automatically create help and version switches.
+                 */
+                bool _helpAndVersion;
+
         public:
-
-                /**
-                 * Command line constructor. DEPRECATED!!!  This is here to maintain
-                 * backwards compatibility with earlier releases.  Note that the
-                 * program name will be overwritten with argv[0].  The delimiter
-                 * used is ' ' (as before).
-                 * \param name - The program name - will be overwritten with argv[0].
-                 * \param message - The message to be used in the usage output.
-                 * \param version - The version number to be used in the
-                 * --version switch.
-                 */
-                CmdLine(const std::string& name, 
-                                const std::string& message,
-                                const std::string& version = "none" );
 
                 /**
@@ -168 +189 @@
                  * \param version - The version number to be used in the
                  * --version switch.
-                 */
-                CmdLine(const std::string& message, 
+                 * \param helpAndVersion - Whether or not to create the Help and
+                 * Version switches. Defaults to true.
+                 */
+                CmdLine(const std::string& message,
                                 const char delimiter = ' ',
-                                const std::string& version = "none" );
-                
+                                const std::string& version = "none",
+                                bool helpAndVersion = true);
+
                 /**
                  * Deletes any resources allocated by a CmdLine object.
@@ -180 +204 @@
                 /**
                  * Adds an argument to the list of arguments to be parsed.
-                 * \param a - Argument to be added. 
+                 * \param a - Argument to be added.
                  */
                 void add( Arg& a );
@@ -186 +210 @@
                 /**
                  * An alternative add.  Functionally identical.
-                 * \param a - Argument to be added. 
+                 * \param a - Argument to be added.
                  */
                 void add( Arg* a );
@@ -193 +217 @@
                  * Add two Args that will be xor'd.  If this method is used, add does
                  * not need to be called.
-                 * \param a - Argument to be added and xor'd. 
-                 * \param b - Argument to be added and xor'd. 
+                 * \param a - Argument to be added and xor'd.
+                 * \param b - Argument to be added and xor'd.
                  */
                 void xorAdd( Arg& a, Arg& b );
 
                 /**
-                 * Add a list of Args that will be xor'd.  If this method is used, 
+                 * Add a list of Args that will be xor'd.  If this method is used,
                  * add does not need to be called.
-                 * \param xors - List of Args to be added and xor'd. 
+                 * \param xors - List of Args to be added and xor'd.
                  */
                 void xorAdd( std::vector<Arg*>& xors );
@@ -210 +234 @@
                  * \param argv - Array of arguments.
                  */
-                void parse(int argc, char** argv);
+                void parse(int argc, const char * const * argv);
+
+                /**
+                 * Parses the command line.
+                 * \param args - A vector of strings representing the args.
+                 * args[0] is still the program name.
+                 */
+                void parse(std::vector<std::string>& args);
 
                 /**
@@ -251 +282 @@
                  */
                 std::string& getMessage();
+
+                /**
+                 *
+                 */
+                bool hasHelpAndVersion();
+
+                /**
+                 * Disables or enables CmdLine's internal parsing exception handling.
+                 *
+                 * @param state Should CmdLine handle parsing exceptions internally?
+                 */
+                void setExceptionHandling(const bool state);
+
+                /**
+                 * Returns the current state of the internal exception handling.
+                 *
+                 * @retval true Parsing exceptions are handled internally.
+                 * @retval false Parsing exceptions are propagated to the caller.
+                 */
+                bool getExceptionHandling() const;
+
+                /**
+                 * Allows the CmdLine object to be reused.
+                 */
+                void reset();
+
 };
 
@@ -258 +315 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-inline CmdLine::CmdLine(const std::string& n, 
-                                        const std::string& m, 
-                                                const std::string& v )
-: _progName(n),
-  _message(m),
-  _version(v),
-  _numRequired(0),
-  _delimiter(' '),
-  _userSetOutput(false)
-{ 
-        _constructor();
-}
-
-inline CmdLine::CmdLine(const std::string& m, 
-                                        char delim, 
-                                                const std::string& v )
+inline CmdLine::CmdLine(const std::string& m,
+                        char delim,
+                        const std::string& v,
+                        bool help )
 : _progName("not_set_yet"),
   _message(m),
@@ -279 +324 @@
   _numRequired(0),
   _delimiter(delim),
-  _userSetOutput(false)
+  _handleExceptions(true),
+  _userSetOutput(false),
+  _helpAndVersion(help)
 {
         _constructor();
@@ -286 +333 @@
 inline CmdLine::~CmdLine()
 {
-        ArgListIterator argIter;
-        VisitorListIterator visIter;
-  
-        for( argIter = _argDeleteOnExitList.begin(); 
-                 argIter != _argDeleteOnExitList.end(); 
-                 ++argIter)
-                delete *argIter;
-  
-        for( visIter = _visitorDeleteOnExitList.begin(); 
-                 visIter != _visitorDeleteOnExitList.end(); 
-                 ++visIter) 
-                delete *visIter;
-
-        if ( !_userSetOutput )
+        ClearContainer(_argDeleteOnExitList);
+        ClearContainer(_visitorDeleteOnExitList);
+
+        if ( !_userSetOutput ) {
                 delete _output;
+                _output = 0;
+        }
 }
 
 inline void CmdLine::_constructor()
-{ 
+{
         _output = new StdOutput;
 
-        Visitor *v;
-        
         Arg::setDelimiter( _delimiter );
 
-        v = new HelpVisitor( this, &_output );
-        SwitchArg* help = new SwitchArg("h","help", 
-                                        "Displays usage information and exits.", 
+        Visitor* v;
+
+        if ( _helpAndVersion )
+        {
+                v = new HelpVisitor( this, &_output );
+                SwitchArg* help = new SwitchArg("h","help",
+                                                "Displays usage information and exits.",
+                                                false, v);
+                add( help );
+                deleteOnExit(help);
+                deleteOnExit(v);
+
+                v = new VersionVisitor( this, &_output );
+                SwitchArg* vers = new SwitchArg("","version",
+                                        "Displays version information and exits.",
                                         false, v);
-        add( help );
-        deleteOnExit(help);
-        deleteOnExit(v);
-        
-        v = new VersionVisitor( this, &_output );
-        SwitchArg* vers = new SwitchArg("v","version", 
-                                        "Displays version information and exits.", 
-                                        false, v);
-        add( vers );
-        deleteOnExit(vers);
-        deleteOnExit(v);
+                add( vers );
+                deleteOnExit(vers);
+                deleteOnExit(v);
+        }
 
         v = new IgnoreRestVisitor();
-        SwitchArg* ignore  = new SwitchArg(Arg::flagStartString(), 
+        SwitchArg* ignore  = new SwitchArg(Arg::flagStartString(),
                                            Arg::ignoreNameString(),
                            "Ignores the rest of the labeled arguments following this flag.",
@@ -350 +392 @@
 }
 
-inline void CmdLine::xorAdd( Arg& a, Arg& b ) 
+inline void CmdLine::xorAdd( Arg& a, Arg& b )
 {
     std::vector<Arg*> ors;
@@ -358 +400 @@
 }
 
-inline void CmdLine::add( Arg& a ) 
-{ 
+inline void CmdLine::add( Arg& a )
+{
         add( &a );
 }
 
-inline void CmdLine::add( Arg* a ) 
-{ 
-        for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ ) 
-                if ( *a == *(*it) ) 
-                        throw( SpecificationException( 
-                                "Argument with same flag/name already exists!", 
+inline void CmdLine::add( Arg* a )
+{
+        for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
+                if ( *a == *(*it) )
+                        throw( SpecificationException(
+                                "Argument with same flag/name already exists!",
                                         a->longID() ) );
 
         a->addToList( _argList );
 
-        if ( a->isRequired() ) 
-                _numRequired++; 
-}
-
-inline void CmdLine::parse(int argc, char** argv)
-{
+        if ( a->isRequired() )
+                _numRequired++;
+}
+
+
+inline void CmdLine::parse(int argc, const char * const * argv)
+{
+                // this step is necessary so that we have easy access to
+                // mutable strings.
+                std::vector<std::string> args;
+                for (int i = 0; i < argc; i++)
+                        args.push_back(argv[i]);
+
+                parse(args);
+}
+
+inline void CmdLine::parse(std::vector<std::string>& args)
+{
+        bool shouldExit = false;
+        int estat = 0;
+
         try {
-
-        _progName = argv[0]; 
-
-        // this step is necessary so that we have easy access to mutable strings.
-        std::vector<std::string> args;
-        for (int i = 1; i < argc; i++)
-                args.push_back(argv[i]);
-
-        int requiredCount = 0;
-
-        for (int i = 0; (unsigned int)i < args.size(); i++)
-        {
-                bool matched = false;
-                for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
-        {
-                        if ( (*it)->processArg( &i, args ) )
-                        {
-                                requiredCount += _xorHandler.check( *it );
+                _progName = args.front();
+                args.erase(args.begin());
+
+                int requiredCount = 0;
+
+                for (int i = 0; static_cast<unsigned int>(i) < args.size(); i++) {
+                        bool matched = false;
+                        for (ArgListIterator it = _argList.begin();
+                                 it != _argList.end(); it++) {
+                                if ( (*it)->processArg( &i, args ) )
+                                        {
+                                                requiredCount += _xorHandler.check( *it );
+                                                matched = true;
+                                                break;
+                                        }
+                        }
+
+                        // checks to see if the argument is an empty combined
+                        // switch and if so, then we've actually matched it
+                        if ( !matched && _emptyCombined( args[i] ) )
                                 matched = true;
-                                break;
-                        }
-        }
-
-                // checks to see if the argument is an empty combined switch ...
-                // and if so, then we've actually matched it
-                if ( !matched && _emptyCombined( args[i] ) )
-                        matched = true;
-
-                if ( !matched && !Arg::ignoreRest() )
-                        throw(CmdLineParseException("Couldn't find match for argument",
-                                                     args[i]));
-    }
-
-        if ( requiredCount < _numRequired )
-                throw(CmdLineParseException("One or more required arguments missing!"));
-
-        if ( requiredCount > _numRequired )
-                throw(CmdLineParseException("Too many arguments!"));
-
-        } catch ( ArgException e ) { _output->failure(*this,e); exit(1); }
+
+                        if ( !matched && !Arg::ignoreRest() )
+                                throw(CmdLineParseException("Couldn't find match "
+                                                                                        "for argument",
+                                                                                        args[i]));
+                }
+
+                if ( requiredCount < _numRequired )
+                        missingArgsException();
+
+                if ( requiredCount > _numRequired )
+                        throw(CmdLineParseException("Too many arguments!"));
+
+        } catch ( ArgException& e ) {
+                // If we're not handling the exceptions, rethrow.
+                if ( !_handleExceptions) {
+                        throw;
+                }
+
+                try {
+                        _output->failure(*this,e);
+                } catch ( ExitException &ee ) {
+                        estat = ee.getExitStatus();
+                        shouldExit = true;
+                }
+        } catch (ExitException &ee) {
+                // If we're not handling the exceptions, rethrow.
+                if ( !_handleExceptions) {
+                        throw;
+                }
+
+                estat = ee.getExitStatus();
+                shouldExit = true;
+        }
+
+        if (shouldExit)
+                exit(estat);
 }
 
 inline bool CmdLine::_emptyCombined(const std::string& s)
 {
-        if ( s[0] != Arg::flagStartChar() )
+        if ( s.length() > 0 && s[0] != Arg::flagStartChar() )
                 return false;
 
-        for ( int i = 1; (unsigned int)i < s.length(); i++ )
+        for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
                 if ( s[i] != Arg::blankChar() )
                         return false;
@@ -434 +509 @@
 }
 
+inline void CmdLine::missingArgsException()
+{
+                int count = 0;
+
+                std::string missingArgList;
+                for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
+                {
+                        if ( (*it)->isRequired() && !(*it)->isSet() )
+                        {
+                                missingArgList += (*it)->getName();
+                                missingArgList += ", ";
+                                count++;
+                        }
+                }
+                missingArgList = missingArgList.substr(0,missingArgList.length()-2);
+
+                std::string msg;
+                if ( count > 1 )
+                        msg = "Required arguments missing: ";
+                else
+                        msg = "Required argument missing: ";
+
+                msg += missingArgList;
+
+                throw(CmdLineParseException(msg));
+}
+
 inline void CmdLine::deleteOnExit(Arg* ptr)
 {
@@ -483 +585 @@
 {
         return _message;
+}
+
+inline bool CmdLine::hasHelpAndVersion()
+{
+        return _helpAndVersion;
+}
+
+inline void CmdLine::setExceptionHandling(const bool state)
+{
+        _handleExceptions = state;
+}
+
+inline bool CmdLine::getExceptionHandling() const
+{
+        return _handleExceptions;
+}
+
+inline void CmdLine::reset()
+{
+        for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
+        {
+                (*it)->reset();
+        }
+        
+        _progName.clear();
 }
 
@@ -492 +619 @@
 
 } //namespace TCLAP
-#endif 
+#endif

trunk/third_party/tclap/CmdLineInterface.h

@@ -83 +83 @@
                  * \param argv - Array of arguments.
                  */
-                virtual void parse(int argc, char** argv)=0;
+                virtual void parse(int argc, const char * const * argv)=0;
+
+        /**
+         * Parses the command line.
+         * \param args - A vector of strings representing the args. 
+         * args[0] is still the program name.
+         */
+        void parse(std::vector<std::string>& args);
 
                 /**
@@ -124 +131 @@
                  */
                 virtual std::string& getMessage()=0;
+
+                /**
+                 * Indicates whether or not the help and version switches were created
+                 * automatically.
+                 */
+                virtual bool hasHelpAndVersion()=0;
+
+                /** 
+                 * Resets the instance as if it had just been constructed so that the
+                 * instance can be reused. 
+                 */
+                virtual void reset()=0;
 };
 

trunk/third_party/tclap/CmdLineOutput.h

@@ -43 +43 @@
 
         public:
+
+                /**
+                 * Virtual destructor.
+                 */
+                virtual ~CmdLineOutput() {}
+
                 /**
                  * Generates some sort of output for the USAGE. 

trunk/third_party/tclap/DocBookOutput.h

@@ +1 @@
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
 
 /****************************************************************************** 
@@ -77 +78 @@
                  */
                 void substituteSpecialChars( std::string& s, char r, std::string& x );
+                void removeChar( std::string& s, char r);
+                void basename( std::string& s );
+
+                void printShortArg(Arg* it);
+                void printLongArg(Arg* it);
+
+                char theDelimiter;
 };
 
@@ -89 +97 @@
         std::list<Arg*> argList = _cmd.getArgList();
         std::string progName = _cmd.getProgramName();
+        std::string version = _cmd.getVersion();
+        theDelimiter = _cmd.getDelimiter();
         XorHandler xorHandler = _cmd.getXorHandler();
         std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
-
+        basename(progName);
 
         std::cout << "<?xml version='1.0'?>" << std::endl;
-        std::cout << "<!DOCTYPE book PUBLIC \"-//Norman Walsh//DTD DocBk XML V4.2//EN\"" << std::endl;
+        std::cout << "<!DOCTYPE refentry PUBLIC \"-//OASIS//DTD DocBook XML V4.2//EN\"" << std::endl;
         std::cout << "\t\"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd\">" << std::endl << std::endl;
 
-        std::cout << "<book>" << std::endl;
+        std::cout << "<refentry>" << std::endl;
+
+        std::cout << "<refmeta>" << std::endl;
+        std::cout << "<refentrytitle>" << progName << "</refentrytitle>" << std::endl;
+        std::cout << "<manvolnum>1</manvolnum>" << std::endl;
+        std::cout << "</refmeta>" << std::endl;
+
+        std::cout << "<refnamediv>" << std::endl;
+        std::cout << "<refname>" << progName << "</refname>" << std::endl;
+        std::cout << "<refpurpose>" << _cmd.getMessage() << "</refpurpose>" << std::endl;
+        std::cout << "</refnamediv>" << std::endl;
+
+        std::cout << "<refsynopsisdiv>" << std::endl;
         std::cout << "<cmdsynopsis>" << std::endl;
 
         std::cout << "<command>" << progName << "</command>" << std::endl;
-
-        std::string lt = "&lt;"; 
-        std::string gt = "&gt;"; 
 
         // xor
         for ( int i = 0; (unsigned int)i < xorList.size(); i++ )
         {
-                std::cout << "<group>" << std::endl;
+                std::cout << "<group choice='req'>" << std::endl;
                 for ( ArgVectorIterator it = xorList[i].begin(); 
                                                 it != xorList[i].end(); it++ )
-                {
-                        std::string id = (*it)->shortID();
-                        substituteSpecialChars(id,'<',lt);
-                        substituteSpecialChars(id,'>',gt);
-                        std::cout << "<arg>" << id << "</arg>" << std::endl; 
-                }
+                        printShortArg((*it));
 
                 std::cout << "</group>" << std::endl;
         }
-
+        
+        // rest of args
         for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
                 if ( !xorHandler.contains( (*it) ) )
-                {
-                        std::string id = (*it)->shortID();
-                        substituteSpecialChars(id,'<',lt);
-                        substituteSpecialChars(id,'>',gt);
-                        std::cout << "<arg>" << id << "</arg>" << std::endl; 
-                }
+                        printShortArg((*it));
 
         std::cout << "</cmdsynopsis>" << std::endl;
-        std::cout << "</book>" << std::endl;
+        std::cout << "</refsynopsisdiv>" << std::endl;
+
+        std::cout << "<refsect1>" << std::endl;
+        std::cout << "<title>Description</title>" << std::endl;
+        std::cout << "<para>" << std::endl;
+        std::cout << _cmd.getMessage() << std::endl; 
+        std::cout << "</para>" << std::endl;
+        std::cout << "</refsect1>" << std::endl;
+
+        std::cout << "<refsect1>" << std::endl;
+        std::cout << "<title>Options</title>" << std::endl;
+
+        std::cout << "<variablelist>" << std::endl;
+        
+        for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
+                printLongArg((*it));
+
+        std::cout << "</variablelist>" << std::endl;
+        std::cout << "</refsect1>" << std::endl;
+
+        std::cout << "<refsect1>" << std::endl;
+        std::cout << "<title>Version</title>" << std::endl;
+        std::cout << "<para>" << std::endl;
+        std::cout << version << std::endl; 
+        std::cout << "</para>" << std::endl;
+        std::cout << "</refsect1>" << std::endl;
+        
+        std::cout << "</refentry>" << std::endl;
 
 }
 
 inline void DocBookOutput::failure( CmdLineInterface& _cmd,
-                                                ArgException& e ) 
+                                    ArgException& e ) 
 { 
-                std::cout << e.what() << std::endl;
+        static_cast<void>(_cmd); // unused
+        std::cout << e.what() << std::endl;
+        throw ExitException(1);
 }
 
@@ -153 +192 @@
 }
 
+inline void DocBookOutput::removeChar( std::string& s, char r)
+{
+        size_t p;
+        while ( (p = s.find_first_of(r)) != std::string::npos )
+        {
+                s.erase(p,1);
+        }
+}
+
+inline void DocBookOutput::basename( std::string& s )
+{
+        size_t p = s.find_last_of('/');
+        if ( p != std::string::npos )
+        {
+                s.erase(0, p + 1);
+        }
+}
+
+inline void DocBookOutput::printShortArg(Arg* a)
+{
+        std::string lt = "&lt;"; 
+        std::string gt = "&gt;"; 
+
+        std::string id = a->shortID();
+        substituteSpecialChars(id,'<',lt);
+        substituteSpecialChars(id,'>',gt);
+        removeChar(id,'[');
+        removeChar(id,']');
+        
+        std::string choice = "opt";
+        if ( a->isRequired() )
+                choice = "plain";
+
+        std::cout << "<arg choice='" << choice << '\'';
+        if ( a->acceptsMultipleValues() )
+                std::cout << " rep='repeat'";
+
+
+        std::cout << '>';
+        if ( !a->getFlag().empty() )
+                std::cout << a->flagStartChar() << a->getFlag();
+        else
+                std::cout << a->nameStartString() << a->getName();
+        if ( a->isValueRequired() )
+        {
+                std::string arg = a->shortID();
+                removeChar(arg,'[');
+                removeChar(arg,']');
+                removeChar(arg,'<');
+                removeChar(arg,'>');
+                arg.erase(0, arg.find_last_of(theDelimiter) + 1);
+                std::cout << theDelimiter;
+                std::cout << "<replaceable>" << arg << "</replaceable>";
+        }
+        std::cout << "</arg>" << std::endl;
+
+}
+
+inline void DocBookOutput::printLongArg(Arg* a)
+{
+        std::string lt = "&lt;"; 
+        std::string gt = "&gt;"; 
+
+        std::string desc = a->getDescription();
+        substituteSpecialChars(desc,'<',lt);
+        substituteSpecialChars(desc,'>',gt);
+
+        std::cout << "<varlistentry>" << std::endl;
+
+        if ( !a->getFlag().empty() )
+        {
+                std::cout << "<term>" << std::endl;
+                std::cout << "<option>";
+                std::cout << a->flagStartChar() << a->getFlag();
+                std::cout << "</option>" << std::endl;
+                std::cout << "</term>" << std::endl;
+        }
+
+        std::cout << "<term>" << std::endl;
+        std::cout << "<option>";
+        std::cout << a->nameStartString() << a->getName();
+        if ( a->isValueRequired() )
+        {
+                std::string arg = a->shortID();
+                removeChar(arg,'[');
+                removeChar(arg,']');
+                removeChar(arg,'<');
+                removeChar(arg,'>');
+                arg.erase(0, arg.find_last_of(theDelimiter) + 1);
+                std::cout << theDelimiter;
+                std::cout << "<replaceable>" << arg << "</replaceable>";
+        }
+        std::cout << "</option>" << std::endl;
+        std::cout << "</term>" << std::endl;
+
+        std::cout << "<listitem>" << std::endl;
+        std::cout << "<para>" << std::endl;
+        std::cout << desc << std::endl;
+        std::cout << "</para>" << std::endl;
+        std::cout << "</listitem>" << std::endl;
+
+        std::cout << "</varlistentry>" << std::endl;
+}
+
 } //namespace TCLAP
 #endif 

trunk/third_party/tclap/HelpVisitor.h

@@ -61 +61 @@
                  * specified CmdLine.
                  */
-                void visit() { (*_out)->usage(*_cmd); exit(0); }
+                void visit() { (*_out)->usage(*_cmd); throw ExitException(0); }
                 
 };

trunk/third_party/tclap/Makefile.am

@@ -1 @@
-#====================================================================
-#  NeXus - Neutron & X-ray Common Data Format
-#  
-#  $Id: Makefile.am 1247 2009-04-21 18:14:24Z Freddie Akeroyd $
-#
-#  Top level Makefile for coordinating NeXus build
-#  
-#  Copyright (C) 2004 Freddie Akeroyd
-#  
-#  This library is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU Lesser General Public
-#  License as published by the Free Software Foundation; either
-#  version 2 of the License, or (at your option) any later version.
-# 
-#  This library is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-#  Lesser General Public License for more details.
-# 
-#  You should have received a copy of the GNU Lesser General Public
-#  License along with this library; if not, write to the Free 
-#  Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
-#  MA  02111-1307  USA
-#             
-#  For further information, see <http://www.neutron.anl.gov/NeXus/>
-#
-#  @configure_input@
-#
-#====================================================================
 
-EXTRA_DIST=README AUTHORS COPYING
-noinst_HEADERS = Arg.h ArgException.h CmdLine.h CmdLineInterface.h \
-    CmdLineOutput.h DocBookOutput.h HelpVisitor.h IgnoreRestVisitor.h \
-    MultiArg.h StdOutput.h SwitchArg.h UnlabeledMultiArg.h \
-    UnlabeledValueArg.h ValueArg.h VersionVisitor.h Visitor.h XorHandler.h
+libtclapincludedir = $(includedir)/tclap
+
+libtclapinclude_HEADERS = \
+                         CmdLineInterface.h \
+                         ArgException.h \
+                         CmdLine.h \
+                         XorHandler.h \
+                         MultiArg.h \
+                         UnlabeledMultiArg.h \
+                         ValueArg.h \
+                         UnlabeledValueArg.h \
+                         Visitor.h Arg.h \
+                         HelpVisitor.h \
+                         SwitchArg.h \
+                         MultiSwitchArg.h \
+                         VersionVisitor.h \
+                         IgnoreRestVisitor.h \
+                         CmdLineOutput.h \
+                         StdOutput.h \
+                         DocBookOutput.h \
+                         ZshCompletionOutput.h \
+                         OptionalUnlabeledTracker.h \
+                         Constraint.h \
+                         ValuesConstraint.h \
+                         ArgTraits.h \
+                         StandardTraits.h
+

trunk/third_party/tclap/MultiArg.h

@@ -28 +28 @@
 
 #include <tclap/Arg.h>
-
-#ifdef _____HAVE_CONFIG_H /* not needed */
-#include <config.h>
-#else
-#define HAVE_SSTREAM
-#endif
-
-#if defined(HAVE_SSTREAM)
-#include <sstream>
-#elif defined(HAVE_STRSTREAM)
-#include <strstream>
-#else
-#error "Need a stringstream (sstream or strstream) to compile!"
-#endif
+#include <tclap/Constraint.h>
 
 namespace TCLAP {
-
-template<class T> class MultiArg;
-
-namespace MULTI_ARG_HELPER {
-
-enum Error_e { EXTRACT_FAILURE = 1000, EXTRACT_TOO_MANY };
-
-/**
- * This class is used to extract a value from an argument. 
- * It is used because we need a special implementation to
- * deal with std::string and making a specialiced function
- * puts it in the T segment, thus generating link errors.
- * Having a specialiced class makes the symbols weak.
- * This is not pretty but I don't know how to make it
- * work any other way.
- */
-template<class T>
-class ValueExtractor 
-{
-        friend class MultiArg<T>;
-  
-        private:
-
-                /**
-                 * Reference to the vector of values where the result of the 
-                 * extraction will be put.
-                 */
-                std::vector<T> &_values;
-  
-                /**
-                 * Constructor.
-                 * \param values - Where the values extracted will be put.
-                 */
-                ValueExtractor(std::vector<T> &values) : _values(values) {}
-  
-                /**
-                 * Method that will attempt to parse the input stream for values
-                 * of type T.
-                 * \param val - Where the values parsed will be put.
-                 */
-                int extractValue( const std::string& val ) 
-                {
-                        T temp;
-
-#if defined(HAVE_SSTREAM)
-                        std::istringstream is(val);
-#elif defined(HAVE_STRSTREAM)
-                        std::istrstream is(val.c_str());
-#else
-#error "Need a stringstream (sstream or strstream) to compile!"
-#endif
-
-                        int valuesRead = 0;
-    
-                        while ( is.good() ) 
-                        {
-                                if ( is.peek() != EOF )
-                                        is >> temp; 
-                                else
-                                        break;
-      
-                                valuesRead++;
-                        }               
-    
-                        if ( is.fail() )
-                                return EXTRACT_FAILURE;
-    
-                        if ( valuesRead > 1 )
-                                return EXTRACT_TOO_MANY;
-    
-                        _values.push_back(temp);
-    
-                        return 0;
-                } 
-};
-
-/**
- * Specialization for string.  This is necessary because istringstream
- * operator>> is not able to ignore spaces...  meaning -x "X Y" will only 
- * read 'X'... and thus the specialization.
- */
-template<>
-class ValueExtractor<std::string> 
-{
-        friend class MultiArg<std::string>;
-
-        private:
-
-                /**
-                 * Reference to the vector of strings where the result of the 
-                 * extraction will be put.
-                 */
-        std::vector<std::string> &_values;
-  
-                /**
-                 * Constructor.
-                 * \param values - Where the strings extracted will be put.
-                 */
-        ValueExtractor(std::vector<std::string> &values) : _values(values) {}
-
-                /**
-                 * Method that will attempt to parse the input stream for values
-                 * of type std::string.
-                 * \param val - Where the values parsed will be put.
-                 */
-        int extractValue( const std::string& val ) 
-                {
-            _values.push_back( val );
-            return 0;
-        }
-};
-
-} //namespace MULTI_ARG_HELPER
-
 /**
  * An argument that allows multiple values of type T to be specified.  Very
@@ -166 +39 @@
 class MultiArg : public Arg
 {
-        protected:
-
-                /**
-                 * The list of values parsed from the CmdLine.
-                 */
-                std::vector<T> _values;
-
-                /**
-                 * A list of allowed values.
-                 * A list of values allowed for this argument. If the value parsed
-                 * for this arg is not found in this list, then an exception is
-                 * thrown.  If the list is empty, then any value is allowed.
-                 */
-                std::vector<T> _allowed;
-
-                /**
-                 * The description of type T to be used in the usage.
-                 */
-                std::string _typeDesc;
-
-                /**
-                 * Extracts the value from the string.
-                 * Attempts to parse string as type T, if this fails an exception
-                 * is thrown.
-                 * \param val - The string to be read.
-                 */
-                void _extractValue( const std::string& val );
-
-                /**
-                 * Checks to see if parsed value is in allowed list.
-                 * \param val - value parsed (only used in output).
-                 */
-                void _checkAllowed( const std::string& val );
-
-        public:
-
-                /**
-                 * Constructor.
-                 * \param flag - The one character flag that identifies this
-                 * argument on the command line.
-                 * \param name - A one word name for the argument.  Can be
-                 * used as a long flag on the command line.
-                 * \param desc - A description of what the argument is for or
-                 * does.
-                 * \param req - Whether the argument is required on the command
-                 * line.
-                 * \param typeDesc - A short, human readable description of the
-                 * type that this object expects.  This is used in the generation
-                 * of the USAGE statement.  The goal is to be helpful to the end user
-                 * of the program.
-                 * \param v - An optional visitor.  You probably should not
-                 * use this unless you have a very good reason.
-                 */
-                MultiArg( const std::string& flag,
+public:
+        typedef std::vector<T> container_type;  
+        typedef typename container_type::iterator iterator;
+        typedef typename container_type::const_iterator const_iterator;
+
+protected:
+
+        /**
+         * The list of values parsed from the CmdLine.
+         */
+        std::vector<T> _values;
+
+        /**
+         * The description of type T to be used in the usage.
+         */
+        std::string _typeDesc;
+
+        /**
+         * A list of constraint on this Arg. 
+         */
+        Constraint<T>* _constraint;
+
+        /**
+         * Extracts the value from the string.
+         * Attempts to parse string as type T, if this fails an exception
+         * is thrown.
+         * \param val - The string to be read.
+         */
+        void _extractValue( const std::string& val );
+
+        /**
+         * Used by XorHandler to decide whether to keep parsing for this arg.
+         */
+        bool _allowMore;
+
+public:
+
+        /**
+         * Constructor.
+         * \param flag - The one character flag that identifies this
+         * argument on the command line.
+         * \param name - A one word name for the argument.  Can be
+         * used as a long flag on the command line.
+         * \param desc - A description of what the argument is for or
+         * does.
+         * \param req - Whether the argument is required on the command
+         * line.
+         * \param typeDesc - A short, human readable description of the
+         * type that this object expects.  This is used in the generation
+         * of the USAGE statement.  The goal is to be helpful to the end user
+         * of the program.
+         * \param v - An optional visitor.  You probably should not
+         * use this unless you have a very good reason.
+         */
+        MultiArg( const std::string& flag,
                   const std::string& name,
                   const std::string& desc,
@@ -226 +100 @@
                   Visitor* v = NULL);
 
-                /**
-                 * Constructor.
-                 * \param flag - The one character flag that identifies this
-                 * argument on the command line.
-                 * \param name - A one word name for the argument.  Can be
-                 * used as a long flag on the command line.
-                 * \param desc - A description of what the argument is for or
-                 * does.
-                 * \param req - Whether the argument is required on the command
-                 * line.
-                 * \param typeDesc - A short, human readable description of the
-                 * type that this object expects.  This is used in the generation
-                 * of the USAGE statement.  The goal is to be helpful to the end user
-                 * of the program.
-                 * \param parser - A CmdLine parser object to add this Arg to
-                 * \param v - An optional visitor.  You probably should not
-                 * use this unless you have a very good reason.
-                 */
-                MultiArg( const std::string& flag, 
+        /**
+         * Constructor.
+         * \param flag - The one character flag that identifies this
+         * argument on the command line.
+         * \param name - A one word name for the argument.  Can be
+         * used as a long flag on the command line.
+         * \param desc - A description of what the argument is for or
+         * does.
+         * \param req - Whether the argument is required on the command
+         * line.
+         * \param typeDesc - A short, human readable description of the
+         * type that this object expects.  This is used in the generation
+         * of the USAGE statement.  The goal is to be helpful to the end user
+         * of the program.
+         * \param parser - A CmdLine parser object to add this Arg to
+         * \param v - An optional visitor.  You probably should not
+         * use this unless you have a very good reason.
+         */
+        MultiArg( const std::string& flag, 
                   const std::string& name,
                   const std::string& desc,
@@ -252 +126 @@
                   Visitor* v = NULL );
 
-                /**
-                 * Constructor.
-                 * \param flag - The one character flag that identifies this
-                 * argument on the command line.
-                 * \param name - A one word name for the argument.  Can be
-                 * used as a long flag on the command line.
-                 * \param desc - A description of what the argument is for or
-                 * does.
-                 * \param req - Whether the argument is required on the command
-                 * line.
-                 * \param allowed - A vector of type T that where the values in the
-                 * vector are the only values allowed for the arg.
-                 * \param v - An optional visitor.  You probably should not
-                 * use this unless you have a very good reason.
-                 */
-                MultiArg( const std::string& flag,
+        /**
+         * Constructor.
+         * \param flag - The one character flag that identifies this
+         * argument on the command line.
+         * \param name - A one word name for the argument.  Can be
+         * used as a long flag on the command line.
+         * \param desc - A description of what the argument is for or
+         * does.
+         * \param req - Whether the argument is required on the command
+         * line.
+         * \param constraint - A pointer to a Constraint object used
+         * to constrain this Arg.
+         * \param v - An optional visitor.  You probably should not
+         * use this unless you have a very good reason.
+         */
+        MultiArg( const std::string& flag,
                   const std::string& name,
                   const std::string& desc,
                   bool req,
-                  const std::vector<T>& allowed,
+                  Constraint<T>* constraint,
                   Visitor* v = NULL );
                   
-                /**
-                 * Constructor.
-                 * \param flag - The one character flag that identifies this
-                 * argument on the command line.
-                 * \param name - A one word name for the argument.  Can be
-                 * used as a long flag on the command line.
-                 * \param desc - A description of what the argument is for or
-                 * does.
-                 * \param req - Whether the argument is required on the command
-                 * line.
-                 * \param allowed - A vector of type T that where the values in the
-                 * vector are the only values allowed for the arg.
-                 * \param parser - A CmdLine parser object to add this Arg to
-                 * \param v - An optional visitor.  You probably should not
-                 * use this unless you have a very good reason.
-                 */
-                MultiArg( const std::string& flag, 
+        /**
+         * Constructor.
+         * \param flag - The one character flag that identifies this
+         * argument on the command line.
+         * \param name - A one word name for the argument.  Can be
+         * used as a long flag on the command line.
+         * \param desc - A description of what the argument is for or
+         * does.
+         * \param req - Whether the argument is required on the command
+         * line.
+         * \param constraint - A pointer to a Constraint object used
+         * to constrain this Arg.
+         * \param parser - A CmdLine parser object to add this Arg to
+         * \param v - An optional visitor.  You probably should not
+         * use this unless you have a very good reason.
+         */
+        MultiArg( const std::string& flag, 
                   const std::string& name,
                   const std::string& desc,
                   bool req,
-                  const std::vector<T>& allowed,
+                  Constraint<T>* constraint,
                   CmdLineInterface& parser,
                   Visitor* v = NULL );
                   
-                /**
-                 * Handles the processing of the argument.
-                 * This re-implements the Arg version of this method to set the
-                 * _value of the argument appropriately.  It knows the difference
-                 * between labeled and unlabeled.
-                 * \param i - Pointer the the current argument in the list.
-                 * \param args - Mutable list of strings. Passed from main().
-                 */
-                virtual bool processArg(int* i, std::vector<std::string>& args); 
-
-                /**
-                 * Returns a vector of type T containing the values parsed from
-                 * the command line.
-                 */
-                const std::vector<T>& getValue();
-
-                /**
-                 * Returns the a short id string.  Used in the usage. 
-                 * \param val - value to be used.
-                 */
-                virtual std::string shortID(const std::string& val="val") const;
-
-                /**
-                 * Returns the a long id string.  Used in the usage. 
-                 * \param val - value to be used.
-                 */
-                virtual std::string longID(const std::string& val="val") const;
-
-                /**
-                 * Once we've matched the first value, then the arg is no longer
-                 * required.
-                 */
-                virtual bool isRequired() const;
-
-        private:
-
-                /**
-                 * Common initialization code for constructors with allowed vectors.
-                 */
-                void allowedInit();
+        /**
+         * Handles the processing of the argument.
+         * This re-implements the Arg version of this method to set the
+         * _value of the argument appropriately.  It knows the difference
+         * between labeled and unlabeled.
+         * \param i - Pointer the the current argument in the list.
+         * \param args - Mutable list of strings. Passed from main().
+         */
+        virtual bool processArg(int* i, std::vector<std::string>& args); 
+
+        /**
+         * Returns a vector of type T containing the values parsed from
+         * the command line.
+         */
+        const std::vector<T>& getValue();
+
+        /**
+         * Returns an iterator over the values parsed from the command
+         * line.
+         */
+        const_iterator begin() const { return _values.begin(); }
+
+        /**
+         * Returns the end of the values parsed from the command
+         * line.
+         */
+        const_iterator end() const { return _values.end(); }
+
+        /**
+         * Returns the a short id string.  Used in the usage. 
+         * \param val - value to be used.
+         */
+        virtual std::string shortID(const std::string& val="val") const;
+
+        /**
+         * Returns the a long id string.  Used in the usage. 
+         * \param val - value to be used.
+         */
+        virtual std::string longID(const std::string& val="val") const;
+
+        /**
+         * Once we've matched the first value, then the arg is no longer
+         * required.
+         */
+        virtual bool isRequired() const;
+
+        virtual bool allowMore();
+        
+        virtual void reset();
+
 };
 
-/**
- *
- */
-template<class T>
-void MultiArg<T>::allowedInit()
-{
-        for ( unsigned int i = 0; i < _allowed.size(); i++ )
-        {
-
-#if defined(HAVE_SSTREAM)
-                std::ostringstream os;
-#elif defined(HAVE_STRSTREAM)
-                std::ostrstream os;
-#else
-#error "Need a stringstream (sstream or strstream) to compile!"
-#endif
-
-                os << _allowed[i];
-
-                std::string temp( os.str() );
-
-                if ( i > 0 )
-                        _typeDesc += "|";
-        
-                _typeDesc += temp;
-        }
-}
-
-/**
- *
- */
 template<class T>
 MultiArg<T>::MultiArg(const std::string& flag, 
@@ -379 +232 @@
                       Visitor* v)
 : Arg( flag, name, desc, req, true, v ),
-  _typeDesc( typeDesc )
-{ }
+  _typeDesc( typeDesc ),
+  _constraint( NULL ),
+  _allowMore(false)
+{ 
+        _acceptsMultipleValues = true;
+}
 
 template<class T>
@@ -391 +248 @@
                       Visitor* v)
 : Arg( flag, name, desc, req, true, v ),
-  _typeDesc( typeDesc )
+  _typeDesc( typeDesc ),
+  _constraint( NULL ),
+  _allowMore(false)
 { 
         parser.add( this );
+        _acceptsMultipleValues = true;
 }
 
@@ -404 +264 @@
                       const std::string& desc,
                       bool req,
-                      const std::vector<T>& allowed,
+                      Constraint<T>* constraint,
                       Visitor* v)
 : Arg( flag, name, desc, req, true, v ),
-  _allowed( allowed )
+  _typeDesc( constraint->shortID() ),
+  _constraint( constraint ),
+  _allowMore(false)
 { 
-        allowedInit();
+        _acceptsMultipleValues = true;
 }
 
@@ -417 +279 @@
                       const std::string& desc,
                       bool req,
-                      const std::vector<T>& allowed,
+                      Constraint<T>* constraint,
                       CmdLineInterface& parser,
                       Visitor* v)
 : Arg( flag, name, desc, req, true, v ),
-  _allowed( allowed )
+  _typeDesc( constraint->shortID() ),
+  _constraint( constraint ),
+  _allowMore(false)
 { 
-        allowedInit();
         parser.add( this );
-}
-
-/**
- *
- */
+        _acceptsMultipleValues = true;
+}
+
 template<class T>
 const std::vector<T>& MultiArg<T>::getValue() { return _values; }
 
-/**
- *
- */
 template<class T>
 bool MultiArg<T>::processArg(int *i, std::vector<std::string>& args) 
@@ -457 +315 @@
                                            toString() ) );
 
+                // always take the first one, regardless of start string
                 if ( value == "" )
                 {
                         (*i)++;
-                        if ( (unsigned int)*i < args.size() )
+                        if ( static_cast<unsigned int>(*i) < args.size() )
                                 _extractValue( args[*i] );
                         else
                                 throw( ArgParseException("Missing a value for this argument!",
                                          toString() ) );
-                }
+                } 
                 else
                         _extractValue( value );
 
+                /*
+                // continuing taking the args until we hit one with a start string 
+                while ( (unsigned int)(*i)+1 < args.size() &&
+                                args[(*i)+1].find_first_of( Arg::flagStartString() ) != 0 &&
+                        args[(*i)+1].find_first_of( Arg::nameStartString() ) != 0 ) 
+                                _extractValue( args[++(*i)] );
+                */
+
+                _alreadySet = true;
                 _checkWithVisitor();
 
@@ -478 +346 @@
 
 /**
- * Checks to see if the value parsed is in the allowed list.
+ *
  */
 template<class T>
-void MultiArg<T>::_checkAllowed( const std::string& val )
-{
-        if ( _allowed.size() > 0 )
-                if ( find(_allowed.begin(),_allowed.end(),_values.back()) 
-                 == _allowed.end() )
-                        throw( CmdLineParseException( "Couldn't find '" + val +
-                                          "' in allowed list.", toString() ) );
+std::string MultiArg<T>::shortID(const std::string& val) const
+{
+        static_cast<void>(val); // Ignore input, don't warn
+        return Arg::shortID(_typeDesc) + " ... ";
 }
 
@@ -494 +359 @@
  */
 template<class T>
-std::string MultiArg<T>::shortID(const std::string& val) const
-{
-        std::string id = Arg::shortID(_typeDesc) + " ... ";
-
-        return id;
-}
-
-/**
- *
- */
-template<class T>
 std::string MultiArg<T>::longID(const std::string& val) const
 {
-        std::string id = Arg::longID(_typeDesc) + "  (accepted multiple times)";
-
-        return id;
+        static_cast<void>(val); // Ignore input, don't warn
+        return Arg::longID(_typeDesc) + "  (accepted multiple times)";
 }
 
@@ -534 +387 @@
 void MultiArg<T>::_extractValue( const std::string& val ) 
 {
-        MULTI_ARG_HELPER::ValueExtractor<T> ve(_values);
-                  
-        int err = ve.extractValue(val);
-
-        if ( err == MULTI_ARG_HELPER::EXTRACT_FAILURE )
-                throw( ArgParseException("Couldn't read argument value "
-                                 "from string '" + val + "'", toString() ) );
-
-        if(err == MULTI_ARG_HELPER::EXTRACT_TOO_MANY)
-            throw( ArgParseException("More than one valid value "
-                                 "parsed from string '" + val + "'", 
-                                                                 toString() ) );                    
-        _checkAllowed( val );
+    try {
+        T tmp;
+        ExtractValue(tmp, val, typename ArgTraits<T>::ValueCategory());
+        _values.push_back(tmp);
+    } catch( ArgParseException &e) {
+        throw ArgParseException(e.error(), toString());
+    }
+
+    if ( _constraint != NULL )
+        if ( ! _constraint->check( _values.back() ) )
+            throw( CmdLineParseException( "Value '" + val +
+                                          "' does not meet constraint: " +
+                                          _constraint->description(), 
+                                          toString() ) );
 }
                 
+template<class T>
+bool MultiArg<T>::allowMore()
+{
+        bool am = _allowMore;
+        _allowMore = true;
+        return am;
+}
+
+template<class T>
+void MultiArg<T>::reset()
+{
+        Arg::reset();
+        _values.clear();
+}
 
 } // namespace TCLAP

trunk/third_party/tclap/StdOutput.h

@@ +1 @@
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
 
 /****************************************************************************** 
@@ -66 +67 @@
                  */
                 virtual void failure(CmdLineInterface& c, 
-                                                     ArgException& e );
+                                     ArgException& e );
 
         protected:
@@ -129 +130 @@
 
 inline void StdOutput::failure( CmdLineInterface& _cmd,
-                                                ArgException& e ) 
+                                                                ArgException& e ) 
 {
         std::string progName = _cmd.getProgramName();
@@ -136 +137 @@
                       << "             " << e.error() << std::endl << std::endl;
 
-        std::cerr << "Brief USAGE: " << std::endl;
-
-        _shortUsage( _cmd, std::cerr ); 
-
-        std::cerr << std::endl << "For complete USAGE and HELP type: " 
-                      << std::endl << "   " << progName << " --help" 
-                          << std::endl << std::endl;
-
-}
-
-inline void StdOutput::_shortUsage( CmdLineInterface& _cmd, 
-                                                    std::ostream& os ) const
+        if ( _cmd.hasHelpAndVersion() )
+                {
+                        std::cerr << "Brief USAGE: " << std::endl;
+
+                        _shortUsage( _cmd, std::cerr ); 
+
+                        std::cerr << std::endl << "For complete USAGE and HELP type: " 
+                                          << std::endl << "   " << progName << " --help" 
+                                          << std::endl << std::endl;
+                }
+        else
+                usage(_cmd);
+
+        throw ExitException(1);
+}
+
+inline void 
+StdOutput::_shortUsage( CmdLineInterface& _cmd, 
+                                                std::ostream& os ) const
 {
         std::list<Arg*> argList = _cmd.getArgList();
@@ -157 +165 @@
 
         // first the xor
-        for ( int i = 0; (unsigned int)i < xorList.size(); i++ )
-        {
-                s += " {";
-                for ( ArgVectorIterator it = xorList[i].begin(); 
-                                                it != xorList[i].end(); it++ )
-                        s += (*it)->shortID() + "|";
-
-                s[s.length()-1] = '}';
-        }
+        for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
+                {
+                        s += " {";
+                        for ( ArgVectorIterator it = xorList[i].begin(); 
+                                  it != xorList[i].end(); it++ )
+                                s += (*it)->shortID() + "|";
+
+                        s[s.length()-1] = '}';
+                }
 
         // then the rest
@@ -173 +181 @@
 
         // if the program name is too long, then adjust the second line offset 
-        int secondLineOffset = (int)(progName.length()) + 2;
+        int secondLineOffset = static_cast<int>(progName.length()) + 2;
         if ( secondLineOffset > 75/2 )
-                        secondLineOffset = (int)(75/2);
-
-        spacePrint( std::cout, s, 75, 3, secondLineOffset );
-}
-
-inline void StdOutput::_longUsage( CmdLineInterface& _cmd, 
-                                               std::ostream& os ) const
+                secondLineOffset = static_cast<int>(75/2);
+
+        spacePrint( os, s, 75, 3, secondLineOffset );
+}
+
+inline void 
+StdOutput::_longUsage( CmdLineInterface& _cmd, 
+                                           std::ostream& os ) const
 {
         std::list<Arg*> argList = _cmd.getArgList();
@@ -189 +198 @@
 
         // first the xor 
-        for ( int i = 0; (unsigned int)i < xorList.size(); i++ )
-        {
-                for ( ArgVectorIterator it = xorList[i].begin(); 
-                          it != xorList[i].end(); 
-                          it++ )
-                {
-                        spacePrint( os, (*it)->longID(), 75, 3, 3 );
-                        spacePrint( os, (*it)->getDescription(), 75, 5, 0 );
-
-                        if ( it+1 != xorList[i].end() )
-                                spacePrint(os, "-- OR --", 75, 9, 0);
-                }
-                os << std::endl << std::endl;
-        }
+        for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
+                {
+                        for ( ArgVectorIterator it = xorList[i].begin(); 
+                                  it != xorList[i].end(); 
+                                  it++ )
+                                {
+                                        spacePrint( os, (*it)->longID(), 75, 3, 3 );
+                                        spacePrint( os, (*it)->getDescription(), 75, 5, 0 );
+
+                                        if ( it+1 != xorList[i].end() )
+                                                spacePrint(os, "-- OR --", 75, 9, 0);
+                                }
+                        os << std::endl << std::endl;
+                }
 
         // then the rest
         for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
                 if ( !xorHandler.contains( (*it) ) )
-                {
-                        spacePrint( os, (*it)->longID(), 75, 3, 3 ); 
-                        spacePrint( os, (*it)->getDescription(), 75, 5, 0 ); 
-                        os << std::endl;
-                }
+                        {
+                                spacePrint( os, (*it)->longID(), 75, 3, 3 ); 
+                                spacePrint( os, (*it)->getDescription(), 75, 5, 0 ); 
+                                os << std::endl;
+                        }
 
         os << std::endl;
@@ -224 +233 @@
                                                            int secondLineOffset ) const
 {
-        int len = (int)(s.length());
+        int len = static_cast<int>(s.length());
 
         if ( (len + indentSpaces > maxWidth) && maxWidth > 0 )
-        {
-                int allowedLen = maxWidth - indentSpaces;
-                int start = 0;
-                while ( start < len )
-                {
-                        // find the substring length
-#if defined (_MSC_VER)             
-                        int stringLen = (std::min)( len - start, allowedLen ); 
-#else
-            int stringLen = std::min( len - start, allowedLen );
-#endif
-
-                        // trim the length so it doesn't end in middle of a word
-                        if ( stringLen == allowedLen )
-                                while ( s[stringLen+start] != ' ' && 
-                                        s[stringLen+start] != ',' &&
-                                        s[stringLen+start] != '|' &&
-                                                stringLen >= 0 )
-                                        stringLen--;
+                {
+                        int allowedLen = maxWidth - indentSpaces;
+                        int start = 0;
+                        while ( start < len )
+                                {
+                                        // find the substring length
+                                        // int stringLen = std::min<int>( len - start, allowedLen );
+                                        // doing it this way to support a VisualC++ 2005 bug 
+                                        using namespace std; 
+                                        int stringLen = min<int>( len - start, allowedLen );
+
+                                        // trim the length so it doesn't end in middle of a word
+                                        if ( stringLen == allowedLen )
+                                                while ( stringLen >= 0 &&
+                                                                s[stringLen+start] != ' ' && 
+                                                                s[stringLen+start] != ',' &&
+                                                                s[stringLen+start] != '|' ) 
+                                                        stringLen--;
         
-                        // ok, the word is longer than the line, so just split in the 
-                        // wherever the line ends
-                        if ( stringLen <= 0 )
-                                stringLen = allowedLen;
-
-                        // check for newlines
-                        for ( int i = 0; i < stringLen; i++ )
-                                if ( s[start+i] == '\n' )
-                                        stringLen = i+1;
-
-                        // print the indent     
+                                        // ok, the word is longer than the line, so just split 
+                                        // wherever the line ends
+                                        if ( stringLen <= 0 )
+                                                stringLen = allowedLen;
+
+                                        // check for newlines
+                                        for ( int i = 0; i < stringLen; i++ )
+                                                if ( s[start+i] == '\n' )
+                                                        stringLen = i+1;
+
+                                        // print the indent     
+                                        for ( int i = 0; i < indentSpaces; i++ )
+                                                os << " ";
+
+                                        if ( start == 0 )
+                                                {
+                                                        // handle second line offsets
+                                                        indentSpaces += secondLineOffset;
+
+                                                        // adjust allowed len
+                                                        allowedLen -= secondLineOffset;
+                                                }
+
+                                        os << s.substr(start,stringLen) << std::endl;
+
+                                        // so we don't start a line with a space
+                                        while ( s[stringLen+start] == ' ' && start < len )
+                                                start++;
+                        
+                                        start += stringLen;
+                                }
+                }
+        else
+                {
                         for ( int i = 0; i < indentSpaces; i++ )
                                 os << " ";
-
-                        if ( start == 0 )
-                        {
-                                // handle second line offsets
-                                indentSpaces += secondLineOffset;
-
-                                // adjust allowed len
-                                allowedLen -= secondLineOffset;
-                        }
-
-                        os << s.substr(start,stringLen) << std::endl;
-
-                        // so we don't start a line with a space
-                        while ( s[stringLen+start] == ' ' && start < len )
-                                start++;
-                        
-                        start += stringLen;
-                }
-        }
-        else
-        {
-                for ( int i = 0; i < indentSpaces; i++ )
-                                os << " ";
-                os << s << std::endl;
-        }
+                        os << s << std::endl;
+                }
 }
 

trunk/third_party/tclap/SwitchArg.h

@@ -46 +46 @@
                 bool _value;
 
+                /**
+                 * Used to support the reset() method so that ValueArg can be
+                 * reset to their constructed value.
+                 */
+        bool _default;
 
         public:
@@ -64 +69 @@
                               const std::string& name, 
                               const std::string& desc,
-                              bool def,
+                              bool def = false,
                                   Visitor* v = NULL);
 
@@ -84 +89 @@
                               const std::string& name, 
                               const std::string& desc,
-                              bool def,
                                   CmdLineInterface& parser,
+                              bool def = false,
                                   Visitor* v = NULL);
                                   
@@ -109 +114 @@
                  */
                 bool getValue();
+                
+                virtual void reset();
+
 };
 
@@ -117 +125 @@
                                  const std::string& name, 
                                  const std::string& desc, 
-                         bool _default,
+                         bool default_val,
                                          Visitor* v )
 : Arg(flag, name, desc, false, false, v),