From 861c18230d1597c77bb1659b220dd6dfc564b8f2 Mon Sep 17 00:00:00 2001
From: Karen Arutyunov <karen@codesynthesis.com>
Date: Mon, 20 Mar 2023 16:29:51 +0300
Subject: Regenerate options parsing files

---
 libbuild2/b-options.cxx                    | 60 ++++++++++++++++++++++++++++++
 libbuild2/build/script/builtin-options.cxx | 50 +++++++++++++++++++++++++
 libbuild2/common-options.cxx               | 50 +++++++++++++++++++++++++
 libbuild2/script/builtin-options.cxx       | 50 +++++++++++++++++++++++++
 4 files changed, 210 insertions(+)

diff --git a/libbuild2/b-options.cxx b/libbuild2/b-options.cxx
index 1fa801a..9cdfd1b 100644
--- a/libbuild2/b-options.cxx
+++ b/libbuild2/b-options.cxx
@@ -233,6 +233,66 @@ namespace build2
         }
       };
 
+      template <typename K, typename V, typename C>
+      struct parser<std::multimap<K, V, C> >
+      {
+        static void
+        parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+        {
+          const char* o (s.next ());
+
+          if (s.more ())
+          {
+            std::size_t pos (s.position ());
+            std::string ov (s.next ());
+            std::string::size_type p = ov.find ('=');
+
+            K k = K ();
+            V v = V ();
+            std::string kstr (ov, 0, p);
+            std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (o),
+              0
+            };
+
+            bool dummy;
+            if (!kstr.empty ())
+            {
+              av[1] = const_cast<char*> (kstr.c_str ());
+              argv_scanner s (0, ac, av, false, pos);
+              parser<K>::parse (k, dummy, s);
+            }
+
+            if (!vstr.empty ())
+            {
+              av[1] = const_cast<char*> (vstr.c_str ());
+              argv_scanner s (0, ac, av, false, pos);
+              parser<V>::parse (v, dummy, s);
+            }
+
+            m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+          }
+          else
+            throw missing_value (o);
+
+          xs = true;
+        }
+
+        static void
+        merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+        {
+          for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+               i != a.end (); 
+               ++i)
+            b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                   i->second));
+        }
+      };
+
       template <typename X, typename T, T X::*M>
       void
       thunk (X& x, scanner& s)
diff --git a/libbuild2/build/script/builtin-options.cxx b/libbuild2/build/script/builtin-options.cxx
index f7ba0e7..9e4213d 100644
--- a/libbuild2/build/script/builtin-options.cxx
+++ b/libbuild2/build/script/builtin-options.cxx
@@ -188,6 +188,56 @@ namespace build2
         }
       };
 
+      template <typename K, typename V, typename C>
+      struct parser<std::multimap<K, V, C> >
+      {
+        static void
+        parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+        {
+          const char* o (s.next ());
+
+          if (s.more ())
+          {
+            std::size_t pos (s.position ());
+            std::string ov (s.next ());
+            std::string::size_type p = ov.find ('=');
+
+            K k = K ();
+            V v = V ();
+            std::string kstr (ov, 0, p);
+            std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (o),
+              0
+            };
+
+            bool dummy;
+            if (!kstr.empty ())
+            {
+              av[1] = const_cast<char*> (kstr.c_str ());
+              argv_scanner s (0, ac, av, false, pos);
+              parser<K>::parse (k, dummy, s);
+            }
+
+            if (!vstr.empty ())
+            {
+              av[1] = const_cast<char*> (vstr.c_str ());
+              argv_scanner s (0, ac, av, false, pos);
+              parser<V>::parse (v, dummy, s);
+            }
+
+            m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+          }
+          else
+            throw missing_value (o);
+
+          xs = true;
+        }
+      };
+
       template <typename X, typename T, T X::*M>
       void
       thunk (X& x, scanner& s)
diff --git a/libbuild2/common-options.cxx b/libbuild2/common-options.cxx
index 4be0289..1580d9c 100644
--- a/libbuild2/common-options.cxx
+++ b/libbuild2/common-options.cxx
@@ -721,6 +721,56 @@ namespace build2
         }
       };
 
+      template <typename K, typename V, typename C>
+      struct parser<std::multimap<K, V, C> >
+      {
+        static void
+        parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+        {
+          const char* o (s.next ());
+
+          if (s.more ())
+          {
+            std::size_t pos (s.position ());
+            std::string ov (s.next ());
+            std::string::size_type p = ov.find ('=');
+
+            K k = K ();
+            V v = V ();
+            std::string kstr (ov, 0, p);
+            std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (o),
+              0
+            };
+
+            bool dummy;
+            if (!kstr.empty ())
+            {
+              av[1] = const_cast<char*> (kstr.c_str ());
+              argv_scanner s (0, ac, av, false, pos);
+              parser<K>::parse (k, dummy, s);
+            }
+
+            if (!vstr.empty ())
+            {
+              av[1] = const_cast<char*> (vstr.c_str ());
+              argv_scanner s (0, ac, av, false, pos);
+              parser<V>::parse (v, dummy, s);
+            }
+
+            m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+          }
+          else
+            throw missing_value (o);
+
+          xs = true;
+        }
+      };
+
       template <typename X, typename T, T X::*M>
       void
       thunk (X& x, scanner& s)
diff --git a/libbuild2/script/builtin-options.cxx b/libbuild2/script/builtin-options.cxx
index 9b4067b..b71b9d3 100644
--- a/libbuild2/script/builtin-options.cxx
+++ b/libbuild2/script/builtin-options.cxx
@@ -187,6 +187,56 @@ namespace build2
         }
       };
 
+      template <typename K, typename V, typename C>
+      struct parser<std::multimap<K, V, C> >
+      {
+        static void
+        parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+        {
+          const char* o (s.next ());
+
+          if (s.more ())
+          {
+            std::size_t pos (s.position ());
+            std::string ov (s.next ());
+            std::string::size_type p = ov.find ('=');
+
+            K k = K ();
+            V v = V ();
+            std::string kstr (ov, 0, p);
+            std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (o),
+              0
+            };
+
+            bool dummy;
+            if (!kstr.empty ())
+            {
+              av[1] = const_cast<char*> (kstr.c_str ());
+              argv_scanner s (0, ac, av, false, pos);
+              parser<K>::parse (k, dummy, s);
+            }
+
+            if (!vstr.empty ())
+            {
+              av[1] = const_cast<char*> (vstr.c_str ());
+              argv_scanner s (0, ac, av, false, pos);
+              parser<V>::parse (v, dummy, s);
+            }
+
+            m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+          }
+          else
+            throw missing_value (o);
+
+          xs = true;
+        }
+      };
+
       template <typename X, typename T, T X::*M>
       void
       thunk (X& x, scanner& s)
-- 
cgit v1.1