summaryrefslogtreecommitdiff
path: root/cli/cli/runtime-source.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'cli/cli/runtime-source.cxx')
-rw-r--r--cli/cli/runtime-source.cxx1052
1 files changed, 1052 insertions, 0 deletions
diff --git a/cli/cli/runtime-source.cxx b/cli/cli/runtime-source.cxx
new file mode 100644
index 0000000..36d8968
--- /dev/null
+++ b/cli/cli/runtime-source.cxx
@@ -0,0 +1,1052 @@
+// file : cli/runtime-source.cxx
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// license : MIT; see accompanying LICENSE file
+
+#include <cli/runtime-source.hxx>
+
+using namespace std;
+
+void
+generate_runtime_source (context& ctx, bool complete)
+{
+ ostream& os (ctx.os);
+
+ os << "#include <map>" << endl
+ << "#include <set>" << endl
+ << "#include <string>" << endl
+ << "#include <vector>" << endl
+ << "#include <ostream>" << endl
+ << "#include <sstream>" << endl;
+
+ if (complete && ctx.options.generate_file_scanner ())
+ os << "#include <cstring>" << endl
+ << "#include <fstream>" << endl;
+
+ os << endl;
+
+ ctx.ns_open (ctx.cli);
+
+ if (complete)
+ {
+ string const& os_type (ctx.options.ostream_type ());
+
+ // unknown_option
+ //
+ os << "// unknown_option" << endl
+ << "//" << endl
+ << "unknown_option::" << endl
+ << "~unknown_option () throw ()"
+ << "{"
+ << "}"
+
+ << "void unknown_option::" << endl
+ << "print (" << os_type << "& os) const"
+ << "{"
+ << "os << \"unknown option '\" << option ().c_str () << \"'\";"
+ << "}"
+
+ << "const char* unknown_option::" << endl
+ << "what () const throw ()"
+ << "{"
+ << "return \"unknown option\";"
+ << "}";
+
+ // unknown_argument
+ //
+ os << "// unknown_argument" << endl
+ << "//" << endl
+ << "unknown_argument::" << endl
+ << "~unknown_argument () throw ()"
+ << "{"
+ << "}"
+
+ << "void unknown_argument::" << endl
+ << "print (" << os_type << "& os) const"
+ << "{"
+ << "os << \"unknown argument '\" << argument ().c_str () << \"'\";"
+ << "}"
+
+ << "const char* unknown_argument::" << endl
+ << "what () const throw ()"
+ << "{"
+ << "return \"unknown argument\";"
+ << "}";
+
+ // missing_value
+ //
+ os << "// missing_value" << endl
+ << "//" << endl
+ << "missing_value::" << endl
+ << "~missing_value () throw ()"
+ << "{"
+ << "}"
+
+ << "void missing_value::" << endl
+ << "print (" << os_type << "& os) const"
+ << "{"
+ << "os << \"missing value for option '\" << option ().c_str () << \"'\";"
+ << "}"
+
+ << "const char* missing_value::" << endl
+ << "what () const throw ()"
+ << "{"
+ << "return \"missing option value\";"
+ << "}";
+
+ // invalid_value
+ //
+ os << "// invalid_value" << endl
+ << "//" << endl
+ << "invalid_value::" << endl
+ << "~invalid_value () throw ()"
+ << "{"
+ << "}"
+
+ << "void invalid_value::" << endl
+ << "print (" << os_type << "& os) const"
+ << "{"
+ << "os << \"invalid value '\" << value ().c_str () << \"' for " <<
+ "option '\"" << endl
+ << " << option ().c_str () << \"'\";"
+ << endl
+ << "if (!message ().empty ())" << endl
+ << "os << \": \" << message ().c_str ();"
+ << "}"
+
+ << "const char* invalid_value::" << endl
+ << "what () const throw ()"
+ << "{"
+ << "return \"invalid option value\";"
+ << "}";
+
+ // eos_reached
+ //
+ os << "// eos_reached" << endl
+ << "//" << endl
+ << "void eos_reached::" << endl
+ << "print (" << os_type << "& os) const"
+ << "{"
+ << "os << what ();"
+ << "}"
+
+ << "const char* eos_reached::" << endl
+ << "what () const throw ()"
+ << "{"
+ << "return \"end of argument stream reached\";"
+ << "}";
+
+ if (ctx.options.generate_file_scanner ())
+ {
+ // file_io_failure
+ //
+ os << "// file_io_failure" << endl
+ << "//" << endl
+ << "file_io_failure::" << endl
+ << "~file_io_failure () throw ()"
+ << "{"
+ << "}"
+
+ << "void file_io_failure::" << endl
+ << "print (" << os_type << "& os) const"
+ << "{"
+ << "os << \"unable to open file '\" << file ().c_str () << " <<
+ "\"' or read failure\";"
+ << "}"
+
+ << "const char* file_io_failure::" << endl
+ << "what () const throw ()"
+ << "{"
+ << "return \"unable to open file or read failure\";"
+ << "}";
+
+ // unmatched_argument
+ //
+ os << "// unmatched_quote" << endl
+ << "//" << endl
+ << "unmatched_quote::" << endl
+ << "~unmatched_quote () throw ()"
+ << "{"
+ << "}"
+
+ << "void unmatched_quote::" << endl
+ << "print (" << os_type << "& os) const"
+ << "{"
+ << "os << \"unmatched quote in argument '\" << " <<
+ "argument ().c_str () << \"'\";"
+ << "}"
+
+ << "const char* unmatched_quote::" << endl
+ << "what () const throw ()"
+ << "{"
+ << "return \"unmatched quote\";"
+ << "}";
+ }
+
+ if (ctx.options.generate_group_scanner ())
+ {
+ // unexpected_group
+ //
+ os << "// unexpected_group" << endl
+ << "//" << endl
+
+ << "unexpected_group::" << endl
+ << "~unexpected_group () throw ()"
+ << "{"
+ << "}"
+
+ << "void unexpected_group::" << endl
+ << "print (" << os_type << "& os) const"
+ << "{"
+ << "os << \"unexpected grouped argument '\" << group_ << \"' \"" << endl
+ << " << \"for argument '\" << argument_ << \"'\";"
+ << "}"
+
+ << "const char* unexpected_group::" << endl
+ << "what () const throw ()"
+ << "{"
+ << "return \"unexpected grouped argument\";"
+ << "}";
+
+ // group_separator
+ //
+ os << "// group_separator" << endl
+ << "//" << endl
+
+ << "group_separator::" << endl
+ << "~group_separator () throw ()"
+ << "{"
+ << "}"
+
+ << "void group_separator::" << endl
+ << "print (" << os_type << "& os) const"
+ << "{"
+ << "bool ex (!expected_.empty ());"
+ << "bool en (!encountered_.empty ());"
+ << endl
+ << "if (ex)"
+ << "{"
+ << "os << \"expected group separator '\" << expected_ << \"'\";"
+ << "if (en)" << endl
+ << "os << \" instead of '\" << encountered_ << \"'\";"
+ << "}"
+ << "else" << endl
+ << "os << \"unexpected group separator '\" << encountered_ << \"'\";"
+ << endl
+ << "if (en)" << endl
+ << "os << \", use '\\\\\" << encountered_ << \"' to escape\";"
+ << "}"
+
+ << "const char* group_separator::" << endl
+ << "what () const throw ()"
+ << "{"
+ << "bool ex (!expected_.empty ());"
+ << "bool en (!encountered_.empty ());"
+ << endl
+ << "return en" << endl
+ << " ? ex ? \"wrong group separator\" : \"unexpected group separator\"" << endl
+ << " : ex ? \"expected group separator\" : \"\";"
+ << "}";
+ }
+
+ // scanner
+ //
+ os << "// scanner" << endl
+ << "//" << endl
+ << "scanner::" << endl
+ << "~scanner ()"
+ << "{"
+ << "}";
+
+ // argv_scanner
+ //
+ os << "// argv_scanner" << endl
+ << "//" << endl
+
+ << "bool argv_scanner::" << endl
+ << "more ()"
+ << "{"
+ << "return i_ < argc_;"
+ << "}"
+
+ << "const char* argv_scanner::" << endl
+ << "peek ()"
+ << "{"
+ << "if (i_ < argc_)" << endl
+ << "return argv_[i_];"
+ << "else" << endl
+ << "throw eos_reached ();"
+ << "}"
+
+ << "const char* argv_scanner::" << endl
+ << "next ()"
+ << "{"
+ << "if (i_ < argc_)"
+ << "{"
+ << "const char* r (argv_[i_]);"
+ << endl
+ << "if (erase_)"
+ << "{"
+ << "for (int i (i_ + 1); i < argc_; ++i)" << endl
+ << "argv_[i - 1] = argv_[i];"
+ << endl
+ << "--argc_;"
+ << "argv_[argc_] = 0;"
+ << "}"
+ << "else" << endl
+ << "++i_;"
+ << endl
+ << "return r;"
+ << "}"
+ << "else" << endl
+ << "throw eos_reached ();"
+ << "}"
+
+ << "void argv_scanner::" << endl
+ << "skip ()"
+ << "{"
+ << "if (i_ < argc_)" << endl
+ << "++i_;"
+ << "else" << endl
+ << "throw eos_reached ();"
+ << "}";
+
+ // vector_scanner
+ //
+ if (ctx.options.generate_vector_scanner ())
+ {
+ os << "// vector_scanner" << endl
+ << "//" << endl
+
+ << "bool vector_scanner::" << endl
+ << "more ()"
+ << "{"
+ << "return i_ < v_.size ();"
+ << "}"
+
+ << "const char* vector_scanner::" << endl
+ << "peek ()"
+ << "{"
+ << "if (i_ < v_.size ())" << endl
+ << "return v_[i_].c_str ();"
+ << "else" << endl
+ << "throw eos_reached ();"
+ << "}"
+
+ << "const char* vector_scanner::" << endl
+ << "next ()"
+ << "{"
+ << "if (i_ < v_.size ())" << endl
+ << "return v_[i_++].c_str ();"
+ << "else" << endl
+ << "throw eos_reached ();"
+ << "}"
+
+ << "void vector_scanner::" << endl
+ << "skip ()"
+ << "{"
+ << "if (i_ < v_.size ())" << endl
+ << "++i_;"
+ << "else" << endl
+ << "throw eos_reached ();"
+ << "}";
+ }
+
+ // argv_file_scanner
+ //
+ if (ctx.options.generate_file_scanner ())
+ {
+ bool sep (!ctx.opt_sep.empty ());
+
+ const string& pfx (ctx.opt_prefix);
+ size_t pfx_n (pfx.size ());
+ bool comb_values (pfx_n != 0 && !ctx.options.no_combined_values ());
+
+ os << "// argv_file_scanner" << endl
+ << "//" << endl
+
+ << "int argv_file_scanner::zero_argc_ = 0;"
+ << "std::string argv_file_scanner::empty_string_;"
+ << endl
+
+ << "bool argv_file_scanner::" << endl
+ << "more ()"
+ << "{"
+ << "if (!args_.empty ())" << endl
+ << "return true;"
+ << endl
+ << "while (base::more ())"
+ << "{"
+ << "// See if the next argument is the file option." << endl
+ << "//" << endl
+ << "const char* a (base::peek ());"
+ << "const option_info* oi = 0;"
+ << "const char* ov = 0;"
+ << endl;
+
+ if (sep)
+ os << "if (!skip_)"
+ << "{";
+
+ os << "if ((oi = find (a)) != 0)"
+ << "{"
+ << "base::next ();"
+ << endl
+ << "if (!base::more ())" << endl
+ << "throw missing_value (a);"
+ << endl
+ << "ov = base::next ();"
+ << "}";
+
+ // Handle the combined option/value (--foo=bar). See the option parsing
+ // implementation for details.
+ //
+ if (comb_values)
+ {
+ os << "else if (std::strncmp (a, \"" << pfx << "\", " <<
+ pfx_n << ") == 0)" // It looks like an option.
+ << "{"
+ << "if ((ov = std::strchr (a, '=')) != 0)" // Has '='.
+ << "{"
+ << "std::string o (a, 0, ov - a);"
+ << "if ((oi = find (o.c_str ())) != 0)"
+ << "{"
+ << "base::next ();"
+ << "++ov;" // That's the value.
+ << "}"
+ << "}"
+ << "}";
+ }
+
+ if (sep)
+ os << "}";
+
+ os << "if (oi != 0)"
+ << "{"
+ << "if (oi->search_func != 0)"
+ << "{"
+ << "std::string f (oi->search_func (ov, oi->arg));"
+ << endl
+ << "if (!f.empty ())" << endl
+ << "load (f);"
+ << "}"
+ << "else" << endl
+ << "load (ov);"
+ << endl
+ << "if (!args_.empty ())" << endl
+ << "return true;"
+ << "}"
+ << "else"
+ << "{";
+ if (sep)
+ os << "if (!skip_)" << endl
+ << "skip_ = (std::strcmp (a, \"" << ctx.opt_sep << "\") == 0);"
+ << endl;
+ os << "return true;"
+ << "}"
+ << "}" // while
+ << "return false;"
+ << "}"
+
+ << "const char* argv_file_scanner::" << endl
+ << "peek ()"
+ << "{"
+ << "if (!more ())" << endl
+ << "throw eos_reached ();"
+ << endl
+ << "return args_.empty () ? base::peek () : args_.front ().value.c_str ();"
+ << "}"
+
+ << "const std::string& argv_file_scanner::" << endl
+ << "peek_file ()"
+ << "{"
+ << "if (!more ())" << endl
+ << "throw eos_reached ();"
+ << endl
+ << "return args_.empty () ? empty_string_ : *args_.front ().file;"
+ << "}"
+
+ << "std::size_t argv_file_scanner::" << endl
+ << "peek_line ()"
+ << "{"
+ << "if (!more ())" << endl
+ << "throw eos_reached ();"
+ << endl
+ << "return args_.empty () ? 0 : args_.front ().line;"
+ << "}"
+
+ << "const char* argv_file_scanner::" << endl
+ << "next ()"
+ << "{"
+ << "if (!more ())" << endl
+ << "throw eos_reached ();"
+ << endl
+ << "if (args_.empty ())" << endl
+ << "return base::next ();"
+ << "else"
+ << "{"
+ << "hold_[i_ == 0 ? ++i_ : --i_].swap (args_.front ().value);"
+ << "args_.pop_front ();"
+ << "return hold_[i_].c_str ();"
+ << "}"
+ << "}"
+
+ << "void argv_file_scanner::" << endl
+ << "skip ()"
+ << "{"
+ << "if (!more ())" << endl
+ << "throw eos_reached ();"
+ << endl
+ << "if (args_.empty ())" << endl
+ << "return base::skip ();"
+ << "else" << endl
+ << "args_.pop_front ();"
+ << "}"
+
+ << "const argv_file_scanner::option_info* argv_file_scanner::" << endl
+ << "find (const char* a) const"
+ << "{"
+ << "for (std::size_t i (0); i < options_count_; ++i)" << endl
+ << "if (std::strcmp (a, options_[i].option) == 0)" << endl
+ << "return &options_[i];"
+ << endl
+ << "return 0;"
+ << "}"
+
+ << "void argv_file_scanner::" << endl
+ << "load (const std::string& file)"
+ << "{"
+ << "using namespace std;"
+ << endl
+ << "ifstream is (file.c_str ());"
+ << endl
+ << "if (!is.is_open ())" << endl
+ << "throw file_io_failure (file);"
+ << endl
+ << "files_.push_back (file);"
+ << endl
+ << "arg a;"
+ << "a.file = &*files_.rbegin ();"
+ << endl
+ << "for (a.line = 1; !is.eof (); ++a.line)"
+ << "{"
+ << "string line;"
+ << "getline (is, line);"
+ << endl
+ << "if (is.fail () && !is.eof ())" << endl
+ << "throw file_io_failure (file);"
+ << endl
+ << "string::size_type n (line.size ());"
+ << endl
+ << "// Trim the line from leading and trailing whitespaces." << endl
+ << "//" << endl
+ << "if (n != 0)"
+ << "{"
+ << "const char* f (line.c_str ());"
+ << "const char* l (f + n);"
+ << endl
+ << "const char* of (f);"
+ << "while (f < l && (*f == ' ' || *f == '\\t' || *f == '\\r'))" << endl
+ << "++f;"
+ << endl
+ << "--l;"
+ << endl
+ << "const char* ol (l);"
+ << "while (l > f && (*l == ' ' || *l == '\\t' || *l == '\\r'))" << endl
+ << "--l;"
+ << endl
+ << "if (f != of || l != ol)" << endl
+ << "line = f <= l ? string (f, l - f + 1) : string ();"
+ << "}"
+ << "// Ignore empty lines, those that start with #." << endl
+ << "//" << endl
+ << "if (line.empty () || line[0] == '#')" << endl
+ << "continue;"
+ << endl
+ << "string::size_type p (string::npos);";
+
+ // If we have the option prefix, then only consider lines that start
+ // with that as options.
+ //
+ if (pfx_n != 0)
+ os << "if (line.compare (0, " << pfx_n << ", \"" << pfx << "\") == 0)"
+ << "{";
+
+ os << "p = line.find (' ');";
+
+ // Handle the combined option/value (--foo=bar). This is a bit tricky
+ // since the equal sign can be part of the value (--foo bar=baz).
+ //
+ // Note that we cannot just pass it along as combined because of
+ // quoting (--foo="'bar baz'").
+ //
+ if (comb_values)
+ {
+ os << endl
+ << "string::size_type q (line.find ('='));"
+ << "if (q != string::npos && q < p)" << endl
+ << "p = q;";
+ }
+
+ if (pfx_n != 0)
+ os << "}";
+ else
+ os << endl;
+
+ os << "string s1;"
+ << "if (p != string::npos)"
+ << "{"
+ << "s1.assign (line, 0, p);"
+ << endl
+ << "// Skip leading whitespaces in the argument." << endl
+ << "//" << endl;
+ if (comb_values)
+ os << "if (line[p] == '=')" << endl // Keep whitespaces after '='.
+ << "++p;"
+ << "else"
+ << "{";
+ os << "n = line.size ();"
+ << "for (++p; p < n; ++p)"
+ << "{"
+ << "char c (line[p]);"
+ << "if (c != ' ' && c != '\\t' && c != '\\r')" << endl
+ << "break;"
+ << "}";
+ if (comb_values)
+ os << "}";
+ os << "}";
+ if (sep)
+ os << "else if (!skip_)" << endl
+ << "skip_ = (line == \"" << ctx.opt_sep << "\");"
+ << endl;
+
+ os << "string s2 (line, p != string::npos ? p : 0);"
+ << endl
+ << "// If the string (which is an option value or argument) is" << endl
+ << "// wrapped in quotes, remove them." << endl
+ << "//" << endl
+ << "n = s2.size ();"
+ << "char cf (s2[0]), cl (s2[n - 1]);"
+ << endl
+ << "if (cf == '\"' || cf == '\\'' || cl == '\"' || cl == '\\'')"
+ << "{"
+ << "if (n == 1 || cf != cl)" << endl
+ << "throw unmatched_quote (s2);"
+ << endl
+ << "s2 = string (s2, 1, n - 2);"
+ << "}";
+
+ os << "if (!s1.empty ())"
+ << "{"
+ << "// See if this is another file option." << endl
+ << "//" << endl
+ << "const option_info* oi;"
+ << "if (" << (sep ? "!skip_ && " : "") <<
+ "(oi = find (s1.c_str ())))" << endl
+ << "{"
+ << "if (s2.empty ())" << endl
+ << "throw missing_value (oi->option);"
+ << endl
+ << "if (oi->search_func != 0)"
+ << "{"
+ << "std::string f (oi->search_func (s2.c_str (), oi->arg));"
+ << "if (!f.empty ())" << endl
+ << "load (f);"
+ << "}"
+ << "else" << endl
+ << "load (s2);"
+ << endl
+ << "continue;"
+ << "}"
+ << "a.value = s1;"
+ << "args_.push_back (a);"
+ << "}"
+ << "a.value = s2;"
+ << "args_.push_back (a);"
+ << "}" // while
+ << "}";
+ }
+
+ // group_scanner
+ //
+ if (ctx.options.generate_group_scanner ())
+ {
+ os << "// group_scanner" << endl
+ << "//" << endl
+
+ << "bool group_scanner::" << endl
+ << "more ()"
+ << "{"
+ << "// We don't want to call scan_group() here since that" << endl
+ << "// would invalidate references to previous arguments." << endl
+ << "// But we do need to check that the previous group was" << endl
+ << "// handled." << endl
+ << "//" << endl
+ << "if (state_ == scanned)"
+ << "{"
+ << "if (group_scan_.end () != group_.size ())" << endl
+ << "throw unexpected_group (arg_[i_], group_scan_.next ());"
+ << "}"
+ << "return scan_.more ();"
+ << "}"
+
+ << "const char* group_scanner::" << endl
+ << "peek ()"
+ << "{"
+ << "if (state_ != peeked)" << endl
+ << "scan_group (peeked);"
+ << "scan_.peek ();"
+ << "// Return unescaped." << endl
+ << "return arg_[i_].c_str ();"
+ << "}"
+
+ << "const char* group_scanner::" << endl
+ << "next ()"
+ << "{"
+ << "if (state_ != peeked)" << endl
+ << "scan_group (peeked);"
+ << "scan_.next ();"
+ << "scan_group (scanned);"
+ << "// Return unescaped." << endl
+ << "return arg_[i_].c_str ();"
+ << "}"
+
+ << "void group_scanner::" << endl
+ << "skip ()"
+ << "{"
+ << "if (state_ != peeked)" << endl
+ << "scan_group (peeked);"
+ << "scan_.skip ();"
+ << "scan_group (skipped);"
+ << "}"
+
+ << "void group_scanner::" << endl
+ << "scan_group (state st)"
+ << "{"
+ << "// If the previous argument has been scanned, then make" << endl
+ << "// sure the group has been scanned (handled) as well." << endl
+ << "//" << endl
+ << "if (state_ == scanned)"
+ << "{"
+ << "if (group_scan_.end () != group_.size ())" << endl
+ << "throw unexpected_group (arg_[i_], group_scan_.next ());"
+ << "}"
+
+ << "if (state_ != peeked)"
+ << "{"
+ << "arg_[i_ == 0 ? ++i_ : --i_].clear ();"
+ << "group_.clear ();"
+ << "group_scan_.reset ();"
+ << "}"
+
+ << "// We recognize all group sequences both before and " << endl
+ << "// after the argument and diagnose any misuse. We may" << endl
+ << "// also have multiple groups:" << endl
+ << "//" << endl
+ << "// { -x }+ { -y }+ arg" << endl
+ << "//" << endl
+ << endl
+ << "// Using group_ won't cover empty groups." << endl
+ << "//" << endl
+ << "bool g (false);"
+ << endl
+ << "while (scan_.more ())"
+ << "{"
+ << "const char* a (scan_.peek ());"
+ << "size_t i (*a == '\\\\' ? 1 : 0);"
+ << "separator s (sense (a + i));"
+ << endl
+ << "if (s == none || i != 0)"
+ << "{"
+ << "if (state_ != peeked)" << endl
+ << "arg_[i_] = a + (s != none ? i : 0);"
+ << "break;"
+ << "}"
+
+ << "// Start of a leading group for the next argument." << endl
+ << "//" << endl
+ << "if (s == open && state_ == peeked)" << endl
+ << "break;"
+ << endl
+ << "if (s != (state_ == peeked ? open_plus : open))" << endl
+ << "throw group_separator (a, \"\");"
+ << endl
+ << "g = true;"
+ << endl
+ << "// Scan the group until the closing separator." << endl
+ << "//" << endl
+ << "scan_.next ();"
+ << "s = none;"
+ << "while (s == none && scan_.more ())"
+ << "{"
+ << "a = scan_.next ();"
+ << "i = (*a == '\\\\' ? 1 : 0);"
+ << "s = sense (a + i);"
+ << endl
+ << "if (s == none || i != 0)"
+ << "{"
+ << "group_.push_back (a + (s != none ? i : 0));"
+ << "s = none;"
+ << "}"
+ << "}"
+
+ << "if (s != (state_ == peeked ? close : close_plus))"
+ << "{"
+ << "throw group_separator ((s != none ? a : \"\")," << endl
+ << "(state_ == peeked ? \"}\" : \"}+\"));"
+ << "}"
+ << "}"
+
+ << "// Handle the case where we have seen the leading group" << endl
+ << "// but there are no more arguments." << endl
+ << "//" << endl
+ << "if (g && state_ != peeked && !scan_.more ())" << endl
+ << "throw group_separator (\"{\", \"\");"
+ << endl
+ << "state_ = st;"
+ << "}";
+ }
+
+ // Option description.
+ //
+ if (ctx.options.generate_description ())
+ {
+ // options
+ //
+ os << "void options::" << endl
+ << "push_back (const option& o)"
+ << "{"
+ << "container_type::size_type n (size ());"
+ << "container_type::push_back (o);"
+ << "map_[o.name ()] = n;"
+ << endl
+ << "for (option_names::const_iterator i (o.aliases ().begin ());" << endl
+ << "i != o.aliases ().end (); ++i)" << endl
+ << "map_[*i] = n;"
+ << "}";
+ }
+ }
+
+ // To reduce the number of standard headers we have to include in the
+ // generated header file, we always generate the following templates
+ // in the source file.
+ //
+ bool sp (ctx.gen_specifier);
+ bool gen_merge (ctx.gen_merge);
+
+ // parser class template & its specializations
+ //
+ os << "template <typename X>" << endl
+ << "struct parser"
+ << "{";
+
+ os << "static void" << endl
+ << "parse (X& x, " << (sp ? "bool& xs, " : "") << "scanner& s)"
+ << "{"
+ << "using namespace std;"
+ << endl
+ << "const char* o (s.next ());"
+ << "if (s.more ())"
+ << "{"
+ << "string v (s.next ());"
+ << "istringstream is (v);"
+ << "if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))" << endl
+ << "throw invalid_value (o, v);"
+ << "}"
+ << "else" << endl
+ << "throw missing_value (o);";
+ if (sp)
+ os << endl
+ << "xs = true;";
+ os << "}";
+
+ if (gen_merge)
+ os << "static void" << endl
+ << "merge (X& b, const X& a)"
+ << "{"
+ << "b = a;"
+ << "}";
+
+ os << "};";
+
+ // parser<bool>
+ //
+ os << "template <>" << endl
+ << "struct parser<bool>"
+ << "{";
+
+ os << "static void" << endl
+ << "parse (bool& x, scanner& s)"
+ << "{"
+ << "s.next ();"
+ << "x = true;"
+ << "}";
+
+ if (gen_merge)
+ os << "static void" << endl
+ << "merge (bool& b, const bool&)"
+ << "{"
+ << "b = true;" // We wouldn't be here if a is false.
+ << "}";
+
+ os << "};";
+
+ // parser<string>
+ //
+ os << "template <>" << endl
+ << "struct parser<std::string>"
+ << "{";
+
+ os << "static void" << endl
+ << "parse (std::string& x, " << (sp ? "bool& xs, " : "") << "scanner& s)"
+ << "{"
+ << "const char* o (s.next ());"
+ << endl
+ << "if (s.more ())" << endl
+ << "x = s.next ();"
+ << "else" << endl
+ << "throw missing_value (o);";
+ if (sp)
+ os << endl
+ << "xs = true;";
+ os << "}";
+
+ if (gen_merge)
+ os << "static void" << endl
+ << "merge (std::string& b, const std::string& a)"
+ << "{"
+ << "b = a;"
+ << "}";
+
+ os << "};";
+
+ // parser<std::vector<X>>
+ //
+ os << "template <typename X>" << endl
+ << "struct parser<std::vector<X> >"
+ << "{";
+
+ os << "static void" << endl
+ << "parse (std::vector<X>& c, " << (sp ? "bool& xs, " : "") << "scanner& s)"
+ << "{"
+ << "X x;";
+ if (sp)
+ os << "bool dummy;";
+ os << "parser<X>::parse (x, " << (sp ? "dummy, " : "") << "s);"
+ << "c.push_back (x);";
+ if (sp)
+ os << "xs = true;";
+ os << "}";
+
+ if (gen_merge)
+ os << "static void" << endl
+ << "merge (std::vector<X>& b, const std::vector<X>& a)"
+ << "{"
+ << "b.insert (b.end (), a.begin (), a.end ());"
+ << "}";
+
+ os << "};";
+
+ // parser<std::set<X>>
+ //
+ os << "template <typename X>" << endl
+ << "struct parser<std::set<X> >"
+ << "{";
+
+ os << "static void" << endl
+ << "parse (std::set<X>& c, " << (sp ? "bool& xs, " : "") << "scanner& s)"
+ << "{"
+ << "X x;";
+ if (sp)
+ os << "bool dummy;";
+ os << "parser<X>::parse (x, " << (sp ? "dummy, " : "") << "s);"
+ << "c.insert (x);";
+ if (sp)
+ os << "xs = true;";
+ os << "}";
+
+ if (gen_merge)
+ os << "static void" << endl
+ << "merge (std::set<X>& b, const std::set<X>& a)"
+ << "{"
+ << "b.insert (a.begin (), a.end ());"
+ << "}";
+
+ os << "};";
+
+ // parser<std::map<K,V>>
+ //
+ os << "template <typename K, typename V>" << endl
+ << "struct parser<std::map<K, V> >"
+ << "{";
+
+ os << "static void" << endl
+ << "parse (std::map<K, V>& m, " << (sp ? "bool& xs, " : "") << "scanner& s)"
+ << "{"
+ << "const char* o (s.next ());"
+ << endl
+ << "if (s.more ())"
+ << "{"
+ << "std::string ov (s.next ());"
+ << "std::string::size_type p = ov.find ('=');"
+ << endl
+ << "K k = K ();"
+ << "V v = V ();"
+ << "std::string kstr (ov, 0, p);"
+ << "std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));"
+ << endl
+ << "int ac (2);"
+ << "char* av[] = {const_cast<char*> (o), 0};";
+ if (sp)
+ os << "bool dummy;";
+ os << "if (!kstr.empty ())"
+ << "{"
+ << "av[1] = const_cast<char*> (kstr.c_str ());"
+ << "argv_scanner s (0, ac, av);"
+ << "parser<K>::parse (k, " << (sp ? "dummy, " : "") << "s);"
+ << "}"
+ << "if (!vstr.empty ())"
+ << "{"
+ << "av[1] = const_cast<char*> (vstr.c_str ());"
+ << "argv_scanner s (0, ac, av);"
+ << "parser<V>::parse (v, " << (sp ? "dummy, " : "") << "s);"
+ << "}"
+ << "m[k] = v;"
+ << "}"
+ << "else" << endl
+ << "throw missing_value (o);";
+ if (sp)
+ os << endl
+ << "xs = true;";
+ os << "}";
+
+ if (gen_merge)
+ os << "static void" << endl
+ << "merge (std::map<K, V>& b, const std::map<K, V>& a)"
+ << "{"
+ << "for (typename std::map<K, V>::const_iterator i (a.begin ()); " << endl
+ << "i != a.end (); " << endl
+ << "++i)" << endl
+ << "b[i->first] = i->second;"
+ << "}";
+
+ os << "};";
+
+ // Parser thunk.
+ //
+ os << "template <typename X, typename T, T X::*M>" << endl
+ << "void" << endl
+ << "thunk (X& x, scanner& s)"
+ << "{"
+ << "parser<T>::parse (x.*M, s);"
+ << "}";
+
+ if (ctx.gen_specifier)
+ os << "template <typename X, typename T, T X::*M, bool X::*S>" << endl
+ << "void" << endl
+ << "thunk (X& x, scanner& s)"
+ << "{"
+ << "parser<T>::parse (x.*M, x.*S, s);"
+ << "}";
+
+ ctx.ns_close (ctx.cli);
+}
generated by cgit v1.1 at 2024-04-26 22:37:12 +0000