Format code using uncrustify

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

24 files changed, 4582 insertions, 4538 deletions

diff --git a/src/tclap/Arg.h b/src/tclap/Arg.h
index 3d44c85..a65822b 100755..100644
--- a/src/tclap/Arg.h
+++ b/src/tclap/Arg.h
@@ -26,9 +26,9 @@
 #define TCLAP_ARGUMENT_H
 
 #ifdef HAVE_CONFIG_H
-#include <config.h>
+ #include <config.h>
 #else
-#define HAVE_SSTREAM
+ #define HAVE_SSTREAM
 #endif
 
 #include <string>
@@ -38,14 +38,14 @@
 #include <iomanip>
 #include <cstdio>
 
-#if defined(HAVE_SSTREAM)
-#include <sstream>
+#if defined (HAVE_SSTREAM)
+ #include <sstream>
 typedef std::istringstream istringstream;
-#elif defined(HAVE_STRSTREAM)
-#include <strstream>
+#elif defined (HAVE_STRSTREAM)
+ #include <strstream>
 typedef std::istrstream istringstream;
 #else
-#error "Need a stringstream (sstream or strstream) to compile!"
+ #error "Need a stringstream (sstream or strstream) to compile!"
 #endif
 
 #include <tclap/ArgException.h>
@@ -54,619 +54,696 @@ typedef std::istrstream istringstream;
 #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.
- */
-class Arg
-{
-	private:
-
-		/**
-		 * Indicates whether the rest of the arguments should be ignored.
-		 */
-		static bool& ignoreRestRef() { static bool ign = false; return ign; }
-
-		/**
-		 * The delimiter that separates an argument flag/name from the
-		 * value.
-		 */
-		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,
-		 * in fact this is how unlabeled args work.  Unlabeled args must
-		 * override appropriate functions to get correct handling. Note
-		 * that the _flag does NOT include the dash as part of the flag.
-		 */
-		std::string _flag;
-
-		/**
-		 * A single work namd indentifying the argument.
-		 * 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
-		 * _name cannot be blank.
-		 */
-		std::string _name;
-
-		/**
-		 * Description of the argument.
-		 */
-		std::string _description;
-
-		/**
-		 * Indicating whether the argument is required.
-		 */
-		bool _required;
-
-		/**
-		 * Label to be used in usage description.  Normally set to
-		 * "required", but can be changed when necessary.
-		 */
-		std::string _requireLabel;
-
-		/**
-		 * Indicates whether a value is required for the argument.
-		 * Note that the value may be required but the argument/value
-		 * combination may not be, as specified by _required.
-		 */
-		bool _valueRequired;
-
-		/**
-		 * Indicates whether the argument has been set.
-		 * Indicates that a value on the command line has matched the
-		 * name/flag of this argument and the values have been set accordingly.
-		 */
-		bool _alreadySet;
-
-		/**
-		 * A pointer to a vistitor object.
-		 * The visitor allows special handling to occur as soon as the
-		 * argument is matched.  This defaults to NULL and should not
-		 * be used unless absolutely necessary.
-		 */
-		Visitor* _visitor;
-
-		/**
-		 * Whether this argument can be ignored, if desired.
-		 */
-		bool _ignoreable;
-
-		/**
-		 * Indicates that the arg was set as part of an XOR and not on the
-		 * command line.
-		 */
-		bool _xorSet;
-
-		bool _acceptsMultipleValues;
-
-		/**
-		 * Performs the special handling described by the Vistitor.
-		 */
-		void _checkWithVisitor() const;
-
-		/**
-		 * 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,
-		 * UnlabeledValueArg, or UnlabeledMultiArg instead.
-		 *
-		 * \param flag - The flag identifying the argument.
-		 * \param name - The name identifying the argument.
-		 * \param desc - The description of the argument, used in the usage.
-		 * \param req - Whether the argument is required.
-		 * \param valreq - Whether the a value is required for the argument.
-		 * \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,
-			 bool valreq,
-			 Visitor* v = NULL );
-
-	public:
-		/**
-		 * Destructor.
-		 */
-		virtual ~Arg();
-
-		/**
-		 * Adds this to the specified list of Args.
-		 * \param argList - The list to add this to.
-		 */
-		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.
-		 */
-		static bool ignoreRest() { return ignoreRestRef(); }
-
-		/**
-		 * The delimiter that separates an argument flag/name from the
-		 * value.
-		 */
-		static char delimiter() { return delimiterRef(); }
-
-		/**
-		 * The char used as a place holder when SwitchArgs are combined.
-		 * 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 char flagStartChar() { return '-'; }
-
-		/**
-		 * The sting that indicates the beginning of a flag.  Currently "-".
-		 * Should be identical to flagStartChar.
-		 */
-		static const std::string flagStartString() { return "-"; }
-
-		/**
-		 * The sting that indicates the beginning of a name.  Currently "--".
-		 * Should be flagStartChar twice.
-		 */
-		static const std::string nameStartString() { return "--"; }
-
-		/**
-		 * The name used to identify the ignore rest argument.
-		 */
-		static const std::string ignoreNameString() { return "ignore_rest"; }
-
-		/**
-		 * Sets the delimiter for all arguments.
-		 * \param c - The character that delimits flags/names from values.
-		 */
-		static void setDelimiter( char c ) { delimiterRef() = c; }
-
-		/**
-		 * Pure virtual method meant to handle the parsing and value assignment
-		 * 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
-		 * passed in from main.
-		 */
-		virtual bool processArg(int *i, std::vector<std::string>& args) = 0;
-
-		/**
-		 * Operator ==.
-		 * Equality operator. Must be virtual to handle unlabeled args.
-		 * \param a - The Arg to be compared to this.
-		 */
-		virtual bool operator==(const Arg& a) const;
-
-		/**
-		 * Returns the argument flag.
-		 */
-		const std::string& getFlag() const;
-
-		/**
-		 * Returns the argument name.
-		 */
-		const std::string& getName() const;
-
-		/**
-		 * Returns the argument description.
-		 */
-		std::string getDescription() const;
-
-		/**
-		 * Indicates whether the argument is required.
-		 */
-		virtual bool isRequired() const;
-
-		/**
-		 * Sets _required to true. This is used by the XorHandler.
-		 * You really have no reason to ever use it.
-		 */
-		void forceRequired();
-
-		/**
-		 * Sets the _alreadySet value to true.  This is used by the XorHandler.
-		 * You really have no reason to ever use it.
-		 */
-		void xorSet();
-
-		/**
-		 * Indicates whether a value must be specified for argument.
-		 */
-		bool isValueRequired() const;
-
-		/**
-		 * Indicates whether the argument has already been set.  Only true
-		 * if the arg has been matched on the command line.
-		 */
-		bool isSet() const;
-
-		/**
-		 * Indicates whether the argument can be ignored, if desired.
-		 */
-		bool isIgnoreable() const;
-
-		/**
-		 * 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
-		 * arguments are specified on the command line.
-		 * \param s - The string to be compared to the flag/name to determine
-		 * whether the arg matches.
-		 */
-		virtual bool argMatches( const std::string& s ) const;
-
-		/**
-		 * Returns a simple string representation of the argument.
-		 * Primarily for debugging.
-		 */
-		virtual std::string toString() const;
-
-		/**
-		 * Returns a short ID for the usage.
-		 * \param valueId - The value used in the id.
-		 */
-		virtual std::string shortID( const std::string& valueId = "val" ) const;
-
-		/**
-		 * Returns a long ID for the usage.
-		 * \param valueId - The value used in the id.
-		 */
-		virtual std::string longID( const std::string& valueId = "val" ) const;
-
-		/**
-		 * 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 value - Where the value trimmed from the string will
-		 * be stored.
-		 */
-		virtual void trimFlag( std::string& flag, std::string& value ) const;
-
-		/**
-		 * Checks whether a given string has blank chars, indicating that
-		 * it is a combined SwitchArg.  If so, return true, otherwise return
-		 * false.
-		 * \param s - string to be checked.
-		 */
-		bool _hasBlanks( const std::string& s ) const;
-
-		/**
-		 * Sets the requireLabel. Used by XorHandler.  You shouldn't ever
-		 * use this.
-		 * \param s - Set the requireLabel to this value.
-		 */
-		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();
-};
-
-/**
- * Typedef of an Arg list iterator.
- */
-typedef std::list<Arg*>::iterator ArgListIterator;
-
-/**
- * Typedef of an Arg vector iterator.
- */
-typedef std::vector<Arg*>::iterator ArgVectorIterator;
-
-/**
- * Typedef of a Visitor list iterator.
- */
-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)
+namespace TCLAP
 {
-    static_cast<void>(vl); // Avoid warning about unused vl
-    std::istringstream is(strVal);
+	/**
+	 * 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.
+	 */
+	class Arg
+	{
+		private:
+
+			/**
+			 * Indicates whether the rest of the arguments should be ignored.
+			 */
+			static bool& ignoreRestRef()
+			{
+				static bool ign = false;
+				return ign;
+			}
+
+			/**
+			 * The delimiter that separates an argument flag/name from the
+			 * value.
+			 */
+			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,
+			 * in fact this is how unlabeled args work.  Unlabeled args must
+			 * override appropriate functions to get correct handling. Note
+			 * that the _flag does NOT include the dash as part of the flag.
+			 */
+			std::string _flag;
+
+			/**
+			 * A single work namd indentifying the argument.
+			 * 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
+			 * _name cannot be blank.
+			 */
+			std::string _name;
+
+			/**
+			 * Description of the argument.
+			 */
+			std::string _description;
+
+			/**
+			 * Indicating whether the argument is required.
+			 */
+			bool _required;
+
+			/**
+			 * Label to be used in usage description.  Normally set to
+			 * "required", but can be changed when necessary.
+			 */
+			std::string _requireLabel;
+
+			/**
+			 * Indicates whether a value is required for the argument.
+			 * Note that the value may be required but the argument/value
+			 * combination may not be, as specified by _required.
+			 */
+			bool _valueRequired;
+
+			/**
+			 * Indicates whether the argument has been set.
+			 * Indicates that a value on the command line has matched the
+			 * name/flag of this argument and the values have been set accordingly.
+			 */
+			bool _alreadySet;
+
+			/**
+			 * A pointer to a vistitor object.
+			 * The visitor allows special handling to occur as soon as the
+			 * argument is matched.  This defaults to NULL and should not
+			 * be used unless absolutely necessary.
+			 */
+			Visitor *_visitor;
+
+			/**
+			 * Whether this argument can be ignored, if desired.
+			 */
+			bool _ignoreable;
+
+			/**
+			 * Indicates that the arg was set as part of an XOR and not on the
+			 * command line.
+			 */
+			bool _xorSet;
+
+			bool _acceptsMultipleValues;
+
+			/**
+			 * Performs the special handling described by the Vistitor.
+			 */
+			void _checkWithVisitor() const;
+
+			/**
+			 * 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,
+			 * UnlabeledValueArg, or UnlabeledMultiArg instead.
+			 *
+			 * \param flag - The flag identifying the argument.
+			 * \param name - The name identifying the argument.
+			 * \param desc - The description of the argument, used in the usage.
+			 * \param req - Whether the argument is required.
+			 * \param valreq - Whether the a value is required for the argument.
+			 * \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,
+			        bool valreq, Visitor *v = NULL);
+
+		public:
+			/**
+			 * Destructor.
+			 */
+			virtual ~Arg();
+
+			/**
+			 * Adds this to the specified list of Args.
+			 * \param argList - The list to add this to.
+			 */
+			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.
+			 */
+			static bool ignoreRest()
+			{
+				return ignoreRestRef();
+			}
+
+			/**
+			 * The delimiter that separates an argument flag/name from the
+			 * value.
+			 */
+			static char delimiter()
+			{
+				return delimiterRef();
+			}
+
+			/**
+			 * The char used as a place holder when SwitchArgs are combined.
+			 * 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 char flagStartChar()
+			{
+				return '-';
+			}
+
+			/**
+			 * The sting that indicates the beginning of a flag.  Currently "-".
+			 * Should be identical to flagStartChar.
+			 */
+			static const std::string flagStartString()
+			{
+				return "-";
+			}
+
+			/**
+			 * The sting that indicates the beginning of a name.  Currently "--".
+			 * Should be flagStartChar twice.
+			 */
+			static const std::string nameStartString()
+			{
+				return "--";
+			}
+
+			/**
+			 * The name used to identify the ignore rest argument.
+			 */
+			static const std::string ignoreNameString()
+			{
+				return "ignore_rest";
+			}
+
+			/**
+			 * Sets the delimiter for all arguments.
+			 * \param c - The character that delimits flags/names from values.
+			 */
+			static void setDelimiter(char c)
+			{
+				delimiterRef() = c;
+			}
+
+			/**
+			 * Pure virtual method meant to handle the parsing and value assignment
+			 * 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
+			 * passed in from main.
+			 */
+			virtual bool processArg(int *i, std::vector<std::string> &args) = 0;
+
+			/**
+			 * Operator ==.
+			 * Equality operator. Must be virtual to handle unlabeled args.
+			 * \param a - The Arg to be compared to this.
+			 */
+			virtual bool operator==(const Arg &a) const;
+
+			/**
+			 * Returns the argument flag.
+			 */
+			const std::string& getFlag() const;
+
+			/**
+			 * Returns the argument name.
+			 */
+			const std::string& getName() const;
+
+			/**
+			 * Returns the argument description.
+			 */
+			std::string getDescription() const;
+
+			/**
+			 * Indicates whether the argument is required.
+			 */
+			virtual bool isRequired() const;
+
+			/**
+			 * Sets _required to true. This is used by the XorHandler.
+			 * You really have no reason to ever use it.
+			 */
+			void forceRequired();
+
+			/**
+			 * Sets the _alreadySet value to true.  This is used by the XorHandler.
+			 * You really have no reason to ever use it.
+			 */
+			void xorSet();
+
+			/**
+			 * Indicates whether a value must be specified for argument.
+			 */
+			bool isValueRequired() const;
+
+			/**
+			 * Indicates whether the argument has already been set.  Only true
+			 * if the arg has been matched on the command line.
+			 */
+			bool isSet() const;
+
+			/**
+			 * Indicates whether the argument can be ignored, if desired.
+			 */
+			bool isIgnoreable() const;
+
+			/**
+			 * 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
+			 * arguments are specified on the command line.
+			 * \param s - The string to be compared to the flag/name to determine
+			 * whether the arg matches.
+			 */
+			virtual bool argMatches(const std::string &s) const;
+
+			/**
+			 * Returns a simple string representation of the argument.
+			 * Primarily for debugging.
+			 */
+			virtual std::string toString() const;
+
+			/**
+			 * Returns a short ID for the usage.
+			 * \param valueId - The value used in the id.
+			 */
+			virtual std::string shortID(const std::string &valueId = "val") const;
+
+			/**
+			 * Returns a long ID for the usage.
+			 * \param valueId - The value used in the id.
+			 */
+			virtual std::string longID(const std::string &valueId = "val") const;
+
+			/**
+			 * 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 value - Where the value trimmed from the string will
+			 * be stored.
+			 */
+			virtual void trimFlag(std::string &flag, std::string &value) const;
+
+			/**
+			 * Checks whether a given string has blank chars, indicating that
+			 * it is a combined SwitchArg.  If so, return true, otherwise return
+			 * false.
+			 * \param s - string to be checked.
+			 */
+			bool _hasBlanks(const std::string &s) const;
+
+			/**
+			 * Sets the requireLabel. Used by XorHandler.  You shouldn't ever
+			 * use this.
+			 * \param s - Set the requireLabel to this value.
+			 */
+			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();
+	};
+
+	/**
+	 * Typedef of an Arg list iterator.
+	 */
+	typedef std::list<Arg*>::iterator ArgListIterator;
+
+	/**
+	 * Typedef of an Arg vector iterator.
+	 */
+	typedef std::vector<Arg*>::iterator ArgVectorIterator;
+
+	/**
+	 * Typedef of a Visitor list iterator.
+	 */
+	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 )
+		int valuesRead = 0;
+		while (is.good())
+		{
+			if (is.peek() != EOF)
 #ifdef TCLAP_SETBASE_ZERO
-	    is >> std::setbase(0) >> destVal;
+			{
+				is >> std::setbase(0) >> destVal;
+			}
 #else
-	    is >> destVal;
+			{
+				is >> destVal;
+			}
 #endif
-	else
-	    break;
+			else
+			{
+				break;
+			}
 
-	valuesRead++;
-    }
+			valuesRead++;
+		}
 
-    if ( is.fail() )
-	throw( ArgParseException("Couldn't read argument value "
-				 "from string '" + strVal + "'"));
+		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 + "'"));
+		}
+	}
 
-    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);
+	}
 
-}
+	//////////////////////////////////////////////////////////////////////
+	//BEGIN Arg.cpp
+	//////////////////////////////////////////////////////////////////////
 
-/*
- * 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);
-}
-
-//////////////////////////////////////////////////////////////////////
-//BEGIN Arg.cpp
-//////////////////////////////////////////////////////////////////////
-
-inline Arg::Arg(const std::string& flag,
-         const std::string& name,
-         const std::string& desc,
-         bool req,
-         bool valreq,
-         Visitor* v) :
-  _flag(flag),
-  _name(name),
-  _description(desc),
-  _required(req),
-  _requireLabel("required"),
-  _valueRequired(valreq),
-  _alreadySet(false),
-  _visitor( v ),
-  _ignoreable(true),
-  _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() ||
-		   _flag == " " ) )
-		throw(SpecificationException("Argument flag cannot be either '" +
-							Arg::flagStartString() + "' or '" +
-							Arg::nameStartString() + "' or a space.",
-							toString() ) );
-
-	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 begin with either '" +
-							Arg::flagStartString() + "' or '" +
-							Arg::nameStartString() + "' or space.",
-							toString() ) );
-
-}
-
-inline Arg::~Arg() { }
-
-inline std::string Arg::shortID( const std::string& valueId ) const
-{
-	std::string id = "";
+	inline Arg::Arg(const std::string &flag, const std::string &name, const std::string &desc,
+	        bool req, bool valreq, Visitor *v) :
+			_flag(flag), _name(name), _description(desc), _required(req), _requireLabel("required"),
+			_valueRequired(valreq), _alreadySet(false), _visitor(v), _ignoreable(true),
+			_xorSet(false), _acceptsMultipleValues(false)
+	{
+		if (_flag.length() > 1)
+		{
+			throw (SpecificationException(
+							"Argument flag can only be one character long", toString()));
+		}
 
-	if ( _flag != "" )
-		id = Arg::flagStartString() + _flag;
-	else
-		id = Arg::nameStartString() + _name;
+		if (_name != ignoreNameString() &&
+		        (_flag == Arg::flagStartString() ||
+		        _flag == Arg::nameStartString() ||
+		        _flag == " "))
+		{
+			throw (SpecificationException("Argument flag cannot be either '" + Arg::flagStartString() +
+			      "' or '" + Arg::nameStartString() + "' or a space.", toString()));
+		}
 
-	if ( _valueRequired )
-		id += std::string( 1, Arg::delimiter() ) + "<" + valueId  + ">";
+		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 begin with either '" + Arg::flagStartString() +
+			      "' or '" + Arg::nameStartString() + "' or space.", toString()));
+		}
+	}
 
-	if ( !_required )
-		id = "[" + id + "]";
+	inline Arg::~Arg()
+	{
+	}
 
-	return id;
-}
+	inline std::string Arg::shortID(const std::string &valueId) const
+	{
+		std::string id = "";
 
-inline std::string Arg::longID( const std::string& valueId ) const
-{
-	std::string id = "";
+		if (_flag != "")
+		{
+			id = Arg::flagStartString() + _flag;
+		}
+		else
+		{
+			id = Arg::nameStartString() + _name;
+		}
 
-	if ( _flag != "" )
-	{
-		id += Arg::flagStartString() + _flag;
+		if (_valueRequired)
+		{
+			id += std::string(1, Arg::delimiter()) + "<" + valueId + ">";
+		}
 
-		if ( _valueRequired )
-			id += std::string( 1, Arg::delimiter() ) + "<" + valueId + ">";
+		if (!_required)
+		{
+			id = "[" + id + "]";
+		}
 
-		id += ",  ";
+		return id;
 	}
 
-	id += Arg::nameStartString() + _name;
+	inline std::string Arg::longID(const std::string &valueId) const
+	{
+		std::string id = "";
 
-	if ( _valueRequired )
-		id += std::string( 1, Arg::delimiter() ) + "<" + valueId + ">";
+		if (_flag != "")
+		{
+			id += Arg::flagStartString() + _flag;
 
-	return id;
+			if (_valueRequired)
+			{
+				id += std::string(1, Arg::delimiter()) + "<" + valueId + ">";
+			}
 
-}
+			id += ",  ";
+		}
 
-inline bool Arg::operator==(const Arg& a) const
-{
-	if ( ( _flag != "" && _flag == a._flag ) || _name == a._name)
-		return true;
-	else
-		return false;
-}
+		id += Arg::nameStartString() + _name;
 
-inline std::string Arg::getDescription() const
-{
-	std::string desc = "";
-	if ( _required )
-		desc = "(" + _requireLabel + ")  ";
+		if (_valueRequired)
+		{
+			id += std::string(1, Arg::delimiter()) + "<" + valueId + ">";
+		}
 
-//	if ( _valueRequired )
-//		desc += "(value required)  ";
+		return id;
+	}
 
-	desc += _description;
-	return desc;
-}
+	inline bool Arg::operator==(const Arg &a) const
+	{
+		if ((_flag != "" && _flag == a._flag) || _name == a._name)
+		{
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
 
-inline const std::string& Arg::getFlag() const { return _flag; }
+	inline std::string Arg::getDescription() const
+	{
+		std::string desc = "";
+		if (_required)
+		{
+			desc = "(" + _requireLabel + ")  ";
+		}
 
-inline const std::string& Arg::getName() const { return _name; }
+		//	if ( _valueRequired )
+		//		desc += "(value required)  ";
 
-inline bool Arg::isRequired() const { return _required; }
+		desc += _description;
+		return desc;
+	}
 
-inline bool Arg::isValueRequired() const { return _valueRequired; }
+	inline const std::string& Arg::getFlag() const
+	{
+		return _flag;
+	}
 
-inline bool Arg::isSet() const
-{
-	if ( _alreadySet && !_xorSet )
-		return true;
-	else
-		return false;
-}
+	inline const std::string& Arg::getName() const
+	{
+		return _name;
+	}
 
-inline bool Arg::isIgnoreable() const { return _ignoreable; }
+	inline bool Arg::isRequired() const
+	{
+		return _required;
+	}
 
-inline void Arg::setRequireLabel( const std::string& s)
-{
-	_requireLabel = s;
-}
+	inline bool Arg::isValueRequired() const
+	{
+		return _valueRequired;
+	}
 
-inline bool Arg::argMatches( const std::string& argFlag ) const
-{
-	if ( ( argFlag == Arg::flagStartString() + _flag && _flag != "" ) ||
-		 argFlag == Arg::nameStartString() + _name )
-		return true;
-	else
-		return false;
-}
+	inline bool Arg::isSet() const
+	{
+		if (_alreadySet && !_xorSet)
+		{
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
 
-inline std::string Arg::toString() const
-{
-	std::string s = "";
+	inline bool Arg::isIgnoreable() const
+	{
+		return _ignoreable;
+	}
 
-	if ( _flag != "" )
-		s += Arg::flagStartString() + _flag + " ";
+	inline void Arg::setRequireLabel(const std::string &s)
+	{
+		_requireLabel = s;
+	}
 
-	s += "(" + Arg::nameStartString() + _name + ")";
+	inline bool Arg::argMatches(const std::string &argFlag) const
+	{
+		if ((argFlag == Arg::flagStartString() + _flag && _flag != "") ||
+		        argFlag == Arg::nameStartString() + _name)
+		{
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
 
-	return s;
-}
+	inline std::string Arg::toString() const
+	{
+		std::string s = "";
 
-inline void Arg::_checkWithVisitor() const
-{
-	if ( _visitor != NULL )
-		_visitor->visit();
-}
-
-/**
- * Implementation of trimFlag.
- */
-inline void Arg::trimFlag(std::string& flag, std::string& value) const
-{
-	int stop = 0;
-	for ( int i = 0; static_cast<unsigned int>(i) < flag.length(); i++ )
-		if ( flag[i] == Arg::delimiter() )
+		if (_flag != "")
 		{
-			stop = i;
-			break;
+			s += Arg::flagStartString() + _flag + " ";
 		}
 
-	if ( stop > 1 )
+		s += "(" + Arg::nameStartString() + _name + ")";
+
+		return s;
+	}
+
+	inline void Arg::_checkWithVisitor() const
 	{
-		value = flag.substr(stop+1);
-		flag = flag.substr(0,stop);
+		if (_visitor != NULL)
+		{
+			_visitor->visit();
+		}
 	}
 
-}
+	/**
+	 * Implementation of trimFlag.
+	 */
+	inline void Arg::trimFlag(std::string &flag, std::string &value) const
+	{
+		int stop = 0;
+		for (int i = 0; static_cast<unsigned int>(i) < flag.length(); i++)
+		{
+			if (flag[i] == Arg::delimiter())
+			{
+				stop = i;
+				break;
+			}
+		}
 
-/**
- * Implementation of _hasBlanks.
- */
-inline bool Arg::_hasBlanks( const std::string& s ) const
-{
-	for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
-		if ( s[i] == Arg::blankChar() )
-			return true;
+		if (stop > 1)
+		{
+			value = flag.substr(stop + 1);
+			flag  = flag.substr(0, stop);
+		}
+	}
 
-	return false;
-}
+	/**
+	 * Implementation of _hasBlanks.
+	 */
+	inline bool Arg::_hasBlanks(const std::string &s) const
+	{
+		for (int i = 1; static_cast<unsigned int>(i) < s.length(); i++)
+		{
+			if (s[i] == Arg::blankChar())
+			{
+				return true;
+			}
+		}
 
-inline void Arg::forceRequired()
-{
-	_required = true;
-}
+		return false;
+	}
 
-inline void Arg::xorSet()
-{
-	_alreadySet = true;
-	_xorSet = true;
-}
-
-/**
- * Overridden by Args that need to added to the end of the list.
- */
-inline void Arg::addToList( std::list<Arg*>& argList ) const
-{
-	argList.push_front( const_cast<Arg*>(this) );
-}
+	inline void Arg::forceRequired()
+	{
+		_required = true;
+	}
 
-inline bool Arg::allowMore()
-{
-	return false;
-}
+	inline void Arg::xorSet()
+	{
+		_alreadySet = true;
+		_xorSet     = true;
+	}
 
-inline bool Arg::acceptsMultipleValues()
-{
-	return _acceptsMultipleValues;
-}
+	/**
+	 * Overridden by Args that need to added to the end of the list.
+	 */
+	inline void Arg::addToList(std::list<Arg*> &argList) const
+	{
+		argList.push_front(const_cast<Arg*>(this));
+	}
 
-inline void Arg::reset()
-{
-	_xorSet = false;
-	_alreadySet = false;
-}
+	inline bool Arg::allowMore()
+	{
+		return false;
+	}
+
+	inline bool Arg::acceptsMultipleValues()
+	{
+		return _acceptsMultipleValues;
+	}
 
-//////////////////////////////////////////////////////////////////////
-//END Arg.cpp
-//////////////////////////////////////////////////////////////////////
+	inline void Arg::reset()
+	{
+		_xorSet     = false;
+		_alreadySet = false;
+	}
 
+	//////////////////////////////////////////////////////////////////////
+	//END Arg.cpp
+	//////////////////////////////////////////////////////////////////////
 } //namespace TCLAP
 
 #endif
-
diff --git a/src/tclap/ArgException.h b/src/tclap/ArgException.h
index 3411aa9..be0b817 100755..100644
--- a/src/tclap/ArgException.h
+++ b/src/tclap/ArgException.h
@@ -1,24 +1,24 @@
 // -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
 
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  ArgException.h
- * 
+ *
  *  Copyright (c) 2003, Michael E. Smoot .
  *  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_ARG_EXCEPTION_H
@@ -27,174 +27,182 @@
 #include <string>
 #include <exception>
 
-namespace TCLAP {
-
-/**
- * A simple class that defines and argument exception.  Should be caught
- * whenever a CmdLine is created and parsed.
- */
-class ArgException : public std::exception
-{
-	public:
-	
-		/**
-		 * Constructor.
-		 * \param text - The text of the exception.
-		 * \param id - The text identifying the argument source.
-		 * \param td - Text describing the type of ArgException it is.
-		 * of the exception.
-		 */
-		ArgException( const std::string& text = "undefined exception", 
-					  const std::string& id = "undefined",
-					  const std::string& td = "Generic ArgException")
-			: std::exception(), 
-			  _errorText(text), 
-			  _argId( id ), 
-			  _typeDescription(td)
-		{ } 
-		
-		/**
-		 * Destructor.
-		 */
-		virtual ~ArgException() throw() { }
-
-		/**
-		 * Returns the error text.
-		 */
-		std::string error() const { return ( _errorText ); }
-
-		/**
-		 * Returns the argument id.
-		 */
-		std::string argId() const  
-		{ 
-			if ( _argId == "undefined" )
-				return " ";
-			else
-				return ( "Argument: " + _argId ); 
-		}
-
-		/**
-		 * Returns the arg id and error text. 
-		 */
-		const char* what() const throw() 
-		{
-			static std::string ex; 
-			ex = _argId + " -- " + _errorText;
-			return ex.c_str();
-		}
-
-		/**
-		 * Returns the type of the exception.  Used to explain and distinguish
-		 * between different child exceptions.
-		 */
-		std::string typeDescription() const
-		{
-			return _typeDescription; 
-		}
-
-
-	private:
-
-		/**
-		 * The text of the exception message.
-		 */
-		std::string _errorText;
-
-		/**
-		 * The argument related to this exception.
-		 */
-		std::string _argId;
-
-		/**
-		 * Describes the type of the exception.  Used to distinguish
-		 * between different child exceptions.
-		 */
-		std::string _typeDescription;
-
-};
-
-/**
- * Thrown from within the child Arg classes when it fails to properly
- * parse the argument it has been passed.
- */
-class ArgParseException : public ArgException
-{ 
-	public:
-		/**
-		 * Constructor.
-		 * \param text - The text of the exception.
-		 * \param id - The text identifying the argument source 
-		 * of the exception.
-		 */
-		ArgParseException( const std::string& text = "undefined exception", 
-					       const std::string& id = "undefined" )
-			: ArgException( text, 
-			                id, 
-							std::string( "Exception found while parsing " ) + 
-							std::string( "the value the Arg has been passed." ))
-			{ }
-};
-
-/**
- * Thrown from CmdLine when the arguments on the command line are not
- * properly specified, e.g. too many arguments, required argument missing, etc.
- */
-class CmdLineParseException : public ArgException
-{
-	public:
-		/**
-		 * Constructor.
-		 * \param text - The text of the exception.
-		 * \param id - The text identifying the argument source 
-		 * of the exception.
-		 */
-		CmdLineParseException( const std::string& text = "undefined exception", 
-					           const std::string& id = "undefined" )
-			: ArgException( text, 
-			                id,
-							std::string( "Exception found when the values ") +
-							std::string( "on the command line do not meet ") +
-							std::string( "the requirements of the defined ") +
-							std::string( "Args." ))
-		{ }
-};
-
-/**
- * Thrown from Arg and CmdLine when an Arg is improperly specified, e.g. 
- * same flag as another Arg, same name, etc.
- */
-class SpecificationException : public ArgException
+namespace TCLAP
 {
-	public:
-		/**
-		 * Constructor.
-		 * \param text - The text of the exception.
-		 * \param id - The text identifying the argument source 
-		 * of the exception.
-		 */
-		SpecificationException( const std::string& text = "undefined exception",
-					            const std::string& id = "undefined" )
-			: ArgException( text, 
-			                id,
-							std::string("Exception found when an Arg object ")+
-							std::string("is improperly defined by the ") +
-							std::string("developer." )) 
-		{ }
-
-};
-
-class ExitException {
-public:
-	ExitException(int estat) : _estat(estat) {}
-
-	int getExitStatus() const { return _estat; }
-
-private:
-	int _estat;
-};
-
+	/**
+	 * A simple class that defines and argument exception.  Should be caught
+	 * whenever a CmdLine is created and parsed.
+	 */
+	class ArgException : public std::exception
+	{
+		public:
+			/**
+			 * Constructor.
+			 * \param text - The text of the exception.
+			 * \param id - The text identifying the argument source.
+			 * \param td - Text describing the type of ArgException it is.
+			 * of the exception.
+			 */
+			ArgException(const std::string &text = "undefined exception",
+			        const std::string &id = "undefined",
+			        const std::string &td = "Generic ArgException") :
+					std::exception(), _errorText(text), _argId(id), _typeDescription(td)
+			{
+			}
+
+			/**
+			 * Destructor.
+			 */
+			virtual ~ArgException() throw ()
+			{
+			}
+
+			/**
+			 * Returns the error text.
+			 */
+			std::string error() const
+			{
+				return _errorText;
+			}
+
+			/**
+			 * Returns the argument id.
+			 */
+			std::string argId() const
+			{
+				if (_argId == "undefined")
+				{
+					return " ";
+				}
+				else
+				{
+					return "Argument: " + _argId;
+				}
+			}
+
+			/**
+			 * Returns the arg id and error text.
+			 */
+			const char* what() const throw ()
+			{
+				static std::string ex;
+				ex = _argId + " -- " + _errorText;
+				return ex.c_str();
+			}
+
+			/**
+			 * Returns the type of the exception.  Used to explain and distinguish
+			 * between different child exceptions.
+			 */
+			std::string typeDescription() const
+			{
+				return _typeDescription;
+			}
+
+		private:
+			/**
+			 * The text of the exception message.
+			 */
+			std::string _errorText;
+
+			/**
+			 * The argument related to this exception.
+			 */
+			std::string _argId;
+
+			/**
+			 * Describes the type of the exception.  Used to distinguish
+			 * between different child exceptions.
+			 */
+			std::string _typeDescription;
+	};
+
+	/**
+	 * Thrown from within the child Arg classes when it fails to properly
+	 * parse the argument it has been passed.
+	 */
+	class ArgParseException : public ArgException
+	{
+		public:
+			/**
+			 * Constructor.
+			 * \param text - The text of the exception.
+			 * \param id - The text identifying the argument source
+			 * of the exception.
+			 */
+			ArgParseException(const std::string &text = "undefined exception",
+			        const std::string &id             = "undefined") :
+					ArgException(text,
+					        id,
+					        std::string("Exception found while parsing ") +
+					        std::string("the value the Arg has been passed."))
+			{
+			}
+	};
+
+	/**
+	 * Thrown from CmdLine when the arguments on the command line are not
+	 * properly specified, e.g. too many arguments, required argument missing, etc.
+	 */
+	class CmdLineParseException : public ArgException
+	{
+		public:
+			/**
+			 * Constructor.
+			 * \param text - The text of the exception.
+			 * \param id - The text identifying the argument source
+			 * of the exception.
+			 */
+			CmdLineParseException(const std::string &text = "undefined exception",
+			        const std::string &id                 = "undefined") :
+					ArgException(text,
+					        id,
+					        std::string("Exception found when the values ") +
+					        std::string("on the command line do not meet ") +
+					        std::string("the requirements of the defined ") + std::string("Args."))
+			{
+			}
+	};
+
+	/**
+	 * Thrown from Arg and CmdLine when an Arg is improperly specified, e.g.
+	 * same flag as another Arg, same name, etc.
+	 */
+	class SpecificationException : public ArgException
+	{
+		public:
+			/**
+			 * Constructor.
+			 * \param text - The text of the exception.
+			 * \param id - The text identifying the argument source
+			 * of the exception.
+			 */
+			SpecificationException(const std::string &text = "undefined exception",
+			        const std::string &id                  = "undefined") :
+					ArgException(text,
+					        id,
+					        std::string("Exception found when an Arg object ") +
+					        std::string("is improperly defined by the ") + std::string("developer."))
+			{
+			}
+	};
+
+	class ExitException
+	{
+		public:
+			ExitException(int estat) :
+					_estat(estat)
+			{
+			}
+
+			int getExitStatus() const
+			{
+				return _estat;
+			}
+
+		private:
+			int _estat;
+	};
 } // namespace TCLAP
 
 #endif
-
diff --git a/src/tclap/ArgTraits.h b/src/tclap/ArgTraits.h
index a89ed12..7a4a892 100755..100644
--- a/src/tclap/ArgTraits.h
+++ b/src/tclap/ArgTraits.h
@@ -24,58 +24,62 @@
 // include this directly
 
 #ifndef TCLAP_ARGTRAITS_H
-#define TCLAP_ARGTRAITS_H
+ #define TCLAP_ARGTRAITS_H
 
-namespace TCLAP {
+namespace TCLAP
+{
+	// We use two empty structs to get compile type specialization
+	// function to work
 
-// We use two empty structs to get compile type specialization
-// function to work
+	/**
+	 * A value like argument value type is a value that can be set using
+	 * operator>>. This is the default value type.
+	 */
+	struct ValueLike
+	{
+		typedef ValueLike ValueCategory;
+	};
 
-/**
- * A value like argument value type is a value that can be set using
- * operator>>. This is the default value type.
- */
-struct ValueLike {
-    typedef ValueLike ValueCategory;
-};
+	/**
+	 * A string like argument value type is a value that can be set using
+	 * operator=(string). Usefull if the value type contains spaces which
+	 * will be broken up into individual tokens by operator>>.
+	 */
+	struct StringLike
+	{};
 
-/**
- * A string like argument value type is a value that can be set using
- * operator=(string). Usefull if the value type contains spaces which
- * will be broken up into individual tokens by operator>>.
- */
-struct StringLike {};
+	/**
+	 * A class can inherit from this object to make it have string like
+	 * traits. This is a compile time thing and does not add any overhead
+	 * to the inherenting class.
+	 */
+	struct StringLikeTrait
+	{
+		typedef StringLike ValueCategory;
+	};
 
-/**
- * A class can inherit from this object to make it have string like
- * traits. This is a compile time thing and does not add any overhead
- * to the inherenting class.
- */
-struct StringLikeTrait {
-    typedef StringLike ValueCategory;
-};
+	/**
+	 * A class can inherit from this object to make it have value like
+	 * traits. This is a compile time thing and does not add any overhead
+	 * to the inherenting class.
+	 */
+	struct ValueLikeTrait
+	{
+		typedef ValueLike ValueCategory;
+	};
 
-/**
- * A class can inherit from this object to make it have value like
- * traits. This is a compile time thing and does not add any overhead
- * to the inherenting class.
- */
-struct ValueLikeTrait {
-    typedef ValueLike ValueCategory;
-};
-
-/**
- * Arg traits are used to get compile type specialization when parsing
- * argument values. Using an ArgTraits you can specify the way that
- * values gets assigned to any particular type during parsing. The two
- * supported types are string like and value like.
- */
-template<typename T>
-struct ArgTraits {
-    typedef typename T::ValueCategory ValueCategory;
-    //typedef ValueLike ValueCategory;
-};
+	/**
+	 * Arg traits are used to get compile type specialization when parsing
+	 * argument values. Using an ArgTraits you can specify the way that
+	 * values gets assigned to any particular type during parsing. The two
+	 * supported types are string like and value like.
+	 */
+	template<typename T>
+	struct ArgTraits
+	{
+		typedef typename T::ValueCategory ValueCategory;
+		//typedef ValueLike ValueCategory;
+	};
 
 #endif
-
 } // namespace
diff --git a/src/tclap/CmdLine.h b/src/tclap/CmdLine.h
index 90d0e65..7bc9835 100755..100644
--- a/src/tclap/CmdLine.h
+++ b/src/tclap/CmdLine.h
@@ -48,574 +48,592 @@
 #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)
+namespace TCLAP
 {
-	typedef typename C::value_type value_type;
-	std::for_each(c.begin(), c.end(), DelPtr<value_type>);
-	c.clear();
-}
+	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();
+	}
 
-/**
- * The base class that manages the command line definition and passes
- * along the parsing to the appropriate Arg classes.
- */
-class CmdLine : public CmdLineInterface
-{
-	protected:
-
-		/**
-		 * The list of arguments that will be tested against the
-		 * command line.
-		 */
-		std::list<Arg*> _argList;
-
-		/**
-		 * The name of the program.  Set to argv[0].
-		 */
-		std::string _progName;
-
-		/**
-		 * A message used to describe the program.  Used in the usage output.
-		 */
-		std::string _message;
-
-		/**
-		 * The version to be displayed with the --version switch.
-		 */
-		std::string _version;
-
-		/**
-		 * 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.
-		 */
-		int _numRequired;
-
-		/**
-		 * The character that is used to separate the argument flag/name
-		 * from the value.  Defaults to ' ' (space).
-		 */
-		char _delimiter;
-
-		/**
-		 * The handler that manages xoring lists of args.
-		 */
-		XorHandler _xorHandler;
-
-		/**
-		 * A list of Args to be explicitly deleted when the destructor
-		 * is called.  At the moment, this only includes the three default
-		 * Args.
-		 */
-		std::list<Arg*> _argDeleteOnExitList;
-
-		/**
-		 * A list of Visitors to be explicitly deleted when the destructor
-		 * is called.  At the moment, these are the Vistors created for the
-		 * default Args.
-		 */
-		std::list<Visitor*> _visitorDeleteOnExitList;
-
-		/**
-		 * Object that handles all output for the CmdLine.
-		 */
-		CmdLineOutput* _output;
-
-		/**
-		 * Should CmdLine handle parsing exceptions internally?
-		 */
-		bool _handleExceptions;
-
-		/**
-		 * Throws an exception listing the missing args.
-		 */
-		void missingArgsException();
-
-		/**
-		 * Checks whether a name/flag string matches entirely matches
-		 * the Arg::blankChar.  Used when multiple switches are combined
-		 * into a single argument.
-		 * \param s - The message to be used in the usage.
-		 */
-		bool _emptyCombined(const std::string& s);
-
-		/**
-		 * 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();
-
-
-		/**
-		 * Is set to true when a user sets the output object. We use this so
-		 * that we don't delete objects that are created outside of this lib.
-		 */
-		bool _userSetOutput;
-
-		/**
-		 * Whether or not to automatically create help and version switches.
-		 */
-		bool _helpAndVersion;
-
-	public:
-
-		/**
-		 * Command line constructor. Defines how the arguments will be
-		 * parsed.
-		 * \param message - The message to be used in the usage
-		 * output.
-		 * \param delimiter - The character that is used to separate
-		 * the argument flag/name from the value.  Defaults to ' ' (space).
-		 * \param version - The version number to be used in the
-		 * --version switch.
-		 * \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",
-				bool helpAndVersion = true);
-
-		/**
-		 * Deletes any resources allocated by a CmdLine object.
-		 */
-		virtual ~CmdLine();
-
-		/**
-		 * Adds an argument to the list of arguments to be parsed.
-		 * \param a - Argument to be added.
-		 */
-		void add( Arg& a );
-
-		/**
-		 * An alternative add.  Functionally identical.
-		 * \param a - Argument to be added.
-		 */
-		void add( Arg* a );
-
-		/**
-		 * 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.
-		 */
-		void xorAdd( Arg& a, Arg& b );
-
-		/**
-		 * 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.
-		 */
-		void xorAdd( std::vector<Arg*>& xors );
-
-		/**
-		 * Parses the command line.
-		 * \param argc - Number of arguments.
-		 * \param argv - Array of arguments.
-		 */
-		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);
-
-		/**
-		 *
-		 */
-		CmdLineOutput* getOutput();
-
-		/**
-		 *
-		 */
-		void setOutput(CmdLineOutput* co);
-
-		/**
-		 *
-		 */
-		std::string& getVersion();
-
-		/**
-		 *
-		 */
-		std::string& getProgramName();
-
-		/**
-		 *
-		 */
-		std::list<Arg*>& getArgList();
-
-		/**
-		 *
-		 */
-		XorHandler& getXorHandler();
-
-		/**
-		 *
-		 */
-		char getDelimiter();
-
-		/**
-		 *
-		 */
-		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();
-
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-//Begin CmdLine.cpp
-///////////////////////////////////////////////////////////////////////////////
-
-inline CmdLine::CmdLine(const std::string& m,
-			char delim,
-			const std::string& v,
-			bool help )
-: _progName("not_set_yet"),
-  _message(m),
-  _version(v),
-  _numRequired(0),
-  _delimiter(delim),
-  _handleExceptions(true),
-  _userSetOutput(false),
-  _helpAndVersion(help)
-{
-	_constructor();
-}
+	/**
+	 * The base class that manages the command line definition and passes
+	 * along the parsing to the appropriate Arg classes.
+	 */
+	class CmdLine : public CmdLineInterface
+	{
+		protected:
+			/**
+			 * The list of arguments that will be tested against the
+			 * command line.
+			 */
+			std::list<Arg*> _argList;
+
+			/**
+			 * The name of the program.  Set to argv[0].
+			 */
+			std::string _progName;
+
+			/**
+			 * A message used to describe the program.  Used in the usage output.
+			 */
+			std::string _message;
+
+			/**
+			 * The version to be displayed with the --version switch.
+			 */
+			std::string _version;
+
+			/**
+			 * 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.
+			 */
+			int _numRequired;
+
+			/**
+			 * The character that is used to separate the argument flag/name
+			 * from the value.  Defaults to ' ' (space).
+			 */
+			char _delimiter;
+
+			/**
+			 * The handler that manages xoring lists of args.
+			 */
+			XorHandler _xorHandler;
+
+			/**
+			 * A list of Args to be explicitly deleted when the destructor
+			 * is called.  At the moment, this only includes the three default
+			 * Args.
+			 */
+			std::list<Arg*> _argDeleteOnExitList;
+
+			/**
+			 * A list of Visitors to be explicitly deleted when the destructor
+			 * is called.  At the moment, these are the Vistors created for the
+			 * default Args.
+			 */
+			std::list<Visitor*> _visitorDeleteOnExitList;
+
+			/**
+			 * Object that handles all output for the CmdLine.
+			 */
+			CmdLineOutput *_output;
+
+			/**
+			 * Should CmdLine handle parsing exceptions internally?
+			 */
+			bool _handleExceptions;
+
+			/**
+			 * Throws an exception listing the missing args.
+			 */
+			void missingArgsException();
+
+			/**
+			 * Checks whether a name/flag string matches entirely matches
+			 * the Arg::blankChar.  Used when multiple switches are combined
+			 * into a single argument.
+			 * \param s - The message to be used in the usage.
+			 */
+			bool _emptyCombined(const std::string &s);
+
+			/**
+			 * 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();
+
+
+			/**
+			 * Is set to true when a user sets the output object. We use this so
+			 * that we don't delete objects that are created outside of this lib.
+			 */
+			bool _userSetOutput;
+
+			/**
+			 * Whether or not to automatically create help and version switches.
+			 */
+			bool _helpAndVersion;
+
+		public:
+			/**
+			 * Command line constructor. Defines how the arguments will be
+			 * parsed.
+			 * \param message - The message to be used in the usage
+			 * output.
+			 * \param delimiter - The character that is used to separate
+			 * the argument flag/name from the value.  Defaults to ' ' (space).
+			 * \param version - The version number to be used in the
+			 * --version switch.
+			 * \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", bool helpAndVersion = true);
+
+			/**
+			 * Deletes any resources allocated by a CmdLine object.
+			 */
+			virtual ~CmdLine();
+
+			/**
+			 * Adds an argument to the list of arguments to be parsed.
+			 * \param a - Argument to be added.
+			 */
+			void add(Arg &a);
+
+			/**
+			 * An alternative add.  Functionally identical.
+			 * \param a - Argument to be added.
+			 */
+			void add(Arg *a);
+
+			/**
+			 * 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.
+			 */
+			void xorAdd(Arg &a, Arg &b);
+
+			/**
+			 * 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.
+			 */
+			void xorAdd(std::vector<Arg*> &xors);
+
+			/**
+			 * Parses the command line.
+			 * \param argc - Number of arguments.
+			 * \param argv - Array of arguments.
+			 */
+			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);
+
+			/**
+			 *
+			 */
+			CmdLineOutput* getOutput();
+
+			/**
+			 *
+			 */
+			void setOutput(CmdLineOutput *co);
+
+			/**
+			 *
+			 */
+			std::string& getVersion();
+
+			/**
+			 *
+			 */
+			std::string& getProgramName();
+
+			/**
+			 *
+			 */
+			std::list<Arg*>& getArgList();
+
+			/**
+			 *
+			 */
+			XorHandler& getXorHandler();
+
+			/**
+			 *
+			 */
+			char getDelimiter();
+
+			/**
+			 *
+			 */
+			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();
+	};
+
+
+	///////////////////////////////////////////////////////////////////////////////
+	//Begin CmdLine.cpp
+	///////////////////////////////////////////////////////////////////////////////
+
+	inline CmdLine::CmdLine(const std::string &m, char delim, const std::string &v, bool help) :
+			_progName("not_set_yet"), _message(m), _version(v), _numRequired(0), _delimiter(delim),
+			_handleExceptions(true), _userSetOutput(false), _helpAndVersion(help)
+	{
+		_constructor();
+	}
 
-inline CmdLine::~CmdLine()
-{
-	ClearContainer(_argDeleteOnExitList);
-	ClearContainer(_visitorDeleteOnExitList);
+	inline CmdLine::~CmdLine()
+	{
+		ClearContainer(_argDeleteOnExitList);
+		ClearContainer(_visitorDeleteOnExitList);
 
-	if ( !_userSetOutput ) {
-		delete _output;
-		_output = 0;
+		if (!_userSetOutput)
+		{
+			delete _output;
+			_output = 0;
+		}
 	}
-}
 
-inline void CmdLine::_constructor()
-{
-	_output = new StdOutput;
+	inline void CmdLine::_constructor()
+	{
+		_output = new StdOutput;
 
-	Arg::setDelimiter( _delimiter );
+		Arg::setDelimiter(_delimiter);
 
-	Visitor* v;
+		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);
+		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(vers);
+			deleteOnExit(vers);
+			deleteOnExit(v);
+		}
 
-		v = new VersionVisitor( this, &_output );
-		SwitchArg* vers = new SwitchArg("","version",
-					"Displays version information and exits.",
-					false, v);
-		add( vers );
-		deleteOnExit(vers);
+		v = new IgnoreRestVisitor();
+		SwitchArg *ignore = new SwitchArg(Arg::flagStartString(),
+		        Arg::ignoreNameString(), "Ignores the rest of the labeled arguments following this flag.", false,
+		        v);
+		add(ignore);
+		deleteOnExit(ignore);
 		deleteOnExit(v);
 	}
 
-	v = new IgnoreRestVisitor();
-	SwitchArg* ignore  = new SwitchArg(Arg::flagStartString(),
-					   Arg::ignoreNameString(),
-			   "Ignores the rest of the labeled arguments following this flag.",
-					   false, v);
-	add( ignore );
-	deleteOnExit(ignore);
-	deleteOnExit(v);
-}
-
-inline void CmdLine::xorAdd( std::vector<Arg*>& ors )
-{
-	_xorHandler.add( ors );
-
-	for (ArgVectorIterator it = ors.begin(); it != ors.end(); it++)
+	inline void CmdLine::xorAdd(std::vector<Arg*> &ors)
 	{
-		(*it)->forceRequired();
-		(*it)->setRequireLabel( "OR required" );
+		_xorHandler.add(ors);
 
-		add( *it );
-	}
-}
+		for (ArgVectorIterator it = ors.begin(); it != ors.end(); it++)
+		{
+			(*it)->forceRequired();
+			(*it)->setRequireLabel("OR required");
 
-inline void CmdLine::xorAdd( Arg& a, Arg& b )
-{
-    std::vector<Arg*> ors;
-    ors.push_back( &a );
-    ors.push_back( &b );
-	xorAdd( ors );
-}
+			add(*it);
+		}
+	}
 
-inline void CmdLine::add( Arg& a )
-{
-	add( &a );
-}
+	inline void CmdLine::xorAdd(Arg &a, Arg &b)
+	{
+		std::vector<Arg*> ors;
+		ors.push_back(&a);
+		ors.push_back(&b);
+		xorAdd(ors);
+	}
 
-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() ) );
+	inline void CmdLine::add(Arg &a)
+	{
+		add(&a);
+	}
 
-	a->addToList( _argList );
+	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()));
+			}
+		}
 
-	if ( a->isRequired() )
-		_numRequired++;
-}
+		a->addToList(_argList);
 
+		if (a->isRequired())
+		{
+			_numRequired++;
+		}
+	}
 
-inline void CmdLine::parse(int argc, const char * const * argv)
-{
+	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;
+	inline void CmdLine::parse(std::vector<std::string> &args)
+	{
+		bool shouldExit = false;
+		int  estat      = 0;
 
-	try {
-		_progName = args.front();
-		args.erase(args.begin());
+		try
+		{
+			_progName = args.front();
+			args.erase(args.begin());
 
-		int requiredCount = 0;
+			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 ) )
+			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;
+						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;
+				}
+
+				if (!matched && !Arg::ignoreRest())
+				{
+					throw (CmdLineParseException("Couldn't find match "
+					                             "for argument", args[i]));
+				}
 			}
 
-			// 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 (requiredCount < _numRequired)
+			{
+				missingArgsException();
+			}
 
-			if ( !matched && !Arg::ignoreRest() )
-				throw(CmdLineParseException("Couldn't find match "
-											"for argument",
-											args[i]));
+			if (requiredCount > _numRequired)
+			{
+				throw (CmdLineParseException("Too many arguments!"));
+			}
 		}
+		catch (ArgException &e)
+		{
+			// If we're not handling the exceptions, rethrow.
+			if (!_handleExceptions)
+			{
+				throw;
+			}
 
-		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;
+			}
 
-		try {
-			_output->failure(*this,e);
-		} catch ( ExitException &ee ) {
-			estat = ee.getExitStatus();
+			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);
+		}
 	}
 
-	if (shouldExit)
-		exit(estat);
-}
-
-inline bool CmdLine::_emptyCombined(const std::string& s)
-{
-	if ( s.length() > 0 && s[0] != Arg::flagStartChar() )
-		return false;
-
-	for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
-		if ( s[i] != Arg::blankChar() )
+	inline bool CmdLine::_emptyCombined(const std::string &s)
+	{
+		if (s.length() > 0 && s[0] != Arg::flagStartChar())
+		{
 			return false;
+		}
 
-	return true;
-}
+		for (int i = 1; static_cast<unsigned int>(i) < s.length(); i++)
+		{
+			if (s[i] != Arg::blankChar())
+			{
+				return false;
+			}
+		}
 
-inline void CmdLine::missingArgsException()
-{
+		return true;
+	}
+
+	inline void CmdLine::missingArgsException()
+	{
 		int count = 0;
 
 		std::string missingArgList;
 		for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
 		{
-			if ( (*it)->isRequired() && !(*it)->isSet() )
+			if ((*it)->isRequired() && !(*it)->isSet())
 			{
 				missingArgList += (*it)->getName();
 				missingArgList += ", ";
 				count++;
 			}
 		}
-		missingArgList = missingArgList.substr(0,missingArgList.length()-2);
+		missingArgList = missingArgList.substr(0, missingArgList.length() - 2);
 
 		std::string msg;
-		if ( count > 1 )
+		if (count > 1)
+		{
 			msg = "Required arguments missing: ";
+		}
 		else
+		{
 			msg = "Required argument missing: ";
+		}
 
 		msg += missingArgList;
 
-		throw(CmdLineParseException(msg));
-}
-
-inline void CmdLine::deleteOnExit(Arg* ptr)
-{
-	_argDeleteOnExitList.push_back(ptr);
-}
-
-inline void CmdLine::deleteOnExit(Visitor* ptr)
-{
-	_visitorDeleteOnExitList.push_back(ptr);
-}
+		throw (CmdLineParseException(msg));
+	}
 
-inline CmdLineOutput* CmdLine::getOutput()
-{
-	return _output;
-}
+	inline void CmdLine::deleteOnExit(Arg *ptr)
+	{
+		_argDeleteOnExitList.push_back(ptr);
+	}
 
-inline void CmdLine::setOutput(CmdLineOutput* co)
-{
-	_userSetOutput = true;
-	_output = co;
-}
+	inline void CmdLine::deleteOnExit(Visitor *ptr)
+	{
+		_visitorDeleteOnExitList.push_back(ptr);
+	}
 
-inline std::string& CmdLine::getVersion()
-{
-	return _version;
-}
+	inline CmdLineOutput* CmdLine::getOutput()
+	{
+		return _output;
+	}
 
-inline std::string& CmdLine::getProgramName()
-{
-	return _progName;
-}
+	inline void CmdLine::setOutput(CmdLineOutput *co)
+	{
+		_userSetOutput = true;
+		_output = co;
+	}
 
-inline std::list<Arg*>& CmdLine::getArgList()
-{
-	return _argList;
-}
+	inline std::string& CmdLine::getVersion()
+	{
+		return _version;
+	}
 
-inline XorHandler& CmdLine::getXorHandler()
-{
-	return _xorHandler;
-}
+	inline std::string& CmdLine::getProgramName()
+	{
+		return _progName;
+	}
 
-inline char CmdLine::getDelimiter()
-{
-	return _delimiter;
-}
+	inline std::list<Arg*>& CmdLine::getArgList()
+	{
+		return _argList;
+	}
 
-inline std::string& CmdLine::getMessage()
-{
-	return _message;
-}
+	inline XorHandler& CmdLine::getXorHandler()
+	{
+		return _xorHandler;
+	}
 
-inline bool CmdLine::hasHelpAndVersion()
-{
-	return _helpAndVersion;
-}
+	inline char CmdLine::getDelimiter()
+	{
+		return _delimiter;
+	}
 
-inline void CmdLine::setExceptionHandling(const bool state)
-{
-	_handleExceptions = state;
-}
+	inline std::string& CmdLine::getMessage()
+	{
+		return _message;
+	}
 
-inline bool CmdLine::getExceptionHandling() const
-{
-	return _handleExceptions;
-}
+	inline bool CmdLine::hasHelpAndVersion()
+	{
+		return _helpAndVersion;
+	}
 
-inline void CmdLine::reset()
-{
-	for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
+	inline void CmdLine::setExceptionHandling(const bool state)
 	{
-		(*it)->reset();
+		_handleExceptions = state;
 	}
-	
-	_progName.clear();
-}
 
-///////////////////////////////////////////////////////////////////////////////
-//End CmdLine.cpp
-///////////////////////////////////////////////////////////////////////////////
+	inline bool CmdLine::getExceptionHandling() const
+	{
+		return _handleExceptions;
+	}
 
+	inline void CmdLine::reset()
+	{
+		for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
+		{
+			(*it)->reset();
+		}
 
+		_progName.clear();
+	}
 
+	///////////////////////////////////////////////////////////////////////////////
+	//End CmdLine.cpp
+	///////////////////////////////////////////////////////////////////////////////
 } //namespace TCLAP
+
 #endif
diff --git a/src/tclap/CmdLineInterface.h b/src/tclap/CmdLineInterface.h
index 1b25e9b..369ade8 100755..100644
--- a/src/tclap/CmdLineInterface.h
+++ b/src/tclap/CmdLineInterface.h
@@ -1,24 +1,23 @@
-
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  CmdLineInterface.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_COMMANDLINE_INTERFACE_H
 #define TCLAP_COMMANDLINE_INTERFACE_H
@@ -30,121 +29,121 @@
 #include <algorithm>
 
 
-namespace TCLAP {
-     
-class Arg;
-class CmdLineOutput;
-class XorHandler;
-
-/**
- * The base class that manages the command line definition and passes
- * along the parsing to the appropriate Arg classes.
- */
-class CmdLineInterface
+namespace TCLAP
 {
-	public:
-
-		/**
-		 * Destructor
-		 */
-		virtual ~CmdLineInterface() {}
-
-		/**
-		 * Adds an argument to the list of arguments to be parsed.
-		 * \param a - Argument to be added. 
-		 */
-		virtual void add( Arg& a )=0;
-
-		/**
-		 * An alternative add.  Functionally identical.
-		 * \param a - Argument to be added. 
-		 */
-		virtual void add( Arg* a )=0;
-
-		/**
-		 * 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. 
-		 */
-		virtual void xorAdd( Arg& a, Arg& b )=0;
-
-		/**
-		 * 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. 
-		 */
-		virtual void xorAdd( std::vector<Arg*>& xors )=0;
-
-		/**
-		 * Parses the command line.
-		 * \param argc - Number of arguments.
-		 * \param argv - Array of arguments.
-		 */
-		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);
-
-		/**
-		 * Returns the CmdLineOutput object.
-		 */
-		virtual CmdLineOutput* getOutput()=0;
-
-		/**
-		 * \param co - CmdLineOutput object that we want to use instead. 
-		 */
-		virtual void setOutput(CmdLineOutput* co)=0;
-
-		/**
-		 * Returns the version string.
-		 */
-		virtual std::string& getVersion()=0;
-
-		/**
-		 * Returns the program name string.
-		 */
-		virtual std::string& getProgramName()=0;
-
-		/**
-		 * Returns the argList. 
-		 */
-		virtual std::list<Arg*>& getArgList()=0;
-
-		/**
-		 * Returns the XorHandler. 
-		 */
-		virtual XorHandler& getXorHandler()=0;
-
-		/**
-		 * Returns the delimiter string.
-		 */
-		virtual char getDelimiter()=0;
-
-		/**
-		 * Returns the message string.
-		 */
-		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;
-};
-
+	class Arg;
+	class CmdLineOutput;
+	class XorHandler;
+
+	/**
+	 * The base class that manages the command line definition and passes
+	 * along the parsing to the appropriate Arg classes.
+	 */
+	class CmdLineInterface
+	{
+		public:
+			/**
+			 * Destructor
+			 */
+			virtual ~CmdLineInterface()
+			{
+			}
+
+			/**
+			 * Adds an argument to the list of arguments to be parsed.
+			 * \param a - Argument to be added.
+			 */
+			virtual void add(Arg &a) = 0;
+
+			/**
+			 * An alternative add.  Functionally identical.
+			 * \param a - Argument to be added.
+			 */
+			virtual void add(Arg *a) = 0;
+
+			/**
+			 * 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.
+			 */
+			virtual void xorAdd(Arg &a, Arg &b) = 0;
+
+			/**
+			 * 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.
+			 */
+			virtual void xorAdd(std::vector<Arg*> &xors) = 0;
+
+			/**
+			 * Parses the command line.
+			 * \param argc - Number of arguments.
+			 * \param argv - Array of arguments.
+			 */
+			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);
+
+			/**
+			 * Returns the CmdLineOutput object.
+			 */
+			virtual CmdLineOutput* getOutput() = 0;
+
+			/**
+			 * \param co - CmdLineOutput object that we want to use instead.
+			 */
+			virtual void setOutput(CmdLineOutput *co) = 0;
+
+			/**
+			 * Returns the version string.
+			 */
+			virtual std::string& getVersion() = 0;
+
+			/**
+			 * Returns the program name string.
+			 */
+			virtual std::string& getProgramName() = 0;
+
+			/**
+			 * Returns the argList.
+			 */
+			virtual std::list<Arg*>& getArgList() = 0;
+
+			/**
+			 * Returns the XorHandler.
+			 */
+			virtual XorHandler& getXorHandler() = 0;
+
+			/**
+			 * Returns the delimiter string.
+			 */
+			virtual char getDelimiter() = 0;
+
+			/**
+			 * Returns the message string.
+			 */
+			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;
+	};
 } //namespace
 
 
-#endif 
+#endif
diff --git a/src/tclap/CmdLineOutput.h b/src/tclap/CmdLineOutput.h
index 71ee5a3..909bf25 100755..100644
--- a/src/tclap/CmdLineOutput.h
+++ b/src/tclap/CmdLineOutput.h
@@ -1,24 +1,22 @@
-
-
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  CmdLineOutput.h
- * 
+ *
  *  Copyright (c) 2004, Michael E. Smoot
  *  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_CMDLINEOUTPUT_H
 #define TCLAP_CMDLINEOUTPUT_H
@@ -30,45 +28,43 @@
 #include <iomanip>
 #include <algorithm>
 
-namespace TCLAP {
-
-class CmdLineInterface;
-class ArgException;
-
-/**
- * The interface that any output object must implement.
- */
-class CmdLineOutput 
+namespace TCLAP
 {
+	class CmdLineInterface;
+	class ArgException;
 
-	public:
+	/**
+	 * The interface that any output object must implement.
+	 */
+	class CmdLineOutput
+	{
+		public:
+			/**
+			 * Virtual destructor.
+			 */
+			virtual ~CmdLineOutput()
+			{
+			}
 
-		/**
-		 * Virtual destructor.
-		 */
-		virtual ~CmdLineOutput() {}
+			/**
+			 * Generates some sort of output for the USAGE.
+			 * \param c - The CmdLine object the output is generated for.
+			 */
+			virtual void usage(CmdLineInterface &c) = 0;
 
-		/**
-		 * Generates some sort of output for the USAGE. 
-		 * \param c - The CmdLine object the output is generated for. 
-		 */
-		virtual void usage(CmdLineInterface& c)=0;
-
-		/**
-		 * Generates some sort of output for the version. 
-		 * \param c - The CmdLine object the output is generated for. 
-		 */
-		virtual void version(CmdLineInterface& c)=0;
-
-		/**
-		 * Generates some sort of output for a failure. 
-		 * \param c - The CmdLine object the output is generated for. 
-		 * \param e - The ArgException that caused the failure. 
-		 */
-		virtual void failure( CmdLineInterface& c, 
-						      ArgException& e )=0;
-
-};
+			/**
+			 * Generates some sort of output for the version.
+			 * \param c - The CmdLine object the output is generated for.
+			 */
+			virtual void version(CmdLineInterface &c) = 0;
 
+			/**
+			 * Generates some sort of output for a failure.
+			 * \param c - The CmdLine object the output is generated for.
+			 * \param e - The ArgException that caused the failure.
+			 */
+			virtual void failure(CmdLineInterface &c, ArgException &e) = 0;
+	};
 } //namespace TCLAP
-#endif 
+
+#endif
diff --git a/src/tclap/Constraint.h b/src/tclap/Constraint.h
index a92acf9..e99418b 100755..100644
--- a/src/tclap/Constraint.h
+++ b/src/tclap/Constraint.h
@@ -1,4 +1,3 @@
-
 /******************************************************************************
  *
  *  file:  Constraint.h
@@ -29,40 +28,41 @@
 #include <iomanip>
 #include <algorithm>
 
-namespace TCLAP {
-
-/**
- * The interface that defines the interaction between the Arg and Constraint.
- */
-template<class T>
-class Constraint
+namespace TCLAP
 {
+	/**
+	 * The interface that defines the interaction between the Arg and Constraint.
+	 */
+	template<class T>
+	class Constraint
+	{
+		public:
+			/**
+			 * Returns a description of the Constraint.
+			 */
+			virtual std::string description() const = 0;
 
-	public:
-		/**
-		 * Returns a description of the Constraint.
-		 */
-		virtual std::string description() const =0;
-
-		/**
-		 * Returns the short ID for the Constraint.
-		 */
-		virtual std::string shortID() const =0;
+			/**
+			 * Returns the short ID for the Constraint.
+			 */
+			virtual std::string shortID() const = 0;
 
-		/**
-		 * The method used to verify that the value parsed from the command
-		 * line meets the constraint.
-		 * \param value - The value that will be checked.
-		 */
-		virtual bool check(const T& value) const =0;
-
-		/**
-		 * Destructor.
-		 * Silences warnings about Constraint being a base class with virtual
-		 * functions but without a virtual destructor.
-		 */
-		virtual ~Constraint() { ; }
-};
+			/**
+			 * The method used to verify that the value parsed from the command
+			 * line meets the constraint.
+			 * \param value - The value that will be checked.
+			 */
+			virtual bool check(const T &value) const = 0;
 
+			/**
+			 * Destructor.
+			 * Silences warnings about Constraint being a base class with virtual
+			 * functions but without a virtual destructor.
+			 */
+			virtual ~Constraint()
+			{
+			}
+	};
 } //namespace TCLAP
+
 #endif
diff --git a/src/tclap/DocBookOutput.h b/src/tclap/DocBookOutput.h
index d2f1290..f4ff822 100755..100644
--- a/src/tclap/DocBookOutput.h
+++ b/src/tclap/DocBookOutput.h
@@ -1,24 +1,24 @@
 // -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
 
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  DocBookOutput.h
- * 
+ *
  *  Copyright (c) 2004, Michael E. Smoot
  *  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_DOCBOOKOUTPUT_H
 #define TCLAP_DOCBOOKOUTPUT_H
@@ -34,266 +34,272 @@
 #include <tclap/XorHandler.h>
 #include <tclap/Arg.h>
 
-namespace TCLAP {
-
-/**
- * A class that generates DocBook output for usage() method for the 
- * given CmdLine and its Args.
- */
-class DocBookOutput : public CmdLineOutput
-{
-
-	public:
-
-		/**
-		 * Prints the usage to stdout.  Can be overridden to 
-		 * produce alternative behavior.
-		 * \param c - The CmdLine object the output is generated for. 
-		 */
-		virtual void usage(CmdLineInterface& c);
-
-		/**
-		 * Prints the version to stdout. Can be overridden 
-		 * to produce alternative behavior.
-		 * \param c - The CmdLine object the output is generated for. 
-		 */
-		virtual void version(CmdLineInterface& c);
-
-		/**
-		 * Prints (to stderr) an error message, short usage 
-		 * Can be overridden to produce alternative behavior.
-		 * \param c - The CmdLine object the output is generated for. 
-		 * \param e - The ArgException that caused the failure. 
-		 */
-		virtual void failure(CmdLineInterface& c, 
-						     ArgException& e );
-
-	protected:
-
-		/**
-		 * Substitutes the char r for string x in string s.
-		 * \param s - The string to operate on. 
-		 * \param r - The char to replace. 
-		 * \param x - What to replace r with. 
-		 */
-		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;
-};
-
-
-inline void DocBookOutput::version(CmdLineInterface& _cmd) 
-{ 
-	std::cout << _cmd.getVersion() << std::endl;
-}
-
-inline void DocBookOutput::usage(CmdLineInterface& _cmd ) 
+namespace TCLAP
 {
-	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 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 << "<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;
+	/**
+	 * A class that generates DocBook output for usage() method for the
+	 * given CmdLine and its Args.
+	 */
+	class DocBookOutput : public CmdLineOutput
+	{
+		public:
+			/**
+			 * Prints the usage to stdout.  Can be overridden to
+			 * produce alternative behavior.
+			 * \param c - The CmdLine object the output is generated for.
+			 */
+			virtual void usage(CmdLineInterface &c);
+
+			/**
+			 * Prints the version to stdout. Can be overridden
+			 * to produce alternative behavior.
+			 * \param c - The CmdLine object the output is generated for.
+			 */
+			virtual void version(CmdLineInterface &c);
+
+			/**
+			 * Prints (to stderr) an error message, short usage
+			 * Can be overridden to produce alternative behavior.
+			 * \param c - The CmdLine object the output is generated for.
+			 * \param e - The ArgException that caused the failure.
+			 */
+			virtual void failure(CmdLineInterface &c, ArgException &e);
+
+		protected:
+			/**
+			 * Substitutes the char r for string x in string s.
+			 * \param s - The string to operate on.
+			 * \param r - The char to replace.
+			 * \param x - What to replace r with.
+			 */
+			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;
+	};
+
+	inline void DocBookOutput::version(CmdLineInterface &_cmd)
+	{
+		std::cout << _cmd.getVersion() << std::endl;
+	}
 
-	// xor
-	for ( int i = 0; (unsigned int)i < xorList.size(); i++ )
+	inline void DocBookOutput::usage(CmdLineInterface &_cmd)
 	{
-		std::cout << "<group choice='req'>" << std::endl;
-		for ( ArgVectorIterator it = xorList[i].begin(); 
-						it != xorList[i].end(); it++ )
-			printShortArg((*it));
+		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 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 << "<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;
+
+		// xor
+		for (int i = 0; (unsigned int)i < xorList.size(); i++)
+		{
+			std::cout << "<group choice='req'>" << std::endl;
+			for (ArgVectorIterator it = xorList[i].begin();
+			        it != xorList[i].end(); it++)
+			{
+				printShortArg((*it));
+			}
+
+			std::cout << "</group>" << std::endl;
+		}
+
+		// rest of args
+		for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
+		{
+			if (!xorHandler.contains((*it)))
+			{
+				printShortArg((*it));
+			}
+		}
+
+		std::cout << "</cmdsynopsis>" << 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;
+	}
 
-		std::cout << "</group>" << std::endl;
+	inline void DocBookOutput::failure(CmdLineInterface &_cmd, ArgException &e)
+	{
+		static_cast<void>(_cmd); // unused
+		std::cout << e.what() << std::endl;
+		throw ExitException(1);
 	}
-	
-	// rest of args
-	for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
-		if ( !xorHandler.contains( (*it) ) )
-			printShortArg((*it));
-
- 	std::cout << "</cmdsynopsis>" << 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 ) 
-{ 
-	static_cast<void>(_cmd); // unused
-	std::cout << e.what() << std::endl;
-	throw ExitException(1);
-}
-
-inline void DocBookOutput::substituteSpecialChars( std::string& s,
-				                                   char r,
-												   std::string& x )
-{
-	size_t p;
-	while ( (p = s.find_first_of(r)) != std::string::npos )
+
+	inline void DocBookOutput::substituteSpecialChars(std::string &s, char r, std::string &x)
 	{
-		s.erase(p,1);
-		s.insert(p,x);
+		size_t p;
+		while ((p = s.find_first_of(r)) != std::string::npos)
+		{
+			s.erase(p, 1);
+			s.insert(p, x);
+		}
 	}
-}
 
-inline void DocBookOutput::removeChar( std::string& s, char r)
-{
-	size_t p;
-	while ( (p = s.find_first_of(r)) != std::string::npos )
+	inline void DocBookOutput::removeChar(std::string &s, char r)
 	{
-		s.erase(p,1);
+		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 )
+	inline void DocBookOutput::basename(std::string &s)
 	{
-		s.erase(0, p + 1);
+		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() )
+	inline void DocBookOutput::printShortArg(Arg *a)
 	{
-		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::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;
 	}
-	std::cout << "</arg>" << std::endl;
 
-}
+	inline void DocBookOutput::printLongArg(Arg *a)
+	{
+		std::string lt = "&lt;";
+		std::string gt = "&gt;";
 
-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::string desc = a->getDescription();
-	substituteSpecialChars(desc,'<',lt);
-	substituteSpecialChars(desc,'>',gt);
+		std::cout << "<varlistentry>" << std::endl;
 
-	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;
+		}
 
-	if ( !a->getFlag().empty() )
-	{
 		std::cout << "<term>" << std::endl;
 		std::cout << "<option>";
-		std::cout << a->flagStartChar() << a->getFlag();
+		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 << "<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;
-}
+		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 
+
+#endif
diff --git a/src/tclap/HelpVisitor.h b/src/tclap/HelpVisitor.h
index 2cdb997..1afc148 100755..100644
--- a/src/tclap/HelpVisitor.h
+++ b/src/tclap/HelpVisitor.h
@@ -1,23 +1,22 @@
-
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  HelpVisitor.h
- * 
+ *
  *  Copyright (c) 2003, Michael E. Smoot .
  *  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_HELP_VISITOR_H
 #define TCLAP_HELP_VISITOR_H
@@ -26,44 +25,46 @@
 #include <tclap/CmdLineOutput.h>
 #include <tclap/Visitor.h>
 
-namespace TCLAP {
-
-/**
- * A Visitor object that calls the usage method of the given CmdLineOutput
- * object for the specified CmdLine object.
- */
-class HelpVisitor: public Visitor
+namespace TCLAP
 {
-	protected:
-
-		/**
-		 * The CmdLine the output will be generated for. 
-		 */
-		CmdLineInterface* _cmd;
-
-		/**
-		 * The output object. 
-		 */
-		CmdLineOutput** _out;
-
-	public:
+	/**
+	 * A Visitor object that calls the usage method of the given CmdLineOutput
+	 * object for the specified CmdLine object.
+	 */
+	class HelpVisitor : public Visitor
+	{
+		protected:
+			/**
+			 * The CmdLine the output will be generated for.
+			 */
+			CmdLineInterface *_cmd;
 
-		/**
-		 * Constructor.
-		 * \param cmd - The CmdLine the output will be generated for.
-		 * \param out - The type of output. 
-		 */
-		HelpVisitor(CmdLineInterface* cmd, CmdLineOutput** out) 
-				: Visitor(), _cmd( cmd ), _out( out ) { }
+			/**
+			 * The output object.
+			 */
+			CmdLineOutput **_out;
 
-		/**
-		 * Calls the usage method of the CmdLineOutput for the 
-		 * specified CmdLine.
-		 */
-		void visit() { (*_out)->usage(*_cmd); throw ExitException(0); }
-		
-};
+		public:
+			/**
+			 * Constructor.
+			 * \param cmd - The CmdLine the output will be generated for.
+			 * \param out - The type of output.
+			 */
+			HelpVisitor(CmdLineInterface *cmd, CmdLineOutput **out) :
+					Visitor(), _cmd(cmd), _out(out)
+			{
+			}
 
+			/**
+			 * Calls the usage method of the CmdLineOutput for the
+			 * specified CmdLine.
+			 */
+			void visit()
+			{
+				(*_out)->usage(*_cmd);
+				throw ExitException(0);
+			}
+	};
 }
 
 #endif
diff --git a/src/tclap/IgnoreRestVisitor.h b/src/tclap/IgnoreRestVisitor.h
index e328649..8165008 100755..100644
--- a/src/tclap/IgnoreRestVisitor.h
+++ b/src/tclap/IgnoreRestVisitor.h
@@ -1,23 +1,22 @@
-
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  IgnoreRestVisitor.h
- * 
+ *
  *  Copyright (c) 2003, Michael E. Smoot .
  *  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_IGNORE_REST_VISITOR_H
@@ -26,27 +25,31 @@
 #include <tclap/Visitor.h>
 #include <tclap/Arg.h>
 
-namespace TCLAP {
-
-/**
- * A Vistor that tells the CmdLine to begin ignoring arguments after
- * this one is parsed.
- */
-class IgnoreRestVisitor: public Visitor
+namespace TCLAP
 {
-	public:
-
-		/**
-		 * Constructor.
-		 */
-		IgnoreRestVisitor() : Visitor() {}
-
-		/**
-		 * Sets Arg::_ignoreRest.
-		 */
-		void visit() { Arg::beginIgnoring();  }
-};
-
+	/**
+	 * A Vistor that tells the CmdLine to begin ignoring arguments after
+	 * this one is parsed.
+	 */
+	class IgnoreRestVisitor : public Visitor
+	{
+		public:
+			/**
+			 * Constructor.
+			 */
+			IgnoreRestVisitor() :
+					Visitor()
+			{
+			}
+
+			/**
+			 * Sets Arg::_ignoreRest.
+			 */
+			void visit()
+			{
+				Arg::beginIgnoring();
+			}
+	};
 }
 
 #endif
diff --git a/src/tclap/MultiArg.h b/src/tclap/MultiArg.h
index 460e5cb..467edd4 100755..100644
--- a/src/tclap/MultiArg.h
+++ b/src/tclap/MultiArg.h
@@ -1,22 +1,22 @@
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  MultiArg.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.
+ *
  *****************************************************************************/
 
 
@@ -29,394 +29,377 @@
 #include <tclap/Arg.h>
 #include <tclap/Constraint.h>
 
-namespace TCLAP {
-/**
- * An argument that allows multiple values of type T to be specified.  Very
- * similar to a ValueArg, except a vector of values will be returned
- * instead of just one.
- */
-template<class T>
-class MultiArg : public Arg
+namespace TCLAP
 {
-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.
+	 * An argument that allows multiple values of type T to be specified.  Very
+	 * similar to a ValueArg, except a vector of values will be returned
+	 * instead of just one.
 	 */
-	std::vector<T> _values;
+	template<class T>
+	class MultiArg : public Arg
+	{
+		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, bool req,
+			        const std::string &typeDesc, 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, const std::string &name, const std::string &desc, bool req,
+			        const std::string &typeDesc, CmdLineInterface &parser, 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 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,
+			        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 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,
+			        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 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>
+	MultiArg<T>::MultiArg(const std::string &flag, const std::string &name, const std::string &desc,
+	        bool req, const std::string &typeDesc, Visitor *v) :
+			Arg(flag, name, desc, req, true, v), _typeDesc(typeDesc), _constraint(NULL), _allowMore(false)
+	{
+		_acceptsMultipleValues = true;
+	}
 
-	/**
-	 * The description of type T to be used in the usage.
-	 */
-	std::string _typeDesc;
+	template<class T>
+	MultiArg<T>::MultiArg(const std::string &flag, const std::string &name, const std::string &desc,
+	        bool req, const std::string &typeDesc, CmdLineInterface &parser,
+	        Visitor *v) :
+			Arg(flag, name, desc, req, true, v), _typeDesc(typeDesc), _constraint(NULL), _allowMore(false)
+	{
+		parser.add(this);
+		_acceptsMultipleValues = true;
+	}
 
 	/**
-	 * A list of constraint on this Arg. 
+	 *
 	 */
-	Constraint<T>* _constraint;
+	template<class T>
+	MultiArg<T>::MultiArg(const std::string &flag, const std::string &name, const std::string &desc,
+	        bool req, Constraint<T> *constraint, Visitor *v) :
+			Arg(flag, name, desc, req, true, v), _typeDesc(constraint->shortID()),
+			_constraint(constraint), _allowMore(false)
+	{
+		_acceptsMultipleValues = true;
+	}
 
-	/**
-	 * 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 );
+	template<class T>
+	MultiArg<T>::MultiArg(const std::string &flag, const std::string &name, const std::string &desc,
+	        bool req, Constraint<T> *constraint, CmdLineInterface &parser, Visitor *v) :
+			Arg(flag, name, desc, req, true, v), _typeDesc(constraint->shortID()),
+			_constraint(constraint), _allowMore(false)
+	{
+		parser.add(this);
+		_acceptsMultipleValues = true;
+	}
 
-	/**
-	 * Used by XorHandler to decide whether to keep parsing for this arg.
-	 */
-	bool _allowMore;
+	template<class T>
+	const std::vector<T>& MultiArg<T>::getValue()
+	{
+		return _values;
+	}
 
-public:
+	template<class T>
+	bool MultiArg<T>::processArg(int *i, std::vector<std::string> &args)
+	{
+		if (_ignoreable && Arg::ignoreRest())
+		{
+			return false;
+		}
 
-	/**
-	 * 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,
-                  bool req,
-                  const std::string& typeDesc,
-                  Visitor* v = NULL);
+		if (_hasBlanks(args[*i]))
+		{
+			return false;
+		}
 
-	/**
-	 * 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,
-                  bool req,
-                  const std::string& typeDesc,
-                  CmdLineInterface& parser,
-                  Visitor* v = NULL );
+		std::string flag  = args[*i];
+		std::string value = "";
 
-	/**
-	 * 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,
-                  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 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,
-                  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); 
+		trimFlag(flag, value);
 
-	/**
-	 * Returns a vector of type T containing the values parsed from
-	 * the command line.
-	 */
-	const std::vector<T>& getValue();
+		if (argMatches(flag))
+		{
+			if (Arg::delimiter() != ' ' && value == "")
+			{
+				throw (ArgParseException(
+								"Couldn't find delimiter for this argument!", toString()));
+			}
+
+			// always take the first one, regardless of start string
+			if (value == "")
+			{
+				(*i)++;
+				if (static_cast<unsigned int>(*i) < args.size())
+				{
+					_extractValue(args[*i]);
+				}
+				else
+				{
+					throw (ArgParseException("Missing a value for this argument!", toString()));
+				}
+			}
+			else
+			{
+				_extractValue(value);
+			}
 
-	/**
-	 * Returns an iterator over the values parsed from the command
-	 * line.
-	 */
-	const_iterator begin() const { return _values.begin(); }
+			/*
+			// 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)] );
+			*/
 
-	/**
-	 * Returns the end of the values parsed from the command
-	 * line.
-	 */
-	const_iterator end() const { return _values.end(); }
+			_alreadySet = true;
+			_checkWithVisitor();
+
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
 
 	/**
-	 * 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;
+	template<class T>
+	std::string MultiArg<T>::shortID(const std::string &val) const
+	{
+		static_cast<void>(val); // Ignore input, don't warn
+		return Arg::shortID(_typeDesc) + " ... ";
+	}
 
 	/**
-	 * 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;
+	template<class T>
+	std::string MultiArg<T>::longID(const std::string &val) const
+	{
+		static_cast<void>(val); // Ignore input, don't warn
+		return Arg::longID(_typeDesc) + "  (accepted multiple times)";
+	}
 
 	/**
 	 * 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>
-MultiArg<T>::MultiArg(const std::string& flag, 
-                      const std::string& name,
-                      const std::string& desc,
-                      bool req,
-                      const std::string& typeDesc,
-                      Visitor* v)
-: Arg( flag, name, desc, req, true, v ),
-  _typeDesc( typeDesc ),
-  _constraint( NULL ),
-  _allowMore(false)
-{ 
-	_acceptsMultipleValues = true;
-}
-
-template<class T>
-MultiArg<T>::MultiArg(const std::string& flag, 
-                      const std::string& name,
-                      const std::string& desc,
-                      bool req,
-                      const std::string& typeDesc,
-                      CmdLineInterface& parser,
-                      Visitor* v)
-: Arg( flag, name, desc, req, true, v ),
-  _typeDesc( typeDesc ),
-  _constraint( NULL ),
-  _allowMore(false)
-{ 
-	parser.add( this );
-	_acceptsMultipleValues = true;
-}
-
-/**
- *
- */
-template<class T>
-MultiArg<T>::MultiArg(const std::string& flag, 
-                      const std::string& name,
-                      const std::string& desc,
-                      bool req,
-                      Constraint<T>* constraint,
-                      Visitor* v)
-: Arg( flag, name, desc, req, true, v ),
-  _typeDesc( constraint->shortID() ),
-  _constraint( constraint ),
-  _allowMore(false)
-{ 
-	_acceptsMultipleValues = true;
-}
-
-template<class T>
-MultiArg<T>::MultiArg(const std::string& flag, 
-                      const std::string& name,
-                      const std::string& desc,
-                      bool req,
-                      Constraint<T>* constraint,
-                      CmdLineInterface& parser,
-                      Visitor* v)
-: Arg( flag, name, desc, req, true, v ),
-  _typeDesc( constraint->shortID() ),
-  _constraint( constraint ),
-  _allowMore(false)
-{ 
-	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) 
-{
- 	if ( _ignoreable && Arg::ignoreRest() )
-		return false;
-
-	if ( _hasBlanks( args[*i] ) )
-		return false;
-
-	std::string flag = args[*i];
-	std::string value = "";
-
-   	trimFlag( flag, value );
-
-   	if ( argMatches( flag ) )
-   	{
-   		if ( Arg::delimiter() != ' ' && value == "" )
-			throw( ArgParseException( 
-			           "Couldn't find delimiter for this argument!",
-					   toString() ) );
-
-		// always take the first one, regardless of start string
-		if ( value == "" )
+	template<class T>
+	bool MultiArg<T>::isRequired() const
+	{
+		if (_required)
 		{
-			(*i)++;
-			if ( static_cast<unsigned int>(*i) < args.size() )
-				_extractValue( args[*i] );
+			if (_values.size() > 1)
+			{
+				return false;
+			}
 			else
-				throw( ArgParseException("Missing a value for this argument!",
-                                         toString() ) );
-		} 
+			{
+				return true;
+			}
+		}
 		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();
-
-		return true;
+		{
+			return false;
+		}
 	}
-	else
-		return false;
-}
-
-/**
- *
- */
-template<class T>
-std::string MultiArg<T>::shortID(const std::string& val) const
-{
-	static_cast<void>(val); // Ignore input, don't warn
-	return Arg::shortID(_typeDesc) + " ... ";
-}
 
-/**
- *
- */
-template<class T>
-std::string MultiArg<T>::longID(const std::string& val) const
-{
-	static_cast<void>(val); // Ignore input, don't warn
-	return Arg::longID(_typeDesc) + "  (accepted multiple times)";
-}
-
-/**
- * Once we've matched the first value, then the arg is no longer
- * required.
- */
-template<class T>
-bool MultiArg<T>::isRequired() const
-{
-	if ( _required )
+	template<class T>
+	void MultiArg<T>::_extractValue(const std::string &val)
 	{
-		if ( _values.size() > 1 )
-			return false;
-		else
-			return true;
-   	}
-   	else
-		return false;
-
-}
+		try
+		{
+			T tmp;
+			ExtractValue(tmp, val, typename ArgTraits<T>::ValueCategory());
+			_values.push_back(tmp);
+		}
+		catch (ArgParseException &e)
+		{
+			throw ArgParseException(e.error(), toString());
+		}
 
-template<class T>
-void MultiArg<T>::_extractValue( const std::string& 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;
-}
+		if (_constraint != NULL)
+		{
+			if (!_constraint->check(_values.back()))
+			{
+				throw (CmdLineParseException("Value '" + val + "' does not meet constraint: " +
+				      _constraint->description(), toString()));
+			}
+		}
+	}
 
-template<class T>
-void MultiArg<T>::reset()
-{
-	Arg::reset();
-	_values.clear();
-}
+	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
 
 #endif
diff --git a/src/tclap/MultiSwitchArg.h b/src/tclap/MultiSwitchArg.h
index 8820b64..33cd144 100755..100644
--- a/src/tclap/MultiSwitchArg.h
+++ b/src/tclap/MultiSwitchArg.h
@@ -1,5 +1,4 @@
-
-/****************************************************************************** 
+/******************************************************************************
 *
 *  file:  MultiSwitchArg.h
 *
@@ -30,187 +29,173 @@
 
 #include <tclap/SwitchArg.h>
 
-namespace TCLAP {
-
-/**
-* A multiple switch argument.  If the switch is set on the command line, then
-* the getValue method will return the number of times the switch appears.
-*/
-class MultiSwitchArg : public SwitchArg
+namespace TCLAP
 {
-	protected:
-
-		/**
-		 * The value of the switch.
-		 */
-		int _value;
-
-		/**
-		 * Used to support the reset() method so that ValueArg can be
-		 * reset to their constructed value.
-		 */
-		int _default;
-
-	public:
-
-		/**
-		 * MultiSwitchArg 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 init - Optional. The initial/default value of this Arg. 
-		 * Defaults to 0.
-		 * \param v - An optional visitor.  You probably should not
-		 * use this unless you have a very good reason.
-		 */
-		MultiSwitchArg(const std::string& flag, 
-				const std::string& name,
-				const std::string& desc,
-				int init = 0,
-				Visitor* v = NULL);
-
-
-		/**
-		 * MultiSwitchArg 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 parser - A CmdLine parser object to add this Arg to
-		 * \param init - Optional. The initial/default value of this Arg. 
-		 * Defaults to 0.
-		 * \param v - An optional visitor.  You probably should not
-		 * use this unless you have a very good reason.
-		 */
-		MultiSwitchArg(const std::string& flag, 
-				const std::string& name,
-				const std::string& desc,
-				CmdLineInterface& parser,
-				int init = 0,
-				Visitor* v = NULL);
-
-
-		/**
-		 * Handles the processing of the argument.
-		 * This re-implements the SwitchArg version of this method to set the
-		 * _value of the argument appropriately.
-		 * \param i - Pointer the the current argument in the list.
-		 * \param args - Mutable list of strings. Passed
-		 * in from main().
-		 */
-		virtual bool processArg(int* i, std::vector<std::string>& args); 
-
-		/**
-		 * Returns int, the number of times the switch has been set.
-		 */
-		int getValue();
-
-		/**
-		 * Returns the shortID for this Arg.
-		 */
-		std::string shortID(const std::string& val) const;
-
-		/**
-		 * Returns the longID for this Arg.
-		 */
-		std::string longID(const std::string& val) const;
-		
-		void reset();
-
-};
-
-//////////////////////////////////////////////////////////////////////
-//BEGIN MultiSwitchArg.cpp
-//////////////////////////////////////////////////////////////////////
-inline MultiSwitchArg::MultiSwitchArg(const std::string& flag,
-					const std::string& name,
-					const std::string& desc,
-					int init,
-					Visitor* v )
-: SwitchArg(flag, name, desc, false, v),
-_value( init ),
-_default( init )
-{ }
-
-inline MultiSwitchArg::MultiSwitchArg(const std::string& flag,
-					const std::string& name, 
-					const std::string& desc, 
-					CmdLineInterface& parser,
-					int init,
-					Visitor* v )
-: SwitchArg(flag, name, desc, false, v),
-_value( init ),
-_default( init )
-{ 
-	parser.add( this );
-}
-
-inline int MultiSwitchArg::getValue() { return _value; }
-
-inline bool MultiSwitchArg::processArg(int *i, std::vector<std::string>& args)
-{
-	if ( _ignoreable && Arg::ignoreRest() )
-		return false;
-
-	if ( argMatches( args[*i] ))
+	/**
+	* A multiple switch argument.  If the switch is set on the command line, then
+	* the getValue method will return the number of times the switch appears.
+	*/
+	class MultiSwitchArg : public SwitchArg
 	{
-		// so the isSet() method will work
-		_alreadySet = true;
-
-		// Matched argument: increment value.
-		++_value;
+		protected:
+			/**
+			 * The value of the switch.
+			 */
+			int _value;
+
+			/**
+			 * Used to support the reset() method so that ValueArg can be
+			 * reset to their constructed value.
+			 */
+			int _default;
+
+		public:
+			/**
+			 * MultiSwitchArg 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 init - Optional. The initial/default value of this Arg.
+			 * Defaults to 0.
+			 * \param v - An optional visitor.  You probably should not
+			 * use this unless you have a very good reason.
+			 */
+			MultiSwitchArg(const std::string &flag, const std::string &name, const std::string &desc,
+			        int init = 0, Visitor *v = NULL);
+
+
+			/**
+			 * MultiSwitchArg 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 parser - A CmdLine parser object to add this Arg to
+			 * \param init - Optional. The initial/default value of this Arg.
+			 * Defaults to 0.
+			 * \param v - An optional visitor.  You probably should not
+			 * use this unless you have a very good reason.
+			 */
+			MultiSwitchArg(const std::string &flag, const std::string &name, const std::string &desc,
+			        CmdLineInterface &parser, int init = 0, Visitor *v = NULL);
+
+
+			/**
+			 * Handles the processing of the argument.
+			 * This re-implements the SwitchArg version of this method to set the
+			 * _value of the argument appropriately.
+			 * \param i - Pointer the the current argument in the list.
+			 * \param args - Mutable list of strings. Passed
+			 * in from main().
+			 */
+			virtual bool processArg(int *i, std::vector<std::string> &args);
+
+			/**
+			 * Returns int, the number of times the switch has been set.
+			 */
+			int getValue();
+
+			/**
+			 * Returns the shortID for this Arg.
+			 */
+			std::string shortID(const std::string &val) const;
+
+			/**
+			 * Returns the longID for this Arg.
+			 */
+			std::string longID(const std::string &val) const;
+
+			void reset();
+	};
+
+	//////////////////////////////////////////////////////////////////////
+	//BEGIN MultiSwitchArg.cpp
+	//////////////////////////////////////////////////////////////////////
+	inline MultiSwitchArg::MultiSwitchArg(const std::string &flag, const std::string &name,
+	        const std::string &desc, int init, Visitor *v) :
+			SwitchArg(flag, name, desc, false, v), _value(init), _default(init)
+	{
+	}
 
-		_checkWithVisitor();
+	inline MultiSwitchArg::MultiSwitchArg(const std::string &flag, const std::string &name,
+	        const std::string &desc, CmdLineInterface &parser, int init,
+	        Visitor *v) :
+			SwitchArg(flag, name, desc, false, v), _value(init), _default(init)
+	{
+		parser.add(this);
+	}
 
-		return true;
+	inline int MultiSwitchArg::getValue()
+	{
+		return _value;
 	}
-	else if ( combinedSwitchesMatch( args[*i] ) )
+
+	inline bool MultiSwitchArg::processArg(int *i, std::vector<std::string> &args)
 	{
-		// so the isSet() method will work
-		_alreadySet = true;
+		if (_ignoreable && Arg::ignoreRest())
+		{
+			return false;
+		}
 
-		// Matched argument: increment value.
-		++_value;
+		if (argMatches(args[*i]))
+		{
+			// so the isSet() method will work
+			_alreadySet = true;
 
-		// Check for more in argument and increment value.
-		while ( combinedSwitchesMatch( args[*i] ) ) 
+			// Matched argument: increment value.
 			++_value;
 
-		_checkWithVisitor();
+			_checkWithVisitor();
 
-		return false;
-	}
-	else
-		return false;
-}
+			return true;
+		}
+		else if (combinedSwitchesMatch(args[*i]))
+		{
+			// so the isSet() method will work
+			_alreadySet = true;
 
-inline std::string 
-MultiSwitchArg::shortID(const std::string& val) const
-{
-	return Arg::shortID(val) + " ... ";
-}
+			// Matched argument: increment value.
+			++_value;
 
-inline std::string 
-MultiSwitchArg::longID(const std::string& val) const
-{
-	return Arg::longID(val) + "  (accepted multiple times)";
-}
+			// Check for more in argument and increment value.
+			while (combinedSwitchesMatch(args[*i]))
+			{
+				++_value;
+			}
 
-inline void
-MultiSwitchArg::reset()
-{
-	MultiSwitchArg::_value = MultiSwitchArg::_default;
-}
+			_checkWithVisitor();
 
-//////////////////////////////////////////////////////////////////////
-//END MultiSwitchArg.cpp
-//////////////////////////////////////////////////////////////////////
+			return false;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	inline std::string MultiSwitchArg::shortID(const std::string &val) const
+	{
+		return Arg::shortID(val) + " ... ";
+	}
+
+	inline std::string MultiSwitchArg::longID(const std::string &val) const
+	{
+		return Arg::longID(val) + "  (accepted multiple times)";
+	}
+
+	inline void MultiSwitchArg::reset()
+	{
+		MultiSwitchArg::_value = MultiSwitchArg::_default;
+	}
 
+	//////////////////////////////////////////////////////////////////////
+	//END MultiSwitchArg.cpp
+	//////////////////////////////////////////////////////////////////////
 } //namespace TCLAP
 
 #endif
diff --git a/src/tclap/OptionalUnlabeledTracker.h b/src/tclap/OptionalUnlabeledTracker.h
index 8174c5f..1ac8220 100755..100644
--- a/src/tclap/OptionalUnlabeledTracker.h
+++ b/src/tclap/OptionalUnlabeledTracker.h
@@ -1,24 +1,22 @@
-
-
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  OptionalUnlabeledTracker.h
- * 
+ *
  *  Copyright (c) 2005, Michael E. Smoot .
  *  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_OPTIONAL_UNLABELED_TRACKER_H
@@ -26,37 +24,45 @@
 
 #include <string>
 
-namespace TCLAP {
-
-class OptionalUnlabeledTracker
-{
-
-	public:
-
-		static void check( bool req, const std::string& argName );
-
-		static void gotOptional() { alreadyOptionalRef() = true; }
-
-		static bool& alreadyOptional() { return alreadyOptionalRef(); } 
-
-	private:
-
-		static bool& alreadyOptionalRef() { static bool ct = false; return ct; }
-};
-
-
-inline void OptionalUnlabeledTracker::check( bool req, const std::string& argName )
+namespace TCLAP
 {
-    if ( OptionalUnlabeledTracker::alreadyOptional() )
-        throw( SpecificationException(
-	"You can't specify ANY Unlabeled Arg following an optional Unlabeled Arg",
-	                argName ) );
-
-    if ( !req )
-        OptionalUnlabeledTracker::gotOptional();
-}
-
 
+	class OptionalUnlabeledTracker
+	{
+		public:
+			static void check(bool req, const std::string &argName);
+
+			static void gotOptional()
+			{
+				alreadyOptionalRef() = true;
+			}
+
+			static bool& alreadyOptional()
+			{
+				return alreadyOptionalRef();
+			}
+
+		private:
+			static bool& alreadyOptionalRef()
+			{
+				static bool ct = false;
+				return ct;
+			}
+	};
+
+	inline void OptionalUnlabeledTracker::check(bool req, const std::string &argName)
+	{
+		if (OptionalUnlabeledTracker::alreadyOptional())
+		{
+			throw (SpecificationException(
+							"You can't specify ANY Unlabeled Arg following an optional Unlabeled Arg", argName));
+		}
+
+		if (!req)
+		{
+			OptionalUnlabeledTracker::gotOptional();
+		}
+	}
 } // namespace TCLAP
 
 #endif
diff --git a/src/tclap/StandardTraits.h b/src/tclap/StandardTraits.h
index 151b851..4129c7e 100755..100644
--- a/src/tclap/StandardTraits.h
+++ b/src/tclap/StandardTraits.h
@@ -27,160 +27,174 @@
 #define TCLAP_STANDARD_TRAITS_H
 
 #ifdef HAVE_CONFIG_H
-#include <config.h> // To check for long long
+ #include <config.h> // To check for long long
 #endif
 
-namespace TCLAP {
-
-// ======================================================================
-// Integer types
-// ======================================================================
-
-/**
- * longs have value-like semantics.
- */
-template<>
-struct ArgTraits<long> {
-    typedef ValueLike ValueCategory;
-};
-
-/**
- * ints have value-like semantics.
- */
-template<>
-struct ArgTraits<int> {
-    typedef ValueLike ValueCategory;
-};
-
-/**
- * shorts have value-like semantics.
- */
-template<>
-struct ArgTraits<short> {
-    typedef ValueLike ValueCategory;
-};
-
-/**
- * chars have value-like semantics.
- */
-template<>
-struct ArgTraits<char> {
-    typedef ValueLike ValueCategory;
-};
+namespace TCLAP
+{
+	// ======================================================================
+	// Integer types
+	// ======================================================================
+
+	/**
+	 * longs have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<long>
+	{
+		typedef ValueLike ValueCategory;
+	};
+
+	/**
+	 * ints have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<int>
+	{
+		typedef ValueLike ValueCategory;
+	};
+
+	/**
+	 * shorts have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<short>
+	{
+		typedef ValueLike ValueCategory;
+	};
+
+	/**
+	 * chars have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<char>
+	{
+		typedef ValueLike ValueCategory;
+	};
 
 #ifdef HAVE_LONG_LONG
-/**
- * long longs have value-like semantics.
- */
-template<>
-struct ArgTraits<long long> {
-    typedef ValueLike ValueCategory;
-};
+	/**
+	 * long longs have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<long long>
+	{
+		typedef ValueLike ValueCategory;
+	};
+
 #endif
 
-// ======================================================================
-// Unsigned integer types
-// ======================================================================
-
-/**
- * unsigned longs have value-like semantics.
- */
-template<>
-struct ArgTraits<unsigned long> {
-    typedef ValueLike ValueCategory;
-};
-
-/**
- * unsigned ints have value-like semantics.
- */
-template<>
-struct ArgTraits<unsigned int> {
-    typedef ValueLike ValueCategory;
-};
-
-/**
- * unsigned shorts have value-like semantics.
- */
-template<>
-struct ArgTraits<unsigned short> {
-    typedef ValueLike ValueCategory;
-};
-
-/**
- * unsigned chars have value-like semantics.
- */
-template<>
-struct ArgTraits<unsigned char> {
-    typedef ValueLike ValueCategory;
-};
+	// ======================================================================
+	// Unsigned integer types
+	// ======================================================================
+
+	/**
+	 * unsigned longs have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<unsigned long>
+	{
+		typedef ValueLike ValueCategory;
+	};
+
+	/**
+	 * unsigned ints have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<unsigned int>
+	{
+		typedef ValueLike ValueCategory;
+	};
+
+	/**
+	 * unsigned shorts have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<unsigned short>
+	{
+		typedef ValueLike ValueCategory;
+	};
+
+	/**
+	 * unsigned chars have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<unsigned char>
+	{
+		typedef ValueLike ValueCategory;
+	};
 
 #ifdef HAVE_LONG_LONG
-/**
- * unsigned long longs have value-like semantics.
- */
-template<>
-struct ArgTraits<unsigned long long> {
-    typedef ValueLike ValueCategory;
-};
-#endif
+	/**
+	 * unsigned long longs have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<unsigned long long>
+	{
+		typedef ValueLike ValueCategory;
+	};
 
-// ======================================================================
-// Float types
-// ======================================================================
-
-/**
- * floats have value-like semantics.
- */
-template<>
-struct ArgTraits<float> {
-    typedef ValueLike ValueCategory;
-};
-
-/**
- * doubles have value-like semantics.
- */
-template<>
-struct ArgTraits<double> {
-    typedef ValueLike ValueCategory;
-};
-
-// ======================================================================
-// Other types
-// ======================================================================
-
-/**
- * bools have value-like semantics.
- */
-template<>
-struct ArgTraits<bool> {
-    typedef ValueLike ValueCategory;
-};
-
-/**
- * wchar_ts have value-like semantics.
- */
-/*
-template<>
-struct ArgTraits<wchar_t> {
-    typedef ValueLike ValueCategory;
-};
-*/
-
-/**
- * Strings have string like argument traits.
- */
-template<>
-struct ArgTraits<std::string> {
-    typedef StringLike ValueCategory;
-};
-
-template<typename T>
-void SetString(T &dst, const std::string &src)
-{
-    dst = src;
-}
+#endif
 
+	// ======================================================================
+	// Float types
+	// ======================================================================
+
+	/**
+	 * floats have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<float>
+	{
+		typedef ValueLike ValueCategory;
+	};
+
+	/**
+	 * doubles have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<double>
+	{
+		typedef ValueLike ValueCategory;
+	};
+
+	// ======================================================================
+	// Other types
+	// ======================================================================
+
+	/**
+	 * bools have value-like semantics.
+	 */
+	template<>
+	struct ArgTraits<bool>
+	{
+		typedef ValueLike ValueCategory;
+	};
+
+	/**
+	 * wchar_ts have value-like semantics.
+	 */
+	/*
+	template<>
+	struct ArgTraits<wchar_t> {
+	    typedef ValueLike ValueCategory;
+	};
+	*/
+
+	/**
+	 * Strings have string like argument traits.
+	 */
+	template<>
+	struct ArgTraits<std::string>
+	{
+		typedef StringLike ValueCategory;
+	};
+
+	template<typename T>
+	void SetString(T &dst, const std::string &src)
+	{
+		dst = src;
+	}
 } // namespace
 
 #endif
-
diff --git a/src/tclap/StdOutput.h b/src/tclap/StdOutput.h
index 9ceac0c..98272f3 100755..100644
--- a/src/tclap/StdOutput.h
+++ b/src/tclap/StdOutput.h
@@ -1,24 +1,24 @@
 // -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
 
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  StdOutput.h
- * 
+ *
  *  Copyright (c) 2004, Michael E. Smoot
  *  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_STDCMDLINEOUTPUT_H
 #define TCLAP_STDCMDLINEOUTPUT_H
@@ -34,265 +34,275 @@
 #include <tclap/XorHandler.h>
 #include <tclap/Arg.h>
 
-namespace TCLAP {
-
-/**
- * A class that isolates any output from the CmdLine object so that it
- * may be easily modified.
- */
-class StdOutput : public CmdLineOutput
-{
-
-	public:
-
-		/**
-		 * Prints the usage to stdout.  Can be overridden to 
-		 * produce alternative behavior.
-		 * \param c - The CmdLine object the output is generated for. 
-		 */
-		virtual void usage(CmdLineInterface& c);
-
-		/**
-		 * Prints the version to stdout. Can be overridden 
-		 * to produce alternative behavior.
-		 * \param c - The CmdLine object the output is generated for. 
-		 */
-		virtual void version(CmdLineInterface& c);
-
-		/**
-		 * Prints (to stderr) an error message, short usage 
-		 * Can be overridden to produce alternative behavior.
-		 * \param c - The CmdLine object the output is generated for. 
-		 * \param e - The ArgException that caused the failure. 
-		 */
-		virtual void failure(CmdLineInterface& c, 
-				     ArgException& e );
-
-	protected:
-
-        /**
-         * Writes a brief usage message with short args.
-		 * \param c - The CmdLine object the output is generated for. 
-         * \param os - The stream to write the message to.
-         */
-        void _shortUsage( CmdLineInterface& c, std::ostream& os ) const;
-
-        /**
-		 * Writes a longer usage message with long and short args, 
-		 * provides descriptions and prints message.
-		 * \param c - The CmdLine object the output is generated for. 
-		 * \param os - The stream to write the message to.
-		 */
-		void _longUsage( CmdLineInterface& c, std::ostream& os ) const;
-
-		/**
-		 * This function inserts line breaks and indents long strings 
-		 * according the  params input. It will only break lines at spaces, 
-		 * commas and pipes.
-		 * \param os - The stream to be printed to.
-		 * \param s - The string to be printed.
-		 * \param maxWidth - The maxWidth allowed for the output line. 
-		 * \param indentSpaces - The number of spaces to indent the first line. 
-		 * \param secondLineOffset - The number of spaces to indent the second
-		 * and all subsequent lines in addition to indentSpaces.
-		 */
-		void spacePrint( std::ostream& os, 
-						 const std::string& s, 
-						 int maxWidth, 
-						 int indentSpaces, 
-						 int secondLineOffset ) const;
-
-};
-
-
-inline void StdOutput::version(CmdLineInterface& _cmd) 
-{
-	std::string progName = _cmd.getProgramName();
-	std::string version = _cmd.getVersion();
-
-	std::cout << std::endl << progName << "  version: " 
-			  << version << std::endl << std::endl;
-}
-
-inline void StdOutput::usage(CmdLineInterface& _cmd ) 
+namespace TCLAP
 {
-	std::cout << std::endl << "USAGE: " << std::endl << std::endl; 
-
-	_shortUsage( _cmd, std::cout );
-
-	std::cout << std::endl << std::endl << "Where: " << std::endl << std::endl;
-
-	_longUsage( _cmd, std::cout );
-
-	std::cout << std::endl; 
-
-}
-
-inline void StdOutput::failure( CmdLineInterface& _cmd,
-								ArgException& e ) 
-{
-	std::string progName = _cmd.getProgramName();
-
-	std::cerr << "PARSE ERROR: " << e.argId() << std::endl
-		      << "             " << e.error() << std::endl << std::endl;
-
-	if ( _cmd.hasHelpAndVersion() )
+	/**
+	 * A class that isolates any output from the CmdLine object so that it
+	 * may be easily modified.
+	 */
+	class StdOutput : public CmdLineOutput
+	{
+		public:
+			/**
+			 * Prints the usage to stdout.  Can be overridden to
+			 * produce alternative behavior.
+			 * \param c - The CmdLine object the output is generated for.
+			 */
+			virtual void usage(CmdLineInterface &c);
+
+			/**
+			 * Prints the version to stdout. Can be overridden
+			 * to produce alternative behavior.
+			 * \param c - The CmdLine object the output is generated for.
+			 */
+			virtual void version(CmdLineInterface &c);
+
+			/**
+			 * Prints (to stderr) an error message, short usage
+			 * Can be overridden to produce alternative behavior.
+			 * \param c - The CmdLine object the output is generated for.
+			 * \param e - The ArgException that caused the failure.
+			 */
+			virtual void failure(CmdLineInterface &c, ArgException &e);
+
+		protected:
+			/**
+			   * Writes a brief usage message with short args.
+			* \param c - The CmdLine object the output is generated for.
+			   * \param os - The stream to write the message to.
+			   */
+			void _shortUsage(CmdLineInterface &c, std::ostream &os) const;
+
+			/**
+			* Writes a longer usage message with long and short args,
+			* provides descriptions and prints message.
+			* \param c - The CmdLine object the output is generated for.
+			* \param os - The stream to write the message to.
+			*/
+			void _longUsage(CmdLineInterface &c, std::ostream &os) const;
+
+			/**
+			 * This function inserts line breaks and indents long strings
+			 * according the  params input. It will only break lines at spaces,
+			 * commas and pipes.
+			 * \param os - The stream to be printed to.
+			 * \param s - The string to be printed.
+			 * \param maxWidth - The maxWidth allowed for the output line.
+			 * \param indentSpaces - The number of spaces to indent the first line.
+			 * \param secondLineOffset - The number of spaces to indent the second
+			 * and all subsequent lines in addition to indentSpaces.
+			 */
+			void spacePrint(std::ostream &os, const std::string &s, int maxWidth, int indentSpaces,
+			        int secondLineOffset) const;
+	};
+
+	inline void StdOutput::version(CmdLineInterface &_cmd)
+	{
+		std::string progName = _cmd.getProgramName();
+		std::string version  = _cmd.getVersion();
+
+		std::cout << std::endl << progName << "  version: " << version << std::endl << std::endl;
+	}
+
+	inline void StdOutput::usage(CmdLineInterface &_cmd)
+	{
+		std::cout << std::endl << "USAGE: " << std::endl << std::endl;
+
+		_shortUsage(_cmd, std::cout);
+
+		std::cout << std::endl << std::endl << "Where: " << std::endl << std::endl;
+
+		_longUsage(_cmd, std::cout);
+
+		std::cout << std::endl;
+	}
+
+	inline void StdOutput::failure(CmdLineInterface &_cmd, ArgException &e)
+	{
+		std::string progName = _cmd.getProgramName();
+
+		std::cerr << "PARSE ERROR: " << e.argId() << std::endl << "             " << e.error() <<
+		        std::endl << std::endl;
+
+		if (_cmd.hasHelpAndVersion())
 		{
 			std::cerr << "Brief USAGE: " << std::endl;
 
-			_shortUsage( _cmd, std::cerr );	
+			_shortUsage(_cmd, std::cerr);
 
-			std::cerr << std::endl << "For complete USAGE and HELP type: " 
-					  << std::endl << "   " << progName << " --help" 
-					  << std::endl << std::endl;
+			std::cerr << std::endl << "For complete USAGE and HELP type: " << std::endl << "   " <<
+			        progName << " --help" << std::endl << std::endl;
+		}
+		else
+		{
+			usage(_cmd);
 		}
-	else
-		usage(_cmd);
 
-	throw ExitException(1);
-}
+		throw ExitException(1);
+	}
 
-inline void 
-StdOutput::_shortUsage( CmdLineInterface& _cmd, 
-						std::ostream& os ) const
-{
-	std::list<Arg*> argList = _cmd.getArgList();
-	std::string progName = _cmd.getProgramName();
-	XorHandler xorHandler = _cmd.getXorHandler();
-	std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
+	inline void StdOutput::_shortUsage(CmdLineInterface &_cmd, std::ostream &os) const
+	{
+		std::list<Arg*> argList    = _cmd.getArgList();
+		std::string     progName   = _cmd.getProgramName();
+		XorHandler      xorHandler = _cmd.getXorHandler();
+		std::vector<std::vector<Arg*>> xorList = xorHandler.getXorList();
 
-	std::string s = progName + " ";
+		std::string s = progName + " ";
 
-	// first the xor
-	for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
+		// first the xor
+		for (int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++)
 		{
 			s += " {";
-			for ( ArgVectorIterator it = xorList[i].begin(); 
-				  it != xorList[i].end(); it++ )
+			for (ArgVectorIterator it = xorList[i].begin();
+			        it != xorList[i].end(); it++)
+			{
 				s += (*it)->shortID() + "|";
+			}
 
-			s[s.length()-1] = '}';
+			s[s.length() - 1] = '}';
 		}
 
-	// then the rest
-	for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
-		if ( !xorHandler.contains( (*it) ) )
-			s += " " + (*it)->shortID();
+		// then the rest
+		for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
+		{
+			if (!xorHandler.contains((*it)))
+			{
+				s += " " + (*it)->shortID();
+			}
+		}
 
-	// if the program name is too long, then adjust the second line offset 
-	int secondLineOffset = static_cast<int>(progName.length()) + 2;
-	if ( secondLineOffset > 75/2 )
-		secondLineOffset = static_cast<int>(75/2);
+		// if the program name is too long, then adjust the second line offset
+		int secondLineOffset = static_cast<int>(progName.length()) + 2;
+		if (secondLineOffset > 75 / 2)
+		{
+			secondLineOffset = static_cast<int>(75 / 2);
+		}
 
-	spacePrint( os, s, 75, 3, secondLineOffset );
-}
+		spacePrint(os, s, 75, 3, secondLineOffset);
+	}
 
-inline void 
-StdOutput::_longUsage( CmdLineInterface& _cmd, 
-					   std::ostream& os ) const
-{
-	std::list<Arg*> argList = _cmd.getArgList();
-	std::string message = _cmd.getMessage();
-	XorHandler xorHandler = _cmd.getXorHandler();
-	std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
+	inline void StdOutput::_longUsage(CmdLineInterface &_cmd, std::ostream &os) const
+	{
+		std::list<Arg*> argList    = _cmd.getArgList();
+		std::string     message    = _cmd.getMessage();
+		XorHandler      xorHandler = _cmd.getXorHandler();
+		std::vector<std::vector<Arg*>> xorList = xorHandler.getXorList();
 
-	// first the xor 
-	for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
+		// first the xor
+		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 );
+			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);
+				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) ) )
+		// 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 ); 
+				spacePrint(os, (*it)->longID(), 75, 3, 3);
+				spacePrint(os, (*it)->getDescription(), 75, 5, 0);
 				os << std::endl;
 			}
+		}
 
-	os << std::endl;
+		os << std::endl;
 
-	spacePrint( os, message, 75, 3, 0 );
-}
+		spacePrint(os, message, 75, 3, 0);
+	}
 
-inline void StdOutput::spacePrint( std::ostream& os, 
-						           const std::string& s, 
-						           int maxWidth, 
-						           int indentSpaces, 
-						           int secondLineOffset ) const
-{
-	int len = static_cast<int>(s.length());
+	inline void StdOutput::spacePrint(std::ostream &os, const std::string &s, int maxWidth,
+	        int indentSpaces, int secondLineOffset) const
+	{
+		int len = static_cast<int>(s.length());
 
-	if ( (len + indentSpaces > maxWidth) && maxWidth > 0 )
+		if ((len + indentSpaces > maxWidth) && maxWidth > 0)
 		{
 			int allowedLen = maxWidth - indentSpaces;
-			int start = 0;
-			while ( start < len )
+			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
+				// 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++)
 				{
-					// 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 
-					// 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;
+					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
+		else
 		{
-			for ( int i = 0; i < indentSpaces; i++ )
+			for (int i = 0; i < indentSpaces; i++)
+			{
 				os << " ";
+			}
 			os << s << std::endl;
 		}
-}
-
+	}
 } //namespace TCLAP
-#endif 
+
+#endif
diff --git a/src/tclap/SwitchArg.h b/src/tclap/SwitchArg.h
index dc4952e..78b8c0c 100755..100644
--- a/src/tclap/SwitchArg.h
+++ b/src/tclap/SwitchArg.h
@@ -1,24 +1,23 @@
-
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  SwitchArg.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_SWITCH_ARG_H
@@ -29,200 +28,202 @@
 
 #include <tclap/Arg.h>
 
-namespace TCLAP {
-
-/**
- * A simple switch argument.  If the switch is set on the command line, then
- * the getValue method will return the opposite of the default value for the
- * switch.
- */
-class SwitchArg : public Arg
-{
-	protected:
-
-		/**
-		 * The value of the switch.
-		 */
-		bool _value;
-
-		/**
-		 * Used to support the reset() method so that ValueArg can be
-		 * reset to their constructed value.
-		 */
-        bool _default;
-
-	public:
-
-        /**
-		 * SwitchArg 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 def - The default value for this Switch. 
-		 * \param v - An optional visitor.  You probably should not
-		 * use this unless you have a very good reason.
-		 */
-		SwitchArg(const std::string& flag, 
-			      const std::string& name, 
-			      const std::string& desc,
-			      bool def = false,
-				  Visitor* v = NULL);
-
-				  
-		/**
-		 * SwitchArg 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 parser - A CmdLine parser object to add this Arg to
-		 * \param def - The default value for this Switch.
-		 * \param v - An optional visitor.  You probably should not
-		 * use this unless you have a very good reason.
-		 */
-		SwitchArg(const std::string& flag, 
-			      const std::string& name, 
-			      const std::string& desc,
-				  CmdLineInterface& parser,
-			      bool def = false,
-				  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.
-		 * \param i - Pointer the the current argument in the list.
-		 * \param args - Mutable list of strings. Passed
-		 * in from main().
-		 */
-		virtual bool processArg(int* i, std::vector<std::string>& args); 
-
-		/**
-		 * Checks a string to see if any of the chars in the string
-		 * match the flag for this Switch.
-		 */
-		bool combinedSwitchesMatch(std::string& combined);
-
-		/**
-		 * Returns bool, whether or not the switch has been set.
-		 */
-		bool getValue();
-		
-		virtual void reset();
-
-};
-
-//////////////////////////////////////////////////////////////////////
-//BEGIN SwitchArg.cpp
-//////////////////////////////////////////////////////////////////////
-inline SwitchArg::SwitchArg(const std::string& flag, 
-	 		         const std::string& name, 
-     		   		 const std::string& desc, 
-	     	    	 bool default_val,
-					 Visitor* v )
-: Arg(flag, name, desc, false, false, v),
-  _value( default_val ),
-  _default( default_val )
-{ }
-
-inline SwitchArg::SwitchArg(const std::string& flag, 
-					const std::string& name, 
-					const std::string& desc, 
-					CmdLineInterface& parser,
-					bool default_val,
-					Visitor* v )
-: Arg(flag, name, desc, false, false, v),
-  _value( default_val ),
-  _default(default_val)
-{ 
-	parser.add( this );
-}
-
-inline bool SwitchArg::getValue() { return _value; }
-
-inline bool SwitchArg::combinedSwitchesMatch(std::string& combinedSwitches )
+namespace TCLAP
 {
-	// make sure this is actually a combined switch
-	if ( combinedSwitches.length() > 0 &&
-	     combinedSwitches[0] != Arg::flagStartString()[0] )
-		return false;
+	/**
+	 * A simple switch argument.  If the switch is set on the command line, then
+	 * the getValue method will return the opposite of the default value for the
+	 * switch.
+	 */
+	class SwitchArg : public Arg
+	{
+		protected:
+			/**
+			 * The value of the switch.
+			 */
+			bool _value;
+
+			/**
+			 * Used to support the reset() method so that ValueArg can be
+			 * reset to their constructed value.
+			 */
+			bool _default;
+
+		public:
+			/**
+			* SwitchArg 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 def - The default value for this Switch.
+			* \param v - An optional visitor.  You probably should not
+			* use this unless you have a very good reason.
+			*/
+			SwitchArg(const std::string &flag, const std::string &name, const std::string &desc,
+			        bool def = false, Visitor *v = NULL);
+
+
+			/**
+			 * SwitchArg 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 parser - A CmdLine parser object to add this Arg to
+			 * \param def - The default value for this Switch.
+			 * \param v - An optional visitor.  You probably should not
+			 * use this unless you have a very good reason.
+			 */
+			SwitchArg(const std::string &flag, const std::string &name, const std::string &desc,
+			        CmdLineInterface &parser, bool def = false, 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.
+			* \param i - Pointer the the current argument in the list.
+			* \param args - Mutable list of strings. Passed
+			* in from main().
+			*/
+			virtual bool processArg(int *i, std::vector<std::string> &args);
+
+			/**
+			 * Checks a string to see if any of the chars in the string
+			 * match the flag for this Switch.
+			 */
+			bool combinedSwitchesMatch(std::string &combined);
+
+			/**
+			 * Returns bool, whether or not the switch has been set.
+			 */
+			bool getValue();
+
+			virtual void reset();
+	};
+
+	//////////////////////////////////////////////////////////////////////
+	//BEGIN SwitchArg.cpp
+	//////////////////////////////////////////////////////////////////////
+	inline SwitchArg::SwitchArg(const std::string &flag, const std::string &name,
+	        const std::string &desc, bool default_val, Visitor *v) :
+			Arg(flag, name, desc, false, false, v), _value(default_val), _default(default_val)
+	{
+	}
 
-	// make sure it isn't a long name 
-	if ( combinedSwitches.substr( 0, Arg::nameStartString().length() ) == 
-		 Arg::nameStartString() )
-		return false;
+	inline SwitchArg::SwitchArg(const std::string &flag, const std::string &name,
+	        const std::string &desc, CmdLineInterface &parser, bool default_val,
+	        Visitor *v) :
+			Arg(flag, name, desc, false, false, v), _value(default_val), _default(default_val)
+	{
+		parser.add(this);
+	}
 
-	// make sure the delimiter isn't in the string 
-	if ( combinedSwitches.find_first_of( Arg::delimiter() ) != std::string::npos )
-		return false;
+	inline bool SwitchArg::getValue()
+	{
+		return _value;
+	}
 
-	// ok, we're not specifying a ValueArg, so we know that we have
-	// a combined switch list.  
-	for ( unsigned int i = 1; i < combinedSwitches.length(); i++ )
-		if ( _flag.length() > 0 && 
-		     combinedSwitches[i] == _flag[0] &&
-		     _flag[0] != Arg::flagStartString()[0] ) 
+	inline bool SwitchArg::combinedSwitchesMatch(std::string &combinedSwitches)
+	{
+		// make sure this is actually a combined switch
+		if (combinedSwitches.length() > 0 &&
+		        combinedSwitches[0] != Arg::flagStartString()[0])
 		{
-			// update the combined switches so this one is no longer present
-			// this is necessary so that no unlabeled args are matched
-			// later in the processing.
-			//combinedSwitches.erase(i,1);
-			combinedSwitches[i] = Arg::blankChar(); 
-			return true;
+			return false;
 		}
 
-	// none of the switches passed in the list match. 
-	return false;	
-}
+		// make sure it isn't a long name
+		if (combinedSwitches.substr(0, Arg::nameStartString().length()) == Arg::nameStartString())
+		{
+			return false;
+		}
 
+		// make sure the delimiter isn't in the string
+		if (combinedSwitches.find_first_of(Arg::delimiter()) != std::string::npos)
+		{
+			return false;
+		}
 
-inline bool SwitchArg::processArg(int *i, std::vector<std::string>& args)
-{
-	if ( _ignoreable && Arg::ignoreRest() )
+		// ok, we're not specifying a ValueArg, so we know that we have
+		// a combined switch list.
+		for (unsigned int i = 1; i < combinedSwitches.length(); i++)
+		{
+			if (_flag.length() > 0 &&
+			        combinedSwitches[i] == _flag[0] &&
+			        _flag[0] != Arg::flagStartString()[0])
+			{
+				// update the combined switches so this one is no longer present
+				// this is necessary so that no unlabeled args are matched
+				// later in the processing.
+				//combinedSwitches.erase(i,1);
+				combinedSwitches[i] = Arg::blankChar();
+				return true;
+			}
+		}
+
+		// none of the switches passed in the list match.
 		return false;
+	}
 
-	if ( argMatches( args[*i] ) || combinedSwitchesMatch( args[*i] ) )
+	inline bool SwitchArg::processArg(int *i, std::vector<std::string> &args)
 	{
-		// If we match on a combined switch, then we want to return false
-		// so that other switches in the combination will also have a
-		// chance to match.
-		bool ret = false;
-		if ( argMatches( args[*i] ) )
-			ret = true;
-
-		if ( _alreadySet || ( !ret && combinedSwitchesMatch( args[*i] ) ) )
-			throw(CmdLineParseException("Argument already set!", toString()));	
-
-		_alreadySet = true;
+		if (_ignoreable && Arg::ignoreRest())
+		{
+			return false;
+		}
 
-		if ( _value == true )
-			_value = false;
+		if (argMatches(args[*i]) || combinedSwitchesMatch(args[*i]))
+		{
+			// If we match on a combined switch, then we want to return false
+			// so that other switches in the combination will also have a
+			// chance to match.
+			bool ret = false;
+			if (argMatches(args[*i]))
+			{
+				ret = true;
+			}
+
+			if (_alreadySet || (!ret && combinedSwitchesMatch(args[*i])))
+			{
+				throw (CmdLineParseException("Argument already set!", toString()));
+			}
+
+			_alreadySet = true;
+
+			if (_value == true)
+			{
+				_value = false;
+			}
+			else
+			{
+				_value = true;
+			}
+
+			_checkWithVisitor();
+
+			return ret;
+		}
 		else
-			_value = true;
-
-		_checkWithVisitor();
-
-		return ret;
+		{
+			return false;
+		}
 	}
-	else
-		return false;
-}
 
-inline void SwitchArg::reset()
-{
-	Arg::reset();
-	_value = _default;  
-}
-//////////////////////////////////////////////////////////////////////
-//End SwitchArg.cpp
-//////////////////////////////////////////////////////////////////////
+	inline void SwitchArg::reset()
+	{
+		Arg::reset();
+		_value = _default;
+	}
 
+	//////////////////////////////////////////////////////////////////////
+	//End SwitchArg.cpp
+	//////////////////////////////////////////////////////////////////////
 } //namespace TCLAP
 
 #endif
diff --git a/src/tclap/UnlabeledMultiArg.h b/src/tclap/UnlabeledMultiArg.h
index d5e1781..c338a6a 100755..100644
--- a/src/tclap/UnlabeledMultiArg.h
+++ b/src/tclap/UnlabeledMultiArg.h
@@ -1,23 +1,22 @@
-
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  UnlabeledMultiArg.h
- * 
+ *
  *  Copyright (c) 2003, Michael E. Smoot.
  *  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_MULTIPLE_UNLABELED_ARGUMENT_H
@@ -29,273 +28,243 @@
 #include <tclap/MultiArg.h>
 #include <tclap/OptionalUnlabeledTracker.h>
 
-namespace TCLAP {
-
-/**
- * Just like a MultiArg, except that the arguments are unlabeled.  Basically,
- * this Arg will slurp up everything that hasn't been matched to another 
- * Arg.
- */
-template<class T>
-class UnlabeledMultiArg : public MultiArg<T>
-{
-
-	// If compiler has two stage name lookup (as gcc >= 3.4 does)
-	// this is requried to prevent undef. symbols
-	using MultiArg<T>::_ignoreable;
-	using MultiArg<T>::_hasBlanks;
-	using MultiArg<T>::_extractValue;
-	using MultiArg<T>::_typeDesc;
-	using MultiArg<T>::_name;
-	using MultiArg<T>::_description;
-	using MultiArg<T>::_alreadySet;
-	using MultiArg<T>::toString;
-
-	public:
-		
-		/**
-		 * Constructor.  
-		 * \param name - The name of the Arg. Note that this is used for
-		 * identification, not as a long flag.
-		 * \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 ignoreable - Whether or not this argument can be ignored
-		 * using the "--" flag.
-		 * \param v - An optional visitor.  You probably should not
-		 * use this unless you have a very good reason.
-		 */
-		UnlabeledMultiArg( const std::string& name,
-				           const std::string& desc,
-						   bool req,
-				           const std::string& typeDesc,
-						   bool ignoreable = false,
-				           Visitor* v = NULL );
-		/**
-		 * Constructor.  
-		 * \param name - The name of the Arg. Note that this is used for
-		 * identification, not as a long flag.
-		 * \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 ignoreable - Whether or not this argument can be ignored
-		 * using the "--" flag.
-		 * \param v - An optional visitor.  You probably should not
-		 * use this unless you have a very good reason.
-		 */
-		UnlabeledMultiArg( const std::string& name,
-				           const std::string& desc,
-						   bool req,
-				           const std::string& typeDesc,
-						   CmdLineInterface& parser,
-						   bool ignoreable = false,
-				           Visitor* v = NULL );
-						 
-		/**
-		 * Constructor.  
-		 * \param name - The name of the Arg. Note that this is used for
-		 * identification, not as a long flag.
-		 * \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 ignoreable - Whether or not this argument can be ignored
-		 * using the "--" flag.
-		 * \param v - An optional visitor.  You probably should not
-		 * use this unless you have a very good reason.
-		 */
-		UnlabeledMultiArg( const std::string& name,
-						   const std::string& desc,
-						   bool req,
-						   Constraint<T>* constraint,
-						   bool ignoreable = false,
-						   Visitor* v = NULL );
-
-		/**
-		 * Constructor.  
-		 * \param name - The name of the Arg. Note that this is used for
-		 * identification, not as a long flag.
-		 * \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 ignoreable - Whether or not this argument can be ignored
-		 * using the "--" flag.
-		 * \param v - An optional visitor.  You probably should not
-		 * use this unless you have a very good reason.
-		 */
-		UnlabeledMultiArg( const std::string& name, 
-						   const std::string& desc, 
-						   bool req,
-						   Constraint<T>* constraint,
-						   CmdLineInterface& parser,
-						   bool ignoreable = false,
-						   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 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;
-
-		/**
-		 * Opertor ==.
-		 * \param a - The Arg to be compared to this.
-		 */
-		virtual bool operator==(const Arg& a) const;
-
-		/**
-		 * Pushes this to back of list rather than front.
-		 * \param argList - The list this should be added to.
-		 */
-		virtual void addToList( std::list<Arg*>& argList ) const;
-};
-
-template<class T>
-UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name, 
-				                        const std::string& desc, 
-										bool req,
-					                    const std::string& typeDesc,
-										bool ignoreable,
-					                    Visitor* v)
-: MultiArg<T>("", name, desc,  req, typeDesc, v)
-{ 
-	_ignoreable = ignoreable;
-	OptionalUnlabeledTracker::check(true, toString());
-}
-
-template<class T>
-UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name, 
-				                        const std::string& desc, 
-										bool req,
-					                    const std::string& typeDesc,
-										CmdLineInterface& parser,
-										bool ignoreable,
-					                    Visitor* v)
-: MultiArg<T>("", name, desc,  req, typeDesc, v)
-{ 
-	_ignoreable = ignoreable;
-	OptionalUnlabeledTracker::check(true, toString());
-	parser.add( this );
-}
-
-
-template<class T>
-UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name, 
-				                        const std::string& desc, 
-										bool req,
-					                    Constraint<T>* constraint,
-										bool ignoreable,
-					                    Visitor* v)
-: MultiArg<T>("", name, desc,  req, constraint, v)
-{ 
-	_ignoreable = ignoreable;
-	OptionalUnlabeledTracker::check(true, toString());
-}
-
-template<class T>
-UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name, 
-				                        const std::string& desc, 
-										bool req,
-					                    Constraint<T>* constraint,
-										CmdLineInterface& parser,
-										bool ignoreable,
-					                    Visitor* v)
-: MultiArg<T>("", name, desc,  req, constraint, v)
-{ 
-	_ignoreable = ignoreable;
-	OptionalUnlabeledTracker::check(true, toString());
-	parser.add( this );
-}
-
-
-template<class T>
-bool UnlabeledMultiArg<T>::processArg(int *i, std::vector<std::string>& args) 
+namespace TCLAP
 {
+	/**
+	 * Just like a MultiArg, except that the arguments are unlabeled.  Basically,
+	 * this Arg will slurp up everything that hasn't been matched to another
+	 * Arg.
+	 */
+	template<class T>
+	class UnlabeledMultiArg : public MultiArg<T>
+	{
+		// If compiler has two stage name lookup (as gcc >= 3.4 does)
+		// this is requried to prevent undef. symbols
+		using MultiArg<T>::_ignoreable;
+		using MultiArg<T>::_hasBlanks;
+		using MultiArg<T>::_extractValue;
+		using MultiArg<T>::_typeDesc;
+		using MultiArg<T>::_name;
+		using MultiArg<T>::_description;
+		using MultiArg<T>::_alreadySet;
+		using MultiArg<T>::toString;
+
+		public:
+			/**
+			 * Constructor.
+			 * \param name - The name of the Arg. Note that this is used for
+			 * identification, not as a long flag.
+			 * \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 ignoreable - Whether or not this argument can be ignored
+			 * using the "--" flag.
+			 * \param v - An optional visitor.  You probably should not
+			 * use this unless you have a very good reason.
+			 */
+			UnlabeledMultiArg(const std::string &name, const std::string &desc, bool req,
+			        const std::string &typeDesc, bool ignoreable = false, Visitor *v = NULL);
+
+			/**
+			 * Constructor.
+			 * \param name - The name of the Arg. Note that this is used for
+			 * identification, not as a long flag.
+			 * \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 ignoreable - Whether or not this argument can be ignored
+			 * using the "--" flag.
+			 * \param v - An optional visitor.  You probably should not
+			 * use this unless you have a very good reason.
+			 */
+			UnlabeledMultiArg(const std::string &name, const std::string &desc, bool req,
+			        const std::string &typeDesc, CmdLineInterface &parser,
+			        bool ignoreable = false, Visitor *v = NULL);
+
+			/**
+			 * Constructor.
+			 * \param name - The name of the Arg. Note that this is used for
+			 * identification, not as a long flag.
+			 * \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 ignoreable - Whether or not this argument can be ignored
+			 * using the "--" flag.
+			 * \param v - An optional visitor.  You probably should not
+			 * use this unless you have a very good reason.
+			 */
+			UnlabeledMultiArg(const std::string &name, const std::string &desc, bool req,
+			        Constraint<T> *constraint, bool ignoreable = false, Visitor *v = NULL);
+
+			/**
+			 * Constructor.
+			 * \param name - The name of the Arg. Note that this is used for
+			 * identification, not as a long flag.
+			 * \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 ignoreable - Whether or not this argument can be ignored
+			 * using the "--" flag.
+			 * \param v - An optional visitor.  You probably should not
+			 * use this unless you have a very good reason.
+			 */
+			UnlabeledMultiArg(const std::string &name, const std::string &desc, bool req,
+			        Constraint<T> *constraint, CmdLineInterface &parser,
+			        bool ignoreable = false, 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 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;
+
+			/**
+			 * Opertor ==.
+			 * \param a - The Arg to be compared to this.
+			 */
+			virtual bool operator==(const Arg &a) const;
+
+			/**
+			 * Pushes this to back of list rather than front.
+			 * \param argList - The list this should be added to.
+			 */
+			virtual void addToList(std::list<Arg*> &argList) const;
+	};
+
+	template<class T>
+	UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string &name, const std::string &desc,
+	        bool req, const std::string &typeDesc, bool ignoreable,
+	        Visitor *v) :
+			MultiArg<T>("", name, desc, req, typeDesc, v)
+	{
+		_ignoreable = ignoreable;
+		OptionalUnlabeledTracker::check(true, toString());
+	}
+
+	template<class T>
+	UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string &name, const std::string &desc,
+	        bool req, const std::string &typeDesc,
+	        CmdLineInterface &parser, bool ignoreable, Visitor *v) :
+			MultiArg<T>("", name, desc, req, typeDesc, v)
+	{
+		_ignoreable = ignoreable;
+		OptionalUnlabeledTracker::check(true, toString());
+		parser.add(this);
+	}
+
+	template<class T>
+	UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string &name, const std::string &desc,
+	        bool req, Constraint<T> *constraint, bool ignoreable,
+	        Visitor *v) :
+			MultiArg<T>("", name, desc, req, constraint, v)
+	{
+		_ignoreable = ignoreable;
+		OptionalUnlabeledTracker::check(true, toString());
+	}
+
+	template<class T>
+	UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string &name, const std::string &desc,
+	        bool req, Constraint<T> *constraint,
+	        CmdLineInterface &parser, bool ignoreable, Visitor *v) :
+			MultiArg<T>("", name, desc, req, constraint, v)
+	{
+		_ignoreable = ignoreable;
+		OptionalUnlabeledTracker::check(true, toString());
+		parser.add(this);
+	}
+
+	template<class T>
+	bool UnlabeledMultiArg<T>::processArg(int *i, std::vector<std::string> &args)
+	{
+		if (_hasBlanks(args[*i]))
+		{
+			return false;
+		}
+
+		// never ignore an unlabeled multi arg
+
+		// always take the first value, regardless of the start string
+		_extractValue(args[(*i)]);
+
+		/*
+		// continue taking args until we hit the end or 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;
 
-	if ( _hasBlanks( args[*i] ) )
-		return false;
-
-	// never ignore an unlabeled multi arg
-
-
-	// always take the first value, regardless of the start string 
-	_extractValue( args[(*i)] );
-
-	/*
-	// continue taking args until we hit the end or 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;
-
-	return true;
-}
-
-template<class T>
-std::string UnlabeledMultiArg<T>::shortID(const std::string& val) const
-{
-	static_cast<void>(val); // Ignore input, don't warn
-	return std::string("<") + _typeDesc + "> ...";
-}
-
-template<class T>
-std::string UnlabeledMultiArg<T>::longID(const std::string& val) const
-{
-	static_cast<void>(val); // Ignore input, don't warn
-	return std::string("<") + _typeDesc + ">  (accepted multiple times)";
-}
-
-template<class T>
-bool UnlabeledMultiArg<T>::operator==(const Arg& a) const
-{
-	if ( _name == a.getName() || _description == a.getDescription() )
 		return true;
-	else
-		return false;
-}
-
-template<class T>
-void UnlabeledMultiArg<T>::addToList( std::list<Arg*>& argList ) const
-{
-	argList.push_back( const_cast<Arg*>(static_cast<const Arg* const>(this)) );
-}
-
+	}
+
+	template<class T>
+	std::string UnlabeledMultiArg<T>::shortID(const std::string &val) const
+	{
+		static_cast<void>(val); // Ignore input, don't warn
+		return std::string("<") + _typeDesc + "> ...";
+	}
+
+	template<class T>
+	std::string UnlabeledMultiArg<T>::longID(const std::string &val) const
+	{
+		static_cast<void>(val); // Ignore input, don't warn
+		return std::string("<") + _typeDesc + ">  (accepted multiple times)";
+	}
+
+	template<class T>
+	bool UnlabeledMultiArg<T>::operator==(const Arg &a) const
+	{
+		if (_name == a.getName() || _description == a.getDescription())
+		{
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	template<class T>
+	void UnlabeledMultiArg<T>::addToList(std::list<Arg*> &argList) const
+	{
+		argList.push_back(const_cast<Arg*>(static_cast<const Arg*const>(this)));
+	}
 }
 
 #endif
diff --git a/src/tclap/UnlabeledValueArg.h b/src/tclap/UnlabeledValueArg.h
index 5721d61..d22e3c9 100755..100644
--- a/src/tclap/UnlabeledValueArg.h
+++ b/src/tclap/UnlabeledValueArg.h
@@ -1,24 +1,23 @@
-
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  UnlabeledValueArg.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_UNLABELED_VALUE_ARGUMENT_H
@@ -31,310 +30,275 @@
 #include <tclap/OptionalUnlabeledTracker.h>
 
 
-namespace TCLAP {
-
-/**
- * The basic unlabeled argument that parses a value.
- * This is a template class, which means the type T defines the type
- * that a given object will attempt to parse when an UnlabeledValueArg
- * is reached in the list of args that the CmdLine iterates over.
- */
-template<class T>
-class UnlabeledValueArg : public ValueArg<T>
+namespace TCLAP
 {
-
-	// If compiler has two stage name lookup (as gcc >= 3.4 does)
-	// this is requried to prevent undef. symbols
-	using ValueArg<T>::_ignoreable;
-	using ValueArg<T>::_hasBlanks;
-	using ValueArg<T>::_extractValue;
-	using ValueArg<T>::_typeDesc;
-	using ValueArg<T>::_name;
-	using ValueArg<T>::_description;
-	using ValueArg<T>::_alreadySet;
-	using ValueArg<T>::toString;
-
-	public:
-
-		/**
-		 * UnlabeledValueArg constructor.
-		 * \param name - A one word name for the argument.  Note that this is used for
-		 * identification, not as a long flag.
-		 * \param desc - A description of what the argument is for or
-		 * does.
-		 * \param req - Whether the argument is required on the command
-		 * line.
-		 * \param value - The default value assigned to this argument if it
-		 * is not present 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 ignoreable - Allows you to specify that this argument can be
-		 * ignored if the '--' flag is set.  This defaults to false (cannot
-		 * be ignored) and should  generally stay that way unless you have 
-		 * some special need for certain arguments to be ignored.
-		 * \param v - Optional Vistor.  You should leave this blank unless
-		 * you have a very good reason.
-		 */
-		UnlabeledValueArg( const std::string& name, 
-			               const std::string& desc, 
-						   bool req,
-				           T value,
-				           const std::string& typeDesc,
-						   bool ignoreable = false,
-				           Visitor* v = NULL); 
-
-		/**
-		 * UnlabeledValueArg constructor.
-		 * \param name - A one word name for the argument.  Note that this is used for
-		 * identification, not as a long flag.
-		 * \param desc - A description of what the argument is for or
-		 * does.
-		 * \param req - Whether the argument is required on the command
-		 * line.
-		 * \param value - The default value assigned to this argument if it
-		 * is not present 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 ignoreable - Allows you to specify that this argument can be
-		 * ignored if the '--' flag is set.  This defaults to false (cannot
-		 * be ignored) and should  generally stay that way unless you have 
-		 * some special need for certain arguments to be ignored.
-		 * \param v - Optional Vistor.  You should leave this blank unless
-		 * you have a very good reason.
-		 */
-		UnlabeledValueArg( const std::string& name, 
-			               const std::string& desc, 
-						   bool req,
-				           T value,
-				           const std::string& typeDesc,
-						   CmdLineInterface& parser,
-						   bool ignoreable = false,
-				           Visitor* v = NULL ); 					
-						
-		/**
-		 * UnlabeledValueArg constructor.
-		 * \param name - A one word name for the argument.  Note that this is used for
-		 * identification, not as a long flag.
-		 * \param desc - A description of what the argument is for or
-		 * does.
-		 * \param req - Whether the argument is required on the command
-		 * line.
-		 * \param value - The default value assigned to this argument if it
-		 * is not present on the command line.
-		 * \param constraint - A pointer to a Constraint object used
-		 * to constrain this Arg.
-		 * \param ignoreable - Allows you to specify that this argument can be
-		 * ignored if the '--' flag is set.  This defaults to false (cannot
-		 * be ignored) and should  generally stay that way unless you have 
-		 * some special need for certain arguments to be ignored.
-		 * \param v - Optional Vistor.  You should leave this blank unless
-		 * you have a very good reason.
-		 */
-		UnlabeledValueArg( const std::string& name, 
-			               const std::string& desc, 
-						   bool req,
-				           T value,
-				           Constraint<T>* constraint,
-						   bool ignoreable = false,
-				           Visitor* v = NULL ); 
-
-		
-		/**
-		 * UnlabeledValueArg constructor.
-		 * \param name - A one word name for the argument.  Note that this is used for
-		 * identification, not as a long flag.
-		 * \param desc - A description of what the argument is for or
-		 * does.
-		 * \param req - Whether the argument is required on the command
-		 * line.
-		 * \param value - The default value assigned to this argument if it
-		 * is not present 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 ignoreable - Allows you to specify that this argument can be
-		 * ignored if the '--' flag is set.  This defaults to false (cannot
-		 * be ignored) and should  generally stay that way unless you have 
-		 * some special need for certain arguments to be ignored.
-		 * \param v - Optional Vistor.  You should leave this blank unless
-		 * you have a very good reason.
-		 */
-		UnlabeledValueArg( const std::string& name, 
-			               const std::string& desc, 
-						   bool req,
-				           T value,
-				           Constraint<T>* constraint,
-						   CmdLineInterface& parser,
-						   bool ignoreable = false,
-				           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.  Handling specific to
-		 * unlabled arguments.
-		 * \param i - Pointer the the current argument in the list.
-		 * \param args - Mutable list of strings. 
-		 */
-		virtual bool processArg(int* i, std::vector<std::string>& args); 
-
-		/**
-		 * Overrides shortID for specific behavior.
-		 */
-		virtual std::string shortID(const std::string& val="val") const;
-
-		/**
-		 * Overrides longID for specific behavior.
-		 */
-		virtual std::string longID(const std::string& val="val") const;
-
-		/**
-		 * Overrides operator== for specific behavior.
-		 */
-		virtual bool operator==(const Arg& a ) const;
-
-		/**
-		 * Instead of pushing to the front of list, push to the back.
-		 * \param argList - The list to add this to.
-		 */
-		virtual void addToList( std::list<Arg*>& argList ) const;
-
-};
-
-/**
- * Constructor implemenation.
- */
-template<class T>
-UnlabeledValueArg<T>::UnlabeledValueArg(const std::string& name, 
-					                    const std::string& desc, 
-										bool req,
-					                    T val,
-					                    const std::string& typeDesc,
-					                    bool ignoreable,
-					                    Visitor* v)
-: ValueArg<T>("", name, desc, req, val, typeDesc, v)
-{ 
-	_ignoreable = ignoreable;
-
-	OptionalUnlabeledTracker::check(req, toString());
-
-}
-
-template<class T>
-UnlabeledValueArg<T>::UnlabeledValueArg(const std::string& name, 
-					                    const std::string& desc, 
-										bool req,
-					                    T val,
-					                    const std::string& typeDesc,
-					                    CmdLineInterface& parser,
-					                    bool ignoreable,
-					                    Visitor* v)
-: ValueArg<T>("", name, desc, req, val, typeDesc, v)
-{ 
-	_ignoreable = ignoreable;
-	OptionalUnlabeledTracker::check(req, toString());
-	parser.add( this );
-}
-
-/**
- * Constructor implemenation.
- */
-template<class T>
-UnlabeledValueArg<T>::UnlabeledValueArg(const std::string& name, 
-                                        const std::string& desc, 
-										bool req,
-                                        T val,
-                                        Constraint<T>* constraint,
-                                        bool ignoreable,
-                                        Visitor* v)
-: ValueArg<T>("", name, desc, req, val, constraint, v)
-{ 
-	_ignoreable = ignoreable;
-	OptionalUnlabeledTracker::check(req, toString());
-}
-
-template<class T>
-UnlabeledValueArg<T>::UnlabeledValueArg(const std::string& name, 
-					                    const std::string& desc, 
-										bool req,
-					                    T val,
-					                    Constraint<T>* constraint,
-					                    CmdLineInterface& parser,
-					                    bool ignoreable,
-					                    Visitor* v)
-: ValueArg<T>("", name, desc, req, val, constraint,  v)
-{ 
-	_ignoreable = ignoreable;
-	OptionalUnlabeledTracker::check(req, toString());
-	parser.add( this );
-}
-
-/**
- * Implementation of processArg().
- */
-template<class T>
-bool UnlabeledValueArg<T>::processArg(int *i, std::vector<std::string>& args) 
-{
-	
-	if ( _alreadySet )
-		return false;
-	
-	if ( _hasBlanks( args[*i] ) )
-		return false;
-
-	// never ignore an unlabeled arg
-	
-	_extractValue( args[*i] );
-	_alreadySet = true;
-	return true;
-}
-
-/**
- * Overriding shortID for specific output.
- */
-template<class T>
-std::string UnlabeledValueArg<T>::shortID(const std::string& val) const
-{
-	static_cast<void>(val); // Ignore input, don't warn
-	return std::string("<") + _typeDesc + ">";
-}
-
-/**
- * Overriding longID for specific output.
- */
-template<class T>
-std::string UnlabeledValueArg<T>::longID(const std::string& val) const
-{
-	static_cast<void>(val); // Ignore input, don't warn
-
-	// Ideally we would like to be able to use RTTI to return the name
-	// of the type required for this argument.  However, g++ at least, 
-	// doesn't appear to return terribly useful "names" of the types.  
-	return std::string("<") + _typeDesc + ">";
-}
-
-/**
- * Overriding operator== for specific behavior.
- */
-template<class T>
-bool UnlabeledValueArg<T>::operator==(const Arg& a ) const
-{
-	if ( _name == a.getName() || _description == a.getDescription() )
+	/**
+	 * The basic unlabeled argument that parses a value.
+	 * This is a template class, which means the type T defines the type
+	 * that a given object will attempt to parse when an UnlabeledValueArg
+	 * is reached in the list of args that the CmdLine iterates over.
+	 */
+	template<class T>
+	class UnlabeledValueArg : public ValueArg<T>
+	{
+		// If compiler has two stage name lookup (as gcc >= 3.4 does)
+		// this is requried to prevent undef. symbols
+		using ValueArg<T>::_ignoreable;
+		using ValueArg<T>::_hasBlanks;
+		using ValueArg<T>::_extractValue;
+		using ValueArg<T>::_typeDesc;
+		using ValueArg<T>::_name;
+		using ValueArg<T>::_description;
+		using ValueArg<T>::_alreadySet;
+		using ValueArg<T>::toString;
+
+		public:
+			/**
+			 * UnlabeledValueArg constructor.
+			 * \param name - A one word name for the argument.  Note that this is used for
+			 * identification, not as a long flag.
+			 * \param desc - A description of what the argument is for or
+			 * does.
+			 * \param req - Whether the argument is required on the command
+			 * line.
+			 * \param value - The default value assigned to this argument if it
+			 * is not present 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 ignoreable - Allows you to specify that this argument can be
+			 * ignored if the '--' flag is set.  This defaults to false (cannot
+			 * be ignored) and should  generally stay that way unless you have
+			 * some special need for certain arguments to be ignored.
+			 * \param v - Optional Vistor.  You should leave this blank unless
+			 * you have a very good reason.
+			 */
+			UnlabeledValueArg(const std::string &name, const std::string &desc, bool req, T value,
+			        const std::string &typeDesc, bool ignoreable = false, Visitor *v = NULL);
+
+			/**
+			 * UnlabeledValueArg constructor.
+			 * \param name - A one word name for the argument.  Note that this is used for
+			 * identification, not as a long flag.
+			 * \param desc - A description of what the argument is for or
+			 * does.
+			 * \param req - Whether the argument is required on the command
+			 * line.
+			 * \param value - The default value assigned to this argument if it
+			 * is not present 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 ignoreable - Allows you to specify that this argument can be
+			 * ignored if the '--' flag is set.  This defaults to false (cannot
+			 * be ignored) and should  generally stay that way unless you have
+			 * some special need for certain arguments to be ignored.
+			 * \param v - Optional Vistor.  You should leave this blank unless
+			 * you have a very good reason.
+			 */
+			UnlabeledValueArg(const std::string &name, const std::string &desc, bool req, T value,
+			        const std::string &typeDesc, CmdLineInterface &parser,
+			        bool ignoreable = false, Visitor *v = NULL);
+
+			/**
+			 * UnlabeledValueArg constructor.
+			 * \param name - A one word name for the argument.  Note that this is used for
+			 * identification, not as a long flag.
+			 * \param desc - A description of what the argument is for or
+			 * does.
+			 * \param req - Whether the argument is required on the command
+			 * line.
+			 * \param value - The default value assigned to this argument if it
+			 * is not present on the command line.
+			 * \param constraint - A pointer to a Constraint object used
+			 * to constrain this Arg.
+			 * \param ignoreable - Allows you to specify that this argument can be
+			 * ignored if the '--' flag is set.  This defaults to false (cannot
+			 * be ignored) and should  generally stay that way unless you have
+			 * some special need for certain arguments to be ignored.
+			 * \param v - Optional Vistor.  You should leave this blank unless
+			 * you have a very good reason.
+			 */
+			UnlabeledValueArg(const std::string &name, const std::string &desc, bool req, T value,
+			        Constraint<T> *constraint, bool ignoreable = false, Visitor *v = NULL);
+
+
+			/**
+			 * UnlabeledValueArg constructor.
+			 * \param name - A one word name for the argument.  Note that this is used for
+			 * identification, not as a long flag.
+			 * \param desc - A description of what the argument is for or
+			 * does.
+			 * \param req - Whether the argument is required on the command
+			 * line.
+			 * \param value - The default value assigned to this argument if it
+			 * is not present 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 ignoreable - Allows you to specify that this argument can be
+			 * ignored if the '--' flag is set.  This defaults to false (cannot
+			 * be ignored) and should  generally stay that way unless you have
+			 * some special need for certain arguments to be ignored.
+			 * \param v - Optional Vistor.  You should leave this blank unless
+			 * you have a very good reason.
+			 */
+			UnlabeledValueArg(const std::string &name, const std::string &desc, bool req, T value,
+			        Constraint<T> *constraint, CmdLineInterface &parser,
+			        bool ignoreable = false, 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.  Handling specific to
+			 * unlabled arguments.
+			 * \param i - Pointer the the current argument in the list.
+			 * \param args - Mutable list of strings.
+			 */
+			virtual bool processArg(int *i, std::vector<std::string> &args);
+
+			/**
+			 * Overrides shortID for specific behavior.
+			 */
+			virtual std::string shortID(const std::string &val = "val") const;
+
+			/**
+			 * Overrides longID for specific behavior.
+			 */
+			virtual std::string longID(const std::string &val = "val") const;
+
+			/**
+			 * Overrides operator== for specific behavior.
+			 */
+			virtual bool operator==(const Arg &a) const;
+
+			/**
+			 * Instead of pushing to the front of list, push to the back.
+			 * \param argList - The list to add this to.
+			 */
+			virtual void addToList(std::list<Arg*> &argList) const;
+	};
+
+	/**
+	 * Constructor implemenation.
+	 */
+	template<class T>
+	UnlabeledValueArg<T>::UnlabeledValueArg(const std::string &name, const std::string &desc,
+	        bool req, T val, const std::string &typeDesc,
+	        bool ignoreable, Visitor *v) :
+			ValueArg<T>("", name, desc, req, val, typeDesc, v)
+	{
+		_ignoreable = ignoreable;
+
+		OptionalUnlabeledTracker::check(req, toString());
+	}
+
+	template<class T>
+	UnlabeledValueArg<T>::UnlabeledValueArg(const std::string &name, const std::string &desc,
+	        bool req, T val, const std::string &typeDesc,
+	        CmdLineInterface &parser, bool ignoreable, Visitor *v) :
+			ValueArg<T>("", name, desc, req, val, typeDesc, v)
+	{
+		_ignoreable = ignoreable;
+		OptionalUnlabeledTracker::check(req, toString());
+		parser.add(this);
+	}
+
+	/**
+	 * Constructor implemenation.
+	 */
+	template<class T>
+	UnlabeledValueArg<T>::UnlabeledValueArg(const std::string &name, const std::string &desc,
+	        bool req, T val, Constraint<T> *constraint,
+	        bool ignoreable, Visitor *v) :
+			ValueArg<T>("", name, desc, req, val, constraint, v)
+	{
+		_ignoreable = ignoreable;
+		OptionalUnlabeledTracker::check(req, toString());
+	}
+
+	template<class T>
+	UnlabeledValueArg<T>::UnlabeledValueArg(const std::string &name, const std::string &desc,
+	        bool req, T val, Constraint<T> *constraint,
+	        CmdLineInterface &parser, bool ignoreable, Visitor *v) :
+			ValueArg<T>("", name, desc, req, val, constraint, v)
+	{
+		_ignoreable = ignoreable;
+		OptionalUnlabeledTracker::check(req, toString());
+		parser.add(this);
+	}
+
+	/**
+	 * Implementation of processArg().
+	 */
+	template<class T>
+	bool UnlabeledValueArg<T>::processArg(int *i, std::vector<std::string> &args)
+	{
+		if (_alreadySet)
+		{
+			return false;
+		}
+
+		if (_hasBlanks(args[*i]))
+		{
+			return false;
+		}
+
+		// never ignore an unlabeled arg
+
+		_extractValue(args[*i]);
+		_alreadySet = true;
 		return true;
-	else
-		return false;
+	}
+
+	/**
+	 * Overriding shortID for specific output.
+	 */
+	template<class T>
+	std::string UnlabeledValueArg<T>::shortID(const std::string &val) const
+	{
+		static_cast<void>(val); // Ignore input, don't warn
+		return std::string("<") + _typeDesc + ">";
+	}
+
+	/**
+	 * Overriding longID for specific output.
+	 */
+	template<class T>
+	std::string UnlabeledValueArg<T>::longID(const std::string &val) const
+	{
+		static_cast<void>(val); // Ignore input, don't warn
+
+		// Ideally we would like to be able to use RTTI to return the name
+		// of the type required for this argument.  However, g++ at least,
+		// doesn't appear to return terribly useful "names" of the types.
+		return std::string("<") + _typeDesc + ">";
+	}
+
+	/**
+	 * Overriding operator== for specific behavior.
+	 */
+	template<class T>
+	bool UnlabeledValueArg<T>::operator==(const Arg &a) const
+	{
+		if (_name == a.getName() || _description == a.getDescription())
+		{
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	template<class T>
+	void UnlabeledValueArg<T>::addToList(std::list<Arg*> &argList) const
+	{
+		argList.push_back(const_cast<Arg*>(static_cast<const Arg*const>(this)));
+	}
 }
 
-template<class T>
-void UnlabeledValueArg<T>::addToList( std::list<Arg*>& argList ) const
-{
-	argList.push_back( const_cast<Arg*>(static_cast<const Arg* const>(this)) );
-}
-
-}
 #endif
diff --git a/src/tclap/ValueArg.h b/src/tclap/ValueArg.h
index 28117f6..e80f649 100755..100644
--- a/src/tclap/ValueArg.h
+++ b/src/tclap/ValueArg.h
@@ -1,23 +1,23 @@
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  ValueArg.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_VALUE_ARGUMENT_H
@@ -29,383 +29,348 @@
 #include <tclap/Arg.h>
 #include <tclap/Constraint.h>
 
-namespace TCLAP {
-
-/**
- * The basic labeled argument that parses a value.
- * This is a template class, which means the type T defines the type
- * that a given object will attempt to parse when the flag/name is matched
- * on the command line.  While there is nothing stopping you from creating
- * an unflagged ValueArg, it is unwise and would cause significant problems.
- * Instead use an UnlabeledValueArg.
- */
-template<class T>
-class ValueArg : public Arg 
+namespace TCLAP
 {
-    protected:
-
-        /**
-         * The value parsed from the command line.
-         * Can be of any type, as long as the >> operator for the type
-         * is defined.
-         */
-        T _value;
-
-		/**
-		 * Used to support the reset() method so that ValueArg can be
-		 * reset to their constructed value.
-		 */
-        T _default;
-
-        /**
-         * A human readable description of the type to be parsed.
-         * This is a hack, plain and simple.  Ideally we would use RTTI to
-         * return the name of type T, but until there is some sort of
-         * consistent support for human readable names, we are left to our
-         * own devices.
-         */
-        std::string _typeDesc;
-
-        /**
-         * A Constraint this Arg must conform to. 
-         */
-        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 - value to be parsed. 
-         */
-        void _extractValue( const std::string& val );
-
-	public:
-
-        /**
-         * Labeled ValueArg constructor.
-         * You could conceivably call this constructor with a blank flag, 
-         * but that would make you a bad person.  It would also cause
-         * an exception to be thrown.   If you want an unlabeled argument, 
-         * use the other 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 value - The default value assigned to this argument if it
-         * is not present 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.
-         */
-        ValueArg( const std::string& flag, 
-                  const std::string& name, 
-                  const std::string& desc, 
-                  bool req, 
-                  T value,
-                  const std::string& typeDesc,
-                  Visitor* v = NULL);
-				 
-				 
-        /**
-         * Labeled ValueArg constructor.
-         * You could conceivably call this constructor with a blank flag, 
-         * but that would make you a bad person.  It would also cause
-         * an exception to be thrown.   If you want an unlabeled argument, 
-         * use the other 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 value - The default value assigned to this argument if it
-         * is not present 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.
-         */
-        ValueArg( const std::string& flag, 
-                  const std::string& name, 
-                  const std::string& desc, 
-                  bool req, 
-                  T value,
-                  const std::string& typeDesc,
-                  CmdLineInterface& parser,
-                  Visitor* v = NULL );
- 
-        /**
-         * Labeled ValueArg constructor.
-         * You could conceivably call this constructor with a blank flag, 
-         * but that would make you a bad person.  It would also cause
-         * an exception to be thrown.   If you want an unlabeled argument, 
-         * use the other 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 value - The default value assigned to this argument if it
-         * is not present 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.
-         */
-        ValueArg( const std::string& flag, 
-                  const std::string& name, 
-                  const std::string& desc, 
-                  bool req, 
-                  T value,
-                  Constraint<T>* constraint,
-                  CmdLineInterface& parser,
-                  Visitor* v = NULL );
-	  
-        /**
-         * Labeled ValueArg constructor.
-         * You could conceivably call this constructor with a blank flag, 
-         * but that would make you a bad person.  It would also cause
-         * an exception to be thrown.   If you want an unlabeled argument, 
-         * use the other 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 value - The default value assigned to this argument if it
-         * is not present 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.
-         */
-        ValueArg( const std::string& flag, 
-                  const std::string& name, 
-                  const std::string& desc, 
-                  bool req, 
-                  T value,
-                  Constraint<T>* constraint,
-                  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 
-         * in from main().
-         */
-        virtual bool processArg(int* i, std::vector<std::string>& args); 
-
-        /**
-         * Returns the value of the argument.
-         */
-        T& getValue() ;
-
-        /**
-         * Specialization of shortID.
-         * \param val - value to be used.
-         */
-        virtual std::string shortID(const std::string& val = "val") const;
-
-        /**
-         * Specialization of longID.
-         * \param val - value to be used.
-         */
-        virtual std::string longID(const std::string& val = "val") const;
-        
-        virtual void reset() ;
-
-};
-
-
-/**
- * Constructor implementation.
- */
-template<class T>
-ValueArg<T>::ValueArg(const std::string& flag, 
-                      const std::string& name, 
-                      const std::string& desc, 
-                      bool req, 
-                      T val,
-                      const std::string& typeDesc,
-                      Visitor* v)
-: Arg(flag, name, desc, req, true, v),
-  _value( val ),
-  _default( val ),
-  _typeDesc( typeDesc ),
-  _constraint( NULL )
-{ }
-
-template<class T>
-ValueArg<T>::ValueArg(const std::string& flag, 
-                      const std::string& name, 
-                      const std::string& desc, 
-                      bool req, 
-                      T val,
-                      const std::string& typeDesc,
-                      CmdLineInterface& parser,
-                      Visitor* v)
-: Arg(flag, name, desc, req, true, v),
-  _value( val ),
-  _default( val ),
-  _typeDesc( typeDesc ),
-  _constraint( NULL )
-{ 
-    parser.add( this );
-}
-
-template<class T>
-ValueArg<T>::ValueArg(const std::string& flag, 
-                      const std::string& name, 
-                      const std::string& desc, 
-                      bool req, 
-                      T val,
-                      Constraint<T>* constraint,
-                      Visitor* v)
-: Arg(flag, name, desc, req, true, v),
-  _value( val ),
-  _default( val ),
-  _typeDesc( constraint->shortID() ),
-  _constraint( constraint )
-{ }
-
-template<class T>
-ValueArg<T>::ValueArg(const std::string& flag, 
-                      const std::string& name, 
-                      const std::string& desc, 
-                      bool req, 
-                      T val,
-                      Constraint<T>* constraint,
-                      CmdLineInterface& parser,
-                      Visitor* v)
-: Arg(flag, name, desc, req, true, v),
-  _value( val ),
-  _default( val ),
-  _typeDesc( constraint->shortID() ),
-  _constraint( constraint )
-{ 
-    parser.add( this );
-}
-
-
-/**
- * Implementation of getValue().
- */
-template<class T>
-T& ValueArg<T>::getValue() { return _value; }
-
-/**
- * Implementation of processArg().
- */
-template<class T>
-bool ValueArg<T>::processArg(int *i, std::vector<std::string>& args)
-{
-    if ( _ignoreable && Arg::ignoreRest() )
-		return false;
-
-    if ( _hasBlanks( args[*i] ) )
-		return false;
-
-    std::string flag = args[*i];
-
-    std::string value = "";
-    trimFlag( flag, value );
-
-    if ( argMatches( flag ) )
-    {
-        if ( _alreadySet )
-			throw( CmdLineParseException("Argument already set!", toString()) );
-
-        if ( Arg::delimiter() != ' ' && value == "" )
-			throw( ArgParseException( 
-							"Couldn't find delimiter for this argument!",
-                             toString() ) );
-
-        if ( value == "" )
-        {
-            (*i)++;
-            if ( static_cast<unsigned int>(*i) < args.size() ) 
-				_extractValue( args[*i] );
-            else
-				throw( ArgParseException("Missing a value for this argument!",
-                                                    toString() ) );
-        }
-        else
-			_extractValue( value );
-				
-        _alreadySet = true;
-        _checkWithVisitor();
-        return true;
-    }	
-    else
-		return false;
-}
-
-/**
- * Implementation of shortID.
- */
-template<class T>
-std::string ValueArg<T>::shortID(const std::string& val) const
-{
-	static_cast<void>(val); // Ignore input, don't warn
-	return Arg::shortID( _typeDesc ); 
-}
-
-/**
- * Implementation of longID.
- */
-template<class T>
-std::string ValueArg<T>::longID(const std::string& val) const
-{
-	static_cast<void>(val); // Ignore input, don't warn
-	return Arg::longID( _typeDesc ); 
-}
-
-template<class T>
-void ValueArg<T>::_extractValue( const std::string& val ) 
-{
-    try {
-	ExtractValue(_value, val, typename ArgTraits<T>::ValueCategory());
-    } catch( ArgParseException &e) {
-	throw ArgParseException(e.error(), toString());
-    }
-    
-    if ( _constraint != NULL )
-	if ( ! _constraint->check( _value ) )
-	    throw( CmdLineParseException( "Value '" + val + 
-					  + "' does not meet constraint: " 
-					  + _constraint->description(),
-					  toString() ) );
-}
-
-template<class T>
-void ValueArg<T>::reset()
-{
-	Arg::reset();
-	_value = _default;
-}
-
+	/**
+	 * The basic labeled argument that parses a value.
+	 * This is a template class, which means the type T defines the type
+	 * that a given object will attempt to parse when the flag/name is matched
+	 * on the command line.  While there is nothing stopping you from creating
+	 * an unflagged ValueArg, it is unwise and would cause significant problems.
+	 * Instead use an UnlabeledValueArg.
+	 */
+	template<class T>
+	class ValueArg : public Arg
+	{
+		protected:
+			/**
+			   * The value parsed from the command line.
+			   * Can be of any type, as long as the >> operator for the type
+			   * is defined.
+			   */
+			T _value;
+
+			/**
+			 * Used to support the reset() method so that ValueArg can be
+			 * reset to their constructed value.
+			 */
+			T _default;
+
+			/**
+			   * A human readable description of the type to be parsed.
+			   * This is a hack, plain and simple.  Ideally we would use RTTI to
+			   * return the name of type T, but until there is some sort of
+			   * consistent support for human readable names, we are left to our
+			   * own devices.
+			   */
+			std::string _typeDesc;
+
+			/**
+			   * A Constraint this Arg must conform to.
+			   */
+			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 - value to be parsed.
+			   */
+			void _extractValue(const std::string &val);
+
+		public:
+			/**
+			   * Labeled ValueArg constructor.
+			   * You could conceivably call this constructor with a blank flag,
+			   * but that would make you a bad person.  It would also cause
+			   * an exception to be thrown.   If you want an unlabeled argument,
+			   * use the other 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 value - The default value assigned to this argument if it
+			   * is not present 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.
+			   */
+			ValueArg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
+			        T value, const std::string &typeDesc, Visitor *v = NULL);
+
+
+			/**
+			   * Labeled ValueArg constructor.
+			   * You could conceivably call this constructor with a blank flag,
+			   * but that would make you a bad person.  It would also cause
+			   * an exception to be thrown.   If you want an unlabeled argument,
+			   * use the other 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 value - The default value assigned to this argument if it
+			   * is not present 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.
+			   */
+			ValueArg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
+			        T value, const std::string &typeDesc, CmdLineInterface &parser, Visitor *v = NULL);
+
+			/**
+			   * Labeled ValueArg constructor.
+			   * You could conceivably call this constructor with a blank flag,
+			   * but that would make you a bad person.  It would also cause
+			   * an exception to be thrown.   If you want an unlabeled argument,
+			   * use the other 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 value - The default value assigned to this argument if it
+			   * is not present 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.
+			   */
+			ValueArg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
+			        T value, Constraint<T> *constraint, CmdLineInterface &parser, Visitor *v = NULL);
+
+			/**
+			   * Labeled ValueArg constructor.
+			   * You could conceivably call this constructor with a blank flag,
+			   * but that would make you a bad person.  It would also cause
+			   * an exception to be thrown.   If you want an unlabeled argument,
+			   * use the other 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 value - The default value assigned to this argument if it
+			   * is not present 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.
+			   */
+			ValueArg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
+			        T value, Constraint<T> *constraint, 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
+			   * in from main().
+			   */
+			virtual bool processArg(int *i, std::vector<std::string> &args);
+
+			/**
+			   * Returns the value of the argument.
+			   */
+			T& getValue();
+
+			/**
+			   * Specialization of shortID.
+			   * \param val - value to be used.
+			   */
+			virtual std::string shortID(const std::string &val = "val") const;
+
+			/**
+			   * Specialization of longID.
+			   * \param val - value to be used.
+			   */
+			virtual std::string longID(const std::string &val = "val") const;
+
+			virtual void reset();
+	};
+
+
+	/**
+	 * Constructor implementation.
+	 */
+	template<class T>
+	ValueArg<T>::ValueArg(const std::string &flag, const std::string &name, const std::string &desc,
+	        bool req, T val, const std::string &typeDesc, Visitor *v) :
+			Arg(flag, name, desc, req, true, v), _value(val), _default(val), _typeDesc(typeDesc),
+			_constraint(NULL)
+	{
+	}
+
+	template<class T>
+	ValueArg<T>::ValueArg(const std::string &flag, const std::string &name, const std::string &desc,
+	        bool req, T val, const std::string &typeDesc, CmdLineInterface &parser,
+	        Visitor *v) :
+			Arg(flag, name, desc, req, true, v), _value(val), _default(val), _typeDesc(typeDesc),
+			_constraint(NULL)
+	{
+		parser.add(this);
+	}
+
+	template<class T>
+	ValueArg<T>::ValueArg(const std::string &flag, const std::string &name, const std::string &desc,
+	        bool req, T val, Constraint<T> *constraint, Visitor *v) :
+			Arg(flag, name, desc, req, true, v), _value(val), _default(val), _typeDesc(
+				constraint->shortID()), _constraint(constraint)
+	{
+	}
+
+	template<class T>
+	ValueArg<T>::ValueArg(const std::string &flag, const std::string &name, const std::string &desc,
+	        bool req, T val, Constraint<T> *constraint, CmdLineInterface &parser,
+	        Visitor *v) :
+			Arg(flag, name, desc, req, true, v), _value(val), _default(val), _typeDesc(
+				constraint->shortID()), _constraint(constraint)
+	{
+		parser.add(this);
+	}
+
+	/**
+	 * Implementation of getValue().
+	 */
+	template<class T>
+	T& ValueArg<T>::getValue()
+	{
+		return _value;
+	}
+
+	/**
+	 * Implementation of processArg().
+	 */
+	template<class T>
+	bool ValueArg<T>::processArg(int *i, std::vector<std::string> &args)
+	{
+		if (_ignoreable && Arg::ignoreRest())
+		{
+			return false;
+		}
+
+		if (_hasBlanks(args[*i]))
+		{
+			return false;
+		}
+
+		std::string flag = args[*i];
+
+		std::string value = "";
+		trimFlag(flag, value);
+
+		if (argMatches(flag))
+		{
+			if (_alreadySet)
+			{
+				throw (CmdLineParseException("Argument already set!", toString()));
+			}
+
+			if (Arg::delimiter() != ' ' && value == "")
+			{
+				throw (ArgParseException(
+								"Couldn't find delimiter for this argument!", toString()));
+			}
+
+			if (value == "")
+			{
+				(*i)++;
+				if (static_cast<unsigned int>(*i) < args.size())
+				{
+					_extractValue(args[*i]);
+				}
+				else
+				{
+					throw (ArgParseException("Missing a value for this argument!", toString()));
+				}
+			}
+			else
+			{
+				_extractValue(value);
+			}
+
+			_alreadySet = true;
+			_checkWithVisitor();
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	/**
+	 * Implementation of shortID.
+	 */
+	template<class T>
+	std::string ValueArg<T>::shortID(const std::string &val) const
+	{
+		static_cast<void>(val); // Ignore input, don't warn
+		return Arg::shortID(_typeDesc);
+	}
+
+	/**
+	 * Implementation of longID.
+	 */
+	template<class T>
+	std::string ValueArg<T>::longID(const std::string &val) const
+	{
+		static_cast<void>(val); // Ignore input, don't warn
+		return Arg::longID(_typeDesc);
+	}
+
+	template<class T>
+	void ValueArg<T>::_extractValue(const std::string &val)
+	{
+		try
+		{
+			ExtractValue(_value, val, typename ArgTraits<T>::ValueCategory());
+		}
+		catch (ArgParseException &e)
+		{
+			throw ArgParseException(e.error(), toString());
+		}
+
+		if (_constraint != NULL)
+		{
+			if (!_constraint->check(_value))
+			{
+				throw (CmdLineParseException("Value '" + val + +"' does not meet constraint: " +
+				      _constraint->description(), toString()));
+			}
+		}
+	}
+
+	template<class T>
+	void ValueArg<T>::reset()
+	{
+		Arg::reset();
+		_value = _default;
+	}
 } // namespace TCLAP
 
 #endif
diff --git a/src/tclap/ValuesConstraint.h b/src/tclap/ValuesConstraint.h
index 235939c..882f762 100755..100644
--- a/src/tclap/ValuesConstraint.h
+++ b/src/tclap/ValuesConstraint.h
@@ -1,24 +1,22 @@
-
-
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  ValuesConstraint.h
- * 
+ *
  *  Copyright (c) 2005, Michael E. Smoot
  *  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_VALUESCONSTRAINT_H
 #define TCLAP_VALUESCONSTRAINT_H
@@ -28,120 +26,122 @@
 #include <tclap/Constraint.h>
 
 #ifdef HAVE_CONFIG_H
-#include <config.h>
+ #include <config.h>
 #else
-#define HAVE_SSTREAM
+ #define HAVE_SSTREAM
 #endif
 
-#if defined(HAVE_SSTREAM)
-#include <sstream>
-#elif defined(HAVE_STRSTREAM)
-#include <strstream>
+#if defined (HAVE_SSTREAM)
+ #include <sstream>
+#elif defined (HAVE_STRSTREAM)
+ #include <strstream>
 #else
-#error "Need a stringstream (sstream or strstream) to compile!"
+ #error "Need a stringstream (sstream or strstream) to compile!"
 #endif
 
-namespace TCLAP {
-
-/**
- * A Constraint that constrains the Arg to only those values specified
- * in the constraint.
- */
-template<class T>
-class ValuesConstraint : public Constraint<T>
+namespace TCLAP
 {
 
-	public:
-
-		/**
-		 * Constructor. 
-		 * \param allowed - vector of allowed values. 
-		 */
-		ValuesConstraint(std::vector<T>& allowed);	
-
-		/**
-		 * Virtual destructor.
-		 */
-		virtual ~ValuesConstraint() {}
-
-		/**
-		 * Returns a description of the Constraint. 
-		 */
-		virtual std::string description() const;
-
-		/**
-		 * Returns the short ID for the Constraint.
-		 */
-		virtual std::string shortID() const;
-
-		/**
-		 * The method used to verify that the value parsed from the command
-		 * line meets the constraint.
-		 * \param value - The value that will be checked. 
-		 */
-		virtual bool check(const T& value) const;
-	
-	protected:
-
-		/**
-		 * The list of valid values. 
-		 */
-		std::vector<T> _allowed;
-
-		/**
-		 * The string used to describe the allowed values of this constraint.
-		 */
-		std::string _typeDesc;
-
-};
-
-template<class T>
-ValuesConstraint<T>::ValuesConstraint(std::vector<T>& allowed)
-: _allowed(allowed)
-{ 
-    for ( unsigned int i = 0; i < _allowed.size(); i++ )
-    {
-
-#if defined(HAVE_SSTREAM)
-        std::ostringstream os;
-#elif defined(HAVE_STRSTREAM)
-        std::ostrstream os;
+	/**
+	 * A Constraint that constrains the Arg to only those values specified
+	 * in the constraint.
+	 */
+	template<class T>
+	class ValuesConstraint : public Constraint<T>
+	{
+		public:
+			/**
+			 * Constructor.
+			 * \param allowed - vector of allowed values.
+			 */
+			ValuesConstraint(std::vector<T> &allowed);
+
+			/**
+			 * Virtual destructor.
+			 */
+			virtual ~ValuesConstraint()
+			{
+			}
+
+			/**
+			 * Returns a description of the Constraint.
+			 */
+			virtual std::string description() const;
+
+			/**
+			 * Returns the short ID for the Constraint.
+			 */
+			virtual std::string shortID() const;
+
+			/**
+			 * The method used to verify that the value parsed from the command
+			 * line meets the constraint.
+			 * \param value - The value that will be checked.
+			 */
+			virtual bool check(const T &value) const;
+
+		protected:
+			/**
+			 * The list of valid values.
+			 */
+			std::vector<T> _allowed;
+
+			/**
+			 * The string used to describe the allowed values of this constraint.
+			 */
+			std::string _typeDesc;
+	};
+
+	template<class T>
+	ValuesConstraint<T>::ValuesConstraint(std::vector<T> &allowed) :
+			_allowed(allowed)
+	{
+		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!"
+ #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>
-bool ValuesConstraint<T>::check( const T& val ) const
-{
-	if ( std::find(_allowed.begin(),_allowed.end(),val) == _allowed.end() )
-		return false;
-	else 
-		return true;
-}
-
-template<class T>
-std::string ValuesConstraint<T>::shortID() const
-{
-    return _typeDesc;	
-}
-
-template<class T>
-std::string ValuesConstraint<T>::description() const
-{
-    return _typeDesc;	
-}
-
-
+			os << _allowed[i];
+
+			std::string temp(os.str());
+
+			if (i > 0)
+			{
+				_typeDesc += "|";
+			}
+			_typeDesc += temp;
+		}
+	}
+
+	template<class T>
+	bool ValuesConstraint<T>::check(const T &val) const
+	{
+		if (std::find(_allowed.begin(), _allowed.end(), val) == _allowed.end())
+		{
+			return false;
+		}
+		else
+		{
+			return true;
+		}
+	}
+
+	template<class T>
+	std::string ValuesConstraint<T>::shortID() const
+	{
+		return _typeDesc;
+	}
+
+	template<class T>
+	std::string ValuesConstraint<T>::description() const
+	{
+		return _typeDesc;
+	}
 } //namespace TCLAP
-#endif 
 
+#endif
diff --git a/src/tclap/VersionVisitor.h b/src/tclap/VersionVisitor.h
index 3e55921..d6c02bc 100755..100644
--- a/src/tclap/VersionVisitor.h
+++ b/src/tclap/VersionVisitor.h
@@ -1,24 +1,24 @@
 // -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
 
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  VersionVisitor.h
- * 
+ *
  *  Copyright (c) 2003, Michael E. Smoot .
  *  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_VERSION_VISITOR_H
@@ -28,47 +28,46 @@
 #include <tclap/CmdLineOutput.h>
 #include <tclap/Visitor.h>
 
-namespace TCLAP {
-
-/**
- * A Vistor that will call the version method of the given CmdLineOutput
- * for the specified CmdLine object and then exit.
- */
-class VersionVisitor: public Visitor
+namespace TCLAP
 {
-	protected:
-
-		/**
-		 * The CmdLine of interest.
-		 */
-		CmdLineInterface* _cmd;
-
-		/**
-		 * The output object. 
-		 */
-		CmdLineOutput** _out;
-
-	public:
-
-		/**
-		 * Constructor.
-		 * \param cmd - The CmdLine the output is generated for. 
-		 * \param out - The type of output. 
-		 */
-		VersionVisitor( CmdLineInterface* cmd, CmdLineOutput** out ) 
-				: Visitor(), _cmd( cmd ), _out( out ) { }
+	/**
+	 * A Vistor that will call the version method of the given CmdLineOutput
+	 * for the specified CmdLine object and then exit.
+	 */
+	class VersionVisitor : public Visitor
+	{
+		protected:
+			/**
+			 * The CmdLine of interest.
+			 */
+			CmdLineInterface *_cmd;
 
-		/**
-		 * Calls the version method of the output object using the
-		 * specified CmdLine.
-		 */
-		void visit() { 
-		    (*_out)->version(*_cmd); 
-		    throw ExitException(0); 
-		}
+			/**
+			 * The output object.
+			 */
+			CmdLineOutput **_out;
 
-};
+		public:
+			/**
+			 * Constructor.
+			 * \param cmd - The CmdLine the output is generated for.
+			 * \param out - The type of output.
+			 */
+			VersionVisitor(CmdLineInterface *cmd, CmdLineOutput **out) :
+					Visitor(), _cmd(cmd), _out(out)
+			{
+			}
 
+			/**
+			 * Calls the version method of the output object using the
+			 * specified CmdLine.
+			 */
+			void visit()
+			{
+				(*_out)->version(*_cmd);
+				throw ExitException(0);
+			}
+	};
 }
 
 #endif
diff --git a/src/tclap/Visitor.h b/src/tclap/Visitor.h
index 38ddcbd..1d2fe1e 100755..100644
--- a/src/tclap/Visitor.h
+++ b/src/tclap/Visitor.h
@@ -1,53 +1,56 @@
-
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  Visitor.h
- * 
+ *
  *  Copyright (c) 2003, Michael E. Smoot .
  *  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_VISITOR_H
 #define TCLAP_VISITOR_H
 
-namespace TCLAP {
-
-/**
- * A base class that defines the interface for visitors.
- */
-class Visitor
+namespace TCLAP
 {
-	public:
-
-		/**
-		 * Constructor. Does nothing.
-		 */
-		Visitor() { }
-
-		/**
-		 * Destructor. Does nothing.
-		 */
-		virtual ~Visitor() { }
-
-		/**
-		 * Does nothing. Should be overridden by child.
-		 */
-		virtual void visit() { }
-};
-
+	/**
+	 * A base class that defines the interface for visitors.
+	 */
+	class Visitor
+	{
+		public:
+			/**
+			 * Constructor. Does nothing.
+			 */
+			Visitor()
+			{
+			}
+
+			/**
+			 * Destructor. Does nothing.
+			 */
+			virtual ~Visitor()
+			{
+			}
+
+			/**
+			 * Does nothing. Should be overridden by child.
+			 */
+			virtual void visit()
+			{
+			}
+	};
 }
 
 #endif
diff --git a/src/tclap/XorHandler.h b/src/tclap/XorHandler.h
index af68943..ae3cd5c 100755..100644
--- a/src/tclap/XorHandler.h
+++ b/src/tclap/XorHandler.h
@@ -1,24 +1,23 @@
-
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  XorHandler.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_XORHANDLER_H
 #define TCLAP_XORHANDLER_H
@@ -29,128 +28,141 @@
 #include <algorithm>
 #include <iostream>
 
-namespace TCLAP {
-
-/**
- * This class handles lists of Arg's that are to be XOR'd on the command
- * line.  This is used by CmdLine and you shouldn't ever use it.
- */
-class XorHandler
+namespace TCLAP
 {
-	protected:
-
-		/**
-		 * The list of of lists of Arg's to be or'd together.
-		 */
-		std::vector< std::vector<Arg*> > _orList;
-
-	public:
-
-		/**
-		 * Constructor.  Does nothing.
-		 */
-		XorHandler( ) {}
-
-		/**
-		 * Add a list of Arg*'s that will be orred together.
-		 * \param ors - list of Arg* that will be xor'd.
-		 */
-		void add( std::vector<Arg*>& ors );
-			
-		/**
-		 * Checks whether the specified Arg is in one of the xor lists and
-		 * if it does match one, returns the size of the xor list that the
-		 * Arg matched.  If the Arg matches, then it also sets the rest of
-		 * the Arg's in the list. You shouldn't use this.  
-		 * \param a - The Arg to be checked.
-		 */
-		int check( const Arg* a );
-
-		/**
-		 * Returns the XOR specific short usage.
-		 */
-		std::string shortUsage();
-
-		/**
-		 * Prints the XOR specific long usage.
-		 * \param os - Stream to print to.
-		 */
-		void printLongUsage(std::ostream& os);
-
-		/**
-		 * Simply checks whether the Arg is contained in one of the arg
-		 * lists.
-		 * \param a - The Arg to be checked.
-		 */
-		bool contains( const Arg* a );
-
-		std::vector< std::vector<Arg*> >& getXorList(); 
-
-};
-
-
-//////////////////////////////////////////////////////////////////////
-//BEGIN XOR.cpp
-//////////////////////////////////////////////////////////////////////
-inline void XorHandler::add( std::vector<Arg*>& ors )
-{ 
-	_orList.push_back( ors );
-}
-
-inline int XorHandler::check( const Arg* a ) 
-{
-	// iterate over each XOR list
-	for ( int i = 0; static_cast<unsigned int>(i) < _orList.size(); i++ )
+
+	/**
+	 * This class handles lists of Arg's that are to be XOR'd on the command
+	 * line.  This is used by CmdLine and you shouldn't ever use it.
+	 */
+	class XorHandler
 	{
-		// if the XOR list contains the arg..
-		ArgVectorIterator ait = std::find( _orList[i].begin(), 
-		                                   _orList[i].end(), a );
-		if ( ait != _orList[i].end() )
-		{
-			// go through and set each arg that is not a
-			for ( ArgVectorIterator it = _orList[i].begin(); 
-				  it != _orList[i].end(); 
-				  it++ )	
-				if ( a != (*it) )
-					(*it)->xorSet();
-
-			// return the number of required args that have now been set
-			if ( (*ait)->allowMore() )
-				return 0;
-			else
-				return static_cast<int>(_orList[i].size());
-		}
+		protected:
+			/**
+			 * The list of of lists of Arg's to be or'd together.
+			 */
+			std::vector<std::vector<Arg*>> _orList;
+
+		public:
+			/**
+			 * Constructor.  Does nothing.
+			 */
+			XorHandler()
+			{
+			}
+
+			/**
+			 * Add a list of Arg*'s that will be orred together.
+			 * \param ors - list of Arg* that will be xor'd.
+			 */
+			void add(std::vector<Arg*> &ors);
+
+			/**
+			 * Checks whether the specified Arg is in one of the xor lists and
+			 * if it does match one, returns the size of the xor list that the
+			 * Arg matched.  If the Arg matches, then it also sets the rest of
+			 * the Arg's in the list. You shouldn't use this.
+			 * \param a - The Arg to be checked.
+			 */
+			int check(const Arg *a);
+
+			/**
+			 * Returns the XOR specific short usage.
+			 */
+			std::string shortUsage();
+
+			/**
+			 * Prints the XOR specific long usage.
+			 * \param os - Stream to print to.
+			 */
+			void printLongUsage(std::ostream &os);
+
+			/**
+			 * Simply checks whether the Arg is contained in one of the arg
+			 * lists.
+			 * \param a - The Arg to be checked.
+			 */
+			bool contains(const Arg *a);
+
+			std::vector<std::vector<Arg*>>& getXorList();
+	};
+
+	//////////////////////////////////////////////////////////////////////
+	//BEGIN XOR.cpp
+	//////////////////////////////////////////////////////////////////////
+	inline void XorHandler::add(std::vector<Arg*> &ors)
+	{
+		_orList.push_back(ors);
 	}
 
-	if ( a->isRequired() )
-		return 1;
-	else
-		return 0;
-}
-
-inline bool XorHandler::contains( const Arg* a )
-{
-	for ( int i = 0; static_cast<unsigned int>(i) < _orList.size(); i++ )
-		for ( ArgVectorIterator it = _orList[i].begin(); 
-			  it != _orList[i].end(); 
-			  it++ )	
-			if ( a == (*it) )
-				return true;
-
-	return false;
-}
+	inline int XorHandler::check(const Arg *a)
+	{
+		// iterate over each XOR list
+		for (int i = 0; static_cast<unsigned int>(i) < _orList.size(); i++)
+		{
+			// if the XOR list contains the arg..
+			ArgVectorIterator ait = std::find(_orList[i].begin(), _orList[i].end(), a);
+			if (ait != _orList[i].end())
+			{
+				// go through and set each arg that is not a
+				for (ArgVectorIterator it = _orList[i].begin();
+				        it != _orList[i].end();
+				        it++)
+				{
+					if (a != (*it))
+					{
+						(*it)->xorSet();
+					}
+				}
+
+				// return the number of required args that have now been set
+				if ((*ait)->allowMore())
+				{
+					return 0;
+				}
+				else
+				{
+					return static_cast<int>(_orList[i].size());
+				}
+			}
+		}
 
-inline std::vector< std::vector<Arg*> >& XorHandler::getXorList() 
-{
-	return _orList;
-}
+		if (a->isRequired())
+		{
+			return 1;
+		}
+		else
+		{
+			return 0;
+		}
+	}
 
+	inline bool XorHandler::contains(const Arg *a)
+	{
+		for (int i = 0; static_cast<unsigned int>(i) < _orList.size(); i++)
+		{
+			for (ArgVectorIterator it = _orList[i].begin();
+			        it != _orList[i].end();
+			        it++)
+			{
+				if (a == (*it))
+				{
+					return true;
+				}
+			}
+		}
 
+		return false;
+	}
 
-//////////////////////////////////////////////////////////////////////
-//END XOR.cpp
-//////////////////////////////////////////////////////////////////////
+	inline std::vector<std::vector<Arg*>>& XorHandler::getXorList()
+	{
+		return _orList;
+	}
 
+	//////////////////////////////////////////////////////////////////////
+	//END XOR.cpp
+	//////////////////////////////////////////////////////////////////////
 } //namespace TCLAP
 
-#endif 
+#endif
diff --git a/src/tclap/ZshCompletionOutput.h b/src/tclap/ZshCompletionOutput.h
index 1ed4381..ba28306 100755..100644
--- a/src/tclap/ZshCompletionOutput.h
+++ b/src/tclap/ZshCompletionOutput.h
@@ -1,24 +1,24 @@
 // -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
 
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  file:  ZshCompletionOutput.h
- * 
+ *
  *  Copyright (c) 2006, Oliver Kiddle
  *  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 
+ *
+ *  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_ZSHCOMPLETIONOUTPUT_H
 #define TCLAP_ZSHCOMPLETIONOUTPUT_H
@@ -34,288 +34,309 @@
 #include <tclap/XorHandler.h>
 #include <tclap/Arg.h>
 
-namespace TCLAP {
-
-/**
- * A class that generates a Zsh completion function as output from the usage()
- * method for the given CmdLine and its Args.
- */
-class ZshCompletionOutput : public CmdLineOutput
-{
-
-	public:
-
-		ZshCompletionOutput();
-
-		/**
-		 * Prints the usage to stdout.  Can be overridden to 
-		 * produce alternative behavior.
-		 * \param c - The CmdLine object the output is generated for. 
-		 */
-		virtual void usage(CmdLineInterface& c);
-
-		/**
-		 * Prints the version to stdout. Can be overridden 
-		 * to produce alternative behavior.
-		 * \param c - The CmdLine object the output is generated for. 
-		 */
-		virtual void version(CmdLineInterface& c);
-
-		/**
-		 * Prints (to stderr) an error message, short usage 
-		 * Can be overridden to produce alternative behavior.
-		 * \param c - The CmdLine object the output is generated for. 
-		 * \param e - The ArgException that caused the failure. 
-		 */
-		virtual void failure(CmdLineInterface& c,
-						     ArgException& e );
-
-	protected:
-
-		void basename( std::string& s );
-		void quoteSpecialChars( std::string& s );
-
-		std::string getMutexList( CmdLineInterface& _cmd, Arg* a );
-		void printOption( Arg* it, std::string mutex );
-		void printArg( Arg* it );
-
-		std::map<std::string, std::string> common;
-		char theDelimiter;
-};
-
-ZshCompletionOutput::ZshCompletionOutput()
-{
-	common["host"] = "_hosts";
-	common["hostname"] = "_hosts";
-	common["file"] = "_files";
-	common["filename"] = "_files";
-	common["user"] = "_users";
-	common["username"] = "_users";
-	common["directory"] = "_directories";
-	common["path"] = "_directories";
-	common["url"] = "_urls";
-}
-
-inline void ZshCompletionOutput::version(CmdLineInterface& _cmd)
-{
-	std::cout << _cmd.getVersion() << std::endl;
-}
-
-inline void ZshCompletionOutput::usage(CmdLineInterface& _cmd )
+namespace TCLAP
 {
-	std::list<Arg*> argList = _cmd.getArgList();
-	std::string progName = _cmd.getProgramName();
-	std::string version = _cmd.getVersion();
-	theDelimiter = _cmd.getDelimiter();
-	basename(progName);
-
-	std::cout << "#compdef " << progName << std::endl << std::endl <<
-		"# " << progName << " version " << _cmd.getVersion() << std::endl << std::endl <<
-		"_arguments -s -S";
-
-	for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
+	/**
+	 * A class that generates a Zsh completion function as output from the usage()
+	 * method for the given CmdLine and its Args.
+	 */
+	class ZshCompletionOutput : public CmdLineOutput
 	{
-		if ( (*it)->shortID().at(0) == '<' )
-			printArg((*it));
-		else if ( (*it)->getFlag() != "-" )
-			printOption((*it), getMutexList(_cmd, *it));
-	}
-
-	std::cout << std::endl;
-}
-
-inline void ZshCompletionOutput::failure( CmdLineInterface& _cmd,
-				                ArgException& e )
-{
-	static_cast<void>(_cmd); // unused
-	std::cout << e.what() << std::endl;
-}
-
-inline void ZshCompletionOutput::quoteSpecialChars( std::string& s )
-{
-	size_t idx = s.find_last_of(':');
-	while ( idx != std::string::npos )
+		public:
+			ZshCompletionOutput();
+
+			/**
+			 * Prints the usage to stdout.  Can be overridden to
+			 * produce alternative behavior.
+			 * \param c - The CmdLine object the output is generated for.
+			 */
+			virtual void usage(CmdLineInterface &c);
+
+			/**
+			 * Prints the version to stdout. Can be overridden
+			 * to produce alternative behavior.
+			 * \param c - The CmdLine object the output is generated for.
+			 */
+			virtual void version(CmdLineInterface &c);
+
+			/**
+			 * Prints (to stderr) an error message, short usage
+			 * Can be overridden to produce alternative behavior.
+			 * \param c - The CmdLine object the output is generated for.
+			 * \param e - The ArgException that caused the failure.
+			 */
+			virtual void failure(CmdLineInterface &c, ArgException &e);
+
+		protected:
+			void basename(std::string &s);
+			void quoteSpecialChars(std::string &s);
+
+			std::string getMutexList(CmdLineInterface &_cmd, Arg *a);
+			void        printOption(Arg *it, std::string mutex);
+			void        printArg(Arg *it);
+
+			std::map<std::string, std::string> common;
+			char theDelimiter;
+	};
+
+	ZshCompletionOutput::ZshCompletionOutput()
 	{
-		s.insert(idx, 1, '\\');
-		idx = s.find_last_of(':', idx);
+		common["host"]      = "_hosts";
+		common["hostname"]  = "_hosts";
+		common["file"]      = "_files";
+		common["filename"]  = "_files";
+		common["user"]      = "_users";
+		common["username"]  = "_users";
+		common["directory"] = "_directories";
+		common["path"]      = "_directories";
+		common["url"]       = "_urls";
 	}
-	idx = s.find_last_of('\'');
-	while ( idx != std::string::npos )
+
+	inline void ZshCompletionOutput::version(CmdLineInterface &_cmd)
 	{
-		s.insert(idx, "'\\'");
-		if (idx == 0)
-			idx = std::string::npos;
-		else
-			idx = s.find_last_of('\'', --idx);
+		std::cout << _cmd.getVersion() << std::endl;
 	}
-}
 
-inline void ZshCompletionOutput::basename( std::string& s )
-{
-	size_t p = s.find_last_of('/');
-	if ( p != std::string::npos )
+	inline void ZshCompletionOutput::usage(CmdLineInterface &_cmd)
 	{
-		s.erase(0, p + 1);
-	}
-}
+		std::list<Arg*> argList  = _cmd.getArgList();
+		std::string     progName = _cmd.getProgramName();
+		std::string     version  = _cmd.getVersion();
+		theDelimiter = _cmd.getDelimiter();
+		basename(progName);
 
-inline void ZshCompletionOutput::printArg(Arg* a)
-{
-	static int count = 1;
-
-	std::cout << " \\" << std::endl << "  '";
-	if ( a->acceptsMultipleValues() )
-		std::cout << '*';
-	else
-		std::cout << count++;
-	std::cout << ':';
-	if ( !a->isRequired() )
-		std::cout << ':';
+		std::cout << "#compdef " << progName << std::endl << std::endl << "# " << progName <<
+		        " version " << _cmd.getVersion() << std::endl << std::endl << "_arguments -s -S";
 
-	std::cout << a->getName() << ':';
-	std::map<std::string, std::string>::iterator compArg = common.find(a->getName());
-	if ( compArg != common.end() )
-	{
-		std::cout << compArg->second;
-	}
-	else
-	{
-		std::cout << "_guard \"^-*\" " << a->getName();
-	}
-	std::cout << '\'';
-}
+		for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
+		{
+			if ((*it)->shortID().at(0) == '<')
+			{
+				printArg((*it));
+			}
+			else if ((*it)->getFlag() != "-")
+			{
+				printOption((*it), getMutexList(_cmd, *it));
+			}
+		}
 
-inline void ZshCompletionOutput::printOption(Arg* a, std::string mutex)
-{
-	std::string flag = a->flagStartChar() + a->getFlag();
-	std::string name = a->nameStartString() + a->getName();
-	std::string desc = a->getDescription();
+		std::cout << std::endl;
+	}
 
-	// remove full stop and capitalisation from description as
-	// this is the convention for zsh function
-	if (!desc.compare(0, 12, "(required)  "))
+	inline void ZshCompletionOutput::failure(CmdLineInterface &_cmd, ArgException &e)
 	{
-		desc.erase(0, 12);
+		static_cast<void>(_cmd); // unused
+		std::cout << e.what() << std::endl;
 	}
-	if (!desc.compare(0, 15, "(OR required)  "))
+
+	inline void ZshCompletionOutput::quoteSpecialChars(std::string &s)
 	{
-		desc.erase(0, 15);
+		size_t idx = s.find_last_of(':');
+		while (idx != std::string::npos)
+		{
+			s.insert(idx, 1, '\\');
+			idx = s.find_last_of(':', idx);
+		}
+		idx = s.find_last_of('\'');
+		while (idx != std::string::npos)
+		{
+			s.insert(idx, "'\\'");
+			if (idx == 0)
+			{
+				idx = std::string::npos;
+			}
+			else
+			{
+				idx = s.find_last_of('\'', --idx);
+			}
+		}
 	}
-	size_t len = desc.length();
-	if (len && desc.at(--len) == '.')
+
+	inline void ZshCompletionOutput::basename(std::string &s)
 	{
-		desc.erase(len);
+		size_t p = s.find_last_of('/');
+		if (p != std::string::npos)
+		{
+			s.erase(0, p + 1);
+		}
 	}
-	if (len)
+
+	inline void ZshCompletionOutput::printArg(Arg *a)
 	{
-		desc.replace(0, 1, 1, tolower(desc.at(0)));
-	}
+		static int count = 1;
 
-	std::cout << " \\" << std::endl << "  '" << mutex;
+		std::cout << " \\" << std::endl << "  '";
+		if (a->acceptsMultipleValues())
+		{
+			std::cout << '*';
+		}
+		else
+		{
+			std::cout << count++;
+		}
+		std::cout << ':';
+		if (!a->isRequired())
+		{
+			std::cout << ':';
+		}
 
-	if ( a->getFlag().empty() )
-	{
-		std::cout << name;
-	}
-	else
-	{
-		std::cout << "'{" << flag << ',' << name << "}'";
+		std::cout << a->getName() << ':';
+		std::map<std::string, std::string>::iterator compArg = common.find(a->getName());
+		if (compArg != common.end())
+		{
+			std::cout << compArg->second;
+		}
+		else
+		{
+			std::cout << "_guard \"^-*\" " << a->getName();
+		}
+		std::cout << '\'';
 	}
-	if ( theDelimiter == '=' && a->isValueRequired() )
-		std::cout << "=-";
-	quoteSpecialChars(desc);
-	std::cout << '[' << desc << ']';
 
-	if ( a->isValueRequired() )
+	inline void ZshCompletionOutput::printOption(Arg *a, std::string mutex)
 	{
-		std::string arg = a->shortID();
-		arg.erase(0, arg.find_last_of(theDelimiter) + 1);
-		if ( arg.at(arg.length()-1) == ']' )
-			arg.erase(arg.length()-1);
-		if ( arg.at(arg.length()-1) == ']' )
+		std::string flag = a->flagStartChar() + a->getFlag();
+		std::string name = a->nameStartString() + a->getName();
+		std::string desc = a->getDescription();
+
+		// remove full stop and capitalisation from description as
+		// this is the convention for zsh function
+		if (!desc.compare(0, 12, "(required)  "))
 		{
-			arg.erase(arg.length()-1);
+			desc.erase(0, 12);
 		}
-		if ( arg.at(0) == '<' )
+		if (!desc.compare(0, 15, "(OR required)  "))
 		{
-			arg.erase(arg.length()-1);
-			arg.erase(0, 1);
+			desc.erase(0, 15);
 		}
-		size_t p = arg.find('|');
-		if ( p != std::string::npos )
+		size_t len = desc.length();
+		if (len && desc.at(--len) == '.')
 		{
-			do
-			{
-				arg.replace(p, 1, 1, ' ');
-			}
-			while ( (p = arg.find_first_of('|', p)) != std::string::npos );
-			quoteSpecialChars(arg);
-			std::cout << ": :(" << arg << ')';
+			desc.erase(len);
+		}
+		if (len)
+		{
+			desc.replace(0, 1, 1, tolower(desc.at(0)));
+		}
+
+		std::cout << " \\" << std::endl << "  '" << mutex;
+
+		if (a->getFlag().empty())
+		{
+			std::cout << name;
 		}
 		else
 		{
-			std::cout << ':' << arg;
-			std::map<std::string, std::string>::iterator compArg = common.find(arg);
-			if ( compArg != common.end() )
+			std::cout << "'{" << flag << ',' << name << "}'";
+		}
+		if (theDelimiter == '=' && a->isValueRequired())
+		{
+			std::cout << "=-";
+		}
+		quoteSpecialChars(desc);
+		std::cout << '[' << desc << ']';
+
+		if (a->isValueRequired())
+		{
+			std::string arg = a->shortID();
+			arg.erase(0, arg.find_last_of(theDelimiter) + 1);
+			if (arg.at(arg.length() - 1) == ']')
+			{
+				arg.erase(arg.length() - 1);
+			}
+			if (arg.at(arg.length() - 1) == ']')
+			{
+				arg.erase(arg.length() - 1);
+			}
+			if (arg.at(0) == '<')
+			{
+				arg.erase(arg.length() - 1);
+				arg.erase(0, 1);
+			}
+			size_t p = arg.find('|');
+			if (p != std::string::npos)
 			{
-				std::cout << ':' << compArg->second;
+				do
+				{
+					arg.replace(p, 1, 1, ' ');
+				}
+				while ((p = arg.find_first_of('|', p)) != std::string::npos);
+				quoteSpecialChars(arg);
+				std::cout << ": :(" << arg << ')';
+			}
+			else
+			{
+				std::cout << ':' << arg;
+				std::map<std::string, std::string>::iterator compArg = common.find(arg);
+				if (compArg != common.end())
+				{
+					std::cout << ':' << compArg->second;
+				}
 			}
 		}
-	}
-
-	std::cout << '\'';
-}
 
-inline std::string ZshCompletionOutput::getMutexList( CmdLineInterface& _cmd, Arg* a)
-{
-	XorHandler xorHandler = _cmd.getXorHandler();
-	std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
-	
-	if (a->getName() == "help" || a->getName() == "version")
-	{
-		return "(-)";
+		std::cout << '\'';
 	}
 
-	std::ostringstream list;
-	if ( a->acceptsMultipleValues() )
+	inline std::string ZshCompletionOutput::getMutexList(CmdLineInterface &_cmd, Arg *a)
 	{
-		list << '*';
-	}
+		XorHandler xorHandler = _cmd.getXorHandler();
+		std::vector<std::vector<Arg*>> xorList = xorHandler.getXorList();
 
-	for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
-	{
-		for ( ArgVectorIterator it = xorList[i].begin();
-			it != xorList[i].end();
-			it++)
-		if ( a == (*it) )
+		if (a->getName() == "help" || a->getName() == "version")
+		{
+			return "(-)";
+		}
+
+		std::ostringstream list;
+		if (a->acceptsMultipleValues())
+		{
+			list << '*';
+		}
+
+		for (int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++)
 		{
-			list << '(';
-			for ( ArgVectorIterator iu = xorList[i].begin();
-				iu != xorList[i].end();
-				iu++ )
+			for (ArgVectorIterator it = xorList[i].begin();
+			        it != xorList[i].end();
+			        it++)
 			{
-				bool notCur = (*iu) != a;
-				bool hasFlag = !(*iu)->getFlag().empty();
-				if ( iu != xorList[i].begin() && (notCur || hasFlag) )
-					list << ' ';
-				if (hasFlag)
-					list << (*iu)->flagStartChar() << (*iu)->getFlag() << ' ';
-				if ( notCur || hasFlag )
-					list << (*iu)->nameStartString() << (*iu)->getName();
+				if (a == (*it))
+				{
+					list << '(';
+					for (ArgVectorIterator iu = xorList[i].begin();
+					        iu != xorList[i].end();
+					        iu++)
+					{
+						bool notCur  = (*iu) != a;
+						bool hasFlag = !(*iu)->getFlag().empty();
+						if (iu != xorList[i].begin() && (notCur || hasFlag))
+						{
+							list << ' ';
+						}
+						if (hasFlag)
+						{
+							list << (*iu)->flagStartChar() << (*iu)->getFlag() << ' ';
+						}
+						if (notCur || hasFlag)
+						{
+							list << (*iu)->nameStartString() << (*iu)->getName();
+						}
+					}
+					list << ')';
+					return list.str();
+				}
 			}
-			list << ')';
-			return list.str();
 		}
-	}
-	
-	// wasn't found in xor list
-	if (!a->getFlag().empty()) {
-		list << "(" << a->flagStartChar() << a->getFlag() << ' ' <<
-			a->nameStartString() << a->getName() << ')';
-	}
-	
-	return list.str();
-}
 
+		// wasn't found in xor list
+		if (!a->getFlag().empty())
+		{
+			list << "(" << a->flagStartChar() << a->getFlag() << ' ' << a->nameStartString() <<
+			        a->getName() << ')';
+		}
+
+		return list.str();
+	}
 } //namespace TCLAP
+
 #endif