summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorPetr Mrázek2011-06-20 01:17:49 +0200
committerPetr Mrázek2011-06-20 01:17:49 +0200
commitffd2ca328150bc6ae73310b65264426d8de24896 (patch)
treeca1eb31a957a709553c65f61d3c6a5d2dbcf05b9
parentf2b91d32690988241c3311d62bab780803682906 (diff)
downloaddfhack-ffd2ca328150bc6ae73310b65264426d8de24896.tar.gz
dfhack-ffd2ca328150bc6ae73310b65264426d8de24896.tar.bz2
dfhack-ffd2ca328150bc6ae73310b65264426d8de24896.tar.xz
License updates done, removed argstream.
-rw-r--r--LICENSE61
-rw-r--r--library/depends/argstream/argstream.h819
2 files changed, 3 insertions, 877 deletions
diff --git a/LICENSE b/LICENSE
index d9943bf5..5e1de64e 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,7 +1,8 @@
----------------------------------------------------------------------
License of dfhack
-github.com/peterix/dfhack
-Copyright (c) 2009 Petr Mrázek (peterix), Kenneth Ferland (Impaler[WrG]), dorf
+
+https://github.com/peterix/dfhack
+Copyright (c) 2009-2011 Petr Mrázek (peterix@gmail.com)
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
@@ -22,62 +23,6 @@ must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source
distribution.
-----------------------------------------------------------------------
-License of library/include/dfhack/DFstdint_win.h
-
-ISO C9x compliant stdint.h for Microsoft Visual Studio
-Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
-
- Copyright (c) 2006-2008 Alexander Chemeris
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
-
- 3. The name of the author may be used to endorse or promote products
- derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------------
-License of argstream (used by some utilities for parsing command line params)
-
-Copyright (C) 2004 Xavier Decoret <Xavier.Decoret@imag.fr>
-
-argsteam is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-Foobar is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with Foobar; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-This library is used by:
-tools/playground/catsplosion.cpp
-tools/playground/digger.cpp
-tools/supported/vdig.cpp
-
----------------------------------------------------------------------------
License of "RSA Data Security, Inc. MD5 Message-Digest Algorithm"
Used to identify DF binaries.
diff --git a/library/depends/argstream/argstream.h b/library/depends/argstream/argstream.h
deleted file mode 100644
index 0abf5580..00000000
--- a/library/depends/argstream/argstream.h
+++ /dev/null
@@ -1,819 +0,0 @@
-/* Copyright (C) 2004 Xavier Decoret <Xavier.Decoret@imag.fr>
-*
-* argsteam is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation; either version 2 of the License, or
-* (at your option) any later version.
-*
-* Foobar is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with Foobar; if not, write to the Free Software
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#ifndef ARGSTREAM_H
-#define ARGSTREAM_H
-
-
-#include <string>
-#include <list>
-#include <deque>
-#include <map>
-#include <stdexcept>
-#include <sstream>
-#include <iostream>
-
-namespace
-{
- class argstream;
-
- template<class T>
- class ValueHolder;
-
- template <typename T>
- argstream& operator>> (argstream&, const ValueHolder<T>&);
- //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- // Interface of ValueHolder<T>
- //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- template<class T>
- class ValueHolder
- {
- public:
- ValueHolder(char s,
- const char* l,
- T& b,
- const char* desc,
- bool mandatory);
- ValueHolder(const char* l,
- T& b,
- const char* desc,
- bool mandatory);
- ValueHolder(char s,
- T& b,
- const char* desc,
- bool mandatory);
- friend argstream& operator>><>(argstream& s,const ValueHolder<T>& v);
- std::string name() const;
- std::string description() const;
- private:
- std::string shortName_;
- std::string longName_;
- T* value_;
- T initialValue_;
- std::string description_;
- bool mandatory_;
- };
- template <class T>
- inline ValueHolder<T>
- parameter(char s,
- const char* l,
- T& b,
- const char* desc="",
- bool mandatory = true)
- {
- return ValueHolder<T>(s,l,b,desc,mandatory);
- }
- template <class T>
- inline ValueHolder<T>
- parameter(char s,
- T& b,
- const char* desc="",
- bool mandatory = true)
- {
- return ValueHolder<T>(s,b,desc,mandatory);
- }
- template <class T>
- inline ValueHolder<T>
- parameter(const char* l,
- T& b,
- const char* desc="",
- bool mandatory = true)
- {
- return ValueHolder<T>(l,b,desc,mandatory);
- }
- //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- // Interface of OptionHolder
- //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- class OptionHolder
- {
- public:
- inline OptionHolder(char s,
- const char* l,
- bool& b,
- const char* desc);
- inline OptionHolder(const char* l,
- bool& b,
- const char* desc);
- inline OptionHolder(char s,
- bool& b,
- const char* desc);
- friend argstream& operator>>(argstream& s,const OptionHolder& v);
- inline std::string name() const;
- inline std::string description() const;
- protected:
- inline OptionHolder(char s,
- const char* l,
- const char* desc);
- friend OptionHolder help(char s='h',
- const char* l="help",
- const char* desc="Display this help");
- private:
- std::string shortName_;
- std::string longName_;
- bool* value_;
- std::string description_;
- };
- inline OptionHolder
- option(char s,
- const char* l,
- bool& b,
- const char* desc="")
- {
- return OptionHolder(s,l,b,desc);
- }
- inline OptionHolder
- option(char s,
- bool& b,
- const char* desc="")
- {
- return OptionHolder(s,b,desc);
- }
- inline OptionHolder
- option(const char* l,
- bool& b,
- const char* desc="")
- {
- return OptionHolder(l,b,desc);
- }
- inline OptionHolder
- help(char s,
- const char* l,
- const char* desc)
- {
- return OptionHolder(s,l,desc);
- }
- template <class T, class O>
- class ValuesHolder;
- template <typename T, typename O>
- argstream& operator>> (argstream&, const ValuesHolder<T, O>&);
- //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- // Interface of ValuesHolder
- //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- template<class T,class O>
- class ValuesHolder
- {
- public:
- ValuesHolder(const O& o,
- const char* desc,
- int len);
- friend argstream& operator>><>(argstream& s,const ValuesHolder<T,O>& v);
- std::string name() const;
- std::string description() const;
- typedef T value_type;
- private:
- mutable O value_;
- std::string description_;
- int len_;
- char letter_;
- };
- template<class T,class O>
- inline ValuesHolder<T,O>
- values(const O& o,
- const char* desc="",
- int len=-1)
- {
- return ValuesHolder<T,O>(o,desc,len);
- }
- //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- // Interface of ValueParser
- //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- template <class T>
- class ValueParser
- {
- public:
- inline T operator()(const std::string& s) const
- {
- std::istringstream is(s);
- T t;
- is>>t;
- return t;
- }
- };
- // We need to specialize for string otherwise parsing of a value that
- // contains space (for example a string with space passed in quotes on the
- // command line) would parse only the first element of the value!!!
- template <>
- class ValueParser<std::string>
- {
- public:
- inline std::string operator()(const std::string& s) const
- {
- return s;
- }
- };
- //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- // Interface of argstream
- //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- class argstream
- {
- public:
- inline argstream(int argc,char** argv);
- //inline argstream(const char* c);
- template<class T>
- friend argstream& operator>>(argstream& s,const ValueHolder<T>& v);
- friend inline argstream& operator>>(argstream& s,const OptionHolder& v);
- template<class T,class O>
- friend argstream& operator>>(argstream& s,const ValuesHolder<T,O>& v);
-
- inline bool helpRequested() const;
- inline bool isOk() const;
- inline std::string errorLog() const;
- inline std::string usage() const;
- inline void defaultErrorHandling(bool ignoreUnused=false) const;
- static inline char uniqueLetter();
- protected:
- void parse(int argc,char** argv);
- private:
- typedef std::list<std::string>::iterator value_iterator;
- typedef std::pair<std::string,std::string> help_entry;
- std::string progName_;
- std::map<std::string,value_iterator> options_;
- std::list<std::string> values_;
- bool minusActive_;
- bool isOk_;
- std::deque<help_entry> argHelps_;
- std::string cmdLine_;
- std::deque<std::string> errors_;
- bool helpRequested_;
- };
- //************************************************************
- // Implementation of ValueHolder<T>
- //************************************************************
- template<class T>
- ValueHolder<T>::ValueHolder(char s,
- const char* l,
- T& v,
- const char* desc,
- bool mandatory)
- : shortName_(1,s),
- longName_(l),
- value_(&v),
- initialValue_(v),
- description_(desc),
- mandatory_(mandatory)
- {
- }
- template<class T>
- ValueHolder<T>::ValueHolder(const char* l,
- T& v,
- const char* desc,
- bool mandatory)
- : longName_(l),
- value_(&v),
- initialValue_(v),
- description_(desc),
- mandatory_(mandatory)
- {
- }
- template<class T>
- ValueHolder<T>::ValueHolder(char s,
- T& v,
- const char* desc,
- bool mandatory)
- : shortName_(1,s),
- value_(&v),
- initialValue_(v),
- description_(desc),
- mandatory_(mandatory)
- {
- }
- template<class T>
- std::string
- ValueHolder<T>::name() const
- {
- std::ostringstream os;
- if (!shortName_.empty()) os<<'-'<<shortName_;
- if (!longName_.empty()) {
- if (!shortName_.empty()) os<<'/';
- os<<"--"<<longName_;
- }
- return os.str();
- }
- template<class T>
- std::string
- ValueHolder<T>::description() const
- {
- std::ostringstream os;
- os<<description_;
- if (mandatory_)
- {
- os<<"(mandatory)";
- }
- else
- {
- os<<"(default="<<initialValue_<<")";
- }
- return os.str();
- }
- //************************************************************
- // Implementation of OptionHolder
- //************************************************************
- inline OptionHolder::OptionHolder(char s,
- const char* l,
- bool& b,
- const char* desc)
- : shortName_(1,s),
- longName_(l),
- value_(&b),
- description_(desc)
- {
- }
- inline OptionHolder::OptionHolder(const char* l,
- bool& b,
- const char* desc)
- : longName_(l),
- value_(&b),
- description_(desc)
- {
- }
- inline OptionHolder::OptionHolder(char s,
- bool& b,
- const char* desc)
- : shortName_(1,s),
- value_(&b),
- description_(desc)
- {
- }
- inline OptionHolder::OptionHolder(char s,
- const char* l,
- const char* desc)
- : shortName_(1,s),
- longName_(l),
- value_(NULL),
- description_(desc)
- {
- }
- inline std::string
- OptionHolder::name() const
- {
- std::ostringstream os;
- if (!shortName_.empty()) os<<'-'<<shortName_;
- if (!longName_.empty())
- {
- if (!shortName_.empty()) os<<'/';
- os<<"--"<<longName_;
- }
- return os.str();
- }
- inline std::string
- OptionHolder::description() const
- {
- return description_;
- }
- //************************************************************
- // Implementation of ValuesHolder<T,O>
- //************************************************************
- template<class T,class O>
- ValuesHolder<T,O>::ValuesHolder(const O& o,
- const char* desc,
- int len)
- : value_(o),
- description_(desc),
- len_(len)
- {
- letter_ = argstream::uniqueLetter();
- }
- template <class T,class O>
- std::string
- ValuesHolder<T,O>::name() const
- {
- std::ostringstream os;
- os<<letter_<<"i";
- return os.str();
- }
- template <class T,class O>
- std::string
- ValuesHolder<T,O>::description() const
- {
- return description_;
- }
- //************************************************************
- // Implementation of argstream
- //************************************************************
- inline
- argstream::argstream(int argc,char** argv)
- : progName_(argv[0]),
- minusActive_(true),
- isOk_(true)
- {
- parse(argc,argv);
- }
- //inline
- // argstream::argstream(const char* c)
- // : progName_(""),
- // minusActive_(true),
- // isOk_(true)
- //{
- // std::string s(c);
- // // Build argc, argv from s. We must add a dummy first element for
- // // progName because parse() expects it!!
- // std::deque<std::string> args;
- // args.push_back("");
- // std::istringstream is(s);
- // while (is.good())
- // {
- // std::string t;
- // is>>t;
- // args.push_back(t);
- // }
- // char* pargs[args.size()];
- // char** p = pargs;
- // for (std::deque<std::string>::const_iterator
- // iter = args.begin();
- // iter != args.end();++iter)
- // {
- // *p++ = const_cast<char*>(iter->c_str());
- // }
- // parse(args.size(),pargs);
- //}
- inline void
- argstream::parse(int argc,char** argv)
- {
- // Run thru all arguments.
- // * it has -- in front : it is a long name option, if remainder is empty,
- // it is an error
- // * it has - in front : it is a sequence of short name options, if
- // remainder is empty, deactivates option (- will
- // now be considered a char).
- // * if any other char, or if option was deactivated
- // : it is a value. Values are split in parameters
- // (immediately follow an option) and pure values.
- // Each time a value is parsed, if the previously parsed argument was an
- // option, then the option is linked to the value in case of it is a
- // option with parameter. The subtle point is that when several options
- // are given with short names (ex: -abc equivalent to -a -b -c), the last
- // parsed option is -c).
- // Since we use map for option, any successive call overides the previous
- // one: foo -a -b -a hello is equivalent to foo -b -a hello
- // For values it is not true since we might have several times the same
- // value.
- value_iterator* lastOption = NULL;
- for (char** a = argv,**astop=a+argc;++a!=astop;)
- {
- std::string s(*a);
- if (minusActive_ && s[0] == '-')
- {
- if (s.size() > 1 && s[1] == '-')
- {
- if (s.size() == 2)
- {
- minusActive_ = false;
- continue;
- }
- lastOption = &(options_[s.substr(2)] = values_.end());
- }
- else
- {
- if (s.size() > 1)
- {
- // Parse all chars, if it is a minus we have an error
- for (std::string::const_iterator cter = s.begin();
- ++cter != s.end();)
- {
- if (*cter == '-')
- {
- isOk_ = false;
- std::ostringstream os;
- os<<"- in the middle of a switch "<<a;
- errors_.push_back(os.str());
- break;
- }
- lastOption = &(options_[std::string(1,*cter)] = values_.end());
- }
- }
- else
- {
- isOk_ = false;
- errors_.push_back("Invalid argument -");
- break;
- }
- }
- }
- else
- {
- values_.push_back(s);
- if (lastOption != NULL)
- {
- *lastOption = --values_.end();
- }
- lastOption = NULL;
- }
- }
-#ifdef ARGSTREAM_DEBUG
- for (std::map<std::string,value_iterator>::const_iterator
- iter = options_.begin();iter != options_.end();++iter)
- {
- std::cout<<"DEBUG: option "<<iter->first;
- if (iter->second != values_.end())
- {
- std::cout<<" -> "<<*(iter->second);
- }
- std::cout<<std::endl;
- }
- for (std::list<std::string>::const_iterator
- iter = values_.begin();iter != values_.end();++iter)
- {
- std::cout<<"DEBUG: value "<<*iter<<std::endl;
- }
-#endif // ARGSTREAM_DEBUG
- }
- inline bool
- argstream::isOk() const
- {
- return isOk_;
- }
- inline bool
- argstream::helpRequested() const
- {
- return helpRequested_;
- }
- inline std::string
- argstream::usage() const
- {
- std::ostringstream os;
- os<<"usage: "<<progName_<<cmdLine_<<'\n';
- unsigned int lmax = 0;
- for (std::deque<help_entry>::const_iterator
- iter = argHelps_.begin();iter != argHelps_.end();++iter)
- {
- if (lmax<iter->first.size()) lmax = iter->first.size();
- }
- for (std::deque<help_entry>::const_iterator
- iter = argHelps_.begin();iter != argHelps_.end();++iter)
- {
- os<<'\t'<<iter->first<<std::string(lmax-iter->first.size(),' ')
- <<" : "<<iter->second<<'\n';
- }
- return os.str();
- }
- inline std::string
- argstream::errorLog() const
- {
- std::string s;
- for(std::deque<std::string>::const_iterator iter = errors_.begin();
- iter != errors_.end();++iter)
- {
- s += *iter;
- s += '\n';
- }
- return s;
- }
- inline char
- argstream::uniqueLetter()
- {
- static unsigned int c = 'a';
- return c++;
- }
- template<class T>
- argstream&
- operator>>(argstream& s,const ValueHolder<T>& v)
- {
- // Search in the options if there is any such option defined either with a
- // short name or a long name. If both are found, only the last one is
- // used.
-#ifdef ARGSTREAM_DEBUG
- std::cout<<"DEBUG: searching "<<v.shortName_<<" "<<v.longName_<<std::endl;
-#endif
- s.argHelps_.push_back(argstream::help_entry(v.name(),v.description()));
- if (v.mandatory_)
- {
- if (!v.shortName_.empty())
- {
- s.cmdLine_ += " -";
- s.cmdLine_ += v.shortName_;
- }
- else
- {
- s.cmdLine_ += " --";
- s.cmdLine_ += v.longName_;
- }
- s.cmdLine_ += " value";
- }
- else
- {
- if (!v.shortName_.empty())
- {
- s.cmdLine_ += " [-";
- s.cmdLine_ += v.shortName_;
- }
- else
- {
- s.cmdLine_ += " [--";
- s.cmdLine_ += v.longName_;
- }
- s.cmdLine_ += " value]";
-
- }
- std::map<std::string,argstream::value_iterator>::iterator iter =
- s.options_.find(v.shortName_);
- if (iter == s.options_.end())
- {
- iter = s.options_.find(v.longName_);
- }
- if (iter != s.options_.end())
- {
- // If we find counterpart for value holder on command line, either it
- // has an associated value in which case we assign it, or it has not, in
- // which case we have an error.
- if (iter->second != s.values_.end())
- {
-#ifdef ARGSTREAM_DEBUG
- std::cout<<"DEBUG: found value "<<*(iter->second)<<std::endl;
-#endif
- ValueParser<T> p;
- *(v.value_) = p(*(iter->second));
- // The option and its associated value are removed, the subtle thing
- // is that someother options might have this associated value too,
- // which we must invalidate.
- s.values_.erase(iter->second);
-
- // FIXME this loop seems to crash if a std::string is used as the value
- //for (std::map<std::string,argstream::value_iterator>::iterator
- // jter = s.options_.begin();jter != s.options_.end();++jter)
- //{
- // if (jter->second == iter->second)
- // {
- // jter->second = s.values_.end();
- // }
- //}
- s.options_.erase(iter);
- }
- else
- {
- s.isOk_ = false;
- std::ostringstream os;
- os<<"No value following switch "<<iter->first
- <<" on command line";
- s.errors_.push_back(os.str());
- }
- }
- else
- {
- if (v.mandatory_)
- {
- s.isOk_ = false;
- std::ostringstream os;
- os<<"Mandatory parameter ";
- if (!v.shortName_.empty()) os<<'-'<<v.shortName_;
- if (!v.longName_.empty())
- {
- if (!v.shortName_.empty()) os<<'/';
- os<<"--"<<v.longName_;
- }
- os<<" missing";
- s.errors_.push_back(os.str());
- }
- }
- return s;
- }
- inline argstream&
- operator>>(argstream& s,const OptionHolder& v)
- {
- // Search in the options if there is any such option defined either with a
- // short name or a long name. If both are found, only the last one is
- // used.
-#ifdef ARGSTREAM_DEBUG
- std::cout<<"DEBUG: searching "<<v.shortName_<<" "<<v.longName_<<std::endl;
-#endif
- s.argHelps_.push_back(argstream::help_entry(v.name(),v.description()));
- {
- std::string c;
- if (!v.shortName_.empty())
- {
- c += " [-";
- c += v.shortName_;
- }
- else
- {
- c += " [--";
- c += v.longName_;
- }
- c += "]";
- s.cmdLine_ = c+s.cmdLine_;
- }
- std::map<std::string,argstream::value_iterator>::iterator iter =
- s.options_.find(v.shortName_);
- if (iter == s.options_.end())
- {
- iter = s.options_.find(v.longName_);
- }
- if (iter != s.options_.end())
- {
- // If we find counterpart for value holder on command line then the
- // option is true and if an associated value was found, it is ignored
- if (v.value_ != NULL)
- {
- *(v.value_) = true;
- }
- else
- {
- s.helpRequested_ = true;
- }
- // The option only is removed
- s.options_.erase(iter);
- }
- else
- {
- if (v.value_ != NULL)
- {
- *(v.value_) = false;
- }
- else
- {
- s.helpRequested_ = false;
- }
- }
- return s;
- }
- template<class T,class O>
- argstream&
- operator>>(argstream& s,const ValuesHolder<T,O>& v)
- {
- s.argHelps_.push_back(argstream::help_entry(v.name(),v.description()));
- {
- std::ostringstream os;
- os<<' '<<v.letter_<<'1';
- switch (v.len_)
- {
- case -1:
- os<<"...";
- break;
- case 1:
- break;
- default:
- os<<"..."<<v.letter_<<v.len_;
- break;
- }
- s.cmdLine_ += os.str();
- }
- std::list<std::string>::iterator first = s.values_.begin();
- // We add to the iterator as much values as we can, limited to the length
- // specified (if different of -1)
- int n = v.len_ != -1?v.len_:s.values_.size();
- while (first != s.values_.end() && n-->0)
- {
- // Read the value from the string *first
- ValueParser<T> p;
- *(v.value_++) = p(*first );
- s.argHelps_.push_back(argstream::help_entry(v.name(),v.description()));
- // The value we just removed was maybe "remembered" by an option so we
- // remove it now.
- for (std::map<std::string,argstream::value_iterator>::iterator
- jter = s.options_.begin();jter != s.options_.end();++jter)
- {
- if (jter->second == first)
- {
- jter->second = s.values_.end();
- }
- }
- ++first;
- }
- // Check if we have enough values
- if (n != 0)
- {
- s.isOk_ = false;
- std::ostringstream os;
- os<<"Expecting "<<v.len_<<" values";
- s.errors_.push_back(os.str());
- }
- // Erase the values parsed
- s.values_.erase(s.values_.begin(),first);
- return s;
- }
- inline void
- argstream::defaultErrorHandling(bool ignoreUnused) const
- {
- if (helpRequested_)
- {
- std::cout<<usage();
- exit(1);
- }
- if (!isOk_)
- {
- std::cerr<<errorLog();
- exit(1);
- }
- if (!ignoreUnused &&
- (!values_.empty() || !options_.empty()))
- {
- std::cerr<<"Unused arguments"<<std::endl;
- exit(1);
- }
- }
-};
-#endif // ARGSTREAM_H
-