New upstream release

116 files changed, 14455 insertions, 6556 deletions

diff --git a/xsd/xsd/cxx/elements.cxx b/xsd/xsd/cxx/elements.cxx
index d2600dc..dfa2f38 100644
--- a/xsd/xsd/cxx/elements.cxx
+++ b/xsd/xsd/cxx/elements.cxx
@@ -1,16 +1,14 @@
 // file      : xsd/cxx/elements.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/elements.hxx>
 
-#include <backend-elements/regex.hxx>
-
 #include <cctype>    // std::toupper
 #include <memory>
 #include <sstream>
 #include <fstream>
+#include <cassert>
 #include <iostream>
 
 using std::wcerr;
@@ -28,7 +26,7 @@ namespace CXX
 
   namespace
   {
-    WideChar const* keywords[] = {
+    wchar_t const* keywords[] = {
       L"NULL",
       L"and",
       L"asm",
@@ -114,55 +112,47 @@ namespace CXX
   Context (std::wostream& o,
            SemanticGraph::Schema& root,
            SemanticGraph::Path const& path,
-           StringLiteralMap const* string_literal_map_,
-           NarrowString const& char_type__,
-           NarrowString const& char_encoding__,
-           Boolean include_with_brackets__,
-           NarrowString const& include_prefix__,
-           NarrowString const& esymbol,
-           Containers::Vector<NarrowString> const& nsm,
-           Containers::Vector<NarrowString> const& nsr,
-           Boolean trace_namespace_regex_,
-           Containers::Vector<NarrowString> const& ir,
-           Boolean trace_include_regex_,
-           Boolean inline_,
-           Containers::Vector<NarrowString> const& reserved_name)
+           options_type const& ops,
+           StringLiteralMap const* string_literal_map_)
       : os (o),
         schema_root (root),
         schema_path (schema_path_),
+        options (ops),
+        std (ops.std ()),
         char_type (char_type_),
         char_encoding (char_encoding_),
         L (L_),
         string_type (string_type_),
+        auto_ptr (auto_ptr_),
         string_literal_map (string_literal_map_),
-        include_with_brackets (include_with_brackets_),
-        include_prefix (include_prefix_),
         type_exp (type_exp_),
         inst_exp (inst_exp_),
         inl (inl_),
         ns_mapping_cache (ns_mapping_cache_),
         schema_path_ (path),
         xs_ns_ (0),
-        char_type_ (char_type__),
-        char_encoding_ (char_encoding__),
+        char_type_ (ops.char_type ()),
+        char_encoding_ (ops.char_encoding ()),
         L_ (char_type == L"wchar_t" ? L"L" : L""),
-        include_with_brackets_ (include_with_brackets__),
-        include_prefix_ (include_prefix__),
-        type_exp_ (esymbol ? esymbol + " " : esymbol),
-        inst_exp_ (esymbol ? esymbol + "\n" : esymbol),
-        inl_ (inline_ ? L"inline\n" : L""),
+        inl_ (ops.generate_inline () ? L"inline\n" : L""),
         cxx_id_expr_ (L"^(::)?([a-zA-Z_]\\w*)(::[a-zA-Z_]\\w*)*$"),
         cxx_id_expr (cxx_id_expr_),
-        trace_namespace_regex (trace_namespace_regex_),
         urn_mapping_ (L"#^urn.*:([a-zA-Z_].*)$#$1#"),
         urn_mapping (urn_mapping_),
         nsr_mapping (nsr_mapping_),
         nsm_mapping (nsm_mapping_),
         include_mapping (include_mapping_),
-        trace_include_regex (trace_include_regex_),
         reserved_name_map (reserved_name_map_),
         keyword_set (keyword_set_)
   {
+    // Export symbol.
+    //
+    {
+      String es (ops.export_symbol ());
+      type_exp_ = es ? es + L" " : es;
+      inst_exp_ = es ? es + L"\n" : es;
+    }
+
     // Resolve and cache XML Schema namespace.
     //
     {
@@ -196,6 +186,12 @@ namespace CXX
     else
       string_type_ = L"::std::basic_string< " + char_type + L" >";
 
+    // Automatic pointer type.
+    //
+    auto_ptr_ = std >= cxx_version::cxx11
+      ? "::std::unique_ptr"
+      : "::std::auto_ptr";
+
     // Default encoding.
     //
     if (!char_encoding)
@@ -209,28 +205,28 @@ namespace CXX
     // Default mapping.
     //
     nsr_mapping_.push_back (
-      Regex (L"#^.* (.*?/)??"L"(([a-zA-Z_]\\w*)(/[a-zA-Z_]\\w*)*)/?$#$2#"));
+      Regex (L"#^.* (.*?/)??" L"(([a-zA-Z_]\\w*)(/[a-zA-Z_]\\w*)*)/?$#$2#"));
     nsr_mapping_.push_back (
       Regex (L"#^.* http://www\\.w3\\.org/2001/XMLSchema$#xml_schema#"));
 
     // Custom regex mapping.
     //
-    for (Containers::Vector<NarrowString>::ConstIterator
-           i (nsr.begin ()), e (nsr.end ()); i != e; ++i)
+    for (NarrowStrings::const_iterator i (ops.namespace_regex ().begin ()),
+           e (ops.namespace_regex ().end ()); i != e; ++i)
     {
-      nsr_mapping_.push_back (Regex (*i));
+      nsr_mapping_.push_back (Regex (String (*i)));
     }
 
     // Custom direct mapping.
     //
-    for (Containers::Vector<NarrowString>::ConstIterator
-           i (nsm.begin ()), e (nsm.end ()); i != e; ++i)
+    for (NarrowStrings::const_iterator i (ops.namespace_map ().begin ()),
+           e (ops.namespace_map ().end ()); i != e; ++i)
     {
       String s (*i);
 
       // Split the string in two parts at the last '='.
       //
-      Size pos (s.rfind ('='));
+      size_t pos (s.rfind ('='));
 
       if (pos == String::npos)
         throw InvalidNamespaceMapping (s, "delimiter ('=') not found");
@@ -248,22 +244,22 @@ namespace CXX
 
     // Include path regex
     //
-    for (Containers::Vector<NarrowString>::ConstIterator
-           i (ir.begin ()), e (ir.end ()); i != e; ++i)
+    for (NarrowStrings::const_iterator i (ops.include_regex ().begin ()),
+           e (ops.include_regex ().end ()); i != e; ++i)
     {
-      include_mapping_.push_back (Regex (*i));
+      include_mapping_.push_back (Regex (String (*i)));
     }
 
     // Reserved names.
     //
-    for (Containers::Vector<NarrowString>::ConstIterator
-           i (reserved_name.begin ()), e (reserved_name.end ()); i != e; ++i)
+    for (NarrowStrings::const_iterator i (ops.reserved_name ().begin ()),
+           e (ops.reserved_name ().end ()); i != e; ++i)
     {
       String s (*i);
 
       // Split the string in two parts at '='.
       //
-      Size pos (s.find ('='));
+      size_t pos (s.find ('='));
 
       if (pos == String::npos)
         reserved_name_map_[s] = L"";
@@ -273,7 +269,7 @@ namespace CXX
 
     // Populate the keyword set.
     //
-    for (Size i (0); i < sizeof (keywords) / sizeof (char*); ++i)
+    for (size_t i (0); i < sizeof (keywords) / sizeof (char*); ++i)
       keyword_set_.insert (keywords[i]);
   }
 
@@ -287,7 +283,7 @@ namespace CXX
     using SemanticGraph::Sources;
 
     String tmp;
-    MapMapping::ConstIterator i (nsm_mapping.find (ns.name ()));
+    MapMapping::const_iterator i (nsm_mapping.find (ns.name ()));
 
     if (i != nsm_mapping.end ())
     {
@@ -317,20 +313,18 @@ namespace CXX
 
       if (!path.empty ())
       {
+        path.normalize ();
+
         // Try to use the portable representation of the path. If that
         // fails, fall back to the native representation.
         //
         try
         {
-          pair = path.string ();
+          pair = path.posix_string ();
         }
         catch (SemanticGraph::InvalidPath const&)
         {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-          pair = path.native_file_string ();
-#else
           pair = path.string ();
-#endif
         }
       }
 
@@ -338,7 +332,7 @@ namespace CXX
 
       // Check cache first
       //
-      MappingCache::ConstIterator i (ns_mapping_cache.find (pair));
+      MappingCache::const_iterator i (ns_mapping_cache.find (pair));
 
       if (i != ns_mapping_cache.end ())
       {
@@ -346,32 +340,34 @@ namespace CXX
       }
       else
       {
-        if (trace_namespace_regex)
+        bool trace (options.namespace_regex_trace ());
+
+        if (trace)
           wcerr << "namespace: '" << pair << "'" << endl;
 
-        Boolean found (false);
+        bool found (false);
         Regex colon (L"#/#::#");
 
-        for (RegexMapping::ConstReverseIterator e (nsr_mapping.rbegin ());
+        for (RegexMapping::const_reverse_iterator e (nsr_mapping.rbegin ());
              e != nsr_mapping.rend (); ++e)
         {
-          if (trace_namespace_regex)
-            wcerr << "try: '" << e->pattern () << "' : ";
+          if (trace)
+            wcerr << "try: '" << e->regex () << "' : ";
 
           if (e->match (pair))
           {
-            tmp = e->merge (pair);
-            tmp = colon.merge (tmp); // replace `/' with `::'
+            tmp = e->replace (pair);
+            tmp = colon.replace (tmp); // replace `/' with `::'
 
             // Check the result.
             //
             found = cxx_id_expr.match (tmp);
 
-            if (trace_namespace_regex)
+            if (trace)
               wcerr << "'" << tmp << "' : ";
           }
 
-          if (trace_namespace_regex)
+          if (trace)
             wcerr << (found ? '+' : '-') << endl;
 
           if (found)
@@ -392,7 +388,7 @@ namespace CXX
           }
           else
           {
-            tmp = colon.merge (n); // replace `/' with `::'
+            tmp = colon.replace (n); // replace `/' with `::'
 
             if (!cxx_id_expr.match (tmp))
             {
@@ -401,8 +397,8 @@ namespace CXX
               if (urn_mapping.match (n))
               {
                 Regex filter (L"#[.:-]#_#");
-                tmp = urn_mapping.merge (n);
-                tmp = filter.merge (tmp);
+                tmp = urn_mapping.replace (n);
+                tmp = filter.replace (tmp);
 
                 if (!cxx_id_expr.match (tmp))
                   throw NoNamespaceMapping (
@@ -496,7 +492,7 @@ namespace CXX
   }
 
   String Context::
-  fq_name (SemanticGraph::Nameable& n, Char const* name_key)
+  fq_name (SemanticGraph::Nameable& n, char const* name_key)
   {
     using namespace SemanticGraph;
 
@@ -548,17 +544,17 @@ namespace CXX
   escape (String const& name)
   {
     String r;
-    Size n (name.size ());
+    size_t n (name.size ());
 
     // In most common cases we will have that many chars.
     //
     r.reserve (n);
 
-    for (Size i (0); i < n; ++i)
+    for (size_t i (0); i < n; ++i)
     {
-      Boolean first (i == 0);
+      bool first (i == 0);
 
-      UnsignedLong u (unicode_char (name, i)); // May advance i.
+      unsigned int u (unicode_char (name, i)); // May advance i.
 
       if (first)
       {
@@ -574,7 +570,7 @@ namespace CXX
             u == '_'))
         r.push_back ('_');
       else
-        r.push_back (static_cast<WideChar> (u));
+        r.push_back (static_cast<wchar_t> (u));
     }
 
     if (r.empty ())
@@ -582,7 +578,7 @@ namespace CXX
 
     // Custom reserved words.
     //
-    ReservedNameMap::ConstIterator i (reserved_name_map.find (r));
+    ReservedNameMap::const_iterator i (reserved_name_map.find (r));
 
     if (i != reserved_name_map.end ())
     {
@@ -618,14 +614,14 @@ namespace CXX
   //
 
   String
-  charlit (UnsignedLong u)
+  charlit (unsigned int u)
   {
     String r ("\\x");
-    Boolean lead (true);
+    bool lead (true);
 
-    for (Long i (7); i >= 0; --i)
+    for (int i (7); i >= 0; --i)
     {
-      UnsignedLong x ((u >> (i * 4)) & 0x0F);
+      unsigned int x ((u >> (i * 4)) & 0x0F);
 
       if (lead)
       {
@@ -645,7 +641,7 @@ namespace CXX
   strlit_ascii (String const& str)
   {
     String r;
-    Size n (str.size ());
+    size_t n (str.size ());
 
     // In most common cases we will have that many chars.
     //
@@ -653,11 +649,11 @@ namespace CXX
 
     r += '"';
 
-    Boolean escape (false);
+    bool escape (false);
 
-    for (Size i (0); i < n; ++i)
+    for (size_t i (0); i < n; ++i)
     {
-      UnsignedLong u (Context::unicode_char (str, i)); // May advance i.
+      unsigned int u (Context::unicode_char (str, i)); // May advance i.
 
       // [128 - ]     - unrepresentable
       // 127          - \x7F
@@ -738,7 +734,7 @@ namespace CXX
           }
         default:
           {
-            r += static_cast<WideChar> (u);
+            r += static_cast<wchar_t> (u);
             break;
           }
         }
@@ -756,7 +752,7 @@ namespace CXX
     return r;
   }
 
-  const UnsignedLong utf8_first_char_mask[5] =
+  const unsigned int utf8_first_char_mask[5] =
   {
     0x00, 0x00, 0xC0, 0xE0, 0xF0
   };
@@ -765,7 +761,7 @@ namespace CXX
   strlit_utf8 (String const& str)
   {
     String r;
-    Size n (str.size ());
+    size_t n (str.size ());
 
     // In most common cases we will have that many chars.
     //
@@ -773,11 +769,11 @@ namespace CXX
 
     r += '"';
 
-    Boolean escape (false);
+    bool escape (false);
 
-    for (Size i (0); i < n; ++i)
+    for (size_t i (0); i < n; ++i)
     {
-      UnsignedLong u (Context::unicode_char (str, i)); // May advance i.
+      unsigned int u (Context::unicode_char (str, i)); // May advance i.
 
       // [128 - ]     - UTF-8
       // 127          - \x7F
@@ -858,15 +854,15 @@ namespace CXX
           }
         default:
           {
-            r += static_cast<WideChar> (u);
+            r += static_cast<wchar_t> (u);
             break;
           }
         }
       }
       else
       {
-        UnsignedLong count;
-        UnsignedLong tmp[4];
+        unsigned int count (0);
+        unsigned int tmp[4];
 
         if (u < 0x800)
           count = 2;
@@ -895,10 +891,13 @@ namespace CXX
         case 1:
           {
             tmp[0] = u | utf8_first_char_mask[count];
+            break;
           }
+        default:
+          assert (false);
         }
 
-        for (UnsignedLong j (0); j < count; ++j)
+        for (unsigned int j (0); j < count; ++j)
           r += charlit (tmp[j]);
 
         escape = true;
@@ -914,7 +913,7 @@ namespace CXX
   strlit_iso8859_1 (String const& str)
   {
     String r;
-    Size n (str.size ());
+    size_t n (str.size ());
 
     // In most common cases we will have that many chars.
     //
@@ -922,11 +921,11 @@ namespace CXX
 
     r += '"';
 
-    Boolean escape (false);
+    bool escape (false);
 
-    for (Size i (0); i < n; ++i)
+    for (size_t i (0); i < n; ++i)
     {
-      UnsignedLong u (Context::unicode_char (str, i)); // May advance i.
+      unsigned int u (Context::unicode_char (str, i)); // May advance i.
 
       // [256 -    ]  - unrepresentable
       // [127 - 255]  - \xXX
@@ -1007,7 +1006,7 @@ namespace CXX
           }
         default:
           {
-            r += static_cast<WideChar> (u);
+            r += static_cast<wchar_t> (u);
             break;
           }
         }
@@ -1034,7 +1033,7 @@ namespace CXX
   strlit_utf32 (String const& str)
   {
     String r;
-    Size n (str.size ());
+    size_t n (str.size ());
 
     // In most common cases we will have that many chars.
     //
@@ -1042,11 +1041,11 @@ namespace CXX
 
     r += L"L\"";
 
-    Boolean escape (false);
+    bool escape (false);
 
-    for (Size i (0); i < n; ++i)
+    for (size_t i (0); i < n; ++i)
     {
-      UnsignedLong u (Context::unicode_char (str, i)); // May advance i.
+      unsigned int u (Context::unicode_char (str, i)); // May advance i.
 
       // [128 - ]     - \xUUUUUUUU
       // 127          - \x7F
@@ -1105,9 +1104,10 @@ namespace CXX
       {
         if (escape)
         {
-          // Close and open the string so there are no clashes.
+          // Close and open the string so there are no clashes. C++11
+          // requires a space between " and L.
           //
-          r += L"\"L\"";
+          r += L"\" L\"";
           escape = false;
         }
 
@@ -1125,7 +1125,7 @@ namespace CXX
           }
         default:
           {
-            r += static_cast<WideChar> (u);
+            r += static_cast<wchar_t> (u);
             break;
           }
         }
@@ -1148,7 +1148,7 @@ namespace CXX
     // First see if we have a custom mapping.
     //
     assert (string_literal_map != 0);
-    StringLiteralMap::ConstIterator i (string_literal_map->find (str));
+    StringLiteralMap::const_iterator i (string_literal_map->find (str));
 
     if (i != string_literal_map->end ())
       return i->second;
@@ -1175,16 +1175,16 @@ namespace CXX
   {
     String r;
 
-    WideChar const* s (str.c_str ());
-    Size size (str.size ());
+    wchar_t const* s (str.c_str ());
+    size_t size (str.size ());
 
     // In most common cases we will have that many chars.
     //
     r.reserve (size);
 
-    for (WideChar const* p (s); p < s + size; ++p)
+    for (wchar_t const* p (s); p < s + size; ++p)
     {
-      UnsignedLong u (unicode_char (p)); // May advance p.
+      unsigned int u (unicode_char (p)); // May advance p.
 
       // We are going to treat \v, \f and \n as unrepresentable
       // here even though they can be present in C++ source code.
@@ -1192,7 +1192,7 @@ namespace CXX
       if (u > 127 || (u < 32 && u != '\t'))
         r += L'?';
       else
-        r += static_cast<WideChar> (u);
+        r += static_cast<wchar_t> (u);
     }
 
     return r;
@@ -1201,30 +1201,31 @@ namespace CXX
   String Context::
   process_include_path (String const& name) const
   {
-    String path (include_prefix + name);
+    String path (String (options.include_prefix ()) + name);
+    bool trace (options.include_regex_trace ());
 
-    if (trace_include_regex)
+    if (trace)
       wcerr << "include: '" << path << "'" << endl;
 
     String r;
-    Boolean found (false);
+    bool found (false);
 
-    for (RegexMapping::ConstReverseIterator e (include_mapping.rbegin ());
+    for (RegexMapping::const_reverse_iterator e (include_mapping.rbegin ());
          e != include_mapping.rend (); ++e)
     {
-      if (trace_include_regex)
-        wcerr << "try: '" << e->pattern () << "' : ";
+      if (trace)
+        wcerr << "try: '" << e->regex () << "' : ";
 
       if (e->match (path))
       {
-        r = e->merge (path);
+        r = e->replace (path);
         found = true;
 
-        if (trace_include_regex)
+        if (trace)
           wcerr << "'" << r << "' : ";
       }
 
-      if (trace_include_regex)
+      if (trace)
         wcerr << (found ? '+' : '-') << endl;
 
       if (found)
@@ -1236,8 +1237,8 @@ namespace CXX
 
     if (!r.empty () && r[0] != L'"' && r[0] != L'<')
     {
-      WideChar op (include_with_brackets ? L'<' : L'"');
-      WideChar cl (include_with_brackets ? L'>' : L'"');
+      wchar_t op (options.include_with_brackets () ? L'<' : L'"');
+      wchar_t cl (options.include_with_brackets () ? L'>' : L'"');
       r = op + r + cl;
     }
 
@@ -1247,7 +1248,7 @@ namespace CXX
   // Namespace
   //
 
-  Void Namespace::
+  void Namespace::
   pre (Type& n)
   {
     String ns (ctx_.ns_name (n));
@@ -1281,7 +1282,7 @@ namespace CXX
     } while (true);
   }
 
-  Void Namespace::
+  void Namespace::
   post (Type& n)
   {
     String ns (ctx_.ns_name (n));
diff --git a/xsd/xsd/cxx/elements.hxx b/xsd/xsd/cxx/elements.hxx
index 59938c5..4b36da9 100644
--- a/xsd/xsd/cxx/elements.hxx
+++ b/xsd/xsd/cxx/elements.hxx
@@ -1,31 +1,29 @@
 // file      : xsd/cxx/elements.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_ELEMENTS_HXX
 #define CXX_ELEMENTS_HXX
 
+#include <set>
+#include <map>
+#include <vector>
 #include <ostream>
 
-#include <cult/types.hxx>
-#include <cult/containers/set.hxx>
-#include <cult/containers/map.hxx>
-#include <cult/containers/vector.hxx>
-
-#include <backend-elements/regex.hxx>
+#include <cutl/re.hxx>
 
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
 
+#include <types.hxx>
 #include <elements.hxx>
+
+#include <cxx/options.hxx>
 #include <cxx/literal-map.hxx>
 
 namespace CXX
 {
   using std::endl;
-  typedef WideString String;
-
 
   // On some platforms std::toupper can be something other than a
   // function with C++ linkage.
@@ -39,7 +37,7 @@ namespace CXX
 
   struct UnrepresentableCharacter
   {
-    UnrepresentableCharacter (String const& str, Size pos)
+    UnrepresentableCharacter (String const& str, size_t pos)
         : str_ (str), pos_ (pos)
     {
     }
@@ -50,7 +48,7 @@ namespace CXX
       return str_;
     }
 
-    Size
+    size_t
     position () const
     {
       return pos_;
@@ -58,14 +56,14 @@ namespace CXX
 
   private:
     String str_;
-    Size pos_;
+    size_t pos_;
   };
 
   struct NoNamespaceMapping
   {
     NoNamespaceMapping (SemanticGraph::Path const& file,
-                        UnsignedLong line,
-                        UnsignedLong column,
+                        size_t line,
+                        size_t column,
                         String const& ns)
         : file_ (file),
           line_ (line),
@@ -81,13 +79,13 @@ namespace CXX
       return file_;
     }
 
-    UnsignedLong
+    size_t
     line () const
     {
       return line_;
     }
 
-    UnsignedLong
+    size_t
     column () const
     {
       return column_;
@@ -101,8 +99,8 @@ namespace CXX
 
   private:
     SemanticGraph::Path file_;
-    UnsignedLong line_;
-    UnsignedLong column_;
+    size_t line_;
+    size_t column_;
     String ns_;
   };
 
@@ -136,57 +134,47 @@ namespace CXX
   class Context
   {
   public:
-    typedef BackendElements::Regex::Pattern<WideChar> RegexPat;
-    typedef BackendElements::Regex::Expression<WideChar> Regex;
-    typedef Cult::Containers::Vector<Regex> RegexMapping;
-    typedef Cult::Containers::Map<String, String> MapMapping;
-    typedef Cult::Containers::Map<String, String> MappingCache;
+    typedef cutl::re::wregex RegexPat;
+    typedef cutl::re::wregexsub Regex;
+    typedef std::vector<Regex> RegexMapping;
+    typedef std::map<String, String> MapMapping;
+    typedef std::map<String, String> MappingCache;
 
-    typedef Cult::Containers::Map<String, String> ReservedNameMap;
-    typedef Cult::Containers::Set<String> KeywordSet;
+    typedef std::map<String, String> ReservedNameMap;
+    typedef std::set<String> KeywordSet;
+
+    typedef CXX::options options_type;
 
   public:
     Context (std::wostream& o,
              SemanticGraph::Schema& root,
              SemanticGraph::Path const& path,
-             StringLiteralMap const* custom_literals_map,
-             NarrowString const& char_type__,
-             NarrowString const& char_encoding__,
-             Boolean include_with_brackets__,
-             NarrowString const& include_prefix__,
-             NarrowString const& esymbol,
-             Containers::Vector<NarrowString> const& nsm,
-             Containers::Vector<NarrowString> const& nsr,
-             Boolean trace_namespace_regex_,
-             Containers::Vector<NarrowString> const& include_regex,
-             Boolean trace_include_regex_,
-             Boolean inline_,
-             Containers::Vector<NarrowString> const& reserved_name);
+             options_type const& ops,
+             StringLiteralMap const* custom_literals_map);
 
   protected:
     Context (Context& c)
         : os (c.os),
           schema_root (c.schema_root),
           schema_path (c.schema_path),
+          options (c.options),
+          std (c.std),
           char_type (c.char_type),
           char_encoding (c.char_encoding),
           L (c.L),
           string_type (c.string_type),
+          auto_ptr (c.auto_ptr),
           string_literal_map (c.string_literal_map),
-          include_with_brackets (c.include_with_brackets),
-          include_prefix (c.include_prefix),
           type_exp (c.type_exp),
           inst_exp (c.inst_exp),
           inl (c.inl),
           ns_mapping_cache (c.ns_mapping_cache),
           xs_ns_ (c.xs_ns_),
           cxx_id_expr (c.cxx_id_expr),
-          trace_namespace_regex (c.trace_namespace_regex),
           urn_mapping (c.urn_mapping),
           nsr_mapping (c.nsr_mapping),
           nsm_mapping (c.nsm_mapping),
           include_mapping (c.include_mapping),
-          trace_include_regex (c.trace_include_regex),
           reserved_name_map (c.reserved_name_map),
           keyword_set (c.keyword_set)
     {
@@ -196,25 +184,24 @@ namespace CXX
         : os (o),
           schema_root (c.schema_root),
           schema_path (c.schema_path),
+          options (c.options),
+          std (c.std),
           char_type (c.char_type),
           char_encoding (c.char_encoding),
           L (c.L),
           string_type (c.string_type),
+          auto_ptr (c.auto_ptr),
           string_literal_map (c.string_literal_map),
-          include_with_brackets (c.include_with_brackets),
-          include_prefix (c.include_prefix),
           type_exp (c.type_exp),
           inst_exp (c.inst_exp),
           inl (c.inl),
           ns_mapping_cache (c.ns_mapping_cache),
           xs_ns_ (c.xs_ns_),
           cxx_id_expr (c.cxx_id_expr),
-          trace_namespace_regex (c.trace_namespace_regex),
           urn_mapping (c.urn_mapping),
           nsr_mapping (c.nsr_mapping),
           nsm_mapping (c.nsm_mapping),
           include_mapping (c.include_mapping),
-          trace_include_regex (c.trace_include_regex),
           reserved_name_map (c.reserved_name_map),
           keyword_set (c.keyword_set)
     {
@@ -232,11 +219,11 @@ namespace CXX
     // advanced by 1 if this Unicode character takes more than one
     // underlying character.
     //
-    static UnsignedLong
-    unicode_char (String const& str, Size& pos);
+    static unsigned int
+    unicode_char (String const& str, size_t& pos);
 
-    static UnsignedLong
-    unicode_char (WideChar const*& p);
+    static unsigned int
+    unicode_char (wchar_t const*& p);
 
     // Escape C++ keywords and illegal characters.
     //
@@ -283,7 +270,7 @@ namespace CXX
     // Fully-qualified C++ name.
     //
     String
-    fq_name (SemanticGraph::Nameable& n, Char const* name_key = "name");
+    fq_name (SemanticGraph::Nameable& n, char const* name_key = "name");
 
   public:
     static SemanticGraph::Type&
@@ -294,7 +281,7 @@ namespace CXX
     process_include_path (String const&) const;
 
   public:
-    static Boolean
+    static bool
     skip (SemanticGraph::Member& m)
     {
       // "Subsequent" local element.
@@ -303,28 +290,28 @@ namespace CXX
         m.context ().count ("min") == 0;
     }
 
-    static UnsignedLong
+    static size_t
     min (SemanticGraph::Member const& m)
     {
-      return m.context ().get<UnsignedLong> ("min");
+      return m.context ().get<size_t> ("min");
     }
 
-    static UnsignedLong
+    static size_t
     min (SemanticGraph::Any const& a)
     {
-      return a.context ().get<UnsignedLong> ("min");
+      return a.context ().get<size_t> ("min");
     }
 
-    static UnsignedLong
+    static size_t
     max (SemanticGraph::Member const& m)
     {
-      return m.context ().get<UnsignedLong> ("max");
+      return m.context ().get<size_t> ("max");
     }
 
-    static UnsignedLong
+    static size_t
     max (SemanticGraph::Any const& a)
     {
-      return a.context ().get<UnsignedLong> ("max");
+      return a.context ().get<size_t> ("max");
     }
 
   public:
@@ -342,14 +329,17 @@ namespace CXX
     SemanticGraph::Schema& schema_root;
     SemanticGraph::Path const& schema_path;
 
+    options_type const& options;
+
+    cxx_version std;
+
     String& char_type;
     String& char_encoding;
     String& L;                  // string literal prefix
     String& string_type;
-    StringLiteralMap const* string_literal_map;
+    String& auto_ptr;
 
-    Boolean& include_with_brackets;
-    String& include_prefix;
+    StringLiteralMap const* string_literal_map;
 
     String& type_exp;
     String& inst_exp;
@@ -367,9 +357,7 @@ namespace CXX
     String char_encoding_;
     String L_;
     String string_type_;
-
-    Boolean include_with_brackets_;
-    String include_prefix_;
+    String auto_ptr_;
 
     String type_exp_;
     String inst_exp_;
@@ -378,7 +366,6 @@ namespace CXX
   private:
     RegexPat const cxx_id_expr_;
     RegexPat const& cxx_id_expr;
-    Boolean trace_namespace_regex;
     Regex urn_mapping_;
     RegexMapping nsr_mapping_;
     MapMapping nsm_mapping_;
@@ -389,7 +376,6 @@ namespace CXX
 
     RegexMapping include_mapping_;
     RegexMapping const& include_mapping;
-    Boolean trace_include_regex;
 
     ReservedNameMap const& reserved_name_map;
     ReservedNameMap reserved_name_map_;
@@ -398,16 +384,16 @@ namespace CXX
     KeywordSet keyword_set_;
   };
 
-  inline UnsignedLong Context::
-  unicode_char (String const& str, Size& pos)
+  inline unsigned int Context::
+  unicode_char (String const& str, size_t& pos)
   {
-    if (sizeof (WideChar) == 4)
+    if (sizeof (wchar_t) == 4)
     {
       return str[pos];
     }
-    else if (sizeof (WideChar) == 2)
+    else if (sizeof (wchar_t) == 2)
     {
-      WideChar x (str[pos]);
+      wchar_t x (str[pos]);
 
       if (x < 0xD800 || x > 0xDBFF)
         return x;
@@ -418,16 +404,16 @@ namespace CXX
       return 0;
   }
 
-  inline UnsignedLong Context::
-  unicode_char (WideChar const*& p)
+  inline unsigned int Context::
+  unicode_char (wchar_t const*& p)
   {
-    if (sizeof (WideChar) == 4)
+    if (sizeof (wchar_t) == 4)
     {
       return *p;
     }
-    else if (sizeof (WideChar) == 2)
+    else if (sizeof (wchar_t) == 2)
     {
-      WideChar x (*p);
+      wchar_t x (*p);
 
       if (x < 0xD800 || x > 0xDBFF)
         return x;
@@ -438,6 +424,21 @@ namespace CXX
       return 0;
   }
 
+  // Sources traverser that goes into each schema only once.
+  //
+  struct Sources: Traversal::Sources
+  {
+    virtual void
+    traverse (SemanticGraph::Sources& s)
+    {
+      if (schemas_.insert (&s.schema ()).second)
+        Traversal::Sources::traverse (s);
+    }
+
+  private:
+    std::set<SemanticGraph::Schema*> schemas_;
+  };
+
   // Usual namespace mapping.
   //
   struct Namespace: Traversal::Namespace
@@ -447,10 +448,10 @@ namespace CXX
       // First scope name if always empty (global scope). The last flag
       // signals the last scope.
       //
-      virtual Void
-      enter (Type&, String const& name, Boolean last) = 0;
+      virtual void
+      enter (Type&, String const& name, bool last) = 0;
 
-      virtual Void
+      virtual void
       leave () = 0;
     };
 
@@ -465,10 +466,10 @@ namespace CXX
     {
     }
 
-    virtual Void
+    virtual void
     pre (Type&);
 
-    virtual Void
+    virtual void
     post (Type&);
 
   private:
@@ -476,36 +477,35 @@ namespace CXX
     ScopeTracker* st_;
   };
 
-
   //
   //
   template <typename X>
   struct Has : X
   {
-    Has (Boolean& result)
+    Has (bool& result)
         : result_ (result)
     {
     }
 
-    virtual Void
+    virtual void
     traverse (typename X::Type&)
     {
       result_ = true;
     }
 
   private:
-    Boolean& result_;
+    bool& result_;
   };
 
   // Checks if scope 'Y' names any of 'X'
   //
   template <typename X, typename Y>
-  Boolean
+  bool
   has (Y& y)
   {
     using SemanticGraph::Scope;
 
-    Boolean result (false);
+    bool result (false);
     Has<X> t (result);
 
     for (Scope::NamesIterator i (y.names_begin ()), e (y.names_end ());
@@ -518,12 +518,12 @@ namespace CXX
   // Checks if the compositor has any particle of 'X'
   //
   template <typename X>
-  Boolean
+  bool
   has_particle (SemanticGraph::Compositor& y)
   {
     using SemanticGraph::Compositor;
 
-    Boolean result (false);
+    bool result (false);
     Has<X> t (result);
 
     for (Compositor::ContainsIterator i (y.contains_begin ()),
@@ -543,7 +543,7 @@ namespace CXX
   // Specialization for Complex
   //
   template <typename X>
-  Boolean
+  bool
   has_particle (SemanticGraph::Complex& c)
   {
     return c.contains_compositor_p () &&
@@ -562,61 +562,61 @@ namespace CXX
                       Traversal::Fundamental::Id,
                       Traversal::Fundamental::IdRef
   {
-    virtual Void
+    virtual void
     fundamental_type (SemanticGraph::Fundamental::Type& t) = 0;
 
-    virtual Void
+    virtual void
     fundamental_template (SemanticGraph::Fundamental::Type& t) = 0;
 
-    virtual Void
+    virtual void
     traverse (SemanticGraph::Fundamental::Type& t)
     {
       fundamental_type (t);
     }
 
-    virtual Void
+    virtual void
     traverse (SemanticGraph::Fundamental::String& t)
     {
       fundamental_template (t);
     }
 
-    virtual Void
+    virtual void
     traverse (SemanticGraph::Fundamental::NormalizedString& t)
     {
       fundamental_template (t);
     }
 
-    virtual Void
+    virtual void
     traverse (SemanticGraph::Fundamental::Token& t)
     {
       fundamental_template (t);
     }
 
-    virtual Void
+    virtual void
     traverse (SemanticGraph::Fundamental::Name& t)
     {
       fundamental_template (t);
     }
 
-    virtual Void
+    virtual void
     traverse (SemanticGraph::Fundamental::NameToken& t)
     {
       fundamental_template (t);
     }
 
-    virtual Void
+    virtual void
     traverse (SemanticGraph::Fundamental::NCName& t)
     {
       fundamental_template (t);
     }
 
-    virtual Void
+    virtual void
     traverse (SemanticGraph::Fundamental::Id& t)
     {
       fundamental_template (t);
     }
 
-    virtual Void
+    virtual void
     traverse (SemanticGraph::Fundamental::IdRef& t)
     {
       fundamental_template (t);
diff --git a/xsd/xsd/cxx/literal-map.cxx b/xsd/xsd/cxx/literal-map.cxx
index c531b5e..24bfc52 100644
--- a/xsd/xsd/cxx/literal-map.cxx
+++ b/xsd/xsd/cxx/literal-map.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/literal-map.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <memory>  // std::auto_ptr
@@ -9,7 +8,6 @@
 #include <iostream>
 
 #include <xercesc/util/XMLUni.hpp>
-#include <xercesc/util/XercesVersion.hpp>
 
 #include <xercesc/framework/LocalFileInputSource.hpp>
 
@@ -45,7 +43,7 @@ namespace CXX
       locator_ = l;
     }
 
-    virtual Void
+    virtual void
     startElement (const XMLCh* const,
                   const XMLCh* const lname,
                   const XMLCh* const,
@@ -81,7 +79,7 @@ namespace CXX
       }
     }
 
-    virtual Void
+    virtual void
     endElement (const XMLCh* const,
                 const XMLCh* const lname,
                 const XMLCh* const)
@@ -115,13 +113,8 @@ namespace CXX
         state_ = s_entry;
     }
 
-#if _XERCES_VERSION >= 30000
-    virtual Void
+    virtual void
     characters (const XMLCh* const s, const XMLSize_t length)
-#else
-    virtual Void
-    characters (const XMLCh* const s, const unsigned int length)
-#endif
     {
       String str (XML::transcode (s, length));
 
@@ -131,9 +124,9 @@ namespace CXX
         lit_ += str;
       else
       {
-        for (Size i (0); i < str.size (); ++i)
+        for (size_t i (0); i < str.size (); ++i)
         {
-          WideChar c (str[i]);
+          wchar_t c (str[i]);
 
           if (c != 0x20 && c != 0x0A && c != 0x0D && c != 0x09)
           {
@@ -149,44 +142,37 @@ namespace CXX
     //
     enum Severity {s_warning, s_error, s_fatal};
 
-    virtual Void
+    virtual void
     warning (const SAXParseException& e)
     {
       handle (e, s_warning);
     }
 
-    virtual Void
+    virtual void
     error (const SAXParseException& e)
     {
       handle (e, s_error);
     }
 
-    virtual Void
+    virtual void
     fatalError (const SAXParseException& e)
     {
       handle (e, s_fatal);
     }
 
-    virtual Void
+    virtual void
     resetErrors ()
     {
     }
 
-    Void
+    void
     handle (const SAXParseException& e, Severity s)
     {
-      wcerr << file_ << ":";
-
-#if _XERCES_VERSION >= 30000
-      wcerr << e.getLineNumber () << ":" << e.getColumnNumber () << ": ";
-#else
-      XMLSSize_t l (e.getLineNumber ());
-      XMLSSize_t c (e.getColumnNumber ());
-      wcerr << (l == -1 ? 0 : l) << ":" << (c == -1 ? 0 : c) << ": ";
-#endif
-
       String msg (XML::transcode (e.getMessage ()));
-      wcerr << (s == s_warning ? "warning: " : "error: ") << msg << endl;
+
+      wcerr << file_ << ":"
+            << e.getLineNumber () << ":" << e.getColumnNumber () << ": "
+            << (s == s_warning ? "warning: " : "error: ") << msg << endl;
 
       if (s != s_warning)
         throw Failed ();
@@ -195,37 +181,17 @@ namespace CXX
     size_t
     line () const
     {
-      size_t r (0);
-
-      if (locator_ != 0)
-      {
-#if _XERCES_VERSION >= 30000
-        r = static_cast<size_t> (locator_->getLineNumber ());
-#else
-        XMLSSize_t l (locator_->getLineNumber ());
-        r = l == -1 ? 0 : static_cast<size_t> (l);
-#endif
-      }
-
-      return r;
+      return locator_ != 0
+        ? static_cast<size_t> (locator_->getLineNumber ())
+        : 0;
     }
 
     size_t
     col () const
     {
-      size_t r (0);
-
-      if (locator_ != 0)
-      {
-#if _XERCES_VERSION >= 30000
-        r = static_cast<size_t> (locator_->getColumnNumber ());
-#else
-        XMLSSize_t c (locator_->getColumnNumber ());
-        r = c == -1 ? 0 : static_cast<size_t> (c);
-#endif
-      }
-
-      return r;
+      return locator_ != 0
+        ? static_cast<size_t> (locator_->getColumnNumber ())
+        : 0;
     }
 
   private:
@@ -243,8 +209,8 @@ namespace CXX
     String file_;
     StringLiteralMap& map_;
 
-    Boolean str_seen_;
-    Boolean lit_seen_;
+    bool str_seen_;
+    bool lit_seen_;
 
     String str_;
     String lit_;
diff --git a/xsd/xsd/cxx/literal-map.hxx b/xsd/xsd/cxx/literal-map.hxx
index 6edeb00..987a531 100644
--- a/xsd/xsd/cxx/literal-map.hxx
+++ b/xsd/xsd/cxx/literal-map.hxx
@@ -1,20 +1,17 @@
 // file      : xsd/cxx/literal-map.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_LITERAL_MAP_HXX
 #define CXX_LITERAL_MAP_HXX
 
-#include <cult/types.hxx>
-#include <cult/containers/map.hxx>
+#include <map>
+
+#include <types.hxx>
 
 namespace CXX
 {
-  using namespace Cult;
-  typedef WideString String;
-
-  typedef Cult::Containers::Map<String, String> StringLiteralMap;
+  typedef std::map<String, String> StringLiteralMap;
 
   bool
   read_literal_map (NarrowString const& file, StringLiteralMap& map);
diff --git a/xsd/xsd/cxx/option-types.cxx b/xsd/xsd/cxx/option-types.cxx
new file mode 100644
index 0000000..78424f0
--- /dev/null
+++ b/xsd/xsd/cxx/option-types.cxx
@@ -0,0 +1,48 @@
+// file      : xsd/cxx/option-types.cxx
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <istream>
+#include <ostream>
+
+#include <cxx/option-types.hxx>
+
+using namespace std;
+
+namespace CXX
+{
+  //
+  // cxx_version
+  //
+
+  static const char* cxx_version_[] =
+  {
+    "c++98",
+    "c++11"
+  };
+
+  string cxx_version::
+  string () const
+  {
+    return cxx_version_[v_];
+  }
+
+  istream&
+  operator>> (istream& is, cxx_version& v)
+  {
+    string s;
+    is >> s;
+
+    if (!is.fail ())
+    {
+      if (s == "c++98")
+        v = cxx_version::cxx98;
+      else if (s == "c++11")
+        v = cxx_version::cxx11;
+      else
+        is.setstate (istream::failbit);
+    }
+
+    return is;
+  }
+}
diff --git a/xsd/xsd/cxx/option-types.hxx b/xsd/xsd/cxx/option-types.hxx
new file mode 100644
index 0000000..b2377ba
--- /dev/null
+++ b/xsd/xsd/cxx/option-types.hxx
@@ -0,0 +1,35 @@
+// file      : xsd/cxx/option-types.hxx
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_OPTION_TYPES_HXX
+#define XSD_OPTION_TYPES_HXX
+
+#include <iosfwd>
+#include <string>
+
+namespace CXX
+{
+  struct cxx_version
+  {
+    enum value
+    {
+      cxx98,
+      cxx11
+    };
+
+    cxx_version (value v = value (0)) : v_ (v) {}
+    operator value () const {return v_;}
+
+    std::string
+    string () const;
+
+  private:
+    value v_;
+  };
+
+  std::istream&
+  operator>> (std::istream&, cxx_version&);
+}
+
+#endif // XSD_OPTION_TYPES_HXX
diff --git a/xsd/xsd/cxx/options.cli b/xsd/xsd/cxx/options.cli
new file mode 100644
index 0000000..8133b25
--- /dev/null
+++ b/xsd/xsd/cxx/options.cli
@@ -0,0 +1,551 @@
+// file      : xsd/cxx/options.cli
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+include <cstddef>; // std::size_t
+
+include <types.hxx>; // NarrowString, NarrowStrings
+
+include <cxx/option-types.hxx>;
+
+include <options.cli>;
+
+namespace CXX
+{
+  class options: ::options = 0
+  {
+    // Language.
+    //
+    cxx_version --std = cxx_version::cxx98
+    {
+      "<version>",
+      "Specify the C++ standard that the generated code should conform to.
+       Valid values are \cb{c++98} (default) and \cb{c++11}.
+
+       The C++ standard affects various aspects of the generated code that
+       are discussed in more detail in various mapping-specific
+       documentation. Overall, when C++11 is selected, the generated
+       code relies on the move semantics and uses \cb{std::unique_ptr}
+       instead of deprecated \cb{std::auto_ptr}.
+
+       When the C++11 mode is selected, you normally don't need to
+       perform any extra steps other than enable C++11 in your C++
+       compiler, if required. The XSD compiler will automatically
+       add the necessary macro defines to the generated header files
+       that will switch the header-only XSD runtime library (\cb{libxsd})
+       to the C++11 mode. However, if you include any of the XSD runtime
+       headers directly in your application (normally you just include
+       the generated headers), then you will need to define the
+       \cb{XSD_CXX11} macro for your entire project."
+    };
+
+    // Character type and encoding.
+    //
+    NarrowString --char-type = "char"
+    {
+      "<type>",
+      "Generate code using the provided character <type> instead of the
+       default \cb{char}. Valid values are \cb{char} and \cb{wchar_t}."
+    };
+
+    NarrowString --char-encoding
+    {
+      "<enc>",
+      "Specify the character encoding that should be used in the generated
+       code. Valid values for the \cb{char} character type are \cb{utf8}
+       (default), \cb{iso8859-1}, \cb{lcp} (Xerces-C++ local code page),
+       and \cb{custom}. If you pass \cb{custom} as the value then you will
+       need to include the transcoder implementation header for your
+       encoding at the beginning of the generated header files (see the
+       \cb{--hxx-prologue} option).
+
+       For the \cb{wchar_t} character type the only valid value is \cb{auto}
+       and the encoding is automatically selected between UTF-16 and
+       UTF-32/UCS-4, depending on the \cb{wchar_t} type size."
+    };
+
+    // Output options.
+    //
+    NarrowString --output-dir
+    {
+      "<dir>",
+      "Write generated files to <dir> instead of the current directory."
+    };
+
+    bool --generate-inline
+    {
+      "Generate simple functions inline. This option triggers creation of
+       the inline file."
+    };
+
+    // Extern XML Schema.
+    //
+    bool --generate-xml-schema
+    {
+      "Generate a C++ header file as if the schema being compiled defines the
+       XML Schema namespace. For the C++/Tree mapping, the resulting file will
+       contain definitions for all XML Schema built-in types. For the
+       C++/Parser mapping, the resulting file will contain definitions for
+       all the parser skeletons and implementations corresponding to the
+       XML Schema built-in types.
+
+       The schema file provided to the compiler need not exist and is only
+       used to derive the name of the resulting header file. Use the
+       \cb{--extern-xml-schema} option to include this file in the
+       generated files for other schemas."
+     };
+
+    NarrowString --extern-xml-schema
+    {
+      "<file>",
+      "Include a header file derived from <file> instead of generating the
+       XML Schema namespace mapping inline. The provided file need not
+       exist and is only used to derive the name of the included header
+       file. Use the \cb{--generate-xml-schema} option to generate this
+       header file."
+     };
+
+    // Namespace mapping.
+    //
+    NarrowStrings --namespace-map
+    {
+      "<xns>=<cns>",
+      "Map XML Schema namespace <xns> to C++ namespace <cns>. Repeat
+       this option to specify mapping for more than one XML Schema namespace.
+       For example, the following option:
+
+       \cb{--namespace-map http://example.com/foo/bar=foo::bar}
+
+       Will map the \cb{http://example.com/foo/bar} XML Schema namespace to
+       the \cb{foo::bar} C++ namespace."
+    };
+
+    NarrowStrings --namespace-regex
+    {
+      "<regex>",
+      "Add <regex> to the list of regular expressions used to translate XML
+       Schema namespace names to C++ namespace names. <regex> is a Perl-like
+       regular expression in the form
+       \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. Any character can be
+       used as a delimiter instead of \cb{/}. Escaping of the delimiter
+       character in \ci{pattern} or \ci{replacement} is not supported.
+
+       All the regular expressions are pushed into a stack with the last
+       specified expression considered first. The first match that
+       succeeds is used. Regular expressions are applied to a string in
+       the form
+
+       \c{\i{filename} \i{namespace}}
+
+       For example, if you have file \cb{hello.xsd} with namespace
+       \cb{http://example.com/hello} and you run \cb{xsd} on this file,
+       then the string in question will be:
+
+       \cb{hello.xsd. http://example.com/hello}
+
+       For the built-in XML Schema namespace the string is:
+
+       \cb{XMLSchema.xsd http://www.w3.org/2001/XMLSchema}
+
+       The following three steps are performed for each regular expression
+       until the match is found:
+
+       1. The expression is applied and if the result is empty the next
+       expression is considered.
+
+       2. All \cb{/} are replaced with \cb{::}.
+
+       3. The result is verified to be a valid C++ scope name (e.g.,
+       \cb{foo::bar}). If this test succeeds, the result is used as a
+       C++ namespace name.
+
+       As an example, the following expression maps XML  Schema namespaces
+       in the form \cb{http://example.com/foo/bar} to C++ namespaces in the
+       form \cb{foo::bar}:
+
+       \cb{%.* http://example.com/(.+)%$1%}
+
+       See also the REGEX AND SHELL QUOTING section below."
+    };
+
+    bool --namespace-regex-trace
+    {
+      "Trace the process of applying regular expressions specified with the
+       \cb{--namespace-regex} option. Use this option to find out why your
+       regular expressions don't do what you expected them to do."
+    };
+
+    // Reserved names.
+    //
+    NarrowStrings --reserved-name
+    {
+      "<n>[=<r>]",
+      "Add name <n> to the list of names that should not be used as
+       identifiers. The name can optionally be followed by \cb{=} and the
+       replacement name <r> that should be used instead. All the C++ keywords
+       are already in this list."
+    };
+
+    // Include options.
+    //
+    bool --include-with-brackets
+    {
+      "Use angle brackets (<>) instead of quotes (\"\") in generated
+       \cb{#include} directives."
+    };
+
+    NarrowString --include-prefix
+    {
+      "<prefix>",
+      "Add <prefix> to generated \cb{#include} directive paths.
+
+       For example, if you had the following import element in your schema
+
+       \cb{<import namespace=\"...\" schemaLocation=\"base.xsd\"/>}
+
+       and compiled this fragment with \cb{--include-prefix schemas/}, then
+       the include directive in the generated code would be:
+
+       \cb{#include \"schemas/base.hxx\"}"
+    };
+
+    NarrowStrings --include-regex
+    {
+      "<regex>",
+      "Add <regex> to the list of regular expressions used to transform
+       \cb{#include} directive paths. <regex> is a Perl-like regular
+       expression in the form \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}.
+       Any character can be used as a delimiter instead of \cb{/}. Escaping
+       of the delimiter character in \ci{pattern} or \ci{replacement} is not
+       supported.
+
+       All the regular expressions are pushed into a stack with the last
+       specified expression considered first. The first match that succeeds
+       is used.
+
+       As an example, the following expression transforms paths in the form
+       \cb{schemas/foo/bar} to paths in the form \cb{generated/foo/bar}:
+
+       \cb{%schemas/(.+)%generated/$1%}
+
+       See also the REGEX AND SHELL QUOTING section below."
+    };
+
+    bool --include-regex-trace
+    {
+      "Trace the process of applying regular expressions specified with the
+       \cb{--include-regex} option. Use this option to find out why your
+       regular expressions don't do what you expected them to do."
+    };
+
+    NarrowString --guard-prefix
+    {
+      "<prefix>",
+      "Add <prefix> to generated header inclusion guards. The prefix is
+       transformed to upper case and characters that are illegal in a
+       preprocessor macro name are replaced with underscores. If this
+       option is not specified then the directory part of the input schema
+       file is used as a prefix."
+    };
+
+    // File suffixes.
+    //
+    NarrowString --hxx-suffix = ".hxx"
+    {
+      "<suffix>",
+      "Use the provided <suffix> instead of the default \cb{.hxx} to
+       construct the name of the header file. Note that this suffix is also
+       used to construct names of header files corresponding to
+       included/imported schemas."
+    };
+
+    NarrowString --ixx-suffix = ".ixx"
+    {
+      "<suffix>",
+      "Use the provided <suffix> instead of the default \cb{.ixx} to
+       construct the name of the inline file."
+    };
+
+    NarrowString --cxx-suffix = ".cxx"
+    {
+      "<suffix>",
+      "Use the provided <suffix> instead of the default \cb{.cxx} to
+       construct the name of the source file."
+    };
+
+    NarrowString --fwd-suffix = "-fwd.hxx"
+    {
+      "<suffix>",
+      "Use the provided <suffix> instead of the default \cb{-fwd.hxx} to
+       construct the name of the forward declaration file."
+    };
+
+    NarrowString --hxx-regex
+    {
+      "<regex>",
+      "Use the provided expression to construct the name of the header file.
+       <regex> is a Perl-like regular expression in the form
+       \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}.
+       Note that this expression is also used to construct names of header
+       files corresponding to included/imported schemas. See also the REGEX
+       AND SHELL QUOTING section below."
+    };
+
+    NarrowString --ixx-regex
+    {
+      "<regex>",
+      "Use the provided expression to construct the name of the inline file.
+       <regex> is a Perl-like regular expression in the form
+       \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. See also the REGEX AND
+       SHELL QUOTING section below."
+    };
+
+    NarrowString --cxx-regex
+    {
+      "<regex>",
+      "Use the provided expression to construct the name of the source file.
+       <regex> is a Perl-like regular expression in the form
+       \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. See also the REGEX AND
+       SHELL QUOTING section below."
+    };
+
+    NarrowString --fwd-regex
+    {
+      "<regex>",
+      "Use the provided expression to construct the name of the forward
+       declaration file. <regex> is a Perl-like regular expression in the
+       form \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. See also the REGEX
+       AND SHELL QUOTING section below."
+    };
+
+    // Prologues/epilogues.
+    //
+    NarrowStrings --hxx-prologue
+    {
+      "<text>",
+      "Insert <text> at the beginning of the header file."
+    };
+
+    NarrowStrings --ixx-prologue
+    {
+      "<text>",
+      "Insert <text> at the beginning of the inline file."
+    };
+
+    NarrowStrings --cxx-prologue
+    {
+      "<text>",
+      "Insert <text> at the beginning of the source file."
+    };
+
+    NarrowStrings --fwd-prologue
+    {
+      "<text>",
+      "Insert <text> at the beginning of the forward declaration file."
+    };
+
+    NarrowStrings --prologue
+    {
+      "<text>",
+      "Insert <text> at the beginning of each generated file for which
+       there is no file-specific prologue."
+    };
+
+    NarrowStrings --hxx-epilogue
+    {
+      "<text>",
+      "Insert <text> at the end of the header file."
+    };
+
+    NarrowStrings --ixx-epilogue
+    {
+      "<text>",
+      "Insert <text> at the end of the inline file."
+    };
+
+    NarrowStrings --cxx-epilogue
+    {
+      "<text>",
+      "Insert <text> at the end of the source file."
+    };
+
+    NarrowStrings --fwd-epilogue
+    {
+      "<text>",
+      "Insert <text> at the end of the forward declaration file."
+    };
+
+    NarrowStrings --epilogue
+    {
+      "<text>",
+      "Insert <text> at the end of each generated file for which there
+       is no file-specific epilogue."
+    };
+
+    NarrowString --hxx-prologue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the beginning of the header file."
+    };
+
+    NarrowString --ixx-prologue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the beginning of the inline file."
+    };
+
+    NarrowString --cxx-prologue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the beginning of the source file."
+    };
+
+    NarrowString --fwd-prologue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the beginning of the forward
+       declaration file."
+    };
+
+    NarrowString --prologue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the beginning of each generated
+       file for which there is no file-specific prologue file."
+    };
+
+    NarrowString --hxx-epilogue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the end of the header file."
+    };
+
+    NarrowString --ixx-epilogue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the end of the inline file."
+    };
+
+    NarrowString --cxx-epilogue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the end of the source file."
+    };
+
+    NarrowString --fwd-epilogue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the end of the forward declaration
+       file."
+    };
+
+    NarrowString --epilogue-file
+    {
+      "<file>",
+      "Insert the content of the <file> at the end of each generated file
+       for which there is no file-specific epilogue file."
+    };
+
+    // Export options.
+    //
+    NarrowString --export-symbol
+    {
+      "<symbol>",
+      "Insert <symbol> in places where DLL export/import control statements
+       (\cb{__declspec(dllexport/dllimport)}) are necessary."
+    };
+
+    bool --export-xml-schema
+    {
+      "Export/import types in the XML Schema namespace using the export
+       symbol provided with the \cb{--export-symbol} option. The
+       \cb{XSD_NO_EXPORT} macro can be used to omit this code during C++
+       compilation, which may be useful if you would like to use the same
+       generated code across multiple platforms."
+    };
+
+    bool --export-maps
+    {
+      "Export polymorphism support maps from a Win32 DLL into which this
+       generated code is placed. This is necessary when your type hierarchy
+       is split across several DLLs since otherwise each DLL will have its
+       own set of maps. In this situation the generated code for the DLL
+       which contains base types and/or substitution group heads should be
+       compiled with this option and the generated code for all other DLLs
+       should be compiled with \cb{--import-maps}. This option is only valid
+       together with \cb{--generate-polymorphic}. The \cb{XSD_NO_EXPORT}
+       macro can be used to omit this code during C++ compilation, which may
+       be useful if you would like to use the same generated code across
+       multiple platforms."
+    };
+
+    bool --import-maps
+    {
+      "Import polymorphism support maps to a Win32 DLL or executable into
+       which this generated code is linked. See the \cb{--export-maps}
+       option documentation for details. This options is only valid together
+       with \cb{--generate-polymorphic}. The \cb{XSD_NO_EXPORT} macro can be
+       used to omit this code during C++ compilation, which may be useful if
+       you would like to use the same generated code across multiple
+       platforms."
+    };
+
+    // Make dependency generation.
+    //
+    bool --generate-dep
+    {
+      "Generate \cb{make} dependency information. This option triggers the
+       creation of the \cb{.d} file containing the dependencies of the
+       generated files on the main schema file as well as all the schema
+       files that it includes/imports, transitively. This dependency file
+       is then normally included into the main \cb{makefile} to implement
+       automatic dependency tracking.
+
+       Note also that automatic dependency generation is not supported in
+       the file-per-type mode (\cb{--file-per-type}). In this case, all
+       the generated files are produced with a single compiler invocation
+       and depend on all the schemas. As a result, it is easier to establish
+       such a dependency manually, perhaps with the help of the
+       \cb{--file-list*} options."
+    };
+
+    bool --generate-dep-only
+    {
+      "Generate \cb{make} dependency information only."
+    };
+
+    bool --dep-phony
+    {
+      "Generate phony targets for included/imported schema files, causing
+       each to depend on nothing. Such dummy rules work around \cb{make}
+       errors caused by the removal of schema files without also updating
+       the dependency file to match."
+    };
+
+    NarrowStrings --dep-target
+    {
+      "<target>",
+      "Change the target of the dependency rule. By default it contains
+       all the generated C++ files as well as the dependency file itself,
+       without any directory prefixes. If you require multiple targets,
+       then you can specify them as a single, space-separated argument or
+       you can repeat this option multiple times."
+    };
+
+    NarrowString --dep-suffix = ".d"
+    {
+      "<suffix>",
+      "Use the provided <suffix> instead of the default \cb{.d} to
+       construct the name of the dependency file."
+    };
+
+    NarrowString --dep-regex
+    {
+      "<regex>",
+      "Use the provided expression to construct the name of the dependency
+       file. <regex> is a Perl-like regular expression in the form
+       \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. See also the REGEX
+       AND SHELL QUOTING section below."
+    };
+  };
+}
diff --git a/xsd/xsd/cxx/options.cxx b/xsd/xsd/cxx/options.cxx
new file mode 100644
index 0000000..1d2e8fd
--- /dev/null
+++ b/xsd/xsd/cxx/options.cxx
@@ -0,0 +1,638 @@
+// This code was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <options-parser.hxx>
+//
+// End prologue.
+
+#include <cxx/options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <ostream>
+#include <sstream>
+
+namespace cli
+{
+  template <typename X>
+  struct parser
+  {
+    static void
+    parse (X& x, bool& xs, scanner& s)
+    {
+      std::string o (s.next ());
+
+      if (s.more ())
+      {
+        std::string v (s.next ());
+        std::istringstream is (v);
+        if (!(is >> x && is.eof ()))
+          throw invalid_value (o, v);
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <>
+  struct parser<bool>
+  {
+    static void
+    parse (bool& x, scanner& s)
+    {
+      s.next ();
+      x = true;
+    }
+  };
+
+  template <>
+  struct parser<std::string>
+  {
+    static void
+    parse (std::string& x, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+        x = s.next ();
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X>
+  struct parser<std::vector<X> >
+  {
+    static void
+    parse (std::vector<X>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.push_back (x);
+      xs = true;
+    }
+  };
+
+  template <typename X>
+  struct parser<std::set<X> >
+  {
+    static void
+    parse (std::set<X>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.insert (x);
+      xs = true;
+    }
+  };
+
+  template <typename K, typename V>
+  struct parser<std::map<K, V> >
+  {
+    static void
+    parse (std::map<K, V>& m, bool& xs, scanner& s)
+    {
+      std::string o (s.next ());
+
+      if (s.more ())
+      {
+        std::string ov (s.next ());
+        std::string::size_type p = ov.find ('=');
+
+        if (p == std::string::npos)
+        {
+          K k = K ();
+
+          if (!ov.empty ())
+          {
+            std::istringstream ks (ov);
+
+            if (!(ks >> k && ks.eof ()))
+              throw invalid_value (o, ov);
+          }
+
+          m[k] = V ();
+        }
+        else
+        {
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, p + 1);
+
+          if (!kstr.empty ())
+          {
+            std::istringstream ks (kstr);
+
+            if (!(ks >> k && ks.eof ()))
+              throw invalid_value (o, ov);
+          }
+
+          if (!vstr.empty ())
+          {
+            std::istringstream vs (vstr);
+
+            if (!(vs >> v && vs.eof ()))
+              throw invalid_value (o, ov);
+          }
+
+          m[k] = v;
+        }
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X, typename T, T X::*M>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, s);
+  }
+
+  template <typename X, typename T, T X::*M, bool X::*S>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, x.*S, s);
+  }
+}
+
+#include <map>
+#include <cstring>
+
+namespace CXX
+{
+  // options
+  //
+
+  options::
+  options ()
+  : std_ (cxx_version::cxx98),
+    std_specified_ (false),
+    char_type_ ("char"),
+    char_type_specified_ (false),
+    char_encoding_ (),
+    char_encoding_specified_ (false),
+    output_dir_ (),
+    output_dir_specified_ (false),
+    generate_inline_ (),
+    generate_xml_schema_ (),
+    extern_xml_schema_ (),
+    extern_xml_schema_specified_ (false),
+    namespace_map_ (),
+    namespace_map_specified_ (false),
+    namespace_regex_ (),
+    namespace_regex_specified_ (false),
+    namespace_regex_trace_ (),
+    reserved_name_ (),
+    reserved_name_specified_ (false),
+    include_with_brackets_ (),
+    include_prefix_ (),
+    include_prefix_specified_ (false),
+    include_regex_ (),
+    include_regex_specified_ (false),
+    include_regex_trace_ (),
+    guard_prefix_ (),
+    guard_prefix_specified_ (false),
+    hxx_suffix_ (".hxx"),
+    hxx_suffix_specified_ (false),
+    ixx_suffix_ (".ixx"),
+    ixx_suffix_specified_ (false),
+    cxx_suffix_ (".cxx"),
+    cxx_suffix_specified_ (false),
+    fwd_suffix_ ("-fwd.hxx"),
+    fwd_suffix_specified_ (false),
+    hxx_regex_ (),
+    hxx_regex_specified_ (false),
+    ixx_regex_ (),
+    ixx_regex_specified_ (false),
+    cxx_regex_ (),
+    cxx_regex_specified_ (false),
+    fwd_regex_ (),
+    fwd_regex_specified_ (false),
+    hxx_prologue_ (),
+    hxx_prologue_specified_ (false),
+    ixx_prologue_ (),
+    ixx_prologue_specified_ (false),
+    cxx_prologue_ (),
+    cxx_prologue_specified_ (false),
+    fwd_prologue_ (),
+    fwd_prologue_specified_ (false),
+    prologue_ (),
+    prologue_specified_ (false),
+    hxx_epilogue_ (),
+    hxx_epilogue_specified_ (false),
+    ixx_epilogue_ (),
+    ixx_epilogue_specified_ (false),
+    cxx_epilogue_ (),
+    cxx_epilogue_specified_ (false),
+    fwd_epilogue_ (),
+    fwd_epilogue_specified_ (false),
+    epilogue_ (),
+    epilogue_specified_ (false),
+    hxx_prologue_file_ (),
+    hxx_prologue_file_specified_ (false),
+    ixx_prologue_file_ (),
+    ixx_prologue_file_specified_ (false),
+    cxx_prologue_file_ (),
+    cxx_prologue_file_specified_ (false),
+    fwd_prologue_file_ (),
+    fwd_prologue_file_specified_ (false),
+    prologue_file_ (),
+    prologue_file_specified_ (false),
+    hxx_epilogue_file_ (),
+    hxx_epilogue_file_specified_ (false),
+    ixx_epilogue_file_ (),
+    ixx_epilogue_file_specified_ (false),
+    cxx_epilogue_file_ (),
+    cxx_epilogue_file_specified_ (false),
+    fwd_epilogue_file_ (),
+    fwd_epilogue_file_specified_ (false),
+    epilogue_file_ (),
+    epilogue_file_specified_ (false),
+    export_symbol_ (),
+    export_symbol_specified_ (false),
+    export_xml_schema_ (),
+    export_maps_ (),
+    import_maps_ (),
+    generate_dep_ (),
+    generate_dep_only_ (),
+    dep_phony_ (),
+    dep_target_ (),
+    dep_target_specified_ (false),
+    dep_suffix_ (".d"),
+    dep_suffix_specified_ (false),
+    dep_regex_ (),
+    dep_regex_specified_ (false)
+  {
+  }
+
+  void options::
+  print_usage (::std::wostream& os)
+  {
+    os << "--std <version>              Specify the C++ standard that the generated code" << ::std::endl
+       << "                             should conform to." << ::std::endl;
+
+    os << "--char-type <type>           Generate code using the provided character <type>" << ::std::endl
+       << "                             instead of the default 'char'." << ::std::endl;
+
+    os << "--char-encoding <enc>        Specify the character encoding that should be used" << ::std::endl
+       << "                             in the generated code." << ::std::endl;
+
+    os << "--output-dir <dir>           Write generated files to <dir> instead of the" << ::std::endl
+       << "                             current directory." << ::std::endl;
+
+    os << "--generate-inline            Generate simple functions inline." << ::std::endl;
+
+    os << "--generate-xml-schema        Generate a C++ header file as if the schema being" << ::std::endl
+       << "                             compiled defines the XML Schema namespace." << ::std::endl;
+
+    os << "--extern-xml-schema <file>   Include a header file derived from <file> instead" << ::std::endl
+       << "                             of generating the XML Schema namespace mapping" << ::std::endl
+       << "                             inline." << ::std::endl;
+
+    os << "--namespace-map <xns>=<cns>  Map XML Schema namespace <xns> to C++ namespace" << ::std::endl
+       << "                             <cns>." << ::std::endl;
+
+    os << "--namespace-regex <regex>    Add <regex> to the list of regular expressions" << ::std::endl
+       << "                             used to translate XML Schema namespace names to" << ::std::endl
+       << "                             C++ namespace names." << ::std::endl;
+
+    os << "--namespace-regex-trace      Trace the process of applying regular expressions" << ::std::endl
+       << "                             specified with the '--namespace-regex' option." << ::std::endl;
+
+    os << "--reserved-name <n>[=<r>]    Add name <n> to the list of names that should not" << ::std::endl
+       << "                             be used as identifiers." << ::std::endl;
+
+    os << "--include-with-brackets      Use angle brackets (<>) instead of quotes (\"\") in" << ::std::endl
+       << "                             generated '#include' directives." << ::std::endl;
+
+    os << "--include-prefix <prefix>    Add <prefix> to generated '#include' directive" << ::std::endl
+       << "                             paths." << ::std::endl;
+
+    os << "--include-regex <regex>      Add <regex> to the list of regular expressions" << ::std::endl
+       << "                             used to transform '#include' directive paths." << ::std::endl;
+
+    os << "--include-regex-trace        Trace the process of applying regular expressions" << ::std::endl
+       << "                             specified with the '--include-regex' option." << ::std::endl;
+
+    os << "--guard-prefix <prefix>      Add <prefix> to generated header inclusion guards." << ::std::endl;
+
+    os << "--hxx-suffix <suffix>        Use the provided <suffix> instead of the default" << ::std::endl
+       << "                             '.hxx' to construct the name of the header file." << ::std::endl;
+
+    os << "--ixx-suffix <suffix>        Use the provided <suffix> instead of the default" << ::std::endl
+       << "                             '.ixx' to construct the name of the inline file." << ::std::endl;
+
+    os << "--cxx-suffix <suffix>        Use the provided <suffix> instead of the default" << ::std::endl
+       << "                             '.cxx' to construct the name of the source file." << ::std::endl;
+
+    os << "--fwd-suffix <suffix>        Use the provided <suffix> instead of the default" << ::std::endl
+       << "                             '-fwd.hxx' to construct the name of the forward" << ::std::endl
+       << "                             declaration file." << ::std::endl;
+
+    os << "--hxx-regex <regex>          Use the provided expression to construct the name" << ::std::endl
+       << "                             of the header file." << ::std::endl;
+
+    os << "--ixx-regex <regex>          Use the provided expression to construct the name" << ::std::endl
+       << "                             of the inline file." << ::std::endl;
+
+    os << "--cxx-regex <regex>          Use the provided expression to construct the name" << ::std::endl
+       << "                             of the source file." << ::std::endl;
+
+    os << "--fwd-regex <regex>          Use the provided expression to construct the name" << ::std::endl
+       << "                             of the forward declaration file." << ::std::endl;
+
+    os << "--hxx-prologue <text>        Insert <text> at the beginning of the header file." << ::std::endl;
+
+    os << "--ixx-prologue <text>        Insert <text> at the beginning of the inline file." << ::std::endl;
+
+    os << "--cxx-prologue <text>        Insert <text> at the beginning of the source file." << ::std::endl;
+
+    os << "--fwd-prologue <text>        Insert <text> at the beginning of the forward" << ::std::endl
+       << "                             declaration file." << ::std::endl;
+
+    os << "--prologue <text>            Insert <text> at the beginning of each generated" << ::std::endl
+       << "                             file for which there is no file-specific prologue." << ::std::endl;
+
+    os << "--hxx-epilogue <text>        Insert <text> at the end of the header file." << ::std::endl;
+
+    os << "--ixx-epilogue <text>        Insert <text> at the end of the inline file." << ::std::endl;
+
+    os << "--cxx-epilogue <text>        Insert <text> at the end of the source file." << ::std::endl;
+
+    os << "--fwd-epilogue <text>        Insert <text> at the end of the forward" << ::std::endl
+       << "                             declaration file." << ::std::endl;
+
+    os << "--epilogue <text>            Insert <text> at the end of each generated file" << ::std::endl
+       << "                             for which there is no file-specific epilogue." << ::std::endl;
+
+    os << "--hxx-prologue-file <file>   Insert the content of the <file> at the beginning" << ::std::endl
+       << "                             of the header file." << ::std::endl;
+
+    os << "--ixx-prologue-file <file>   Insert the content of the <file> at the beginning" << ::std::endl
+       << "                             of the inline file." << ::std::endl;
+
+    os << "--cxx-prologue-file <file>   Insert the content of the <file> at the beginning" << ::std::endl
+       << "                             of the source file." << ::std::endl;
+
+    os << "--fwd-prologue-file <file>   Insert the content of the <file> at the beginning" << ::std::endl
+       << "                             of the forward declaration file." << ::std::endl;
+
+    os << "--prologue-file <file>       Insert the content of the <file> at the beginning" << ::std::endl
+       << "                             of each generated file for which there is no" << ::std::endl
+       << "                             file-specific prologue file." << ::std::endl;
+
+    os << "--hxx-epilogue-file <file>   Insert the content of the <file> at the end of the" << ::std::endl
+       << "                             header file." << ::std::endl;
+
+    os << "--ixx-epilogue-file <file>   Insert the content of the <file> at the end of the" << ::std::endl
+       << "                             inline file." << ::std::endl;
+
+    os << "--cxx-epilogue-file <file>   Insert the content of the <file> at the end of the" << ::std::endl
+       << "                             source file." << ::std::endl;
+
+    os << "--fwd-epilogue-file <file>   Insert the content of the <file> at the end of the" << ::std::endl
+       << "                             forward declaration file." << ::std::endl;
+
+    os << "--epilogue-file <file>       Insert the content of the <file> at the end of" << ::std::endl
+       << "                             each generated file for which there is no" << ::std::endl
+       << "                             file-specific epilogue file." << ::std::endl;
+
+    os << "--export-symbol <symbol>     Insert <symbol> in places where DLL export/import" << ::std::endl
+       << "                             control statements" << ::std::endl
+       << "                             ('__declspec(dllexport/dllimport)') are necessary." << ::std::endl;
+
+    os << "--export-xml-schema          Export/import types in the XML Schema namespace" << ::std::endl
+       << "                             using the export symbol provided with the" << ::std::endl
+       << "                             '--export-symbol' option." << ::std::endl;
+
+    os << "--export-maps                Export polymorphism support maps from a Win32 DLL" << ::std::endl
+       << "                             into which this generated code is placed." << ::std::endl;
+
+    os << "--import-maps                Import polymorphism support maps to a Win32 DLL or" << ::std::endl
+       << "                             executable into which this generated code is" << ::std::endl
+       << "                             linked." << ::std::endl;
+
+    os << "--generate-dep               Generate 'make' dependency information." << ::std::endl;
+
+    os << "--generate-dep-only          Generate 'make' dependency information only." << ::std::endl;
+
+    os << "--dep-phony                  Generate phony targets for included/imported" << ::std::endl
+       << "                             schema files, causing each to depend on nothing." << ::std::endl;
+
+    os << "--dep-target <target>        Change the target of the dependency rule." << ::std::endl;
+
+    os << "--dep-suffix <suffix>        Use the provided <suffix> instead of the default" << ::std::endl
+       << "                             '.d' to construct the name of the dependency file." << ::std::endl;
+
+    os << "--dep-regex <regex>          Use the provided expression to construct the name" << ::std::endl
+       << "                             of the dependency file." << ::std::endl;
+  }
+
+  typedef
+  std::map<std::string, void (*) (options&, ::cli::scanner&)>
+  _cli_options_map;
+
+  static _cli_options_map _cli_options_map_;
+
+  struct _cli_options_map_init
+  {
+    _cli_options_map_init ()
+    {
+      _cli_options_map_["--std"] = 
+      &::cli::thunk< options, cxx_version, &options::std_,
+        &options::std_specified_ >;
+      _cli_options_map_["--char-type"] = 
+      &::cli::thunk< options, NarrowString, &options::char_type_,
+        &options::char_type_specified_ >;
+      _cli_options_map_["--char-encoding"] = 
+      &::cli::thunk< options, NarrowString, &options::char_encoding_,
+        &options::char_encoding_specified_ >;
+      _cli_options_map_["--output-dir"] = 
+      &::cli::thunk< options, NarrowString, &options::output_dir_,
+        &options::output_dir_specified_ >;
+      _cli_options_map_["--generate-inline"] = 
+      &::cli::thunk< options, bool, &options::generate_inline_ >;
+      _cli_options_map_["--generate-xml-schema"] = 
+      &::cli::thunk< options, bool, &options::generate_xml_schema_ >;
+      _cli_options_map_["--extern-xml-schema"] = 
+      &::cli::thunk< options, NarrowString, &options::extern_xml_schema_,
+        &options::extern_xml_schema_specified_ >;
+      _cli_options_map_["--namespace-map"] = 
+      &::cli::thunk< options, NarrowStrings, &options::namespace_map_,
+        &options::namespace_map_specified_ >;
+      _cli_options_map_["--namespace-regex"] = 
+      &::cli::thunk< options, NarrowStrings, &options::namespace_regex_,
+        &options::namespace_regex_specified_ >;
+      _cli_options_map_["--namespace-regex-trace"] = 
+      &::cli::thunk< options, bool, &options::namespace_regex_trace_ >;
+      _cli_options_map_["--reserved-name"] = 
+      &::cli::thunk< options, NarrowStrings, &options::reserved_name_,
+        &options::reserved_name_specified_ >;
+      _cli_options_map_["--include-with-brackets"] = 
+      &::cli::thunk< options, bool, &options::include_with_brackets_ >;
+      _cli_options_map_["--include-prefix"] = 
+      &::cli::thunk< options, NarrowString, &options::include_prefix_,
+        &options::include_prefix_specified_ >;
+      _cli_options_map_["--include-regex"] = 
+      &::cli::thunk< options, NarrowStrings, &options::include_regex_,
+        &options::include_regex_specified_ >;
+      _cli_options_map_["--include-regex-trace"] = 
+      &::cli::thunk< options, bool, &options::include_regex_trace_ >;
+      _cli_options_map_["--guard-prefix"] = 
+      &::cli::thunk< options, NarrowString, &options::guard_prefix_,
+        &options::guard_prefix_specified_ >;
+      _cli_options_map_["--hxx-suffix"] = 
+      &::cli::thunk< options, NarrowString, &options::hxx_suffix_,
+        &options::hxx_suffix_specified_ >;
+      _cli_options_map_["--ixx-suffix"] = 
+      &::cli::thunk< options, NarrowString, &options::ixx_suffix_,
+        &options::ixx_suffix_specified_ >;
+      _cli_options_map_["--cxx-suffix"] = 
+      &::cli::thunk< options, NarrowString, &options::cxx_suffix_,
+        &options::cxx_suffix_specified_ >;
+      _cli_options_map_["--fwd-suffix"] = 
+      &::cli::thunk< options, NarrowString, &options::fwd_suffix_,
+        &options::fwd_suffix_specified_ >;
+      _cli_options_map_["--hxx-regex"] = 
+      &::cli::thunk< options, NarrowString, &options::hxx_regex_,
+        &options::hxx_regex_specified_ >;
+      _cli_options_map_["--ixx-regex"] = 
+      &::cli::thunk< options, NarrowString, &options::ixx_regex_,
+        &options::ixx_regex_specified_ >;
+      _cli_options_map_["--cxx-regex"] = 
+      &::cli::thunk< options, NarrowString, &options::cxx_regex_,
+        &options::cxx_regex_specified_ >;
+      _cli_options_map_["--fwd-regex"] = 
+      &::cli::thunk< options, NarrowString, &options::fwd_regex_,
+        &options::fwd_regex_specified_ >;
+      _cli_options_map_["--hxx-prologue"] = 
+      &::cli::thunk< options, NarrowStrings, &options::hxx_prologue_,
+        &options::hxx_prologue_specified_ >;
+      _cli_options_map_["--ixx-prologue"] = 
+      &::cli::thunk< options, NarrowStrings, &options::ixx_prologue_,
+        &options::ixx_prologue_specified_ >;
+      _cli_options_map_["--cxx-prologue"] = 
+      &::cli::thunk< options, NarrowStrings, &options::cxx_prologue_,
+        &options::cxx_prologue_specified_ >;
+      _cli_options_map_["--fwd-prologue"] = 
+      &::cli::thunk< options, NarrowStrings, &options::fwd_prologue_,
+        &options::fwd_prologue_specified_ >;
+      _cli_options_map_["--prologue"] = 
+      &::cli::thunk< options, NarrowStrings, &options::prologue_,
+        &options::prologue_specified_ >;
+      _cli_options_map_["--hxx-epilogue"] = 
+      &::cli::thunk< options, NarrowStrings, &options::hxx_epilogue_,
+        &options::hxx_epilogue_specified_ >;
+      _cli_options_map_["--ixx-epilogue"] = 
+      &::cli::thunk< options, NarrowStrings, &options::ixx_epilogue_,
+        &options::ixx_epilogue_specified_ >;
+      _cli_options_map_["--cxx-epilogue"] = 
+      &::cli::thunk< options, NarrowStrings, &options::cxx_epilogue_,
+        &options::cxx_epilogue_specified_ >;
+      _cli_options_map_["--fwd-epilogue"] = 
+      &::cli::thunk< options, NarrowStrings, &options::fwd_epilogue_,
+        &options::fwd_epilogue_specified_ >;
+      _cli_options_map_["--epilogue"] = 
+      &::cli::thunk< options, NarrowStrings, &options::epilogue_,
+        &options::epilogue_specified_ >;
+      _cli_options_map_["--hxx-prologue-file"] = 
+      &::cli::thunk< options, NarrowString, &options::hxx_prologue_file_,
+        &options::hxx_prologue_file_specified_ >;
+      _cli_options_map_["--ixx-prologue-file"] = 
+      &::cli::thunk< options, NarrowString, &options::ixx_prologue_file_,
+        &options::ixx_prologue_file_specified_ >;
+      _cli_options_map_["--cxx-prologue-file"] = 
+      &::cli::thunk< options, NarrowString, &options::cxx_prologue_file_,
+        &options::cxx_prologue_file_specified_ >;
+      _cli_options_map_["--fwd-prologue-file"] = 
+      &::cli::thunk< options, NarrowString, &options::fwd_prologue_file_,
+        &options::fwd_prologue_file_specified_ >;
+      _cli_options_map_["--prologue-file"] = 
+      &::cli::thunk< options, NarrowString, &options::prologue_file_,
+        &options::prologue_file_specified_ >;
+      _cli_options_map_["--hxx-epilogue-file"] = 
+      &::cli::thunk< options, NarrowString, &options::hxx_epilogue_file_,
+        &options::hxx_epilogue_file_specified_ >;
+      _cli_options_map_["--ixx-epilogue-file"] = 
+      &::cli::thunk< options, NarrowString, &options::ixx_epilogue_file_,
+        &options::ixx_epilogue_file_specified_ >;
+      _cli_options_map_["--cxx-epilogue-file"] = 
+      &::cli::thunk< options, NarrowString, &options::cxx_epilogue_file_,
+        &options::cxx_epilogue_file_specified_ >;
+      _cli_options_map_["--fwd-epilogue-file"] = 
+      &::cli::thunk< options, NarrowString, &options::fwd_epilogue_file_,
+        &options::fwd_epilogue_file_specified_ >;
+      _cli_options_map_["--epilogue-file"] = 
+      &::cli::thunk< options, NarrowString, &options::epilogue_file_,
+        &options::epilogue_file_specified_ >;
+      _cli_options_map_["--export-symbol"] = 
+      &::cli::thunk< options, NarrowString, &options::export_symbol_,
+        &options::export_symbol_specified_ >;
+      _cli_options_map_["--export-xml-schema"] = 
+      &::cli::thunk< options, bool, &options::export_xml_schema_ >;
+      _cli_options_map_["--export-maps"] = 
+      &::cli::thunk< options, bool, &options::export_maps_ >;
+      _cli_options_map_["--import-maps"] = 
+      &::cli::thunk< options, bool, &options::import_maps_ >;
+      _cli_options_map_["--generate-dep"] = 
+      &::cli::thunk< options, bool, &options::generate_dep_ >;
+      _cli_options_map_["--generate-dep-only"] = 
+      &::cli::thunk< options, bool, &options::generate_dep_only_ >;
+      _cli_options_map_["--dep-phony"] = 
+      &::cli::thunk< options, bool, &options::dep_phony_ >;
+      _cli_options_map_["--dep-target"] = 
+      &::cli::thunk< options, NarrowStrings, &options::dep_target_,
+        &options::dep_target_specified_ >;
+      _cli_options_map_["--dep-suffix"] = 
+      &::cli::thunk< options, NarrowString, &options::dep_suffix_,
+        &options::dep_suffix_specified_ >;
+      _cli_options_map_["--dep-regex"] = 
+      &::cli::thunk< options, NarrowString, &options::dep_regex_,
+        &options::dep_regex_specified_ >;
+    }
+  };
+
+  static _cli_options_map_init _cli_options_map_init_;
+
+  bool options::
+  _parse (const char* o, ::cli::scanner& s)
+  {
+    _cli_options_map::const_iterator i (_cli_options_map_.find (o));
+
+    if (i != _cli_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // options base
+    //
+    if (::options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/xsd/xsd/cxx/options.hxx b/xsd/xsd/cxx/options.hxx
new file mode 100644
index 0000000..dea93a0
--- /dev/null
+++ b/xsd/xsd/cxx/options.hxx
@@ -0,0 +1,440 @@
+// This code was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef CXX_OPTIONS_HXX
+#define CXX_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <cstddef>
+
+#include <types.hxx>
+
+#include <cxx/option-types.hxx>
+
+#include <options.hxx>
+
+namespace CXX
+{
+  class options: public ::options
+  {
+    public:
+    // Option accessors.
+    //
+    const cxx_version&
+    std () const;
+
+    bool
+    std_specified () const;
+
+    const NarrowString&
+    char_type () const;
+
+    bool
+    char_type_specified () const;
+
+    const NarrowString&
+    char_encoding () const;
+
+    bool
+    char_encoding_specified () const;
+
+    const NarrowString&
+    output_dir () const;
+
+    bool
+    output_dir_specified () const;
+
+    const bool&
+    generate_inline () const;
+
+    const bool&
+    generate_xml_schema () const;
+
+    const NarrowString&
+    extern_xml_schema () const;
+
+    bool
+    extern_xml_schema_specified () const;
+
+    const NarrowStrings&
+    namespace_map () const;
+
+    bool
+    namespace_map_specified () const;
+
+    const NarrowStrings&
+    namespace_regex () const;
+
+    bool
+    namespace_regex_specified () const;
+
+    const bool&
+    namespace_regex_trace () const;
+
+    const NarrowStrings&
+    reserved_name () const;
+
+    bool
+    reserved_name_specified () const;
+
+    const bool&
+    include_with_brackets () const;
+
+    const NarrowString&
+    include_prefix () const;
+
+    bool
+    include_prefix_specified () const;
+
+    const NarrowStrings&
+    include_regex () const;
+
+    bool
+    include_regex_specified () const;
+
+    const bool&
+    include_regex_trace () const;
+
+    const NarrowString&
+    guard_prefix () const;
+
+    bool
+    guard_prefix_specified () const;
+
+    const NarrowString&
+    hxx_suffix () const;
+
+    bool
+    hxx_suffix_specified () const;
+
+    const NarrowString&
+    ixx_suffix () const;
+
+    bool
+    ixx_suffix_specified () const;
+
+    const NarrowString&
+    cxx_suffix () const;
+
+    bool
+    cxx_suffix_specified () const;
+
+    const NarrowString&
+    fwd_suffix () const;
+
+    bool
+    fwd_suffix_specified () const;
+
+    const NarrowString&
+    hxx_regex () const;
+
+    bool
+    hxx_regex_specified () const;
+
+    const NarrowString&
+    ixx_regex () const;
+
+    bool
+    ixx_regex_specified () const;
+
+    const NarrowString&
+    cxx_regex () const;
+
+    bool
+    cxx_regex_specified () const;
+
+    const NarrowString&
+    fwd_regex () const;
+
+    bool
+    fwd_regex_specified () const;
+
+    const NarrowStrings&
+    hxx_prologue () const;
+
+    bool
+    hxx_prologue_specified () const;
+
+    const NarrowStrings&
+    ixx_prologue () const;
+
+    bool
+    ixx_prologue_specified () const;
+
+    const NarrowStrings&
+    cxx_prologue () const;
+
+    bool
+    cxx_prologue_specified () const;
+
+    const NarrowStrings&
+    fwd_prologue () const;
+
+    bool
+    fwd_prologue_specified () const;
+
+    const NarrowStrings&
+    prologue () const;
+
+    bool
+    prologue_specified () const;
+
+    const NarrowStrings&
+    hxx_epilogue () const;
+
+    bool
+    hxx_epilogue_specified () const;
+
+    const NarrowStrings&
+    ixx_epilogue () const;
+
+    bool
+    ixx_epilogue_specified () const;
+
+    const NarrowStrings&
+    cxx_epilogue () const;
+
+    bool
+    cxx_epilogue_specified () const;
+
+    const NarrowStrings&
+    fwd_epilogue () const;
+
+    bool
+    fwd_epilogue_specified () const;
+
+    const NarrowStrings&
+    epilogue () const;
+
+    bool
+    epilogue_specified () const;
+
+    const NarrowString&
+    hxx_prologue_file () const;
+
+    bool
+    hxx_prologue_file_specified () const;
+
+    const NarrowString&
+    ixx_prologue_file () const;
+
+    bool
+    ixx_prologue_file_specified () const;
+
+    const NarrowString&
+    cxx_prologue_file () const;
+
+    bool
+    cxx_prologue_file_specified () const;
+
+    const NarrowString&
+    fwd_prologue_file () const;
+
+    bool
+    fwd_prologue_file_specified () const;
+
+    const NarrowString&
+    prologue_file () const;
+
+    bool
+    prologue_file_specified () const;
+
+    const NarrowString&
+    hxx_epilogue_file () const;
+
+    bool
+    hxx_epilogue_file_specified () const;
+
+    const NarrowString&
+    ixx_epilogue_file () const;
+
+    bool
+    ixx_epilogue_file_specified () const;
+
+    const NarrowString&
+    cxx_epilogue_file () const;
+
+    bool
+    cxx_epilogue_file_specified () const;
+
+    const NarrowString&
+    fwd_epilogue_file () const;
+
+    bool
+    fwd_epilogue_file_specified () const;
+
+    const NarrowString&
+    epilogue_file () const;
+
+    bool
+    epilogue_file_specified () const;
+
+    const NarrowString&
+    export_symbol () const;
+
+    bool
+    export_symbol_specified () const;
+
+    const bool&
+    export_xml_schema () const;
+
+    const bool&
+    export_maps () const;
+
+    const bool&
+    import_maps () const;
+
+    const bool&
+    generate_dep () const;
+
+    const bool&
+    generate_dep_only () const;
+
+    const bool&
+    dep_phony () const;
+
+    const NarrowStrings&
+    dep_target () const;
+
+    bool
+    dep_target_specified () const;
+
+    const NarrowString&
+    dep_suffix () const;
+
+    bool
+    dep_suffix_specified () const;
+
+    const NarrowString&
+    dep_regex () const;
+
+    bool
+    dep_regex_specified () const;
+
+    // Print usage information.
+    //
+    static void
+    print_usage (::std::wostream&);
+
+    // Implementation details.
+    //
+    protected:
+    options ();
+
+    bool
+    _parse (const char*, ::cli::scanner&);
+
+    public:
+    cxx_version std_;
+    bool std_specified_;
+    NarrowString char_type_;
+    bool char_type_specified_;
+    NarrowString char_encoding_;
+    bool char_encoding_specified_;
+    NarrowString output_dir_;
+    bool output_dir_specified_;
+    bool generate_inline_;
+    bool generate_xml_schema_;
+    NarrowString extern_xml_schema_;
+    bool extern_xml_schema_specified_;
+    NarrowStrings namespace_map_;
+    bool namespace_map_specified_;
+    NarrowStrings namespace_regex_;
+    bool namespace_regex_specified_;
+    bool namespace_regex_trace_;
+    NarrowStrings reserved_name_;
+    bool reserved_name_specified_;
+    bool include_with_brackets_;
+    NarrowString include_prefix_;
+    bool include_prefix_specified_;
+    NarrowStrings include_regex_;
+    bool include_regex_specified_;
+    bool include_regex_trace_;
+    NarrowString guard_prefix_;
+    bool guard_prefix_specified_;
+    NarrowString hxx_suffix_;
+    bool hxx_suffix_specified_;
+    NarrowString ixx_suffix_;
+    bool ixx_suffix_specified_;
+    NarrowString cxx_suffix_;
+    bool cxx_suffix_specified_;
+    NarrowString fwd_suffix_;
+    bool fwd_suffix_specified_;
+    NarrowString hxx_regex_;
+    bool hxx_regex_specified_;
+    NarrowString ixx_regex_;
+    bool ixx_regex_specified_;
+    NarrowString cxx_regex_;
+    bool cxx_regex_specified_;
+    NarrowString fwd_regex_;
+    bool fwd_regex_specified_;
+    NarrowStrings hxx_prologue_;
+    bool hxx_prologue_specified_;
+    NarrowStrings ixx_prologue_;
+    bool ixx_prologue_specified_;
+    NarrowStrings cxx_prologue_;
+    bool cxx_prologue_specified_;
+    NarrowStrings fwd_prologue_;
+    bool fwd_prologue_specified_;
+    NarrowStrings prologue_;
+    bool prologue_specified_;
+    NarrowStrings hxx_epilogue_;
+    bool hxx_epilogue_specified_;
+    NarrowStrings ixx_epilogue_;
+    bool ixx_epilogue_specified_;
+    NarrowStrings cxx_epilogue_;
+    bool cxx_epilogue_specified_;
+    NarrowStrings fwd_epilogue_;
+    bool fwd_epilogue_specified_;
+    NarrowStrings epilogue_;
+    bool epilogue_specified_;
+    NarrowString hxx_prologue_file_;
+    bool hxx_prologue_file_specified_;
+    NarrowString ixx_prologue_file_;
+    bool ixx_prologue_file_specified_;
+    NarrowString cxx_prologue_file_;
+    bool cxx_prologue_file_specified_;
+    NarrowString fwd_prologue_file_;
+    bool fwd_prologue_file_specified_;
+    NarrowString prologue_file_;
+    bool prologue_file_specified_;
+    NarrowString hxx_epilogue_file_;
+    bool hxx_epilogue_file_specified_;
+    NarrowString ixx_epilogue_file_;
+    bool ixx_epilogue_file_specified_;
+    NarrowString cxx_epilogue_file_;
+    bool cxx_epilogue_file_specified_;
+    NarrowString fwd_epilogue_file_;
+    bool fwd_epilogue_file_specified_;
+    NarrowString epilogue_file_;
+    bool epilogue_file_specified_;
+    NarrowString export_symbol_;
+    bool export_symbol_specified_;
+    bool export_xml_schema_;
+    bool export_maps_;
+    bool import_maps_;
+    bool generate_dep_;
+    bool generate_dep_only_;
+    bool dep_phony_;
+    NarrowStrings dep_target_;
+    bool dep_target_specified_;
+    NarrowString dep_suffix_;
+    bool dep_suffix_specified_;
+    NarrowString dep_regex_;
+    bool dep_regex_specified_;
+  };
+}
+
+#include <cxx/options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // CXX_OPTIONS_HXX
diff --git a/xsd/xsd/cxx/options.ixx b/xsd/xsd/cxx/options.ixx
new file mode 100644
index 0000000..0a8cafa
--- /dev/null
+++ b/xsd/xsd/cxx/options.ixx
@@ -0,0 +1,601 @@
+// This code was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace CXX
+{
+  // options
+  //
+
+  inline const cxx_version& options::
+  std () const
+  {
+    return this->std_;
+  }
+
+  inline bool options::
+  std_specified () const
+  {
+    return this->std_specified_;
+  }
+
+  inline const NarrowString& options::
+  char_type () const
+  {
+    return this->char_type_;
+  }
+
+  inline bool options::
+  char_type_specified () const
+  {
+    return this->char_type_specified_;
+  }
+
+  inline const NarrowString& options::
+  char_encoding () const
+  {
+    return this->char_encoding_;
+  }
+
+  inline bool options::
+  char_encoding_specified () const
+  {
+    return this->char_encoding_specified_;
+  }
+
+  inline const NarrowString& options::
+  output_dir () const
+  {
+    return this->output_dir_;
+  }
+
+  inline bool options::
+  output_dir_specified () const
+  {
+    return this->output_dir_specified_;
+  }
+
+  inline const bool& options::
+  generate_inline () const
+  {
+    return this->generate_inline_;
+  }
+
+  inline const bool& options::
+  generate_xml_schema () const
+  {
+    return this->generate_xml_schema_;
+  }
+
+  inline const NarrowString& options::
+  extern_xml_schema () const
+  {
+    return this->extern_xml_schema_;
+  }
+
+  inline bool options::
+  extern_xml_schema_specified () const
+  {
+    return this->extern_xml_schema_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  namespace_map () const
+  {
+    return this->namespace_map_;
+  }
+
+  inline bool options::
+  namespace_map_specified () const
+  {
+    return this->namespace_map_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  namespace_regex () const
+  {
+    return this->namespace_regex_;
+  }
+
+  inline bool options::
+  namespace_regex_specified () const
+  {
+    return this->namespace_regex_specified_;
+  }
+
+  inline const bool& options::
+  namespace_regex_trace () const
+  {
+    return this->namespace_regex_trace_;
+  }
+
+  inline const NarrowStrings& options::
+  reserved_name () const
+  {
+    return this->reserved_name_;
+  }
+
+  inline bool options::
+  reserved_name_specified () const
+  {
+    return this->reserved_name_specified_;
+  }
+
+  inline const bool& options::
+  include_with_brackets () const
+  {
+    return this->include_with_brackets_;
+  }
+
+  inline const NarrowString& options::
+  include_prefix () const
+  {
+    return this->include_prefix_;
+  }
+
+  inline bool options::
+  include_prefix_specified () const
+  {
+    return this->include_prefix_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  include_regex () const
+  {
+    return this->include_regex_;
+  }
+
+  inline bool options::
+  include_regex_specified () const
+  {
+    return this->include_regex_specified_;
+  }
+
+  inline const bool& options::
+  include_regex_trace () const
+  {
+    return this->include_regex_trace_;
+  }
+
+  inline const NarrowString& options::
+  guard_prefix () const
+  {
+    return this->guard_prefix_;
+  }
+
+  inline bool options::
+  guard_prefix_specified () const
+  {
+    return this->guard_prefix_specified_;
+  }
+
+  inline const NarrowString& options::
+  hxx_suffix () const
+  {
+    return this->hxx_suffix_;
+  }
+
+  inline bool options::
+  hxx_suffix_specified () const
+  {
+    return this->hxx_suffix_specified_;
+  }
+
+  inline const NarrowString& options::
+  ixx_suffix () const
+  {
+    return this->ixx_suffix_;
+  }
+
+  inline bool options::
+  ixx_suffix_specified () const
+  {
+    return this->ixx_suffix_specified_;
+  }
+
+  inline const NarrowString& options::
+  cxx_suffix () const
+  {
+    return this->cxx_suffix_;
+  }
+
+  inline bool options::
+  cxx_suffix_specified () const
+  {
+    return this->cxx_suffix_specified_;
+  }
+
+  inline const NarrowString& options::
+  fwd_suffix () const
+  {
+    return this->fwd_suffix_;
+  }
+
+  inline bool options::
+  fwd_suffix_specified () const
+  {
+    return this->fwd_suffix_specified_;
+  }
+
+  inline const NarrowString& options::
+  hxx_regex () const
+  {
+    return this->hxx_regex_;
+  }
+
+  inline bool options::
+  hxx_regex_specified () const
+  {
+    return this->hxx_regex_specified_;
+  }
+
+  inline const NarrowString& options::
+  ixx_regex () const
+  {
+    return this->ixx_regex_;
+  }
+
+  inline bool options::
+  ixx_regex_specified () const
+  {
+    return this->ixx_regex_specified_;
+  }
+
+  inline const NarrowString& options::
+  cxx_regex () const
+  {
+    return this->cxx_regex_;
+  }
+
+  inline bool options::
+  cxx_regex_specified () const
+  {
+    return this->cxx_regex_specified_;
+  }
+
+  inline const NarrowString& options::
+  fwd_regex () const
+  {
+    return this->fwd_regex_;
+  }
+
+  inline bool options::
+  fwd_regex_specified () const
+  {
+    return this->fwd_regex_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  hxx_prologue () const
+  {
+    return this->hxx_prologue_;
+  }
+
+  inline bool options::
+  hxx_prologue_specified () const
+  {
+    return this->hxx_prologue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  ixx_prologue () const
+  {
+    return this->ixx_prologue_;
+  }
+
+  inline bool options::
+  ixx_prologue_specified () const
+  {
+    return this->ixx_prologue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  cxx_prologue () const
+  {
+    return this->cxx_prologue_;
+  }
+
+  inline bool options::
+  cxx_prologue_specified () const
+  {
+    return this->cxx_prologue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  fwd_prologue () const
+  {
+    return this->fwd_prologue_;
+  }
+
+  inline bool options::
+  fwd_prologue_specified () const
+  {
+    return this->fwd_prologue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  prologue () const
+  {
+    return this->prologue_;
+  }
+
+  inline bool options::
+  prologue_specified () const
+  {
+    return this->prologue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  hxx_epilogue () const
+  {
+    return this->hxx_epilogue_;
+  }
+
+  inline bool options::
+  hxx_epilogue_specified () const
+  {
+    return this->hxx_epilogue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  ixx_epilogue () const
+  {
+    return this->ixx_epilogue_;
+  }
+
+  inline bool options::
+  ixx_epilogue_specified () const
+  {
+    return this->ixx_epilogue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  cxx_epilogue () const
+  {
+    return this->cxx_epilogue_;
+  }
+
+  inline bool options::
+  cxx_epilogue_specified () const
+  {
+    return this->cxx_epilogue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  fwd_epilogue () const
+  {
+    return this->fwd_epilogue_;
+  }
+
+  inline bool options::
+  fwd_epilogue_specified () const
+  {
+    return this->fwd_epilogue_specified_;
+  }
+
+  inline const NarrowStrings& options::
+  epilogue () const
+  {
+    return this->epilogue_;
+  }
+
+  inline bool options::
+  epilogue_specified () const
+  {
+    return this->epilogue_specified_;
+  }
+
+  inline const NarrowString& options::
+  hxx_prologue_file () const
+  {
+    return this->hxx_prologue_file_;
+  }
+
+  inline bool options::
+  hxx_prologue_file_specified () const
+  {
+    return this->hxx_prologue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  ixx_prologue_file () const
+  {
+    return this->ixx_prologue_file_;
+  }
+
+  inline bool options::
+  ixx_prologue_file_specified () const
+  {
+    return this->ixx_prologue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  cxx_prologue_file () const
+  {
+    return this->cxx_prologue_file_;
+  }
+
+  inline bool options::
+  cxx_prologue_file_specified () const
+  {
+    return this->cxx_prologue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  fwd_prologue_file () const
+  {
+    return this->fwd_prologue_file_;
+  }
+
+  inline bool options::
+  fwd_prologue_file_specified () const
+  {
+    return this->fwd_prologue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  prologue_file () const
+  {
+    return this->prologue_file_;
+  }
+
+  inline bool options::
+  prologue_file_specified () const
+  {
+    return this->prologue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  hxx_epilogue_file () const
+  {
+    return this->hxx_epilogue_file_;
+  }
+
+  inline bool options::
+  hxx_epilogue_file_specified () const
+  {
+    return this->hxx_epilogue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  ixx_epilogue_file () const
+  {
+    return this->ixx_epilogue_file_;
+  }
+
+  inline bool options::
+  ixx_epilogue_file_specified () const
+  {
+    return this->ixx_epilogue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  cxx_epilogue_file () const
+  {
+    return this->cxx_epilogue_file_;
+  }
+
+  inline bool options::
+  cxx_epilogue_file_specified () const
+  {
+    return this->cxx_epilogue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  fwd_epilogue_file () const
+  {
+    return this->fwd_epilogue_file_;
+  }
+
+  inline bool options::
+  fwd_epilogue_file_specified () const
+  {
+    return this->fwd_epilogue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  epilogue_file () const
+  {
+    return this->epilogue_file_;
+  }
+
+  inline bool options::
+  epilogue_file_specified () const
+  {
+    return this->epilogue_file_specified_;
+  }
+
+  inline const NarrowString& options::
+  export_symbol () const
+  {
+    return this->export_symbol_;
+  }
+
+  inline bool options::
+  export_symbol_specified () const
+  {
+    return this->export_symbol_specified_;
+  }
+
+  inline const bool& options::
+  export_xml_schema () const
+  {
+    return this->export_xml_schema_;
+  }
+
+  inline const bool& options::
+  export_maps () const
+  {
+    return this->export_maps_;
+  }
+
+  inline const bool& options::
+  import_maps () const
+  {
+    return this->import_maps_;
+  }
+
+  inline const bool& options::
+  generate_dep () const
+  {
+    return this->generate_dep_;
+  }
+
+  inline const bool& options::
+  generate_dep_only () const
+  {
+    return this->generate_dep_only_;
+  }
+
+  inline const bool& options::
+  dep_phony () const
+  {
+    return this->dep_phony_;
+  }
+
+  inline const NarrowStrings& options::
+  dep_target () const
+  {
+    return this->dep_target_;
+  }
+
+  inline bool options::
+  dep_target_specified () const
+  {
+    return this->dep_target_specified_;
+  }
+
+  inline const NarrowString& options::
+  dep_suffix () const
+  {
+    return this->dep_suffix_;
+  }
+
+  inline bool options::
+  dep_suffix_specified () const
+  {
+    return this->dep_suffix_specified_;
+  }
+
+  inline const NarrowString& options::
+  dep_regex () const
+  {
+    return this->dep_regex_;
+  }
+
+  inline bool options::
+  dep_regex_specified () const
+  {
+    return this->dep_regex_specified_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/xsd/xsd/cxx/parser/attribute-validation-source.cxx b/xsd/xsd/cxx/parser/attribute-validation-source.cxx
index 536e2da..7ed54e4 100644
--- a/xsd/xsd/cxx/parser/attribute-validation-source.cxx
+++ b/xsd/xsd/cxx/parser/attribute-validation-source.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/attribute-validation-source.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/parser/attribute-validation-source.hxx>
@@ -23,7 +22,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Attribute& a)
         {
           String const& name (a.name ());
@@ -39,7 +38,7 @@ namespace CXX
             os << "n == " << strlit (name) << " && ns.empty ()";
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute& a)
         {
           String const& ns (a.definition_namespace ().name ());
@@ -93,7 +92,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           String const& name (ename (a));
@@ -120,10 +119,20 @@ namespace CXX
             os << "this->" << inst << "->" << post << " ();"
                << "this->" << name << " ();";
           else
-            os << arg_type (type) << " tmp (this->" << inst << "->" <<
-              post << " ());"
-               << "this->" << name << " (tmp);"
-               << endl;
+          {
+            // Don't create an lvalue in C++11 (think std::unique_ptr).
+            // In C++98 we do it for compatibility with older/broken
+            // compilers (e.g., IBM xlC that needs an lvalue to pass
+            // std::auto_ptr).
+            //
+            if (std == cxx_version::cxx98)
+              os << arg_type (type) << " tmp (this->" << inst << "->" <<
+                post << " ());"
+                 << "this->" << name << " (tmp);";
+            else
+              os << "this->" << name << " (this->" << inst << "->" <<
+                post << " ());";
+          }
 
           os << "}";
 
@@ -149,7 +158,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           os << "if (";
@@ -177,7 +186,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           if (!a.optional_p ())
@@ -195,7 +204,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           if (!a.optional_p ())
@@ -227,16 +236,16 @@ namespace CXX
           names_attribute_state_check_ >> attribute_state_check_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
-          Boolean has_att (has<Traversal::Attribute> (c));
-          Boolean has_any (has<Traversal::AnyAttribute> (c));
+          bool has_att (has<Traversal::Attribute> (c));
+          bool has_any (has<Traversal::AnyAttribute> (c));
 
           if (!has_att && !has_any)
             return;
 
-          Boolean has_req_att (false);
+          bool has_req_att (false);
           if (has_att)
           {
             RequiredAttributeTest test (has_req_att);
@@ -380,12 +389,12 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_attribute_validation_source (Context& ctx)
     {
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names schema_names;
 
       Namespace ns (ctx);
diff --git a/xsd/xsd/cxx/parser/attribute-validation-source.hxx b/xsd/xsd/cxx/parser/attribute-validation-source.hxx
index a11f434..10438fd 100644
--- a/xsd/xsd/cxx/parser/attribute-validation-source.hxx
+++ b/xsd/xsd/cxx/parser/attribute-validation-source.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/attribute-validation-source.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_ATTRIBUTE_VALIDATION_SOURCE_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Parser
   {
-    Void
+    void
     generate_attribute_validation_source (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/parser/characters-validation-source.cxx b/xsd/xsd/cxx/parser/characters-validation-source.cxx
index 236f2f5..ddecc70 100644
--- a/xsd/xsd/cxx/parser/characters-validation-source.cxx
+++ b/xsd/xsd/cxx/parser/characters-validation-source.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/characters-validation-source.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/parser/characters-validation-source.hxx>
@@ -23,7 +22,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           if (!c.mixed_p ())
@@ -46,7 +45,7 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_characters_validation_source (Context& ctx)
     {
       //@@ Most of the time there is no mixed content type so
@@ -56,7 +55,7 @@ namespace CXX
       //
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names schema_names;
 
       Namespace ns (ctx);
diff --git a/xsd/xsd/cxx/parser/characters-validation-source.hxx b/xsd/xsd/cxx/parser/characters-validation-source.hxx
index 2c1a1b1..219df3e 100644
--- a/xsd/xsd/cxx/parser/characters-validation-source.hxx
+++ b/xsd/xsd/cxx/parser/characters-validation-source.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/characters-validation-source.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_CHARACTERS_VALIDATION_SOURCE_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Parser
   {
-    Void
+    void
     generate_characters_validation_source (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/parser/cli.hxx b/xsd/xsd/cxx/parser/cli.hxx
deleted file mode 100644
index bc7ca1a..0000000
--- a/xsd/xsd/cxx/parser/cli.hxx
+++ /dev/null
@@ -1,154 +0,0 @@
-// file      : xsd/cxx/parser/cli.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
-// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
-
-#ifndef CXX_PARSER_CLI_HXX
-#define CXX_PARSER_CLI_HXX
-
-#include <cult/types.hxx>
-
-#include <cult/containers/vector.hxx>
-
-#include <cult/cli/options.hxx>
-#include <cult/cli/options-spec.hxx>
-
-namespace CXX
-{
-  namespace Parser
-  {
-    namespace CLI
-    {
-      using namespace Cult::Types;
-
-      typedef Char const Key[];
-
-      extern Key type_map;
-      extern Key char_encoding;
-      extern Key char_type;
-      extern Key output_dir;
-      extern Key xml_parser;
-      extern Key generate_inline;
-      extern Key generate_validation;
-      extern Key suppress_validation;
-      extern Key generate_polymorphic;
-      extern Key generate_noop_impl;
-      extern Key generate_print_impl;
-      extern Key generate_test_driver;
-      extern Key force_overwrite;
-      extern Key root_element_first;
-      extern Key root_element_last;
-      extern Key root_element;
-      extern Key generate_xml_schema;
-      extern Key extern_xml_schema;
-      extern Key skel_type_suffix;
-      extern Key skel_file_suffix;
-      extern Key impl_type_suffix;
-      extern Key impl_file_suffix;
-      extern Key namespace_map;
-      extern Key namespace_regex;
-      extern Key namespace_regex_trace;
-      extern Key reserved_name;
-      extern Key include_with_brackets;
-      extern Key include_prefix;
-      extern Key include_regex;
-      extern Key include_regex_trace;
-      extern Key guard_prefix;
-      extern Key hxx_suffix;
-      extern Key ixx_suffix;
-      extern Key cxx_suffix;
-      extern Key hxx_regex;
-      extern Key ixx_regex;
-      extern Key cxx_regex;
-      extern Key hxx_prologue;
-      extern Key ixx_prologue;
-      extern Key cxx_prologue;
-      extern Key prologue;
-      extern Key hxx_epilogue;
-      extern Key ixx_epilogue;
-      extern Key cxx_epilogue;
-      extern Key epilogue;
-      extern Key hxx_prologue_file;
-      extern Key ixx_prologue_file;
-      extern Key cxx_prologue_file;
-      extern Key prologue_file;
-      extern Key hxx_epilogue_file;
-      extern Key ixx_epilogue_file;
-      extern Key cxx_epilogue_file;
-      extern Key epilogue_file;
-      extern Key export_symbol;
-      extern Key export_maps;
-      extern Key import_maps;
-      extern Key show_anonymous;
-      extern Key show_sloc;
-      extern Key proprietary_license;
-
-      typedef Cult::CLI::Options<
-        type_map,                 Cult::Containers::Vector<NarrowString>,
-        char_type,                NarrowString,
-        char_encoding,            NarrowString,
-        output_dir,               NarrowString,
-        xml_parser,               NarrowString,
-        generate_inline,          Boolean,
-        generate_validation,      Boolean,
-        suppress_validation,      Boolean,
-        generate_polymorphic,     Boolean,
-        generate_noop_impl,       Boolean,
-        generate_print_impl,      Boolean,
-        generate_test_driver,     Boolean,
-        force_overwrite,          Boolean,
-        root_element_first,       Boolean,
-        root_element_last,        Boolean,
-        root_element,             NarrowString,
-        generate_xml_schema,      Boolean,
-        extern_xml_schema,        NarrowString,
-        skel_type_suffix,         NarrowString,
-        skel_file_suffix,         NarrowString,
-        impl_type_suffix,         NarrowString,
-        impl_file_suffix,         NarrowString,
-        namespace_map,            Cult::Containers::Vector<NarrowString>,
-        namespace_regex,          Cult::Containers::Vector<NarrowString>,
-        namespace_regex_trace,    Boolean,
-        reserved_name,            Cult::Containers::Vector<NarrowString>,
-        include_with_brackets,    Boolean,
-        include_prefix,           NarrowString,
-        include_regex,            Cult::Containers::Vector<NarrowString>,
-        include_regex_trace,      Boolean,
-        guard_prefix,             NarrowString,
-        hxx_suffix,               NarrowString,
-        ixx_suffix,               NarrowString,
-        cxx_suffix,               NarrowString,
-        hxx_regex,                NarrowString,
-        ixx_regex,                NarrowString,
-        cxx_regex,                NarrowString,
-        hxx_prologue,             Cult::Containers::Vector<NarrowString>,
-        ixx_prologue,             Cult::Containers::Vector<NarrowString>,
-        cxx_prologue,             Cult::Containers::Vector<NarrowString>,
-        prologue,                 Cult::Containers::Vector<NarrowString>,
-        hxx_epilogue,             Cult::Containers::Vector<NarrowString>,
-        ixx_epilogue,             Cult::Containers::Vector<NarrowString>,
-        cxx_epilogue,             Cult::Containers::Vector<NarrowString>,
-        epilogue,                 Cult::Containers::Vector<NarrowString>,
-        hxx_prologue_file,        NarrowString,
-        ixx_prologue_file,        NarrowString,
-        cxx_prologue_file,        NarrowString,
-        prologue_file,            NarrowString,
-        hxx_epilogue_file,        NarrowString,
-        ixx_epilogue_file,        NarrowString,
-        cxx_epilogue_file,        NarrowString,
-        epilogue_file,            NarrowString,
-        export_symbol,            NarrowString,
-        export_maps,              Boolean,
-        import_maps,              Boolean,
-        show_anonymous,           Boolean,
-        show_sloc,                Boolean,
-        proprietary_license,      Boolean
-
-        > Options;
-
-      struct OptionsSpec: Cult::CLI::OptionsSpec<Options> {};
-    }
-  }
-}
-
-#endif // CXX_PARSER_CLI_HXX
diff --git a/xsd/xsd/cxx/parser/driver-source.cxx b/xsd/xsd/cxx/parser/driver-source.cxx
index b48b0e0..510c965 100644
--- a/xsd/xsd/cxx/parser/driver-source.cxx
+++ b/xsd/xsd/cxx/parser/driver-source.cxx
@@ -1,18 +1,18 @@
 // file      : xsd/cxx/parser/driver-source.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
+#include <set>
+#include <map>
+#include <sstream>
+
 #include <cxx/parser/driver-source.hxx>
 #include <cxx/parser/print-impl-common.hxx>
 
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
 
-#include <cult/containers/map.hxx>
-#include <cult/containers/set.hxx>
-
-#include <sstream>
+using namespace std;
 
 namespace CXX
 {
@@ -20,23 +20,22 @@ namespace CXX
   {
     namespace
     {
-      typedef
-      Cult::Containers::Map<SemanticGraph::Type*, String>
-      TypeInstanceMap;
-
-      typedef Cult::Containers::Set<String> InstanceSet;
+      typedef map<SemanticGraph::Type*, String> TypeInstanceMap;
+      typedef set<String> InstanceSet;
 
       // For base types we only want member's types, but not the
       // base itself.
       //
-      struct BaseType: Traversal::Complex, Context
+      struct BaseType: Traversal::Complex,
+                       Traversal::List,
+                       Context
       {
-        BaseType (Context& c)
-            : Context (c)
+        BaseType (Context& c, Traversal::NodeBase& def)
+            : Context (c), def_ (def)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           inherits (c);
@@ -44,6 +43,15 @@ namespace CXX
           if (!restriction_p (c))
             names (c);
         }
+
+        virtual void
+        traverse (SemanticGraph::List& l)
+        {
+          def_.dispatch (l.argumented ().type ());
+        }
+
+      private:
+        Traversal::NodeBase& def_;
       };
 
       struct ParserDef: Traversal::Type,
@@ -109,7 +117,7 @@ namespace CXX
                         Context
       {
         ParserDef (Context& c, TypeInstanceMap& map, InstanceSet& set)
-            : Context (c), map_ (map), set_ (set), base_ (c)
+            : Context (c), map_ (map), set_ (set), base_ (c, *this)
         {
           *this >> inherits_ >> base_ >> inherits_;
 
@@ -119,7 +127,7 @@ namespace CXX
           names_ >> member_ >> belongs_ >> *this;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Type& t)
         {
           if (map_.find (&t) == map_.end ())
@@ -131,7 +139,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::List& l)
         {
           if (map_.find (&l) == map_.end ())
@@ -145,7 +153,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           if (map_.find (&c) == map_.end ())
@@ -164,13 +172,13 @@ namespace CXX
 
         // anyType & anySimpleType.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyType& t)
         {
           fund_type (t, "any_type");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnySimpleType& t)
         {
           fund_type (t, "any_simple_type");
@@ -178,7 +186,7 @@ namespace CXX
 
         // Boolean.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Boolean& t)
         {
           fund_type (t, "boolean");
@@ -186,79 +194,79 @@ namespace CXX
 
         // Integral types.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Byte& t)
         {
           fund_type (t, "byte");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedByte& t)
         {
           fund_type (t, "unsigned_byte");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Short& t)
         {
           fund_type (t, "short");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedShort& t)
         {
           fund_type (t, "unsigned_short");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Int& t)
         {
           fund_type (t, "int");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedInt& t)
         {
           fund_type (t, "unsigned_int");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Long& t)
         {
           fund_type (t, "long");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedLong& t)
         {
           fund_type (t, "unsigned_long");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Integer& t)
         {
           fund_type (t, "integer");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NonPositiveInteger& t)
         {
           fund_type (t, "non_positive_integer");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NonNegativeInteger& t)
         {
           fund_type (t, "non_negative_integer");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::PositiveInteger& t)
         {
           fund_type (t, "positive_integer");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NegativeInteger& t)
         {
           fund_type (t, "negative_integer");
@@ -266,19 +274,19 @@ namespace CXX
 
         // Floats.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Float& t)
         {
           fund_type (t, "float");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Double& t)
         {
           fund_type (t, "double");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Decimal& t)
         {
           fund_type (t, "decimal");
@@ -286,49 +294,49 @@ namespace CXX
 
         // Strings.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::String& t)
         {
           fund_type (t, "string");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NormalizedString& t)
         {
           fund_type (t, "normalized_string");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Token& t)
         {
           fund_type (t, "token");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NameToken& t)
         {
           fund_type (t, "nmtoken");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NameTokens& t)
         {
           fund_type (t, "nmtokens");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Name& t)
         {
           fund_type (t, "name");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NCName& t)
         {
           fund_type (t, "ncname");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Language& t)
         {
           fund_type (t, "language");
@@ -337,7 +345,7 @@ namespace CXX
 
         // Qualified name.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::QName& t)
         {
           fund_type (t, "qname");
@@ -346,19 +354,19 @@ namespace CXX
 
         // ID/IDREF.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Id& t)
         {
           fund_type (t, "id");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::IdRef& t)
         {
           fund_type (t, "idref");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::IdRefs& t)
         {
           fund_type (t, "idrefs");
@@ -366,7 +374,7 @@ namespace CXX
 
         // URI.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::AnyURI& t)
         {
           fund_type (t, "uri");
@@ -374,13 +382,13 @@ namespace CXX
 
         // Binary.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Base64Binary& t)
         {
           fund_type (t, "base64_binary");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::HexBinary& t)
         {
           fund_type (t, "hex_binary");
@@ -389,55 +397,55 @@ namespace CXX
 
         // Date/time.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Date& t)
         {
           fund_type (t, "date");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::DateTime& t)
         {
           fund_type (t, "date_time");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Duration& t)
         {
           fund_type (t, "duration");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Day& t)
         {
           fund_type (t, "day");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Month& t)
         {
           fund_type (t, "month");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::MonthDay& t)
         {
           fund_type (t, "month_day");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Year& t)
         {
           fund_type (t, "year");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::YearMonth& t)
         {
           fund_type (t, "year_month");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Time& t)
         {
           fund_type (t, "time");
@@ -445,20 +453,20 @@ namespace CXX
 
         // Entity.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Entity& t)
         {
           fund_type (t, "entity");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Entities& t)
         {
           fund_type (t, "entities");
         }
 
       private:
-        virtual Void
+        virtual void
         fund_type (SemanticGraph::Type& t, String const& name)
         {
           if (map_.find (&t) == map_.end ())
@@ -476,7 +484,7 @@ namespace CXX
           String base_name (escape (raw_name + L"_p"));
           String name (base_name);
 
-          for (UnsignedLong i (1); set_.find (name) != set_.end (); ++i)
+          for (size_t i (1); set_.find (name) != set_.end (); ++i)
           {
             std::wostringstream os;
             os << i;
@@ -516,7 +524,7 @@ namespace CXX
           names_ >> *this;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           inherits (c, inherits_);
@@ -525,7 +533,7 @@ namespace CXX
             names (c, names_);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::List& l)
         {
           if (!first_)
@@ -536,7 +544,7 @@ namespace CXX
           os << map_[&l.argumented ().type ()];
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Member& m)
         {
           if (skip (m))
@@ -556,7 +564,7 @@ namespace CXX
         Traversal::Inherits inherits_;
         Traversal::Names names_;
 
-        Boolean first_;
+        bool first_;
       };
 
       struct ParserConnect: Traversal::List,
@@ -564,7 +572,7 @@ namespace CXX
                             Context
       {
         ParserConnect (Context& c, TypeInstanceMap& map)
-            : Context (c), map_ (map), base_ (c)
+            : Context (c), map_ (map), base_ (c, *this)
         {
           *this >> inherits_ >> base_ >> inherits_;
 
@@ -574,7 +582,7 @@ namespace CXX
           names_ >> member_ >> belongs_ >> *this;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::List& l)
         {
           if (type_set_.find (&l) == type_set_.end ())
@@ -587,7 +595,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           if (type_set_.find (&c) == type_set_.end ())
@@ -613,7 +621,7 @@ namespace CXX
         }
 
       private:
-        Boolean
+        bool
         has_members (SemanticGraph::Complex& c)
         {
           using SemanticGraph::Complex;
@@ -636,7 +644,7 @@ namespace CXX
 
       private:
         TypeInstanceMap& map_;
-        Cult::Containers::Set<SemanticGraph::Type*> type_set_;
+        set<SemanticGraph::Type*> type_set_;
 
         BaseType base_;
         Traversal::Inherits inherits_;
@@ -647,7 +655,7 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_driver_source (Context& ctx)
     {
       // Figure out the root element. Validator should have made sure
@@ -656,7 +664,7 @@ namespace CXX
       SemanticGraph::Element* root (0);
       {
         Traversal::Schema schema;
-        Traversal::Sources sources;
+        Sources sources;
 
         schema >> sources >> schema;
 
@@ -740,7 +748,7 @@ namespace CXX
           root_p << "." << post << " ());"
            << endl;
 
-        if (ctx.options.value<CLI::generate_print_impl> ())
+        if (ctx.options.generate_print_impl ())
         {
           PrintCall t (ctx, root->name (), "v");
           t.dispatch (root_type);
diff --git a/xsd/xsd/cxx/parser/driver-source.hxx b/xsd/xsd/cxx/parser/driver-source.hxx
index 9b5a8b1..53e19d8 100644
--- a/xsd/xsd/cxx/parser/driver-source.hxx
+++ b/xsd/xsd/cxx/parser/driver-source.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/driver-source.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_DRIVER_SOURCE_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Parser
   {
-    Void
+    void
     generate_driver_source (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/parser/element-validation-source.cxx b/xsd/xsd/cxx/parser/element-validation-source.cxx
index 211a0d3..b2c244e 100644
--- a/xsd/xsd/cxx/parser/element-validation-source.cxx
+++ b/xsd/xsd/cxx/parser/element-validation-source.cxx
@@ -1,14 +1,15 @@
 // file      : xsd/cxx/parser/element-validation-source.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
+#include <vector>
+
 #include <cxx/parser/element-validation-source.hxx>
 
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
 
-#include <cult/containers/vector.hxx>
+using namespace std;
 
 namespace CXX
 {
@@ -16,8 +17,7 @@ namespace CXX
   {
     namespace
     {
-      typedef Cult::Containers::Vector<SemanticGraph::Particle*> Particles;
-
+      typedef vector<SemanticGraph::Particle*> Particles;
 
       //
       //
@@ -31,7 +31,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element& e)
         {
           String const& name (e.name ());
@@ -62,7 +62,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           String const& ns (a.definition_namespace ().name ());
@@ -109,7 +109,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Compositor& c)
         {
           // This compositor should already have been tested for
@@ -117,9 +117,9 @@ namespace CXX
           //
           Particles const& p (c.context ().get<Particles> ("prefixes"));
 
-          Boolean paren (p.size () != 1);
+          bool paren (p.size () != 1);
 
-          for (Particles::ConstIterator i (p.begin ()), e (p.end ());
+          for (Particles::const_iterator i (p.begin ()), e (p.end ());
                i != e;)
           {
             if (paren)
@@ -150,21 +150,21 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element& e)
         {
           String ns (e.qualified_p () ? e.namespace_ ().name () : String ());
           os << strlit (ns) << ", " << strlit (e.name ());
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           String const& ns (*a.namespace_begin ());
           os << strlit (ns) << ", " << L << "\"*\"";
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Compositor& c)
         {
           Particles const& p (c.context ().get<Particles> ("prefixes"));
@@ -187,7 +187,7 @@ namespace CXX
 
         // Generate sub-parser setup code as well as the pre/post calls.
         //
-        Void
+        void
         pre_post_calls (SemanticGraph::Particle& p)
         {
           using SemanticGraph::Element;
@@ -196,20 +196,23 @@ namespace CXX
           if (Element* e = dynamic_cast<Element*> (&p))
           {
             SemanticGraph::Type& type (e->type ());
-            Boolean poly (polymorphic && !anonymous (type));
+            String const& fq_type (fq_name (type));
+            bool poly (polymorphic && !anonymous (type));
 
             String name, inst, def_parser, map;
 
             if (e->context ().count("name"))
             {
               name = ename (*e);
-              inst = poly ? emember_cache (*e) : emember (*e);
 
               if (poly)
               {
                 def_parser = emember (*e);
                 map = emember_map (*e);
+                inst = "p";
               }
+              else
+                inst = L"this->" + emember (*e);
             }
             else
             {
@@ -222,13 +225,15 @@ namespace CXX
               Element& fe (dynamic_cast<Element&>(ip.first->named ()));
 
               name = ename (fe);
-              inst = poly ? emember_cache (fe) : emember (fe);
 
               if (poly)
               {
                 def_parser = emember (fe);
                 map = emember_map (fe);
+                inst = "p";
               }
+              else
+                inst = L"this->" + emember (fe);
             }
 
             if (poly)
@@ -243,8 +248,10 @@ namespace CXX
                 type_id += type_ns;
               }
 
-              os << "if (t == 0 && this->" << def_parser << " != 0)" << endl
-                 << "this->" << inst << " = this->" << def_parser << ";"
+              os << fq_type << "* p = 0;"
+                 << endl
+                 << "if (t == 0 && this->" << def_parser << " != 0)" << endl
+                 << inst << " = this->" << def_parser << ";"
                  << "else"
                  << "{"
                  << string_type << " ts (" << fq_name (type) <<
@@ -254,7 +261,7 @@ namespace CXX
                  << "t = &ts;"
                  << endl
                  << "if (this->" << def_parser << " != 0 && *t == ts)" << endl
-                 << "this->" << inst << " = this->" << def_parser << ";"
+                 << inst << " = this->" << def_parser << ";"
                  << "else"
                  << "{";
 
@@ -269,36 +276,51 @@ namespace CXX
                 " > (*t);"
                  << endl
                  << "if (this->" << map << " != 0)" << endl
-                 << "this->" << inst << " = dynamic_cast< " <<
-                fq_name (type) << "* > (" << endl
+                 << inst << " = dynamic_cast< " << fq_type << "* > (" << endl
                  << "this->" << map << "->find (*t));"
-                 << "else" << endl
-                 << "this->" << inst << " = 0;"
                  << "}"
                  << "}";
             }
 
             os << "this->" << complex_base << "::context_.top ()." <<
-              "parser_ = this->" << inst << ";"
+              "parser_ = " << inst << ";"
                << endl
-               << "if (this->" << inst << ")" << endl
-               << "this->" << inst << "->pre ();"
+               << "if (" << inst << ")" << endl
+               << inst << "->pre ();"
                << "}"
                << "else" // start
-               << "{"
-               << "if (this->" << inst << ")"
+               << "{";
+
+            if (poly)
+              os << fq_type << "* p =" << endl
+                 << "dynamic_cast< " << fq_type << "* > (" << endl
+                 << "this->" << complex_base << "::context_.top ().parser_);"
+                 << endl;
+
+            os << "if (" << inst << ")"
                << "{";
 
             String const& ret (ret_type (type));
             String const& post (post_name (type));
 
             if (ret == L"void")
-              os << "this->" << inst << "->" << post << " ();"
+              os << inst << "->" << post << " ();"
                  << "this->" << name << " ();";
             else
-              os << arg_type (type) << " tmp (this->" << inst << "->" <<
-                post << " ());"
-                 << "this->" << name << " (tmp);";
+            {
+              // Don't create an lvalue in C++11 (think std::unique_ptr).
+              // In C++98 we do it for compatibility with older/broken
+              // compilers (e.g., IBM xlC that needs an lvalue to pass
+              // std::auto_ptr).
+              //
+              if (std == cxx_version::cxx98)
+                os << arg_type (type) << " tmp (" << inst << "->" <<
+                  post << " ());"
+                   << "this->" << name << " (tmp);";
+              else
+                os << "this->" << name << " (" << inst << "->" <<
+                  post << " ());";
+            }
 
             os << "}";
           }
@@ -331,10 +353,10 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element& e)
         {
-          UnsignedLong state (e.context ().get<UnsignedLong> ("state"));
+          size_t state (e.context ().get<size_t> ("state"));
 
           if (state != 0)
             os << "else ";
@@ -382,14 +404,14 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Particle& p)
         {
           using SemanticGraph::Element;
 
-          UnsignedLong state (p.context ().get<UnsignedLong> ("state"));
+          size_t state (p.context ().get<size_t> ("state"));
 
-          UnsignedLong min (p.min ()), max (p.max ());
+          size_t min (p.min ()), max (p.max ());
 
           os << "case " << state << "UL:" << endl
              << "{";
@@ -465,15 +487,15 @@ namespace CXX
              << "}"; // case
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Compositor& c)
         {
           using SemanticGraph::Compositor;
 
-          UnsignedLong max (c.max ());
-          UnsignedLong min (c.context ().get<UnsignedLong> ("effective-min"));
-          UnsignedLong n (c.context ().get<UnsignedLong> ("comp-number"));
-          UnsignedLong state (c.context ().get<UnsignedLong> ("state"));
+          size_t max (c.max ());
+          size_t min (c.context ().get<size_t> ("effective-min"));
+          size_t n (c.context ().get<size_t> ("comp-number"));
+          size_t state (c.context ().get<size_t> ("state"));
 
           String func (c.is_a<SemanticGraph::Choice> () ?
                        "choice_" : "sequence_");
@@ -483,7 +505,7 @@ namespace CXX
              << "unsigned long s (~0UL);"
              << endl;
 
-          Boolean first (true);
+          bool first (true);
 
           for (Compositor::ContainsIterator ci (c.contains_begin ());
                ci != c.contains_end (); ++ci)
@@ -496,7 +518,7 @@ namespace CXX
             if (!p.context ().count ("prefix"))
               break;
 
-            UnsignedLong state (p.context ().get<UnsignedLong> ("state"));
+            size_t state (p.context ().get<size_t> ("state"));
 
             if (first)
               first = false;
@@ -599,8 +621,8 @@ namespace CXX
                                  ParticleInCompositor
       {
         ParticleInSequence (Context& c,
-                            UnsignedLong state,
-                            UnsignedLong next_state,
+                            size_t state,
+                            size_t next_state,
                             SemanticGraph::Complex& type)
             : ParticleInCompositor (c, type),
               state_ (state), particle_name_ (c)
@@ -617,10 +639,10 @@ namespace CXX
             next_state_ = L"~0";
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Particle& p)
         {
-          UnsignedLong min (p.min ()), max (p.max ());
+          size_t min (p.min ()), max (p.max ());
 
           os << "case " << state_ << "UL:" << endl
              << "{"
@@ -694,14 +716,14 @@ namespace CXX
              << "}"; // case
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Compositor& c)
         {
           using SemanticGraph::Compositor;
 
-          UnsignedLong max (c.max ());
-          UnsignedLong min (c.context ().get<UnsignedLong> ("effective-min"));
-          UnsignedLong n (c.context ().get<UnsignedLong> ("comp-number"));
+          size_t max (c.max ());
+          size_t min (c.context ().get<size_t> ("effective-min"));
+          size_t n (c.context ().get<size_t> ("comp-number"));
 
           String func (c.is_a<SemanticGraph::Choice> () ?
                        "choice_" : "sequence_");
@@ -711,7 +733,7 @@ namespace CXX
              << "unsigned long s (~0UL);"
              << endl;
 
-          Boolean first (true);
+          bool first (true);
 
           for (Compositor::ContainsIterator ci (c.contains_begin ());
                ci != c.contains_end (); ++ci)
@@ -724,7 +746,7 @@ namespace CXX
             if (!p.context ().count ("prefix"))
               break;
 
-            UnsignedLong state (p.context ().get<UnsignedLong> ("state"));
+            size_t state (p.context ().get<size_t> ("state"));
 
             if (first)
               first = false;
@@ -816,7 +838,7 @@ namespace CXX
         }
 
       private:
-        UnsignedLong state_;
+        size_t state_;
         String next_state_;
 
         ParticleName particle_name_;
@@ -837,7 +859,7 @@ namespace CXX
         }
 
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::All& a)
         {
           if (!a.context().count ("comp-number")) // Empty compositor.
@@ -878,7 +900,7 @@ namespace CXX
 
             Element& e (dynamic_cast<Element&> (ci->particle ()));
             String ns (e.qualified_p () ? e.namespace_ ().name () : String ());
-            UnsignedLong state (e.context ().get<UnsignedLong> ("state"));
+            size_t state (e.context ().get<size_t> ("state"));
 
             os << "if (count[" << state << "UL] == 0)" << endl
                << "this->_expected_element (" << endl
@@ -894,7 +916,7 @@ namespace CXX
              << "}";
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Choice& c)
         {
           if (!c.context().count ("comp-number")) // Empty compositor.
@@ -902,7 +924,7 @@ namespace CXX
 
           using SemanticGraph::Compositor;
 
-          UnsignedLong n (c.context ().get<UnsignedLong> ("comp-number"));
+          size_t n (c.context ().get<size_t> ("comp-number"));
 
           os << "void " << ename (type_) << "::" << endl
              << "choice_" << n << " (unsigned long& state," << endl
@@ -940,7 +962,7 @@ namespace CXX
           Traversal::Choice::traverse (c);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Sequence& s)
         {
           if (!s.context().count ("comp-number")) // Empty compositor.
@@ -948,7 +970,7 @@ namespace CXX
 
           using SemanticGraph::Compositor;
 
-          UnsignedLong n (s.context ().get<UnsignedLong> ("comp-number"));
+          size_t n (s.context ().get<size_t> ("comp-number"));
 
           os << "void " << ename (type_) << "::" << endl
              << "sequence_" << n << " (unsigned long& state," << endl
@@ -963,7 +985,7 @@ namespace CXX
              << "switch (state)"
              << "{";
 
-          UnsignedLong state (0);
+          size_t state (0);
 
           for (Compositor::ContainsIterator ci (s.contains_begin ()),
                  ce (s.contains_end ()); ci != ce;)
@@ -986,7 +1008,7 @@ namespace CXX
                    ci->particle ().is_a<Compositor> () &&
                    !ci->particle ().context().count ("comp-number"));
 
-            UnsignedLong next (ci == ce ? 0 : state + 1);
+            size_t next (ci == ce ? 0 : state + 1);
 
             ParticleInSequence t (*this, state++, next, type_);
             t.dispatch (p);
@@ -1014,12 +1036,12 @@ namespace CXX
                             Traversal::Compositor,
                             Context
       {
-        CompositorPre (Context& c, SemanticGraph::Complex& type)
-            : Context (c), type_ (type)
+        CompositorPre (Context& c)
+            : Context (c)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::All& a)
         {
           // Clear the counts and push the initial state.
@@ -1031,7 +1053,7 @@ namespace CXX
           traverse (c);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Compositor&) // Choice and sequence.
         {
           os << "v_state_& vs = *static_cast< v_state_* > (" <<
@@ -1042,9 +1064,6 @@ namespace CXX
              << "vd.state = 0;"
              << "vd.count = 0;";
         }
-
-      private:
-        SemanticGraph::Complex& type_;
       };
 
 
@@ -1060,7 +1079,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::All&)
         {
           // The 'all' state machine reaches the final state only
@@ -1078,14 +1097,14 @@ namespace CXX
              << endl;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Compositor& c) // Choice and sequence.
         {
           using SemanticGraph::Compositor;
 
-          UnsignedLong max (c.max ());
-          UnsignedLong min (c.context ().get<UnsignedLong> ("effective-min"));
-          UnsignedLong n (c.context ().get<UnsignedLong> ("comp-number"));
+          size_t max (c.max ());
+          size_t min (c.context ().get<size_t> ("effective-min"));
+          size_t n (c.context ().get<size_t> ("comp-number"));
 
           String func (c.is_a<SemanticGraph::Choice> () ?
                        "choice_" : "sequence_");
@@ -1117,7 +1136,7 @@ namespace CXX
              << "unsigned long s = ~0UL;"
              << endl;
 
-          Boolean first (true);
+          bool first (true);
 
           // Note that we don't need to worry about the compositor
           // being empty - this case is handled by our caller.
@@ -1133,7 +1152,7 @@ namespace CXX
             if (!p.context ().count ("prefix"))
               break;
 
-            UnsignedLong state (p.context ().get<UnsignedLong> ("state"));
+            size_t state (p.context ().get<size_t> ("state"));
 
             if (first)
               first = false;
@@ -1230,12 +1249,12 @@ namespace CXX
                                    Traversal::Compositor,
                                    Context
       {
-        CompositorEndElement (Context& c, SemanticGraph::Complex& type)
-            : Context (c), type_ (type)
+        CompositorEndElement (Context& c)
+          : Context (c)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::All&)
         {
           os << "all_0 (vd.state, v_all_count_.top (), " <<
@@ -1243,7 +1262,7 @@ namespace CXX
              << endl;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Compositor&) // Choice and sequence.
         {
           os << "assert (vd.func != 0);"
@@ -1253,9 +1272,6 @@ namespace CXX
              << "vs.size--;" // pop
              << endl;
         }
-
-      private:
-        SemanticGraph::Complex& type_;
       };
 
 
@@ -1265,12 +1281,12 @@ namespace CXX
                              Traversal::Compositor,
                              Context
       {
-        CompositorPost (Context& c, SemanticGraph::Complex& type)
-            : Context (c), type_ (type), particle_name_ (c)
+        CompositorPost (Context& c)
+            : Context (c), particle_name_ (c)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::All& a)
         {
           using SemanticGraph::Element;
@@ -1289,7 +1305,7 @@ namespace CXX
              << "all_0 (vd.state, v_all_count_.top (), empty, empty, 0, true);"
              << "}";
 
-          if (a.context ().get<UnsignedLong> ("effective-min") != 0)
+          if (a.context ().get<size_t> ("effective-min") != 0)
           {
             os << "else" << endl
                << "this->_expected_element (" << endl;
@@ -1304,10 +1320,10 @@ namespace CXX
              << "v_all_count_.pop ();";
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Compositor& c) // Choice and sequence.
         {
-          UnsignedLong min (c.context ().get<UnsignedLong> ("effective-min"));
+          size_t min (c.context ().get<size_t> ("effective-min"));
 
           os << "v_state_& vs = *static_cast< v_state_* > (" <<
             "this->v_state_stack_.top ());"
@@ -1343,7 +1359,6 @@ namespace CXX
         }
 
       private:
-        SemanticGraph::Complex& type_;
         ParticleName particle_name_;
       };
 
@@ -1357,7 +1372,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           // Nothing to generate if we don't have any elements and wildcards.
@@ -1374,7 +1389,7 @@ namespace CXX
           // Don't use restriction_p here since we don't want special
           // treatment of anyType.
           //
-          Boolean restriction (
+          bool restriction (
             c.inherits_p () &&
             c.inherits ().is_a<SemanticGraph::Restricts> ());
 
@@ -1476,7 +1491,7 @@ namespace CXX
           }
 
           {
-            CompositorEndElement t (*this, c);
+            CompositorEndElement t (*this);
             t.dispatch (comp);
           }
 
@@ -1495,7 +1510,7 @@ namespace CXX
              << endl;
 
           {
-            CompositorPre t (*this, c);
+            CompositorPre t (*this);
             t.dispatch (comp);
           }
 
@@ -1543,7 +1558,7 @@ namespace CXX
           }
 
           {
-            CompositorPost t (*this, c);
+            CompositorPost t (*this);
             t.dispatch (c.contains_compositor ().compositor ());
           }
 
@@ -1559,7 +1574,7 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_element_validation_source (Context& ctx)
     {
       ctx.os << "#include <cassert>" << endl
@@ -1567,7 +1582,7 @@ namespace CXX
 
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names schema_names;
 
       Namespace ns (ctx);
diff --git a/xsd/xsd/cxx/parser/element-validation-source.hxx b/xsd/xsd/cxx/parser/element-validation-source.hxx
index 544b8f1..b9bd70b 100644
--- a/xsd/xsd/cxx/parser/element-validation-source.hxx
+++ b/xsd/xsd/cxx/parser/element-validation-source.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/element-validation-source.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_ELEMENT_VALIDATION_SOURCE_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Parser
   {
-    Void
+    void
     generate_element_validation_source (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/parser/elements.cxx b/xsd/xsd/cxx/parser/elements.cxx
index b3458c7..889eea4 100644
--- a/xsd/xsd/cxx/parser/elements.cxx
+++ b/xsd/xsd/cxx/parser/elements.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/elements.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/parser/elements.hxx>
@@ -9,60 +8,16 @@ namespace CXX
 {
   namespace Parser
   {
-    // Keep this symbol first to help HP-UX linker (long symbols?).
-    //
-    Content::Value Context::
-    content (SemanticGraph::Complex& c)
-    {
-      using namespace SemanticGraph;
-
-      if (c.mixed_p ())
-        return Content::mixed;
-
-      if (c.inherits_p ())
-      {
-        Type& base (c.inherits ().base ());
-
-        if (Complex* cb = dynamic_cast<Complex*> (&base))
-          return content (*cb);
-
-        if (base.is_a<AnyType> ())
-          return Content::complex;
-
-        // Everyhting else (built-in type and AnySimpleType) is simple
-        // content.
-        //
-        return Content::simple;
-      }
-      else
-        return Content::complex;
-    }
-
     Context::
     Context (std::wostream& o,
              SemanticGraph::Schema& root,
              SemanticGraph::Path const& path,
-             CLI::Options const& ops,
+             options_type const& ops,
              StringLiteralMap const* map,
              Regex const* he,
              Regex const* ie,
              Regex const* hie)
-        : CXX::Context (o,
-                        root,
-                        path,
-                        map,
-                        ops.value<CLI::char_type> (),
-                        ops.value<CLI::char_encoding> (),
-                        ops.value<CLI::include_with_brackets> (),
-                        ops.value<CLI::include_prefix> (),
-                        ops.value<CLI::export_symbol> (),
-                        ops.value<CLI::namespace_map> (),
-                        ops.value<CLI::namespace_regex> (),
-                        ops.value<CLI::namespace_regex_trace> (),
-                        ops.value<CLI::include_regex> (),
-                        ops.value<CLI::include_regex_trace> (),
-                        ops.value<CLI::generate_inline> (),
-                        ops.value<CLI::reserved_name> ()),
+        : CXX::Context (o, root, path, ops, map),
           options (ops),
           xml_parser (xml_parser_),
           simple_base (simple_base_),
@@ -77,11 +32,11 @@ namespace CXX
           hxx_expr (he),
           ixx_expr (ie),
           hxx_impl_expr (hie),
-          xml_parser_ (ops.value<CLI::xml_parser> ()),
-          validation_ ((ops.value<CLI::xml_parser> () == "expat" ||
-                        ops.value<CLI::generate_validation> ()) &&
-                       !ops.value<CLI::suppress_validation> ()),
-          polymorphic_ (ops.value<CLI::generate_polymorphic> ())
+          xml_parser_ (ops.xml_parser ()),
+          validation_ ((ops.xml_parser () == "expat" ||
+                        ops.generate_validation ()) &&
+                       !ops.suppress_validation ()),
+          polymorphic_ (ops.generate_polymorphic ())
     {
       if (char_type == L"char")
         std_string_type = L"::std::string";
@@ -144,7 +99,34 @@ namespace CXX
     {
     }
 
-    Boolean Context::
+    Content::Value Context::
+    content (SemanticGraph::Complex& c)
+    {
+      using namespace SemanticGraph;
+
+      if (c.mixed_p ())
+        return Content::mixed;
+
+      if (c.inherits_p ())
+      {
+        Type& base (c.inherits ().base ());
+
+        if (Complex* cb = dynamic_cast<Complex*> (&base))
+          return content (*cb);
+
+        if (base.is_a<AnyType> ())
+          return Content::complex;
+
+        // Everyhting else (built-in type and AnySimpleType) is simple
+        // content.
+        //
+        return Content::simple;
+      }
+      else
+        return Content::complex;
+    }
+
+    bool Context::
     anonymous (SemanticGraph::Type& t)
     {
       return t.context ().count ("anonymous");
@@ -181,12 +163,6 @@ namespace CXX
     }
 
     String const& Context::
-    emember_cache (SemanticGraph::Member& m)
-    {
-      return m.context ().get<String> ("member-cache");
-    }
-
-    String const& Context::
     emember_map (SemanticGraph::Member& m)
     {
       return m.context ().get<String> ("member-map");
@@ -200,20 +176,20 @@ namespace CXX
 
     // Includes
     //
-    Void TypeForward::
+    void TypeForward::
     traverse (SemanticGraph::Type& t)
     {
       os << "class " << t.context ().get<String> (name_key_) << ";";
     }
 
-    Void Includes::
+    void Includes::
     traverse_ (SemanticGraph::Uses& u)
     {
       // Support for weak (forward) inclusion used in the file-per-type
       // compilation model.
       //
       SemanticGraph::Schema& s (u.schema ());
-      Boolean weak (u.context ().count ("weak"));
+      bool weak (u.context ().count ("weak"));
 
       if (weak && (type_ == header || type_ == impl_header))
       {
@@ -233,6 +209,7 @@ namespace CXX
         s.context ().count ("renamed")
         ? s.context ().get<SemanticGraph::Path> ("renamed")
         : u.path ());
+      path.normalize ();
 
       // Try to use the portable representation of the path. If that
       // fails, fall back to the native representation.
@@ -240,15 +217,11 @@ namespace CXX
       NarrowString path_str;
       try
       {
-        path_str = path.string ();
+        path_str = path.posix_string ();
       }
       catch (SemanticGraph::InvalidPath const&)
       {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        path_str = path.native_file_string ();
-#else
         path_str = path.string ();
-#endif
       }
 
       String inc_path;
@@ -258,12 +231,12 @@ namespace CXX
       case header:
       case source:
         {
-          inc_path = ctx_.hxx_expr->merge (path_str);
+          inc_path = ctx_.hxx_expr->replace (path_str);
           break;
         }
       case impl_header:
         {
-          inc_path = ctx_.hxx_impl_expr->merge (path_str);
+          inc_path = ctx_.hxx_impl_expr->replace (path_str);
           break;
         }
       }
diff --git a/xsd/xsd/cxx/parser/elements.hxx b/xsd/xsd/cxx/parser/elements.hxx
index ee5ca86..31f5d87 100644
--- a/xsd/xsd/cxx/parser/elements.hxx
+++ b/xsd/xsd/cxx/parser/elements.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/elements.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_ELEMENTS_HXX
@@ -8,11 +7,13 @@
 
 #include <sstream>
 
-#include <backend-elements/regex.hxx>
+#include <cutl/re.hxx>
+
+#include <types.hxx>
 
 #include <cxx/elements.hxx>
 
-#include <cxx/parser/cli.hxx>
+#include <cxx/parser/options.hxx>
 
 namespace CXX
 {
@@ -33,13 +34,15 @@ namespace CXX
     class Context: public CXX::Context
     {
     public:
-      typedef BackendElements::Regex::Expression<Char> Regex;
+      typedef cutl::re::regexsub Regex;
+
+      typedef Parser::options options_type;
 
     public:
       Context (std::wostream&,
                SemanticGraph::Schema&,
                SemanticGraph::Path const& path,
-               CLI::Options const&,
+               options_type const&,
                StringLiteralMap const*,
                Regex const* hxx_expr,
                Regex const* ixx_expr,
@@ -50,7 +53,7 @@ namespace CXX
       Context (Context& c, std::wostream& o);
 
     public:
-      Boolean
+      bool
       restriction_p (SemanticGraph::Complex& c) const
       {
         if (c.inherits_p () &&
@@ -69,7 +72,7 @@ namespace CXX
       content (SemanticGraph::Complex&);
 
     public:
-      static Boolean
+      static bool
       anonymous (SemanticGraph::Type&);
 
     public:
@@ -90,9 +93,6 @@ namespace CXX
       emember (SemanticGraph::Member&);
 
       static String const&
-      emember_cache (SemanticGraph::Member&);
-
-      static String const&
       emember_map (SemanticGraph::Member&);
 
     public:
@@ -100,7 +100,7 @@ namespace CXX
       eimpl (SemanticGraph::Type&);
 
     public:
-      CLI::Options const& options;
+      options_type const& options;
       String& xml_parser;
       String& simple_base;
       String& complex_base;
@@ -109,8 +109,8 @@ namespace CXX
       String& cerr_inst;
       String& parser_map;
       String& std_string_type;
-      Boolean& validation;
-      Boolean& polymorphic;
+      bool& validation;
+      bool& polymorphic;
 
       Regex const* hxx_expr;
       Regex const* ixx_expr;
@@ -125,20 +125,20 @@ namespace CXX
       String cerr_inst_;
       String parser_map_;
       String std_string_type_;
-      Boolean validation_;
-      Boolean polymorphic_;
+      bool validation_;
+      bool polymorphic_;
     };
 
     //
     //
     struct RequiredAttributeTest: Traversal::Attribute
     {
-      RequiredAttributeTest (Boolean& result)
+      RequiredAttributeTest (bool& result)
           : result_ (result)
       {
       }
 
-      virtual Void
+      virtual void
       traverse (Type& a)
       {
         if (!result_ && !a.optional_p ())
@@ -146,7 +146,7 @@ namespace CXX
       }
 
     private:
-      Boolean& result_;
+      bool& result_;
     };
 
     //
@@ -156,14 +156,14 @@ namespace CXX
                             Traversal::Member,
                             Context
     {
-      ParserParamDecl (Context& c, Boolean name_arg)
+      ParserParamDecl (Context& c, bool name_arg)
           : Context (c), first_ (true), name_arg_ (name_arg)
       {
         inherits_ >> *this;
         names_ >> *this;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex& c)
       {
         inherits (c, inherits_);
@@ -172,7 +172,7 @@ namespace CXX
           names (c, names_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::List& l)
       {
         if (!first_)
@@ -188,7 +188,7 @@ namespace CXX
           os << " /* " << comment (l.name ()) << " item */";
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Member& m)
       {
         if (skip (m)) return;
@@ -210,8 +210,8 @@ namespace CXX
       Traversal::Inherits inherits_;
       Traversal::Names names_;
 
-      Boolean first_;
-      Boolean name_arg_;
+      bool first_;
+      bool name_arg_;
     };
 
 
@@ -219,16 +219,16 @@ namespace CXX
     //
     struct TypeForward: Traversal::Type, Context
     {
-      TypeForward (Context& c, Char const* name_key)
+      TypeForward (Context& c, char const* name_key)
           : Context (c), name_key_ (name_key)
       {
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Type& t);
 
     private:
-      Char const* name_key_;
+      char const* name_key_;
     };
 
     struct Includes: Traversal::Imports,
@@ -250,20 +250,20 @@ namespace CXX
         schema_ >> schema_names_ >> namespace_ >> names_ >> type_forward_;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Imports& i)
       {
         traverse_ (i);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Includes& i)
       {
         traverse_ (i);
       }
 
     private:
-      Void
+      void
       traverse_ (SemanticGraph::Uses&);
 
     private:
@@ -281,21 +281,23 @@ namespace CXX
     //
     struct RootElement: Traversal::Element
     {
-      RootElement (CLI::Options const& options,
+      typedef Parser::options options_type;
+
+      RootElement (options_type const& options,
                    SemanticGraph::Element*& element)
           : options_ (options), element_ (element)
       {
       }
 
-      virtual Void
+      virtual void
       traverse (Type& e)
       {
-        if (options_.value<CLI::root_element_first> ())
+        if (options_.root_element_first ())
         {
           if (element_ == 0)
             element_ = &e;
         }
-        else if (String name = options_.value<CLI::root_element> ())
+        else if (String name = options_.root_element ())
         {
           if (e.name () == name)
             element_ = &e;
@@ -305,7 +307,7 @@ namespace CXX
       }
 
     private:
-      CLI::Options const& options_;
+      options_type const& options_;
       SemanticGraph::Element*& element_;
     };
   }
diff --git a/xsd/xsd/cxx/parser/generator.cxx b/xsd/xsd/cxx/parser/generator.cxx
index b3aee76..e17986b 100644
--- a/xsd/xsd/cxx/parser/generator.cxx
+++ b/xsd/xsd/cxx/parser/generator.cxx
@@ -1,8 +1,19 @@
 // file      : xsd/cxx/parser/generator.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+
+#include <cutl/re.hxx>
+
+#include <cutl/compiler/code-stream.hxx>
+#include <cutl/compiler/cxx-indenter.hxx>
+#include <cutl/compiler/sloc-counter.hxx>
+
+#include <xsd-frontend/semantic-graph.hxx>
+
 #include <type-map/lexer.hxx>
 #include <type-map/parser.hxx>
 #include <type-map/type-map.hxx>
@@ -28,49 +39,28 @@
 #include <cxx/parser/attribute-validation-source.hxx>
 #include <cxx/parser/characters-validation-source.hxx>
 
-#include <xsd-frontend/semantic-graph.hxx>
-
-#include <backend-elements/regex.hxx>
-#include <backend-elements/indentation/cxx.hxx>
-#include <backend-elements/indentation/sloc.hxx>
-#include <backend-elements/indentation/clip.hxx>
-
-#include <cult/containers/set.hxx>
-#include <cult/containers/vector.hxx>
-
-#include <boost/filesystem/fstream.hpp>
-
-#include <iostream>
-
-#include <usage.hxx>
+#include <cxx/parser/options.hxx>
 
 #include "../../../libxsd/xsd/cxx/version.hxx"
 
 using std::endl;
 using std::wcerr;
+using std::wcout;
 
 using namespace XSDFrontend::SemanticGraph;
 
 //
 //
-typedef
-boost::filesystem::wifstream
-WideInputFileStream;
-
-typedef
-boost::filesystem::wofstream
-WideOutputFileStream;
-
-typedef
-boost::filesystem::ifstream
-NarrowInputFileStream;
+typedef std::wifstream WideInputFileStream;
+typedef std::wofstream WideOutputFileStream;
+typedef std::ifstream NarrowInputFileStream;
 
 namespace CXX
 {
   namespace
   {
-    Char const copyright_gpl[] =
-    "// Copyright (C) 2005-2010 Code Synthesis Tools CC\n"
+    char const copyright_gpl[] =
+    "// Copyright (c) 2005-2014 Code Synthesis Tools CC\n"
     "//\n"
     "// This program was generated by CodeSynthesis XSD, an XML Schema to\n"
     "// C++ data binding compiler.\n"
@@ -103,8 +93,8 @@ namespace CXX
     "// in the accompanying FLOSSE file.\n"
     "//\n\n";
 
-    Char const copyright_proprietary[] =
-    "// Copyright (C) 2005-2010 Code Synthesis Tools CC\n"
+    char const copyright_proprietary[] =
+    "// Copyright (c) 2005-2014 Code Synthesis Tools CC\n"
     "//\n"
     "// This program was generated by CodeSynthesis XSD, an XML Schema\n"
     "// to C++ data binding compiler, in the Proprietary License mode.\n"
@@ -113,7 +103,7 @@ namespace CXX
     "// conditions.\n"
     "//\n\n";
 
-    Char const copyright_impl[] =
+    char const copyright_impl[] =
     "// Not copyrighted - public domain.\n"
     "//\n"
     "// This sample parser implementation was generated by CodeSynthesis XSD,\n"
@@ -122,442 +112,24 @@ namespace CXX
     "//\n\n";
   }
 
-  namespace Parser
-  {
-    namespace CLI
-    {
-      extern Key type_map                 = "type-map";
-      extern Key char_type                = "char-type";
-      extern Key char_encoding            = "char-encoding";
-      extern Key output_dir               = "output-dir";
-      extern Key xml_parser               = "xml-parser";
-      extern Key generate_inline          = "generate-inline";
-      extern Key generate_validation      = "generate-validation";
-      extern Key suppress_validation      = "suppress-validation";
-      extern Key generate_polymorphic     = "generate-polymorphic";
-      extern Key generate_noop_impl       = "generate-noop-impl";
-      extern Key generate_print_impl      = "generate-print-impl";
-      extern Key generate_test_driver     = "generate-test-driver";
-      extern Key force_overwrite          = "force-overwrite";
-      extern Key root_element_first       = "root-element-first";
-      extern Key root_element_last        = "root-element-last";
-      extern Key root_element             = "root-element";
-      extern Key generate_xml_schema      = "generate-xml-schema";
-      extern Key extern_xml_schema        = "extern-xml-schema";
-      extern Key skel_type_suffix         = "skel-type-suffix";
-      extern Key skel_file_suffix         = "skel-file-suffix";
-      extern Key impl_type_suffix         = "impl-type-suffix";
-      extern Key impl_file_suffix         = "impl-file-suffix";
-      extern Key namespace_map            = "namespace-map";
-      extern Key namespace_regex          = "namespace-regex";
-      extern Key namespace_regex_trace    = "namespace-regex-trace";
-      extern Key reserved_name            = "reserved-name";
-      extern Key include_with_brackets    = "include-with-brackets";
-      extern Key include_prefix           = "include-prefix";
-      extern Key include_regex            = "include-regex";
-      extern Key include_regex_trace      = "include-regex-trace";
-      extern Key guard_prefix             = "guard-prefix";
-      extern Key hxx_suffix               = "hxx-suffix";
-      extern Key ixx_suffix               = "ixx-suffix";
-      extern Key cxx_suffix               = "cxx-suffix";
-      extern Key hxx_regex                = "hxx-regex";
-      extern Key ixx_regex                = "ixx-regex";
-      extern Key cxx_regex                = "cxx-regex";
-      extern Key hxx_prologue             = "hxx-prologue";
-      extern Key ixx_prologue             = "ixx-prologue";
-      extern Key cxx_prologue             = "cxx-prologue";
-      extern Key prologue                 = "prologue";
-      extern Key hxx_epilogue             = "hxx-epilogue";
-      extern Key ixx_epilogue             = "ixx-epilogue";
-      extern Key cxx_epilogue             = "cxx-epilogue";
-      extern Key epilogue                 = "epilogue";
-      extern Key hxx_prologue_file        = "hxx-prologue-file";
-      extern Key ixx_prologue_file        = "ixx-prologue-file";
-      extern Key cxx_prologue_file        = "cxx-prologue-file";
-      extern Key prologue_file            = "prologue-file";
-      extern Key hxx_epilogue_file        = "hxx-epilogue-file";
-      extern Key ixx_epilogue_file        = "ixx-epilogue-file";
-      extern Key cxx_epilogue_file        = "cxx-epilogue-file";
-      extern Key epilogue_file            = "epilogue-file";
-      extern Key export_symbol            = "export-symbol";
-      extern Key export_maps              = "export-maps";
-      extern Key import_maps              = "import-maps";
-      extern Key show_anonymous           = "show-anonymous";
-      extern Key show_sloc                = "show-sloc";
-      extern Key proprietary_license      = "proprietary-license";
-    }
-  }
-
-  Void Parser::Generator::
+  void Parser::Generator::
   usage ()
   {
-    std::wostream& e (wcerr);
-    ::CLI::Indent::Clip< ::CLI::OptionsUsage, WideChar> clip (e);
-
-    e << "--type-map <mapfile>" << endl
-      << " Read XML Schema to C++ type mapping information\n"
-      << " from <mapfile>. Repeat this option to specify\n"
-      << " several type maps. Type maps are considered in\n"
-      << " order of appearance and the first match is used."
-      << endl;
-
-    e << "--char-type <type>" << endl
-      << " Use <type> as the base character type. Valid\n"
-      << " values are 'char' (default) and 'wchar_t'."
-      << endl;
-
-    e << "--char-encoding <enc>" << endl
-      << " Specify the character encoding that should be used\n"
-      << " in the object model. Valid values for the 'char'\n"
-      << " character type are 'utf8' (default), 'iso8859-1',\n"
-      << " 'lcp', and 'custom'. For the 'wchar_t' character\n"
-      << " type the only valid value is 'auto'."
-      << endl;
-
-    e << "--output-dir <dir>" << endl
-      << " Write generated files to <dir> instead of current\n"
-      << " directory."
-      << endl;
-
-    e << "--xml-parser <parser>" << endl
-      << " Use <parser> as the underlying XML parser. Valid\n"
-      << " values are 'xerces' (default) and 'expat'."
-      << endl;
-
-    e << "--generate-inline" << endl
-      << " Generate certain functions inline."
-      << endl;
-
-    e << "--generate-validation" << endl
-      << " Generate validation code."
-      << endl;
-
-    e << "--suppress-validation" << endl
-      << " Suppress the generation of validation code."
-      << endl;
-
-    e << "--generate-polymorphic" << endl
-      << " Generate polymorphism-aware code. Specify this\n"
-      << " option if you use substitution groups or xsi:type."
-      << endl;
-
-    e << "--generate-noop-impl" << endl
-      << " Generate a sample parser implementation that\n"
-      << " does nothing (no operation)."
-      << endl;
-
-    e << "--generate-print-impl" << endl
-      << " Generate a sample parser implementation that\n"
-      << " prints the XML data to STDOUT."
-      << endl;
-
-    e << "--generate-test-driver" << endl
-      << " Generate a test driver for the sample parser\n"
-      << " implementation."
-      << endl;
-
-    e << "--force-overwrite" << endl
-      << " Force overwriting of the existing implementation\n"
-      << " and test driver files."
-      << endl;
-
-    e << "--root-element-first" << endl
-      << " Indicate that the first global element is the\n"
-      << " document root."
-      << endl;
-
-    e << "--root-element-last" << endl
-      << " Indicate that the last global element is the\n"
-      << " document root."
-      << endl;
-
-    e << "--root-element <element>" << endl
-      << " Indicate that <element> is the document root."
-      << endl;
-
-    e << "--generate-xml-schema" << endl
-      << " Generate a C++ header file as if the schema being\n"
-      << " compiled defines the XML Schema namespace."
-      << endl;
-
-    e << "--extern-xml-schema <file>" << endl
-      << " Generate code as if the XML Schema namespace was\n"
-      << " defined in <file> and xsd:included in the schema\n"
-      << " being compiled."
-      << endl;
-
-    e << "--skel-type-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '_pskel' to\n"
-      << " construct the names of generated parser skeletons."
-      << endl;
-
-    e << "--skel-file-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '-pskel' to\n"
-      << " construct the names of generated parser skeleton\n"
-      << " files."
-      << endl;
-
-    e << "--impl-type-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '_pimpl' to\n"
-      << " construct the names of parser implementations for\n"
-      << " the built-in XML Schema types and sample parser\n"
-      << " implementations."
-      << endl;
-
-    e << "--impl-file-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '-pimpl' to\n"
-      << " construct the names of generated sample parser\n"
-      << " implementation files."
-      << endl;
-
-    e << "--namespace-map <xns>=<cns>" << endl
-      << " Map XML Schema namespace <xns> to C++ namespace\n"
-      << " <cns>. Repeat this option to specify mapping for\n"
-      << " more than one XML Schema namespace."
-      << endl;
-
-    e << "--namespace-regex <regex>" << endl
-      << " Add <regex> to the list of regular expressions\n"
-      << " used to translate XML Schema namespace names to\n"
-      << " C++ namespace names."
-      << endl;
-
-    e << "--namespace-regex-trace" << endl
-      << " Trace the process of applying regular expressions\n"
-      << " specified with the --namespace-regex option."
-      << endl;
-
-    e << "--reserved-name <name>" << endl
-      << " Add <name> to the list of names that should not\n"
-      << " be used as identifiers. The name can optionally\n"
-      << " be followed by '=' and the replacement name that\n"
-      << " should be used instead."
-      << endl;
-
-    e << "--include-with-brackets" << endl
-      << " Use angle brackets (<>) instead of quotes (\"\") in\n"
-      << " generated #include directives."
-      << endl;
-
-    e << "--include-prefix <prefix>" << endl
-      << " Add <prefix> to generated #include directive\n"
-      << " paths."
-      << endl;
-
-    e << "--include-regex <regex>" << endl
-      << " Add <regex> to the list of regular expressions\n"
-      << " used to transform #include directive paths."
-      << endl;
-
-    e << "--include-regex-trace" << endl
-      << " Trace the process of applying regular expressions\n"
-      << " specified with the --include-regex option."
-      << endl;
-
-    e << "--guard-prefix <prefix>" << endl
-      << " Add <prefix> to generated header inclusion guards."
-      << endl;
-
-    e << "--hxx-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '.hxx' to\n"
-      << " construct the name of the header file."
-      << endl;
-
-    e << "--ixx-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '.ixx' to\n"
-      << " construct the name of the inline file."
-      << endl;
-
-    e << "--cxx-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '.cxx' to\n"
-      << " construct the name of the source file."
-      << endl;
-
-    e << "--hxx-regex <regex>" << endl
-      << " Use <regex> to construct the name of the header\n"
-      << " file."
-      << endl;
-
-    e << "--ixx-regex <regex>" << endl
-      << " Use <regex> to construct the name of the inline\n"
-      << " file."
-      << endl;
-
-    e << "--cxx-regex <regex>" << endl
-      << " Use <regex> to construct the name of the source\n"
-      << " file."
-      << endl;
-
-
-    // Prologues.
-    //
-    e << "--hxx-prologue <text>" << endl
-      << " Insert <text> at the beginning of the header file."
-      << endl;
-
-    e << "--ixx-prologue <text>" << endl
-      << " Insert <text> at the beginning of the inline file."
-      << endl;
-
-    e << "--cxx-prologue <text>" << endl
-      << " Insert <text> at the beginning of the source file."
-      << endl;
-
-    e << "--prologue <text>" << endl
-      << " Insert <text> at the beginning of each generated\n"
-      << " file for which there is no file-specific prologue."
-      << endl;
-
-
-    // Epilogues.
-    //
-    e << "--hxx-epilogue <text>" << endl
-      << " Insert <text> at the end of the header file."
-      << endl;
-
-    e << "--ixx-epilogue <text>" << endl
-      << " Insert <text> at the end of the inline file."
-      << endl;
-
-    e << "--cxx-epilogue <text>" << endl
-      << " Insert <text> at the end of the source file."
-      << endl;
-
-    e << "--epilogue <text>" << endl
-      << " Insert <text> at the end of each generated file\n"
-      << " for which there is no file-specific epilogue."
-      << endl;
-
-
-    // Prologue files.
-    //
-    e << "--hxx-prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of the header file."
-      << endl;
-
-    e << "--ixx-prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of the inline file."
-      << endl;
-
-    e << "--cxx-prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of the source file."
-      << endl;
-
-    e << "--prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of each generated file for which there is no file-\n"
-      << " specific prologue file."
-      << endl;
-
-
-    // Epilogue files.
-    //
-    e << "--hxx-epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " the header file."
-      << endl;
-
-    e << "--ixx-epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " the inline file."
-      << endl;
-
-    e << "--cxx-epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " the source file."
-      << endl;
-
-    e << "--epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " each generated file for which there is no file-\n"
-      << " specific epilogue file."
-      << endl;
-
-
-    // Misc.
-    //
-    e << "--custom-literals <file>" << endl
-      << " Load custom XML string to C++ literal mappings\n"
-      << " from <file>."
-      << endl;
-
-    e << "--export-symbol <symbol>" << endl
-      << " Export symbol for Win32 DLL export/import control."
-      << endl;
-
-    e << "--export-maps" << endl
-      << " Export polymorphism support maps from Win32 DLL."
-      << endl;
-
-    e << "--import-maps" << endl
-      << " Import polymorphism support maps from Win32 DLL."
-      << endl;
-
-    e << "--show-anonymous" << endl
-      << " Show elements and attributes that are of anonymous\n"
-      << " types."
-      << endl;
-
-    e << "--show-sloc" << endl
-      << " Show the number of generated physical source lines\n"
-      << " of code (SLOC)."
-      << endl;
-
-    e << "--sloc-limit <num>" << endl
-      << " Check that the number of generated physical source\n"
-      << " lines of code (SLOC) does not exceed <num>."
-      << endl;
-
-    e << "--options-file <file>" << endl
-      << " Read additional options from <file>. Each option\n"
-      << " should appear on a separate line optionally\n"
-      << " followed by space and an argument."
-      << endl;
-
-    e << "--proprietary-license" << endl
-      << " Indicate that the generated code is licensed under\n"
-      << " a proprietary license instead of the GPL."
-      << endl;
+    CXX::Parser::options::print_usage (wcout);
+    CXX::options::print_usage (wcout);
   }
 
-  Parser::CLI::OptionsSpec Parser::Generator::
-  options_spec ()
-  {
-    CLI::OptionsSpec spec;
-
-    spec.option<CLI::char_type> ().default_value ("char");
-    spec.option<CLI::xml_parser> ().default_value ("xerces");
-
-    spec.option<CLI::skel_file_suffix> ().default_value ("-pskel");
-    spec.option<CLI::skel_type_suffix> ().default_value ("_pskel");
-    spec.option<CLI::impl_file_suffix> ().default_value ("-pimpl");
-    spec.option<CLI::impl_type_suffix> ().default_value ("_pimpl");
-
-    spec.option<CLI::hxx_suffix> ().default_value (".hxx");
-    spec.option<CLI::ixx_suffix> ().default_value (".ixx");
-    spec.option<CLI::cxx_suffix> ().default_value (".cxx");
-
-    return spec;
-  }
-
-
   namespace
   {
     template <typename S>
-    Void
+    void
     open (S& ifs, NarrowString const& path)
     {
       try
       {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        Path fs_path (path, boost::filesystem::native);
-#else
-        Path fs_path (path.c_str());
-#endif
-        ifs.open (fs_path, std::ios_base::in | std::ios_base::binary);
+        Path fs_path (path);
+        ifs.open (fs_path.string ().c_str (),
+                  std::ios_base::in | std::ios_base::binary);
 
         if (!ifs.is_open ())
         {
@@ -576,7 +148,7 @@ namespace CXX
       }
     }
 
-    Void
+    void
     append (WideOutputFileStream& os,
             NarrowString const& path,
             WideInputFileStream& default_is)
@@ -596,16 +168,15 @@ namespace CXX
       }
     }
 
-    Void
+    void
     append (WideOutputFileStream& os,
-            Cult::Containers::Vector<NarrowString> const& primary,
-            Cult::Containers::Vector<NarrowString> const& def)
+            NarrowStrings const& primary,
+            NarrowStrings const& def)
     {
-      Cult::Containers::Vector<NarrowString> const& v (
-        primary.empty () ? def : primary);
+      NarrowStrings const& v (primary.empty () ? def : primary);
 
-      for (Containers::Vector<NarrowString>::ConstIterator
-             i (v.begin ()), e (v.end ()); i != e; ++i)
+      for (NarrowStrings::const_iterator i (v.begin ()), e (v.end ());
+           i != e; ++i)
       {
         os << i->c_str () << endl;
       }
@@ -613,25 +184,24 @@ namespace CXX
   }
 
 
-  UnsignedLong Parser::Generator::
-  generate (Parser::CLI::Options const& ops,
+  size_t Parser::Generator::
+  generate (Parser::options const& ops,
             Schema& schema,
             Path const& file_path,
-            Boolean fpt,
+            bool fpt,
             StringLiteralMap const& string_literal_map,
-            Boolean gen_driver,
+            bool gen_driver,
             const WarningSet& disabled_warnings,
             FileList& file_list,
             AutoUnlinks& unlinks)
   {
     using std::ios_base;
-    namespace Indentation = BackendElements::Indentation;
 
-    typedef BackendElements::Regex::Expression<Char> Regex;
+    typedef cutl::re::regexsub Regex;
 
     try
     {
-      Boolean generate_xml_schema (ops.value<CLI::generate_xml_schema> ());
+      bool generate_xml_schema (ops.generate_xml_schema ());
 
       // We could be compiling several schemas at once in which case
       // handling of the --generate-xml-schema option gets tricky: we
@@ -640,23 +210,19 @@ namespace CXX
       //
       if (generate_xml_schema)
       {
-        if (NarrowString name = ops.value<CLI::extern_xml_schema> ())
+        if (NarrowString name = ops.extern_xml_schema ())
         {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-          if (file_path.native_file_string () != name)
-#else
           if (file_path.string () != name)
-#endif
             generate_xml_schema = false;
         }
       }
 
-      Boolean impl (!generate_xml_schema &&
-                    (ops.value<CLI::generate_noop_impl> () ||
-                     ops.value<CLI::generate_print_impl> ()));
+      bool impl (!generate_xml_schema &&
+                    (ops.generate_noop_impl () ||
+                     ops.generate_print_impl ()));
 
-      Boolean driver (gen_driver && !generate_xml_schema &&
-                      ops.value<CLI::generate_test_driver> ());
+      bool driver (gen_driver && !generate_xml_schema &&
+                      ops.generate_test_driver ());
 
       // Evaluate the graph for possibility of generating something useful.
       //
@@ -674,9 +240,9 @@ namespace CXX
         proc.process (ops, schema, file_path, string_literal_map);
       }
 
-      Boolean validation ((ops.value<CLI::xml_parser> () == "expat" ||
-                           ops.value<CLI::generate_validation> ()) &&
-                          !ops.value<CLI::suppress_validation> ());
+      bool validation ((ops.xml_parser () == "expat" ||
+                           ops.generate_validation ()) &&
+                          !ops.suppress_validation ());
 
       // Compute state machine info.
       //
@@ -691,11 +257,11 @@ namespace CXX
       TypeMap::Namespaces type_map;
       {
         using namespace TypeMap;
-        typedef Containers::Vector<NarrowString> Files;
 
-        Files const& files (ops.value<CLI::type_map> ());
+        NarrowStrings const& files (ops.type_map ());
 
-        for (Files::ConstIterator f (files.begin ()); f != files.end (); ++f )
+        for (NarrowStrings::const_iterator f (files.begin ());
+             f != files.end (); ++f )
         {
           NarrowInputFileStream ifs;
           open (ifs, *f);
@@ -712,7 +278,7 @@ namespace CXX
 
         // String-based types.
         //
-        String char_type (ops.value<CLI::char_type> ());
+        String char_type (ops.char_type ());
         String string_type;
 
         if (char_type == L"char")
@@ -723,12 +289,14 @@ namespace CXX
           string_type = L"::std::basic_string< " + char_type + L" >";
 
         String xns;
+        String auto_ptr;
         {
           Context ctx (std::wcerr, schema, file_path, ops, 0, 0, 0, 0);
           xns = ctx.xs_ns_name ();
+          auto_ptr = ctx.auto_ptr;
         }
 
-        String buffer (L"::std::auto_ptr< " + xns + L"::buffer >");
+        String buffer (auto_ptr + L"< " + xns + L"::buffer >");
         TypeMap::Namespace xsd ("http://www\\.w3\\.org/2001/XMLSchema");
 
         xsd.types_push_back ("string", string_type);
@@ -800,7 +368,7 @@ namespace CXX
 
         type_map.push_back (xsd);
 
-        // Everyhting else maps to void.
+        // Everything else maps to void.
         //
         TypeMap::Namespace rest (".*");
         rest.types_push_back (".*", "void", "void");
@@ -816,39 +384,33 @@ namespace CXX
 
       //
       //
-      Boolean inline_ (ops.value<CLI::generate_inline> () &&
-                       !generate_xml_schema);
-
-      Boolean source (!generate_xml_schema);
+      bool inline_ (ops.generate_inline () && !generate_xml_schema);
+      bool source (!generate_xml_schema);
 
       // Generate code.
       //
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-      NarrowString name (file_path.leaf ());
-#else
-      NarrowString name (file_path.filename().string());
-#endif
-      NarrowString skel_suffix (ops.value <CLI::skel_file_suffix> ());
-      NarrowString impl_suffix (ops.value <CLI::impl_file_suffix> ());
-
-      NarrowString hxx_suffix (ops.value <CLI::hxx_suffix> ());
-      NarrowString ixx_suffix (ops.value <CLI::ixx_suffix> ());
-      NarrowString cxx_suffix (ops.value <CLI::cxx_suffix> ());
+      NarrowString name (file_path.leaf ().string ());
+      NarrowString skel_suffix (ops.skel_file_suffix ());
+      NarrowString impl_suffix (ops.impl_file_suffix ());
+
+      NarrowString hxx_suffix (ops.hxx_suffix ());
+      NarrowString ixx_suffix (ops.ixx_suffix ());
+      NarrowString cxx_suffix (ops.cxx_suffix ());
 
       Regex hxx_expr (
-        ops.value <CLI::hxx_regex> ().empty ()
+        ops.hxx_regex ().empty ()
         ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + skel_suffix + hxx_suffix + "#"
-        : ops.value <CLI::hxx_regex> ());
+        : ops.hxx_regex ());
 
       Regex ixx_expr (
-        ops.value <CLI::ixx_regex> ().empty ()
+        ops.ixx_regex ().empty ()
         ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + skel_suffix + ixx_suffix + "#"
-        : ops.value <CLI::ixx_regex> ());
+        : ops.ixx_regex ());
 
       Regex cxx_expr (
-        ops.value <CLI::cxx_regex> ().empty ()
+        ops.cxx_regex ().empty ()
         ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + skel_suffix + cxx_suffix + "#"
-        : ops.value <CLI::cxx_regex> ());
+        : ops.cxx_regex ());
 
 
       Regex hxx_impl_expr;
@@ -870,7 +432,7 @@ namespace CXX
       if (!hxx_expr.match (name))
       {
         wcerr << "error: header expression '" <<
-          hxx_expr.pattern () << "' does not match '" <<
+          hxx_expr.regex ().str ().c_str () << "' does not match '" <<
           name.c_str () << "'" << endl;
         throw Failed ();
       }
@@ -878,7 +440,7 @@ namespace CXX
       if (inline_ && !ixx_expr.match (name))
       {
         wcerr << "error: inline expression '" <<
-          ixx_expr.pattern () << "' does not match '" <<
+          ixx_expr.regex ().str ().c_str () << "' does not match '" <<
           name.c_str () << "'" << endl;
         throw Failed ();
       }
@@ -886,7 +448,7 @@ namespace CXX
       if (source && !cxx_expr.match (name))
       {
         wcerr << "error: source expression '" <<
-          cxx_expr.pattern () << "' does not match '" <<
+          cxx_expr.regex ().str ().c_str () << "' does not match '" <<
           name.c_str () << "'" << endl;
         throw Failed ();
       }
@@ -896,7 +458,7 @@ namespace CXX
         if (!hxx_impl_expr.match (name))
         {
           wcerr << "error: implementation header expression '" <<
-            hxx_impl_expr.pattern () << "' does not match '" <<
+            hxx_impl_expr.regex ().str ().c_str () << "' does not match '" <<
             name.c_str () << "'" << endl;
           throw Failed ();
         }
@@ -904,7 +466,7 @@ namespace CXX
         if (!cxx_impl_expr.match (name))
         {
           wcerr << "error: implementation source expression '" <<
-            cxx_impl_expr.pattern () << "' does not match '" <<
+            cxx_impl_expr.regex ().str ().c_str () << "' does not match '" <<
             name.c_str () << "'" << endl;
           throw Failed ();
         }
@@ -912,15 +474,15 @@ namespace CXX
         if (!cxx_driver_expr.match (name))
         {
           wcerr << "error: driver source expression '" <<
-            cxx_driver_expr.pattern () << "' does not match '" <<
+            cxx_driver_expr.regex ().str ().c_str () << "' does not match '" <<
             name.c_str () << "'" << endl;
           throw Failed ();
         }
       }
 
-      NarrowString hxx_name (hxx_expr.merge (name));
-      NarrowString ixx_name (inline_ ? ixx_expr.merge (name) : NarrowString ());
-      NarrowString cxx_name (source ? cxx_expr.merge (name) : NarrowString ());
+      NarrowString hxx_name (hxx_expr.replace (name));
+      NarrowString ixx_name (inline_ ? ixx_expr.replace (name) : NarrowString ());
+      NarrowString cxx_name (source ? cxx_expr.replace (name) : NarrowString ());
 
       NarrowString hxx_impl_name;
       NarrowString cxx_impl_name;
@@ -928,20 +490,14 @@ namespace CXX
 
       if (impl || driver)
       {
-        hxx_impl_name = hxx_impl_expr.merge (name);
-        cxx_impl_name = cxx_impl_expr.merge (name);
-        cxx_driver_name = cxx_driver_expr.merge (name);
+        hxx_impl_name = hxx_impl_expr.replace (name);
+        cxx_impl_name = cxx_impl_expr.replace (name);
+        cxx_driver_name = cxx_driver_expr.replace (name);
       }
 
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-      Path hxx_path (hxx_name, boost::filesystem::native);
-      Path ixx_path (ixx_name, boost::filesystem::native);
-      Path cxx_path (cxx_name, boost::filesystem::native);
-#else
-      Path hxx_path (hxx_name.c_str());
-      Path ixx_path (ixx_name.c_str());
-      Path cxx_path (cxx_name.c_str());
-#endif
+      Path hxx_path (hxx_name);
+      Path ixx_path (ixx_name);
+      Path cxx_path (cxx_name);
 
       Path hxx_impl_path;
       Path cxx_impl_path;
@@ -949,28 +505,18 @@ namespace CXX
 
       if (impl || driver)
       {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        hxx_impl_path = Path (hxx_impl_name, boost::filesystem::native);
-        cxx_impl_path = Path (cxx_impl_name, boost::filesystem::native);
-        cxx_driver_path = Path (cxx_driver_name, boost::filesystem::native);
-#else
-        hxx_impl_path = Path (hxx_impl_name.c_str());
-        cxx_impl_path = Path (cxx_impl_name.c_str());
-        cxx_driver_path = Path (cxx_driver_name.c_str());
-#endif
+        hxx_impl_path = Path (hxx_impl_name);
+        cxx_impl_path = Path (cxx_impl_name);
+        cxx_driver_path = Path (cxx_driver_name);
       }
 
       Path out_dir;
 
-      if (NarrowString dir = ops.value<CLI::output_dir> ())
+      if (NarrowString dir = ops.output_dir ())
       {
         try
         {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-          out_dir = Path (dir, boost::filesystem::native);
-#else
-          out_dir = Path (dir.c_str());
-#endif
+          out_dir = Path (dir);
         }
         catch (InvalidPath const&)
         {
@@ -985,7 +531,7 @@ namespace CXX
         // unless the user added the directory so that we propagate this
         // to the output files.
         //
-        Path fpt_dir (file_path.branch_path ());
+        Path fpt_dir (file_path.directory ());
 
         if (!fpt_dir.empty ())
           out_dir /= fpt_dir;
@@ -1014,9 +560,10 @@ namespace CXX
 
       if (impl)
       {
-        if (!ops.value<CLI::force_overwrite> ())
+        if (!ops.force_overwrite ())
         {
-          WideInputFileStream tmp (hxx_impl_path, ios_base::in);
+          WideInputFileStream tmp (
+            hxx_impl_path.string ().c_str (), ios_base::in);
 
           if (tmp.is_open ())
           {
@@ -1028,7 +575,7 @@ namespace CXX
           tmp.close ();
         }
 
-        hxx_impl.open (hxx_impl_path, ios_base::out);
+        hxx_impl.open (hxx_impl_path.string ().c_str (), ios_base::out);
 
         if (!hxx_impl.is_open ())
         {
@@ -1038,15 +585,12 @@ namespace CXX
         }
 
         unlinks.add (hxx_impl_path);
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        file_list.push_back (hxx_impl_path.native_file_string ());
-#else
         file_list.push_back (hxx_impl_path.string ());
-#endif
 
-        if (!ops.value<CLI::force_overwrite> ())
+        if (!ops.force_overwrite ())
         {
-          WideInputFileStream tmp (cxx_impl_path, ios_base::in);
+          WideInputFileStream tmp (
+            cxx_impl_path.string ().c_str (), ios_base::in);
 
           if (tmp.is_open ())
           {
@@ -1058,7 +602,7 @@ namespace CXX
           tmp.close ();
         }
 
-        cxx_impl.open (cxx_impl_path, ios_base::out);
+        cxx_impl.open (cxx_impl_path.string ().c_str (), ios_base::out);
 
         if (!cxx_impl.is_open ())
         {
@@ -1068,18 +612,15 @@ namespace CXX
         }
 
         unlinks.add (cxx_impl_path);
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        file_list.push_back (cxx_impl_path.native_file_string ());
-#else
         file_list.push_back (cxx_impl_path.string ());
-#endif
       }
 
       if (driver)
       {
-        if (!ops.value<CLI::force_overwrite> ())
+        if (!ops.force_overwrite ())
         {
-          WideInputFileStream tmp (cxx_driver_path, ios_base::in);
+          WideInputFileStream tmp (
+            cxx_driver_path.string ().c_str (), ios_base::in);
 
           if (tmp.is_open ())
           {
@@ -1091,7 +632,7 @@ namespace CXX
           tmp.close ();
         }
 
-        cxx_driver.open (cxx_driver_path, ios_base::out);
+        cxx_driver.open (cxx_driver_path.string ().c_str (), ios_base::out);
 
         if (!cxx_driver.is_open ())
         {
@@ -1101,16 +642,12 @@ namespace CXX
         }
 
         unlinks.add (cxx_driver_path);
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        file_list.push_back (cxx_driver_path.native_file_string ());
-#else
         file_list.push_back (cxx_driver_path.string ());
-#endif
       }
 
       // Open the skel files.
       //
-      WideOutputFileStream hxx (hxx_path, ios_base::out);
+      WideOutputFileStream hxx (hxx_path.string ().c_str (), ios_base::out);
       WideOutputFileStream ixx;
       WideOutputFileStream cxx;
 
@@ -1121,15 +658,11 @@ namespace CXX
       }
 
       unlinks.add (hxx_path);
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-      file_list.push_back (hxx_path.native_file_string ());
-#else
       file_list.push_back (hxx_path.string ());
-#endif
 
       if (inline_)
       {
-        ixx.open (ixx_path, ios_base::out);
+        ixx.open (ixx_path.string ().c_str (), ios_base::out);
 
         if (!ixx.is_open ())
         {
@@ -1138,17 +671,13 @@ namespace CXX
         }
 
         unlinks.add (ixx_path);
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        file_list.push_back (ixx_path.native_file_string ());
-#else
         file_list.push_back (ixx_path.string ());
-#endif
       }
 
 
       if (source)
       {
-        cxx.open (cxx_path, ios_base::out);
+        cxx.open (cxx_path.string ().c_str (), ios_base::out);
 
         if (!cxx.is_open ())
         {
@@ -1157,19 +686,13 @@ namespace CXX
         }
 
         unlinks.add (cxx_path);
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        file_list.push_back (cxx_path.native_file_string ());
-#else
         file_list.push_back (cxx_path.string ());
-#endif
       }
 
       // Print copyright and license.
       //
-      Char const* copyright (
-        ops.value<CLI::proprietary_license> ()
-        ? copyright_proprietary
-        : copyright_gpl);
+      char const* copyright (
+        ops.proprietary_license () ? copyright_proprietary : copyright_gpl);
 
       hxx << copyright;
 
@@ -1192,7 +715,7 @@ namespace CXX
       //
       WideInputFileStream prologue;
       {
-        NarrowString name (ops.value<CLI::prologue_file> ());
+        NarrowString name (ops.prologue_file ());
 
         if (name)
           open (prologue, name);
@@ -1202,7 +725,7 @@ namespace CXX
       //
       WideInputFileStream epilogue;
       {
-        NarrowString name (ops.value<CLI::epilogue_file> ());
+        NarrowString name (ops.epilogue_file ());
 
         if (name)
           open (epilogue, name);
@@ -1210,21 +733,25 @@ namespace CXX
 
       // SLOC counter.
       //
-      UnsignedLong sloc (0);
-      Boolean show_sloc (ops.value<CLI::show_sloc> ());
+      size_t sloc_total (0);
+      bool show_sloc (ops.show_sloc ());
+
+      typedef
+      compiler::ostream_filter<compiler::cxx_indenter, wchar_t>
+      ind_filter;
+
+      typedef
+      compiler::ostream_filter<compiler::sloc_counter, wchar_t>
+      sloc_filter;
 
       //
       //
       Regex guard_expr ("/([a-z])([A-Z])/$1_$2/"); // Split words.
 
-      NarrowString guard_prefix (ops.value<CLI::guard_prefix> ());
+      NarrowString guard_prefix (ops.guard_prefix ());
 
       if (!guard_prefix)
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        guard_prefix = file_path.branch_path ().native_directory_string ();
-#else
-        guard_prefix = file_path.branch_path ().string ();
-#endif
+        guard_prefix = file_path.directory ().string ();
 
       if (guard_prefix)
         guard_prefix += '_';
@@ -1241,9 +768,9 @@ namespace CXX
                      &ixx_expr,
                      &hxx_impl_expr);
 
-        Indentation::Clip<Indentation::SLOC, WideChar> hxx_sloc (hxx);
+        sloc_filter sloc (hxx);
 
-        String guard (guard_expr.merge (guard_prefix + hxx_name));
+        String guard (guard_expr.replace (guard_prefix + hxx_name));
         guard = ctx.escape (guard); // Make it a C++ id.
         std::transform (guard.begin (), guard.end(), guard.begin (), upcase);
 
@@ -1251,14 +778,21 @@ namespace CXX
             << "#define " << guard << endl
             << endl;
 
+        if (ctx.std >= cxx_version::cxx11)
+        {
+          hxx << "#ifndef XSD_CXX11" << endl
+              << "#define XSD_CXX11" << endl
+              << "#endif" << endl
+              << endl;
+        }
+
         // Copy prologue.
         //
         hxx << "// Begin prologue." << endl
             << "//" << endl;
 
-        append (
-          hxx, ops.value<CLI::hxx_prologue> (), ops.value<CLI::prologue> ());
-        append (hxx, ops.value<CLI::hxx_prologue_file> (), prologue);
+        append (hxx, ops.hxx_prologue (), ops.prologue ());
+        append (hxx, ops.hxx_prologue_file (), prologue);
 
         hxx << "//" << endl
             << "// End prologue." << endl
@@ -1273,38 +807,33 @@ namespace CXX
             << "#endif" << endl
             << endl;
 
-        {
-          hxx << "#include <xsd/cxx/pre.hxx>" << endl
-              << endl;
-
-          // Set auto-indentation.
-          //
-          Indentation::Clip<Indentation::CXX, WideChar> hxx_clip (hxx);
+        hxx << "#include <xsd/cxx/pre.hxx>" << endl
+            << endl;
 
+        // Generate.
+        //
+        {
+          ind_filter ind (hxx); // We don't want to indent prologues/epilogues.
 
-          // Generate.
-          //
           if (!generate_xml_schema)
             generate_parser_forward (ctx);
 
           generate_parser_header (ctx, generate_xml_schema);
+        }
 
+        if (inline_)
+          hxx << "#include " << ctx.process_include_path (ixx_name) << endl;
 
-          if (inline_)
-            hxx << "#include " << ctx.process_include_path (ixx_name) << endl;
-
-          hxx << "#include <xsd/cxx/post.hxx>" << endl
-              << endl;
-        }
+        hxx << "#include <xsd/cxx/post.hxx>" << endl
+            << endl;
 
         // Copy epilogue.
         //
         hxx << "// Begin epilogue." << endl
             << "//" << endl;
 
-        append (hxx, ops.value<CLI::hxx_epilogue_file> (), epilogue);
-        append (
-          hxx, ops.value<CLI::hxx_epilogue> (), ops.value<CLI::epilogue> ());
+        append (hxx, ops.hxx_epilogue_file (), epilogue);
+        append (hxx, ops.hxx_epilogue (), ops.epilogue ());
 
         hxx << "//" << endl
             << "// End epilogue." << endl
@@ -1313,12 +842,9 @@ namespace CXX
         hxx << "#endif // " << guard << endl;
 
         if (show_sloc)
-        {
-          wcerr << hxx_path << ": "
-                << hxx_sloc.buffer ().count () << endl;
+          wcerr << hxx_path << ": " << sloc.stream ().count () << endl;
 
-          sloc += hxx_sloc.buffer ().count ();
-        }
+        sloc_total += sloc.stream ().count ();
       }
 
 
@@ -1335,30 +861,24 @@ namespace CXX
                      &ixx_expr,
                      &hxx_impl_expr);
 
-        Indentation::Clip<Indentation::SLOC, WideChar> ixx_sloc (ixx);
-
+        sloc_filter sloc (ixx);
 
         // Copy prologue.
         //
         ixx << "// Begin prologue." << endl
             << "//" << endl;
 
-        append (
-          ixx, ops.value<CLI::ixx_prologue> (), ops.value<CLI::prologue> ());
-        append (ixx, ops.value<CLI::ixx_prologue_file> (), prologue);
+        append (ixx, ops.ixx_prologue (), ops.prologue ());
+        append (ixx, ops.ixx_prologue_file (), prologue);
 
         ixx << "//" << endl
             << "// End prologue." << endl
             << endl;
 
+        // Generate.
+        //
         {
-          // Set auto-indentation.
-          //
-          Indentation::Clip<Indentation::CXX, WideChar> ixx_clip (ixx);
-
-
-          // Generate.
-          //
+          ind_filter ind (ixx); // We don't want to indent prologues/epilogues.
           generate_parser_inline (ctx);
         }
 
@@ -1367,21 +887,17 @@ namespace CXX
         ixx << "// Begin epilogue." << endl
             << "//" << endl;
 
-        append (ixx, ops.value<CLI::ixx_epilogue_file> (), epilogue);
-        append (
-          ixx, ops.value<CLI::ixx_epilogue> (), ops.value<CLI::epilogue> ());
+        append (ixx, ops.ixx_epilogue_file (), epilogue);
+        append (ixx, ops.ixx_epilogue (), ops.epilogue ());
 
         ixx << "//" << endl
             << "// End epilogue." << endl
             << endl;
 
         if (show_sloc)
-        {
-          wcerr << ixx_path << ": "
-                << ixx_sloc.buffer ().count () << endl;
+          wcerr << ixx_path << ": " << sloc.stream ().count () << endl;
 
-          sloc += ixx_sloc.buffer ().count ();
-        }
+        sloc_total += sloc.stream ().count ();
       }
 
 
@@ -1398,28 +914,30 @@ namespace CXX
                      &ixx_expr,
                      &hxx_impl_expr);
 
-        Indentation::Clip<Indentation::SLOC, WideChar> cxx_sloc (cxx);
+        sloc_filter sloc (cxx);
 
         // Copy prologue.
         //
         cxx << "// Begin prologue." << endl
             << "//" << endl;
 
-        append (
-          cxx, ops.value<CLI::cxx_prologue> (), ops.value<CLI::prologue> ());
-        append (cxx, ops.value<CLI::cxx_prologue_file> (), prologue);
+        append (cxx, ops.cxx_prologue (), ops.prologue ());
+        append (cxx, ops.cxx_prologue_file (), prologue);
 
         cxx << "//" << endl
             << "// End prologue." << endl
             << endl;
 
-        {
-          // Set auto-indentation.
-          //
-          Indentation::Clip<Indentation::CXX, WideChar> cxx_clip (cxx);
+        cxx << "#include <xsd/cxx/pre.hxx>" << endl
+             << endl;
 
-          cxx << "#include " << ctx.process_include_path (hxx_name) << endl
-              << endl;
+        cxx << "#include " << ctx.process_include_path (hxx_name) << endl
+            << endl;
+
+        // Generate.
+        //
+        {
+          ind_filter ind (cxx); // We don't want to indent prologues/epilogues.
 
           if (!inline_)
             generate_parser_inline (ctx);
@@ -1434,26 +952,25 @@ namespace CXX
           }
         }
 
+        cxx << "#include <xsd/cxx/post.hxx>" << endl
+            << endl;
+
         // Copy epilogue.
         //
         cxx << "// Begin epilogue." << endl
             << "//" << endl;
 
-        append (cxx, ops.value<CLI::cxx_epilogue_file> (), epilogue);
-        append (
-          cxx, ops.value<CLI::cxx_epilogue> (), ops.value<CLI::epilogue> ());
+        append (cxx, ops.cxx_epilogue_file (), epilogue);
+        append (cxx, ops.cxx_epilogue (), ops.epilogue ());
 
         cxx << "//" << endl
             << "// End epilogue." << endl
             << endl;
 
         if (show_sloc)
-        {
-          wcerr << cxx_path << ": "
-                << cxx_sloc.buffer ().count () << endl;
+          wcerr << cxx_path << ": " << sloc.stream ().count () << endl;
 
-          sloc += cxx_sloc.buffer ().count ();
-        }
+        sloc_total += sloc.stream ().count ();
       }
 
       // HXX impl
@@ -1469,7 +986,7 @@ namespace CXX
                      &ixx_expr,
                      &hxx_impl_expr);
 
-        String guard (guard_expr.merge (guard_prefix + hxx_impl_name));
+        String guard (guard_expr.replace (guard_prefix + hxx_impl_name));
         guard = ctx.escape (guard); // Make it a C++ id.
         std::transform (guard.begin (), guard.end(), guard.begin (), upcase);
 
@@ -1477,14 +994,11 @@ namespace CXX
                  << "#define " << guard << endl
                  << endl;
 
-        {
-          // Set auto-indentation.
-          //
-          Indentation::Clip<Indentation::CXX, WideChar> clip (hxx_impl);
-
-          hxx_impl << "#include " << ctx.process_include_path (hxx_name)
-                   << endl << endl;
+        hxx_impl << "#include " << ctx.process_include_path (hxx_name)
+                 << endl << endl;
 
+        {
+          ind_filter ind (hxx_impl);
           generate_impl_header (ctx);
         }
 
@@ -1504,14 +1018,13 @@ namespace CXX
                      &ixx_expr,
                      &hxx_impl_expr);
 
-        // Set auto-indentation.
-        //
-        Indentation::Clip<Indentation::CXX, WideChar> clip (cxx_impl);
-
         cxx_impl << "#include " << ctx.process_include_path (hxx_impl_name)
                  << endl << endl;
 
-        generate_impl_source (ctx);
+        {
+          ind_filter ind (cxx_impl);
+          generate_impl_source (ctx);
+        }
       }
 
       // CXX driver
@@ -1527,17 +1040,16 @@ namespace CXX
                      &ixx_expr,
                      &hxx_impl_expr);
 
-        // Set auto-indentation.
-        //
-        Indentation::Clip<Indentation::CXX, WideChar> clip (cxx_driver);
-
         cxx_driver << "#include " << ctx.process_include_path (hxx_impl_name)
                    << endl << endl;
 
-        generate_driver_source (ctx);
+        {
+          ind_filter ind (cxx_driver);
+          generate_driver_source (ctx);
+        }
       }
 
-      return sloc;
+      return sloc_total;
     }
     catch (UnrepresentableCharacter const& e)
     {
@@ -1569,18 +1081,18 @@ namespace CXX
 
       throw Failed ();
     }
-    catch (BackendElements::Regex::Format<Char> const& e)
+    catch (cutl::re::format const& e)
     {
       wcerr << "error: invalid regex: '" <<
-        e.expression ().c_str () << "': " <<
+        e.regex ().c_str () << "': " <<
         e.description ().c_str () << endl;
 
       throw Failed ();
     }
-    catch (BackendElements::Regex::Format<WideChar> const& e)
+    catch (cutl::re::wformat const& e)
     {
       wcerr << "error: invalid regex: '" <<
-        e.expression () << "': " << e.description () << endl;
+        e.regex () << "': " << e.description ().c_str () << endl;
 
       throw Failed ();
     }
diff --git a/xsd/xsd/cxx/parser/generator.hxx b/xsd/xsd/cxx/parser/generator.hxx
index eaa1ecd..784ca9d 100644
--- a/xsd/xsd/cxx/parser/generator.hxx
+++ b/xsd/xsd/cxx/parser/generator.hxx
@@ -1,50 +1,38 @@
 // file      : xsd/cxx/parser/generator.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_GENERATOR_HXX
 #define CXX_PARSER_GENERATOR_HXX
 
-#include <cult/types.hxx>
-
-#include <cult/containers/vector.hxx>
-
-#include <cult/cli/options.hxx>
-#include <cult/cli/options-spec.hxx>
-
 #include <xsd-frontend/semantic-graph/elements.hxx> // Path
 #include <xsd-frontend/semantic-graph/schema.hxx>
 
 #include <xsd.hxx>
+#include <types.hxx>
 
 #include <cxx/literal-map.hxx>
-#include <cxx/parser/cli.hxx>
+#include <cxx/parser/options.hxx>
 
 namespace CXX
 {
   namespace Parser
   {
-    using namespace Cult::Types;
-
     class Generator
     {
     public:
-      static Void
+      static void
       usage ();
 
-      static CLI::OptionsSpec
-      options_spec ();
-
       struct Failed {};
 
-      static UnsignedLong
-      generate (CLI::Options const& options,
+      static size_t
+      generate (options const&,
                 XSDFrontend::SemanticGraph::Schema&,
                 XSDFrontend::SemanticGraph::Path const& file,
-                Boolean file_per_type,
+                bool file_per_type,
                 StringLiteralMap const&,
-                Boolean gen_driver,
+                bool gen_driver,
                 const WarningSet& disabled_warnings,
                 FileList& file_list,
                 AutoUnlinks& unlinks);
diff --git a/xsd/xsd/cxx/parser/impl-header.cxx b/xsd/xsd/cxx/parser/impl-header.cxx
index ff635f1..a3d47a4 100644
--- a/xsd/xsd/cxx/parser/impl-header.cxx
+++ b/xsd/xsd/cxx/parser/impl-header.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/impl-header.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/parser/impl-header.hxx>
@@ -21,7 +20,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String const& name (eimpl (e));
@@ -51,7 +50,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String const& name (eimpl (l));
@@ -98,7 +97,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String const& name (eimpl (u));
@@ -130,7 +129,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
 	  if (skip (m))
@@ -161,7 +160,7 @@ namespace CXX
           names_parser_callback_ >> parser_callback_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           String const& name (eimpl (c));
@@ -202,12 +201,12 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_impl_header (Context& ctx)
     {
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Includes includes (ctx, Includes::impl_header);
       Traversal::Names schema_names;
 
diff --git a/xsd/xsd/cxx/parser/impl-header.hxx b/xsd/xsd/cxx/parser/impl-header.hxx
index dd63e52..273201b 100644
--- a/xsd/xsd/cxx/parser/impl-header.hxx
+++ b/xsd/xsd/cxx/parser/impl-header.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/impl-header.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_IMPL_HEADER_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Parser
   {
-    Void
+    void
     generate_impl_header (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/parser/impl-source.cxx b/xsd/xsd/cxx/parser/impl-source.cxx
index b951f6a..ad85f81 100644
--- a/xsd/xsd/cxx/parser/impl-source.cxx
+++ b/xsd/xsd/cxx/parser/impl-source.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/impl-source.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/parser/impl-source.hxx>
@@ -22,7 +21,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String const& name (eimpl (e));
@@ -57,7 +56,7 @@ namespace CXX
             os << arg_type (base) << " v (" << post_name (base) << " ());"
                << endl;
 
-            if (options.value<CLI::generate_print_impl> ())
+            if (options.generate_print_impl ())
             {
               PrintCall t (*this, e.name (), "v");
               t.dispatch (base);
@@ -91,7 +90,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String const& name (eimpl (l));
@@ -126,7 +125,7 @@ namespace CXX
 
           if (arg != L"void")
           {
-            if (options.value<CLI::generate_print_impl> ())
+            if (options.generate_print_impl ())
             {
               PrintCall t (*this, type.name (), item);
               t.dispatch (type);
@@ -164,7 +163,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String const& name (eimpl (u));
@@ -186,7 +185,7 @@ namespace CXX
              << "_characters (const " << string_type << "& s)"
              << "{";
 
-          if (options.value<CLI::generate_print_impl> ())
+          if (options.generate_print_impl ())
             os << cout_inst << " << " << strlit (u.name () + L": ") <<
               " << s << std::endl;";
           else
@@ -221,7 +220,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
 	  if (skip (m))
@@ -244,7 +243,7 @@ namespace CXX
 
           if (arg != L"void")
           {
-            if (options.value<CLI::generate_print_impl> ())
+            if (options.generate_print_impl ())
             {
               PrintCall t (*this, m.name (), name);
               t.dispatch (m.type ());
@@ -268,12 +267,12 @@ namespace CXX
           names_parser_callback_ >> parser_callback_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           String const& name (eimpl (c));
 
-          Boolean restriction (restriction_p (c));
+          bool restriction (restriction_p (c));
 
           os << "// " << name << endl
              << "//" << endl
@@ -314,7 +313,7 @@ namespace CXX
               os << arg_type (base) << " v (" << post_name (base) << " ());"
                  << endl;
 
-              if (options.value<CLI::generate_print_impl> ())
+              if (options.generate_print_impl ())
               {
                 PrintCall t (*this, c.name (), "v");
                 t.dispatch (base);
@@ -354,15 +353,15 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_impl_source (Context& ctx)
     {
-      if (ctx.options.value<CLI::generate_print_impl> ())
+      if (ctx.options.generate_print_impl ())
         ctx.os << "#include <iostream>" << endl
                << endl;
 
       Traversal::Schema schema;
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names schema_names;
       Namespace ns (ctx);
       Traversal::Names names;
diff --git a/xsd/xsd/cxx/parser/impl-source.hxx b/xsd/xsd/cxx/parser/impl-source.hxx
index 0d60162..b6f9b3d 100644
--- a/xsd/xsd/cxx/parser/impl-source.hxx
+++ b/xsd/xsd/cxx/parser/impl-source.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/impl-source.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_IMPL_SOURCE_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Parser
   {
-    Void
+    void
     generate_impl_source (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/parser/name-processor.cxx b/xsd/xsd/cxx/parser/name-processor.cxx
index d323187..219a3c9 100644
--- a/xsd/xsd/cxx/parser/name-processor.cxx
+++ b/xsd/xsd/cxx/parser/name-processor.cxx
@@ -1,66 +1,47 @@
 // file      : xsd/cxx/parser/name-processor.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
+#include <set>
+#include <map>
+#include <sstream>
+#include <iostream>
+
 #include <cxx/parser/name-processor.hxx>
 
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
 
-#include <cult/containers/set.hxx>
 
-#include <sstream>
-#include <iostream>
+using namespace std;
 
 namespace CXX
 {
   namespace Parser
   {
-    NameProcessor::
-    NameProcessor ()
-    {
-      // Dummy ctor, helps with long symbols on HP-UX.
-    }
-
     namespace
     {
       //
       //
-      typedef Cult::Containers::Set<String> NameSet;
+      typedef set<String> NameSet;
 
       class Context: public CXX::Context
       {
       public:
-        Context (CLI::Options const& ops,
+        Context (Parser::options const& ops,
                  SemanticGraph::Schema& root,
                  SemanticGraph::Path const& path,
                  StringLiteralMap const* map)
-            : CXX::Context (std::wcerr,
-                            root,
-                            path,
-                            map,
-                            ops.value<CLI::char_type> (),
-                            ops.value<CLI::char_encoding> (),
-                            ops.value<CLI::include_with_brackets> (),
-                            ops.value<CLI::include_prefix> (),
-                            ops.value<CLI::export_symbol> (),
-                            ops.value<CLI::namespace_map> (),
-                            ops.value<CLI::namespace_regex> (),
-                            ops.value<CLI::namespace_regex_trace> (),
-                            ops.value<CLI::include_regex> (),
-                            ops.value<CLI::include_regex_trace> (),
-                            ops.value<CLI::generate_inline> (),
-                            ops.value<CLI::reserved_name> ()),
-              skel_suffix_ (ops.value<CLI::skel_type_suffix> ()),
-              impl_suffix_ (ops.value<CLI::impl_type_suffix> ()),
-              impl (ops.value<CLI::generate_noop_impl> () ||
-                    ops.value<CLI::generate_print_impl> () ||
-                    ops.value<CLI::generate_test_driver> ()),
+            : CXX::Context (std::wcerr, root, path, ops, map),
+              skel_suffix_ (ops.skel_type_suffix ()),
+              impl_suffix_ (ops.impl_type_suffix ()),
+              impl (ops.generate_noop_impl () ||
+                    ops.generate_print_impl () ||
+                    ops.generate_test_driver ()),
               skel_suffix (skel_suffix_),
               impl_suffix (impl_suffix_),
               global_type_names (global_type_names_),
-              polymorphic (ops.value<CLI::generate_polymorphic> ())
+              polymorphic (ops.generate_polymorphic ())
         {
         }
 
@@ -82,7 +63,7 @@ namespace CXX
           String base_name (escape (n));
           String name (base_name);
 
-          for (UnsignedLong i (1); set.find (name) != set.end (); ++i)
+          for (size_t i (1); set.find (name) != set.end (); ++i)
           {
             std::wostringstream os;
             os << i;
@@ -97,16 +78,16 @@ namespace CXX
         String const skel_suffix_;
         String const impl_suffix_;
 
-        Cult::Containers::Map<String, NameSet> global_type_names_;
+        map<String, NameSet> global_type_names_;
 
       public:
-        Boolean const impl;
+        bool const impl;
         String const& skel_suffix;
         String const& impl_suffix;
 
-        Cult::Containers::Map<String, NameSet>& global_type_names;
+        map<String, NameSet>& global_type_names;
 
-        Boolean polymorphic;
+        bool polymorphic;
       };
 
 
@@ -119,7 +100,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
           if (Parser::Context::skip (m))
@@ -139,7 +120,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
           if (Parser::Context::skip (m))
@@ -156,9 +137,6 @@ namespace CXX
               !m.type ().context ().count ("anonymous"))
           {
             m.context ().set (
-              "member-cache", find_name (base + L"_parser_cache_", set_));
-
-            m.context ().set (
               "member-map", find_name (base + L"_parser_map_", set_));
 
             m.context ().set (
@@ -245,7 +223,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
           if (Parser::Context::skip (m))
@@ -282,17 +260,17 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
           if (Parser::Context::skip (m))
             return;
 
-          Boolean poly (polymorphic &&
+          bool poly (polymorphic &&
                         m.is_a<SemanticGraph::Element> () &&
                         !m.type ().context ().count ("anonymous"));
 
-          String parser, member, member_cache, member_map, member_map_impl;
+          String parser, member, member_map, member_map_impl;
 
           try
           {
@@ -306,7 +284,6 @@ namespace CXX
 
             if (poly)
             {
-              member_cache = bm.context ().get<String> ("member-cache");
               member_map = bm.context ().get<String> ("member-map");
               member_map_impl = bm.context ().get<String> ("member-map-impl");
             }
@@ -322,7 +299,6 @@ namespace CXX
 
             if (poly)
             {
-              member_cache = find_name (base + L"_parser_cache_", set_);
               member_map = find_name (base + L"_parser_map_", set_);
               member_map_impl = find_name (base + L"_parser_map_impl_", set_);
             }
@@ -333,7 +309,6 @@ namespace CXX
 
           if (poly)
           {
-            m.context ().set ("member-cache", member_cache);
             m.context ().set ("member-map", member_map);
             m.context ().set ("member-map-impl", member_map_impl);
           }
@@ -349,7 +324,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           SemanticGraph::Context& cc (c.context ());
@@ -371,7 +346,7 @@ namespace CXX
           // inheriting by restriction in which case we need to have
           // the same names as our base.
           //
-          Boolean restriction (false);
+          bool restriction (false);
 
           if (c.inherits_p ())
           {
@@ -464,7 +439,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Type& t)
         {
           SemanticGraph::Context& c (t.context ());
@@ -533,7 +508,7 @@ namespace CXX
             String base_name (escape (L"post_" + n));
             String post (base_name);
 
-            for (UnsignedLong i (1); set.find (post) != set.end (); ++i)
+            for (size_t i (1); set.find (post) != set.end (); ++i)
             {
               std::wostringstream os;
               os << i;
@@ -556,7 +531,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& ns)
         {
           NameSet& type_set (global_type_names[ns.name ()]);
@@ -634,7 +609,7 @@ namespace CXX
 
         // anyType & anySimpleType.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyType& t)
         {
           t.context ().set ("name", make_skel_name ("any_type"));
@@ -642,7 +617,7 @@ namespace CXX
           t.context ().set ("post", String ("post_any_type"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnySimpleType& t)
         {
           t.context ().set ("name", make_skel_name ("any_simple_type"));
@@ -652,7 +627,7 @@ namespace CXX
 
         // Boolean.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Boolean& t)
         {
           t.context ().set ("name", make_skel_name ("boolean"));
@@ -662,7 +637,7 @@ namespace CXX
 
         // Integral types.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Byte& t)
         {
           t.context ().set ("name", make_skel_name ("byte"));
@@ -670,7 +645,7 @@ namespace CXX
           t.context ().set ("post", String ("post_byte"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedByte& t)
         {
           t.context ().set ("name", make_skel_name ("unsigned_byte"));
@@ -678,7 +653,7 @@ namespace CXX
           t.context ().set ("post", String ("post_unsigned_byte"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Short& t)
         {
           t.context ().set ("name", make_skel_name ("short"));
@@ -686,7 +661,7 @@ namespace CXX
           t.context ().set ("post", String ("post_short"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedShort& t)
         {
           t.context ().set ("name", make_skel_name ("unsigned_short"));
@@ -694,7 +669,7 @@ namespace CXX
           t.context ().set ("post", String ("post_unsigned_short"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Int& t)
         {
           t.context ().set ("name", make_skel_name ("int"));
@@ -702,7 +677,7 @@ namespace CXX
           t.context ().set ("post", String ("post_int"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedInt& t)
         {
           t.context ().set ("name", make_skel_name ("unsigned_int"));
@@ -710,7 +685,7 @@ namespace CXX
           t.context ().set ("post", String ("post_unsigned_int"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Long& t)
         {
           t.context ().set ("name", make_skel_name ("long"));
@@ -718,7 +693,7 @@ namespace CXX
           t.context ().set ("post", String ("post_long"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedLong& t)
         {
           t.context ().set ("name", make_skel_name ("unsigned_long"));
@@ -726,7 +701,7 @@ namespace CXX
           t.context ().set ("post", String ("post_unsigned_long"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Integer& t)
         {
           t.context ().set ("name", make_skel_name ("integer"));
@@ -734,7 +709,7 @@ namespace CXX
           t.context ().set ("post", String ("post_integer"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NonPositiveInteger& t)
         {
           t.context ().set ("name", make_skel_name ("non_positive_integer"));
@@ -742,7 +717,7 @@ namespace CXX
           t.context ().set ("post", String ("post_non_positive_integer"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NonNegativeInteger& t)
         {
           t.context ().set ("name", make_skel_name ("non_negative_integer"));
@@ -750,7 +725,7 @@ namespace CXX
           t.context ().set ("post", String ("post_non_negative_integer"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::PositiveInteger& t)
         {
           t.context ().set ("name", make_skel_name ("positive_integer"));
@@ -758,7 +733,7 @@ namespace CXX
           t.context ().set ("post", String ("post_positive_integer"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NegativeInteger& t)
         {
           t.context ().set ("name", make_skel_name ("negative_integer"));
@@ -768,7 +743,7 @@ namespace CXX
 
         // Floats.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Float& t)
         {
           t.context ().set ("name", make_skel_name ("float"));
@@ -776,7 +751,7 @@ namespace CXX
           t.context ().set ("post", String ("post_float"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Double& t)
         {
           t.context ().set ("name", make_skel_name ("double"));
@@ -784,7 +759,7 @@ namespace CXX
           t.context ().set ("post", String ("post_double"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Decimal& t)
         {
           t.context ().set ("name", make_skel_name ("decimal"));
@@ -794,7 +769,7 @@ namespace CXX
 
         // Strings.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::String& t)
         {
           t.context ().set ("name", make_skel_name ("string"));
@@ -802,7 +777,7 @@ namespace CXX
           t.context ().set ("post", String ("post_string"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NormalizedString& t)
         {
           t.context ().set ("name", make_skel_name ("normalized_string"));
@@ -810,7 +785,7 @@ namespace CXX
           t.context ().set ("post", String ("post_normalized_string"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Token& t)
         {
           t.context ().set ("name", make_skel_name ("token"));
@@ -818,7 +793,7 @@ namespace CXX
           t.context ().set ("post", String ("post_token"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NameToken& t)
         {
           t.context ().set ("name", make_skel_name ("nmtoken"));
@@ -826,7 +801,7 @@ namespace CXX
           t.context ().set ("post", String ("post_nmtoken"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NameTokens& t)
         {
           t.context ().set ("name", make_skel_name ("nmtokens"));
@@ -834,7 +809,7 @@ namespace CXX
           t.context ().set ("post", String ("post_nmtokens"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Name& t)
         {
           t.context ().set ("name", make_skel_name ("name"));
@@ -842,7 +817,7 @@ namespace CXX
           t.context ().set ("post", String ("post_name"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NCName& t)
         {
           t.context ().set ("name", make_skel_name ("ncname"));
@@ -850,7 +825,7 @@ namespace CXX
           t.context ().set ("post", String ("post_ncname"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Language& t)
         {
           t.context ().set ("name", make_skel_name ("language"));
@@ -861,7 +836,7 @@ namespace CXX
 
         // Qualified name.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::QName& t)
         {
           t.context ().set ("name", make_skel_name ("qname"));
@@ -872,7 +847,7 @@ namespace CXX
 
         // ID/IDREF.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Id& t)
         {
           t.context ().set ("name", make_skel_name ("id"));
@@ -880,7 +855,7 @@ namespace CXX
           t.context ().set ("post", String ("post_id"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::IdRef& t)
         {
           t.context ().set ("name", make_skel_name ("idref"));
@@ -888,7 +863,7 @@ namespace CXX
           t.context ().set ("post", String ("post_idref"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::IdRefs& t)
         {
           t.context ().set ("name", make_skel_name ("idrefs"));
@@ -898,7 +873,7 @@ namespace CXX
 
         // URI.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::AnyURI& t)
         {
           t.context ().set ("name", make_skel_name ("uri"));
@@ -908,7 +883,7 @@ namespace CXX
 
         // Binary.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Base64Binary& t)
         {
           t.context ().set ("name", make_skel_name ("base64_binary"));
@@ -916,7 +891,7 @@ namespace CXX
           t.context ().set ("post", String ("post_base64_binary"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::HexBinary& t)
         {
           t.context ().set ("name", make_skel_name ("hex_binary"));
@@ -927,7 +902,7 @@ namespace CXX
 
         // Date/time.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Date& t)
         {
           t.context ().set ("name", make_skel_name ("date"));
@@ -935,7 +910,7 @@ namespace CXX
           t.context ().set ("post", String ("post_date"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::DateTime& t)
         {
           t.context ().set ("name", make_skel_name ("date_time"));
@@ -943,7 +918,7 @@ namespace CXX
           t.context ().set ("post", String ("post_date_time"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Duration& t)
         {
           t.context ().set ("name", make_skel_name ("duration"));
@@ -951,7 +926,7 @@ namespace CXX
           t.context ().set ("post", String ("post_duration"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Day& t)
         {
           t.context ().set ("name", make_skel_name ("gday"));
@@ -959,7 +934,7 @@ namespace CXX
           t.context ().set ("post", String ("post_gday"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Month& t)
         {
           t.context ().set ("name", make_skel_name ("gmonth"));
@@ -967,7 +942,7 @@ namespace CXX
           t.context ().set ("post", String ("post_gmonth"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::MonthDay& t)
         {
           t.context ().set ("name", make_skel_name ("gmonth_day"));
@@ -975,7 +950,7 @@ namespace CXX
           t.context ().set ("post", String ("post_gmonth_day"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Year& t)
         {
           t.context ().set ("name", make_skel_name ("gyear"));
@@ -983,7 +958,7 @@ namespace CXX
           t.context ().set ("post", String ("post_gyear"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::YearMonth& t)
         {
           t.context ().set ("name", make_skel_name ("gyear_month"));
@@ -991,7 +966,7 @@ namespace CXX
           t.context ().set ("post", String ("post_gyear_month"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Time& t)
         {
           t.context ().set ("name", make_skel_name ("time"));
@@ -1001,7 +976,7 @@ namespace CXX
 
         // Entity.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Entity& t)
         {
           t.context ().set ("name", make_skel_name ("entity"));
@@ -1009,7 +984,7 @@ namespace CXX
           t.context ().set ("post", String ("post_entity"));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Entities& t)
         {
           t.context ().set ("name", make_skel_name ("entities"));
@@ -1038,7 +1013,7 @@ namespace CXX
                    Traversal::Includes,
                    Traversal::Imports
       {
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Sources& sr)
         {
           SemanticGraph::Schema& s (sr.schema ());
@@ -1050,7 +1025,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Includes& i)
         {
           SemanticGraph::Schema& s (i.schema ());
@@ -1062,7 +1037,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Imports& i)
         {
           SemanticGraph::Schema& s (i.schema ());
@@ -1080,7 +1055,7 @@ namespace CXX
       //
       struct Implies: Traversal::Implies
       {
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Implies& i)
         {
           SemanticGraph::Schema& s (i.schema ());
@@ -1093,8 +1068,8 @@ namespace CXX
         }
       };
 
-      Void
-      process_impl (CLI::Options const& ops,
+      void
+      process_impl (options const& ops,
                     SemanticGraph::Schema& tu,
                     SemanticGraph::Path const& file,
                     StringLiteralMap const& map)
@@ -1169,7 +1144,7 @@ namespace CXX
           //
           {
             Traversal::Schema schema;
-            Traversal::Sources sources;
+            Sources sources;
 
             schema >> sources >> schema;
 
@@ -1189,8 +1164,8 @@ namespace CXX
       }
     }
 
-    Void NameProcessor::
-    process (CLI::Options const& ops,
+    void NameProcessor::
+    process (options const& ops,
              SemanticGraph::Schema& tu,
              SemanticGraph::Path const& file,
              StringLiteralMap const& map)
diff --git a/xsd/xsd/cxx/parser/name-processor.hxx b/xsd/xsd/cxx/parser/name-processor.hxx
index 5c28371..0460ea4 100644
--- a/xsd/xsd/cxx/parser/name-processor.hxx
+++ b/xsd/xsd/cxx/parser/name-processor.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/name-processor.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_NAME_PROCESSOR_HXX
@@ -8,22 +7,20 @@
 
 #include <xsd-frontend/semantic-graph.hxx>
 
+#include <types.hxx>
+
 #include <cxx/elements.hxx>
-#include <cxx/parser/cli.hxx>
+#include <cxx/parser/options.hxx>
 
 namespace CXX
 {
   namespace Parser
   {
-    using namespace Cult::Types;
-
     class NameProcessor
     {
     public:
-      NameProcessor (); // Dummy ctor, helps with long symbols on HP-UX.
-
-      Void
-      process (CLI::Options const& ops,
+      void
+      process (options const&,
                XSDFrontend::SemanticGraph::Schema&,
                XSDFrontend::SemanticGraph::Path const& file,
                StringLiteralMap const& map);
diff --git a/xsd/xsd/cxx/parser/options.cli b/xsd/xsd/cxx/parser/options.cli
new file mode 100644
index 0000000..227bb51
--- /dev/null
+++ b/xsd/xsd/cxx/parser/options.cli
@@ -0,0 +1,148 @@
+// file      : xsd/cxx/parser/options.cli
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+include <cstddef>; // std::size_t
+
+include <types.hxx>; // NarrowString, NarrowStrings
+
+include <cxx/options.cli>;
+
+namespace CXX
+{
+  namespace Parser
+  {
+    class options: CXX::options
+    {
+      NarrowStrings --type-map
+      {
+        "<mapfile>",
+        "Read XML Schema to C++ type mapping information from <mapfile>.
+         Repeat this option to specify several type maps. Type maps are
+         considered in order of appearance and the first match is used. By
+         default all user-defined types are mapped to \cb{void}. See the
+         TYPE MAP section below for more information."
+      };
+
+      NarrowString --xml-parser = "xerces"
+      {
+        "<parser>",
+        "Use <parser> as the underlying XML parser. Valid values are
+         \cb{xerces} for Xerces-C++ (default) and \cb{expat} for Expat."
+      };
+
+      // Features.
+      //
+      bool --generate-validation
+      {
+        "Generate validation code. The validation code (\"perfect parser\")
+         ensures that instance documents conform to the schema. Validation
+         code is generated by default when the selected underlying XML parser
+         is non-validating (\cb{expat})."
+      };
+
+      bool --suppress-validation
+      {
+        "Suppress the generation of validation code. Validation is suppressed
+         by default when the selected underlying XML parser is validating
+         (\cb{xerces})."
+      };
+
+      bool --generate-polymorphic
+      {
+        "Generate polymorphism-aware code. Specify this option if you use
+         substitution groups or \cb{xsi:type}."
+      };
+
+      bool --generate-noop-impl
+      {
+        "Generate a sample parser implementation that does nothing (no
+         operation). The sample implementation can then be filled with
+         the application-specific code. For an input file in the form
+         \cb{name.xsd} this option triggers the generation of two
+         additional C++ files in the form: \cb{name-pimpl.hxx} (parser
+         implementation header file) and \cb{name-pimpl.cxx} (parser
+         implementation source file)."
+      };
+
+      bool --generate-print-impl
+      {
+        "Generate a sample parser implementation that prints the XML data
+         to \c{STDOUT}. For an input file in the form \cb{name.xsd} this
+         option triggers the generation of two additional C++ files in the
+         form: \cb{name-pimpl.hxx} (parser implementation header file) and
+         \cb{name-pimpl.cxx} (parser implementation source file)."
+      };
+
+      bool --generate-test-driver
+      {
+        "Generate a test driver for the sample parser implementation. For an
+         input file in the form \cb{name.xsd} this option triggers the
+         generation of an additional C++ file in the form
+         \cb{name-driver.cxx}."
+      };
+
+      bool --force-overwrite
+      {
+        "Force overwriting of the existing implementation and test driver
+         files. Use this option only if you do not mind loosing the changes
+         you have made in the sample implementation or test driver files."
+      };
+
+      // Root element.
+      //
+      bool --root-element-first
+      {
+        "Indicate that the first global element is the document root. This
+         information is used to generate the test driver for the sample
+         implementation."
+      };
+
+      bool --root-element-last
+      {
+        "Indicate that the last global element is the document root. This
+         information is used to generate the test driver for the sample
+         implementation."
+      };
+
+      NarrowString --root-element
+      {
+        "<element>",
+        "Indicate that <element> is the document root. This information is
+         used to generate the test driver for the sample implementation."
+      };
+
+      // Suffixes.
+      //
+      NarrowString --skel-type-suffix = "_pskel"
+      {
+        "<suffix>",
+        "Use the provided <suffix> instead of the default \cb{_pskel} to
+         construct the names of the generated parser skeletons."
+      };
+
+      NarrowString --skel-file-suffix = "-pskel"
+      {
+        "<suffix>",
+        "Use the provided <suffix> instead of the default \cb{-pskel} to
+         construct the names of the generated parser skeleton files."
+      };
+
+      NarrowString --impl-type-suffix = "_pimpl"
+      {
+        "<suffix>",
+        "Use the provided <suffix> instead of the default \cb{_pimpl} to
+         construct the names of the parser implementations for the built-in
+         XML Schema types as well as sample parser implementations."
+      };
+
+      NarrowString --impl-file-suffix = "-pimpl"
+      {
+        "<suffix>",
+        "Use the provided <suffix> instead of the default \cb{-pimpl} to
+         construct the names of the generated sample parser implementation
+         files."
+      };
+    };
+  }
+}
diff --git a/xsd/xsd/cxx/parser/options.cxx b/xsd/xsd/cxx/parser/options.cxx
new file mode 100644
index 0000000..6f18446
--- /dev/null
+++ b/xsd/xsd/cxx/parser/options.cxx
@@ -0,0 +1,581 @@
+// This code was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <options-parser.hxx>
+//
+// End prologue.
+
+#include <cxx/parser/options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <ostream>
+#include <sstream>
+
+namespace cli
+{
+  template <typename X>
+  struct parser
+  {
+    static void
+    parse (X& x, bool& xs, scanner& s)
+    {
+      std::string o (s.next ());
+
+      if (s.more ())
+      {
+        std::string v (s.next ());
+        std::istringstream is (v);
+        if (!(is >> x && is.eof ()))
+          throw invalid_value (o, v);
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <>
+  struct parser<bool>
+  {
+    static void
+    parse (bool& x, scanner& s)
+    {
+      s.next ();
+      x = true;
+    }
+  };
+
+  template <>
+  struct parser<std::string>
+  {
+    static void
+    parse (std::string& x, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+        x = s.next ();
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X>
+  struct parser<std::vector<X> >
+  {
+    static void
+    parse (std::vector<X>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.push_back (x);
+      xs = true;
+    }
+  };
+
+  template <typename X>
+  struct parser<std::set<X> >
+  {
+    static void
+    parse (std::set<X>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.insert (x);
+      xs = true;
+    }
+  };
+
+  template <typename K, typename V>
+  struct parser<std::map<K, V> >
+  {
+    static void
+    parse (std::map<K, V>& m, bool& xs, scanner& s)
+    {
+      std::string o (s.next ());
+
+      if (s.more ())
+      {
+        std::string ov (s.next ());
+        std::string::size_type p = ov.find ('=');
+
+        if (p == std::string::npos)
+        {
+          K k = K ();
+
+          if (!ov.empty ())
+          {
+            std::istringstream ks (ov);
+
+            if (!(ks >> k && ks.eof ()))
+              throw invalid_value (o, ov);
+          }
+
+          m[k] = V ();
+        }
+        else
+        {
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, p + 1);
+
+          if (!kstr.empty ())
+          {
+            std::istringstream ks (kstr);
+
+            if (!(ks >> k && ks.eof ()))
+              throw invalid_value (o, ov);
+          }
+
+          if (!vstr.empty ())
+          {
+            std::istringstream vs (vstr);
+
+            if (!(vs >> v && vs.eof ()))
+              throw invalid_value (o, ov);
+          }
+
+          m[k] = v;
+        }
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X, typename T, T X::*M>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, s);
+  }
+
+  template <typename X, typename T, T X::*M, bool X::*S>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, x.*S, s);
+  }
+}
+
+#include <map>
+#include <cstring>
+
+namespace CXX
+{
+  namespace Parser
+  {
+    // options
+    //
+
+    options::
+    options ()
+    : type_map_ (),
+      type_map_specified_ (false),
+      xml_parser_ ("xerces"),
+      xml_parser_specified_ (false),
+      generate_validation_ (),
+      suppress_validation_ (),
+      generate_polymorphic_ (),
+      generate_noop_impl_ (),
+      generate_print_impl_ (),
+      generate_test_driver_ (),
+      force_overwrite_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      skel_type_suffix_ ("_pskel"),
+      skel_type_suffix_specified_ (false),
+      skel_file_suffix_ ("-pskel"),
+      skel_file_suffix_specified_ (false),
+      impl_type_suffix_ ("_pimpl"),
+      impl_type_suffix_specified_ (false),
+      impl_file_suffix_ ("-pimpl"),
+      impl_file_suffix_specified_ (false)
+    {
+    }
+
+    options::
+    options (int& argc,
+             char** argv,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : type_map_ (),
+      type_map_specified_ (false),
+      xml_parser_ ("xerces"),
+      xml_parser_specified_ (false),
+      generate_validation_ (),
+      suppress_validation_ (),
+      generate_polymorphic_ (),
+      generate_noop_impl_ (),
+      generate_print_impl_ (),
+      generate_test_driver_ (),
+      force_overwrite_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      skel_type_suffix_ ("_pskel"),
+      skel_type_suffix_specified_ (false),
+      skel_file_suffix_ ("-pskel"),
+      skel_file_suffix_specified_ (false),
+      impl_type_suffix_ ("_pimpl"),
+      impl_type_suffix_specified_ (false),
+      impl_file_suffix_ ("-pimpl"),
+      impl_file_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (argc, argv, erase);
+      _parse (s, opt, arg);
+    }
+
+    options::
+    options (int start,
+             int& argc,
+             char** argv,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : type_map_ (),
+      type_map_specified_ (false),
+      xml_parser_ ("xerces"),
+      xml_parser_specified_ (false),
+      generate_validation_ (),
+      suppress_validation_ (),
+      generate_polymorphic_ (),
+      generate_noop_impl_ (),
+      generate_print_impl_ (),
+      generate_test_driver_ (),
+      force_overwrite_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      skel_type_suffix_ ("_pskel"),
+      skel_type_suffix_specified_ (false),
+      skel_file_suffix_ ("-pskel"),
+      skel_file_suffix_specified_ (false),
+      impl_type_suffix_ ("_pimpl"),
+      impl_type_suffix_specified_ (false),
+      impl_file_suffix_ ("-pimpl"),
+      impl_file_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (start, argc, argv, erase);
+      _parse (s, opt, arg);
+    }
+
+    options::
+    options (int& argc,
+             char** argv,
+             int& end,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : type_map_ (),
+      type_map_specified_ (false),
+      xml_parser_ ("xerces"),
+      xml_parser_specified_ (false),
+      generate_validation_ (),
+      suppress_validation_ (),
+      generate_polymorphic_ (),
+      generate_noop_impl_ (),
+      generate_print_impl_ (),
+      generate_test_driver_ (),
+      force_overwrite_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      skel_type_suffix_ ("_pskel"),
+      skel_type_suffix_specified_ (false),
+      skel_file_suffix_ ("-pskel"),
+      skel_file_suffix_specified_ (false),
+      impl_type_suffix_ ("_pimpl"),
+      impl_type_suffix_specified_ (false),
+      impl_file_suffix_ ("-pimpl"),
+      impl_file_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (argc, argv, erase);
+      _parse (s, opt, arg);
+      end = s.end ();
+    }
+
+    options::
+    options (int start,
+             int& argc,
+             char** argv,
+             int& end,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : type_map_ (),
+      type_map_specified_ (false),
+      xml_parser_ ("xerces"),
+      xml_parser_specified_ (false),
+      generate_validation_ (),
+      suppress_validation_ (),
+      generate_polymorphic_ (),
+      generate_noop_impl_ (),
+      generate_print_impl_ (),
+      generate_test_driver_ (),
+      force_overwrite_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      skel_type_suffix_ ("_pskel"),
+      skel_type_suffix_specified_ (false),
+      skel_file_suffix_ ("-pskel"),
+      skel_file_suffix_specified_ (false),
+      impl_type_suffix_ ("_pimpl"),
+      impl_type_suffix_specified_ (false),
+      impl_file_suffix_ ("-pimpl"),
+      impl_file_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (start, argc, argv, erase);
+      _parse (s, opt, arg);
+      end = s.end ();
+    }
+
+    options::
+    options (::cli::scanner& s,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : type_map_ (),
+      type_map_specified_ (false),
+      xml_parser_ ("xerces"),
+      xml_parser_specified_ (false),
+      generate_validation_ (),
+      suppress_validation_ (),
+      generate_polymorphic_ (),
+      generate_noop_impl_ (),
+      generate_print_impl_ (),
+      generate_test_driver_ (),
+      force_overwrite_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      skel_type_suffix_ ("_pskel"),
+      skel_type_suffix_specified_ (false),
+      skel_file_suffix_ ("-pskel"),
+      skel_file_suffix_specified_ (false),
+      impl_type_suffix_ ("_pimpl"),
+      impl_type_suffix_specified_ (false),
+      impl_file_suffix_ ("-pimpl"),
+      impl_file_suffix_specified_ (false)
+    {
+      _parse (s, opt, arg);
+    }
+
+    void options::
+    print_usage (::std::wostream& os)
+    {
+      os << "--type-map <mapfile>         Read XML Schema to C++ type mapping information" << ::std::endl
+         << "                             from <mapfile>." << ::std::endl;
+
+      os << "--xml-parser <parser>        Use <parser> as the underlying XML parser." << ::std::endl;
+
+      os << "--generate-validation        Generate validation code." << ::std::endl;
+
+      os << "--suppress-validation        Suppress the generation of validation code." << ::std::endl;
+
+      os << "--generate-polymorphic       Generate polymorphism-aware code." << ::std::endl;
+
+      os << "--generate-noop-impl         Generate a sample parser implementation that does" << ::std::endl
+         << "                             nothing (no operation)." << ::std::endl;
+
+      os << "--generate-print-impl        Generate a sample parser implementation that" << ::std::endl
+         << "                             prints the XML data to 'STDOUT'." << ::std::endl;
+
+      os << "--generate-test-driver       Generate a test driver for the sample parser" << ::std::endl
+         << "                             implementation." << ::std::endl;
+
+      os << "--force-overwrite            Force overwriting of the existing implementation" << ::std::endl
+         << "                             and test driver files." << ::std::endl;
+
+      os << "--root-element-first         Indicate that the first global element is the" << ::std::endl
+         << "                             document root." << ::std::endl;
+
+      os << "--root-element-last          Indicate that the last global element is the" << ::std::endl
+         << "                             document root." << ::std::endl;
+
+      os << "--root-element <element>     Indicate that <element> is the document root." << ::std::endl;
+
+      os << "--skel-type-suffix <suffix>  Use the provided <suffix> instead of the default" << ::std::endl
+         << "                             '_pskel' to construct the names of the generated" << ::std::endl
+         << "                             parser skeletons." << ::std::endl;
+
+      os << "--skel-file-suffix <suffix>  Use the provided <suffix> instead of the default" << ::std::endl
+         << "                             '-pskel' to construct the names of the generated" << ::std::endl
+         << "                             parser skeleton files." << ::std::endl;
+
+      os << "--impl-type-suffix <suffix>  Use the provided <suffix> instead of the default" << ::std::endl
+         << "                             '_pimpl' to construct the names of the parser" << ::std::endl
+         << "                             implementations for the built-in XML Schema types" << ::std::endl
+         << "                             as well as sample parser implementations." << ::std::endl;
+
+      os << "--impl-file-suffix <suffix>  Use the provided <suffix> instead of the default" << ::std::endl
+         << "                             '-pimpl' to construct the names of the generated" << ::std::endl
+         << "                             sample parser implementation files." << ::std::endl;
+    }
+
+    typedef
+    std::map<std::string, void (*) (options&, ::cli::scanner&)>
+    _cli_options_map;
+
+    static _cli_options_map _cli_options_map_;
+
+    struct _cli_options_map_init
+    {
+      _cli_options_map_init ()
+      {
+        _cli_options_map_["--type-map"] = 
+        &::cli::thunk< options, NarrowStrings, &options::type_map_,
+          &options::type_map_specified_ >;
+        _cli_options_map_["--xml-parser"] = 
+        &::cli::thunk< options, NarrowString, &options::xml_parser_,
+          &options::xml_parser_specified_ >;
+        _cli_options_map_["--generate-validation"] = 
+        &::cli::thunk< options, bool, &options::generate_validation_ >;
+        _cli_options_map_["--suppress-validation"] = 
+        &::cli::thunk< options, bool, &options::suppress_validation_ >;
+        _cli_options_map_["--generate-polymorphic"] = 
+        &::cli::thunk< options, bool, &options::generate_polymorphic_ >;
+        _cli_options_map_["--generate-noop-impl"] = 
+        &::cli::thunk< options, bool, &options::generate_noop_impl_ >;
+        _cli_options_map_["--generate-print-impl"] = 
+        &::cli::thunk< options, bool, &options::generate_print_impl_ >;
+        _cli_options_map_["--generate-test-driver"] = 
+        &::cli::thunk< options, bool, &options::generate_test_driver_ >;
+        _cli_options_map_["--force-overwrite"] = 
+        &::cli::thunk< options, bool, &options::force_overwrite_ >;
+        _cli_options_map_["--root-element-first"] = 
+        &::cli::thunk< options, bool, &options::root_element_first_ >;
+        _cli_options_map_["--root-element-last"] = 
+        &::cli::thunk< options, bool, &options::root_element_last_ >;
+        _cli_options_map_["--root-element"] = 
+        &::cli::thunk< options, NarrowString, &options::root_element_,
+          &options::root_element_specified_ >;
+        _cli_options_map_["--skel-type-suffix"] = 
+        &::cli::thunk< options, NarrowString, &options::skel_type_suffix_,
+          &options::skel_type_suffix_specified_ >;
+        _cli_options_map_["--skel-file-suffix"] = 
+        &::cli::thunk< options, NarrowString, &options::skel_file_suffix_,
+          &options::skel_file_suffix_specified_ >;
+        _cli_options_map_["--impl-type-suffix"] = 
+        &::cli::thunk< options, NarrowString, &options::impl_type_suffix_,
+          &options::impl_type_suffix_specified_ >;
+        _cli_options_map_["--impl-file-suffix"] = 
+        &::cli::thunk< options, NarrowString, &options::impl_file_suffix_,
+          &options::impl_file_suffix_specified_ >;
+      }
+    };
+
+    static _cli_options_map_init _cli_options_map_init_;
+
+    bool options::
+    _parse (const char* o, ::cli::scanner& s)
+    {
+      _cli_options_map::const_iterator i (_cli_options_map_.find (o));
+
+      if (i != _cli_options_map_.end ())
+      {
+        (*(i->second)) (*this, s);
+        return true;
+      }
+
+      // options base
+      //
+      if (::CXX::options::_parse (o, s))
+        return true;
+
+      return false;
+    }
+
+    void options::
+    _parse (::cli::scanner& s,
+            ::cli::unknown_mode opt_mode,
+            ::cli::unknown_mode arg_mode)
+    {
+      bool opt = true;
+
+      while (s.more ())
+      {
+        const char* o = s.peek ();
+
+        if (std::strcmp (o, "--") == 0)
+        {
+          s.skip ();
+          opt = false;
+          continue;
+        }
+
+        if (opt && _parse (o, s));
+        else if (opt && std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          switch (opt_mode)
+          {
+            case ::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              continue;
+            }
+            case ::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::cli::unknown_mode::fail:
+            {
+              throw ::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+        else
+        {
+          switch (arg_mode)
+          {
+            case ::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              continue;
+            }
+            case ::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::cli::unknown_mode::fail:
+            {
+              throw ::cli::unknown_argument (o);
+            }
+          }
+
+          break;
+        }
+      }
+    }
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/xsd/xsd/cxx/parser/options.hxx b/xsd/xsd/cxx/parser/options.hxx
new file mode 100644
index 0000000..976f93b
--- /dev/null
+++ b/xsd/xsd/cxx/parser/options.hxx
@@ -0,0 +1,183 @@
+// This code was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef CXX_PARSER_OPTIONS_HXX
+#define CXX_PARSER_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <cstddef>
+
+#include <types.hxx>
+
+#include <cxx/options.hxx>
+
+namespace CXX
+{
+  namespace Parser
+  {
+    class options: public ::CXX::options
+    {
+      public:
+      options (int& argc,
+               char** argv,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (int start,
+               int& argc,
+               char** argv,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (int& argc,
+               char** argv,
+               int& end,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (int start,
+               int& argc,
+               char** argv,
+               int& end,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (::cli::scanner&,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options ();
+
+      // Option accessors.
+      //
+      const NarrowStrings&
+      type_map () const;
+
+      bool
+      type_map_specified () const;
+
+      const NarrowString&
+      xml_parser () const;
+
+      bool
+      xml_parser_specified () const;
+
+      const bool&
+      generate_validation () const;
+
+      const bool&
+      suppress_validation () const;
+
+      const bool&
+      generate_polymorphic () const;
+
+      const bool&
+      generate_noop_impl () const;
+
+      const bool&
+      generate_print_impl () const;
+
+      const bool&
+      generate_test_driver () const;
+
+      const bool&
+      force_overwrite () const;
+
+      const bool&
+      root_element_first () const;
+
+      const bool&
+      root_element_last () const;
+
+      const NarrowString&
+      root_element () const;
+
+      bool
+      root_element_specified () const;
+
+      const NarrowString&
+      skel_type_suffix () const;
+
+      bool
+      skel_type_suffix_specified () const;
+
+      const NarrowString&
+      skel_file_suffix () const;
+
+      bool
+      skel_file_suffix_specified () const;
+
+      const NarrowString&
+      impl_type_suffix () const;
+
+      bool
+      impl_type_suffix_specified () const;
+
+      const NarrowString&
+      impl_file_suffix () const;
+
+      bool
+      impl_file_suffix_specified () const;
+
+      // Print usage information.
+      //
+      static void
+      print_usage (::std::wostream&);
+
+      // Implementation details.
+      //
+      protected:
+      bool
+      _parse (const char*, ::cli::scanner&);
+
+      private:
+      void
+      _parse (::cli::scanner&,
+              ::cli::unknown_mode option,
+              ::cli::unknown_mode argument);
+
+      public:
+      NarrowStrings type_map_;
+      bool type_map_specified_;
+      NarrowString xml_parser_;
+      bool xml_parser_specified_;
+      bool generate_validation_;
+      bool suppress_validation_;
+      bool generate_polymorphic_;
+      bool generate_noop_impl_;
+      bool generate_print_impl_;
+      bool generate_test_driver_;
+      bool force_overwrite_;
+      bool root_element_first_;
+      bool root_element_last_;
+      NarrowString root_element_;
+      bool root_element_specified_;
+      NarrowString skel_type_suffix_;
+      bool skel_type_suffix_specified_;
+      NarrowString skel_file_suffix_;
+      bool skel_file_suffix_specified_;
+      NarrowString impl_type_suffix_;
+      bool impl_type_suffix_specified_;
+      NarrowString impl_file_suffix_;
+      bool impl_file_suffix_specified_;
+    };
+  }
+}
+
+#include <cxx/parser/options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // CXX_PARSER_OPTIONS_HXX
diff --git a/xsd/xsd/cxx/parser/options.ixx b/xsd/xsd/cxx/parser/options.ixx
new file mode 100644
index 0000000..22ab11d
--- /dev/null
+++ b/xsd/xsd/cxx/parser/options.ixx
@@ -0,0 +1,160 @@
+// This code was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace CXX
+{
+  namespace Parser
+  {
+    // options
+    //
+
+    inline const NarrowStrings& options::
+    type_map () const
+    {
+      return this->type_map_;
+    }
+
+    inline bool options::
+    type_map_specified () const
+    {
+      return this->type_map_specified_;
+    }
+
+    inline const NarrowString& options::
+    xml_parser () const
+    {
+      return this->xml_parser_;
+    }
+
+    inline bool options::
+    xml_parser_specified () const
+    {
+      return this->xml_parser_specified_;
+    }
+
+    inline const bool& options::
+    generate_validation () const
+    {
+      return this->generate_validation_;
+    }
+
+    inline const bool& options::
+    suppress_validation () const
+    {
+      return this->suppress_validation_;
+    }
+
+    inline const bool& options::
+    generate_polymorphic () const
+    {
+      return this->generate_polymorphic_;
+    }
+
+    inline const bool& options::
+    generate_noop_impl () const
+    {
+      return this->generate_noop_impl_;
+    }
+
+    inline const bool& options::
+    generate_print_impl () const
+    {
+      return this->generate_print_impl_;
+    }
+
+    inline const bool& options::
+    generate_test_driver () const
+    {
+      return this->generate_test_driver_;
+    }
+
+    inline const bool& options::
+    force_overwrite () const
+    {
+      return this->force_overwrite_;
+    }
+
+    inline const bool& options::
+    root_element_first () const
+    {
+      return this->root_element_first_;
+    }
+
+    inline const bool& options::
+    root_element_last () const
+    {
+      return this->root_element_last_;
+    }
+
+    inline const NarrowString& options::
+    root_element () const
+    {
+      return this->root_element_;
+    }
+
+    inline bool options::
+    root_element_specified () const
+    {
+      return this->root_element_specified_;
+    }
+
+    inline const NarrowString& options::
+    skel_type_suffix () const
+    {
+      return this->skel_type_suffix_;
+    }
+
+    inline bool options::
+    skel_type_suffix_specified () const
+    {
+      return this->skel_type_suffix_specified_;
+    }
+
+    inline const NarrowString& options::
+    skel_file_suffix () const
+    {
+      return this->skel_file_suffix_;
+    }
+
+    inline bool options::
+    skel_file_suffix_specified () const
+    {
+      return this->skel_file_suffix_specified_;
+    }
+
+    inline const NarrowString& options::
+    impl_type_suffix () const
+    {
+      return this->impl_type_suffix_;
+    }
+
+    inline bool options::
+    impl_type_suffix_specified () const
+    {
+      return this->impl_type_suffix_specified_;
+    }
+
+    inline const NarrowString& options::
+    impl_file_suffix () const
+    {
+      return this->impl_file_suffix_;
+    }
+
+    inline bool options::
+    impl_file_suffix_specified () const
+    {
+      return this->impl_file_suffix_specified_;
+    }
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/xsd/xsd/cxx/parser/parser-forward.cxx b/xsd/xsd/cxx/parser/parser-forward.cxx
index a4e8ae7..faf427a 100644
--- a/xsd/xsd/cxx/parser/parser-forward.cxx
+++ b/xsd/xsd/cxx/parser/parser-forward.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/parser-forward.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/parser/parser-forward.hxx>
@@ -21,7 +20,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           os << "class " << ename (e) << ";";
@@ -37,7 +36,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           os << "class " << ename (l) << ";";
@@ -53,7 +52,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           os << "class " << ename (u) << ";";
@@ -69,7 +68,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           os << "class " << ename (c) << ";";
@@ -77,7 +76,7 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_parser_forward (Context& ctx)
     {
       ctx.os << "// Forward declarations" << endl
@@ -85,7 +84,7 @@ namespace CXX
 
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names schema_names;
 
       Namespace ns (ctx);
diff --git a/xsd/xsd/cxx/parser/parser-forward.hxx b/xsd/xsd/cxx/parser/parser-forward.hxx
index a8a17f1..53c7049 100644
--- a/xsd/xsd/cxx/parser/parser-forward.hxx
+++ b/xsd/xsd/cxx/parser/parser-forward.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/parser-forward.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_PARSER_FORWARD_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Parser
   {
-    Void
+    void
     generate_parser_forward (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/parser/parser-header.cxx b/xsd/xsd/cxx/parser/parser-header.cxx
index aade743..800a4b9 100644
--- a/xsd/xsd/cxx/parser/parser-header.cxx
+++ b/xsd/xsd/cxx/parser/parser-header.cxx
@@ -1,13 +1,16 @@
 // file      : xsd/cxx/parser/parser-header.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
+#include <set>
+
 #include <cxx/parser/parser-header.hxx>
 
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
 
+using namespace std;
+
 namespace CXX
 {
   namespace Parser
@@ -21,7 +24,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String const& name (ename (e));
@@ -41,7 +44,7 @@ namespace CXX
 
           String const& ret (ret_type (e));
 
-          Boolean same (ret == ret_type (base));
+          bool same (ret == ret_type (base));
 
           os << "virtual " << ret << endl
              << post_name (e) << " ()" <<
@@ -71,7 +74,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String const& name (ename (l));
@@ -173,7 +176,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String const& name (ename (u));
@@ -222,7 +225,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
 	  if (skip (m)) return;
@@ -251,7 +254,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
 	  if (skip (m))
@@ -281,7 +284,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
 	  if (skip (m))
@@ -295,8 +298,7 @@ namespace CXX
               m.is_a<SemanticGraph::Element> () &&
               !anonymous (m.type ()))
           {
-            os << type << "* " << emember_cache (m) << ";"
-               << "const " << parser_map << "* " << emember_map (m) << ";"
+            os << "const " << parser_map << "* " << emember_map (m) << ";"
                << endl;
           }
         }
@@ -316,14 +318,13 @@ namespace CXX
         }
 
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::All& a)
         {
           if (!a.context().count ("comp-number"))
             return;
 
-          UnsignedLong state_count (
-            a.context().get<UnsignedLong> ("state-count"));
+          size_t state_count (a.context().get<size_t> ("state-count"));
 
           os << "void" << endl
              << "all_0 (unsigned long& state," << endl
@@ -338,13 +339,13 @@ namespace CXX
              << endl;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Choice& c)
         {
           if (!c.context().count ("comp-number"))
             return;
 
-          UnsignedLong n (c.context ().get<UnsignedLong> ("comp-number"));
+          size_t n (c.context ().get<size_t> ("comp-number"));
 
           os << "void" << endl
              << "choice_" << n << " (unsigned long& state," << endl
@@ -358,13 +359,13 @@ namespace CXX
           Traversal::Choice::traverse (c);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Sequence& s)
         {
           if (!s.context().count ("comp-number"))
             return;
 
-          UnsignedLong n (s.context ().get<UnsignedLong> ("comp-number"));
+          size_t n (s.context ().get<size_t> ("comp-number"));
 
           os << "void" << endl
              << "sequence_" << n << " (unsigned long& state," << endl
@@ -392,7 +393,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           if (!a.optional_p ())
@@ -419,7 +420,7 @@ namespace CXX
           names_attribute_validation_state_ >> attribute_validation_state_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           String const& name (ename (c));
@@ -428,15 +429,15 @@ namespace CXX
           // generate parser callbacks, etc. since they are the same as in
           // the base. We only need the parsing/validation code.
           //
-          Boolean restriction (restriction_p (c));
+          bool restriction (restriction_p (c));
 
-          Boolean he (has<Traversal::Element> (c));
-          Boolean ha (has<Traversal::Attribute> (c));
+          bool he (has<Traversal::Element> (c));
+          bool ha (has<Traversal::Attribute> (c));
 
-          Boolean hae (has_particle<Traversal::Any> (c));
-          Boolean haa (has<Traversal::AnyAttribute> (c));
+          bool hae (has_particle<Traversal::Any> (c));
+          bool haa (has<Traversal::AnyAttribute> (c));
 
-          Boolean hra (false); // Has required attribute.
+          bool hra (false); // Has required attribute.
           if (ha)
           {
             RequiredAttributeTest test (hra);
@@ -472,7 +473,7 @@ namespace CXX
 
           String const& ret (ret_type (c));
 
-          Boolean same (c.inherits_p () &&
+          bool same (c.inherits_p () &&
                         ret == ret_type (c.inherits ().base ()));
 
           os << "virtual " << ret << endl
@@ -606,7 +607,7 @@ namespace CXX
 
           if (validation && (he || hae))
           {
-            UnsignedLong depth (c.context ().get<UnsignedLong> ("depth"));
+            size_t depth (c.context ().get<size_t> ("depth"));
 
             os << "protected:" << endl;
 
@@ -770,13 +771,13 @@ namespace CXX
 
         // anyType & anySimpleType.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyType& t)
         {
           gen_typedef (t, "void", "any_type_pskel", "any_type_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnySimpleType& t)
         {
           gen_typedef (t, "void",
@@ -785,7 +786,7 @@ namespace CXX
 
         // Boolean.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Boolean& t)
         {
           gen_typedef (t, "bool", "boolean_pskel", "boolean_pimpl");
@@ -793,72 +794,72 @@ namespace CXX
 
         // Integral types.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Byte& t)
         {
           gen_typedef (t, "signed char", "byte_pskel", "byte_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedByte& t)
         {
           gen_typedef (t, "unsigned char",
                        "unsigned_byte_pskel", "unsigned_byte_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Short& t)
         {
           gen_typedef (t, "short", "short_pskel", "short_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedShort& t)
         {
           gen_typedef (t, "unsigned short",
                        "unsigned_short_pskel", "unsigned_short_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Int& t)
         {
           gen_typedef (t, "int", "int_pskel", "int_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedInt& t)
         {
           gen_typedef (t, "unsigned int",
                        "unsigned_int_pskel", "unsigned_int_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Long& t)
         {
           gen_typedef (t, "long long", "long_pskel", "long_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedLong& t)
         {
           gen_typedef (t, "unsigned long long",
                        "unsigned_long_pskel", "unsigned_long_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Integer& t)
         {
           gen_typedef (t, "long long", "integer_pskel", "integer_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NegativeInteger& t)
         {
           gen_typedef (t, "long long",
                        "negative_integer_pskel", "negative_integer_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NonPositiveInteger& t)
         {
           gen_typedef (t, "long long",
@@ -866,14 +867,14 @@ namespace CXX
                        "non_positive_integer_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::PositiveInteger& t)
         {
           gen_typedef (t, "unsigned long long",
                        "positive_integer_pskel", "positive_integer_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NonNegativeInteger& t)
         {
           gen_typedef (t, "unsigned long long",
@@ -883,19 +884,19 @@ namespace CXX
 
         // Floats.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Float& t)
         {
           gen_typedef (t, "float", "float_pskel", "float_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Double& t)
         {
           gen_typedef (t, "double", "double_pskel", "double_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Decimal& t)
         {
           gen_typedef (t, "double", "decimal_pskel", "decimal_pimpl");
@@ -903,33 +904,33 @@ namespace CXX
 
         // Strings.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::String& t)
         {
           gen_typedef (t, string_type_, "string_pskel", "string_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NormalizedString& t)
         {
           gen_typedef (t, string_type_,
                        "normalized_string_pskel", "normalized_string_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Token& t)
         {
           gen_typedef (t, string_type_, "token_pskel", "token_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NameToken& t)
         {
           nmtoken_ = gen_typedef (t, string_type_,
                                   "nmtoken_pskel", "nmtoken_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NameTokens& t)
         {
           // NMTOKENS uses NMTOKEN implementation to parse individual items.
@@ -941,19 +942,19 @@ namespace CXX
                          "nmtokens_pskel", "nmtokens_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Name& t)
         {
           gen_typedef (t, string_type_, "name_pskel", "name_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NCName& t)
         {
           gen_typedef (t, string_type_, "ncname_pskel", "ncname_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Language& t)
         {
           gen_typedef (t, string_type_, "language_pskel", "language_pimpl");
@@ -961,7 +962,7 @@ namespace CXX
 
         // Qualified name.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::QName& t)
         {
           gen_typedef (t, xs_ns_ + L"::qname", "qname_pskel", "qname_pimpl");
@@ -969,19 +970,19 @@ namespace CXX
 
         // ID/IDREF.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Id& t)
         {
           gen_typedef (t, string_type_, "id_pskel", "id_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::IdRef& t)
         {
           idref_ = gen_typedef (t, string_type_, "idref_pskel", "idref_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::IdRefs& t)
         {
           // IDREFS uses IDREF implementation to parse individual items.
@@ -995,7 +996,7 @@ namespace CXX
 
         // URI.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::AnyURI& t)
         {
           gen_typedef (t, string_type_, "uri_pskel", "uri_pimpl");
@@ -1003,78 +1004,78 @@ namespace CXX
 
         // Binary.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Base64Binary& t)
         {
-          String buffer (L"::std::auto_ptr< " + xs_ns_ + L"::buffer >");
+          String buffer (auto_ptr + L"< " + xs_ns_ + L"::buffer >");
           gen_typedef (t, buffer,
                        "base64_binary_pskel", "base64_binary_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::HexBinary& t)
         {
-          String buffer (L"::std::auto_ptr< " + xs_ns_ + L"::buffer >");
+          String buffer (auto_ptr + L"< " + xs_ns_ + L"::buffer >");
           gen_typedef (t, buffer, "hex_binary_pskel", "hex_binary_pimpl");
         }
 
 
         // Date/time.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Date& t)
         {
           gen_typedef (t, xs_ns_ + L"::date", "date_pskel", "date_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::DateTime& t)
         {
           gen_typedef (t, xs_ns_ + L"::date_time",
                        "date_time_pskel", "date_time_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Duration& t)
         {
           gen_typedef (t, xs_ns_ + L"::duration",
                        "duration_pskel", "duration_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Day& t)
         {
           gen_typedef (t, xs_ns_ + L"::gday", "gday_pskel", "gday_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Month& t)
         {
           gen_typedef (t, xs_ns_ + L"::gmonth",
                        "gmonth_pskel", "gmonth_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::MonthDay& t)
         {
           gen_typedef (t, xs_ns_ + L"::gmonth_day",
                        "gmonth_day_pskel", "gmonth_day_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Year& t)
         {
           gen_typedef (t, xs_ns_ + L"::gyear", "gyear_pskel", "gyear_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::YearMonth& t)
         {
           gen_typedef (t, xs_ns_ + L"::gyear_month",
                        "gyear_month_pskel", "gyear_month_pimpl");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Time& t)
         {
           gen_typedef (t, xs_ns_ + L"::time", "time_pskel", "time_pimpl");
@@ -1082,18 +1083,18 @@ namespace CXX
 
         // Entity.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Entity&)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Entities&)
         {
         }
 
       private:
-        Boolean
+        bool
         gen_typedef (SemanticGraph::Type& t,
                      String const& type,
                      String const& pskel,
@@ -1120,8 +1121,8 @@ namespace CXX
         String impl_ns_;
         String string_type_;
 
-        Boolean idref_;
-        Boolean nmtoken_;
+        bool idref_;
+        bool nmtoken_;
       };
 
       struct FundNamespace: Namespace, Context
@@ -1258,8 +1259,8 @@ namespace CXX
       };
     }
 
-    Void
-    generate_parser_header (Context& ctx, Boolean generate_xml_schema)
+    void
+    generate_parser_header (Context& ctx, bool generate_xml_schema)
     {
       String c (ctx.char_type);
 
@@ -1295,11 +1296,11 @@ namespace CXX
       NarrowString extern_xml_schema;
 
       if (!generate_xml_schema)
-        extern_xml_schema = ctx.options.value<CLI::extern_xml_schema> ();
+        extern_xml_schema = ctx.options.extern_xml_schema ();
 
       if (extern_xml_schema)
       {
-        String name (ctx.hxx_expr->merge (extern_xml_schema));
+        String name (ctx.hxx_expr->replace (extern_xml_schema));
 
         ctx.os << "#include " << ctx.process_include_path (name) << endl
                << endl;
@@ -1308,12 +1309,12 @@ namespace CXX
         //
         if (ctx.schema_root.context ().count ("includes"))
         {
-          typedef Cult::Containers::Set<String> Includes;
+          typedef set<String> Includes;
 
           Includes const& is (
             ctx.schema_root.context ().get<Includes> ("includes"));
 
-          for (Includes::ConstReverseIterator i (is.rbegin ());
+          for (Includes::const_reverse_iterator i (is.rbegin ());
                i != is.rend (); ++i)
           {
             ctx.os << "#include " << *i << endl;
@@ -1357,12 +1358,12 @@ namespace CXX
         //
         if (ctx.schema_root.context ().count ("includes"))
         {
-          typedef Cult::Containers::Set<String> Includes;
+          typedef set<String> Includes;
 
           Includes const& is (
             ctx.schema_root.context ().get<Includes> ("includes"));
 
-          for (Includes::ConstReverseIterator i (is.rbegin ());
+          for (Includes::const_reverse_iterator i (is.rbegin ());
                i != is.rend (); ++i)
           {
             ctx.os << "#include " << *i << endl;
@@ -1412,7 +1413,7 @@ namespace CXX
       {
         Traversal::Schema schema;
 
-        Traversal::Sources sources;
+        Sources sources;
         Includes includes (ctx, Includes::header);
         Traversal::Names schema_names;
 
diff --git a/xsd/xsd/cxx/parser/parser-header.hxx b/xsd/xsd/cxx/parser/parser-header.hxx
index c4e114d..467dcb5 100644
--- a/xsd/xsd/cxx/parser/parser-header.hxx
+++ b/xsd/xsd/cxx/parser/parser-header.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/parser-header.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_PARSER_HEADER_HXX
@@ -12,8 +11,8 @@ namespace CXX
 {
   namespace Parser
   {
-    Void
-    generate_parser_header (Context&, Boolean generate_xml_schema);
+    void
+    generate_parser_header (Context&, bool generate_xml_schema);
   }
 }
 
diff --git a/xsd/xsd/cxx/parser/parser-inline.cxx b/xsd/xsd/cxx/parser/parser-inline.cxx
index b491b72..87ba92c 100644
--- a/xsd/xsd/cxx/parser/parser-inline.cxx
+++ b/xsd/xsd/cxx/parser/parser-inline.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/parser-inline.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/parser/parser-inline.hxx>
@@ -23,7 +22,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String const& name (ename (l));
@@ -75,7 +74,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
 	  if (skip (m))
@@ -84,7 +83,7 @@ namespace CXX
           String const& scope (ename (m.scope ()));
           String const& parser (eparser (m));
 
-          Boolean poly (polymorphic &&
+          bool poly (polymorphic &&
                         m.is_a<SemanticGraph::Element> () &&
                         !anonymous (m.type ()));
 
@@ -117,7 +116,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
 	  if (skip (m)) return;
@@ -138,7 +137,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
 	  if (skip (m)) return;
@@ -159,14 +158,14 @@ namespace CXX
           }
         }
 
-        Boolean
+        bool
         comma () const
         {
           return !first_;
         }
 
       private:
-        Boolean first_;
+        bool first_;
       };
 
       struct ParserBaseSet: Traversal::Complex,
@@ -180,7 +179,7 @@ namespace CXX
           names_ >> member_;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           inherits (c, inherits_);
@@ -189,7 +188,7 @@ namespace CXX
             names (c, names_);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::List& l)
         {
           String const& name (ename (l));
@@ -212,14 +211,13 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::All& a)
         {
           if (!a.context().count ("comp-number"))
             return;
 
-          UnsignedLong state_count (
-            a.context().get<UnsignedLong> ("state-count"));
+          size_t state_count (a.context().get<size_t> ("state-count"));
 
           os << "," << endl
              << "  v_all_count_ (" << state_count << "UL, v_all_first_)";
@@ -242,15 +240,15 @@ namespace CXX
           names_parser_member_set_ >> parser_member_set_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
-          Boolean he (has<Traversal::Element> (c));
-          Boolean ha (has<Traversal::Attribute> (c));
+          bool he (has<Traversal::Element> (c));
+          bool ha (has<Traversal::Attribute> (c));
 
-          Boolean hae (has_particle<Traversal::Any> (c));
+          bool hae (has_particle<Traversal::Any> (c));
 
-          Boolean hra (false); // Has required attribute.
+          bool hra (false); // Has required attribute.
           if (ha)
           {
             RequiredAttributeTest test (hra);
@@ -258,7 +256,7 @@ namespace CXX
             names (c, names_test);
           }
 
-          Boolean restriction (restriction_p (c));
+          bool restriction (restriction_p (c));
 
           if (!((!restriction && (he || ha)) ||
                 (validation && (he || hae || hra))))
@@ -305,7 +303,7 @@ namespace CXX
              << name << " ()" << endl
              << ": ";
 
-          Boolean comma (false);
+          bool comma (false);
 
           if (!restriction && (he || ha))
           {
@@ -364,13 +362,13 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_parser_inline (Context& ctx)
     {
       // Emit "weak" header includes that are used in the file-per-type
       // compilation model.
       //
-      if (!ctx.options.value<CLI::generate_inline> ())
+      if (!ctx.options.generate_inline ())
       {
         Traversal::Schema schema;
         Includes includes (ctx, Includes::source);
@@ -381,7 +379,7 @@ namespace CXX
 
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names schema_names;
 
       Namespace ns (ctx);
diff --git a/xsd/xsd/cxx/parser/parser-inline.hxx b/xsd/xsd/cxx/parser/parser-inline.hxx
index 51f5b93..aff2ad2 100644
--- a/xsd/xsd/cxx/parser/parser-inline.hxx
+++ b/xsd/xsd/cxx/parser/parser-inline.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/parser-inline.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_PARSER_INLINE_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Parser
   {
-    Void
+    void
     generate_parser_inline (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/parser/parser-source.cxx b/xsd/xsd/cxx/parser/parser-source.cxx
index 99bc566..2ee5273 100644
--- a/xsd/xsd/cxx/parser/parser-source.cxx
+++ b/xsd/xsd/cxx/parser/parser-source.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/parser-source.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/parser/parser-source.hxx>
@@ -21,7 +20,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String const& name (ename (e));
@@ -29,7 +28,7 @@ namespace CXX
 
           SemanticGraph::Type& base (e.inherits ().base ());
 
-          Boolean same (ret == ret_type (base));
+          bool same (ret == ret_type (base));
 
           if (same || ret == L"void" || polymorphic)
           {
@@ -79,7 +78,7 @@ namespace CXX
 
             if (validation)
             {
-              Boolean gen (!anonymous (e));
+              bool gen (!anonymous (e));
 
               // We normally don't need to enter anonymous types into
               // the inheritance map. The only exception is when an
@@ -89,16 +88,21 @@ namespace CXX
               if (!gen)
               {
                 // The first instance that this anonymous type classifies
-                // is the prototype for others if any.
+                // is the prototype for others if any. If this type does
+                // not classify anything (e.g., it is a base), then we
+                // don't need to do anything.
                 //
-                SemanticGraph::Instance& i (
-                  e.classifies_begin ()->instance ());
-
-                if (SemanticGraph::Element* e =
-                    dynamic_cast<SemanticGraph::Element*> (&i))
+                if (e.classifies_begin () != e.classifies_end ())
                 {
-                  if (e->substitutes_p ())
-                    gen = true;
+                  SemanticGraph::Instance& i (
+                    e.classifies_begin ()->instance ());
+
+                  if (SemanticGraph::Element* e =
+                      dynamic_cast<SemanticGraph::Element*> (&i))
+                  {
+                    if (e->substitutes_p ())
+                      gen = true;
+                  }
                 }
               }
 
@@ -126,7 +130,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String const& name (ename (l));
@@ -222,7 +226,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String const& name (ename (u));
@@ -277,15 +281,13 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
 	  if (skip (e))
             return;
 
-          Boolean poly (polymorphic && !anonymous (e.type ()));
-
-          String const& inst (poly ? emember_cache (e) : emember (e));
+          bool poly (polymorphic && !anonymous (e.type ()));
 
           os << "if (";
 
@@ -316,9 +318,12 @@ namespace CXX
           os << ")"
              << "{";
 
+          String inst;
+
           if (poly)
           {
             SemanticGraph::Type& t (e.type ());
+            inst = "p";
 
             // For pre-computing length.
             //
@@ -334,8 +339,10 @@ namespace CXX
             String const& member (emember (e));
             String const& member_map (emember_map (e));
 
-            os << "if (t == 0 && this->" << member << " != 0)" << endl
-               << "this->" << inst << " = this->" << member << ";"
+            os << fq_type << "* p = 0;"
+               << endl
+               << "if (t == 0 && this->" << member << " != 0)" << endl
+               << inst << " = this->" << member << ";"
                << "else"
                << "{"
                << string_type << " ts (" << fq_type <<
@@ -345,21 +352,21 @@ namespace CXX
                << "t = &ts;"
                << endl
                << "if (this->" << member << " != 0 && *t == ts)" << endl
-               << "this->" << inst << " = this->" << member << ";"
+               << inst << " = this->" << member << ";"
                << "else if (this->" << member_map << " != 0)" << endl
-               << "this->" << inst << " = dynamic_cast< " << fq_type <<
+               << inst << " = dynamic_cast< " << fq_type <<
               "* > (" << endl
                << "this->" << member_map << "->find (*t));"
-               << "else" << endl
-               << "this->" << inst << " = 0;"
                << "}";
           }
+          else
+            inst = L"this->" + emember (e);
 
           os << "this->" << complex_base << "::context_.top ().parser_ = " <<
-            "this->" << inst << ";"
+            inst << ";"
              << endl
-             << "if (this->" << inst << ")" << endl
-             << "this->" << inst << "->pre ();" // _start_element calls _pre
+             << "if (" << inst << ")" << endl
+             << inst << "->pre ();" // _start_element calls _pre
              << endl
              << "return true;"
              << "}";
@@ -376,16 +383,14 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
 	  if (skip (e))
             return;
 
-          Boolean poly (polymorphic && !anonymous (e.type ()));
-
+          bool poly (polymorphic && !anonymous (e.type ()));
           String const& name (ename (e));
-          String const& inst (poly ? emember_cache (e) : emember (e));
 
           os << "if (";
 
@@ -421,18 +426,31 @@ namespace CXX
 
           SemanticGraph::Type& type (e.type ());
           String const& post (post_name (type));
+          String inst;
+
+          if (poly)
+          {
+            String const& fq_type (fq_name (type));
+            inst = "p";
 
-          os << "if (this->" << inst << ")";
+            os << fq_type << "* p =" << endl
+               << "dynamic_cast< " << fq_type << "* > (" << endl
+               << "this->" << complex_base << "::context_.top ().parser_);"
+               << endl;
+          }
+          else
+            inst = L"this->" + emember (e);
+
+          os << "if (" << inst << ")";
 
           if (ret_type (type) == L"void")
             os << "{"
-               << "this->" << inst << "->" << post << " ();"
+               << inst << "->" << post << " ();"
                << "this->" << name << " ();"
                << "}";
           else
             os << endl
-               << "this->" << name << " (this->" << inst << "->" <<
-              post << " ());"
+               << "this->" << name << " (" << inst << "->" << post << " ());"
                << endl;
 
           os << "return true;"
@@ -449,7 +467,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           String const& name (ename (a));
@@ -500,7 +518,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
 	  if (skip (m))
@@ -538,14 +556,14 @@ namespace CXX
           names_attribute_ >> attribute_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
-          Boolean he (has<Traversal::Element> (c));
-          Boolean ha (has<Traversal::Attribute> (c));
+          bool he (has<Traversal::Element> (c));
+          bool ha (has<Traversal::Attribute> (c));
 
           String const& ret (ret_type (c));
-          Boolean same (c.inherits_p () &&
+          bool same (c.inherits_p () &&
                         ret == ret_type (c.inherits ().base ()));
 
           String const& name (ename (c));
@@ -581,7 +599,7 @@ namespace CXX
 
             if (c.inherits_p () && validation)
             {
-              Boolean gen (!anonymous (c));
+              bool gen (!anonymous (c));
 
               // We normally don't need to enter anonymous types into
               // the inheritance map. The only exception is when an
@@ -591,16 +609,21 @@ namespace CXX
               if (!gen)
               {
                 // The first instance that this anonymous type classifies
-                // is the prototype for others if any.
+                // is the prototype for others if any. If this type does
+                // not classify anything (e.g., it is a base), then we
+                // don't need to do anything.
                 //
-                SemanticGraph::Instance& i (
-                  c.classifies_begin ()->instance ());
-
-                if (SemanticGraph::Element* e =
-                    dynamic_cast<SemanticGraph::Element*> (&i))
+                if (c.classifies_begin () != c.classifies_end ())
                 {
-                  if (e->substitutes_p ())
-                    gen = true;
+                  SemanticGraph::Instance& i (
+                    c.classifies_begin ()->instance ());
+
+                  if (SemanticGraph::Element* e =
+                      dynamic_cast<SemanticGraph::Element*> (&i))
+                  {
+                    if (e->substitutes_p ())
+                      gen = true;
+                  }
                 }
               }
 
@@ -655,7 +678,7 @@ namespace CXX
           // Don't use restriction_p here since we don't want special
           // treatment of anyType.
           //
-          Boolean restriction (
+          bool restriction (
             c.inherits_p () &&
             c.inherits ().is_a<SemanticGraph::Restricts> ());
 
@@ -782,7 +805,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (e.substitutes_p ())
@@ -809,7 +832,7 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_parser_source (Context& ctx)
     {
       if (ctx.polymorphic)
@@ -822,8 +845,8 @@ namespace CXX
         else
           ctx.os << endl;
 
-        Boolean import_maps (ctx.options.value<CLI::import_maps> ());
-        Boolean export_maps (ctx.options.value<CLI::export_maps> ());
+        bool import_maps (ctx.options.import_maps ());
+        bool export_maps (ctx.options.export_maps ());
 
         if (import_maps || export_maps)
         {
@@ -896,7 +919,7 @@ namespace CXX
       // Emit "weak" header includes that are used in the file-per-type
       // compilation model.
       //
-      if (ctx.options.value<CLI::generate_inline> ())
+      if (ctx.options.generate_inline ())
       {
         Traversal::Schema schema;
         Includes includes (ctx, Includes::source);
@@ -906,7 +929,7 @@ namespace CXX
       }
 
       Traversal::Schema schema;
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names schema_names;
 
       Namespace ns (ctx);
diff --git a/xsd/xsd/cxx/parser/parser-source.hxx b/xsd/xsd/cxx/parser/parser-source.hxx
index f6496ea..6e206b4 100644
--- a/xsd/xsd/cxx/parser/parser-source.hxx
+++ b/xsd/xsd/cxx/parser/parser-source.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/parser-source.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_PARSER_SOURCE_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Parser
   {
-    Void
+    void
     generate_parser_source (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/parser/print-impl-common.hxx b/xsd/xsd/cxx/parser/print-impl-common.hxx
index 5a91931..516273a 100644
--- a/xsd/xsd/cxx/parser/print-impl-common.hxx
+++ b/xsd/xsd/cxx/parser/print-impl-common.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/parser/print-impl-common.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_PRINT_IMPL_COMMON_HXX
@@ -74,7 +73,7 @@ namespace CXX
       {
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Type&)
       {
         gen_user_type ();
@@ -82,7 +81,7 @@ namespace CXX
 
       // Boolean.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Boolean& t)
       {
         if (default_type (t, "bool"))
@@ -96,7 +95,7 @@ namespace CXX
 
       // Integral types.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Byte& t)
       {
         if (default_type (t, "signed char"))
@@ -108,7 +107,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedByte& t)
       {
         if (default_type (t, "unsigned char"))
@@ -120,7 +119,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Short& t)
       {
         if (default_type (t, "short"))
@@ -132,7 +131,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedShort& t)
       {
         if (default_type (t, "unsigned short"))
@@ -144,7 +143,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Int& t)
       {
         if (default_type (t, "int"))
@@ -156,7 +155,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedInt& t)
       {
         if (default_type (t, "unsigned int"))
@@ -168,7 +167,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Long& t)
       {
         if (default_type (t, "long long"))
@@ -180,7 +179,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedLong& t)
       {
         if (default_type (t, "unsigned long long"))
@@ -192,7 +191,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Integer& t)
       {
         if (default_type (t, "long long"))
@@ -204,7 +203,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NegativeInteger& t)
       {
         if (default_type (t, "long long"))
@@ -216,7 +215,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonPositiveInteger& t)
       {
         if (default_type (t, "long long"))
@@ -228,7 +227,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::PositiveInteger& t)
       {
         if (default_type (t, "unsigned long long"))
@@ -240,7 +239,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonNegativeInteger& t)
       {
         if (default_type (t, "unsigned long long"))
@@ -254,7 +253,7 @@ namespace CXX
 
       // Floats.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Float& t)
       {
         if (default_type (t, "float"))
@@ -266,7 +265,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Double& t)
       {
         if (default_type (t, "double"))
@@ -278,7 +277,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Decimal& t)
       {
         if (default_type (t, "double"))
@@ -292,61 +291,61 @@ namespace CXX
 
       // Strings.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::String& t)
       {
         gen_string (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NormalizedString& t)
       {
         gen_string (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Token& t)
       {
         gen_string (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NameToken& t)
       {
         gen_string (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Name& t)
       {
         gen_string (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NCName& t)
       {
         gen_string (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Language& t)
       {
         gen_string (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Id& t)
       {
         gen_string (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::IdRef& t)
       {
         gen_string (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::AnyURI& t)
       {
         gen_string (t);
@@ -355,13 +354,13 @@ namespace CXX
       // String sequences.
       //
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NameTokens& t)
       {
         gen_sequence (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::IdRefs& t)
       {
         gen_sequence (t);
@@ -370,7 +369,7 @@ namespace CXX
       // QName
       //
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::QName& t)
       {
         if (default_type (t, xs_ns_name () + L"::qname"))
@@ -391,13 +390,13 @@ namespace CXX
 
       // Binary.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Base64Binary& t)
       {
         gen_buffer (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::HexBinary& t)
       {
         gen_buffer (t);
@@ -405,7 +404,7 @@ namespace CXX
 
       // Date/time.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Date& t)
       {
         if (default_type (t, xs_ns_name () + L"::date"))
@@ -421,7 +420,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::DateTime& t)
       {
         if (default_type (t, xs_ns_name () + L"::date_time"))
@@ -440,7 +439,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Duration& t)
       {
         if (default_type (t, xs_ns_name () + L"::duration"))
@@ -463,7 +462,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Day& t)
       {
         if (default_type (t, xs_ns_name () + L"::gday"))
@@ -477,7 +476,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Month& t)
       {
         if (default_type (t, xs_ns_name () + L"::gmonth"))
@@ -491,7 +490,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::MonthDay& t)
       {
         if (default_type (t, xs_ns_name () + L"::gmonth_day"))
@@ -506,7 +505,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Year& t)
       {
         if (default_type (t, xs_ns_name () + L"::gyear"))
@@ -520,7 +519,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::YearMonth& t)
       {
         if (default_type (t, xs_ns_name () + L"::gyear_month"))
@@ -535,7 +534,7 @@ namespace CXX
           gen_user_type ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Time& t)
       {
         if (default_type (t, xs_ns_name () + L"::time"))
@@ -605,7 +604,7 @@ namespace CXX
       void
       gen_buffer (SemanticGraph::Type& t)
       {
-        String type (L"::std::auto_ptr< " + xs_ns_name () + L"::buffer >");
+        String type (auto_ptr + L"< " + xs_ns_name () + L"::buffer >");
 
         if (default_type (t, type))
         {
diff --git a/xsd/xsd/cxx/parser/state-processor.cxx b/xsd/xsd/cxx/parser/state-processor.cxx
index 7fe3ff6..86f97ce 100644
--- a/xsd/xsd/cxx/parser/state-processor.cxx
+++ b/xsd/xsd/cxx/parser/state-processor.cxx
@@ -1,8 +1,10 @@
 // file      : xsd/cxx/parser/state-processor.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
+#include <vector>
+#include <iostream>
+
 #include <cxx/parser/state-processor.hxx>
 
 #include <cxx/parser/elements.hxx>
@@ -10,9 +12,7 @@
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
 
-#include <cult/containers/vector.hxx>
-
-#include <iostream>
+using namespace std;
 
 namespace CXX
 {
@@ -20,8 +20,9 @@ namespace CXX
   {
     namespace
     {
-      typedef Cult::Containers::Vector<SemanticGraph::Particle*> Particles;
+      typedef vector<SemanticGraph::Particle*> Particles;
 
+      /*
       void
       print (Particles const& p)
       {
@@ -30,7 +31,7 @@ namespace CXX
 
         wcerr << "prefixes: " << endl;
 
-        for (Particles::ConstIterator i (p.begin ()); i != p.end (); ++i)
+        for (Particles::const_iterator i (p.begin ()); i != p.end (); ++i)
         {
           if (SemanticGraph::Element* e =
               dynamic_cast<SemanticGraph::Element*> (*i))
@@ -45,6 +46,7 @@ namespace CXX
 
         wcerr << endl;
       }
+      */
 
       //
       //
@@ -52,10 +54,10 @@ namespace CXX
                        Traversal::Choice,
                        Traversal::Sequence
       {
-        Particle (UnsignedLong& all,
-                  UnsignedLong& choice,
-                  UnsignedLong& sequence,
-                  UnsignedLong& depth)
+        Particle (size_t& all,
+                  size_t& choice,
+                  size_t& sequence,
+                  size_t& depth)
             : all_ (all),
               choice_ (choice),
               sequence_ (sequence),
@@ -63,7 +65,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::All& a)
         {
           using SemanticGraph::Compositor;
@@ -78,8 +80,8 @@ namespace CXX
           // compositor cannot contain any nested compositors.
           //
 
-          UnsignedLong state (0);
-          UnsignedLong min (0);
+          size_t state (0);
+          size_t min (0);
 
           for (Compositor::ContainsIterator ci (a.contains_begin ());
                ci != a.contains_end (); ++ci)
@@ -101,7 +103,7 @@ namespace CXX
           {
             a.context ().set ("comp-number", choice_++);
             a.context ().set ("prefixes", prefixes_);
-            a.context ().set ("state-count", UnsignedLong (prefixes_.size ()));
+            a.context ().set ("state-count", size_t (prefixes_.size ()));
 
             // effective-min = min * actual-min
             //
@@ -114,7 +116,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Choice& c)
         {
           using SemanticGraph::Compositor;
@@ -126,8 +128,8 @@ namespace CXX
           // the actual value specified in the schema.
           //
 
-          UnsignedLong state (0);
-          UnsignedLong min (1);
+          size_t state (0);
+          size_t min (1);
 
           for (Compositor::ContainsIterator ci (c.contains_begin ());
                ci != c.contains_end (); ++ci)
@@ -144,7 +146,7 @@ namespace CXX
             }
             else
             {
-              UnsignedLong depth (0);
+              size_t depth (0);
               Particle t (all_, choice_, sequence_, depth);
               t.dispatch (p);
 
@@ -159,7 +161,7 @@ namespace CXX
                                 t.prefixes_.end ().base ());
 
               if (min == 1 &&
-                  p.context ().get<UnsignedLong> ("effective-min") == 0)
+                  p.context ().get<size_t> ("effective-min") == 0)
                 min = 0;
             }
 
@@ -183,7 +185,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Sequence& s)
         {
           using SemanticGraph::Compositor;
@@ -195,9 +197,9 @@ namespace CXX
           // of the actual value specified in the schema.
           //
 
-          Boolean prefix (true);
-          UnsignedLong state (0);
-          UnsignedLong min (0);
+          bool prefix (true);
+          size_t state (0);
+          size_t min (0);
 
           for (Compositor::ContainsIterator ci (s.contains_begin ());
                ci != s.contains_end (); ++ci)
@@ -217,7 +219,7 @@ namespace CXX
             }
             else
             {
-              UnsignedLong depth (0);
+              size_t depth (0);
               Particle t (all_, choice_, sequence_, depth);
               t.dispatch (p);
 
@@ -233,7 +235,7 @@ namespace CXX
                                   t.prefixes_.begin ().base (),
                                   t.prefixes_.end ().base ());
 
-                if (p.context ().get<UnsignedLong> ("effective-min") != 0)
+                if (p.context ().get<size_t> ("effective-min") != 0)
                   min = 1;
               }
             }
@@ -266,11 +268,11 @@ namespace CXX
       private:
         Particles prefixes_;
 
-        UnsignedLong& all_;
-        UnsignedLong& choice_;
-        UnsignedLong& sequence_;
+        size_t& all_;
+        size_t& choice_;
+        size_t& sequence_;
 
-        UnsignedLong& depth_;
+        size_t& depth_;
       };
 
 
@@ -278,12 +280,12 @@ namespace CXX
       //
       struct Complex: Traversal::Complex
       {
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           if (c.contains_compositor_p ())
           {
-            UnsignedLong all (0), choice (0), sequence (0), depth (0);
+            size_t all (0), choice (0), sequence (0), depth (0);
             Particle t (all, choice, sequence, depth);
             t.dispatch (c.contains_compositor ().compositor ());
 
@@ -296,11 +298,11 @@ namespace CXX
       };
     }
 
-    Void StateProcessor::
+    void StateProcessor::
     process (SemanticGraph::Schema& tu, SemanticGraph::Path const&)
     {
       Traversal::Schema schema;
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names schema_names;
       Traversal::Namespace ns;
       Traversal::Names ns_names;
diff --git a/xsd/xsd/cxx/parser/state-processor.hxx b/xsd/xsd/cxx/parser/state-processor.hxx
index 630ac13..de5af69 100644
--- a/xsd/xsd/cxx/parser/state-processor.hxx
+++ b/xsd/xsd/cxx/parser/state-processor.hxx
@@ -1,24 +1,22 @@
 // file      : xsd/cxx/parser/state-processor.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_STATE_PROCESSOR_HXX
 #define CXX_PARSER_STATE_PROCESSOR_HXX
 
-#include <cult/types.hxx>
 #include <xsd-frontend/semantic-graph.hxx>
 
+#include <types.hxx>
+
 namespace CXX
 {
   namespace Parser
   {
-    using namespace Cult::Types;
-
     class StateProcessor
     {
     public:
-      Void
+      void
       process (XSDFrontend::SemanticGraph::Schema&,
                XSDFrontend::SemanticGraph::Path const& file);
     };
diff --git a/xsd/xsd/cxx/parser/type-processor.cxx b/xsd/xsd/cxx/parser/type-processor.cxx
index 4744c0a..2f1132c 100644
--- a/xsd/xsd/cxx/parser/type-processor.cxx
+++ b/xsd/xsd/cxx/parser/type-processor.cxx
@@ -1,9 +1,8 @@
 // file      : xsd/cxx/parser/type-processor.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
-#include <cult/containers/set.hxx>
+#include <set>
 
 #include <cxx/parser/elements.hxx>
 #include <cxx/parser/type-processor.hxx>
@@ -11,16 +10,12 @@
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
 
+using namespace std;
+
 namespace CXX
 {
   namespace Parser
   {
-    TypeProcessor::
-    TypeProcessor ()
-    {
-      // Dummy ctor, helps with long symbols on HP-UX.
-    }
-
     namespace
     {
       //
@@ -29,14 +24,14 @@ namespace CXX
       {
         Type (SemanticGraph::Schema& schema,
               TypeMap::Namespaces& type_map,
-              Boolean add_includes)
+              bool add_includes)
             : schema_ (schema),
               type_map_ (type_map),
               add_includes_ (add_includes)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Type& type)
         {
           using TypeMap::Namespace;
@@ -54,7 +49,7 @@ namespace CXX
           // match the type in order to add include directives to the
           // new root schema.
           //
-          Boolean set (true);
+          bool set (true);
 
           if (tc.count ("ret-type"))
           {
@@ -73,14 +68,14 @@ namespace CXX
           String ns_name (ns.name ());
           String t_name (type.name ());
 
-          // std::wcerr << "traversing: " << ns_name << "#" << t_name << endl;
+          //std::wcerr << "traversing: " << ns_name << "#" << t_name << endl;
 
-          for (Namespaces::ConstIterator n (type_map_.begin ());
+          for (Namespaces::const_iterator n (type_map_.begin ());
                n != type_map_.end (); ++n)
           {
             // Check if the namespace matches.
             //
-            Boolean ns_match;
+            bool ns_match;
 
             if (!n->xsd_name ().empty ())
             {
@@ -89,7 +84,9 @@ namespace CXX
             else
               ns_match = ns_name.empty ();
 
-            // std::wcerr << "considering ns expr: " << n->xsd_name () << endl;
+            //std::wcerr << "considering ns expr: " << n->xsd_name ()
+            //           << " for " << ns_name
+            //           << ": " << (ns_match ? "+" : "-") << endl;
 
             if (ns_match)
             {
@@ -111,8 +108,8 @@ namespace CXX
                     {
                       if (!n->xsd_name ().empty ())
                       {
-                        cxx_ns = n->xsd_name ().merge (
-                          n->cxx_name (), ns_name, true);
+                        cxx_ns = n->xsd_name ().replace (
+                          ns_name, n->cxx_name (), true);
                       }
                       else
                         cxx_ns = n->cxx_name ();
@@ -124,16 +121,16 @@ namespace CXX
                     //
                     String ret_type (cxx_ns);
 
-                    ret_type += t->xsd_name ().merge (
-                      t->cxx_ret_name (), t_name, true);
+                    ret_type += t->xsd_name ().replace (
+                      t_name, t->cxx_ret_name (), true);
 
                     String arg_type;
 
                     if (t->cxx_arg_name ())
                     {
                       arg_type = cxx_ns;
-                      arg_type += t->xsd_name ().merge (
-                        t->cxx_arg_name (), t_name, true);
+                      arg_type += t->xsd_name ().replace (
+                        t_name, t->cxx_arg_name (), true);
                     }
                     else
                     {
@@ -141,7 +138,7 @@ namespace CXX
                         arg_type = ret_type;
                       else
                       {
-                        WideChar last (ret_type[ret_type.size () - 1]);
+                        wchar_t last (ret_type[ret_type.size () - 1]);
 
                         // If it is already a pointer or reference then use
                         // it as is.
@@ -155,12 +152,12 @@ namespace CXX
 
                     tc.set ("ret-type", ret_type);
                     tc.set ("arg-type", arg_type);
+
+                    //std::wcerr << t_name << " -> " << ret_type << endl;
                   }
 
                   tc.set ("root-schema", &schema_);
 
-                  //std::wcerr << t_name << " -> " << ret_type << endl;
-
                   // See of we need to add any includes to the translations
                   // unit.
                   //
@@ -168,7 +165,7 @@ namespace CXX
                   {
                     if (n->includes_begin () != n->includes_end ())
                     {
-                      typedef Cult::Containers::Set<String> Includes;
+                      typedef std::set<String> Includes;
 
                       if (!schema_.context ().count ("includes"))
                         schema_.context ().set ("includes", Includes ());
@@ -194,7 +191,7 @@ namespace CXX
       private:
         SemanticGraph::Schema& schema_;
         TypeMap::Namespaces& type_map_;
-        Boolean add_includes_;
+        bool add_includes_;
       };
 
 
@@ -207,7 +204,7 @@ namespace CXX
       {
         GlobalType (SemanticGraph::Schema& schema,
                     TypeMap::Namespaces& type_map,
-                    Boolean add_includes)
+                    bool add_includes)
             : type_ (schema, type_map, add_includes)
         {
           inherits_ >> type_;
@@ -215,20 +212,20 @@ namespace CXX
           argumented_ >> type_;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Type& t)
         {
           type_.traverse (t);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::List& l)
         {
           type_.traverse (l);
           Traversal::List::argumented (l, argumented_);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           type_.traverse (c);
@@ -236,7 +233,7 @@ namespace CXX
           Complex::names (c, names_);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Enumeration& e)
         {
           type_.traverse (e);
@@ -252,10 +249,10 @@ namespace CXX
         Traversal::Argumented argumented_;
       };
 
-      Void
-      process_impl (CLI::Options const& options,
+      void
+      process_impl (options const& ops,
                     XSDFrontend::SemanticGraph::Schema& tu,
-                    Boolean gen_driver,
+                    bool gen_driver,
                     TypeMap::Namespaces& type_map)
       {
         if (tu.names_begin ()->named ().name () ==
@@ -279,14 +276,13 @@ namespace CXX
           // If --extern-xml-schema is specified, then we don't want
           // includes from the XML Schema type map.
           //
-          Boolean extern_xml_schema (
-            options.value<CLI::extern_xml_schema> ());
+          bool extern_xml_schema (ops.extern_xml_schema ());
 
           //
           //
           Traversal::Schema schema;
           Traversal::Schema xs_schema;
-          Traversal::Sources sources;
+          Sources sources;
           Traversal::Implies implies;
 
           schema >> sources >> schema;
@@ -312,7 +308,7 @@ namespace CXX
           // If we are generating the test driver, make sure the root
           // element type is processed.
           //
-          if (gen_driver && options.value<CLI::generate_test_driver> ())
+          if (gen_driver && ops.generate_test_driver ())
           {
             // Figure out the root element. Validator should have made sure
             // it is unique.
@@ -320,14 +316,14 @@ namespace CXX
             SemanticGraph::Element* root (0);
             {
               Traversal::Schema schema;
-              Traversal::Sources sources;
+              Sources sources;
 
               schema >> sources >> schema;
 
               Traversal::Names schema_names;
               Traversal::Namespace ns;
               Traversal::Names ns_names;
-              RootElement root_element (options, root);
+              RootElement root_element (ops, root);
 
               schema >> schema_names >> ns >> ns_names >> root_element;
 
@@ -340,13 +336,13 @@ namespace CXX
       }
     }
 
-    Void TypeProcessor::
-    process (CLI::Options const& options,
+    void TypeProcessor::
+    process (options const& ops,
              XSDFrontend::SemanticGraph::Schema& s,
-             Boolean gen_driver,
+             bool gen_driver,
              TypeMap::Namespaces& tm)
     {
-      process_impl (options, s, gen_driver, tm);
+      process_impl (ops, s, gen_driver, tm);
     }
   }
 }
diff --git a/xsd/xsd/cxx/parser/type-processor.hxx b/xsd/xsd/cxx/parser/type-processor.hxx
index 02a090f..634bc14 100644
--- a/xsd/xsd/cxx/parser/type-processor.hxx
+++ b/xsd/xsd/cxx/parser/type-processor.hxx
@@ -1,34 +1,29 @@
 // file      : xsd/cxx/parser/type-processor.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_TYPE_PROCESSOR_HXX
 #define CXX_PARSER_TYPE_PROCESSOR_HXX
 
-#include <cult/types.hxx>
-
 #include <xsd-frontend/semantic-graph.hxx>
 
+#include <types.hxx>
+
 #include <type-map/type-map.hxx>
 
-#include <cxx/parser/cli.hxx>
+#include <cxx/parser/options.hxx>
 
 namespace CXX
 {
   namespace Parser
   {
-    using namespace Cult::Types;
-
     class TypeProcessor
     {
     public:
-      TypeProcessor (); // Dummy ctor, helps with long symbols on HP-UX.
-
-      Void
-      process (CLI::Options const& options,
+      void
+      process (options const&,
                XSDFrontend::SemanticGraph::Schema&,
-               Boolean gen_driver,
+               bool gen_driver,
                TypeMap::Namespaces&);
     };
   }
diff --git a/xsd/xsd/cxx/parser/validator.cxx b/xsd/xsd/cxx/parser/validator.cxx
index 19b15c6..da9f8b0 100644
--- a/xsd/xsd/cxx/parser/validator.cxx
+++ b/xsd/xsd/cxx/parser/validator.cxx
@@ -1,8 +1,10 @@
 // file      : xsd/cxx/parser/validator.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
+#include <set>
+#include <iostream>
+
 #include <cxx/parser/validator.hxx>
 
 #include <xsd-frontend/semantic-graph.hxx>
@@ -10,9 +12,7 @@
 
 #include <cxx/parser/elements.hxx>
 
-#include <iostream>
-
-using std::wcerr;
+using namespace std;
 
 namespace CXX
 {
@@ -25,10 +25,10 @@ namespace CXX
       public:
         ValidationContext (SemanticGraph::Schema& root,
                            SemanticGraph::Path const& path,
-                           CLI::Options const& options,
+                           Parser::options const& ops,
                            const WarningSet& disabled_warnings,
-                           Boolean& valid_)
-            : Context (std::wcerr, root, path, options, 0, 0, 0, 0),
+                           bool& valid_)
+            : Context (std::wcerr, root, path, ops, 0, 0, 0, 0),
               disabled_warnings_ (disabled_warnings),
               disabled_warnings_all_ (false),
               valid (valid_),
@@ -38,8 +38,8 @@ namespace CXX
         }
 
       public:
-        Boolean
-        is_disabled (Char const* w)
+        bool
+        is_disabled (char const* w)
         {
           return disabled_warnings_all_ ||
             disabled_warnings_.find (w) != disabled_warnings_.end ();
@@ -74,10 +74,10 @@ namespace CXX
 
       protected:
         const WarningSet& disabled_warnings_;
-        Boolean disabled_warnings_all_;
-        Boolean& valid;
-        Boolean& subst_group_warning_issued;
-        Boolean subst_group_warning_issued_;
+        bool disabled_warnings_all_;
+        bool& valid;
+        bool& subst_group_warning_issued;
+        bool subst_group_warning_issued_;
       };
 
       //
@@ -98,20 +98,20 @@ namespace CXX
           {
           }
 
-          virtual Void
+          virtual void
           traverse (SemanticGraph::Element& e)
           {
 	    if (skip (e)) return;
 
             using SemanticGraph::Any;
 
-            Boolean q (e.qualified_p ());
+            bool q (e.qualified_p ());
             String ns (q ? e.namespace_ ().name () : "");
 
             for (Any::NamespaceIterator i (any_.namespace_begin ());
                  i != any_.namespace_end (); ++i)
             {
-              Boolean failed (false);
+              bool failed (false);
 
               if (*i == L"##any")
               {
@@ -184,14 +184,14 @@ namespace CXX
           {
           }
 
-          virtual Void
+          virtual void
           post (Type& c)
           {
             // Go down the inheritance hierarchy.
             //
             if (down_)
             {
-              Boolean up = up_;
+              bool up = up_;
               up_ = false;
 
               if (c.inherits_p ())
@@ -204,7 +204,7 @@ namespace CXX
             //
             if (up_)
             {
-              Boolean down = down_;
+              bool down = down_;
               down_ = false;
 
               for (Type::BegetsIterator i (c.begets_begin ());
@@ -218,10 +218,10 @@ namespace CXX
           }
 
         private:
-          Boolean up_, down_;
+          bool up_, down_;
         };
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           using SemanticGraph::Compositor;
@@ -273,7 +273,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           using SemanticGraph::Schema;
@@ -319,7 +319,7 @@ namespace CXX
           Complex::traverse (c);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Type& t)
         {
           if (t.named_p ())
@@ -328,14 +328,14 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element& e)
         {
           if (is_disabled ("P002"))
             return;
 
           if (e.substitutes_p () &&
-              !options.value<CLI::generate_polymorphic> () &&
+              !options.generate_polymorphic () &&
               !subst_group_warning_issued)
           {
             subst_group_warning_issued = true;
@@ -352,7 +352,7 @@ namespace CXX
 
         // Return true if root sources s.
         //
-        Boolean
+        bool
         sources_p (SemanticGraph::Schema& root, SemanticGraph::Schema& s)
         {
           using SemanticGraph::Schema;
@@ -372,9 +372,9 @@ namespace CXX
         }
 
       private:
-        Containers::Set<String> types_;
+        set<String> types_;
 
-        Traversal::Sources sources_;
+        Sources sources_;
 
         Traversal::Names schema_names_;
         Traversal::Namespace ns_;
@@ -405,7 +405,7 @@ namespace CXX
           *this >> names_;
         }
 
-        Boolean
+        bool
         traverse_common (SemanticGraph::Member& m)
         {
           SemanticGraph::Type& t (m.type ());
@@ -434,7 +434,7 @@ namespace CXX
                     << "automatically name them"
                     << endl;
 
-              if (!options.value<CLI::show_anonymous> ())
+              if (!options.show_anonymous ())
                 wcerr << t.file ()
                       << ": info: use --show-anonymous option to see these "
                       << "types" << endl;
@@ -446,14 +446,14 @@ namespace CXX
           return false;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element& e)
         {
 	  if (skip (e)) return;
 
           if (traverse_common (e))
           {
-            if (options.value<CLI::show_anonymous> ())
+            if (options.show_anonymous ())
             {
               wcerr << e.file () << ":" << e.line () << ":" << e.column ()
                     << ": error: element '" << xpath (e) << "' "
@@ -464,12 +464,12 @@ namespace CXX
             Traversal::Element::traverse (e);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Attribute& a)
         {
           if (traverse_common (a))
           {
-            if (options.value<CLI::show_anonymous> ())
+            if (options.show_anonymous ())
             {
               wcerr << a.file () << ":" << a.line () << ":" << a.column ()
                     << ": error: attribute '" << xpath (a) << "' "
@@ -481,11 +481,11 @@ namespace CXX
         }
 
       private:
-        Boolean anonymous_error_issued_;
+        bool anonymous_error_issued_;
 
-        Containers::Set<String> types_;
+        set<String> types_;
 
-        Traversal::Sources sources_;
+        Sources sources_;
 
         Traversal::Names schema_names_;
         Traversal::Namespace ns_;
@@ -500,22 +500,22 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (!valid)
             return;
 
-          if (options.value<CLI::root_element_first> ())
+          if (options.root_element_first ())
           {
             if (element_ == 0)
               element_ = &e;
           }
-          else if (options.value<CLI::root_element_last> ())
+          else if (options.root_element_last ())
           {
             element_ = &e;
           }
-          else if (String name = options.value<CLI::root_element> ())
+          else if (String name = options.root_element ())
           {
             if (e.name () == name)
               element_ = &e;
@@ -544,46 +544,40 @@ namespace CXX
 
     }
 
-    Validator::
-    Validator ()
-    {
-      // Dummy ctor, helps with long symbols on HP-UX.
-    }
-
-    Boolean Validator::
-    validate (CLI::Options const& options,
+    bool Validator::
+    validate (options const& ops,
               SemanticGraph::Schema& root,
               SemanticGraph::Path const& path,
-              Boolean gen_driver,
+              bool gen_driver,
               const WarningSet& disabled_warnings)
     {
-      Boolean valid (true);
-      ValidationContext ctx (root, path, options, disabled_warnings, valid);
+      bool valid (true);
+      ValidationContext ctx (root, path, ops, disabled_warnings, valid);
 
       //
       //
-      if (options.value<CLI::char_type> () != "char" &&
-          options.value<CLI::char_type> () != "wchar_t" &&
+      if (ops.char_type () != "char" &&
+          ops.char_type () != "wchar_t" &&
           !ctx.is_disabled ("P003"))
       {
         wcerr << "warning P003: unknown base character type '" <<
-          options.value<CLI::char_type> ().c_str () << "'" << endl;
+          ops.char_type ().c_str () << "'" << endl;
       }
 
       //
       //
-      if (options.value<CLI::xml_parser> () != "xerces" &&
-          options.value<CLI::xml_parser> () != "expat" &&
+      if (ops.xml_parser () != "xerces" &&
+          ops.xml_parser () != "expat" &&
           !ctx.is_disabled ("P004"))
       {
         wcerr << "warning P004: unknown underlying XML parser '" <<
-          options.value<CLI::xml_parser> ().c_str () << "'" << endl;
+          ops.xml_parser ().c_str () << "'" << endl;
       }
 
       //
       //
-      if (options.value<CLI::xml_parser> () == "expat" &&
-          options.value<CLI::char_type> () == "wchar_t")
+      if (ops.xml_parser () == "expat" &&
+          ops.char_type () == "wchar_t")
       {
         wcerr << "error: using expat with wchar_t is not supported"
               << endl;
@@ -593,9 +587,9 @@ namespace CXX
 
       //
       //
-      if (options.value<CLI::xml_parser> () == "expat" &&
-          !options.value<CLI::char_encoding> ().empty () &&
-          options.value<CLI::char_encoding> () != "utf8")
+      if (ops.xml_parser () == "expat" &&
+          !ops.char_encoding ().empty () &&
+          ops.char_encoding () != "utf8")
       {
         wcerr << "error: using expat with character encoding other than "
               << "utf8 is not supported"
@@ -606,8 +600,7 @@ namespace CXX
 
       //
       //
-      if (options.value<CLI::generate_validation> () &&
-          options.value<CLI::suppress_validation> ())
+      if (ops.generate_validation () && ops.suppress_validation ())
       {
         wcerr << "error: mutually exclusive options specified: "
               << "--generate-validation and --suppress-validation"
@@ -618,8 +611,7 @@ namespace CXX
 
       //
       //
-      if (options.value<CLI::generate_noop_impl> () &&
-          options.value<CLI::generate_print_impl> ())
+      if (ops.generate_noop_impl () && ops.generate_print_impl ())
       {
         wcerr << "error: mutually exclusive options specified: "
               << "--generate-noop-impl and --generate-print-impl"
@@ -631,9 +623,9 @@ namespace CXX
       //
       //
       {
-        Boolean ref (options.value<CLI::root_element_first> ());
-        Boolean rel (options.value<CLI::root_element_last> ());
-        Boolean re (options.value<CLI::root_element> ());
+        bool ref (ops.root_element_first ());
+        bool rel (ops.root_element_last ());
+        bool re (ops.root_element ());
 
         if ((ref && rel) || (ref && re) || (rel && re))
         {
@@ -648,8 +640,8 @@ namespace CXX
 
       //
       //
-      Boolean import_maps (options.value<CLI::import_maps> ());
-      Boolean export_maps (options.value<CLI::export_maps> ());
+      bool import_maps (ops.import_maps ());
+      bool export_maps (ops.export_maps ());
 
       if (import_maps && export_maps)
       {
@@ -698,7 +690,7 @@ namespace CXX
         SemanticGraph::Element* element (0);
 
         Traversal::Schema schema;
-        Traversal::Sources sources;
+        Sources sources;
 
         schema >> sources >> schema;
 
diff --git a/xsd/xsd/cxx/parser/validator.hxx b/xsd/xsd/cxx/parser/validator.hxx
index f519b05..c67cced 100644
--- a/xsd/xsd/cxx/parser/validator.hxx
+++ b/xsd/xsd/cxx/parser/validator.hxx
@@ -1,32 +1,28 @@
 // file      : xsd/cxx/parser/validator.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_PARSER_VALIDATOR_HXX
 #define CXX_PARSER_VALIDATOR_HXX
 
-#include <cxx/parser/elements.hxx>
-#include <cxx/parser/cli.hxx>
-
 #include <xsd.hxx>
+#include <types.hxx>
+
+#include <cxx/parser/elements.hxx>
+#include <cxx/parser/options.hxx>
 
 namespace CXX
 {
   namespace Parser
   {
-    using namespace Cult::Types;
-
     class Validator
     {
     public:
-      Validator (); // Dummy ctor, helps with long symbols on HP-UX.
-
-      Boolean
-      validate (CLI::Options const& options,
+      bool
+      validate (options const&,
                 SemanticGraph::Schema&,
                 SemanticGraph::Path const& tu,
-                Boolean gen_driver,
+                bool gen_driver,
                 const WarningSet& disabled_warnings);
     };
   }
diff --git a/xsd/xsd/cxx/tree/cli.hxx b/xsd/xsd/cxx/tree/cli.hxx
deleted file mode 100644
index 171711d..0000000
--- a/xsd/xsd/cxx/tree/cli.hxx
+++ /dev/null
@@ -1,228 +0,0 @@
-// file      : xsd/cxx/tree/cli.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
-// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
-
-#ifndef CXX_TREE_CLI_HXX
-#define CXX_TREE_CLI_HXX
-
-#include <cult/types.hxx>
-
-#include <cult/containers/vector.hxx>
-
-#include <cult/cli/options.hxx>
-#include <cult/cli/options-spec.hxx>
-
-namespace CXX
-{
-  namespace Tree
-  {
-    namespace CLI
-    {
-      using namespace Cult::Types;
-
-      typedef Char const Key[];
-
-      extern Key char_type;
-      extern Key char_encoding;
-      extern Key output_dir;
-      extern Key generate_polymorphic;
-      extern Key polymorphic_type;
-      extern Key polymorphic_type_all;
-      extern Key generate_serialization;
-      extern Key generate_inline;
-      extern Key generate_ostream;
-      extern Key generate_doxygen;
-      extern Key generate_comparison;
-      extern Key generate_default_ctor;
-      extern Key generate_from_base_ctor;
-      extern Key generate_detach;
-      extern Key generate_wildcard;
-      extern Key generate_insertion;
-      extern Key generate_extraction;
-      extern Key generate_forward;
-      extern Key generate_xml_schema;
-      extern Key extern_xml_schema;
-      extern Key suppress_parsing;
-      extern Key generate_element_type;
-      extern Key generate_element_map;
-      extern Key generate_intellisense;
-      extern Key omit_default_attributes;
-      extern Key namespace_map;
-      extern Key namespace_regex;
-      extern Key namespace_regex_trace;
-      extern Key reserved_name;
-      extern Key type_naming;
-      extern Key function_naming;
-      extern Key type_regex;
-      extern Key accessor_regex;
-      extern Key one_accessor_regex;
-      extern Key opt_accessor_regex;
-      extern Key seq_accessor_regex;
-      extern Key modifier_regex;
-      extern Key one_modifier_regex;
-      extern Key opt_modifier_regex;
-      extern Key seq_modifier_regex;
-      extern Key parser_regex;
-      extern Key serializer_regex;
-      extern Key enumerator_regex;
-      extern Key element_type_regex;
-      extern Key name_regex_trace;
-      extern Key include_with_brackets;
-      extern Key include_prefix;
-      extern Key include_regex;
-      extern Key include_regex_trace;
-      extern Key guard_prefix;
-      extern Key root_element_first;
-      extern Key root_element_last;
-      extern Key root_element_all;
-      extern Key root_element_none;
-      extern Key root_element;
-      extern Key custom_type;
-      extern Key custom_type_regex;
-      extern Key hxx_suffix;
-      extern Key ixx_suffix;
-      extern Key cxx_suffix;
-      extern Key fwd_suffix;
-      extern Key hxx_regex;
-      extern Key ixx_regex;
-      extern Key cxx_regex;
-      extern Key fwd_regex;
-      extern Key hxx_prologue;
-      extern Key ixx_prologue;
-      extern Key cxx_prologue;
-      extern Key fwd_prologue;
-      extern Key prologue;
-      extern Key hxx_epilogue;
-      extern Key ixx_epilogue;
-      extern Key cxx_epilogue;
-      extern Key fwd_epilogue;
-      extern Key epilogue;
-      extern Key hxx_prologue_file;
-      extern Key ixx_prologue_file;
-      extern Key cxx_prologue_file;
-      extern Key fwd_prologue_file;
-      extern Key prologue_file;
-      extern Key hxx_epilogue_file;
-      extern Key ixx_epilogue_file;
-      extern Key cxx_epilogue_file;
-      extern Key fwd_epilogue_file;
-      extern Key epilogue_file;
-      extern Key parts;
-      extern Key parts_suffix;
-      extern Key export_symbol;
-      extern Key export_xml_schema;
-      extern Key export_maps;
-      extern Key import_maps;
-      extern Key show_anonymous;
-      extern Key show_sloc;
-      extern Key proprietary_license;
-      extern Key disable_multi_import; // Undocumented.
-
-
-      typedef Cult::CLI::Options<
-
-        char_type,                NarrowString,
-        char_encoding,            NarrowString,
-        output_dir,               NarrowString,
-        generate_polymorphic,     Boolean,
-        polymorphic_type,         Cult::Containers::Vector<NarrowString>,
-        polymorphic_type_all,     Boolean,
-        generate_serialization,   Boolean,
-        generate_inline,          Boolean,
-        generate_ostream,         Boolean,
-        generate_doxygen,         Boolean,
-        generate_comparison,      Boolean,
-        generate_default_ctor,    Boolean,
-        generate_from_base_ctor,  Boolean,
-        generate_detach,          Boolean,
-        generate_wildcard,        Boolean,
-        generate_insertion,       Cult::Containers::Vector<NarrowString>,
-        generate_extraction,      Cult::Containers::Vector<NarrowString>,
-        generate_forward,         Boolean,
-        generate_xml_schema,      Boolean,
-        extern_xml_schema,        NarrowString,
-        suppress_parsing,         Boolean,
-        generate_element_type,    Boolean,
-        generate_element_map,     Boolean,
-        generate_intellisense,    Boolean,
-        omit_default_attributes,  Boolean,
-        namespace_map,            Cult::Containers::Vector<NarrowString>,
-        namespace_regex,          Cult::Containers::Vector<NarrowString>,
-        namespace_regex_trace,    Boolean,
-        reserved_name,            Cult::Containers::Vector<NarrowString>,
-        type_naming,              NarrowString,
-        function_naming,          NarrowString,
-        type_regex,               Cult::Containers::Vector<NarrowString>,
-        accessor_regex,           Cult::Containers::Vector<NarrowString>,
-        one_accessor_regex,       Cult::Containers::Vector<NarrowString>,
-        opt_accessor_regex,       Cult::Containers::Vector<NarrowString>,
-        seq_accessor_regex,       Cult::Containers::Vector<NarrowString>,
-        modifier_regex,           Cult::Containers::Vector<NarrowString>,
-        one_modifier_regex,       Cult::Containers::Vector<NarrowString>,
-        opt_modifier_regex,       Cult::Containers::Vector<NarrowString>,
-        seq_modifier_regex,       Cult::Containers::Vector<NarrowString>,
-        parser_regex,             Cult::Containers::Vector<NarrowString>,
-        serializer_regex,         Cult::Containers::Vector<NarrowString>,
-        enumerator_regex,         Cult::Containers::Vector<NarrowString>,
-        element_type_regex,       Cult::Containers::Vector<NarrowString>,
-        name_regex_trace,         Boolean,
-        include_with_brackets,    Boolean,
-        include_prefix,           NarrowString,
-        include_regex,            Cult::Containers::Vector<NarrowString>,
-        include_regex_trace,      Boolean,
-        guard_prefix,             NarrowString,
-        root_element_first,       Boolean,
-        root_element_last,        Boolean,
-        root_element_all,         Boolean,
-        root_element_none,        Boolean,
-        root_element,             Cult::Containers::Vector<NarrowString>,
-        custom_type,              Cult::Containers::Vector<NarrowString>,
-        custom_type_regex,        Cult::Containers::Vector<NarrowString>,
-        hxx_suffix,               NarrowString,
-        ixx_suffix,               NarrowString,
-        cxx_suffix,               NarrowString,
-        fwd_suffix,               NarrowString,
-        hxx_regex,                NarrowString,
-        ixx_regex,                NarrowString,
-        cxx_regex,                NarrowString,
-        fwd_regex,                NarrowString,
-        hxx_prologue,             Cult::Containers::Vector<NarrowString>,
-        ixx_prologue,             Cult::Containers::Vector<NarrowString>,
-        cxx_prologue,             Cult::Containers::Vector<NarrowString>,
-        fwd_prologue,             Cult::Containers::Vector<NarrowString>,
-        prologue,                 Cult::Containers::Vector<NarrowString>,
-        hxx_epilogue,             Cult::Containers::Vector<NarrowString>,
-        ixx_epilogue,             Cult::Containers::Vector<NarrowString>,
-        cxx_epilogue,             Cult::Containers::Vector<NarrowString>,
-        fwd_epilogue,             Cult::Containers::Vector<NarrowString>,
-        epilogue,                 Cult::Containers::Vector<NarrowString>,
-        hxx_prologue_file,        NarrowString,
-        ixx_prologue_file,        NarrowString,
-        cxx_prologue_file,        NarrowString,
-        fwd_prologue_file,        NarrowString,
-        prologue_file,            NarrowString,
-        hxx_epilogue_file,        NarrowString,
-        ixx_epilogue_file,        NarrowString,
-        cxx_epilogue_file,        NarrowString,
-        fwd_epilogue_file,        NarrowString,
-        epilogue_file,            NarrowString,
-        parts,                    UnsignedLong,
-        parts_suffix,             NarrowString,
-        export_symbol,            NarrowString,
-        export_xml_schema,        Boolean,
-        export_maps,              Boolean,
-        import_maps,              Boolean,
-        show_anonymous,           Boolean,
-        show_sloc,                Boolean,
-        proprietary_license,      Boolean,
-        disable_multi_import,     Boolean
-
-        > Options;
-
-      struct OptionsSpec: Cult::CLI::OptionsSpec<Options> {};
-    }
-  }
-}
-
-#endif // CXX_TREE_CLI_HXX
diff --git a/xsd/xsd/cxx/tree/counter.cxx b/xsd/xsd/cxx/tree/counter.cxx
index 9254226..23fc221 100644
--- a/xsd/xsd/cxx/tree/counter.cxx
+++ b/xsd/xsd/cxx/tree/counter.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/counter.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/counter.hxx>
@@ -15,40 +14,40 @@ namespace CXX
     {
       struct Member: Traversal::Member
       {
-        Member (UnsignedLong& complexity)
+        Member (size_t& complexity)
             : complexity_ (complexity)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type&)
         {
           complexity_++;
         }
 
-        UnsignedLong& complexity_;
+        size_t& complexity_;
       };
 
       struct Any: Traversal::Any, Traversal::AnyAttribute
       {
-        Any (UnsignedLong& complexity)
+        Any (size_t& complexity)
             : complexity_ (complexity)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any&)
         {
           complexity_++;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute&)
         {
           complexity_++;
         }
 
-        UnsignedLong& complexity_;
+        size_t& complexity_;
       };
 
       struct TypeBase: Traversal::List,
@@ -57,27 +56,27 @@ namespace CXX
                        Traversal::Complex,
                        Context
       {
-        TypeBase (Context& c, UnsignedLong& complexity)
+        TypeBase (Context& c, size_t& complexity)
             : Context (c), complexity_ (complexity)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::List&)
         {
           complexity_++;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Union&)
         {
           complexity_++;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Enumeration& e)
         {
-          Boolean string_based (false);
+          bool string_based (false);
           {
             IsStringBasedType t (string_based);
             t.dispatch (e);
@@ -86,7 +85,7 @@ namespace CXX
           complexity_ += (string_based ? 1 : 2);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           complexity_++; // One for the type itself.
@@ -99,14 +98,14 @@ namespace CXX
 
           names >> member;
 
-          if (options.value<CLI::generate_wildcard> ())
+          if (options.generate_wildcard ())
             names >> any;
 
           Complex::names (c, names);
         }
 
       private:
-        UnsignedLong& complexity_;
+        size_t& complexity_;
       };
 
 
@@ -120,12 +119,12 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Type& t)
         {
           counts_.global_types++;
 
-          UnsignedLong complexity (0);
+          size_t complexity (0);
           TypeBase type (*this, complexity);
           type.dispatch (t);
 
@@ -160,7 +159,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           // Check if the previous element we saw needs to be generated.
@@ -177,33 +176,33 @@ namespace CXX
         }
 
       private:
-        Void
+        void
         count_last ()
         {
           if (generate_p (*last_))
           {
             counts_.generated_global_elements++;
 
-            UnsignedLong complexity (0);
+            size_t complexity (0);
 
             if (doc_root_p (*last_))
             {
-              if (options.value<CLI::generate_element_type> ())
+              if (options.generate_element_type ())
               {
                 complexity += 1; // For c-tors and d-tor.
 
-                if (!options.value<CLI::suppress_parsing> ())
+                if (!options.suppress_parsing ())
                   complexity += 1;
 
-                if (options.value<CLI::generate_serialization> ())
+                if (options.generate_serialization ())
                   complexity += 1;
               }
               else
               {
-                if (!options.value<CLI::suppress_parsing> ())
+                if (!options.suppress_parsing ())
                   complexity += 6; // 13 parsing functions.
 
-                if (options.value<CLI::generate_serialization> ())
+                if (options.generate_serialization ())
                   complexity += 4; // 8 serialization functions.
               }
             }
@@ -230,21 +229,16 @@ namespace CXX
       };
     }
 
-    Counter::
-    Counter ()
-    {
-    }
-
     Counts Counter::
-    count (CLI::Options const& options,
+    count (options const& ops,
            SemanticGraph::Schema& tu,
            SemanticGraph::Path const& path)
     {
       Counts counts;
-      Context ctx (std::wcerr, tu, path, options, counts, false, 0, 0, 0, 0);
+      Context ctx (std::wcerr, tu, path, ops, counts, false, 0, 0, 0, 0);
 
       Traversal::Schema schema;
-      Traversal::Sources sources;
+      Sources sources;
 
       schema >> sources >> schema;
 
diff --git a/xsd/xsd/cxx/tree/counter.hxx b/xsd/xsd/cxx/tree/counter.hxx
index 726de47..ea1a3c3 100644
--- a/xsd/xsd/cxx/tree/counter.hxx
+++ b/xsd/xsd/cxx/tree/counter.hxx
@@ -1,13 +1,12 @@
 // file      : xsd/cxx/tree/counter.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_COUNTER_HXX
 #define CXX_TREE_COUNTER_HXX
 
 #include <cxx/tree/elements.hxx>
-#include <cxx/tree/cli.hxx>
+#include <cxx/tree/options.hxx>
 
 namespace CXX
 {
@@ -16,10 +15,8 @@ namespace CXX
     class Counter
     {
     public:
-      Counter (); // Dummy ctor, helps with long symbols on HP-UX.
-
       Counts
-      count (CLI::Options const&,
+      count (options const&,
              SemanticGraph::Schema&,
              SemanticGraph::Path const&);
     };
diff --git a/xsd/xsd/cxx/tree/default-value.cxx b/xsd/xsd/cxx/tree/default-value.cxx
index ff964d3..4f27d7f 100644
--- a/xsd/xsd/cxx/tree/default-value.cxx
+++ b/xsd/xsd/cxx/tree/default-value.cxx
@@ -1,11 +1,11 @@
 // file      : xsd/cxx/tree/default-value.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/default-value.hxx>
 
 using std::hex;
+using std::dec;
 
 namespace CXX
 {
@@ -13,14 +13,14 @@ namespace CXX
   {
     namespace
     {
-      Void
+      void
       normalize (String& s)
       {
-        Size n (s.size ());
+        size_t n (s.size ());
 
-        for (Size i (0); i < n; ++i)
+        for (size_t i (0); i < n; ++i)
         {
-          WideChar& c (s[i]);
+          wchar_t& c (s[i]);
 
           if (c == 0x0D || // carriage return
               c == 0x09 || // tab
@@ -29,15 +29,15 @@ namespace CXX
         }
       }
 
-      Void
+      void
       collapse (String& s)
       {
-        Size n (s.size ()), j (0);
-        Boolean subs (false), trim (true);
+        size_t n (s.size ()), j (0);
+        bool subs (false), trim (true);
 
-        for (Size i (0); i < n; ++i)
+        for (size_t i (0); i < n; ++i)
         {
-          WideChar c (s[i]);
+          wchar_t c (s[i]);
 
           if (c == 0x20 || c == 0x09 || c == 0x0A)
             subs = true;
@@ -61,21 +61,21 @@ namespace CXX
         s.resize (j);
       }
 
-      Void
+      void
       strip_zeros (String& s)
       {
-        Size n (s.size ()), i (0);
+        size_t n (s.size ()), i (0);
 
         if (n > 0 && (s[i] == '-' || s[i] == '+'))
           i++;
 
-        Size j (i);
+        size_t j (i);
 
-        Boolean strip (true);
+        bool strip (true);
 
         for (; i < n; ++i)
         {
-          WideChar c (s[i]);
+          wchar_t c (s[i]);
 
           if (c == '0')
           {
@@ -97,7 +97,7 @@ namespace CXX
         s.resize (j);
       }
 
-      Void
+      void
       make_float (String& s)
       {
         if (s.find ('.') == String::npos &&
@@ -112,13 +112,13 @@ namespace CXX
     //
 
     IsLiteralValue::
-    IsLiteralValue (Boolean& r)
+    IsLiteralValue (bool& r)
         : IsFundamentalType (r)
     {
       *this >> inherits_ >> *this;
     }
 
-    Void IsLiteralValue::
+    void IsLiteralValue::
     traverse (SemanticGraph::Complex& c)
     {
       inherits (c);
@@ -144,7 +144,7 @@ namespace CXX
       return literal_;
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Complex& c)
     {
       inherits (c);
@@ -152,7 +152,7 @@ namespace CXX
 
     // Boolean.
     //
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::Boolean&)
     {
       collapse (value_);
@@ -161,7 +161,7 @@ namespace CXX
 
     // Integral types.
     //
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::Byte&)
     {
       collapse (value_);
@@ -169,15 +169,15 @@ namespace CXX
       literal_ = value_;
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::UnsignedByte&)
     {
       collapse (value_);
       strip_zeros (value_);
-      literal_ = value_;
+      literal_ = value_ + L"U";
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::Short&)
     {
       collapse (value_);
@@ -185,15 +185,15 @@ namespace CXX
       literal_ = value_;
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::UnsignedShort&)
     {
       collapse (value_);
       strip_zeros (value_);
-      literal_ = value_;
+      literal_ = value_ + L"U";
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::Int&)
     {
       collapse (value_);
@@ -201,15 +201,15 @@ namespace CXX
       literal_ = value_;
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::UnsignedInt&)
     {
       collapse (value_);
       strip_zeros (value_);
-      literal_ = value_;
+      literal_ = value_ + L"U";
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::Long&)
     {
       collapse (value_);
@@ -218,7 +218,7 @@ namespace CXX
       literal_ += L"LL";
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::UnsignedLong&)
     {
       collapse (value_);
@@ -227,7 +227,7 @@ namespace CXX
       literal_ += L"ULL";
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::Integer&)
     {
       collapse (value_);
@@ -235,7 +235,7 @@ namespace CXX
       literal_ = value_ + L"LL";
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::NonPositiveInteger&)
     {
       collapse (value_);
@@ -243,7 +243,7 @@ namespace CXX
       literal_ = value_ + L"LL";
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::NonNegativeInteger&)
     {
       collapse (value_);
@@ -251,7 +251,7 @@ namespace CXX
       literal_ = value_ + L"ULL";
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::PositiveInteger&)
     {
       collapse (value_);
@@ -259,7 +259,7 @@ namespace CXX
       literal_ = value_ + L"ULL";
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::NegativeInteger&)
     {
       collapse (value_);
@@ -269,7 +269,7 @@ namespace CXX
 
     // Floats.
     //
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::Float& t)
     {
       collapse (value_);
@@ -297,7 +297,7 @@ namespace CXX
       }
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::Double& t)
     {
       collapse (value_);
@@ -325,7 +325,7 @@ namespace CXX
       }
     }
 
-    Void LiteralValue::
+    void LiteralValue::
     traverse (SemanticGraph::Fundamental::Decimal&)
     {
       collapse (value_);
@@ -345,43 +345,43 @@ namespace CXX
       *this >> inherits_ >> *this;
     }
 
-    Void InitKind::
+    void InitKind::
     traverse (SemanticGraph::List&)
     {
       r_ = function;
     }
 
-    Void InitKind::
+    void InitKind::
     traverse (SemanticGraph::Complex& c)
     {
       inherits (c);
     }
 
-    Void InitKind::
+    void InitKind::
     traverse (SemanticGraph::Fundamental::Base64Binary&)
     {
       r_ = data;
     }
 
-    Void InitKind::
+    void InitKind::
     traverse (SemanticGraph::Fundamental::HexBinary&)
     {
       r_ = data;
     }
 
-    Void InitKind::
+    void InitKind::
     traverse (SemanticGraph::Fundamental::NameTokens&)
     {
       r_ = function;
     }
 
-    Void InitKind::
+    void InitKind::
     traverse (SemanticGraph::Fundamental::IdRefs&)
     {
       r_ = function;
     }
 
-    Void InitKind::
+    void InitKind::
     traverse (SemanticGraph::Fundamental::Entities&)
     {
       r_ = function;
@@ -397,14 +397,14 @@ namespace CXX
     {
     }
 
-    Void InitValue::
+    void InitValue::
     dispatch (SemanticGraph::Node& type, String const& value)
     {
       value_ = value;
       Traversal::NodeBase::dispatch (type);
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::List& l)
     {
       collapse (value_);
@@ -415,9 +415,9 @@ namespace CXX
       SemanticGraph::Type& t (l.argumented ().type ());
 
       String ov (value_);
-      Size b (0);
+      size_t b (0);
 
-      for (Size e (ov.find (' ')); ; e = ov.find (' ', b))
+      for (size_t e (ov.find (' ')); ; e = ov.find (' ', b))
       {
         String v (ov, b, e != String::npos ? e - b : e);
 
@@ -448,21 +448,27 @@ namespace CXX
       value_ = ov;
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Union&)
     {
       os << strlit (value_);
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Complex& c)
     {
       Traversal::NodeBase::dispatch (ultimate_base (c));
     }
 
-    // anySimpleType.
+    // anyType & anySimpleType.
     //
-    Void InitValue::
+    void InitValue::
+    traverse (SemanticGraph::AnyType& t)
+    {
+      os << fq_name (t) << " (" << strlit (value_) << ")";
+    }
+
+    void InitValue::
     traverse (SemanticGraph::AnySimpleType& t)
     {
       os << fq_name (t) << " (" << strlit (value_) << ")";
@@ -470,34 +476,34 @@ namespace CXX
 
     // Strings.
     //
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::String&)
     {
       os << strlit (value_);
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::NormalizedString&)
     {
       normalize (value_);
       os << strlit (value_);
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Token&)
     {
       collapse (value_);
       os << strlit (value_);
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::NameToken&)
     {
       collapse (value_);
       os << strlit (value_);
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::NameTokens&)
     {
       string_sequence_type (
@@ -505,21 +511,21 @@ namespace CXX
           xs_ns ().find ("NMTOKEN").first->named ()));
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Name&)
     {
       collapse (value_);
       os << strlit (value_);
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::NCName&)
     {
       collapse (value_);
       os << strlit (value_);
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Language&)
     {
       collapse (value_);
@@ -528,10 +534,10 @@ namespace CXX
 
     // Qualified name.
     //
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::QName& t)
     {
-      Size p (value_.rfind ('#'));
+      size_t p (value_.rfind ('#'));
 
       if (p != String::npos)
       {
@@ -563,21 +569,21 @@ namespace CXX
 
     // ID/IDREF.
     //
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Id&)
     {
       collapse (value_);
       os << strlit (value_);
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::IdRef&)
     {
       collapse (value_);
       os << strlit (value_);
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::IdRefs&)
     {
       string_sequence_type (
@@ -587,7 +593,7 @@ namespace CXX
 
     // URI.
     //
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::AnyURI&)
     {
       collapse (value_);
@@ -615,7 +621,7 @@ namespace CXX
       return r;
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Base64Binary& t)
     {
       collapse (value_);
@@ -628,17 +634,17 @@ namespace CXX
 
           // Decode.
           //
-          Size size (value_.size ());
+          size_t size (value_.size ());
 
           // Remove all whitespaces.
           //
           {
-            Size j (0);
-            Boolean subs (false);
+            size_t j (0);
+            bool subs (false);
 
-            for (Size i (0); i < size; ++i)
+            for (size_t i (0); i < size; ++i)
             {
-              WideChar c (value_[i]);
+              wchar_t c (value_[i]);
 
               if (c == 0x20 || c == 0x0A || c == 0x0D || c == 0x09)
                 subs = true;
@@ -657,20 +663,20 @@ namespace CXX
 
           // Our length should be a multiple of four.
           //
-          Size quad_count (size / 4);
+          size_t quad_count (size / 4);
 
           // Source and destination indexes.
           //
-          Size si (0), di (0);
+          size_t si (0), di (0);
 
           // Process all quads except the last one.
           //
           unsigned short v;
           unsigned char b1, b2, b3, b4;
 
-          WideChar prev_fill (os.fill ('0'));
+          wchar_t prev_fill (os.fill ('0'));
 
-          for (Size q (0); q < quad_count - 1; ++q)
+          for (size_t q (0); q < quad_count - 1; ++q)
           {
             b1 = base64_decode (value_[si++]);
             b2 = base64_decode (value_[si++]);
@@ -683,17 +689,21 @@ namespace CXX
             if (di % 9 == 0)
               os << endl;
 
+            os << hex;
+
             v = static_cast<unsigned char> ((b1 << 2) | (b2 >> 4));
             os.width (2);
-            os << "0x" << hex << v;
+            os << "0x" << v;
 
             v = static_cast<unsigned char> ((b2 << 4) | (b3 >> 2));
             os.width (2);
-            os << ", 0x" << hex << v;
+            os << ", 0x" << v;
 
             v = static_cast<unsigned char> ((b3 << 6) | b4);
             os.width (2);
-            os << ", 0x" << hex << v;
+            os << ", 0x" << v;
+
+            os << dec;
 
             di += 3;
           }
@@ -703,7 +713,7 @@ namespace CXX
           b1 = base64_decode (value_[si++]);
           b2 = base64_decode (value_[si++]);
 
-          WideChar e3 (value_[si++]), e4 (value_[si++]);
+          wchar_t e3 (value_[si++]), e4 (value_[si++]);
 
           if (quad_count != 1)
             os << ", ";
@@ -718,7 +728,7 @@ namespace CXX
               // Two pads. Last 4 bits in b2 should be zero.
               //
               v = static_cast<unsigned char> ((b1 << 2) | (b2 >> 4));
-              os << "0x" << hex << v;
+              os << "0x" << hex << v << dec;
               di++;
             }
             else
@@ -727,13 +737,17 @@ namespace CXX
               //
               b3 = base64_decode (e3);
 
+              os << hex;
+
               v = static_cast<unsigned char> ((b1 << 2) | (b2 >> 4));
               os.width (2);
-              os << "0x" << hex << v;
+              os << "0x" << v;
 
               v = static_cast<unsigned char> ((b2 << 4) | (b3 >> 2));
               os.width (2);
-              os << ", 0x" << hex << v;
+              os << ", 0x" << v;
+
+              os << dec;
 
               di += 2;
             }
@@ -745,17 +759,21 @@ namespace CXX
             b3 = base64_decode (e3);
             b4 = base64_decode (e4);
 
+            os << hex;
+
             v = static_cast<unsigned char> ((b1 << 2) | (b2 >> 4));
             os.width (2);
-            os << "0x" << hex << v;
+            os << "0x" << v;
 
             v = static_cast<unsigned char> ((b2 << 4) | (b3 >> 2));
             os.width (2);
-            os << ", 0x" << hex << v;
+            os << ", 0x" << v;
 
             v = static_cast<unsigned char> ((b3 << 6) | b4);
             os.width (2);
-            os << ", 0x" << hex << v;
+            os << ", 0x" << v;
+
+            os << dec;
 
             di += 3;
           }
@@ -797,7 +815,7 @@ namespace CXX
       return r;
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::HexBinary& t)
     {
       collapse (value_);
@@ -810,10 +828,10 @@ namespace CXX
 
           // Decode.
           //
-          Size n (value_.size () / 2);
-          WideChar prev_fill (os.fill ('0'));
+          size_t n (value_.size () / 2);
+          wchar_t prev_fill (os.fill ('0'));
 
-          for (Size i (0); i < n; ++i)
+          for (size_t i (0); i < n; ++i)
           {
             unsigned char h (hex_decode (value_[2 * i]));
             unsigned char l (hex_decode (value_[2 * i + 1]));
@@ -829,7 +847,7 @@ namespace CXX
 
             unsigned short v = static_cast<unsigned char> ((h << 4) | l);
             os.width (2);
-            os << "0x" << hex << v;
+            os << "0x" << hex << v << dec;
           }
 
           os.fill (prev_fill);
@@ -856,15 +874,15 @@ namespace CXX
 
     // Date/time.
     //
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Date& t)
     {
       // date := [-]CCYY[N]*-MM-DD[Z|(+|-)HH:MM]
       //
       collapse (value_);
 
-      Size b (0);
-      Size e (value_.find ('-', value_[0] == '-' ? 5 : 4));
+      size_t b (0);
+      size_t e (value_.find ('-', value_[0] == '-' ? 5 : 4));
       String year (value_, 0, e);
 
       b = e + 1;
@@ -882,15 +900,15 @@ namespace CXX
       os << ")";
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::DateTime& t)
     {
       // date_time := [-]CCYY[N]*-MM-DDTHH:MM:SS[.S+][Z|(+|-)HH:MM]
       //
       collapse (value_);
 
-      Size b (0);
-      Size e (value_.find ('-', value_[0] == '-' ? 5 : 4));
+      size_t b (0);
+      size_t e (value_.find ('-', value_[0] == '-' ? 5 : 4));
       String year (value_, 0, e);
       b = e + 1;
 
@@ -909,7 +927,7 @@ namespace CXX
       e = b + 2;
       for (; e < value_.size (); ++e)
       {
-        WideChar c (value_[e]);
+        wchar_t c (value_[e]);
 
         if (c == 'Z' || c == '+' || c == '-')
           break;
@@ -934,12 +952,12 @@ namespace CXX
 
     namespace
     {
-      Size
-      find_delim (String const& s, Size pos)
+      size_t
+      find_delim (String const& s, size_t pos)
       {
         for (; pos < s.size (); ++pos)
         {
-          WideChar c (s[pos]);
+          wchar_t c (s[pos]);
 
           if (c == 'Y' || c == 'D' || c == 'M' || c == 'H' ||
               c == 'M' || c == 'S' || c == 'T')
@@ -950,14 +968,14 @@ namespace CXX
       }
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Duration& t)
     {
       // duration := [-]P[nY][nM][nD][TnHnMn[.n+]S]
       //
       collapse (value_);
 
-      Size b (1), e, n (value_.size ());
+      size_t b (1), e, n (value_.size ());
 
       os << fq_name (t) << " (";
 
@@ -1053,7 +1071,7 @@ namespace CXX
       os << ")";
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Day& t)
     {
       // gday := ---DD[Z|(+|-)HH:MM]
@@ -1068,7 +1086,7 @@ namespace CXX
       os << ")";
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Month& t)
     {
       // gmonth := --MM[Z|(+|-)HH:MM]
@@ -1083,7 +1101,7 @@ namespace CXX
       os << ")";
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::MonthDay& t)
     {
       // gmonth_day := --MM-DD[Z|(+|-)HH:MM]
@@ -1101,17 +1119,17 @@ namespace CXX
       os << ")";
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Year& t)
     {
       // gyear := [-]CCYY[N]*[Z|(+|-)HH:MM]
       //
       collapse (value_);
 
-      Size pos (value_[0] == '-' ? 5 : 4);
+      size_t pos (value_[0] == '-' ? 5 : 4);
       for (; pos < value_.size (); ++pos)
       {
-        WideChar c (value_[pos]);
+        wchar_t c (value_[pos]);
 
         if (c == 'Z' || c == '+' || c == '-')
           break;
@@ -1125,14 +1143,14 @@ namespace CXX
       os << ")";
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::YearMonth& t)
     {
       // gyear_month := [-]CCYY[N]*-MM[Z|(+|-)HH:MM]
       //
       collapse (value_);
 
-      Size pos (value_.find ('-', value_[0] == '-' ? 5 : 4));
+      size_t pos (value_.find ('-', value_[0] == '-' ? 5 : 4));
 
       String year (value_, 0, pos);
       String month (value_, pos + 1, 2);
@@ -1145,7 +1163,7 @@ namespace CXX
       os << ")";
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Time& t)
     {
       // time := HH:MM:SS[.S+][Z|(+|-)HH:MM]
@@ -1155,10 +1173,10 @@ namespace CXX
       String hours (value_, 0, 2);
       String minutes (value_, 3, 2);
 
-      Size e (8);
+      size_t e (8);
       for (; e < value_.size (); ++e)
       {
-        WideChar c (value_[e]);
+        wchar_t c (value_[e]);
 
         if (c == 'Z' || c == '+' || c == '-')
           break;
@@ -1176,8 +1194,8 @@ namespace CXX
       os << ")";
     }
 
-    Void InitValue::
-    time_zone (Size pos)
+    void InitValue::
+    time_zone (size_t pos)
     {
       // time_zone := Z|(+|-)HH:MM
       //
@@ -1211,14 +1229,14 @@ namespace CXX
 
     // Entity.
     //
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Entity&)
     {
       collapse (value_);
       os << strlit (value_);
     }
 
-    Void InitValue::
+    void InitValue::
     traverse (SemanticGraph::Fundamental::Entities&)
     {
       string_sequence_type (
@@ -1226,7 +1244,7 @@ namespace CXX
           xs_ns ().find ("ENTITY").first->named ()));
     }
 
-    Void InitValue::
+    void InitValue::
     string_sequence_type (SemanticGraph::Type& t)
     {
       collapse (value_);
@@ -1234,9 +1252,9 @@ namespace CXX
       if (!value_)
         return;
 
-      Size b (0);
+      size_t b (0);
 
-      for (Size e (value_.find (' ')); ; e = value_.find (' ', b))
+      for (size_t e (value_.find (' ')); ; e = value_.find (' ', b))
       {
         String v (value_, b, e != String::npos ? e - b : e);
 
diff --git a/xsd/xsd/cxx/tree/default-value.hxx b/xsd/xsd/cxx/tree/default-value.hxx
index c80132e..eb91a8c 100644
--- a/xsd/xsd/cxx/tree/default-value.hxx
+++ b/xsd/xsd/cxx/tree/default-value.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/default-value.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_DEFAULT_VALUE_HXX
@@ -17,9 +16,9 @@ namespace CXX
   {
     struct IsLiteralValue: IsFundamentalType, Traversal::Complex
     {
-      IsLiteralValue (Boolean& r);
+      IsLiteralValue (bool& r);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex&);
 
     private:
@@ -57,64 +56,64 @@ namespace CXX
 
       // Handle inheritance.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex&);
 
       // Boolean.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Boolean&);
 
       // Integral types.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Byte&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedByte&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Short&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedShort&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Int&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedInt&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Long&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedLong&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Integer&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonPositiveInteger&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonNegativeInteger&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::PositiveInteger&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NegativeInteger&);
 
       // Floats.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Float&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Double&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Decimal&);
 
     private:
@@ -148,25 +147,25 @@ namespace CXX
       //
       InitKind (Kind& r);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::List&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Base64Binary&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::HexBinary&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NameTokens&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::IdRefs&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Entities&);
 
     private:
@@ -178,6 +177,7 @@ namespace CXX
                       Traversal::Union,
                       Traversal::Complex,
 
+                      Traversal::AnyType,
                       Traversal::AnySimpleType,
 
                       Traversal::Fundamental::String,
@@ -217,133 +217,136 @@ namespace CXX
     {
       InitValue (Context&);
 
-      Void
+      void
       data (String const& data)
       {
         data_ = data;
         dispatch_count_ = 0;
       }
 
-      Void
+      void
       dispatch (SemanticGraph::Node& type, String const& value);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::List&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Union&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex&);
 
-      // anySimpleType.
+      // anyType & anySimpleType.
       //
-      virtual Void
+      virtual void
+      traverse (SemanticGraph::AnyType&);
+
+      virtual void
       traverse (SemanticGraph::AnySimpleType&);
 
       // Strings.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::String&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NormalizedString&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Token&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NameToken&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NameTokens&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Name&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NCName&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Language&);
 
       // Qualified name.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::QName&);
 
       // ID/IDREF.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Id&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::IdRef&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::IdRefs&);
 
       // URI.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::AnyURI&);
 
       // Binary.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Base64Binary&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::HexBinary&);
 
       // Date/time.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Date&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::DateTime&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Duration&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Day&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Month&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::MonthDay&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Year&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::YearMonth&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Time&);
 
       // Entity.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Entity&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Entities&);
 
     private:
-      Void
+      void
       string_sequence_type (SemanticGraph::Type& element_type);
 
-      Void
-      time_zone (Size pos);
+      void
+      time_zone (size_t pos);
 
     private:
       String value_;
       String data_;
-      Size dispatch_count_;
+      size_t dispatch_count_;
       MemberTypeName type_name_;
       LiteralValue literal_value_;
     };
diff --git a/xsd/xsd/cxx/tree/elements.cxx b/xsd/xsd/cxx/tree/elements.cxx
index cad5a33..202ab62 100644
--- a/xsd/xsd/cxx/tree/elements.cxx
+++ b/xsd/xsd/cxx/tree/elements.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/elements.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/elements.hxx>
@@ -11,55 +10,18 @@ namespace CXX
   {
     // Context
     //
-    Void Context::
-    update_ns_scope () // Keeping this function first helps HP-UX
-    {                  // (long symbols).
-      ns_scope.clear ();
-
-      Boolean first (true);
-
-      for (NamespaceStack::Iterator i (ns_scope_stack.begin ());
-           i != ns_scope_stack.end ();
-           ++i)
-      {
-        // We only qualify names until the namespace level.
-        //
-        if (first)
-          first = false;
-        else
-          ns_scope += L"::";
-
-        ns_scope += *i;
-      }
-    }
-
     Context::
     Context (std::wostream& o,
              SemanticGraph::Schema& root,
              SemanticGraph::Path const& path,
-             CLI::Options const& ops,
+             options_type const& ops,
              Counts const& counts_,
-             Boolean generate_xml_schema__,
+             bool generate_xml_schema__,
              StringLiteralMap const* map,
              Regex const* fe,
              Regex const* he,
              Regex const* ie)
-        : CXX::Context (o,
-                        root,
-                        path,
-                        map,
-                        ops.value<CLI::char_type> (),
-                        ops.value<CLI::char_encoding> (),
-                        ops.value<CLI::include_with_brackets> (),
-                        ops.value<CLI::include_prefix> (),
-                        ops.value<CLI::export_symbol> (),
-                        ops.value<CLI::namespace_map> (),
-                        ops.value<CLI::namespace_regex> (),
-                        ops.value<CLI::namespace_regex_trace> (),
-                        ops.value<CLI::include_regex> (),
-                        ops.value<CLI::include_regex_trace> (),
-                        ops.value<CLI::generate_inline> (),
-                        ops.value<CLI::reserved_name> ()),
+        : CXX::Context (o, root, path, ops, map),
           options (ops),
           counts (counts_),
           any_type (any_type_),
@@ -84,9 +46,10 @@ namespace CXX
           as_decimal_type (as_decimal_type_),
           generate_xml_schema (generate_xml_schema_),
           doxygen (doxygen_),
-          polymorphic (ops.value<CLI::generate_polymorphic> ()),
-          polymorphic_all (ops.value<CLI::polymorphic_type_all> ()),
-          detach (ops.value<CLI::generate_detach> ()),
+          polymorphic (ops.generate_polymorphic ()),
+          polymorphic_all (ops.polymorphic_type_all ()),
+          poly_plate (ops.polymorphic_plate ()),
+          detach (ops.generate_detach ()),
           fwd_expr (fe),
           hxx_expr (he),
           ixx_expr (ie),
@@ -96,7 +59,7 @@ namespace CXX
           qname_type_ (L"::xsd::cxx::xml::qualified_name< " + char_type + L" >"),
           parser_type_ (L"::xsd::cxx::xml::dom::parser< " + char_type + L" >"),
           generate_xml_schema_ (generate_xml_schema__),
-          doxygen_ (ops.value<CLI::generate_doxygen> ()),
+          doxygen_ (ops.generate_doxygen ()),
           ns_scope_stack (ns_scope_stack_),
           cxx_uq_id_expr_ (L"^[a-zA-Z_]\\w*$"),
           cxx_uq_id_expr (cxx_uq_id_expr_)
@@ -118,23 +81,25 @@ namespace CXX
         container = xs_name + L"::" + xsc.get<String> ("container");
         flags_type = xs_name + L"::" + xsc.get<String> ("flags");
 
-        if (ops.value<CLI::generate_element_type> ())
+        if (ops.generate_element_type ())
           element_type = xs_name + L"::" + xsc.get<String> ("element-type");
 
         properties_type = xs_name + L"::" + xsc.get<String> ("properties");
 
-        if (!ops.value<CLI::suppress_parsing> () ||
-            ops.value<CLI::generate_serialization> ())
+        if (!ops.suppress_parsing () || ops.generate_serialization ())
         {
           error_handler_type = xs_name + L"::" +
             xsc.get<String> ("error-handler");
         }
 
-        dom_auto_ptr_ = xs_name + L"::dom::auto_ptr";
+        dom_auto_ptr_ = xs_name + (std >= cxx_version::cxx11
+                                   ? L"::dom::unique_ptr"
+                                   : L"::dom::auto_ptr");
+
         dom_node_key_ = xs_name + L"::dom::" +
           xsc.get<String> ("tree-node-key");
 
-        if (ops.value<CLI::generate_serialization> ())
+        if (ops.generate_serialization ())
         {
           as_double_type_ = xs_name + L"::" +
             xsc.get<String> ("as-double");
@@ -152,17 +117,17 @@ namespace CXX
         // istream and ostream are templates and for now use the same
         // names regardless of the naming convention.
         //
-        if (!ops.value<CLI::generate_extraction> ().empty ())
+        if (!ops.generate_extraction ().empty ())
           istream_type = xs_name + L"::istream";
 
-        if (!ops.value<CLI::generate_insertion> ().empty ())
+        if (!ops.generate_insertion ().empty ())
           ostream_type = xs_name + L"::ostream";
       }
 
       // Xerces-C++ namespace. IntelliSense for some reason does not like
       // it fully-qualified (maybe because it's a namespace alias).
       //
-      if (ops.value<CLI::generate_intellisense> ())
+      if (ops.generate_intellisense ())
         xerces_ns = "xercesc";
       else
         xerces_ns = "::xercesc";
@@ -178,14 +143,14 @@ namespace CXX
 
       // Custom type mapping.
       //
-      typedef Containers::Vector<NarrowString> Vector;
 
       // Direct custom type mapping.
       //
       {
-        Vector const& v (ops.value<CLI::custom_type> ());
+        NarrowStrings const& v (ops.custom_type ());
 
-        for (Vector::ConstIterator i (v.begin ()), e (v.end ()); i != e; ++i)
+        for (NarrowStrings::const_iterator i (v.begin ()),
+               e (v.end ()); i != e; ++i)
         {
           String s (*i);
 
@@ -194,7 +159,7 @@ namespace CXX
 
           // Split the string in two parts at the last '='.
           //
-          Size pos (s.rfind ('='));
+          size_t pos (s.rfind ('='));
 
           // If no delimiter found then both type and base are empty.
           //
@@ -237,20 +202,21 @@ namespace CXX
       // Regex custom type mapping.
       //
       {
-        Vector const& v (ops.value<CLI::custom_type_regex> ());
+        NarrowStrings const& v (ops.custom_type_regex ());
 
-        for (Vector::ConstIterator i (v.begin ()), e (v.end ()); i != e; ++i)
+        for (NarrowStrings::const_iterator i (v.begin ()),
+               e (v.end ()); i != e; ++i)
         {
           String s (*i);
 
           if (s.empty ())
             throw InvalidCustomTypeMapping (s, "mapping string is empty");
 
-          WideChar delimiter (s[0]);
+          wchar_t delimiter (s[0]);
 
           // First get pattern.
           //
-          Size pos (s.find (delimiter, 1));
+          size_t pos (s.find (delimiter, 1));
 
           if (pos == String::npos)
             throw InvalidCustomTypeMapping (
@@ -291,7 +257,7 @@ namespace CXX
           }
 
           regex_custom_type_map.push_back (
-            RegexCustomTypeMapInfo (pat, type, base));
+            RegexCustomTypeMapInfo (WideRegexPat (pat), type, base));
         }
       }
     }
@@ -325,6 +291,7 @@ namespace CXX
           doxygen (c.doxygen),
           polymorphic (c.polymorphic),
           polymorphic_all (c.polymorphic_all),
+          poly_plate (c.poly_plate),
           detach (c.detach),
           fwd_expr (c.fwd_expr),
           hxx_expr (c.hxx_expr),
@@ -366,6 +333,7 @@ namespace CXX
           doxygen (c.doxygen),
           polymorphic (c.polymorphic),
           polymorphic_all (c.polymorphic_all),
+          poly_plate (c.poly_plate),
           detach (c.detach),
           fwd_expr (c.fwd_expr),
           hxx_expr (c.hxx_expr),
@@ -378,7 +346,29 @@ namespace CXX
     {
     }
 
-    Boolean Context::
+    void Context::
+    update_ns_scope ()
+    {
+      ns_scope.clear ();
+
+      bool first (true);
+
+      for (NamespaceStack::iterator i (ns_scope_stack.begin ());
+           i != ns_scope_stack.end ();
+           ++i)
+      {
+        // We only qualify names until the namespace level.
+        //
+        if (first)
+          first = false;
+        else
+          ns_scope += L"::";
+
+        ns_scope += *i;
+      }
+    }
+
+    bool Context::
     custom_type (SemanticGraph::Type const& t, String& r) const
     {
       String const& name (t.name ());
@@ -386,7 +376,7 @@ namespace CXX
       // First search the direct mapping.
       //
       {
-        DirectCustomTypeMap::ConstIterator i (
+        DirectCustomTypeMap::const_iterator i (
           direct_custom_type_map.find (name));
 
         if (i != direct_custom_type_map.end ())
@@ -399,7 +389,7 @@ namespace CXX
 
       // Second search the regex mapping.
       //
-      for (RegexCustomTypeMap::ConstIterator
+      for (RegexCustomTypeMap::const_iterator
              i (regex_custom_type_map.begin ()),
              e (regex_custom_type_map.end ());
            i != e; ++i)
@@ -414,7 +404,7 @@ namespace CXX
             return true;
           }
 
-          r = i->pat.merge (i->type_sub, name);
+          r = i->pat.replace (name, i->type_sub);
           return true;
         }
       }
@@ -437,7 +427,7 @@ namespace CXX
       return r;
     }
 
-    Boolean Context::
+    bool Context::
     renamed_type (SemanticGraph::Type const& t, String& r) const
     {
       String const& name (t.name ());
@@ -445,7 +435,7 @@ namespace CXX
       // First search the direct mapping.
       //
       {
-        DirectCustomTypeMap::ConstIterator i (
+        DirectCustomTypeMap::const_iterator i (
           direct_custom_type_map.find (name));
 
         if (i != direct_custom_type_map.end ())
@@ -458,7 +448,7 @@ namespace CXX
 
       // Second search the regex mapping.
       //
-      for (RegexCustomTypeMap::ConstIterator
+      for (RegexCustomTypeMap::const_iterator
              i (regex_custom_type_map.begin ()),
              e (regex_custom_type_map.end ());
            i != e; ++i)
@@ -467,7 +457,7 @@ namespace CXX
         {
           if (!i->base_sub.empty ())
           {
-            r = i->pat.merge (i->base_sub, name);
+            r = i->pat.replace (name, i->base_sub);
           }
           else
             r.clear ();
@@ -479,17 +469,17 @@ namespace CXX
       return false;
     }
 
-    Void Context::
+    void Context::
     write_annotation (SemanticGraph::Annotation& a)
     {
       String const& doc (a.documentation ());
-      WideChar const* s (doc.c_str ());
-      Size size (doc.size ());
+      wchar_t const* s (doc.c_str ());
+      size_t size (doc.size ());
 
       // Remove leading and trailing whitespaces.
       //
-      while (*s == WideChar (0x20) || *s == WideChar (0x0A) ||
-             *s == WideChar (0x0D) || *s == WideChar (0x09))
+      while (*s == wchar_t (0x20) || *s == wchar_t (0x0A) ||
+             *s == wchar_t (0x0D) || *s == wchar_t (0x09))
       {
         s++;
         size--;
@@ -497,11 +487,11 @@ namespace CXX
 
       if (size != 0)
       {
-        WideChar const* e (s + size - 1);
+        wchar_t const* e (s + size - 1);
 
         while (e > s &&
-               (*e == WideChar (0x20) || *e == WideChar (0x0A) ||
-                *e == WideChar (0x0D) || *e == WideChar (0x09)))
+               (*e == wchar_t (0x20) || *e == wchar_t (0x0A) ||
+                *e == wchar_t (0x0D) || *e == wchar_t (0x09)))
           --e;
 
         size = s <= e ? e - s + 1 : 0;
@@ -514,15 +504,15 @@ namespace CXX
         // Go over the data, forcing newline after 80 chars and adding
         // ' * ' after each new line.
         //
-        WideChar const* last_space (0);
-        WideChar const* b (s);
-        WideChar const* e (s);
-        Boolean after_newline (false);
-        Boolean rogue (false);
+        wchar_t const* last_space (0);
+        wchar_t const* b (s);
+        wchar_t const* e (s);
+        bool after_newline (false);
+        bool rogue (false);
 
         for (; e < s + size; ++e)
         {
-          UnsignedLong u (unicode_char (e)); // May advance e.
+          unsigned int u (unicode_char (e)); // May advance e.
 
           // We are going to treat \v and \f as rogue here even though
           // they can be present in C++ source code.
@@ -579,16 +569,16 @@ namespace CXX
       }
     }
 
-    Void Context::
-    write_rogue_text (WideChar const* s, Size size, Boolean rogue)
+    void Context::
+    write_rogue_text (wchar_t const* s, size_t size, bool rogue)
     {
       if (!rogue)
         os.write (s, size);
       else
       {
-        for (WideChar const* p (s); p < s + size; ++p)
+        for (wchar_t const* p (s); p < s + size; ++p)
         {
-          UnsignedLong u (unicode_char (p)); // May advance p.
+          unsigned int u (unicode_char (p)); // May advance p.
 
           // We are going to treat \v and \f as rogue here even though
           // they can be present in C++ source code.
@@ -596,36 +586,69 @@ namespace CXX
           if (u > 127 || (u < 32 && u != '\t' && u != '\n'))
             os.put ('?');
           else
-            os.put (static_cast<WideChar> (u));
+            os.put (static_cast<wchar_t> (u));
         }
       }
     }
 
-    Boolean Context::
+    bool Context::
     polymorphic_p (SemanticGraph::Type& t)
     {
+      // IDREF templates cannot be polymorphic.
+      //
+      if (!t.named_p () &&
+          (t.is_a<SemanticGraph::Fundamental::IdRef> () ||
+           t.is_a<SemanticGraph::Fundamental::IdRefs> ()))
+        return false;
+
       if (polymorphic_all)
       {
-        Boolean fund (false);
+        bool fund (false);
         IsFundamentalType test (fund);
         test.dispatch (t);
         return !fund;
       }
       else
-        return t.context ().get<Boolean> ("polymorphic");
+        return t.context ().get<bool> ("polymorphic");
+    }
+
+    bool Context::
+    anonymous_substitutes_p (SemanticGraph::Type& t)
+    {
+      // IDREF templates cannot match.
+      //
+      if (!t.named_p () &&
+          (t.is_a<SemanticGraph::Fundamental::IdRef> () ||
+           t.is_a<SemanticGraph::Fundamental::IdRefs> ()))
+        return false;
+
+      // See which elements this type classifies.
+      //
+      for (SemanticGraph::Type::ClassifiesIterator i (t.classifies_begin ()),
+             e (t.classifies_end ()); i != e; ++i)
+      {
+        if (SemanticGraph::Element* e =
+            dynamic_cast<SemanticGraph::Element*> (&i->instance ()))
+        {
+          if (e->substitutes_p ())
+            return true;
+        }
+      }
+
+      return false;
     }
 
     // GenerateDefautCtor
     //
     GenerateDefaultCtor::
-    GenerateDefaultCtor (Context& c, Boolean& generate, Boolean no_base)
+    GenerateDefaultCtor (Context& c, bool& generate, bool no_base)
         : Context (c), generate_ (generate), no_base_ (no_base)
     {
       *this >> inherits_ >> *this;
       *this >> names_ >> *this;
     }
 
-    Void GenerateDefaultCtor::
+    void GenerateDefaultCtor::
     traverse (SemanticGraph::Complex& c)
     {
       // Make sure we figure out if we have any required members before
@@ -637,38 +660,38 @@ namespace CXX
         Complex::inherits (c, inherits_);
     }
 
-    Void GenerateDefaultCtor::
+    void GenerateDefaultCtor::
     traverse (SemanticGraph::Type&)
     {
       if (!no_base_)
         generate_ = true;
     }
 
-    Void GenerateDefaultCtor::
+    void GenerateDefaultCtor::
     traverse (SemanticGraph::Enumeration&)
     {
       if (!no_base_)
         generate_ = true;
     }
 
-    Void GenerateDefaultCtor::
+    void GenerateDefaultCtor::
     traverse (SemanticGraph::Element& e)
     {
       if (!skip (e) && min (e) == 1 && max (e) == 1)
         generate_ = true;
     }
 
-    Void GenerateDefaultCtor::
+    void GenerateDefaultCtor::
     traverse (SemanticGraph::Attribute& a)
     {
       if (min (a) == 1 && !a.fixed_p ())
         generate_ = true;
     }
 
-    Void GenerateDefaultCtor::
+    void GenerateDefaultCtor::
     traverse (SemanticGraph::Any& a)
     {
-      if (options.value<CLI::generate_wildcard> () &&
+      if (options.generate_wildcard () &&
           min (a) == 1 && max (a) == 1)
         generate_ = true;
     }
@@ -677,7 +700,7 @@ namespace CXX
     // GenerateFromBaseCtor
     //
     GenerateFromBaseCtor::
-    GenerateFromBaseCtor (Context& c, Boolean& generate)
+    GenerateFromBaseCtor (Context& c, bool& generate)
         : generate_ (generate),
           custom_ (false),
           traverser_ (c, generate, custom_)
@@ -685,7 +708,7 @@ namespace CXX
       inherits_ >> traverser_;
     }
 
-    Void GenerateFromBaseCtor::
+    void GenerateFromBaseCtor::
     traverse (SemanticGraph::Complex& c)
     {
       inherits (c, inherits_);
@@ -703,14 +726,14 @@ namespace CXX
     }
 
     GenerateFromBaseCtor::Traverser::
-    Traverser (Context& c, Boolean& generate, Boolean& custom)
+    Traverser (Context& c, bool& generate, bool& custom)
         : Context (c), generate_ (generate), custom_ (custom)
     {
       *this >> inherits_ >> *this;
       *this >> names_ >> *this;
     }
 
-    Void GenerateFromBaseCtor::Traverser::
+    void GenerateFromBaseCtor::Traverser::
     traverse (SemanticGraph::Type& t)
     {
       if (!custom_)
@@ -720,7 +743,7 @@ namespace CXX
       }
     }
 
-    Void GenerateFromBaseCtor::Traverser::
+    void GenerateFromBaseCtor::Traverser::
     traverse (SemanticGraph::Complex& c)
     {
       names (c, names_);
@@ -732,24 +755,24 @@ namespace CXX
         traverse (static_cast<SemanticGraph::Type&> (c));
     }
 
-    Void GenerateFromBaseCtor::Traverser::
+    void GenerateFromBaseCtor::Traverser::
     traverse (SemanticGraph::Element& e)
     {
       if (!skip (e) && min (e) == 1 && max (e) == 1)
         generate_ = true;
     }
 
-    Void GenerateFromBaseCtor::Traverser::
+    void GenerateFromBaseCtor::Traverser::
     traverse (SemanticGraph::Attribute& a)
     {
       if (min (a) == 1 && !a.fixed_p ())
         generate_ = true;
     }
 
-    Void GenerateFromBaseCtor::Traverser::
+    void GenerateFromBaseCtor::Traverser::
     traverse (SemanticGraph::Any& a)
     {
-      if (options.value<CLI::generate_wildcard> () &&
+      if (options.generate_wildcard () &&
           min (a) == 1 && max (a) == 1)
         generate_ = true;
     }
@@ -758,10 +781,10 @@ namespace CXX
     //
     HasComplexPolyNonOptArgs::
     HasComplexPolyNonOptArgs (Context& c,
-                              Boolean base,
-                              Boolean& complex,
-                              Boolean& poly,
-                              Boolean& clash)
+                              bool base,
+                              bool& complex,
+                              bool& poly,
+                              bool& clash)
         : Context (c),
           complex_ (complex),
           poly_ (poly),
@@ -773,7 +796,7 @@ namespace CXX
       *this >> names_ >> *this;
     }
 
-    Void HasComplexPolyNonOptArgs::
+    void HasComplexPolyNonOptArgs::
     traverse (SemanticGraph::Complex& c)
     {
       // No optimizations: need to check every arg for clashes.
@@ -782,14 +805,14 @@ namespace CXX
       names (c, names_);
     }
 
-    Void HasComplexPolyNonOptArgs::
+    void HasComplexPolyNonOptArgs::
     traverse (SemanticGraph::Element& e)
     {
       if (!skip (e) && min (e) == 1 && max (e) == 1)
       {
-        Boolean poly (polymorphic && polymorphic_p (e.type ()));
+        bool poly (polymorphic && polymorphic_p (e.type ()));
 
-        Boolean simple (true);
+        bool simple (true);
         IsSimpleType t (simple);
         t.dispatch (e.type ());
 
@@ -807,15 +830,15 @@ namespace CXX
     // FromBaseCtorArg
     //
     FromBaseCtorArg::
-    FromBaseCtorArg (Context& c, ArgType at, Boolean arg)
+    FromBaseCtorArg (Context& c, CtorArgType at, bool arg)
         : Context (c), arg_type_ (at), arg_ (arg)
     {
     }
 
-    Void FromBaseCtorArg::
+    void FromBaseCtorArg::
     traverse (SemanticGraph::Any& a)
     {
-      if (!options.value<CLI::generate_wildcard> ())
+      if (!options.generate_wildcard ())
         return;
 
       if (min (a) == 1 && max (a) == 1)
@@ -830,7 +853,7 @@ namespace CXX
       }
     }
 
-    Void FromBaseCtorArg::
+    void FromBaseCtorArg::
     traverse (SemanticGraph::Element& e)
     {
       if (skip (e))
@@ -842,29 +865,29 @@ namespace CXX
 
         os << "," << endl;
 
-        Boolean auto_ptr (false);
+        bool ptr (false);
 
         switch (arg_type_)
         {
-        case arg_complex_auto_ptr:
+        case CtorArgType::complex_auto_ptr:
           {
-            Boolean simple (true);
+            bool simple (true);
             IsSimpleType t (simple);
             t.dispatch (e.type ());
-            auto_ptr = !simple;
+            ptr = !simple;
             break;
           }
-        case arg_poly_auto_ptr:
+        case CtorArgType::poly_auto_ptr:
           {
-            auto_ptr = polymorphic && polymorphic_p (e.type ());
+            ptr = polymorphic && polymorphic_p (e.type ());
             break;
           }
-        case arg_type:
+        case CtorArgType::type:
           break;
         }
 
-        if (auto_ptr)
-          os << "::std::auto_ptr< " << etype (e) << " >&";
+        if (ptr)
+          os << auto_ptr << "< " << etype (e) << " >";
         else
           os << "const " << etype (e) << "&";
 
@@ -873,7 +896,7 @@ namespace CXX
       }
     }
 
-    Void FromBaseCtorArg::
+    void FromBaseCtorArg::
     traverse (SemanticGraph::Attribute& a)
     {
       // Note that we are not going to include attributes with
@@ -895,7 +918,7 @@ namespace CXX
     // CtorArgs
     //
     CtorArgs::
-    CtorArgs (Context& c, ArgType at)
+    CtorArgs (Context& c, CtorArgType at)
         : Context (c),
           arg_type_ (at),
           base_arg_ (0),
@@ -907,7 +930,7 @@ namespace CXX
     }
 
     CtorArgs::
-    CtorArgs (Context& c, ArgType at, String& base_arg)
+    CtorArgs (Context& c, CtorArgType at, String& base_arg)
         : Context (c),
           arg_type_ (at),
           base_arg_ (&base_arg),
@@ -918,7 +941,7 @@ namespace CXX
       *this >> names_ >> *this;
     }
 
-    Void CtorArgs::
+    void CtorArgs::
     traverse (SemanticGraph::Type& t)
     {
       os << comma () << "const ";
@@ -929,13 +952,17 @@ namespace CXX
 
       if (base_arg_ != 0)
       {
-        *base_arg_ = L"_xsd_" + ename (t) + L"_base";
+        // IDREF templates don't have a name.
+        //
+        *base_arg_ = t.named_p ()
+          ? (L"_xsd_" + ename (t) + L"_base")
+          : L"_xsd_base";
 
         os << " " << *base_arg_;
       }
     }
 
-    Void CtorArgs::
+    void CtorArgs::
     traverse (SemanticGraph::Enumeration& e)
     {
       os << comma () << "const ";
@@ -952,10 +979,10 @@ namespace CXX
       }
     }
 
-    Void CtorArgs::
+    void CtorArgs::
     traverse (SemanticGraph::Any& a)
     {
-      if (!options.value<CLI::generate_wildcard> ())
+      if (!options.generate_wildcard ())
         return;
 
       if (min (a) == 1 && max (a) == 1)
@@ -967,7 +994,7 @@ namespace CXX
       }
     }
 
-    Void CtorArgs::
+    void CtorArgs::
     traverse (SemanticGraph::Element& e)
     {
       if (skip (e))
@@ -975,29 +1002,29 @@ namespace CXX
 
       if (min (e) == 1 && max (e) == 1)
       {
-        Boolean auto_ptr (false);
+        bool ptr (false);
 
         switch (arg_type_)
         {
-        case arg_complex_auto_ptr:
+        case CtorArgType::complex_auto_ptr:
           {
-            Boolean simple (true);
+            bool simple (true);
             IsSimpleType t (simple);
             t.dispatch (e.type ());
-            auto_ptr = !simple;
+            ptr = !simple;
             break;
           }
-        case arg_poly_auto_ptr:
+        case CtorArgType::poly_auto_ptr:
           {
-            auto_ptr = polymorphic && polymorphic_p (e.type ());
+            ptr = polymorphic && polymorphic_p (e.type ());
             break;
           }
-        case arg_type:
+        case CtorArgType::type:
           break;
         }
 
-        if (auto_ptr)
-          os << comma () << "::std::auto_ptr< " << etype (e) << " >&";
+        if (ptr)
+          os << comma () << auto_ptr << "< " << etype (e) << " >";
         else
           os << comma () << "const " << etype (e) << "&";
 
@@ -1006,7 +1033,7 @@ namespace CXX
       }
     }
 
-    Void CtorArgs::
+    void CtorArgs::
     traverse (SemanticGraph::Attribute& a)
     {
       // Note that we are not going to include attributes with
@@ -1025,7 +1052,7 @@ namespace CXX
     String CtorArgs::
     comma ()
     {
-      Boolean tmp (first_);
+      bool tmp (first_);
       first_ = false;
       return tmp ? "" : ",\n";
     }
@@ -1034,17 +1061,17 @@ namespace CXX
     // CtorArgsWithoutBase
     //
     CtorArgsWithoutBase::
-    CtorArgsWithoutBase (Context& c, ArgType at, Boolean arg, Boolean first)
+    CtorArgsWithoutBase (Context& c, CtorArgType at, bool arg, bool first)
         : Context (c), arg_type_ (at), arg_ (arg), first_ (first)
     {
       *this >> inherits_ >> *this;
       *this >> names_ >> *this;
     }
 
-    Void CtorArgsWithoutBase::
+    void CtorArgsWithoutBase::
     traverse (SemanticGraph::Any& a)
     {
-      if (!options.value<CLI::generate_wildcard> ())
+      if (!options.generate_wildcard ())
         return;
 
       if (min (a) == 1 && max (a) == 1)
@@ -1056,7 +1083,7 @@ namespace CXX
       }
     }
 
-    Void CtorArgsWithoutBase::
+    void CtorArgsWithoutBase::
     traverse (SemanticGraph::Element& e)
     {
       if (skip (e))
@@ -1064,29 +1091,29 @@ namespace CXX
 
       if (min (e) == 1 && max (e) == 1)
       {
-        Boolean auto_ptr (false);
+        bool ptr (false);
 
         switch (arg_type_)
         {
-        case arg_complex_auto_ptr:
+        case CtorArgType::complex_auto_ptr:
           {
-            Boolean simple (true);
+            bool simple (true);
             IsSimpleType t (simple);
             t.dispatch (e.type ());
-            auto_ptr = !simple;
+            ptr = !simple;
             break;
           }
-        case arg_poly_auto_ptr:
+        case CtorArgType::poly_auto_ptr:
           {
-            auto_ptr = polymorphic && polymorphic_p (e.type ());
+            ptr = polymorphic && polymorphic_p (e.type ());
             break;
           }
-        case arg_type:
+        case CtorArgType::type:
           break;
         }
 
-        if (auto_ptr)
-          os << comma () << "::std::auto_ptr< " << etype (e) << " >&";
+        if (ptr)
+          os << comma () << auto_ptr << "< " << etype (e) << " >";
         else
           os << comma () << "const " << etype (e) << "&";
 
@@ -1095,7 +1122,7 @@ namespace CXX
       }
     }
 
-    Void CtorArgsWithoutBase::
+    void CtorArgsWithoutBase::
     traverse (SemanticGraph::Attribute& a)
     {
       // Note that we are not going to include attributes with
@@ -1114,14 +1141,14 @@ namespace CXX
     String CtorArgsWithoutBase::
     comma ()
     {
-      Boolean tmp (first_);
+      bool tmp (first_);
       first_ = false;
       return tmp ? "" : ",\n";
     }
 
     // GlobalElementBase
     //
-    Boolean GlobalElementBase::
+    bool GlobalElementBase::
     generate_p (SemanticGraph::Element& e)
     {
       if (e.substitutes_p () && ctx_.polymorphic)
@@ -1133,44 +1160,44 @@ namespace CXX
       // If we are not generating element types nor parsing/serialization
       // code then we won't generate anything from it.
       //
-      if (!ctx_.options.value<CLI::generate_element_type> () &&
-          ctx_.options.value<CLI::suppress_parsing> () &&
-          !ctx_.options.value<CLI::generate_serialization> ())
+      if (!ctx_.options.generate_element_type () &&
+          ctx_.options.suppress_parsing () &&
+          !ctx_.options.generate_serialization ())
         return false;
 
       return true;
     }
 
-    Boolean GlobalElementBase::
+    bool GlobalElementBase::
     doc_root_p (SemanticGraph::Element& e)
     {
-      if (!ctx_.options.value<CLI::root_element_first> () &&
-          !ctx_.options.value<CLI::root_element_last> () &&
-          !ctx_.options.value<CLI::root_element_all> () &&
-          !ctx_.options.value<CLI::root_element_none> () &&
-          ctx_.options.value<CLI::root_element> ().empty ())
+      if (!ctx_.options.root_element_first () &&
+          !ctx_.options.root_element_last () &&
+          !ctx_.options.root_element_all () &&
+          !ctx_.options.root_element_none () &&
+          ctx_.options.root_element ().empty ())
         return true; // By default treat them all.
 
-      if (ctx_.options.value<CLI::root_element_none> ())
+      if (ctx_.options.root_element_none ())
         return false;
 
-      if (ctx_.options.value<CLI::root_element_all> ())
+      if (ctx_.options.root_element_all ())
         return true;
 
-      if (ctx_.options.value<CLI::root_element_first> () &&
+      if (ctx_.options.root_element_first () &&
           e.context ().count ("first") != 0)
         return true;
 
-      if (ctx_.options.value<CLI::root_element_last> () &&
+      if (ctx_.options.root_element_last () &&
           e.context ().count ("last") != 0)
         return true;
 
-      typedef Cult::Containers::Vector<NarrowString> Names;
-      Names const& names (ctx_.options.value<CLI::root_element> ());
+      NarrowStrings const& names (ctx_.options.root_element ());
 
       // Hopefully nobody will specify more than a handful of names ;-).
       //
-      for (Names::ConstIterator i (names.begin ()); i != names.end (); ++i)
+      for (NarrowStrings::const_iterator i (names.begin ());
+           i != names.end (); ++i)
       {
         String name (*i);
 
@@ -1185,8 +1212,8 @@ namespace CXX
     //
     Namespace::
     Namespace (Context& c,
-               UnsignedLong first,
-               UnsignedLong last)
+               size_t first,
+               size_t last)
         : CXX::Namespace (c, *this),
           GlobalElementBase (c),
           ctx_ (c),
@@ -1196,7 +1223,7 @@ namespace CXX
     {
     }
 
-    Void Namespace::
+    void Namespace::
     traverse (Type& ns)
     {
       using SemanticGraph::Element;
@@ -1205,7 +1232,7 @@ namespace CXX
         CXX::Namespace::traverse (ns);
       else
       {
-        Boolean opened (false);
+        bool opened (false);
 
         for (Type::NamesIterator i (ns.names_begin ());
              i != ns.names_end (); ++i)
@@ -1235,13 +1262,13 @@ namespace CXX
       }
     }
 
-    Void Namespace::
-    enter (Type&, String const& name, Boolean)
+    void Namespace::
+    enter (Type&, String const& name, bool)
     {
       ctx_.enter_ns_scope (name);
     }
 
-    Void Namespace::
+    void Namespace::
     leave ()
     {
       ctx_.leave_ns_scope ();
@@ -1249,7 +1276,7 @@ namespace CXX
 
     // Includes
     //
-    Void TypeForward::
+    void TypeForward::
     traverse (SemanticGraph::Type& t)
     {
       String const& name (ename (t));
@@ -1271,14 +1298,14 @@ namespace CXX
         os << "class " << name << ";";
     }
 
-    Void Includes::
+    void Includes::
     traverse_ (SemanticGraph::Uses& u)
     {
       // Support for weak (forward) inclusion used in the file-per-type
       // compilation model.
       //
       Type t (type_);
-      Boolean weak (u.context ().count ("weak"));
+      bool weak (u.context ().count ("weak"));
       SemanticGraph::Schema& s (u.schema ());
 
       if (weak && t == header)
@@ -1301,6 +1328,7 @@ namespace CXX
         s.context ().count ("renamed")
         ? s.context ().get<SemanticGraph::Path> ("renamed")
         : u.path ());
+      path.normalize ();
 
       // Try to use the portable representation of the path. If that
       // fails, fall back to the native representation.
@@ -1308,15 +1336,11 @@ namespace CXX
       NarrowString path_str;
       try
       {
-        path_str = path.string ();
+        path_str = path.posix_string ();
       }
       catch (SemanticGraph::InvalidPath const&)
       {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        path_str = path.native_file_string ();
-#else
         path_str = path.string ();
-#endif
       }
 
       String inc_path;
@@ -1325,25 +1349,25 @@ namespace CXX
       {
       case forward:
         {
-          inc_path = ctx_.fwd_expr->merge (path_str);
+          inc_path = ctx_.fwd_expr->replace (path_str);
           break;
         }
       case header:
       case source:
         {
-          inc_path = ctx_.hxx_expr->merge (path_str);
+          inc_path = ctx_.hxx_expr->replace (path_str);
           break;
         }
       case inline_:
         {
           if (weak)
           {
-            inc_path = ctx_.hxx_expr->merge (path_str);
+            inc_path = ctx_.hxx_expr->replace (path_str);
             ctx_.os << "#include " << ctx_.process_include_path (inc_path)
                     << endl;
           }
 
-          inc_path = ctx_.ixx_expr->merge (path_str);
+          inc_path = ctx_.ixx_expr->replace (path_str);
           break;
         }
       }
diff --git a/xsd/xsd/cxx/tree/elements.hxx b/xsd/xsd/cxx/tree/elements.hxx
index afe3951..6874e6a 100644
--- a/xsd/xsd/cxx/tree/elements.hxx
+++ b/xsd/xsd/cxx/tree/elements.hxx
@@ -1,23 +1,23 @@
 // file      : xsd/cxx/tree/elements.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_ELEMENTS_HXX
 #define CXX_TREE_ELEMENTS_HXX
 
+#include <map>
+#include <set>
+#include <deque>
+#include <vector>
 #include <sstream>
 
-#include <cult/containers/map.hxx>
-#include <cult/containers/deque.hxx>
-#include <cult/containers/vector.hxx>
+#include <cutl/re.hxx>
 
-#include <backend-elements/regex.hxx>
+#include <types.hxx>
 
 #include <cxx/elements.hxx>
 
-#include <cxx/tree/cli.hxx>
-
+#include <cxx/tree/options.hxx>
 
 namespace CXX
 {
@@ -33,15 +33,15 @@ namespace CXX
       {
       }
 
-      UnsignedLong global_types;
-      UnsignedLong global_elements;
-      UnsignedLong generated_global_elements;
+      size_t global_types;
+      size_t global_elements;
+      size_t generated_global_elements;
 
       // Complexity value for each global type and generated global
       // element, in order.
       //
-      Cult::Containers::Vector<UnsignedLong> complexity;
-      UnsignedLong complexity_total;
+      std::vector<size_t> complexity;
+      size_t complexity_total;
     };
 
     struct InvalidCustomTypeMapping
@@ -69,13 +69,63 @@ namespace CXX
       String reason_;
     };
 
+    // A set of potentially qualified XML Schema type names.
+    //
+    struct TypeNameSet
+    {
+      template <typename I>
+      TypeNameSet (I begin, I end)
+      {
+        for (; begin != end; ++begin)
+          insert (*begin);
+      }
+
+      void
+      insert (String const& name)
+      {
+        size_t p (name.rfind ('#'));
+
+        if (p == String::npos)
+          unames_.insert (name);
+        else
+          qnames_.insert (name);
+      }
+
+      bool
+      find (SemanticGraph::Type& t)
+      {
+        if (!unames_.empty ())
+        {
+          if (unames_.find (t.name ()) != unames_.end ())
+            return true;
+        }
+
+        if (!qnames_.empty ())
+        {
+          if (qnames_.find (t.scope ().name () + L"#" + t.name ()) !=
+              qnames_.end ())
+            return true;
+        }
+
+        return false;
+      }
+
+    private:
+      typedef std::set<String> StringSet;
+
+      StringSet unames_;
+      StringSet qnames_;
+    };
+
     //
     //
     class Context: public CXX::Context
     {
     public:
-      typedef BackendElements::Regex::Expression<Char> Regex;
-      typedef BackendElements::Regex::Pattern<WideChar> WideRegexPat;
+      typedef cutl::re::regexsub Regex;
+      typedef cutl::re::wregex WideRegexPat;
+
+      typedef Tree::options options_type;
 
       struct DirectCustomTypeMapInfo
       {
@@ -103,21 +153,16 @@ namespace CXX
         String base_sub;
       };
 
-      typedef
-      Cult::Containers::Vector<RegexCustomTypeMapInfo>
-      RegexCustomTypeMap;
-
-      typedef
-      Cult::Containers::Map<String, DirectCustomTypeMapInfo>
-      DirectCustomTypeMap;
+      typedef std::vector<RegexCustomTypeMapInfo> RegexCustomTypeMap;
+      typedef std::map<String, DirectCustomTypeMapInfo> DirectCustomTypeMap;
 
     public:
       Context (std::wostream& o,
                SemanticGraph::Schema& root,
                SemanticGraph::Path const& path,
-               CLI::Options const& ops,
+               options_type const& ops,
                Counts const& counts_,
-               Boolean generate_xml_schema,
+               bool generate_xml_schema,
                StringLiteralMap const*,
                Regex const* fwd_expr,
                Regex const* hxx_expr,
@@ -139,7 +184,7 @@ namespace CXX
       // populated with the custom type name or empty if the
       // original name should be used.
       //
-      Boolean
+      bool
       custom_type (SemanticGraph::Type const&, String& name) const;
 
       // Returns true if this type has been renamed as part of the
@@ -147,7 +192,7 @@ namespace CXX
       // name string is populated with the new name or empty if
       // the type should not be generated at all.
       //
-      Boolean
+      bool
       renamed_type (SemanticGraph::Type const&, String& name) const;
 
     public:
@@ -155,21 +200,43 @@ namespace CXX
       // line after 80 characters as well as "commentizing" the text by
       // adding '* ' after each newline.
       //
-      Void
+      void
       write_annotation (SemanticGraph::Annotation&);
 
       //
       //
     public:
-      Boolean
+      static bool
+      ordered_p (SemanticGraph::Type const& t)
+      {
+        return t.context ().count ("ordered") &&
+          t.context ().get<bool> ("ordered");
+      }
+
+      // Check if we are generating mixed support for this type. We only
+      // do it for ordered types.
+      //
+      static bool
+      mixed_p (SemanticGraph::Complex const& c)
+      {
+        return c.mixed_p () && ordered_p (c);
+      }
+
+      bool
       polymorphic_p (SemanticGraph::Type&);
 
-      Boolean
+      bool
       anonymous_p (SemanticGraph::Type const& t)
       {
         return t.context ().count ("anonymous");
       }
 
+      // Return true if this anonymous type is defined in an element
+      // that belongs to a substitution group.
+      //
+      bool
+      anonymous_substitutes_p (SemanticGraph::Type&);
+
       // Escaped names.
       //
     public:
@@ -329,7 +396,7 @@ namespace CXX
 
       // dom_document
       //
-      static Boolean
+      static bool
       edom_document_p (SemanticGraph::Complex const& c)
       {
         return c.context ().count ("dom-document");
@@ -341,7 +408,7 @@ namespace CXX
         return c.context ().get<String> ("dom-document");
       }
 
-      static Boolean
+      static bool
       edom_document_member_p (SemanticGraph::Complex const& c)
       {
         return c.context ().count ("dom-document-member");
@@ -368,14 +435,14 @@ namespace CXX
       }
 
     public:
-      Void
+      void
       enter_ns_scope (String const& name)
       {
         ns_scope_stack.push_back (name);
         update_ns_scope ();
       }
 
-      Void
+      void
       leave_ns_scope ()
       {
         ns_scope_stack.pop_back ();
@@ -383,18 +450,18 @@ namespace CXX
       }
 
     private:
-      Void
+      void
       update_ns_scope ();
 
     private:
       // Write text that may contain characters that we will have
       // to escape (indicated by the rogue flag).
       //
-      Void
-      write_rogue_text (WideChar const* s, Size size, Boolean rogue);
+      void
+      write_rogue_text (wchar_t const* s, size_t size, bool rogue);
 
     public:
-      CLI::Options const& options;
+      options_type const& options;
       Counts const& counts;
       String& any_type;
       String& any_simple_type;
@@ -417,11 +484,12 @@ namespace CXX
       String& as_double_type;
       String& as_decimal_type;
 
-      Boolean& generate_xml_schema;
-      Boolean& doxygen;
-      Boolean polymorphic;
-      Boolean polymorphic_all;
-      Boolean detach;
+      bool& generate_xml_schema;
+      bool& doxygen;
+      bool polymorphic;
+      bool polymorphic_all;
+      unsigned long poly_plate;
+      bool detach;
 
       Regex const* fwd_expr;
       Regex const* hxx_expr;
@@ -454,16 +522,11 @@ namespace CXX
       String as_double_type_;
       String as_decimal_type_;
 
-      Boolean generate_xml_schema_;
-      Boolean doxygen_;
+      bool generate_xml_schema_;
+      bool doxygen_;
 
-      typedef
-      Cult::Containers::Deque<String>
-      NamespaceStack;
-
-      typedef
-      Cult::Containers::Deque<String>
-      ScopeStack;
+      typedef std::deque<String> NamespaceStack;
+      typedef std::deque<String> ScopeStack;
 
       String ns_scope_;
 
@@ -501,86 +564,86 @@ namespace CXX
                               Traversal::Fundamental::Decimal
 
     {
-      IsFundamentalType (Boolean& r)
+      IsFundamentalType (bool& r)
           : r_ (r)
       {
       }
 
       // Integral types.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Byte&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedByte&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Short&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedShort&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Int&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedInt&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Long&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedLong&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Integer&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonPositiveInteger&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonNegativeInteger&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::PositiveInteger&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NegativeInteger&)
       {
         r_ = true;
@@ -588,7 +651,7 @@ namespace CXX
 
       // Boolean.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Boolean&)
       {
         r_ = true;
@@ -596,26 +659,26 @@ namespace CXX
 
       // Floats.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Float&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Double&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Decimal&)
       {
         r_ = true;
       }
 
     private:
-      Boolean& r_;
+      bool& r_;
     };
 
     // Check whether this is a string-based type.
@@ -630,19 +693,19 @@ namespace CXX
                               Traversal::Fundamental::NCName,
                               Traversal::Fundamental::Language
     {
-      IsStringBasedType (Boolean& r)
+      IsStringBasedType (bool& r)
           : r_ (r)
       {
         *this >> inherits_ >> *this;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex& c)
       {
         inherits (c, inherits_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Union&)
       {
         // Current mapping of union is string-based.
@@ -652,50 +715,50 @@ namespace CXX
 
       // Strings.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::String&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NormalizedString&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Token&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NameToken&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Name&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NCName&)
       {
         r_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Language&)
       {
         r_ = true;
       }
 
     private:
-      Boolean& r_;
+      bool& r_;
       Traversal::Inherits inherits_;
     };
 
@@ -713,7 +776,7 @@ namespace CXX
         inherits_ >> enum_;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex& c)
       {
         inherits (c, inherits_);
@@ -727,7 +790,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (e_ == 0)
@@ -820,25 +883,25 @@ namespace CXX
       {
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Type&)
       {
         abort ();
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::List& l)
       {
         os << fq_name (l);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Union& u)
       {
         os << fq_name (u);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex& c)
       {
         os << fq_name (c);
@@ -846,13 +909,13 @@ namespace CXX
 
       // anyType & anySimpleType.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::AnyType& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::AnySimpleType& t)
       {
         os << fq_name (t);
@@ -860,79 +923,79 @@ namespace CXX
 
       // Integral types.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Byte& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedByte& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Short& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedShort& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Int& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedInt& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Long& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedLong& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Integer& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonPositiveInteger& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonNegativeInteger& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::PositiveInteger& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NegativeInteger& t)
       {
         os << fq_name (t);
@@ -940,7 +1003,7 @@ namespace CXX
 
       // Boolean.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Boolean& t)
       {
         os << fq_name (t);
@@ -948,19 +1011,19 @@ namespace CXX
 
       // Floats.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Float& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Double& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Decimal& t)
       {
         os << fq_name (t);
@@ -968,49 +1031,49 @@ namespace CXX
 
       // Strings.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::String& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NormalizedString& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Token& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NameToken& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NameTokens& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Name& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NCName& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Language& t)
       {
         os << fq_name (t);
@@ -1019,7 +1082,7 @@ namespace CXX
 
       // Qualified name.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::QName& t)
       {
         os << fq_name (t);
@@ -1028,13 +1091,13 @@ namespace CXX
 
       // ID/IDREF.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Id& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::IdRef& t)
       {
         if (t.named_p ())
@@ -1054,7 +1117,7 @@ namespace CXX
         }
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::IdRefs& t)
       {
         if (t.named_p ())
@@ -1077,7 +1140,7 @@ namespace CXX
 
       // URI.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::AnyURI& t)
       {
         os << fq_name (t);
@@ -1085,13 +1148,13 @@ namespace CXX
 
       // Binary.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Base64Binary& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::HexBinary& t)
       {
         os << fq_name (t);
@@ -1100,55 +1163,55 @@ namespace CXX
 
       // Date/time.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Date& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::DateTime& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Duration& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Day& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Month& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::MonthDay& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Year& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::YearMonth& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Time& t)
       {
         os << fq_name (t);
@@ -1156,13 +1219,13 @@ namespace CXX
 
       // Entity.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Entity& t)
       {
         os << fq_name (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Entities& t)
       {
         os << fq_name (t);
@@ -1200,7 +1263,7 @@ namespace CXX
       {
       }
 
-      virtual Void
+      virtual void
       fundamental_base (SemanticGraph::Type& t)
       {
         os << "::xsd::cxx::tree::fundamental_base< " <<
@@ -1210,79 +1273,79 @@ namespace CXX
 
       // Integrals.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Byte& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedByte& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Short& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedShort& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Int& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedInt& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Long& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedLong& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Integer& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonPositiveInteger& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonNegativeInteger& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::PositiveInteger& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NegativeInteger& t)
       {
         fundamental_base (t);
@@ -1290,7 +1353,7 @@ namespace CXX
 
       // Boolean.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Boolean& t)
       {
         fundamental_base (t);
@@ -1298,13 +1361,13 @@ namespace CXX
 
       // Floats.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Float& t)
       {
         fundamental_base (t);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Double& t)
       {
         os << "::xsd::cxx::tree::fundamental_base< " <<
@@ -1313,7 +1376,7 @@ namespace CXX
           "::xsd::cxx::tree::schema_type::double_ >";
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Decimal& t)
       {
         os << "::xsd::cxx::tree::fundamental_base< " <<
@@ -1330,42 +1393,46 @@ namespace CXX
                          Traversal::Any,
                          Traversal::AnyAttribute
     {
-      IsSimpleType (Boolean& v)
+      IsSimpleType (bool& v)
           : v_ (v)
       {
         *this >> names_ >> *this;
         *this >> inherits_ >> *this;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex& c)
       {
-        names (c, names_);
+        if (c.mixed_p ())
+          v_ = false;
+
+        if (v_)
+          names (c, names_);
 
         if (v_)
           inherits (c, inherits_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Member&)
       {
         v_ = false;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Any&)
       {
         v_ = false;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::AnyAttribute&)
       {
         v_ = false;
       }
 
     private:
-      Boolean& v_;
+      bool& v_;
       Traversal::Names names_;
       Traversal::Inherits inherits_;
     };
@@ -1383,29 +1450,29 @@ namespace CXX
     {
       // generate should initially be false.
       //
-      GenerateDefaultCtor (Context&, Boolean& generate, Boolean no_base);
+      GenerateDefaultCtor (Context&, bool& generate, bool no_base);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Type&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Enumeration&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Element&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Attribute&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Any&);
 
     private:
-      Boolean& generate_;
-      Boolean no_base_;
+      bool& generate_;
+      bool no_base_;
 
     private:
       Traversal::Inherits inherits_;
@@ -1418,14 +1485,14 @@ namespace CXX
     {
       // generate should initially be false.
       //
-      GenerateFromBaseCtor (Context& c, Boolean& generate);
+      GenerateFromBaseCtor (Context& c, bool& generate);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex& c);
 
     private:
-      Boolean& generate_;
-      Boolean custom_;
+      bool& generate_;
+      bool custom_;
 
       // Note that we are not interested in anyAttribute since it is always
       // mapped to a sequence.
@@ -1437,26 +1504,26 @@ namespace CXX
                         Traversal::Any,
                         Context
       {
-        Traverser (Context& c, Boolean& generate, Boolean& custom);
+        Traverser (Context& c, bool& generate, bool& custom);
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Type&);
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex&);
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Attribute&);
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element&);
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any&);
 
       private:
-        Boolean& generate_;
-        Boolean& custom_;
+        bool& generate_;
+        bool& custom_;
 
       private:
         Traversal::Inherits inherits_;
@@ -1477,26 +1544,44 @@ namespace CXX
       // should initially be true.
       //
       HasComplexPolyNonOptArgs (Context& c,
-                                Boolean including_base,
-                                Boolean& complex,
-                                Boolean& poly,
-                                Boolean& clash);
+                                bool including_base,
+                                bool& complex,
+                                bool& poly,
+                                bool& clash);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Element&);
 
     private:
-      Boolean& complex_;
-      Boolean& poly_;
-      Boolean& clash_;
+      bool& complex_;
+      bool& poly_;
+      bool& clash_;
 
       Traversal::Inherits inherits_;
       Traversal::Names names_;
     };
 
+    // Contructor argument types.
+    //
+    struct CtorArgType
+    {
+      enum Value
+      {
+        type,
+        complex_auto_ptr,
+        poly_auto_ptr
+      };
+
+      CtorArgType (Value v = Value (0)) : v_ (v) {}
+      operator Value () const {return v_;}
+
+    private:
+      Value v_;
+    };
+
     // Immediate non-optional member. Note that AnyAttribute is always
     // mapped to a sequence.
     //
@@ -1505,27 +1590,20 @@ namespace CXX
                             Traversal::Attribute,
                             Context
     {
-      enum ArgType
-      {
-        arg_type,
-        arg_complex_auto_ptr,
-        arg_poly_auto_ptr
-      };
+      FromBaseCtorArg (Context& c, CtorArgType, bool arg);
 
-      FromBaseCtorArg (Context& c, ArgType, Boolean arg);
-
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Any&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Attribute&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Element&);
 
     private:
-      ArgType arg_type_;
-      Boolean arg_;
+      CtorArgType arg_type_;
+      bool arg_;
     };
 
     // List of all non-optional members and a simple base. Note that
@@ -1539,32 +1617,25 @@ namespace CXX
                      Traversal::Attribute,
                      Context
     {
-      enum ArgType
-      {
-        arg_type,
-        arg_complex_auto_ptr,
-        arg_poly_auto_ptr
-      };
-
       // The second version outputs the argument name and stores
       // in in the base_arg string.
       //
-      CtorArgs (Context&, ArgType);
-      CtorArgs (Context&, ArgType, String& base_arg);
+      CtorArgs (Context&, CtorArgType);
+      CtorArgs (Context&, CtorArgType, String& base_arg);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Type&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Enumeration&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Any&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Attribute&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Element&);
 
     private:
@@ -1572,10 +1643,10 @@ namespace CXX
       comma ();
 
     private:
-      ArgType arg_type_;
+      CtorArgType arg_type_;
       String base_;
       String* base_arg_;
-      Boolean first_;
+      bool first_;
 
     private:
       Traversal::Inherits inherits_;
@@ -1607,92 +1678,92 @@ namespace CXX
     {
       // generate should initially be false.
       //
-      GenerateWithoutBaseCtor (Boolean& generate)
+      GenerateWithoutBaseCtor (bool& generate)
           : generate_ (generate)
       {
         *this >> inherits_ >> *this;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::List&)
       {
         generate_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Union&)
       {
         // No default initialization.
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Complex& c)
       {
         Complex::inherits (c);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Enumeration&)
       {
         // No default initialization.
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::AnyType&)
       {
         generate_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::AnySimpleType&)
       {
         generate_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::String&)
       {
         generate_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NormalizedString&)
       {
         generate_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Token&)
       {
         generate_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NameTokens&)
       {
         generate_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::IdRefs&)
       {
         generate_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Base64Binary&)
       {
         generate_ = true;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::HexBinary&)
       {
         generate_ = true;
       }
 
     private:
-      Boolean& generate_;
+      bool& generate_;
       Traversal::Inherits inherits_;
     };
 
@@ -1706,22 +1777,15 @@ namespace CXX
                                 Traversal::Attribute,
                                 Context
     {
-      enum ArgType
-      {
-        arg_type,
-        arg_complex_auto_ptr,
-        arg_poly_auto_ptr
-      };
-
-      CtorArgsWithoutBase (Context& c, ArgType, Boolean arg, Boolean first);
+      CtorArgsWithoutBase (Context& c, CtorArgType, bool arg, bool first);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Any&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Element&);
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Attribute&);
 
     private:
@@ -1729,9 +1793,9 @@ namespace CXX
       comma ();
 
     private:
-      ArgType arg_type_;
-      Boolean arg_;
-      Boolean first_;
+      CtorArgType arg_type_;
+      bool arg_;
+      bool first_;
 
     private:
       Traversal::Inherits inherits_;
@@ -1747,10 +1811,10 @@ namespace CXX
       {
       }
 
-      Boolean
+      bool
       generate_p (SemanticGraph::Element&);
 
-      Boolean
+      bool
       doc_root_p (SemanticGraph::Element&);
 
     private:
@@ -1765,26 +1829,26 @@ namespace CXX
                       CXX::Namespace::ScopeTracker
     {
       Namespace (Context&,
-                 UnsignedLong first = 1,
-                 UnsignedLong last = 0);
+                 size_t first = 1,
+                 size_t last = 0);
 
-      virtual Void
+      virtual void
       traverse (Type&);
 
     protected:
-      virtual Void
-      enter (Type&, String const& name, Boolean last);
+      virtual void
+      enter (Type&, String const& name, bool last);
 
-      virtual Void
+      virtual void
       leave ();
 
     protected:
       Context& ctx_;
 
     private:
-      UnsignedLong first_;
-      UnsignedLong last_;
-      UnsignedLong count_;
+      size_t first_;
+      size_t last_;
+      size_t count_;
     };
 
     //
@@ -1796,8 +1860,8 @@ namespace CXX
       {
       }
 
-      virtual Void
-      enter (Type& ns, String const& name, Boolean last)
+      virtual void
+      enter (Type& ns, String const& name, bool last)
       {
         Namespace::enter (ns, name, last);
 
@@ -1823,7 +1887,7 @@ namespace CXX
       {
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Type& t);
     };
 
@@ -1841,33 +1905,33 @@ namespace CXX
       Includes (Context& c, Type type)
           : ctx_ (c),
             type_ (type),
-            forward_ (c.options.value<CLI::generate_forward> ()),
+            forward_ (c.options.generate_forward ()),
             namespace_ (c),
             type_forward_ (c)
       {
         schema_ >> schema_names_ >> namespace_ >> names_ >> type_forward_;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Imports& i)
       {
         traverse_ (i);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Includes& i)
       {
         traverse_ (i);
       }
 
     private:
-      Void
+      void
       traverse_ (SemanticGraph::Uses&);
 
     private:
       Context& ctx_;
       Type type_;
-      Boolean forward_;
+      bool forward_;
 
       Traversal::Schema schema_;
       Traversal::Names schema_names_;
@@ -1907,85 +1971,85 @@ namespace CXX
 
       // Integral types.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Byte& t)
       {
         gen_include (t, "byte.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedByte& t)
       {
         gen_include (t, "unsigned-byte.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Short& t)
       {
         gen_include (t, "short.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedShort& t)
       {
         gen_include (t, "unsigned-short.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Int& t)
       {
         gen_include (t, "int.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedInt& t)
       {
         gen_include (t, "unsigned-int.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Long& t)
       {
         if (!long_)
           long_ = gen_include (t, "long.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedLong& t)
       {
         if (!unsigned_long_)
           unsigned_long_ = gen_include (t, "unsigned-long.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Integer& t)
       {
         if (!long_)
           long_ = gen_include (t, "long.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonPositiveInteger& t)
       {
         if (!long_)
           long_ = gen_include (t, "long.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonNegativeInteger& t)
       {
         if (!unsigned_long_)
           unsigned_long_ = gen_include (t, "unsigned-long.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::PositiveInteger& t)
       {
         if (!unsigned_long_)
           unsigned_long_ = gen_include (t, "unsigned-long.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NegativeInteger& t)
       {
         if (!long_)
@@ -1994,7 +2058,7 @@ namespace CXX
 
       // Boolean.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Boolean& t)
       {
         gen_include (t, "boolean.hxx");
@@ -2002,26 +2066,26 @@ namespace CXX
 
       // Floats.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Float& t)
       {
         gen_include (t, "float.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Double& t)
       {
         gen_include (t, "double.hxx");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Decimal& t)
       {
         gen_include (t, "decimal.hxx");
       }
 
     private:
-      Boolean
+      bool
       gen_include (SemanticGraph::Type& t, String const& file)
       {
         String custom;
@@ -2046,8 +2110,8 @@ namespace CXX
 
     private:
       String prefix_;
-      Boolean long_;
-      Boolean unsigned_long_;
+      bool long_;
+      bool unsigned_long_;
     };
   }
 }
diff --git a/xsd/xsd/cxx/tree/fundamental-header.hxx b/xsd/xsd/cxx/tree/fundamental-header.hxx
index 71cfbea..925d65e 100644
--- a/xsd/xsd/cxx/tree/fundamental-header.hxx
+++ b/xsd/xsd/cxx/tree/fundamental-header.hxx
@@ -1,13 +1,13 @@
 // file      : xsd/cxx/tree/fundamental-header.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_FUNDAMENTAL_HEADER_HXX
 #define CXX_TREE_FUNDAMENTAL_HEADER_HXX
 
-#include <cult/containers/set.hxx>
-#include <cult/containers/vector.hxx>
+#include <set>
+#include <vector>
+#include <algorithm>
 
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
@@ -80,7 +80,7 @@ namespace CXX
       FundamentalNamespace (Context& c)
           : DocumentedNamespace (c),
             Context (c),
-            export_ (c.options.value<CLI::export_xml_schema> () && type_exp)
+            export_ (c.options.export_xml_schema () && type_exp)
       {
         *this >> names_ >> *this;
 
@@ -88,13 +88,13 @@ namespace CXX
           xs_ns_ = ns_name (xs_ns ());
       }
 
-      Void
+      void
       gen_typedef (String const& name,
                    String const& type,
                    String const& arg1 = L"",
                    String const& arg2 = L"",
                    String const& arg3 = L"",
-                   Boolean export_type = true)
+                   bool export_type = true)
       {
         os << "typedef " << type;
 
@@ -225,7 +225,7 @@ namespace CXX
 
       // anyType and anySimpleType
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::AnyType& t)
       {
         os << "// anyType and anySimpleType." << endl
@@ -237,11 +237,11 @@ namespace CXX
         type_ = built_in_type (t, "::xsd::cxx::tree::type");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::AnySimpleType& t)
       {
         simple_type_ = built_in_type (
-          t, L"::xsd::cxx::tree::simple_type< ", type_);
+          t, L"::xsd::cxx::tree::simple_type< " + char_type + L", ", type_);
 
         if (doxygen)
           os << "/**" << endl
@@ -259,7 +259,7 @@ namespace CXX
 
       // Integrals.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Byte& t)
       {
         os << "// 8-bit" << endl
@@ -271,14 +271,14 @@ namespace CXX
         built_in_type (t, "signed char");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedByte& t)
       {
         built_in_type (t, "unsigned char");
         os << endl;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Short& t)
       {
         os << "// 16-bit" << endl
@@ -290,14 +290,14 @@ namespace CXX
         built_in_type (t, "short");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedShort& t)
       {
         built_in_type (t, "unsigned short");
         os << endl;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Int& t)
       {
         os << "// 32-bit" << endl
@@ -309,14 +309,14 @@ namespace CXX
         built_in_type (t, "int");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedInt& t)
       {
         built_in_type (t, "unsigned int");
         os << endl;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Long& t)
       {
         os << "// 64-bit" << endl
@@ -328,14 +328,14 @@ namespace CXX
         built_in_type (t, "long long");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::UnsignedLong& t)
       {
         built_in_type (t, "unsigned long long");
         os << endl;
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Integer& t)
       {
         os << "// Supposed to be arbitrary-length integral types." << endl
@@ -347,25 +347,25 @@ namespace CXX
         built_in_type (t, "long long");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonPositiveInteger& t)
       {
         built_in_type (t, "long long");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NonNegativeInteger& t)
       {
         built_in_type (t, "unsigned long long");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::PositiveInteger& t)
       {
         built_in_type (t, "unsigned long long");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NegativeInteger& t)
       {
         built_in_type (t, "long long");
@@ -374,7 +374,7 @@ namespace CXX
 
       // Boolean.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Boolean& t)
       {
         os << "// Boolean." << endl
@@ -390,7 +390,7 @@ namespace CXX
 
       // Floats.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Float& t)
       {
         os << "// Floating-point types." << endl
@@ -402,13 +402,13 @@ namespace CXX
         built_in_type (t, "float");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Double& t)
       {
         double_ = built_in_type (t, "double");
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Decimal& t)
       {
         decimal_ = built_in_type (t, "double");
@@ -418,7 +418,7 @@ namespace CXX
 
       // Strings.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::String& t)
       {
         os << "// String types." << endl
@@ -431,7 +431,7 @@ namespace CXX
           t, L"::xsd::cxx::tree::string< " + char_type + L", ", simple_type_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NormalizedString& t)
       {
         norm_string_ = built_in_type (
@@ -440,21 +440,21 @@ namespace CXX
           string_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Token& t)
       {
         token_ = built_in_type (
           t, L"::xsd::cxx::tree::token< " + char_type + L", ", norm_string_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NameToken& t)
       {
         nmtoken_ = built_in_type (
           t, L"::xsd::cxx::tree::nmtoken< " + char_type + L", ", token_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NameTokens& t)
       {
         built_in_type (
@@ -464,21 +464,21 @@ namespace CXX
           nmtoken_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Name& t)
       {
         name_ = built_in_type (
           t, L"::xsd::cxx::tree::name< " + char_type + L", ", token_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::NCName& t)
       {
         ncname_ = built_in_type (
           t, L"::xsd::cxx::tree::ncname< " + char_type + L", ", name_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Language& t)
       {
         built_in_type (
@@ -489,7 +489,7 @@ namespace CXX
 
       // ID/IDREF.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Id& t)
       {
         os << "// ID/IDREF." << endl
@@ -502,14 +502,14 @@ namespace CXX
           t, L"::xsd::cxx::tree::id< " + char_type + L", ", ncname_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::IdRef& t)
       {
         idref_ = built_in_type (
           t, L"::xsd::cxx::tree::idref< " + char_type + L", ", ncname_, type_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::IdRefs& t)
       {
         built_in_type (
@@ -524,7 +524,7 @@ namespace CXX
 
       // URI.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::AnyURI& t)
       {
         os << "// URI." << endl
@@ -541,7 +541,7 @@ namespace CXX
 
       // Qualified name.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::QName& t)
       {
         os << "// Qualified name." << endl
@@ -562,7 +562,7 @@ namespace CXX
 
       // Binary.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Base64Binary& t)
       {
         os << "// Binary." << endl
@@ -586,7 +586,7 @@ namespace CXX
           simple_type_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::HexBinary& t)
       {
         built_in_type (
@@ -600,7 +600,7 @@ namespace CXX
 
       // Date/time.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Date& t)
       {
         os << "// Date/time." << endl
@@ -622,7 +622,7 @@ namespace CXX
           t, L"::xsd::cxx::tree::date< " + char_type + L", ", simple_type_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::DateTime& t)
       {
         built_in_type (
@@ -631,7 +631,7 @@ namespace CXX
           simple_type_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Duration& t)
       {
         built_in_type (
@@ -640,21 +640,21 @@ namespace CXX
           simple_type_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Day& t)
       {
         built_in_type (
           t, L"::xsd::cxx::tree::gday< " + char_type + L", ", simple_type_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Month& t)
       {
         built_in_type (
           t, L"::xsd::cxx::tree::gmonth< " + char_type + L", ", simple_type_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::MonthDay& t)
       {
         built_in_type (
@@ -663,14 +663,14 @@ namespace CXX
           simple_type_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Year& t)
       {
         built_in_type (
           t, L"::xsd::cxx::tree::gyear< " + char_type + L", ", simple_type_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::YearMonth& t)
       {
         built_in_type (
@@ -679,7 +679,7 @@ namespace CXX
           simple_type_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Time& t)
       {
         built_in_type (
@@ -690,7 +690,7 @@ namespace CXX
 
       // Entity.
       //
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Entity& t)
       {
         os << "// Entity." << endl
@@ -703,7 +703,7 @@ namespace CXX
           t, L"::xsd::cxx::tree::entity< " + char_type + L", ", ncname_);
       }
 
-      virtual Void
+      virtual void
       traverse (SemanticGraph::Fundamental::Entities& t)
       {
         built_in_type (
@@ -715,16 +715,27 @@ namespace CXX
         os << endl;
       }
 
-      virtual Void
+      virtual void
       post (SemanticGraph::Namespace& n)
       {
         SemanticGraph::Context& c (xs_ns ().context());
 
-        Boolean parsing (!options.value<CLI::suppress_parsing> ());
-        Boolean serialization (options.value<CLI::generate_serialization> ());
-        Boolean element_map (options.value<CLI::generate_element_map> ());
+        bool parsing (!options.suppress_parsing ());
+        bool serialization (options.generate_serialization ());
+        bool element_map (options.generate_element_map ());
 
-        if (options.value<CLI::generate_element_type> ())
+        {
+          if (doxygen)
+            os << endl
+               << "/**" << endl
+               << " * @brief Content order sequence entry." << endl
+               << " */" << endl;
+
+          gen_typedef (c.get<String> ("content-order"),
+                       "::xsd::cxx::tree::content_order");
+        }
+
+        if (options.generate_element_type ())
         {
           if (doxygen)
             os << "/**" << endl
@@ -838,7 +849,7 @@ namespace CXX
         //@@ Can't change names of ostream/istream since they are
         //   templates.
         //
-        if (!options.value<CLI::generate_insertion> ().empty ())
+        if (!options.generate_insertion ().empty ())
         {
           if (doxygen)
             os << "/**" << endl
@@ -852,7 +863,7 @@ namespace CXX
              << endl;
         }
 
-        if (!options.value<CLI::generate_extraction> ().empty ())
+        if (!options.generate_extraction ().empty ())
         {
           if (doxygen)
             os << "/**" << endl
@@ -1050,7 +1061,7 @@ namespace CXX
             L"::xsd::cxx::tree::no_prefix_mapping< " + char_type + L" >");
         }
 
-        if (options.value<CLI::generate_polymorphic> ())
+        if (options.generate_polymorphic ())
         {
           if (parsing || serialization)
           {
@@ -1145,7 +1156,8 @@ namespace CXX
              << "{";
 
           // @@ Disregarding current naming convention by using the
-          //    fixed name (no template typedef).
+          //    fixed name (even in C++11, template alias is not yet
+          //    widely supported).
           //
           if (doxygen)
             os << "/**" << endl
@@ -1155,8 +1167,12 @@ namespace CXX
             os << "// Automatic pointer for DOMDocument." << endl
                << "//" << endl;
 
-          os << "using ::xsd::cxx::xml::dom::auto_ptr;"
-             << endl;
+          if (std >= cxx_version::cxx11)
+            os << "using ::xsd::cxx::xml::dom::unique_ptr;";
+          else
+            os << "using ::xsd::cxx::xml::dom::auto_ptr;";
+
+          os << endl;
 
           if (parsing)
           {
@@ -1228,7 +1244,7 @@ namespace CXX
         {
           StringSet ns_set;
 
-          for (StringList::ConstIterator i (exports_.begin ());
+          for (StringList::const_iterator i (exports_.begin ());
                i != exports_.end (); ++i)
           {
             String const& e (*i);
@@ -1245,14 +1261,14 @@ namespace CXX
              << "namespace cxx"
              << "{";
 
-          for (StringSet::ConstIterator i (ns_set.begin ());
+          for (StringSet::const_iterator i (ns_set.begin ());
                i != ns_set.end (); ++i)
           {
             String const& ns (*i);
             String prefix (L"::xsd::cxx::" + ns);
 
-            Size n (1);
-            for (Size b (0), e (ns.find (':')); ; n++)
+            size_t n (1);
+            for (size_t b (0), e (ns.find (':')); ; n++)
             {
               os << "namespace " << String (ns, b, e)
                  << "{";
@@ -1264,7 +1280,7 @@ namespace CXX
               e = ns.find (':', b);
             }
 
-            for (StringList::ConstIterator i (exports_.begin ());
+            for (StringList::const_iterator i (exports_.begin ());
                  i != exports_.end (); ++i)
             {
               String const& e (*i);
@@ -1289,10 +1305,10 @@ namespace CXX
       }
 
     private:
-      typedef Cult::Containers::Set<String> StringSet;
-      typedef Cult::Containers::Vector<String> StringList;
+      typedef std::set<String> StringSet;
+      typedef std::vector<String> StringList;
 
-      Boolean export_;
+      bool export_;
       StringList exports_;
       StringSet exports_set_;
       String xs_ns_;
diff --git a/xsd/xsd/cxx/tree/generator.cxx b/xsd/xsd/cxx/tree/generator.cxx
index fe5286a..7a413bd 100644
--- a/xsd/xsd/cxx/tree/generator.cxx
+++ b/xsd/xsd/cxx/tree/generator.cxx
@@ -1,8 +1,22 @@
 // file      : xsd/cxx/tree/generator.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+
+#include <cutl/re.hxx>
+#include <cutl/shared-ptr.hxx>
+
+#include <cutl/compiler/code-stream.hxx>
+#include <cutl/compiler/cxx-indenter.hxx>
+#include <cutl/compiler/sloc-counter.hxx>
+
+#include <xsd-frontend/semantic-graph.hxx>
+#include <xsd-frontend/generators/dependencies.hxx>
+
 #include <cxx/tree/generator.hxx>
 
 #include <cxx/tree/elements.hxx>
@@ -10,6 +24,7 @@
 #include <cxx/tree/counter.hxx>
 #include <cxx/tree/validator.hxx>
 #include <cxx/tree/name-processor.hxx>
+#include <cxx/tree/order-processor.hxx>
 #include <cxx/tree/polymorphism-processor.hxx>
 
 #include <cxx/tree/tree-forward.hxx>
@@ -30,45 +45,25 @@
 #include <cxx/tree/stream-insertion-source.hxx>
 #include <cxx/tree/stream-extraction-source.hxx>
 
-#include <xsd-frontend/semantic-graph.hxx>
-
-#include <backend-elements/regex.hxx>
-#include <backend-elements/indentation/cxx.hxx>
-#include <backend-elements/indentation/sloc.hxx>
-#include <backend-elements/indentation/clip.hxx>
-
-#include <cult/containers/set.hxx>
-#include <cult/containers/vector.hxx>
-
-#include <boost/filesystem/fstream.hpp>
-
-#include <iostream>
-
-#include <usage.hxx>
+#include <cxx/tree/options.hxx>
 
 #include "../../../libxsd/xsd/cxx/version.hxx"
 
-using std::endl;
-using std::wcerr;
-
+using namespace std;
+using namespace cutl;
 using namespace XSDFrontend::SemanticGraph;
 
 //
 //
-typedef
-boost::filesystem::wifstream
-WideInputFileStream;
-
-typedef
-boost::filesystem::wofstream
-WideOutputFileStream;
+typedef std::wifstream WideInputFileStream;
+typedef std::wofstream WideOutputFileStream;
 
 namespace CXX
 {
   namespace
   {
-    Char const copyright_gpl[] =
-    "// Copyright (C) 2005-2010 Code Synthesis Tools CC\n"
+    char const copyright_gpl[] =
+    "// Copyright (c) 2005-2014 Code Synthesis Tools CC\n"
     "//\n"
     "// This program was generated by CodeSynthesis XSD, an XML Schema to\n"
     "// C++ data binding compiler.\n"
@@ -101,8 +96,8 @@ namespace CXX
     "// in the accompanying FLOSSE file.\n"
     "//\n\n";
 
-    Char const copyright_proprietary[] =
-    "// Copyright (C) 2005-2010 Code Synthesis Tools CC\n"
+    char const copyright_proprietary[] =
+    "// Copyright (c) 2005-2014 Code Synthesis Tools CC\n"
     "//\n"
     "// This program was generated by CodeSynthesis XSD, an XML Schema\n"
     "// to C++ data binding compiler, in the Proprietary License mode.\n"
@@ -112,673 +107,23 @@ namespace CXX
     "//\n\n";
   }
 
-  namespace Tree
-  {
-    namespace CLI
-    {
-      extern Key char_type                = "char-type";
-      extern Key char_encoding            = "char-encoding";
-      extern Key output_dir               = "output-dir";
-      extern Key generate_polymorphic     = "generate-polymorphic";
-      extern Key polymorphic_type         = "polymorphic-type";
-      extern Key polymorphic_type_all     = "polymorphic-type-all";
-      extern Key generate_serialization   = "generate-serialization";
-      extern Key generate_inline          = "generate-inline";
-      extern Key generate_ostream         = "generate-ostream";
-      extern Key generate_doxygen         = "generate-doxygen";
-      extern Key generate_comparison      = "generate-comparison";
-      extern Key generate_default_ctor    = "generate-default-ctor";
-      extern Key generate_from_base_ctor  = "generate-from-base-ctor";
-      extern Key generate_detach          = "generate-detach";
-      extern Key generate_wildcard        = "generate-wildcard";
-      extern Key generate_insertion       = "generate-insertion";
-      extern Key generate_extraction      = "generate-extraction";
-      extern Key generate_forward         = "generate-forward";
-      extern Key generate_xml_schema      = "generate-xml-schema";
-      extern Key extern_xml_schema        = "extern-xml-schema";
-      extern Key suppress_parsing         = "suppress-parsing";
-      extern Key generate_element_type    = "generate-element-type";
-      extern Key generate_element_map     = "generate-element-map";
-      extern Key generate_intellisense    = "generate-intellisense";
-      extern Key omit_default_attributes  = "omit-default-attributes";
-      extern Key namespace_map            = "namespace-map";
-      extern Key namespace_regex          = "namespace-regex";
-      extern Key namespace_regex_trace    = "namespace-regex-trace";
-      extern Key reserved_name            = "reserved-name";
-      extern Key type_naming              = "type-naming";
-      extern Key function_naming          = "function-naming";
-      extern Key type_regex               = "type-regex";
-      extern Key accessor_regex           = "accessor-regex";
-      extern Key one_accessor_regex       = "one-accessor-regex";
-      extern Key opt_accessor_regex       = "opt-accessor-regex";
-      extern Key seq_accessor_regex       = "seq-accessor-regex";
-      extern Key modifier_regex           = "modifier-regex";
-      extern Key one_modifier_regex       = "one-modifier-regex";
-      extern Key opt_modifier_regex       = "opt-modifier-regex";
-      extern Key seq_modifier_regex       = "seq-modifier-regex";
-      extern Key parser_regex             = "parser-regex";
-      extern Key serializer_regex         = "serializer-regex";
-      extern Key enumerator_regex         = "enumerator-regex";
-      extern Key element_type_regex       = "element-type-regex";
-      extern Key name_regex_trace         = "name-regex-trace";
-      extern Key include_with_brackets    = "include-with-brackets";
-      extern Key include_prefix           = "include-prefix";
-      extern Key include_regex            = "include-regex";
-      extern Key include_regex_trace      = "include-regex-trace";
-      extern Key guard_prefix             = "guard-prefix";
-      extern Key root_element_first       = "root-element-first";
-      extern Key root_element_last        = "root-element-last";
-      extern Key root_element_all         = "root-element-all";
-      extern Key root_element_none        = "root-element-none";
-      extern Key root_element             = "root-element";
-      extern Key custom_type              = "custom-type";
-      extern Key custom_type_regex        = "custom-type-regex";
-      extern Key hxx_suffix               = "hxx-suffix";
-      extern Key ixx_suffix               = "ixx-suffix";
-      extern Key cxx_suffix               = "cxx-suffix";
-      extern Key fwd_suffix               = "fwd-suffix";
-      extern Key hxx_regex                = "hxx-regex";
-      extern Key ixx_regex                = "ixx-regex";
-      extern Key cxx_regex                = "cxx-regex";
-      extern Key fwd_regex                = "fwd-regex";
-      extern Key hxx_prologue             = "hxx-prologue";
-      extern Key ixx_prologue             = "ixx-prologue";
-      extern Key cxx_prologue             = "cxx-prologue";
-      extern Key fwd_prologue             = "fwd-prologue";
-      extern Key prologue                 = "prologue";
-      extern Key hxx_epilogue             = "hxx-epilogue";
-      extern Key ixx_epilogue             = "ixx-epilogue";
-      extern Key cxx_epilogue             = "cxx-epilogue";
-      extern Key fwd_epilogue             = "fwd-epilogue";
-      extern Key epilogue                 = "epilogue";
-      extern Key hxx_prologue_file        = "hxx-prologue-file";
-      extern Key ixx_prologue_file        = "ixx-prologue-file";
-      extern Key cxx_prologue_file        = "cxx-prologue-file";
-      extern Key fwd_prologue_file        = "fwd-prologue-file";
-      extern Key prologue_file            = "prologue-file";
-      extern Key hxx_epilogue_file        = "hxx-epilogue-file";
-      extern Key ixx_epilogue_file        = "ixx-epilogue-file";
-      extern Key cxx_epilogue_file        = "cxx-epilogue-file";
-      extern Key fwd_epilogue_file        = "fwd-epilogue-file";
-      extern Key epilogue_file            = "epilogue-file";
-      extern Key parts                    = "parts";
-      extern Key parts_suffix             = "parts-suffix";
-      extern Key export_symbol            = "export-symbol";
-      extern Key export_xml_schema        = "export-xml-schema";
-      extern Key export_maps              = "export-maps";
-      extern Key import_maps              = "import-maps";
-      extern Key show_anonymous           = "show-anonymous";
-      extern Key show_sloc                = "show-sloc";
-      extern Key proprietary_license      = "proprietary-license";
-      extern Key disable_multi_import     = "disable-multi-import";
-    }
-  }
-
-  Void Tree::Generator::
+  void Tree::Generator::
   usage ()
   {
-    std::wostream& e (wcerr);
-    ::CLI::Indent::Clip< ::CLI::OptionsUsage, WideChar> clip (e);
-
-    e << "--char-type <type>" << endl
-      << " Use <type> as the base character type. Valid\n"
-      << " values are 'char' (default) and 'wchar_t'."
-      << endl;
-
-    e << "--char-encoding <enc>" << endl
-      << " Specify the character encoding that should be used\n"
-      << " in the object model. Valid values for the 'char'\n"
-      << " character type are 'utf8' (default), 'iso8859-1',\n"
-      << " 'lcp', and 'custom'. For the 'wchar_t' character\n"
-      << " type the only valid value is 'auto'."
-      << endl;
-
-    e << "--output-dir <dir>" << endl
-      << " Write generated files to <dir> instead of current\n"
-      << " directory."
-      << endl;
-
-    e << "--generate-polymorphic" << endl
-      << " Generate polymorphism-aware code. Specify this\n"
-      << " option if you use substitution groups or xsi:type."
-      << endl;
-
-    e << "--polymorphic-type <type>" << endl
-      << " Indicate that <type> is a root of a polymorphic\n"
-      << " type hierarchy."
-      << endl;
-
-    e << "--polymorphic-type-all" << endl
-      << " Indicate that all types should be treated as\n"
-      << " polymorphic."
-      << endl;
-
-    e << "--generate-serialization" << endl
-      << " Generate serialization functions. They convert an\n"
-      << " in-memory representation back to XML."
-      << endl;
-
-    e << "--generate-inline" << endl
-      << " Generate certain functions inline."
-      << endl;
-
-    e << "--generate-ostream" << endl
-      << " Generate ostream insertion operators."
-      << endl;
-
-    e << "--generate-doxygen" << endl
-      << " Generate documentation comments in the Doxygen\n"
-      << " format."
-      << endl;
-
-    e << "--generate-comparison" << endl
-      << " Generate comparison operators."
-      << endl;
-
-    e << "--generate-default-ctor" << endl
-      << " Generate default constructors even for types that\n"
-      << " have required members."
-      << endl;
-
-    e << "--generate-from-base-ctor" << endl
-      << " Generate from-base constructors."
-      << endl;
-
-    e << "--generate-detach" << endl
-      << " Generate detach functions for required members."
-      << endl;
-
-    e << "--generate-wildcard" << endl
-      << " Generate accessors/modifiers as well as parsing\n"
-      << " and serialization code for XML Schema wildcards."
-      << endl;
-
-    e << "--generate-insertion <os>" << endl
-      << " Generate data representation stream insertion\n"
-      << " operators for the <os> output stream type."
-      << endl;
-
-    e << "--generate-extraction <is>" << endl
-      << " Generate data representation stream extraction\n"
-      << " constructors for the <is> input stream type."
-      << endl;
-
-    e << "--generate-forward" << endl
-      << " Generate forward declaration file."
-      << endl;
-
-    e << "--generate-xml-schema" << endl
-      << " Generate a C++ header file as if the schema being\n"
-      << " compiled defines the XML Schema namespace."
-      << endl;
-
-    e << "--extern-xml-schema <file>" << endl
-      << " Generate code as if the XML Schema namespace was\n"
-      << " defined in <file> and xsd:included in the schema\n"
-      << " being compiled."
-      << endl;
-
-    e << "--suppress-parsing" << endl
-      << " Suppress the generation of parsing functions."
-      << endl;
-
-    e << "--generate-element-type" << endl
-      << " Generate types instead of parsing/serialization\n"
-      << " functions for root elements."
-      << endl;
-
-    e << "--generate-element-map" << endl
-      << " Generate a root element map that allows uniform\n"
-      << " parsing/serialization of multiple root elements.\n"
-      << endl;
-
-    e << "--generate-intellisense" << endl
-      << " Generate workarounds for IntelliSense bugs in\n"
-      << " Visual Studio 2005 (8.0)."
-      << endl;
-
-    e << "--omit-default-attributes" << endl
-      << " Omit attributes with default and fixed values\n"
-      << " from serialized XML documents."
-      << endl;
-
-    e << "--namespace-map <xns>=<cns>" << endl
-      << " Map XML Schema namespace <xns> to C++ namespace\n"
-      << " <cns>. Repeat this option to specify mapping for\n"
-      << " more than one XML Schema namespace."
-      << endl;
-
-    e << "--namespace-regex <regex>" << endl
-      << " Add <regex> to the list of regular expressions\n"
-      << " used to translate XML Schema namespace names to\n"
-      << " C++ namespace names."
-      << endl;
-
-    e << "--namespace-regex-trace" << endl
-      << " Trace the process of applying regular expressions\n"
-      << " specified with the --namespace-regex option."
-      << endl;
-
-    e << "--reserved-name <name>" << endl
-      << " Add <name> to the list of names that should not\n"
-      << " be used as identifiers. The name can optionally\n"
-      << " be followed by '=' and the replacement name that\n"
-      << " should be used instead."
-      << endl;
-
-    e << "--type-naming <style>" << endl
-      << " Specify the type naming convention that should be\n"
-      << " used in the generated code. Valid styles are 'knr'\n"
-      << " (default), 'ucc', and 'java'."
-      << endl;
-
-    e << "--function-naming <style>" << endl
-      << " Specify the function naming convention that should\n"
-      << " be used in the generated code. Valid styles are\n"
-      << " 'knr' (default), 'lcc', and 'java'."
-      << endl;
-
-    e << "--type-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema type names to C++\n"
-      << " type names."
-      << endl;
-
-    e << "--accessor-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements and\n"
-      << " attributes to C++ accessor function names."
-      << endl;
-
-    e << "--one-accessor-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements\n"
-      << " and attributes with cardinality one to C++\n"
-      << " accessor function names."
-      << endl;
-
-    e << "--opt-accessor-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements\n"
-      << " and attributes with cardinality optional to C++\n"
-      << " accessor function names."
-      << endl;
-
-    e << "--seq-accessor-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements\n"
-      << " and attributes with cardinality sequence to C++\n"
-      << " accessor function names."
-      << endl;
-
-    e << "--modifier-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements and\n"
-      << " attributes to C++ modifier function names."
-      << endl;
-
-    e << "--one-modifier-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements\n"
-      << " and attributes with cardinality one to C++\n"
-      << " modifier function names."
-      << endl;
-
-    e << "--opt-modifier-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements\n"
-      << " and attributes with cardinality optional to C++\n"
-      << " modifier function names."
-      << endl;
-
-    e << "--seq-modifier-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements\n"
-      << " and attributes with cardinality sequence to C++\n"
-      << " modifier function names."
-      << endl;
-
-    e << "--parser-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema element names to\n"
-      << " C++ parsing function names."
-      << endl;
-
-    e << "--serializer-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema element names to\n"
-      << " C++ serialization function names."
-      << endl;
-
-    e << "--enumerator-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema enumeration values\n"
-      << " to C++ enumerator names."
-      << endl;
-
-    e << "--element-type-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema element names to\n"
-      << " C++ element type names."
-      << endl;
-
-    e << "--name-regex-trace" << endl
-      << " Trace the process of applying regular expressions\n"
-      << " specified with the name transformation options."
-      << endl;
-
-    e << "--include-with-brackets" << endl
-      << " Use angle brackets (<>) instead of quotes (\"\") in\n"
-      << " generated #include directives."
-      << endl;
-
-    e << "--include-prefix <prefix>" << endl
-      << " Add <prefix> to generated #include directive\n"
-      << " paths."
-      << endl;
-
-    e << "--include-regex <regex>" << endl
-      << " Add <regex> to the list of regular expressions\n"
-      << " used to transform #include directive paths."
-      << endl;
-
-    e << "--include-regex-trace" << endl
-      << " Trace the process of applying regular expressions\n"
-      << " specified with the --include-regex option."
-      << endl;
-
-    e << "--guard-prefix <prefix>" << endl
-      << " Add <prefix> to generated header inclusion guards."
-      << endl;
-
-    e << "--root-element-first" << endl
-      << " Treat only the first global element as a document\n"
-      << " root."
-      << endl;
-
-    e << "--root-element-last" << endl
-      << " Treat only the last global element as a document\n"
-      << " root."
-      << endl;
-
-    e << "--root-element-all" << endl
-      << " Treat all global elements as document roots."
-      << endl;
-
-    e << "--root-element-none" << endl
-      << " Don't treat any global elements as document roots."
-      << endl;
-
-    e << "--root-element <element>" << endl
-      << " Treat only <element> as a document root. Repeat\n"
-      << " this option to specify more than one root element."
-      << endl;
-
-    e << "--custom-type <map>" << endl
-      << " Use a custom C++ type instead of the generated\n"
-      << " class. The <map> argument is in the form\n"
-      << " name[=type[/base]], where <name> is a type name as\n"
-      << " defined in XML Schema, <type> is a C++ type name\n"
-      << " that should be used instead, and optional <base>\n"
-      << " is a C++ name that should be given to the C++\n"
-      << " class generated from the XML Schema definition\n"
-      << " which is normally used as a base for the custom\n"
-      << " type."
-      << endl;
-
-    e << "--custom-type-regex <regex>" << endl
-      << " Use custom C++ types instead of the generated\n"
-      << " classes. The <regex> argument is in the form\n"
-      << " /name/[type/[base/]], where <name> is a regex\n"
-      << " pattern that will be matched against type names\n"
-      << " as defined in XML Schema, <type> is a C++ type\n"
-      << " name that should be used instead, and optional\n"
-      << " <base> is a C++ name that should be given to\n"
-      << " the C++ class generated from the XML Schema\n"
-      << " definition."
-      << endl;
-
-    e << "--hxx-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '.hxx' to\n"
-      << " construct the name of the header file."
-      << endl;
-
-    e << "--ixx-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '.ixx' to\n"
-      << " construct the name of the inline file."
-      << endl;
-
-    e << "--cxx-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '.cxx' to\n"
-      << " construct the name of the source file."
-      << endl;
-
-    e << "--fwd-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '-fwd.hxx'\n"
-      << " to construct the name of the forward declaration\n"
-      << " file."
-      << endl;
-
-    e << "--hxx-regex <regex>" << endl
-      << " Use <regex> to construct the name of the header\n"
-      << " file."
-      << endl;
-
-    e << "--ixx-regex <regex>" << endl
-      << " Use <regex> to construct the name of the inline\n"
-      << " file."
-      << endl;
-
-    e << "--cxx-regex <regex>" << endl
-      << " Use <regex> to construct the name of the source\n"
-      << " file."
-      << endl;
-
-    e << "--fwd-regex <regex>" << endl
-      << " Use <regex> to construct the name of the forward\n"
-      << " declaration file."
-      << endl;
-
-    // Prologues.
-    //
-    e << "--hxx-prologue <text>" << endl
-      << " Insert <text> at the beginning of the header file."
-      << endl;
-
-    e << "--ixx-prologue <text>" << endl
-      << " Insert <text> at the beginning of the inline file."
-      << endl;
-
-    e << "--cxx-prologue <text>" << endl
-      << " Insert <text> at the beginning of the source file."
-      << endl;
-
-    e << "--fwd-prologue <text>" << endl
-      << " Insert <text> at the beginning of the forward\n"
-      << " declaration file."
-      << endl;
-
-    e << "--prologue <text>" << endl
-      << " Insert <text> at the beginning of each generated\n"
-      << " file for which there is no file-specific prologue."
-      << endl;
-
-
-    // Epilogues.
-    //
-    e << "--hxx-epilogue <text>" << endl
-      << " Insert <text> at the end of the header file."
-      << endl;
-
-    e << "--ixx-epilogue <text>" << endl
-      << " Insert <text> at the end of the inline file."
-      << endl;
-
-    e << "--cxx-epilogue <text>" << endl
-      << " Insert <text> at the end of the source file."
-      << endl;
-
-    e << "--fwd-epilogue <text>" << endl
-      << " Insert <text> at the end of the forward\n"
-      << " declaration file."
-      << endl;
-
-    e << "--epilogue <text>" << endl
-      << " Insert <text> at the end of each generated file\n"
-      << " for which there is no file-specific epilogue."
-      << endl;
-
-
-    // Prologue files.
-    //
-    e << "--hxx-prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of the header file."
-      << endl;
-
-    e << "--ixx-prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of the inline file."
-      << endl;
-
-    e << "--cxx-prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of the source file."
-      << endl;
-
-    e << "--fwd-prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of the forward declaration file."
-      << endl;
-
-    e << "--prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of each generated file for which there is no file-\n"
-      << " specific prologue file."
-      << endl;
-
-    // Epilogue files.
-    //
-    e << "--hxx-epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " the header file."
-      << endl;
-
-    e << "--ixx-epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " the inline file."
-      << endl;
-
-    e << "--cxx-epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " the source file."
-      << endl;
-
-    e << "--fwd-epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " the forward declaration file."
-      << endl;
-
-    e << "--epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " each generated file for which there is no file-\n"
-      << " specific epilogue file."
-      << endl;
-
-    // Misc.
-    //
-    e << "--parts <num>" << endl
-      << " Split generated source code into <num> parts."
-      << endl;
-
-    e << "--parts-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '-' to\n"
-      << " separate the file name from the part number."
-      << endl;
-
-    e << "--custom-literals <file>" << endl
-      << " Load custom XML string to C++ literal mappings\n"
-      << " from <file>."
-      << endl;
-
-    e << "--export-symbol <symbol>" << endl
-      << " Export symbol for Win32 DLL export/import control."
-      << endl;
-
-    e << "--export-xml-schema" << endl
-      << " Export/import types in the XML Schema namespace."
-      << endl;
-
-    e << "--export-maps" << endl
-      << " Export polymorphism support maps from Win32 DLL."
-      << endl;
-
-    e << "--import-maps" << endl
-      << " Import polymorphism support maps from Win32 DLL."
-      << endl;
-
-    e << "--show-anonymous" << endl
-      << " Show elements and attributes that are of anonymous\n"
-      << " types."
-      << endl;
-
-    e << "--show-sloc" << endl
-      << " Show the number of generated physical source lines\n"
-      << " of code (SLOC)."
-      << endl;
-
-    e << "--sloc-limit <num>" << endl
-      << " Check that the number of generated physical source\n"
-      << " lines of code (SLOC) does not exceed <num>."
-      << endl;
-
-    e << "--options-file <file>" << endl
-      << " Read additional options from <file>. Each option\n"
-      << " should appear on a separate line optionally\n"
-      << " followed by space and an argument."
-      << endl;
-
-    e << "--proprietary-license" << endl
-      << " Indicate that the generated code is licensed under\n"
-      << " a proprietary license instead of the GPL."
-      << endl;
+    CXX::Tree::options::print_usage (wcout);
+    CXX::options::print_usage (wcout);
   }
 
-  Tree::CLI::OptionsSpec Tree::Generator::
-  options_spec ()
-  {
-    CLI::OptionsSpec spec;
-
-    spec.option<CLI::char_type> ().default_value ("char");
-
-    spec.option<CLI::hxx_suffix> ().default_value (".hxx");
-    spec.option<CLI::ixx_suffix> ().default_value (".ixx");
-    spec.option<CLI::cxx_suffix> ().default_value (".cxx");
-    spec.option<CLI::fwd_suffix> ().default_value ("-fwd.hxx");
-
-    spec.option<CLI::type_naming> ().default_value ("knr");
-    spec.option<CLI::function_naming> ().default_value ("knr");
-
-    spec.option<CLI::parts> ().default_value (1);
-    spec.option<CLI::parts_suffix> ().default_value ("-");
-
-    return spec;
-  }
-
-
   namespace
   {
-    Void
+    void
     open (WideInputFileStream& ifs, NarrowString const& path)
     {
       try
       {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        Path fs_path (path, boost::filesystem::native);
-#else
-        Path fs_path (path.c_str());
-#endif
-        ifs.open (fs_path, std::ios_base::in | std::ios_base::binary);
+        Path fs_path (path);
+        ifs.open (fs_path.string ().c_str (),
+                  std::ios_base::in | std::ios_base::binary);
 
         if (!ifs.is_open ())
         {
@@ -797,7 +142,7 @@ namespace CXX
       }
     }
 
-    Void
+    void
     append (WideOutputFileStream& os,
             NarrowString const& path,
             WideInputFileStream& default_is)
@@ -817,16 +162,15 @@ namespace CXX
       }
     }
 
-    Void
+    void
     append (WideOutputFileStream& os,
-            Cult::Containers::Vector<NarrowString> const& primary,
-            Cult::Containers::Vector<NarrowString> const& def)
+            NarrowStrings const& primary,
+            NarrowStrings const& def)
     {
-      Cult::Containers::Vector<NarrowString> const& v (
-        primary.empty () ? def : primary);
+      NarrowStrings const& v (primary.empty () ? def : primary);
 
-      for (Containers::Vector<NarrowString>::ConstIterator
-             i (v.begin ()), e (v.end ()); i != e; ++i)
+      for (NarrowStrings::const_iterator i (v.begin ()), e (v.end ());
+           i != e; ++i)
       {
         os << i->c_str () << endl;
       }
@@ -834,34 +178,30 @@ namespace CXX
   }
 
 
-  UnsignedLong Tree::Generator::
-  generate (Tree::CLI::Options const& ops,
+  size_t Tree::Generator::
+  generate (Tree::options const& ops,
             Schema& schema,
             Path const& file_path,
-            Boolean fpt,
+            bool fpt,
             StringLiteralMap const& string_literal_map,
             const WarningSet& disabled_warnings,
             FileList& file_list,
             AutoUnlinks& unlinks)
   {
-    using std::ios_base;
-    namespace Indentation = BackendElements::Indentation;
-
-    typedef BackendElements::Regex::Expression<Char> Regex;
-
-    using Cult::Containers::Vector;
+    using cutl::shared_ptr;
+    typedef cutl::re::regexsub Regex;
 
-    typedef Vector<Path> Paths;
-    typedef Vector<Evptr<WideOutputFileStream> > WideOutputFileStreams;
+    typedef vector<Path> Paths;
+    typedef vector<shared_ptr<WideOutputFileStream> > WideOutputFileStreams;
 
     try
     {
       // Do option validation.
       //
-      if (ops.value<CLI::parts> () < 1)
+      if (ops.parts () < 1)
       {
         wcerr << "error: invalid value for option --parts: " <<
-          ops.value<CLI::parts> () << endl;
+          ops.parts () << endl;
         throw Failed ();
       }
 
@@ -893,8 +233,20 @@ namespace CXX
           throw Failed ();
       }
 
+      bool gen_cxx (!ops.generate_dep_only ());
+
+      // Process ordered types.
+      //
+      if (gen_cxx)
+      {
+        OrderProcessor proc;
+        if (!proc.process (ops, schema, file_path))
+          throw Failed ();
+      }
+
       // Process names.
       //
+      if (gen_cxx)
       {
         NameProcessor proc;
         if (!proc.process (ops, schema, file_path, string_literal_map))
@@ -903,8 +255,9 @@ namespace CXX
 
       // Process polymorphic types.
       //
-      if (ops.value<CLI::generate_polymorphic> () &&
-          !ops.value<CLI::polymorphic_type_all> ())
+      if (gen_cxx &&
+          ops.generate_polymorphic () &&
+          !ops.polymorphic_type_all ())
       {
         PolymorphismProcessor proc;
         if (!proc.process (ops, schema, file_path, disabled_warnings))
@@ -913,11 +266,9 @@ namespace CXX
 
       // Parts.
       //
-      UnsignedLong parts (ops.value<CLI::parts> ());
-      UnsignedLong units (
-        counts.global_types + counts.generated_global_elements);
-
-      UnsignedLong units_per_part (units / parts);
+      size_t parts (ops.parts ());
+      size_t units (counts.global_types + counts.generated_global_elements);
+      size_t units_per_part (units / parts);
 
       if (parts != 1 && units_per_part < 1)
       {
@@ -925,14 +276,14 @@ namespace CXX
         throw Failed ();
       }
 
-      UnsignedLong complexity_per_part (counts.complexity_total / parts);
+      size_t complexity_per_part (counts.complexity_total / parts);
 
 
-      NarrowString parts_suffix (ops.value<CLI::parts_suffix> ());
+      NarrowString parts_suffix (ops.parts_suffix ());
 
       //
       //
-      Boolean generate_xml_schema (ops.value<CLI::generate_xml_schema> ());
+      bool generate_xml_schema (ops.generate_xml_schema ());
 
       // We could be compiling several schemas at once in which case
       // handling of the --generate-xml-schema option gets tricky: we
@@ -941,58 +292,68 @@ namespace CXX
       //
       if (generate_xml_schema)
       {
-        if (NarrowString name = ops.value<CLI::extern_xml_schema> ())
+        if (NarrowString name = ops.extern_xml_schema ())
         {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-          if (file_path.native_file_string () != name)
-#else
           if (file_path.string () != name)
-#endif
             generate_xml_schema = false;
         }
       }
 
-      Boolean inline_ (ops.value<CLI::generate_inline> () &&
-                       !generate_xml_schema);
+      bool header (true);
+      bool inline_ (ops.generate_inline () && !generate_xml_schema);
+      bool forward (ops.generate_forward () && !generate_xml_schema);
+      bool source (!generate_xml_schema);
+      bool gen_dep ((ops.generate_dep () || ops.generate_dep_only ()) &&
+                    !generate_xml_schema);
 
-      Boolean forward (ops.value<CLI::generate_forward> () &&
-                       !generate_xml_schema);
+      if (ops.generate_dep_only () && generate_xml_schema)
+      {
+        wcerr << "error: no dependency information can be generated for "
+          "XML Schema header" << endl;
+        throw Failed ();
+      }
 
-      Boolean source (!generate_xml_schema);
+      if (gen_dep && fpt)
+      {
+        wcerr << "error: dependency generation not support in the " <<
+          "file-per-type mode" << endl;
+        throw Failed ();
+      }
 
       // Generate code.
       //
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-      NarrowString name (file_path.leaf ());
-#else
-      NarrowString name (file_path.filename ().string());
-#endif
-
-      NarrowString hxx_suffix (ops.value <CLI::hxx_suffix> ());
-      NarrowString ixx_suffix (ops.value <CLI::ixx_suffix> ());
-      NarrowString cxx_suffix (ops.value <CLI::cxx_suffix> ());
-      NarrowString fwd_suffix (ops.value <CLI::fwd_suffix> ());
-
-      Regex hxx_expr (ops.value <CLI::hxx_regex> ().empty ()
+      NarrowString name (file_path.leaf ().string ());
+
+      NarrowString hxx_suffix (ops.hxx_suffix ());
+      NarrowString ixx_suffix (ops.ixx_suffix ());
+      NarrowString cxx_suffix (ops.cxx_suffix ());
+      NarrowString fwd_suffix (ops.fwd_suffix ());
+      NarrowString dep_suffix (ops.dep_suffix ());
+
+      Regex hxx_expr (ops.hxx_regex ().empty ()
                       ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + hxx_suffix + "#"
-                      : ops.value <CLI::hxx_regex> ());
+                      : ops.hxx_regex ());
 
-      Regex ixx_expr (ops.value <CLI::ixx_regex> ().empty ()
+      Regex ixx_expr (ops.ixx_regex ().empty ()
                       ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + ixx_suffix + "#"
-                      : ops.value <CLI::ixx_regex> ());
+                      : ops.ixx_regex ());
 
-      Regex cxx_expr (ops.value <CLI::cxx_regex> ().empty ()
+      Regex cxx_expr (ops.cxx_regex ().empty ()
                       ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + cxx_suffix + "#"
-                      : ops.value <CLI::cxx_regex> ());
+                      : ops.cxx_regex ());
 
-      Regex fwd_expr (ops.value <CLI::fwd_regex> ().empty ()
+      Regex fwd_expr (ops.fwd_regex ().empty ()
                       ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + fwd_suffix + "#"
-                      : ops.value <CLI::fwd_regex> ());
+                      : ops.fwd_regex ());
+
+      Regex dep_expr (ops.dep_regex ().empty ()
+                      ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + dep_suffix + "#"
+                      : ops.dep_regex ());
 
-      if (!hxx_expr.match (name))
+      if (header && !hxx_expr.match (name))
       {
         wcerr << "error: header expression '" <<
-          hxx_expr.pattern () << "' does not match '" <<
+          hxx_expr.regex ().str ().c_str () << "' does not match '" <<
           name.c_str () << "'" << endl;
         throw Failed ();
       }
@@ -1000,7 +361,7 @@ namespace CXX
       if (inline_ && !ixx_expr.match (name))
       {
         wcerr << "error: inline expression '" <<
-          ixx_expr.pattern () << "' does not match '" <<
+          ixx_expr.regex ().str ().c_str () << "' does not match '" <<
           name.c_str () << "'" << endl;
         throw Failed ();
       }
@@ -1008,7 +369,7 @@ namespace CXX
       if (source && parts == 1 && !cxx_expr.match (name))
       {
         wcerr << "error: source expression '" <<
-          cxx_expr.pattern () << "' does not match '" <<
+          cxx_expr.regex ().str ().c_str () << "' does not match '" <<
           name.c_str () << "'" << endl;
         throw Failed ();
       }
@@ -1016,31 +377,35 @@ namespace CXX
       if (forward && !fwd_expr.match (name))
       {
         wcerr << "error: forward expression '" <<
-          fwd_expr.pattern () << "' does not match '" <<
+          fwd_expr.regex ().str ().c_str () << "' does not match '" <<
           name.c_str () << "'" << endl;
         throw Failed ();
       }
 
-      NarrowString hxx_name (hxx_expr.merge (name));
-      NarrowString ixx_name (inline_ ? ixx_expr.merge (name) : NarrowString ());
-      NarrowString fwd_name (forward ? fwd_expr.merge (name) : NarrowString ());
-
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-      Path hxx_path (hxx_name, boost::filesystem::native);
-      Path ixx_path (ixx_name, boost::filesystem::native);
-      Path fwd_path (fwd_name, boost::filesystem::native);
-#else
-      Path hxx_path (hxx_name.c_str());
-      Path ixx_path (ixx_name.c_str());
-      Path fwd_path (fwd_name.c_str());
-#endif
+      if (gen_dep && !dep_expr.match (name))
+      {
+        wcerr << "error: dependency expression '" <<
+          dep_expr.regex ().str ().c_str () << "' does not match '" <<
+          name.c_str () << "'" << endl;
+        throw Failed ();
+      }
+
+      NarrowString hxx_name (header ? hxx_expr.replace (name) : NarrowString ());
+      NarrowString ixx_name (inline_ ? ixx_expr.replace (name) : NarrowString ());
+      NarrowString fwd_name (forward ? fwd_expr.replace (name) : NarrowString ());
+      NarrowString dep_name (gen_dep ? dep_expr.replace (name) : NarrowString ());
+
+      Path hxx_path (hxx_name);
+      Path ixx_path (ixx_name);
+      Path fwd_path (fwd_name);
+      Path dep_path (dep_name);
       Paths cxx_paths;
 
       if (source)
       {
         if (parts > 1)
         {
-          for (UnsignedLong i (0); i < parts; ++i)
+          for (size_t i (0); i < parts; ++i)
           {
             std::ostringstream os;
             os << i;
@@ -1048,44 +413,30 @@ namespace CXX
             Regex expr (
               "#^(.+?)(\\.[^./\\\\]+)?$#$1" + parts_suffix + os.str () + "$2#");
 
-            NarrowString part_name (expr.merge (name));
+            NarrowString part_name (expr.replace (name));
 
             if (!cxx_expr.match (part_name))
             {
               wcerr << "error: source expression '" <<
-                cxx_expr.pattern () << "' does not match '" <<
+                cxx_expr.regex ().str ().c_str () << "' does not match '" <<
                 part_name.c_str () << "'" << endl;
               throw Failed ();
             }
 
-            cxx_paths.push_back (
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-              Path (cxx_expr.merge (part_name), boost::filesystem::native));
-#else
-              Path (cxx_expr.merge (part_name).c_str()));
-#endif
+            cxx_paths.push_back (Path (cxx_expr.replace (part_name)));
           }
         }
         else
-          cxx_paths.push_back (
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-            Path (cxx_expr.merge (name), boost::filesystem::native));
-#else
-            Path (cxx_expr.merge (name).c_str()));
-#endif
+          cxx_paths.push_back (Path (cxx_expr.replace (name)));
       }
 
       Path out_dir;
 
-      if (NarrowString dir = ops.value<CLI::output_dir> ())
+      if (NarrowString dir = ops.output_dir ())
       {
         try
         {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-          out_dir = Path (dir, boost::filesystem::native);
-#else
-          out_dir = Path (dir.c_str());
-#endif
+          out_dir = Path (dir);
         }
         catch (InvalidPath const&)
         {
@@ -1100,7 +451,7 @@ namespace CXX
         // unless the user added the directory so that we propagate this
         // to the output files.
         //
-        Path fpt_dir (file_path.branch_path ());
+        Path fpt_dir (file_path.directory ());
 
         if (!fpt_dir.empty ())
           out_dir /= fpt_dir;
@@ -1111,25 +462,42 @@ namespace CXX
         hxx_path = out_dir / hxx_path;
         ixx_path = out_dir / ixx_path;
         fwd_path = out_dir / fwd_path;
+        dep_path = out_dir / dep_path;
 
-        for (Paths::Iterator i (cxx_paths.begin ());
+        for (Paths::iterator i (cxx_paths.begin ());
              i != cxx_paths.end (); ++i)
           *i = out_dir / *i;
       }
 
       //
       //
-      WideOutputFileStream hxx (hxx_path, ios_base::out);
+      WideOutputFileStream hxx;
       WideOutputFileStream ixx;
       WideOutputFileStream fwd;
+      WideOutputFileStream dep;
       WideOutputFileStreams cxx;
 
+      // DEP
+      //
+      if (gen_dep)
+      {
+        dep.open (dep_path.string ().c_str (), ios_base::out);
+
+        if (!dep.is_open ())
+        {
+          wcerr << dep_path << ": error: unable to open in write mode" << endl;
+          throw Failed ();
+        }
+
+        unlinks.add (dep_path);
+        file_list.push_back (dep_path.string ());
+      }
 
       // FWD
       //
-      if (forward)
+      if (gen_cxx && forward)
       {
-        fwd.open (fwd_path, ios_base::out);
+        fwd.open (fwd_path.string ().c_str (), ios_base::out);
 
         if (!fwd.is_open ())
         {
@@ -1138,35 +506,30 @@ namespace CXX
         }
 
         unlinks.add (fwd_path);
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        file_list.push_back (fwd_path.native_file_string ());
-#else
         file_list.push_back (fwd_path.string ());
-#endif
       }
 
-
       // HXX
       //
-      if (!hxx.is_open ())
+      if (gen_cxx && header)
       {
-        wcerr << hxx_path << ": error: unable to open in write mode" << endl;
-        throw Failed ();
-      }
+        hxx.open (hxx_path.string ().c_str (), ios_base::out);
 
-      unlinks.add (hxx_path);
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-      file_list.push_back (hxx_path.native_file_string ());
-#else
-      file_list.push_back (hxx_path.string ());
-#endif
+        if (!hxx.is_open ())
+        {
+          wcerr << hxx_path << ": error: unable to open in write mode" << endl;
+          throw Failed ();
+        }
 
+        unlinks.add (hxx_path);
+        file_list.push_back (hxx_path.string ());
+      }
 
       // IXX
       //
-      if (inline_)
+      if (gen_cxx && inline_)
       {
-        ixx.open (ixx_path, ios_base::out);
+        ixx.open (ixx_path.string ().c_str (), ios_base::out);
 
         if (!ixx.is_open ())
         {
@@ -1175,23 +538,19 @@ namespace CXX
         }
 
         unlinks.add (ixx_path);
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        file_list.push_back (ixx_path.native_file_string ());
-#else
         file_list.push_back (ixx_path.string ());
-#endif
       }
 
-
       // CXX
       //
-      if (source)
+      if (gen_cxx && source)
       {
-        for (Paths::Iterator i (cxx_paths.begin ());
+        for (Paths::iterator i (cxx_paths.begin ());
              i != cxx_paths.end (); ++i)
         {
-          Evptr<WideOutputFileStream> s (
-            new WideOutputFileStream (*i, ios_base::out));
+          shared_ptr<WideOutputFileStream> s (
+            new (shared) WideOutputFileStream (
+              i->string ().c_str (), ios_base::out));
 
           if (!s->is_open ())
           {
@@ -1200,29 +559,23 @@ namespace CXX
           }
 
           unlinks.add (*i);
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-          file_list.push_back (i->native_file_string ());
-#else
           file_list.push_back (i->string ());
-#endif
           cxx.push_back (s);
         }
       }
 
-
       // Print copyright and license.
       //
-      Char const* copyright (
-        ops.value<CLI::proprietary_license> ()
-        ? copyright_proprietary
-        : copyright_gpl);
+      char const* copyright (
+        ops.proprietary_license () ? copyright_proprietary : copyright_gpl);
 
-      if (forward)
-        fwd << copyright;
+      if (gen_cxx && header)
+        hxx << copyright;
 
-      hxx << copyright;
+      if (gen_cxx && forward)
+        fwd << copyright;
 
-      if (ops.value<CLI::generate_doxygen> ())
+      if (ops.generate_doxygen ())
       {
         // Use native path format.
         //
@@ -1234,12 +587,12 @@ namespace CXX
 
       }
 
-      if (inline_)
+      if (gen_cxx && inline_)
         ixx << copyright;
 
-      if (source)
+      if (gen_cxx && source)
       {
-        for (WideOutputFileStreams::Iterator i (cxx.begin ());
+        for (WideOutputFileStreams::iterator i (cxx.begin ());
              i != cxx.end (); ++i)
           **i << copyright;
       }
@@ -1249,7 +602,7 @@ namespace CXX
       //
       WideInputFileStream prologue;
       {
-        NarrowString name (ops.value<CLI::prologue_file> ());
+        NarrowString name (ops.prologue_file ());
 
         if (name)
           open (prologue, name);
@@ -1259,7 +612,7 @@ namespace CXX
       //
       WideInputFileStream epilogue;
       {
-        NarrowString name (ops.value<CLI::epilogue_file> ());
+        NarrowString name (ops.epilogue_file ());
 
         if (name)
           open (epilogue, name);
@@ -1267,27 +620,83 @@ namespace CXX
 
       // SLOC counter.
       //
-      UnsignedLong sloc (0);
-      Boolean show_sloc (ops.value<CLI::show_sloc> ());
+      size_t sloc_total (0);
+      bool show_sloc (ops.show_sloc ());
+
+      typedef
+      compiler::ostream_filter<compiler::cxx_indenter, wchar_t>
+      ind_filter;
+
+      typedef
+      compiler::ostream_filter<compiler::sloc_counter, wchar_t>
+      sloc_filter;
 
       //
       //
       Regex guard_expr ("/([a-z])([A-Z])/$1_$2/"); // Split words.
-      NarrowString guard_prefix (ops.value<CLI::guard_prefix> ());
+      NarrowString guard_prefix (ops.guard_prefix ());
 
       if (!guard_prefix)
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        guard_prefix = file_path.branch_path ().native_directory_string ();
-#else
-        guard_prefix = file_path.branch_path ().string ();
-#endif
+        guard_prefix = file_path.directory ().string ();
 
       if (guard_prefix)
         guard_prefix += '_';
 
+      // DEP
+      //
+      if (gen_dep)
+      {
+        NarrowString target;
+        NarrowStrings const& ts (ops.dep_target ());
+
+        if (!ts.empty ())
+        {
+          for (NarrowStrings::const_iterator i (ts.begin ());
+               i != ts.end (); ++i)
+            target += (target.empty () ? "" : " \\\n") + *i;
+        }
+        else
+        {
+          target = hxx_path.string ();
+
+          if (forward)
+            target += " \\\n" + fwd_path.string ();
+
+          if (inline_)
+            target += " \\\n" + ixx_path.string ();
+
+          for (Paths::iterator i (cxx_paths.begin ());
+               i != cxx_paths.end (); ++i)
+            target += " \\\n" + i->string ();
+
+          target += " \\\n" + dep_path.string ();
+        }
+
+        dep << target.c_str () << ':';
+
+        XSDFrontend::Generators::Dependencies gen;
+        Paths prq (gen.generate (schema, file_path));
+
+        for (Paths::iterator i (prq.begin ()); i != prq.end (); ++i)
+          dep << " \\" << endl
+              << "  " << *i;
+
+        dep << endl;
+
+        // If requested, generate phony rules for included/imported schemas
+        // but not the main file which is the first in the list.
+        //
+        if (ops.dep_phony () && prq.size () > 1)
+        {
+          for (Paths::iterator i (prq.begin () + 1); i != prq.end (); ++i)
+            dep << endl
+                << *i << ':' << endl;
+        }
+      }
+
       // FWD
       //
-      if (forward)
+      if (gen_cxx && forward)
       {
         Context ctx (fwd,
                      schema,
@@ -1300,11 +709,11 @@ namespace CXX
                      &hxx_expr,
                      &ixx_expr);
 
-        Indentation::Clip<Indentation::SLOC, WideChar> fwd_sloc (fwd);
+        sloc_filter sloc (fwd);
 
         // Guard
         //
-        String guard (guard_expr.merge (guard_prefix + fwd_name));
+        String guard (guard_expr.replace (guard_prefix + fwd_name));
         guard = ctx.escape (guard); // make a c++ id
         std::transform (guard.begin (), guard.end(), guard.begin (), upcase);
 
@@ -1312,15 +721,46 @@ namespace CXX
             << "#define " << guard << endl
             << endl;
 
+        if (ctx.std >= cxx_version::cxx11)
+        {
+          fwd << "#ifndef XSD_CXX11" << endl
+              << "#define XSD_CXX11" << endl
+              << "#endif" << endl
+              << endl;
+        }
+
+        if (ctx.char_type == L"char")
+        {
+          fwd << "#ifndef XSD_USE_CHAR" << endl
+              << "#define XSD_USE_CHAR" << endl
+              << "#endif" << endl
+              << endl;
+
+          fwd << "#ifndef XSD_CXX_TREE_USE_CHAR" << endl
+              << "#define XSD_CXX_TREE_USE_CHAR" << endl
+              << "#endif" << endl
+              << endl;
+        }
+        else if (ctx.char_type == L"wchar_t")
+        {
+          fwd << "#ifndef XSD_USE_WCHAR" << endl
+              << "#define XSD_USE_WCHAR" << endl
+              << "#endif" << endl
+              << endl;
+
+          fwd << "#ifndef XSD_CXX_TREE_USE_WCHAR" << endl
+              << "#define XSD_CXX_TREE_USE_WCHAR" << endl
+              << "#endif" << endl
+              << endl;
+        }
+
         // Copy prologue.
         //
         fwd << "// Begin prologue." << endl
             << "//" << endl;
 
-        append (fwd,
-                ops.value<CLI::fwd_prologue> (),
-                ops.value<CLI::prologue> ());
-        append (fwd, ops.value<CLI::fwd_prologue_file> (), prologue);
+        append (fwd, ops.fwd_prologue (), ops.prologue ());
+        append (fwd, ops.fwd_prologue_file (), prologue);
 
         fwd << "//" << endl
             << "// End prologue." << endl
@@ -1333,59 +773,28 @@ namespace CXX
             << "#if (XSD_INT_VERSION != " << XSD_INT_VERSION << "L)" << endl
             << "#error XSD runtime version mismatch" << endl
             << "#endif" << endl
-
             << endl;
-        {
-          fwd << "#include <xsd/cxx/pre.hxx>" << endl
-              << endl;
-
-          if (ctx.char_type == L"char")
-          {
-            fwd << "#ifndef XSD_USE_CHAR" << endl
-                << "#define XSD_USE_CHAR" << endl
-                << "#endif" << endl
-                << endl;
-
-            fwd << "#ifndef XSD_CXX_TREE_USE_CHAR" << endl
-                << "#define XSD_CXX_TREE_USE_CHAR" << endl
-                << "#endif" << endl
-                << endl;
-          }
-          else if (ctx.char_type == L"wchar_t")
-          {
-            fwd << "#ifndef XSD_USE_WCHAR" << endl
-                << "#define XSD_USE_WCHAR" << endl
-                << "#endif" << endl
-                << endl;
-
-            fwd << "#ifndef XSD_CXX_TREE_USE_WCHAR" << endl
-                << "#define XSD_CXX_TREE_USE_WCHAR" << endl
-                << "#endif" << endl
-                << endl;
-          }
-
-          // Set auto-indentation.
-          //
-          Indentation::Clip<Indentation::CXX, WideChar> fwd_clip (fwd);
 
+        fwd << "#include <xsd/cxx/pre.hxx>" << endl
+              << endl;
 
-          // Generate.
-          //
+        // Generate.
+        //
+        {
+          ind_filter ind (fwd); // We don't want to indent prologues/epilogues.
           generate_forward (ctx);
-
-          fwd << "#include <xsd/cxx/post.hxx>" << endl
-              << endl;
         }
 
+        fwd << "#include <xsd/cxx/post.hxx>" << endl
+            << endl;
+
         // Copy epilogue.
         //
         fwd << "// Begin epilogue." << endl
             << "//" << endl;
 
-        append (fwd, ops.value<CLI::fwd_epilogue_file> (), epilogue);
-        append (fwd,
-                ops.value<CLI::fwd_epilogue> (),
-                ops.value<CLI::epilogue> ());
+        append (fwd, ops.fwd_epilogue_file (), epilogue);
+        append (fwd, ops.fwd_epilogue (), ops.epilogue ());
 
         fwd << "//" << endl
             << "// End epilogue." << endl
@@ -1394,16 +803,14 @@ namespace CXX
         fwd << "#endif // " << guard << endl;
 
         if (show_sloc)
-        {
-          wcerr << fwd_path << ": "
-                << fwd_sloc.buffer ().count () << endl;
+          wcerr << fwd_path << ": " << sloc.stream ().count () << endl;
 
-          sloc += fwd_sloc.buffer ().count ();
-        }
+        sloc_total += sloc.stream ().count ();
       }
 
       // HXX
       //
+      if (gen_cxx && header)
       {
         Context ctx (hxx,
                      schema,
@@ -1416,11 +823,11 @@ namespace CXX
                      &hxx_expr,
                      &ixx_expr);
 
-        Indentation::Clip<Indentation::SLOC, WideChar> hxx_sloc (hxx);
+        sloc_filter sloc (hxx);
 
         // Guard
         //
-        String guard (guard_expr.merge (guard_prefix + hxx_name));
+        String guard (guard_expr.replace (guard_prefix + hxx_name));
         guard = ctx.escape (guard); // make a c++ id
         std::transform (guard.begin (), guard.end(), guard.begin (), upcase);
 
@@ -1428,14 +835,57 @@ namespace CXX
             << "#define " << guard << endl
             << endl;
 
+        if (!forward)
+        {
+          if (ctx.std >= cxx_version::cxx11)
+          {
+            hxx << "#ifndef XSD_CXX11" << endl
+                << "#define XSD_CXX11" << endl
+                << "#endif" << endl
+                << endl;
+          }
+
+          if (ctx.char_type == L"char")
+          {
+            hxx << "#ifndef XSD_USE_CHAR" << endl
+                << "#define XSD_USE_CHAR" << endl
+                << "#endif" << endl
+                << endl;
+
+            hxx << "#ifndef XSD_CXX_TREE_USE_CHAR" << endl
+                << "#define XSD_CXX_TREE_USE_CHAR" << endl
+                << "#endif" << endl
+                << endl;
+          }
+          else if (ctx.char_type == L"wchar_t")
+          {
+            hxx << "#ifndef XSD_USE_WCHAR" << endl
+                << "#define XSD_USE_WCHAR" << endl
+                << "#endif" << endl
+                << endl;
+
+            hxx << "#ifndef XSD_CXX_TREE_USE_WCHAR" << endl
+                << "#define XSD_CXX_TREE_USE_WCHAR" << endl
+                << "#endif" << endl
+                << endl;
+          }
+        }
+        else if (!generate_xml_schema)
+        {
+          // Generate it before the prologue so that we get the above
+          // defines.
+          //
+          hxx << "#include " << ctx.process_include_path (fwd_name)
+              << endl << endl;
+        }
+
         // Copy prologue.
         //
         hxx << "// Begin prologue." << endl
             << "//" << endl;
 
-        append (
-          hxx, ops.value<CLI::hxx_prologue> (), ops.value<CLI::prologue> ());
-        append (hxx, ops.value<CLI::hxx_prologue_file> (), prologue);
+        append (hxx, ops.hxx_prologue (), ops.prologue ());
+        append (hxx, ops.hxx_prologue_file (), prologue);
 
         hxx << "//" << endl
             << "// End prologue." << endl
@@ -1450,95 +900,53 @@ namespace CXX
             << "#endif" << endl
             << endl;
 
-        {
-          hxx << "#include <xsd/cxx/pre.hxx>" << endl
-              << endl;
-
-          // Generate character selection defines.
-          //
-          if (!forward)
-          {
-            if (ctx.char_type == L"char")
-            {
-              hxx << "#ifndef XSD_USE_CHAR" << endl
-                  << "#define XSD_USE_CHAR" << endl
-                  << "#endif" << endl
-                  << endl;
-
-              hxx << "#ifndef XSD_CXX_TREE_USE_CHAR" << endl
-                  << "#define XSD_CXX_TREE_USE_CHAR" << endl
-                  << "#endif" << endl
-                  << endl;
-            }
-            else if (ctx.char_type == L"wchar_t")
-            {
-              hxx << "#ifndef XSD_USE_WCHAR" << endl
-                  << "#define XSD_USE_WCHAR" << endl
-                  << "#endif" << endl
-                  << endl;
-
-              hxx << "#ifndef XSD_CXX_TREE_USE_WCHAR" << endl
-                  << "#define XSD_CXX_TREE_USE_WCHAR" << endl
-                  << "#endif" << endl
-                  << endl;
-            }
-          }
-
-          // Set auto-indentation.
-          //
-          Indentation::Clip<Indentation::CXX, WideChar> hxx_clip (hxx);
+        hxx << "#include <xsd/cxx/pre.hxx>" << endl
+            << endl;
 
+        // Generate.
+        //
+        {
+          ind_filter ind (hxx); // We don't want to indent prologues/epilogues.
 
-          // Generate.
-          //
-          if (!generate_xml_schema)
-          {
-            if (forward)
-              hxx << "#include " << ctx.process_include_path (fwd_name)
-                  << endl << endl;
-            else
-              generate_forward (ctx);
-          }
+          if (!generate_xml_schema && !forward)
+            generate_forward (ctx);
 
           generate_tree_header (ctx);
 
           if (!generate_xml_schema)
           {
-
-            if (ops.value<CLI::generate_ostream> ())
+            if (ops.generate_ostream ())
               generate_stream_header (ctx);
 
-            if (!ops.value<CLI::generate_element_type> () &&
-                !ops.value<CLI::suppress_parsing> ())
+            if (!ops.generate_element_type () && !ops.suppress_parsing ())
               generate_parser_header (ctx);
 
-            if (ops.value<CLI::generate_serialization> ())
+            if (ops.generate_serialization ())
               generate_serialization_header (ctx);
 
-            if (!ops.value<CLI::generate_insertion> ().empty ())
+            if (!ops.generate_insertion ().empty ())
               generate_stream_insertion_header (ctx);
           }
+        }
 
-          if (inline_)
-          {
-            hxx << "#ifndef XSD_DONT_INCLUDE_INLINE" << endl
-                << "#include " << ctx.process_include_path (ixx_name) << endl
-                << "#endif // XSD_DONT_INCLUDE_INLINE" << endl
-                << endl;
-          }
-
-          hxx << "#include <xsd/cxx/post.hxx>" << endl
+        if (inline_)
+        {
+          hxx << "#ifndef XSD_DONT_INCLUDE_INLINE" << endl
+              << "#include " << ctx.process_include_path (ixx_name) << endl
+              << "#endif // XSD_DONT_INCLUDE_INLINE" << endl
               << endl;
         }
 
+        hxx << "#include <xsd/cxx/post.hxx>" << endl
+              << endl;
+
         // Copy epilogue.
         //
         hxx << "// Begin epilogue." << endl
             << "//" << endl;
 
-        append (hxx, ops.value<CLI::hxx_epilogue_file> (), epilogue);
-        append (
-          hxx, ops.value<CLI::hxx_epilogue> (), ops.value<CLI::epilogue> ());
+        append (hxx, ops.hxx_epilogue_file (), epilogue);
+        append (hxx, ops.hxx_epilogue (), ops.epilogue ());
 
         hxx << "//" << endl
             << "// End epilogue." << endl
@@ -1547,18 +955,15 @@ namespace CXX
         hxx << "#endif // " << guard << endl;
 
         if (show_sloc)
-        {
-          wcerr << hxx_path << ": "
-                << hxx_sloc.buffer ().count () << endl;
+          wcerr << hxx_path << ": " << sloc.stream ().count () << endl;
 
-          sloc += hxx_sloc.buffer ().count ();
-        }
+        sloc_total += sloc.stream ().count ();
       }
 
 
       // IXX
       //
-      if (inline_)
+      if (gen_cxx && inline_)
       {
         Context ctx (ixx,
                      schema,
@@ -1571,11 +976,11 @@ namespace CXX
                      &hxx_expr,
                      &ixx_expr);
 
-        Indentation::Clip<Indentation::SLOC, WideChar> ixx_sloc (ixx);
+        sloc_filter sloc (ixx);
 
         // Guard
         //
-        String guard (guard_expr.merge (guard_prefix + ixx_name));
+        String guard (guard_expr.replace (guard_prefix + ixx_name));
         guard = ctx.escape (guard); // make a c++ id
         std::transform (guard.begin (), guard.end(), guard.begin (), upcase);
 
@@ -1588,22 +993,17 @@ namespace CXX
         ixx << "// Begin prologue." << endl
             << "//" << endl;
 
-        append (
-          ixx, ops.value<CLI::ixx_prologue> (), ops.value<CLI::prologue> ());
-        append (ixx, ops.value<CLI::ixx_prologue_file> (), prologue);
+        append (ixx, ops.ixx_prologue (), ops.prologue ());
+        append (ixx, ops.ixx_prologue_file (), prologue);
 
         ixx << "//" << endl
             << "// End prologue." << endl
             << endl;
 
+        // Generate.
+        //
         {
-          // Set auto-indentation.
-          //
-          Indentation::Clip<Indentation::CXX, WideChar> ixx_clip (ixx);
-
-
-          // Generate.
-          //
+          ind_filter ind (ixx); // We don't want to indent prologues/epilogues.
           generate_tree_inline (ctx, 1, 0);
         }
 
@@ -1612,9 +1012,8 @@ namespace CXX
         ixx << "// Begin epilogue." << endl
             << "//" << endl;
 
-        append (ixx, ops.value<CLI::ixx_epilogue_file> (), epilogue);
-        append (
-          ixx, ops.value<CLI::ixx_epilogue> (), ops.value<CLI::epilogue> ());
+        append (ixx, ops.ixx_epilogue_file (), epilogue);
+        append (ixx, ops.ixx_epilogue (), ops.epilogue ());
 
         ixx << "//" << endl
             << "// End epilogue." << endl
@@ -1623,31 +1022,26 @@ namespace CXX
         ixx << "#endif // " << guard.c_str () << endl;
 
         if (show_sloc)
-        {
-          wcerr << ixx_path << ": "
-                << ixx_sloc.buffer ().count () << endl;
+          wcerr << ixx_path << ": " << sloc.stream ().count () << endl;
 
-          sloc += ixx_sloc.buffer ().count ();
-        }
+        sloc_total += sloc.stream ().count ();
       }
 
-
       // CXX
       //
-
-      if (source)
+      if (gen_cxx && source)
       {
-        UnsignedLong first_unit (0); // First unit in the current part.
+        size_t first_unit (0); // First unit in the current part.
 
-        for (UnsignedLong part (0); part < parts; ++part)
+        for (size_t part (0); part < parts; ++part)
         {
           // Figure out the range of units for this part.
           //
-          UnsignedLong last_unit (first_unit);
+          size_t last_unit (first_unit);
 
           if (units != 0)
           {
-            UnsignedLong complexity (counts.complexity[last_unit]);
+            size_t complexity (counts.complexity[last_unit]);
 
             while (complexity < complexity_per_part)
             {
@@ -1660,7 +1054,7 @@ namespace CXX
               // Check if the increase in complexity should be kept in this
               // part or moved to the next.
               //
-              UnsignedLong new_complexity (
+              size_t new_complexity (
                 complexity + counts.complexity[last_unit + 1]);
 
               if (new_complexity > complexity_per_part)
@@ -1684,8 +1078,8 @@ namespace CXX
 
           //
           //
-          UnsignedLong first (first_unit);
-          UnsignedLong last (last_unit);
+          size_t first (first_unit);
+          size_t last (last_unit);
 
           first_unit = last_unit + 1;
 
@@ -1705,86 +1099,78 @@ namespace CXX
                        &hxx_expr,
                        &ixx_expr);
 
-          Indentation::Clip<Indentation::SLOC, WideChar> cxx_sloc (os);
+          sloc_filter sloc (os);
 
           // Copy prologue.
           //
           os << "// Begin prologue." << endl
              << "//" << endl;
 
-          append (os,
-                  ops.value<CLI::cxx_prologue> (),
-                  ops.value<CLI::prologue> ());
-          append (os, ops.value<CLI::cxx_prologue_file> (), prologue);
+          append (os, ops.cxx_prologue (), ops.prologue ());
+          append (os, ops.cxx_prologue_file (), prologue);
 
           os << "//" << endl
              << "// End prologue." << endl
              << endl;
 
-          {
-            os << "#include <xsd/cxx/pre.hxx>" << endl
-               << endl;
-
-            // Set auto-indentation.
-            //
-            Indentation::Clip<Indentation::CXX, WideChar> cxx_clip (os);
+          os << "#include <xsd/cxx/pre.hxx>" << endl
+             << endl;
 
+          os << "#include " << ctx.process_include_path (hxx_name) << endl
+             << endl;
 
-            // Generate.
+          // Generate.
+          //
+          {
+            // We don't want to indent prologues/epilogues.
             //
-            os << "#include " << ctx.process_include_path (hxx_name) << endl
-               << endl;
+            ind_filter ind (os);
 
             if (!inline_)
               generate_tree_inline (ctx, first, last);
 
             generate_tree_source (ctx, first, last);
 
-            if (ops.value<CLI::generate_ostream> ())
+            if (ops.generate_ostream ())
               generate_stream_source (ctx, first, last);
 
-            if (!ops.value<CLI::generate_element_type> () &&
-                !ops.value<CLI::suppress_parsing> ())
+            if (!ops.generate_element_type () && !ops.suppress_parsing ())
               generate_parser_source (ctx, first, last);
 
-            if (ops.value<CLI::generate_serialization> ())
+            if (ops.generate_serialization ())
               generate_serialization_source (ctx, first, last);
 
-            if (!ops.value<CLI::generate_extraction> ().empty ())
+            if (!ops.generate_extraction ().empty ())
               generate_stream_extraction_source (ctx);
 
-            if (!ops.value<CLI::generate_insertion> ().empty ())
+            if (!ops.generate_insertion ().empty ())
               generate_stream_insertion_source (ctx);
-
-            os << "#include <xsd/cxx/post.hxx>" << endl
-               << endl;
           }
 
+          os << "#include <xsd/cxx/post.hxx>" << endl
+             << endl;
+
           // Copy epilogue.
           //
           os << "// Begin epilogue." << endl
              << "//" << endl;
 
-          append (os, ops.value<CLI::cxx_epilogue_file> (), epilogue);
-          append (os,
-                  ops.value<CLI::cxx_epilogue> (),
-                  ops.value<CLI::epilogue> ());
+          append (os, ops.cxx_epilogue_file (), epilogue);
+          append (os, ops.cxx_epilogue (), ops.epilogue ());
 
           os << "//" << endl
              << "// End epilogue." << endl
              << endl;
 
           if (show_sloc)
-          {
-            wcerr << cxx_paths[part] << ": "
-                  << cxx_sloc.buffer ().count () << endl;
+            wcerr << cxx_paths[part] << ": " << sloc.stream ().count ()
+                  << endl;
 
-            sloc += cxx_sloc.buffer ().count ();
-          }
+          sloc_total += sloc.stream ().count ();
         }
       }
 
-      return sloc;
+      return sloc_total;
     }
     catch (UnrepresentableCharacter const& e)
     {
@@ -1823,18 +1209,18 @@ namespace CXX
 
       throw Failed ();
     }
-    catch (BackendElements::Regex::Format<Char> const& e)
+    catch (cutl::re::format const& e)
     {
       wcerr << "error: invalid regex: '" <<
-        e.expression ().c_str () << "': " <<
+        e.regex ().c_str () << "': " <<
         e.description ().c_str () << endl;
 
       throw Failed ();
     }
-    catch (BackendElements::Regex::Format<WideChar> const& e)
+    catch (cutl::re::wformat const& e)
     {
       wcerr << "error: invalid regex: '" <<
-        e.expression () << "': " << e.description () << endl;
+        e.regex () << "': " << e.description ().c_str () << endl;
 
       throw Failed ();
     }
diff --git a/xsd/xsd/cxx/tree/generator.hxx b/xsd/xsd/cxx/tree/generator.hxx
index 2e50392..f81f8e3 100644
--- a/xsd/xsd/cxx/tree/generator.hxx
+++ b/xsd/xsd/cxx/tree/generator.hxx
@@ -1,43 +1,36 @@
 // file      : xsd/cxx/tree/generator.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_GENERATOR_HXX
 #define CXX_TREE_GENERATOR_HXX
 
-#include <cult/types.hxx>
-
 #include <xsd-frontend/semantic-graph/elements.hxx> // Path
 #include <xsd-frontend/semantic-graph/schema.hxx>
 
 #include <xsd.hxx>
+#include <types.hxx>
 
 #include <cxx/literal-map.hxx>
-#include <cxx/tree/cli.hxx>
+#include <cxx/tree/options.hxx>
 
 namespace CXX
 {
   namespace Tree
   {
-    using namespace Cult::Types;
-
     class Generator
     {
     public:
-      static Void
+      static void
       usage ();
 
-      static CLI::OptionsSpec
-      options_spec ();
-
       struct Failed {};
 
-      static UnsignedLong
-      generate (CLI::Options const& options,
+      static size_t
+      generate (options const&,
                 XSDFrontend::SemanticGraph::Schema&,
                 XSDFrontend::SemanticGraph::Path const& file,
-                Boolean file_per_type,
+                bool file_per_type,
                 StringLiteralMap const&,
                 const WarningSet& disabled_warnings,
                 FileList& file_list,
diff --git a/xsd/xsd/cxx/tree/name-processor.cxx b/xsd/xsd/cxx/tree/name-processor.cxx
index 4949bed..1f3844b 100644
--- a/xsd/xsd/cxx/tree/name-processor.cxx
+++ b/xsd/xsd/cxx/tree/name-processor.cxx
@@ -1,51 +1,45 @@
 // file      : xsd/cxx/tree/name-processor.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
+#include <set>
+#include <map>
+#include <vector>
 #include <sstream>
 #include <iostream>
 
-#include <cult/containers/set.hxx>
-#include <cult/containers/map.hxx>
-#include <cult/containers/vector.hxx>
-
-#include <backend-elements/regex.hxx>
+#include <cutl/re.hxx>
 
 #include <cxx/tree/default-value.hxx>
 #include <cxx/tree/name-processor.hxx>
 
+using namespace std;
+
 namespace CXX
 {
   namespace Tree
   {
-    NameProcessor::
-    NameProcessor ()
-    {
-      // Dummy ctor, helps with long symbols on HP-UX.
-    }
-
     namespace
     {
       //
       //
-      typedef Cult::Containers::Set<String> NameSet;
+      typedef set<String> NameSet;
 
       class Context: public Tree::Context
       {
       public:
         struct Failed {};
 
-        Context (CLI::Options const& options,
+        Context (Tree::options const& ops,
                  Counts const& counts,
-                 Boolean generate_xml_schema,
+                 bool generate_xml_schema,
                  SemanticGraph::Schema& root,
                  SemanticGraph::Path const& path,
                  StringLiteralMap const& map)
             : Tree::Context (std::wcerr,
                              root,
                              path,
-                             options,
+                             ops,
                              counts,
                              generate_xml_schema,
                              &map,
@@ -54,7 +48,7 @@ namespace CXX
                              0),
               global_type_names (global_type_names_),
               global_element_names (global_element_names_),
-              detach (options.value<CLI::generate_detach> ()),
+              detach (ops.generate_detach ()),
               type_regex (type_regex_),
               accessor_regex (accessor_regex_),
               one_accessor_regex (one_accessor_regex_),
@@ -66,14 +60,12 @@ namespace CXX
               seq_modifier_regex (seq_modifier_regex_),
               parser_regex (parser_regex_),
               serializer_regex (serializer_regex_),
+              const_regex (const_regex_),
               enumerator_regex (enumerator_regex_),
               element_type_regex (element_type_regex_)
         {
-          typedef Containers::Vector<NarrowString> Vector;
-
-          NarrowString tn (options.value<CLI::type_naming> ());
-          NarrowString fn (options.value<CLI::function_naming> ());
-
+          NarrowString tn (options.type_naming ());
+          NarrowString fn (options.function_naming ());
 
           // Type name regex.
           //
@@ -116,9 +108,7 @@ namespace CXX
 
             }
 
-            compile_regex (options.value<CLI::type_regex> (),
-                           type_regex,
-                           "type");
+            compile_regex (options.type_regex (), type_regex, "type");
           }
 
           // Accessor name regex.
@@ -149,24 +139,23 @@ namespace CXX
               accessor_regex.push_back ("/([^,]+)/get\\u$1/");
             }
 
-            compile_regex (options.value<CLI::accessor_regex> (),
+            compile_regex (options.accessor_regex (),
                            accessor_regex,
                            "accessor");
 
-            compile_regex (options.value<CLI::one_accessor_regex> (),
+            compile_regex (options.one_accessor_regex (),
                            one_accessor_regex,
                            "one accessor");
 
-            compile_regex (options.value<CLI::opt_accessor_regex> (),
+            compile_regex (options.opt_accessor_regex (),
                            opt_accessor_regex,
                            "optional accessor");
 
-            compile_regex (options.value<CLI::seq_accessor_regex> (),
+            compile_regex (options.seq_accessor_regex (),
                            seq_accessor_regex,
                            "sequence accessor");
           }
 
-
           // Modifier name regex.
           //
           {
@@ -190,24 +179,23 @@ namespace CXX
               modifier_regex.push_back ("/detach,([^,]+)/detach\\u$1/");
             }
 
-            compile_regex (options.value<CLI::modifier_regex> (),
+            compile_regex (options.modifier_regex (),
                            modifier_regex,
                            "modifier");
 
-            compile_regex (options.value<CLI::one_modifier_regex> (),
+            compile_regex (options.one_modifier_regex (),
                            one_modifier_regex,
                            "one modifier");
 
-            compile_regex (options.value<CLI::opt_modifier_regex> (),
+            compile_regex (options.opt_modifier_regex (),
                            opt_modifier_regex,
                            "optional modifier");
 
-            compile_regex (options.value<CLI::seq_modifier_regex> (),
+            compile_regex (options.seq_modifier_regex (),
                            seq_modifier_regex,
                            "sequence modifier");
           }
 
-
           // Parser name regex.
           //
           {
@@ -222,9 +210,7 @@ namespace CXX
               parser_regex.push_back ("/(.+)/parse\\u$1/");
             }
 
-            compile_regex (options.value<CLI::parser_regex> (),
-                           parser_regex,
-                           "parser");
+            compile_regex (options.parser_regex (), parser_regex, "parser");
           }
 
           // Serializer name regex.
@@ -241,11 +227,35 @@ namespace CXX
               serializer_regex.push_back ("/(.+)/serialize\\u$1/");
             }
 
-            compile_regex (options.value<CLI::serializer_regex> (),
+            compile_regex (options.serializer_regex (),
                            serializer_regex,
                            "serializer");
           }
 
+          // Const regex.
+          //
+          {
+            if (fn == "knr")
+            {
+              const_regex.push_back ("/([^,]+),([^,]+),([^,]+)/$1_$2_$3/");
+              const_regex.push_back ("/([^,]+),([^,]+)/$1_$2/");
+            }
+            else if (fn == "lcc")
+            {
+              const_regex.push_back ("/([^,]+),([^,]+),([^,]+)/\\l$1_\\u$2_\\u$3/");
+              const_regex.push_back ("/([^,]+),([^,]+)/\\l$1\\u$2/");
+            }
+            else
+            {
+              // Java: all uppercase.
+              //
+              const_regex.push_back ("/([^,]+),([^,]+),([^,]+)/\\U$1_$2_$3/");
+              const_regex.push_back ("/([^,]+),([^,]+)/\\U$1_$2/");
+            }
+
+            compile_regex (options.const_regex (), const_regex, "const");
+          }
+
           // Enumerator name regex.
           //
           {
@@ -253,14 +263,14 @@ namespace CXX
             //
             enumerator_regex.push_back ("/^$/empty/");
 
-            compile_regex (options.value<CLI::enumerator_regex> (),
+            compile_regex (options.enumerator_regex (),
                            enumerator_regex,
                            "enumerator");
           }
 
           // Element type regex.
           //
-          compile_regex (options.value<CLI::element_type_regex> (),
+          compile_regex (options.element_type_regex (),
                          element_type_regex,
                          "element_type");
         }
@@ -282,35 +292,44 @@ namespace CXX
               seq_modifier_regex (c.seq_modifier_regex),
               parser_regex (c.parser_regex),
               serializer_regex (c.serializer_regex),
+              const_regex (c.const_regex),
               enumerator_regex (c.enumerator_regex),
               element_type_regex (c.element_type_regex)
         {
         }
 
       public:
-        typedef BackendElements::Regex::Expression<WideChar> Regex;
-        typedef BackendElements::Regex::Format<WideChar> RegexFormat;
-        typedef Cult::Containers::Vector<Regex> RegexVector;
+        typedef cutl::re::wregexsub Regex;
+        typedef cutl::re::wformat RegexFormat;
+
+        struct RegexVector: vector<Regex>
+        {
+          void
+          push_back (String const& r)
+          {
+            vector<Regex>::push_back (Regex (r));
+          }
+        };
 
         String
         process_regex (String const& name,
                        RegexVector const& rv,
                        String const& id)
         {
-          Boolean trace (options.value<CLI::name_regex_trace> ());
+          bool trace (options.name_regex_trace ());
 
           if (trace)
             os << id << " name: '" << name << "'" << endl;
 
-          for (RegexVector::ConstReverseIterator i (rv.rbegin ());
+          for (RegexVector::const_reverse_iterator i (rv.rbegin ());
                i != rv.rend (); ++i)
           {
             if (trace)
-              os << "try: '" << i->pattern () << "' : ";
+              os << "try: '" << i->regex () << "' : ";
 
             if (i->match (name))
             {
-              String r (i->merge (name));
+              String r (i->replace (name));
 
               if (trace)
                 os << "'" << r << "' : +" << endl;
@@ -331,20 +350,20 @@ namespace CXX
                        RegexVector const& backup,
                        String const& id)
         {
-          Boolean trace (options.value<CLI::name_regex_trace> ());
+          bool trace (options.name_regex_trace ());
 
           if (trace)
             os << id << " name: '" << name << "'" << endl;
 
-          for (RegexVector::ConstReverseIterator i (primary.rbegin ());
+          for (RegexVector::const_reverse_iterator i (primary.rbegin ());
                i != primary.rend (); ++i)
           {
             if (trace)
-              os << "try: '" << i->pattern () << "' : ";
+              os << "try: '" << i->regex () << "' : ";
 
             if (i->match (name))
             {
-              String r (i->merge (name));
+              String r (i->replace (name));
 
               if (trace)
                 os << "'" << r << "' : +" << endl;
@@ -356,15 +375,15 @@ namespace CXX
               os << '-' << endl;
           }
 
-          for (RegexVector::ConstReverseIterator i (backup.rbegin ());
+          for (RegexVector::const_reverse_iterator i (backup.rbegin ());
                i != backup.rend (); ++i)
           {
             if (trace)
-              os << "try: '" << i->pattern () << "' : ";
+              os << "try: '" << i->regex () << "' : ";
 
             if (i->match (name))
             {
-              String r (i->merge (name));
+              String r (i->replace (name));
 
               if (trace)
                 os << "'" << r << "' : +" << endl;
@@ -386,20 +405,20 @@ namespace CXX
                        String const& id)
         {
           String s (ns + L' ' + name);
-          Boolean trace (options.value<CLI::name_regex_trace> ());
+          bool trace (options.name_regex_trace ());
 
           if (trace)
             os << id << " name: '" << s << "'" << endl;
 
-          for (RegexVector::ConstReverseIterator i (rv.rbegin ());
+          for (RegexVector::const_reverse_iterator i (rv.rbegin ());
                i != rv.rend (); ++i)
           {
             if (trace)
-              os << "try: '" << i->pattern () << "' : ";
+              os << "try: '" << i->regex () << "' : ";
 
             if (i->match (s))
             {
-              String r (i->merge (s));
+              String r (i->replace (s));
 
               if (trace)
                 os << "'" << r << "' : +" << endl;
@@ -422,20 +441,20 @@ namespace CXX
                        String const& id)
         {
           String s (ns + L' ' + name);
-          Boolean trace (options.value<CLI::name_regex_trace> ());
+          bool trace (options.name_regex_trace ());
 
           if (trace)
             os << id << " name: '" << s << "'" << endl;
 
-          for (RegexVector::ConstReverseIterator i (primary.rbegin ());
+          for (RegexVector::const_reverse_iterator i (primary.rbegin ());
                i != primary.rend (); ++i)
           {
             if (trace)
-              os << "try: '" << i->pattern () << "' : ";
+              os << "try: '" << i->regex () << "' : ";
 
             if (i->match (s))
             {
-              String r (i->merge (s));
+              String r (i->replace (s));
 
               if (trace)
                 os << "'" << r << "' : +" << endl;
@@ -447,15 +466,15 @@ namespace CXX
               os << '-' << endl;
           }
 
-          for (RegexVector::ConstReverseIterator i (backup.rbegin ());
+          for (RegexVector::const_reverse_iterator i (backup.rbegin ());
                i != backup.rend (); ++i)
           {
             if (trace)
-              os << "try: '" << i->pattern () << "' : ";
+              os << "try: '" << i->regex () << "' : ";
 
             if (i->match (s))
             {
-              String r (i->merge (s));
+              String r (i->replace (s));
 
               if (trace)
                 os << "'" << r << "' : +" << endl;
@@ -474,11 +493,11 @@ namespace CXX
         String
         find_name (String const& base_name,
                    NameSet& set,
-                   Boolean insert = true)
+                   bool insert = true)
         {
           String name (base_name);
 
-          for (UnsignedLong i (1); set.find (name) != set.end (); ++i)
+          for (size_t i (1); set.find (name) != set.end (); ++i)
           {
             std::wostringstream os;
             os << i;
@@ -492,23 +511,22 @@ namespace CXX
         }
 
       private:
-        Void
-        compile_regex (Containers::Vector<NarrowString> const& sv,
+        void
+        compile_regex (NarrowStrings const& sv,
                        RegexVector& rv,
                        String const& id)
         {
-          typedef Containers::Vector<NarrowString> Vector;
-
-          for (Vector::ConstIterator i (sv.begin ()); i != sv.end (); ++i)
+          for (NarrowStrings::const_iterator i (sv.begin ()); i != sv.end ();
+               ++i)
           {
             try
             {
-              rv.push_back (Regex (*i));
+              rv.push_back (*i);
             }
             catch (RegexFormat const& e)
             {
               os << "error: invalid " << id << " name regex: '" <<
-                e.expression () << "': " << e.description () << endl;
+                e.regex () << "': " << e.description ().c_str () << endl;
 
               throw Failed ();
             }
@@ -516,8 +534,8 @@ namespace CXX
         }
 
       private:
-        Cult::Containers::Map<String, NameSet> global_type_names_;
-        Cult::Containers::Map<String, NameSet> global_element_names_;
+        map<String, NameSet> global_type_names_;
+        map<String, NameSet> global_element_names_;
 
         RegexVector type_regex_;
         RegexVector accessor_regex_;
@@ -530,14 +548,15 @@ namespace CXX
         RegexVector seq_modifier_regex_;
         RegexVector parser_regex_;
         RegexVector serializer_regex_;
+        RegexVector const_regex_;
         RegexVector enumerator_regex_;
         RegexVector element_type_regex_;
 
       public:
-        Cult::Containers::Map<String, NameSet>& global_type_names;
-        Cult::Containers::Map<String, NameSet>& global_element_names;
+        map<String, NameSet>& global_type_names;
+        map<String, NameSet>& global_element_names;
 
-        Boolean detach;
+        bool detach;
 
         RegexVector& type_regex;
         RegexVector& accessor_regex;
@@ -550,6 +569,7 @@ namespace CXX
         RegexVector& seq_modifier_regex;
         RegexVector& parser_regex;
         RegexVector& serializer_regex;
+        RegexVector& const_regex;
         RegexVector& enumerator_regex;
         RegexVector& element_type_regex;
       };
@@ -563,7 +583,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           // Process the name with enumerator name regex.
@@ -590,7 +610,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           // Use processed name.
@@ -630,7 +650,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
           if (Tree::Context::skip (m))
@@ -657,20 +677,23 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
           if (Tree::Context::skip (m))
             return;
 
-          UnsignedLong max (Tree::Context::max (m));
-          UnsignedLong min (Tree::Context::min (m));
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (m.scope ()));
+
+          size_t max (Tree::Context::max (m));
+          size_t min (Tree::Context::min (m));
 
           String const& s (m.context ().get<String> ("stem"));
           String const& b (m.context ().get<String> ("name"));
 
-          Boolean def_attr (m.default_p () &&
-                            m.is_a<SemanticGraph::Attribute> ());
+          bool def_attr (m.default_p () &&
+                         m.is_a<SemanticGraph::Attribute> ());
 
           // Accessors/modifiers. Note that we postpone inserting
           // the names into the name_set to avoid over-escaping.
@@ -809,7 +832,7 @@ namespace CXX
           //
           if (m.default_p ())
           {
-            Boolean simple (true);
+            bool simple (true);
 
             if (m.is_a<SemanticGraph::Element> ())
             {
@@ -824,9 +847,9 @@ namespace CXX
                   process_regex (
                     s + L",default,value", accessor_regex, L"accessor")));
 
-              m.context ().set ( "default-value", find_name (an, name_set_));
+              m.context ().set ("default-value", find_name (an, name_set_));
 
-              Boolean lit (false);
+              bool lit (false);
               {
                 IsLiteralValue test (lit);
                 test.dispatch (m.type ());
@@ -840,6 +863,18 @@ namespace CXX
               }
             }
           }
+
+          // Element id.
+          //
+          if (m.is_a<SemanticGraph::Element> () && ordered_p (c))
+          {
+            String id (
+              escape (
+                process_regex (
+                  s + L",id", const_regex, L"const")));
+
+            m.context ().set ("ordered-id-name", find_name (id, name_set_));
+          }
         }
 
       private:
@@ -854,7 +889,7 @@ namespace CXX
         Any (Context& c,
              NameSet& name_set,
              NameSet& stem_set,
-             Boolean& has_wildcard)
+             bool& has_wildcard)
             : Context (c),
               name_set_ (name_set),
               stem_set_ (stem_set),
@@ -862,11 +897,14 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
-          UnsignedLong max (Tree::Context::max (a));
-          UnsignedLong min (Tree::Context::min (a));
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (a.scope ()));
+
+          size_t max (Tree::Context::max (a));
+          size_t min (Tree::Context::min (a));
 
           String s (find_name (L"any", stem_set_));
 
@@ -980,11 +1018,23 @@ namespace CXX
           //
           a.context ().set ("member", find_name (b + L"_", name_set_));
 
+          // Wildcard id.
+          //
+          if (ordered_p (c))
+          {
+            String id (
+              escape (
+                process_regex (
+                  s + L",id", const_regex, L"const")));
+
+            a.context ().set ("ordered-id-name", find_name (id, name_set_));
+          }
+
           if (!has_wildcard_)
             has_wildcard_ = true;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute& a)
         {
           String s (find_name (L"any,attribute", stem_set_));
@@ -1050,7 +1100,7 @@ namespace CXX
       private:
         NameSet& name_set_;
         NameSet& stem_set_;
-        Boolean& has_wildcard_;
+        bool& has_wildcard_;
       };
 
       //
@@ -1062,20 +1112,20 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
-          SemanticGraph::Context& cc (c.context ());
+          SemanticGraph::Context& ctx (c.context ());
 
           // We leave this set around to allow other mappings to use
           // this information.
           //
-          cc.set ("cxx-tree-name-processor-stem-set", NameSet ());
-          cc.set ("cxx-tree-name-processor-member-set", NameSet ());
+          ctx.set ("cxx-tree-name-processor-stem-set", NameSet ());
+          ctx.set ("cxx-tree-name-processor-member-set", NameSet ());
 
           // Use processed name.
           //
-          String name (cc.get<String> ("name"));
+          String name (ctx.get<String> ("name"));
 
           // If renamed name is empty then we are not generating
           // anything for this type and name processing is not
@@ -1085,10 +1135,10 @@ namespace CXX
             return;
 
           NameSet& stem_set (
-            cc.get<NameSet> ("cxx-tree-name-processor-stem-set"));
+            ctx.get<NameSet> ("cxx-tree-name-processor-stem-set"));
 
           NameSet& member_set (
-            cc.get<NameSet> ("cxx-tree-name-processor-member-set"));
+            ctx.get<NameSet> ("cxx-tree-name-processor-member-set"));
 
           stem_set.insert (c.name ());
           member_set.insert (name);
@@ -1144,11 +1194,121 @@ namespace CXX
             Complex::names (c, names);
           }
 
+          // Names for the mixed content.
+          //
+          if (mixed_p (c))
+          {
+            // Check if we already have the mixed content down inheritance
+            // hierarchy.
+            //
+            using SemanticGraph::Complex;
+
+            for (Complex* p (&c); p->inherits_p ();)
+            {
+              if (Complex* b = dynamic_cast<Complex*> (
+                    &p->inherits ().base ()))
+              {
+                if (mixed_p (*b))
+                {
+                  SemanticGraph::Context& bctx (b->context ());
+                  ctx.set ("mixed-type", bctx.get<String> ("mixed-type"));
+                  ctx.set ("mixed-const-iterator",
+                           bctx.get<String> ("mixed-const-iterator"));
+                  ctx.set ("mixed-ordered-id-name",
+                           bctx.get<String> ("mixed-ordered-id-name"));
+                  ctx.set ("mixed-aname", bctx.get<String> ("mixed-aname"));
+                  ctx.set ("mixed-member", bctx.get<String> ("mixed-member"));
+                  ctx.set ("mixed-in-base", true);
+                  break;
+                }
+
+                p = b;
+              }
+              else
+                break;
+            }
+
+            // If not, set up the names.
+            //
+            if (!ctx.count ("mixed-in-base"))
+            {
+              String s (find_name (L"text,content", stem_set));
+              String n (find_name (escape (s), member_set, false));
+
+              String an (find_name (
+                           escape (process_regex (s,
+                                                  seq_accessor_regex,
+                                                  accessor_regex,
+                                                  L"sequence accessor")),
+                           member_set,
+                           false));
+
+              String mn (find_name (
+                           escape (process_regex (s,
+                                                  seq_modifier_regex,
+                                                  modifier_regex,
+                                                  L"sequence modifier")),
+                           member_set,
+                           false));
+
+              ctx.set ("mixed-aname", an);
+              ctx.set ("mixed-mname", mn);
+
+              member_set.insert (name);
+
+              if (an != n)
+                member_set.insert (an);
+
+              if (mn != n && mn != an)
+                member_set.insert (mn);
+
+              // Types.
+              //
+              ctx.set (
+                "mixed-type",
+                find_name (
+                  escape (process_regex (s + L",type", type_regex, L"type")),
+                  member_set));
+
+              ctx.set (
+                "mixed-container",
+                find_name (
+                  escape (process_regex (s + L",sequence", type_regex, L"type")),
+                  member_set));
+
+              ctx.set (
+                "mixed-iterator",
+                find_name (
+                  escape (process_regex (s + L",iterator", type_regex, L"type")),
+                  member_set));
+
+              ctx.set (
+                "mixed-const-iterator",
+                find_name (
+                  escape (
+                    process_regex (s + L",const,iterator", type_regex, L"type")),
+                  member_set));
+
+              // Text content id.
+              //
+              ctx.set (
+                "mixed-ordered-id-name",
+                find_name (
+                  escape (
+                    process_regex (s + L",id", const_regex, L"const")),
+                  member_set));
+
+              // Data member.
+              //
+              ctx.set ("mixed-member", find_name (n + L"_", member_set));
+            }
+          }
+
           // Names for wildcards.
           //
-          if (options.value<CLI::generate_wildcard> ())
+          if (options.generate_wildcard ())
           {
-            Boolean has_wildcard (false);
+            bool has_wildcard (false);
             Any any (*this, member_set, stem_set, has_wildcard);
             Traversal::Names names (any);
             Complex::names (c, names);
@@ -1198,6 +1358,105 @@ namespace CXX
               }
             }
           }
+
+          // Names for the order container.
+          //
+          if (ordered_p (c))
+          {
+            // Check if we already have the order container down
+            // inheritance hierarchy.
+            //
+            using SemanticGraph::Complex;
+
+            for (Complex* p (&c); p->inherits_p ();)
+            {
+              if (Complex* b = dynamic_cast<Complex*> (
+                    &p->inherits ().base ()))
+              {
+                if (ordered_p (*b))
+                {
+                  SemanticGraph::Context& bctx (b->context ());
+                  ctx.set ("order-type", bctx.get<String> ("order-type"));
+                  ctx.set ("order-const-iterator",
+                           bctx.get<String> ("order-const-iterator"));
+                  ctx.set ("order-aname", bctx.get<String> ("order-aname"));
+                  ctx.set ("order-member", bctx.get<String> ("order-member"));
+                  ctx.set ("order-in-base", true);
+                  break;
+                }
+
+                p = b;
+              }
+              else
+                break;
+            }
+
+            // If not, set up the names.
+            //
+            if (!ctx.count ("order-in-base"))
+            {
+              String s (find_name (L"content,order", stem_set));
+              String n (find_name (escape (s), member_set, false));
+
+              String an (find_name (
+                           escape (process_regex (s,
+                                                  seq_accessor_regex,
+                                                  accessor_regex,
+                                                  L"sequence accessor")),
+                           member_set,
+                           false));
+
+              String mn (find_name (
+                           escape (process_regex (s,
+                                                  seq_modifier_regex,
+                                                  modifier_regex,
+                                                  L"sequence modifier")),
+                           member_set,
+                           false));
+
+              ctx.set ("order-aname", an);
+              ctx.set ("order-mname", mn);
+
+              member_set.insert (name);
+
+              if (an != n)
+                member_set.insert (an);
+
+              if (mn != n && mn != an)
+                member_set.insert (mn);
+
+              // Types.
+              //
+              ctx.set (
+                "order-type",
+                find_name (
+                  escape (process_regex (s + L",type", type_regex, L"type")),
+                  member_set));
+
+              ctx.set (
+                "order-container",
+                find_name (
+                  escape (process_regex (s + L",sequence", type_regex, L"type")),
+                  member_set));
+
+              ctx.set (
+                "order-iterator",
+                find_name (
+                  escape (process_regex (s + L",iterator", type_regex, L"type")),
+                  member_set));
+
+              ctx.set (
+                "order-const-iterator",
+                find_name (
+                  escape (
+                    process_regex (s + L",const,iterator", type_regex, L"type")),
+                  member_set));
+
+              // Data member.
+              //
+              ctx.set ("order-member", find_name (n + L"_", member_set));
+            }
+          }
         }
       };
 
@@ -1211,7 +1470,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Type& t)
         {
           // Process the name with type name regex.
@@ -1254,7 +1513,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           // First we need to figure out if we need to process this
@@ -1263,7 +1522,7 @@ namespace CXX
           if (!generate_p (e))
             return;
 
-          if (options.value<CLI::generate_element_type> ())
+          if (options.generate_element_type ())
           {
             SemanticGraph::Context& ec (e.context ());
 
@@ -1379,7 +1638,7 @@ namespace CXX
             //
             String p;
 
-            if (!options.value<CLI::suppress_parsing> () && doc_root_p (e))
+            if (!options.suppress_parsing () && doc_root_p (e))
             {
               p = find_name (
                 escape (
@@ -1392,8 +1651,7 @@ namespace CXX
             //
             String s;
 
-            if (options.value<CLI::generate_serialization> () &&
-                doc_root_p (e))
+            if (options.generate_serialization () && doc_root_p (e))
             {
               s = find_name (
                 escape (
@@ -1430,7 +1688,7 @@ namespace CXX
           if (type_set_.find (r) != type_set_.end ())
             r += L"_";
 
-          for (UnsignedLong i (1);
+          for (size_t i (1);
                element_set_.find (r) != element_set_.end () ||
                  type_set_.find (r) != type_set_.end (); ++i)
           {
@@ -1454,7 +1712,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& ns)
         {
           NameSet& type_set (global_type_names[ns.name ()]);
@@ -1475,7 +1733,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& ns)
         {
           String const& name (ns.name ());
@@ -1557,7 +1815,7 @@ namespace CXX
           *this >> names_ >> *this;
         }
 
-        Void
+        void
         process_name (SemanticGraph::Type& t, String const& name)
         {
           String r (
@@ -1567,10 +1825,10 @@ namespace CXX
           t.context ().set ("name", escape (r));
         }
 
-        Void
+        void
         process_name (SemanticGraph::Namespace& n,
                       String const& name,
-                      Char const* key)
+                      char const* key)
         {
           String r (process_regex (name, type_regex, L"type"));
           n.context ().set (key, escape (r));
@@ -1578,13 +1836,13 @@ namespace CXX
 
         // anyType and anySimpleType
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyType& t)
         {
           process_name (t, "type");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnySimpleType& t)
         {
           process_name (t, "simple,type");
@@ -1592,79 +1850,79 @@ namespace CXX
 
         // Integrals.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Byte& t)
         {
           process_name (t, "byte");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedByte& t)
         {
           process_name (t, "unsigned,byte");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Short& t)
         {
           process_name (t, "short");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedShort& t)
         {
           process_name (t, "unsigned,short");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Int& t)
         {
           process_name (t, "int");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedInt& t)
         {
           process_name (t, "unsigned,int");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Long& t)
         {
           process_name (t, "long");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedLong& t)
         {
           process_name (t, "unsigned,long");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Integer& t)
         {
           process_name (t, "integer");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NonPositiveInteger& t)
         {
           process_name (t, "non,positive,integer");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NonNegativeInteger& t)
         {
           process_name (t, "non,negative,integer");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::PositiveInteger& t)
         {
           process_name (t, "positive,integer");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NegativeInteger& t)
         {
           process_name (t, "negative,integer");
@@ -1672,7 +1930,7 @@ namespace CXX
 
         // Boolean.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Boolean& t)
         {
           process_name (t, "boolean");
@@ -1680,19 +1938,19 @@ namespace CXX
 
         // Floats.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Float& t)
         {
           process_name (t, "float");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Double& t)
         {
           process_name (t, "double");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Decimal& t)
         {
           process_name (t, "decimal");
@@ -1700,49 +1958,49 @@ namespace CXX
 
         // Strings.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::String& t)
         {
           process_name (t, "string");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NormalizedString& t)
         {
           process_name (t, "normalized,string");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Token& t)
         {
           process_name (t, "token");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NameToken& t)
         {
           process_name (t, "nmtoken");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NameTokens& t)
         {
           process_name (t, "nmtokens");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Name& t)
         {
           process_name (t, "name");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NCName& t)
         {
           process_name (t, "ncname");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Language& t)
         {
           process_name (t, "language");
@@ -1750,19 +2008,19 @@ namespace CXX
 
         // ID/IDREF.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Id& t)
         {
           process_name (t, "id");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::IdRef& t)
         {
           process_name (t, "idref");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::IdRefs& t)
         {
           process_name (t, "idrefs");
@@ -1771,7 +2029,7 @@ namespace CXX
 
         // URI.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::AnyURI& t)
         {
           process_name (t, "uri");
@@ -1779,7 +2037,7 @@ namespace CXX
 
         // Qualified name.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::QName& t)
         {
           process_name (t, "qname");
@@ -1787,13 +2045,13 @@ namespace CXX
 
         // Binary.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Base64Binary& t)
         {
           process_name (t, "base64,binary");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::HexBinary& t)
         {
           process_name (t, "hex,binary");
@@ -1802,55 +2060,55 @@ namespace CXX
 
         // Date/time.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Date& t)
         {
           process_name (t, "date");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::DateTime& t)
         {
           process_name (t, "date,time");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Duration& t)
         {
           process_name (t, "duration");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Day& t)
         {
           process_name (t, "gday");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Month& t)
         {
           process_name (t, "gmonth");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::MonthDay& t)
         {
           process_name (t, "gmonth,day");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Year& t)
         {
           process_name (t, "gyear");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::YearMonth& t)
         {
           process_name (t, "gyear,month");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Time& t)
         {
           process_name (t, "time");
@@ -1858,19 +2116,19 @@ namespace CXX
 
         // Entity.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Entity& t)
         {
           process_name (t, "entity");
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Entities& t)
         {
           process_name (t, "entities");
         }
 
-        virtual Void
+        virtual void
         post (SemanticGraph::Namespace& n)
         {
           // Assign names to extra stuff in the XML Schema namespace.
@@ -1879,13 +2137,15 @@ namespace CXX
           process_name (n, "buffer", "buffer");
           process_name (n, "time,zone", "time-zone");
 
-          if (options.value<CLI::generate_element_type> ())
+          process_name (n, "content,order", "content-order");
+
+          if (options.generate_element_type ())
             process_name (n, "element,type", "element-type");
 
-          if (options.value<CLI::generate_element_map> ())
+          if (options.generate_element_map ())
             process_name (n, "element,map", "element-map");
 
-          if (options.value<CLI::generate_serialization> ())
+          if (options.generate_serialization ())
           {
             process_name (n, "namespace,info", "namespace-info");
             process_name (n, "namespace,infomap", "namespace-infomap");
@@ -1895,12 +2155,12 @@ namespace CXX
             process_name (n, "facet", "facet");
           }
 
-          if (!options.value<CLI::generate_insertion> ().empty ())
+          if (!options.generate_insertion ().empty ())
           {
             process_name (n, "ostream", "ostream");
           }
 
-          if (!options.value<CLI::generate_extraction> ().empty ())
+          if (!options.generate_extraction ().empty ())
           {
             process_name (n, "istream", "istream");
           }
@@ -1908,7 +2168,7 @@ namespace CXX
           process_name (n, "flags", "flags");
           process_name (n, "properties", "properties");
 
-          NarrowString fn (options.value<CLI::function_naming> ());
+          NarrowString fn (options.function_naming ());
 
           if (fn == "knr")
             n.context ().set ("tree-node-key", String ("tree_node_key"));
@@ -1936,8 +2196,8 @@ namespace CXX
           process_name (n, "error", "error");
           process_name (n, "diagnostics", "diagnostics");
 
-          if (!options.value<CLI::suppress_parsing> () ||
-              options.value<CLI::generate_serialization> ())
+          if (!options.suppress_parsing () ||
+              options.generate_serialization ())
           {
             process_name (n, "error,handler", "error-handler");
           }
@@ -1955,7 +2215,7 @@ namespace CXX
       //
       struct UsesPassOne: Traversal::Uses
       {
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           SemanticGraph::Schema& s (u.schema ());
@@ -1970,7 +2230,7 @@ namespace CXX
 
       struct UsesPassThree: Traversal::Uses
       {
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           SemanticGraph::Schema& s (u.schema ());
@@ -1988,7 +2248,7 @@ namespace CXX
       //
       struct Implies: Traversal::Implies
       {
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Implies& i)
         {
           SemanticGraph::Schema& s (i.schema ());
@@ -2001,8 +2261,8 @@ namespace CXX
         }
       };
 
-      Boolean
-      process_impl (CLI::Options const& ops,
+      bool
+      process_impl (options const& ops,
                     SemanticGraph::Schema& tu,
                     SemanticGraph::Path const& file,
                     StringLiteralMap const& map)
@@ -2064,7 +2324,7 @@ namespace CXX
             //
             {
               Traversal::Schema schema;
-              Traversal::Sources sources;
+              Sources sources;
 
               schema >> sources >> schema;
 
@@ -2128,8 +2388,8 @@ namespace CXX
       }
     }
 
-    Boolean NameProcessor::
-    process (CLI::Options const& ops,
+    bool NameProcessor::
+    process (options const& ops,
              SemanticGraph::Schema& tu,
              SemanticGraph::Path const& file,
              StringLiteralMap const& map)
diff --git a/xsd/xsd/cxx/tree/name-processor.hxx b/xsd/xsd/cxx/tree/name-processor.hxx
index cf187b7..46ea883 100644
--- a/xsd/xsd/cxx/tree/name-processor.hxx
+++ b/xsd/xsd/cxx/tree/name-processor.hxx
@@ -1,26 +1,24 @@
 // file      : xsd/cxx/tree/name-processor.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_NAME_PROCESSOR_HXX
 #define CXX_TREE_NAME_PROCESSOR_HXX
 
+#include <types.hxx>
+
 #include <cxx/tree/elements.hxx>
+#include <cxx/tree/options.hxx>
 
 namespace CXX
 {
   namespace Tree
   {
-    using namespace Cult::Types;
-
     class NameProcessor
     {
     public:
-      NameProcessor (); // Dummy ctor, helps with long symbols on HP-UX.
-
-      Boolean
-      process (CLI::Options const&,
+      bool
+      process (options const&,
                XSDFrontend::SemanticGraph::Schema&,
                XSDFrontend::SemanticGraph::Path const& file,
                StringLiteralMap const&);
diff --git a/xsd/xsd/cxx/tree/options.cli b/xsd/xsd/cxx/tree/options.cli
new file mode 100644
index 0000000..f1b343a
--- /dev/null
+++ b/xsd/xsd/cxx/tree/options.cli
@@ -0,0 +1,480 @@
+// file      : xsd/cxx/tree/options.cli
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+include <cstddef>; // std::size_t
+
+include <types.hxx>; // NarrowString, NarrowStrings
+
+include <cxx/options.cli>;
+
+namespace CXX
+{
+  namespace Tree
+  {
+    class options: CXX::options
+    {
+      // Polymorphism.
+      //
+      bool --generate-polymorphic
+      {
+        "Generate polymorphism-aware code. Specify this option if you use
+         substitution groups or \cb{xsi:type}. Use the \cb{--polymorphic-type}
+         or \cb{--polymorphic-type-all} option to specify which type
+         hierarchies are polymorphic."
+      };
+
+      NarrowStrings --polymorphic-type
+      {
+        "<type>",
+        "Indicate that <type> is a root of a polymorphic type hierarchy. The
+         compiler can often automatically determine which types are
+         polymorphic based on the substitution group declarations. However,
+         you may need to use this option if you are not using substitution
+         groups or if substitution groups are defined in another schema. You
+         need to specify this option when compiling every schema file that
+         references <type>. The <type> argument is an XML Schema type name
+         that can be optionally qualified with a namespace in the
+         \c{\i{namespace}\b{#}\i{name}} form."
+      };
+
+      bool --polymorphic-type-all
+      {
+        "Indicate that all types should be treated as polymorphic."
+      };
+
+      unsigned long --polymorphic-plate = 0
+      {
+        "<num>",
+        "Specify the polymorphic map plate the generated code should register
+         on. This functionality is primarily useful to segregate multiple
+         schemas that define the same polymorphic types."
+      };
+
+      // Ordered content.
+      //
+      NarrowStrings --ordered-type
+      {
+        "<type>",
+        "Indicate that element order in <type> is significant. An example
+         would be a complex type with unbounded choice as a content model
+         where the element order in XML has application-specific semantics.
+         For ordered types the compiler generates a special container data
+         member and a corresponding set of accessors and modifiers that are
+         used to capture the order of elements and, for mixed content, of
+         text.
+
+         The <type> argument is an XML Schema type name that can be optionally
+         qualified with a namespace in the \c{\i{namespace}\b{#}\i{name}} form.
+         Note also that you will need to specify this option when compiling
+         every schema file that has other ordered types derived from this
+         type."
+      };
+
+      bool --ordered-type-derived
+      {
+        "Automatically treat types derived from ordered bases as also
+         ordered. This is primarily useful if you would like to be able
+         to iterate over the complete content using the content order
+         container."
+      };
+
+      bool --ordered-type-mixed
+      {
+        "Automatically treat complex types with mixed content as ordered."
+      };
+
+      bool --ordered-type-all
+      {
+        "Indicate that element order in all types is significant."
+      };
+
+      NarrowString --order-container
+      {
+        "<type>",
+        "Specify a custom class template that should be used as a container
+         for the content order in ordered types instead of the default
+         \cb{std::vector}. See \cb{--ordered-type} for more information on
+         ordered type. This option is primarily useful if you need to
+         perform more complex lookups in the content order container, for
+         example by element id. In this case, a container like Boost
+         multi-index may be more convenient. Note that if using a custom
+         container, you will also most likely need to include the relevant
+         headers using the \cb{--hxx-prologue*} options."
+      };
+
+      // Features.
+      //
+      bool --generate-serialization
+      {
+        "Generate serialization functions. Serialization functions convert
+         the object model back to XML."
+      };
+
+      bool --generate-ostream
+      {
+        "Generate ostream insertion operators (\cb{operator<<}) for generated
+         types. This allows one to easily print a fragment or the whole object
+         model for debugging or logging."
+      };
+
+      bool --generate-doxygen
+      {
+        "Generate documentation comments suitable for extraction by the
+         Doxygen documentation system. Documentation from annotations is
+         added to the comments if present in the schema."
+      };
+
+      bool --generate-comparison
+      {
+        "Generate comparison operators (\cb{operator==} and \cb{operator!=})
+         for complex types. Comparison is performed member-wise."
+      };
+
+      bool --generate-default-ctor
+      {
+        "Generate default constructors even for types that have required
+         members. Required members of an instance constructed using such a
+         constructor are not initialized and accessing them results in
+         undefined behavior."
+      };
+
+      bool --generate-from-base-ctor
+      {
+        "Generate constructors that expect an instance of a base type
+         followed by all required members."
+      };
+
+      bool --suppress-assignment
+      {
+        "Suppress the generation of copy assignment operators for complex
+         types. If this option is specified, the copy assignment operators
+         for such types are declared private and left unimplemented."
+      };
+
+      bool --generate-detach
+      {
+        "Generate detach functions for required elements and attributes.
+         Detach functions for optional and sequence cardinalities are
+         provided by the respective containers. These functions, for
+         example, allow you to move sub-trees in the object model either
+         within the same tree or between different trees."
+      };
+
+      bool --generate-wildcard
+      {
+        "Generate accessors and modifiers as well as parsing and serialization
+         code for XML Schema wildcards (\cb{any} and \cb{anyAttribute}). XML
+         content matched by wildcards is presented as DOM fragments. Note
+         that you need to initialize the Xerces-C++ runtime if you are using
+         this option."
+      };
+
+      bool --generate-any-type
+      {
+        "Extract and store content of the XML Schema \cb{anyType} type as a
+         DOM fragment. Note that you need to initialize the Xerces-C++ runtime
+         if you are using this option."
+      };
+
+      NarrowStrings --generate-insertion
+      {
+        "<os>",
+        "Generate data representation stream insertion operators for the <os>
+         output stream type. Repeat this option to specify more than one
+         stream type. The ACE CDR stream (\cb{ACE_OutputCDR}) and RPC XDR
+         are recognized by the compiler and the necessary \cb{#include}
+         directives are automatically generated. For custom stream types use
+         the \cb{--hxx-prologue*} options to provide the necessary
+         declarations."
+      };
+
+      NarrowStrings --generate-extraction
+      {
+        "<is>",
+        "Generate data representation stream extraction constructors for the
+         <is> input stream type. Repeat this option to specify more than one
+         stream type. The ACE CDR stream (\cb{ACE_InputCDR}) and RPC XDR are
+         recognized by the compiler and the necessary \cb{#include} directives
+         are automatically generated. For custom stream types use the
+         \cb{--hxx-prologue*} options to provide the necessary declarations."
+      };
+
+      bool --generate-forward
+      {
+        "Generate a separate header file with forward declarations for the
+         types being generated."
+      };
+
+      bool --suppress-parsing
+      {
+        "Suppress the generation of the parsing functions and constructors.
+         Use this option to reduce the generated code size when parsing from
+         XML is not needed."
+      };
+
+      bool --generate-element-type
+      {
+        "Generate types instead of parsing and serialization functions for
+         root elements. This is primarily useful to distinguish object models
+         with the same root type but with different root elements."
+      };
+
+      bool --generate-element-map
+      {
+        "Generate a root element map that allows uniform parsing and
+         serialization of multiple root elements. This option is only valid
+         together with \cb{--generate-element-type}."
+      };
+
+      bool --generate-intellisense
+      {
+        "Generate workarounds for IntelliSense bugs in Visual Studio 2005
+         (8.0). When this option is used, the resulting code is slightly
+         more verbose. IntelliSense in Visual Studio 2008 (9.0) and later
+         does not require these workarounds. Support for IntelliSense in
+         Visual Studio 2003 (7.1) is improved with this option but is
+         still incomplete."
+      };
+
+      bool --omit-default-attributes
+      {
+        "Omit attributes with default and fixed values from serialized XML
+         documents."
+      };
+
+      // Naming.
+      //
+      NarrowString --type-naming = "knr"
+      {
+        "<style>",
+        "Specify the type naming convention that should be used in the
+         generated code. Valid styles are \cb{knr} (default), \cb{ucc},
+         and \cb{java}. See the NAMING CONVENTION section below for more
+         information."
+      };
+
+      NarrowString --function-naming = "knr"
+      {
+        "<style>",
+        "Specify the function naming convention that should be used in the
+         generated code. Valid styles are \cb{knr} (default), \cb{lcc}, and
+         \cb{java}. See the NAMING CONVENTION section below for more
+         information."
+      };
+
+      NarrowStrings --type-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema type names to C++ type names. See the NAMING CONVENTION
+         section below for more information."
+      };
+
+      NarrowStrings --accessor-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes to C++ accessor function
+         names. See the NAMING CONVENTION section below for more information."
+      };
+
+      NarrowStrings --one-accessor-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes with cardinality one to
+         C++ accessor function names. See the NAMING CONVENTION section
+         below for more information."
+      };
+
+      NarrowStrings --opt-accessor-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes with cardinality optional
+         to C++ accessor function names. See the NAMING CONVENTION section
+         below for more information."
+      };
+
+      NarrowStrings --seq-accessor-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes with cardinality sequence
+         to C++ accessor function names. See the NAMING CONVENTION section
+         below for more information."
+      };
+
+      NarrowStrings --modifier-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes to C++ modifier function
+         names. See the NAMING CONVENTION section below for more information."
+      };
+
+      NarrowStrings --one-modifier-regex
+
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes with cardinality one to C++
+         modifier function names. See the NAMING CONVENTION section below
+         for more information."
+      };
+
+      NarrowStrings --opt-modifier-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes with cardinality optional
+         to C++ modifier function names. See the NAMING CONVENTION section
+         below for more information."
+      };
+
+      NarrowStrings --seq-modifier-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes with cardinality sequence
+         to C++ modifier function names. See the NAMING CONVENTION section
+         below for more information."
+      };
+
+      NarrowStrings --parser-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema element names to C++ parsing function names. See the
+         NAMING CONVENTION section below for more information."
+      };
+
+      NarrowStrings --serializer-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema element names to C++ serialization function names. See
+         the NAMING CONVENTION section below for more information."
+      };
+
+      NarrowStrings --const-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema-derived names to C++ constant names. See the NAMING
+         CONVENTION section below for more information."
+      };
+
+      NarrowStrings --enumerator-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema enumeration values to C++ enumerator names. See the
+         NAMING CONVENTION section below for more information."
+      };
+
+      NarrowStrings --element-type-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema element names to C++ element type names. See the NAMING
+         CONVENTION section below for more information."
+      };
+
+      bool --name-regex-trace
+      {
+        "Trace the process of applying regular expressions specified with
+         the name transformation options. Use this option to find out why
+         your regular expressions don't do what you expected them to do."
+      };
+
+      // Root element.
+      //
+      bool --root-element-first
+      {
+        "Treat only the first global element as a document root. By default
+         all global elements are considered document roots."
+      };
+
+      bool --root-element-last
+      {
+        "Treat only the last global element as a document root. By default
+         all global elements are considered document roots."
+      };
+
+      bool --root-element-all
+      {
+        "Treat all global elements as document roots. This is the default
+         behavior. By explicitly specifying this option you can suppress
+         the warning that is issued if more than one global element is
+         defined."
+      };
+
+      bool --root-element-none
+      {
+        "Do not treat any global elements as document roots. By default all
+         global elements are considered document roots."
+      };
+
+      NarrowStrings --root-element
+      {
+        "<element>",
+        "Treat only <element> as a document root. Repeat this option to
+         specify more than one root element."
+      };
+
+      // Custom type.
+      //
+      NarrowStrings --custom-type
+      {
+        "<map>",
+        "Use a custom C++ type instead of the generated class. The <map>
+         argument is in the form \c{\i{name}[\b{=}\i{type}[\b{/}\i{base}]]},
+         where \i{name} is a type name as defined in XML Schema and \i{type}
+         is a C++ type name that should be used instead. If \i{type} is not
+         present or empty then the custom type is assumed to have the same
+         name and be defined in the same namespace as the generated class
+         would have. If \i{base} is specified then the generated class is
+         still generated but with that name."
+      };
+
+      NarrowStrings --custom-type-regex
+      {
+        "<regex>",
+        "Use custom C++ types instead of the generated classes. The <regex>
+         argument is in the form
+         \c{\b{/}\i{name-pat}\b{/}[\i{type-sub}\b{/}[\i{base-sub}\b{/}]]},
+         where \i{name-pat} is a regex pattern that will be matched against
+         type names as defined in XML Schema and \i{type-sub} is a C++ type
+         name substitution that should be used instead. If \i{type-sub} is
+         not present or its substitution results in an empty string then
+         the custom type is assumed to have the same name and be defined
+         in the same namespace as the generated class would have. If
+         \i{base-sub} is present and its substitution results in a
+         non-empty string then the generated class is still generated
+         but with the result of this substitution as its name. The pattern
+         and substitutions are in the Perl regular expression format.
+         See also the REGEX AND SHELL QUOTING section below."
+      };
+
+      // Parts.
+      //
+      std::size_t --parts = 1
+      {
+        "<num>",
+        "Split generated source code into <num> parts. This is useful when
+         translating large, monolithic schemas and a C++ compiler is not
+         able to compile the resulting source code at once (usually due
+         to insufficient memory)."
+      };
+
+      NarrowString --parts-suffix = "-"
+      {
+        "<suffix>",
+        "Use <suffix> instead of the default '\cb{-}' to separate the file
+         name from the part number."
+      };
+    };
+  }
+}
diff --git a/xsd/xsd/cxx/tree/options.cxx b/xsd/xsd/cxx/tree/options.cxx
new file mode 100644
index 0000000..820ebac
--- /dev/null
+++ b/xsd/xsd/cxx/tree/options.cxx
@@ -0,0 +1,1149 @@
+// This code was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <options-parser.hxx>
+//
+// End prologue.
+
+#include <cxx/tree/options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <ostream>
+#include <sstream>
+
+namespace cli
+{
+  template <typename X>
+  struct parser
+  {
+    static void
+    parse (X& x, bool& xs, scanner& s)
+    {
+      std::string o (s.next ());
+
+      if (s.more ())
+      {
+        std::string v (s.next ());
+        std::istringstream is (v);
+        if (!(is >> x && is.eof ()))
+          throw invalid_value (o, v);
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <>
+  struct parser<bool>
+  {
+    static void
+    parse (bool& x, scanner& s)
+    {
+      s.next ();
+      x = true;
+    }
+  };
+
+  template <>
+  struct parser<std::string>
+  {
+    static void
+    parse (std::string& x, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+        x = s.next ();
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X>
+  struct parser<std::vector<X> >
+  {
+    static void
+    parse (std::vector<X>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.push_back (x);
+      xs = true;
+    }
+  };
+
+  template <typename X>
+  struct parser<std::set<X> >
+  {
+    static void
+    parse (std::set<X>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.insert (x);
+      xs = true;
+    }
+  };
+
+  template <typename K, typename V>
+  struct parser<std::map<K, V> >
+  {
+    static void
+    parse (std::map<K, V>& m, bool& xs, scanner& s)
+    {
+      std::string o (s.next ());
+
+      if (s.more ())
+      {
+        std::string ov (s.next ());
+        std::string::size_type p = ov.find ('=');
+
+        if (p == std::string::npos)
+        {
+          K k = K ();
+
+          if (!ov.empty ())
+          {
+            std::istringstream ks (ov);
+
+            if (!(ks >> k && ks.eof ()))
+              throw invalid_value (o, ov);
+          }
+
+          m[k] = V ();
+        }
+        else
+        {
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, p + 1);
+
+          if (!kstr.empty ())
+          {
+            std::istringstream ks (kstr);
+
+            if (!(ks >> k && ks.eof ()))
+              throw invalid_value (o, ov);
+          }
+
+          if (!vstr.empty ())
+          {
+            std::istringstream vs (vstr);
+
+            if (!(vs >> v && vs.eof ()))
+              throw invalid_value (o, ov);
+          }
+
+          m[k] = v;
+        }
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X, typename T, T X::*M>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, s);
+  }
+
+  template <typename X, typename T, T X::*M, bool X::*S>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, x.*S, s);
+  }
+}
+
+#include <map>
+#include <cstring>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    // options
+    //
+
+    options::
+    options ()
+    : generate_polymorphic_ (),
+      polymorphic_type_ (),
+      polymorphic_type_specified_ (false),
+      polymorphic_type_all_ (),
+      polymorphic_plate_ (0),
+      polymorphic_plate_specified_ (false),
+      ordered_type_ (),
+      ordered_type_specified_ (false),
+      ordered_type_derived_ (),
+      ordered_type_mixed_ (),
+      ordered_type_all_ (),
+      order_container_ (),
+      order_container_specified_ (false),
+      generate_serialization_ (),
+      generate_ostream_ (),
+      generate_doxygen_ (),
+      generate_comparison_ (),
+      generate_default_ctor_ (),
+      generate_from_base_ctor_ (),
+      suppress_assignment_ (),
+      generate_detach_ (),
+      generate_wildcard_ (),
+      generate_any_type_ (),
+      generate_insertion_ (),
+      generate_insertion_specified_ (false),
+      generate_extraction_ (),
+      generate_extraction_specified_ (false),
+      generate_forward_ (),
+      suppress_parsing_ (),
+      generate_element_type_ (),
+      generate_element_map_ (),
+      generate_intellisense_ (),
+      omit_default_attributes_ (),
+      type_naming_ ("knr"),
+      type_naming_specified_ (false),
+      function_naming_ ("knr"),
+      function_naming_specified_ (false),
+      type_regex_ (),
+      type_regex_specified_ (false),
+      accessor_regex_ (),
+      accessor_regex_specified_ (false),
+      one_accessor_regex_ (),
+      one_accessor_regex_specified_ (false),
+      opt_accessor_regex_ (),
+      opt_accessor_regex_specified_ (false),
+      seq_accessor_regex_ (),
+      seq_accessor_regex_specified_ (false),
+      modifier_regex_ (),
+      modifier_regex_specified_ (false),
+      one_modifier_regex_ (),
+      one_modifier_regex_specified_ (false),
+      opt_modifier_regex_ (),
+      opt_modifier_regex_specified_ (false),
+      seq_modifier_regex_ (),
+      seq_modifier_regex_specified_ (false),
+      parser_regex_ (),
+      parser_regex_specified_ (false),
+      serializer_regex_ (),
+      serializer_regex_specified_ (false),
+      const_regex_ (),
+      const_regex_specified_ (false),
+      enumerator_regex_ (),
+      enumerator_regex_specified_ (false),
+      element_type_regex_ (),
+      element_type_regex_specified_ (false),
+      name_regex_trace_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_all_ (),
+      root_element_none_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      custom_type_ (),
+      custom_type_specified_ (false),
+      custom_type_regex_ (),
+      custom_type_regex_specified_ (false),
+      parts_ (1),
+      parts_specified_ (false),
+      parts_suffix_ ("-"),
+      parts_suffix_specified_ (false)
+    {
+    }
+
+    options::
+    options (int& argc,
+             char** argv,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : generate_polymorphic_ (),
+      polymorphic_type_ (),
+      polymorphic_type_specified_ (false),
+      polymorphic_type_all_ (),
+      polymorphic_plate_ (0),
+      polymorphic_plate_specified_ (false),
+      ordered_type_ (),
+      ordered_type_specified_ (false),
+      ordered_type_derived_ (),
+      ordered_type_mixed_ (),
+      ordered_type_all_ (),
+      order_container_ (),
+      order_container_specified_ (false),
+      generate_serialization_ (),
+      generate_ostream_ (),
+      generate_doxygen_ (),
+      generate_comparison_ (),
+      generate_default_ctor_ (),
+      generate_from_base_ctor_ (),
+      suppress_assignment_ (),
+      generate_detach_ (),
+      generate_wildcard_ (),
+      generate_any_type_ (),
+      generate_insertion_ (),
+      generate_insertion_specified_ (false),
+      generate_extraction_ (),
+      generate_extraction_specified_ (false),
+      generate_forward_ (),
+      suppress_parsing_ (),
+      generate_element_type_ (),
+      generate_element_map_ (),
+      generate_intellisense_ (),
+      omit_default_attributes_ (),
+      type_naming_ ("knr"),
+      type_naming_specified_ (false),
+      function_naming_ ("knr"),
+      function_naming_specified_ (false),
+      type_regex_ (),
+      type_regex_specified_ (false),
+      accessor_regex_ (),
+      accessor_regex_specified_ (false),
+      one_accessor_regex_ (),
+      one_accessor_regex_specified_ (false),
+      opt_accessor_regex_ (),
+      opt_accessor_regex_specified_ (false),
+      seq_accessor_regex_ (),
+      seq_accessor_regex_specified_ (false),
+      modifier_regex_ (),
+      modifier_regex_specified_ (false),
+      one_modifier_regex_ (),
+      one_modifier_regex_specified_ (false),
+      opt_modifier_regex_ (),
+      opt_modifier_regex_specified_ (false),
+      seq_modifier_regex_ (),
+      seq_modifier_regex_specified_ (false),
+      parser_regex_ (),
+      parser_regex_specified_ (false),
+      serializer_regex_ (),
+      serializer_regex_specified_ (false),
+      const_regex_ (),
+      const_regex_specified_ (false),
+      enumerator_regex_ (),
+      enumerator_regex_specified_ (false),
+      element_type_regex_ (),
+      element_type_regex_specified_ (false),
+      name_regex_trace_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_all_ (),
+      root_element_none_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      custom_type_ (),
+      custom_type_specified_ (false),
+      custom_type_regex_ (),
+      custom_type_regex_specified_ (false),
+      parts_ (1),
+      parts_specified_ (false),
+      parts_suffix_ ("-"),
+      parts_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (argc, argv, erase);
+      _parse (s, opt, arg);
+    }
+
+    options::
+    options (int start,
+             int& argc,
+             char** argv,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : generate_polymorphic_ (),
+      polymorphic_type_ (),
+      polymorphic_type_specified_ (false),
+      polymorphic_type_all_ (),
+      polymorphic_plate_ (0),
+      polymorphic_plate_specified_ (false),
+      ordered_type_ (),
+      ordered_type_specified_ (false),
+      ordered_type_derived_ (),
+      ordered_type_mixed_ (),
+      ordered_type_all_ (),
+      order_container_ (),
+      order_container_specified_ (false),
+      generate_serialization_ (),
+      generate_ostream_ (),
+      generate_doxygen_ (),
+      generate_comparison_ (),
+      generate_default_ctor_ (),
+      generate_from_base_ctor_ (),
+      suppress_assignment_ (),
+      generate_detach_ (),
+      generate_wildcard_ (),
+      generate_any_type_ (),
+      generate_insertion_ (),
+      generate_insertion_specified_ (false),
+      generate_extraction_ (),
+      generate_extraction_specified_ (false),
+      generate_forward_ (),
+      suppress_parsing_ (),
+      generate_element_type_ (),
+      generate_element_map_ (),
+      generate_intellisense_ (),
+      omit_default_attributes_ (),
+      type_naming_ ("knr"),
+      type_naming_specified_ (false),
+      function_naming_ ("knr"),
+      function_naming_specified_ (false),
+      type_regex_ (),
+      type_regex_specified_ (false),
+      accessor_regex_ (),
+      accessor_regex_specified_ (false),
+      one_accessor_regex_ (),
+      one_accessor_regex_specified_ (false),
+      opt_accessor_regex_ (),
+      opt_accessor_regex_specified_ (false),
+      seq_accessor_regex_ (),
+      seq_accessor_regex_specified_ (false),
+      modifier_regex_ (),
+      modifier_regex_specified_ (false),
+      one_modifier_regex_ (),
+      one_modifier_regex_specified_ (false),
+      opt_modifier_regex_ (),
+      opt_modifier_regex_specified_ (false),
+      seq_modifier_regex_ (),
+      seq_modifier_regex_specified_ (false),
+      parser_regex_ (),
+      parser_regex_specified_ (false),
+      serializer_regex_ (),
+      serializer_regex_specified_ (false),
+      const_regex_ (),
+      const_regex_specified_ (false),
+      enumerator_regex_ (),
+      enumerator_regex_specified_ (false),
+      element_type_regex_ (),
+      element_type_regex_specified_ (false),
+      name_regex_trace_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_all_ (),
+      root_element_none_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      custom_type_ (),
+      custom_type_specified_ (false),
+      custom_type_regex_ (),
+      custom_type_regex_specified_ (false),
+      parts_ (1),
+      parts_specified_ (false),
+      parts_suffix_ ("-"),
+      parts_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (start, argc, argv, erase);
+      _parse (s, opt, arg);
+    }
+
+    options::
+    options (int& argc,
+             char** argv,
+             int& end,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : generate_polymorphic_ (),
+      polymorphic_type_ (),
+      polymorphic_type_specified_ (false),
+      polymorphic_type_all_ (),
+      polymorphic_plate_ (0),
+      polymorphic_plate_specified_ (false),
+      ordered_type_ (),
+      ordered_type_specified_ (false),
+      ordered_type_derived_ (),
+      ordered_type_mixed_ (),
+      ordered_type_all_ (),
+      order_container_ (),
+      order_container_specified_ (false),
+      generate_serialization_ (),
+      generate_ostream_ (),
+      generate_doxygen_ (),
+      generate_comparison_ (),
+      generate_default_ctor_ (),
+      generate_from_base_ctor_ (),
+      suppress_assignment_ (),
+      generate_detach_ (),
+      generate_wildcard_ (),
+      generate_any_type_ (),
+      generate_insertion_ (),
+      generate_insertion_specified_ (false),
+      generate_extraction_ (),
+      generate_extraction_specified_ (false),
+      generate_forward_ (),
+      suppress_parsing_ (),
+      generate_element_type_ (),
+      generate_element_map_ (),
+      generate_intellisense_ (),
+      omit_default_attributes_ (),
+      type_naming_ ("knr"),
+      type_naming_specified_ (false),
+      function_naming_ ("knr"),
+      function_naming_specified_ (false),
+      type_regex_ (),
+      type_regex_specified_ (false),
+      accessor_regex_ (),
+      accessor_regex_specified_ (false),
+      one_accessor_regex_ (),
+      one_accessor_regex_specified_ (false),
+      opt_accessor_regex_ (),
+      opt_accessor_regex_specified_ (false),
+      seq_accessor_regex_ (),
+      seq_accessor_regex_specified_ (false),
+      modifier_regex_ (),
+      modifier_regex_specified_ (false),
+      one_modifier_regex_ (),
+      one_modifier_regex_specified_ (false),
+      opt_modifier_regex_ (),
+      opt_modifier_regex_specified_ (false),
+      seq_modifier_regex_ (),
+      seq_modifier_regex_specified_ (false),
+      parser_regex_ (),
+      parser_regex_specified_ (false),
+      serializer_regex_ (),
+      serializer_regex_specified_ (false),
+      const_regex_ (),
+      const_regex_specified_ (false),
+      enumerator_regex_ (),
+      enumerator_regex_specified_ (false),
+      element_type_regex_ (),
+      element_type_regex_specified_ (false),
+      name_regex_trace_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_all_ (),
+      root_element_none_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      custom_type_ (),
+      custom_type_specified_ (false),
+      custom_type_regex_ (),
+      custom_type_regex_specified_ (false),
+      parts_ (1),
+      parts_specified_ (false),
+      parts_suffix_ ("-"),
+      parts_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (argc, argv, erase);
+      _parse (s, opt, arg);
+      end = s.end ();
+    }
+
+    options::
+    options (int start,
+             int& argc,
+             char** argv,
+             int& end,
+             bool erase,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : generate_polymorphic_ (),
+      polymorphic_type_ (),
+      polymorphic_type_specified_ (false),
+      polymorphic_type_all_ (),
+      polymorphic_plate_ (0),
+      polymorphic_plate_specified_ (false),
+      ordered_type_ (),
+      ordered_type_specified_ (false),
+      ordered_type_derived_ (),
+      ordered_type_mixed_ (),
+      ordered_type_all_ (),
+      order_container_ (),
+      order_container_specified_ (false),
+      generate_serialization_ (),
+      generate_ostream_ (),
+      generate_doxygen_ (),
+      generate_comparison_ (),
+      generate_default_ctor_ (),
+      generate_from_base_ctor_ (),
+      suppress_assignment_ (),
+      generate_detach_ (),
+      generate_wildcard_ (),
+      generate_any_type_ (),
+      generate_insertion_ (),
+      generate_insertion_specified_ (false),
+      generate_extraction_ (),
+      generate_extraction_specified_ (false),
+      generate_forward_ (),
+      suppress_parsing_ (),
+      generate_element_type_ (),
+      generate_element_map_ (),
+      generate_intellisense_ (),
+      omit_default_attributes_ (),
+      type_naming_ ("knr"),
+      type_naming_specified_ (false),
+      function_naming_ ("knr"),
+      function_naming_specified_ (false),
+      type_regex_ (),
+      type_regex_specified_ (false),
+      accessor_regex_ (),
+      accessor_regex_specified_ (false),
+      one_accessor_regex_ (),
+      one_accessor_regex_specified_ (false),
+      opt_accessor_regex_ (),
+      opt_accessor_regex_specified_ (false),
+      seq_accessor_regex_ (),
+      seq_accessor_regex_specified_ (false),
+      modifier_regex_ (),
+      modifier_regex_specified_ (false),
+      one_modifier_regex_ (),
+      one_modifier_regex_specified_ (false),
+      opt_modifier_regex_ (),
+      opt_modifier_regex_specified_ (false),
+      seq_modifier_regex_ (),
+      seq_modifier_regex_specified_ (false),
+      parser_regex_ (),
+      parser_regex_specified_ (false),
+      serializer_regex_ (),
+      serializer_regex_specified_ (false),
+      const_regex_ (),
+      const_regex_specified_ (false),
+      enumerator_regex_ (),
+      enumerator_regex_specified_ (false),
+      element_type_regex_ (),
+      element_type_regex_specified_ (false),
+      name_regex_trace_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_all_ (),
+      root_element_none_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      custom_type_ (),
+      custom_type_specified_ (false),
+      custom_type_regex_ (),
+      custom_type_regex_specified_ (false),
+      parts_ (1),
+      parts_specified_ (false),
+      parts_suffix_ ("-"),
+      parts_suffix_specified_ (false)
+    {
+      ::cli::argv_scanner s (start, argc, argv, erase);
+      _parse (s, opt, arg);
+      end = s.end ();
+    }
+
+    options::
+    options (::cli::scanner& s,
+             ::cli::unknown_mode opt,
+             ::cli::unknown_mode arg)
+    : generate_polymorphic_ (),
+      polymorphic_type_ (),
+      polymorphic_type_specified_ (false),
+      polymorphic_type_all_ (),
+      polymorphic_plate_ (0),
+      polymorphic_plate_specified_ (false),
+      ordered_type_ (),
+      ordered_type_specified_ (false),
+      ordered_type_derived_ (),
+      ordered_type_mixed_ (),
+      ordered_type_all_ (),
+      order_container_ (),
+      order_container_specified_ (false),
+      generate_serialization_ (),
+      generate_ostream_ (),
+      generate_doxygen_ (),
+      generate_comparison_ (),
+      generate_default_ctor_ (),
+      generate_from_base_ctor_ (),
+      suppress_assignment_ (),
+      generate_detach_ (),
+      generate_wildcard_ (),
+      generate_any_type_ (),
+      generate_insertion_ (),
+      generate_insertion_specified_ (false),
+      generate_extraction_ (),
+      generate_extraction_specified_ (false),
+      generate_forward_ (),
+      suppress_parsing_ (),
+      generate_element_type_ (),
+      generate_element_map_ (),
+      generate_intellisense_ (),
+      omit_default_attributes_ (),
+      type_naming_ ("knr"),
+      type_naming_specified_ (false),
+      function_naming_ ("knr"),
+      function_naming_specified_ (false),
+      type_regex_ (),
+      type_regex_specified_ (false),
+      accessor_regex_ (),
+      accessor_regex_specified_ (false),
+      one_accessor_regex_ (),
+      one_accessor_regex_specified_ (false),
+      opt_accessor_regex_ (),
+      opt_accessor_regex_specified_ (false),
+      seq_accessor_regex_ (),
+      seq_accessor_regex_specified_ (false),
+      modifier_regex_ (),
+      modifier_regex_specified_ (false),
+      one_modifier_regex_ (),
+      one_modifier_regex_specified_ (false),
+      opt_modifier_regex_ (),
+      opt_modifier_regex_specified_ (false),
+      seq_modifier_regex_ (),
+      seq_modifier_regex_specified_ (false),
+      parser_regex_ (),
+      parser_regex_specified_ (false),
+      serializer_regex_ (),
+      serializer_regex_specified_ (false),
+      const_regex_ (),
+      const_regex_specified_ (false),
+      enumerator_regex_ (),
+      enumerator_regex_specified_ (false),
+      element_type_regex_ (),
+      element_type_regex_specified_ (false),
+      name_regex_trace_ (),
+      root_element_first_ (),
+      root_element_last_ (),
+      root_element_all_ (),
+      root_element_none_ (),
+      root_element_ (),
+      root_element_specified_ (false),
+      custom_type_ (),
+      custom_type_specified_ (false),
+      custom_type_regex_ (),
+      custom_type_regex_specified_ (false),
+      parts_ (1),
+      parts_specified_ (false),
+      parts_suffix_ ("-"),
+      parts_suffix_specified_ (false)
+    {
+      _parse (s, opt, arg);
+    }
+
+    void options::
+    print_usage (::std::wostream& os)
+    {
+      os << "--generate-polymorphic       Generate polymorphism-aware code." << ::std::endl;
+
+      os << "--polymorphic-type <type>    Indicate that <type> is a root of a polymorphic" << ::std::endl
+         << "                             type hierarchy." << ::std::endl;
+
+      os << "--polymorphic-type-all       Indicate that all types should be treated as" << ::std::endl
+         << "                             polymorphic." << ::std::endl;
+
+      os << "--polymorphic-plate <num>    Specify the polymorphic map plate the generated" << ::std::endl
+         << "                             code should register on." << ::std::endl;
+
+      os << "--ordered-type <type>        Indicate that element order in <type> is" << ::std::endl
+         << "                             significant." << ::std::endl;
+
+      os << "--ordered-type-derived       Automatically treat types derived from ordered" << ::std::endl
+         << "                             bases as also ordered." << ::std::endl;
+
+      os << "--ordered-type-mixed         Automatically treat complex types with mixed" << ::std::endl
+         << "                             content as ordered." << ::std::endl;
+
+      os << "--ordered-type-all           Indicate that element order in all types is" << ::std::endl
+         << "                             significant." << ::std::endl;
+
+      os << "--order-container <type>     Specify a custom class template that should be" << ::std::endl
+         << "                             used as a container for the content order in" << ::std::endl
+         << "                             ordered types instead of the default" << ::std::endl
+         << "                             'std::vector'." << ::std::endl;
+
+      os << "--generate-serialization     Generate serialization functions." << ::std::endl;
+
+      os << "--generate-ostream           Generate ostream insertion operators" << ::std::endl
+         << "                             ('operator<<') for generated types." << ::std::endl;
+
+      os << "--generate-doxygen           Generate documentation comments suitable for" << ::std::endl
+         << "                             extraction by the Doxygen documentation system." << ::std::endl;
+
+      os << "--generate-comparison        Generate comparison operators ('operator==' and" << ::std::endl
+         << "                             'operator!=') for complex types." << ::std::endl;
+
+      os << "--generate-default-ctor      Generate default constructors even for types that" << ::std::endl
+         << "                             have required members." << ::std::endl;
+
+      os << "--generate-from-base-ctor    Generate constructors that expect an instance of a" << ::std::endl
+         << "                             base type followed by all required members." << ::std::endl;
+
+      os << "--suppress-assignment        Suppress the generation of copy assignment" << ::std::endl
+         << "                             operators for complex types." << ::std::endl;
+
+      os << "--generate-detach            Generate detach functions for required elements" << ::std::endl
+         << "                             and attributes." << ::std::endl;
+
+      os << "--generate-wildcard          Generate accessors and modifiers as well as" << ::std::endl
+         << "                             parsing and serialization code for XML Schema" << ::std::endl
+         << "                             wildcards ('any' and 'anyAttribute')." << ::std::endl;
+
+      os << "--generate-any-type          Extract and store content of the XML Schema" << ::std::endl
+         << "                             'anyType' type as a DOM fragment." << ::std::endl;
+
+      os << "--generate-insertion <os>    Generate data representation stream insertion" << ::std::endl
+         << "                             operators for the <os> output stream type." << ::std::endl;
+
+      os << "--generate-extraction <is>   Generate data representation stream extraction" << ::std::endl
+         << "                             constructors for the <is> input stream type." << ::std::endl;
+
+      os << "--generate-forward           Generate a separate header file with forward" << ::std::endl
+         << "                             declarations for the types being generated." << ::std::endl;
+
+      os << "--suppress-parsing           Suppress the generation of the parsing functions" << ::std::endl
+         << "                             and constructors." << ::std::endl;
+
+      os << "--generate-element-type      Generate types instead of parsing and" << ::std::endl
+         << "                             serialization functions for root elements." << ::std::endl;
+
+      os << "--generate-element-map       Generate a root element map that allows uniform" << ::std::endl
+         << "                             parsing and serialization of multiple root" << ::std::endl
+         << "                             elements." << ::std::endl;
+
+      os << "--generate-intellisense      Generate workarounds for IntelliSense bugs in" << ::std::endl
+         << "                             Visual Studio 2005 (8.0)." << ::std::endl;
+
+      os << "--omit-default-attributes    Omit attributes with default and fixed values from" << ::std::endl
+         << "                             serialized XML documents." << ::std::endl;
+
+      os << "--type-naming <style>        Specify the type naming convention that should be" << ::std::endl
+         << "                             used in the generated code." << ::std::endl;
+
+      os << "--function-naming <style>    Specify the function naming convention that should" << ::std::endl
+         << "                             be used in the generated code." << ::std::endl;
+
+      os << "--type-regex <regex>         Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema type names to C++" << ::std::endl
+         << "                             type names." << ::std::endl;
+
+      os << "--accessor-regex <regex>     Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes to C++ accessor function" << ::std::endl
+         << "                             names." << ::std::endl;
+
+      os << "--one-accessor-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes with cardinality one to C++" << ::std::endl
+         << "                             accessor function names." << ::std::endl;
+
+      os << "--opt-accessor-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes with cardinality optional to" << ::std::endl
+         << "                             C++ accessor function names." << ::std::endl;
+
+      os << "--seq-accessor-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes with cardinality sequence to" << ::std::endl
+         << "                             C++ accessor function names." << ::std::endl;
+
+      os << "--modifier-regex <regex>     Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes to C++ modifier function" << ::std::endl
+         << "                             names." << ::std::endl;
+
+      os << "--one-modifier-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes with cardinality one to C++" << ::std::endl
+         << "                             modifier function names." << ::std::endl;
+
+      os << "--opt-modifier-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes with cardinality optional to" << ::std::endl
+         << "                             C++ modifier function names." << ::std::endl;
+
+      os << "--seq-modifier-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema names of" << ::std::endl
+         << "                             elements/attributes with cardinality sequence to" << ::std::endl
+         << "                             C++ modifier function names." << ::std::endl;
+
+      os << "--parser-regex <regex>       Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema element names to C++" << ::std::endl
+         << "                             parsing function names." << ::std::endl;
+
+      os << "--serializer-regex <regex>   Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema element names to C++" << ::std::endl
+         << "                             serialization function names." << ::std::endl;
+
+      os << "--const-regex <regex>        Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema-derived names to C++" << ::std::endl
+         << "                             constant names." << ::std::endl;
+
+      os << "--enumerator-regex <regex>   Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema enumeration values to" << ::std::endl
+         << "                             C++ enumerator names." << ::std::endl;
+
+      os << "--element-type-regex <regex> Add <regex> to the list of regular expressions" << ::std::endl
+         << "                             used to translate XML Schema element names to C++" << ::std::endl
+         << "                             element type names." << ::std::endl;
+
+      os << "--name-regex-trace           Trace the process of applying regular expressions" << ::std::endl
+         << "                             specified with the name transformation options." << ::std::endl;
+
+      os << "--root-element-first         Treat only the first global element as a document" << ::std::endl
+         << "                             root." << ::std::endl;
+
+      os << "--root-element-last          Treat only the last global element as a document" << ::std::endl
+         << "                             root." << ::std::endl;
+
+      os << "--root-element-all           Treat all global elements as document roots." << ::std::endl;
+
+      os << "--root-element-none          Do not treat any global elements as document" << ::std::endl
+         << "                             roots." << ::std::endl;
+
+      os << "--root-element <element>     Treat only <element> as a document root." << ::std::endl;
+
+      os << "--custom-type <map>          Use a custom C++ type instead of the generated" << ::std::endl
+         << "                             class." << ::std::endl;
+
+      os << "--custom-type-regex <regex>  Use custom C++ types instead of the generated" << ::std::endl
+         << "                             classes." << ::std::endl;
+
+      os << "--parts <num>                Split generated source code into <num> parts." << ::std::endl;
+
+      os << "--parts-suffix <suffix>      Use <suffix> instead of the default ''-'' to" << ::std::endl
+         << "                             separate the file name from the part number." << ::std::endl;
+    }
+
+    typedef
+    std::map<std::string, void (*) (options&, ::cli::scanner&)>
+    _cli_options_map;
+
+    static _cli_options_map _cli_options_map_;
+
+    struct _cli_options_map_init
+    {
+      _cli_options_map_init ()
+      {
+        _cli_options_map_["--generate-polymorphic"] = 
+        &::cli::thunk< options, bool, &options::generate_polymorphic_ >;
+        _cli_options_map_["--polymorphic-type"] = 
+        &::cli::thunk< options, NarrowStrings, &options::polymorphic_type_,
+          &options::polymorphic_type_specified_ >;
+        _cli_options_map_["--polymorphic-type-all"] = 
+        &::cli::thunk< options, bool, &options::polymorphic_type_all_ >;
+        _cli_options_map_["--polymorphic-plate"] = 
+        &::cli::thunk< options, unsigned long, &options::polymorphic_plate_,
+          &options::polymorphic_plate_specified_ >;
+        _cli_options_map_["--ordered-type"] = 
+        &::cli::thunk< options, NarrowStrings, &options::ordered_type_,
+          &options::ordered_type_specified_ >;
+        _cli_options_map_["--ordered-type-derived"] = 
+        &::cli::thunk< options, bool, &options::ordered_type_derived_ >;
+        _cli_options_map_["--ordered-type-mixed"] = 
+        &::cli::thunk< options, bool, &options::ordered_type_mixed_ >;
+        _cli_options_map_["--ordered-type-all"] = 
+        &::cli::thunk< options, bool, &options::ordered_type_all_ >;
+        _cli_options_map_["--order-container"] = 
+        &::cli::thunk< options, NarrowString, &options::order_container_,
+          &options::order_container_specified_ >;
+        _cli_options_map_["--generate-serialization"] = 
+        &::cli::thunk< options, bool, &options::generate_serialization_ >;
+        _cli_options_map_["--generate-ostream"] = 
+        &::cli::thunk< options, bool, &options::generate_ostream_ >;
+        _cli_options_map_["--generate-doxygen"] = 
+        &::cli::thunk< options, bool, &options::generate_doxygen_ >;
+        _cli_options_map_["--generate-comparison"] = 
+        &::cli::thunk< options, bool, &options::generate_comparison_ >;
+        _cli_options_map_["--generate-default-ctor"] = 
+        &::cli::thunk< options, bool, &options::generate_default_ctor_ >;
+        _cli_options_map_["--generate-from-base-ctor"] = 
+        &::cli::thunk< options, bool, &options::generate_from_base_ctor_ >;
+        _cli_options_map_["--suppress-assignment"] = 
+        &::cli::thunk< options, bool, &options::suppress_assignment_ >;
+        _cli_options_map_["--generate-detach"] = 
+        &::cli::thunk< options, bool, &options::generate_detach_ >;
+        _cli_options_map_["--generate-wildcard"] = 
+        &::cli::thunk< options, bool, &options::generate_wildcard_ >;
+        _cli_options_map_["--generate-any-type"] = 
+        &::cli::thunk< options, bool, &options::generate_any_type_ >;
+        _cli_options_map_["--generate-insertion"] = 
+        &::cli::thunk< options, NarrowStrings, &options::generate_insertion_,
+          &options::generate_insertion_specified_ >;
+        _cli_options_map_["--generate-extraction"] = 
+        &::cli::thunk< options, NarrowStrings, &options::generate_extraction_,
+          &options::generate_extraction_specified_ >;
+        _cli_options_map_["--generate-forward"] = 
+        &::cli::thunk< options, bool, &options::generate_forward_ >;
+        _cli_options_map_["--suppress-parsing"] = 
+        &::cli::thunk< options, bool, &options::suppress_parsing_ >;
+        _cli_options_map_["--generate-element-type"] = 
+        &::cli::thunk< options, bool, &options::generate_element_type_ >;
+        _cli_options_map_["--generate-element-map"] = 
+        &::cli::thunk< options, bool, &options::generate_element_map_ >;
+        _cli_options_map_["--generate-intellisense"] = 
+        &::cli::thunk< options, bool, &options::generate_intellisense_ >;
+        _cli_options_map_["--omit-default-attributes"] = 
+        &::cli::thunk< options, bool, &options::omit_default_attributes_ >;
+        _cli_options_map_["--type-naming"] = 
+        &::cli::thunk< options, NarrowString, &options::type_naming_,
+          &options::type_naming_specified_ >;
+        _cli_options_map_["--function-naming"] = 
+        &::cli::thunk< options, NarrowString, &options::function_naming_,
+          &options::function_naming_specified_ >;
+        _cli_options_map_["--type-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::type_regex_,
+          &options::type_regex_specified_ >;
+        _cli_options_map_["--accessor-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::accessor_regex_,
+          &options::accessor_regex_specified_ >;
+        _cli_options_map_["--one-accessor-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::one_accessor_regex_,
+          &options::one_accessor_regex_specified_ >;
+        _cli_options_map_["--opt-accessor-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::opt_accessor_regex_,
+          &options::opt_accessor_regex_specified_ >;
+        _cli_options_map_["--seq-accessor-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::seq_accessor_regex_,
+          &options::seq_accessor_regex_specified_ >;
+        _cli_options_map_["--modifier-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::modifier_regex_,
+          &options::modifier_regex_specified_ >;
+        _cli_options_map_["--one-modifier-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::one_modifier_regex_,
+          &options::one_modifier_regex_specified_ >;
+        _cli_options_map_["--opt-modifier-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::opt_modifier_regex_,
+          &options::opt_modifier_regex_specified_ >;
+        _cli_options_map_["--seq-modifier-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::seq_modifier_regex_,
+          &options::seq_modifier_regex_specified_ >;
+        _cli_options_map_["--parser-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::parser_regex_,
+          &options::parser_regex_specified_ >;
+        _cli_options_map_["--serializer-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::serializer_regex_,
+          &options::serializer_regex_specified_ >;
+        _cli_options_map_["--const-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::const_regex_,
+          &options::const_regex_specified_ >;
+        _cli_options_map_["--enumerator-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::enumerator_regex_,
+          &options::enumerator_regex_specified_ >;
+        _cli_options_map_["--element-type-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::element_type_regex_,
+          &options::element_type_regex_specified_ >;
+        _cli_options_map_["--name-regex-trace"] = 
+        &::cli::thunk< options, bool, &options::name_regex_trace_ >;
+        _cli_options_map_["--root-element-first"] = 
+        &::cli::thunk< options, bool, &options::root_element_first_ >;
+        _cli_options_map_["--root-element-last"] = 
+        &::cli::thunk< options, bool, &options::root_element_last_ >;
+        _cli_options_map_["--root-element-all"] = 
+        &::cli::thunk< options, bool, &options::root_element_all_ >;
+        _cli_options_map_["--root-element-none"] = 
+        &::cli::thunk< options, bool, &options::root_element_none_ >;
+        _cli_options_map_["--root-element"] = 
+        &::cli::thunk< options, NarrowStrings, &options::root_element_,
+          &options::root_element_specified_ >;
+        _cli_options_map_["--custom-type"] = 
+        &::cli::thunk< options, NarrowStrings, &options::custom_type_,
+          &options::custom_type_specified_ >;
+        _cli_options_map_["--custom-type-regex"] = 
+        &::cli::thunk< options, NarrowStrings, &options::custom_type_regex_,
+          &options::custom_type_regex_specified_ >;
+        _cli_options_map_["--parts"] = 
+        &::cli::thunk< options, std::size_t, &options::parts_,
+          &options::parts_specified_ >;
+        _cli_options_map_["--parts-suffix"] = 
+        &::cli::thunk< options, NarrowString, &options::parts_suffix_,
+          &options::parts_suffix_specified_ >;
+      }
+    };
+
+    static _cli_options_map_init _cli_options_map_init_;
+
+    bool options::
+    _parse (const char* o, ::cli::scanner& s)
+    {
+      _cli_options_map::const_iterator i (_cli_options_map_.find (o));
+
+      if (i != _cli_options_map_.end ())
+      {
+        (*(i->second)) (*this, s);
+        return true;
+      }
+
+      // options base
+      //
+      if (::CXX::options::_parse (o, s))
+        return true;
+
+      return false;
+    }
+
+    void options::
+    _parse (::cli::scanner& s,
+            ::cli::unknown_mode opt_mode,
+            ::cli::unknown_mode arg_mode)
+    {
+      bool opt = true;
+
+      while (s.more ())
+      {
+        const char* o = s.peek ();
+
+        if (std::strcmp (o, "--") == 0)
+        {
+          s.skip ();
+          opt = false;
+          continue;
+        }
+
+        if (opt && _parse (o, s));
+        else if (opt && std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          switch (opt_mode)
+          {
+            case ::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              continue;
+            }
+            case ::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::cli::unknown_mode::fail:
+            {
+              throw ::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+        else
+        {
+          switch (arg_mode)
+          {
+            case ::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              continue;
+            }
+            case ::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::cli::unknown_mode::fail:
+            {
+              throw ::cli::unknown_argument (o);
+            }
+          }
+
+          break;
+        }
+      }
+    }
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/xsd/xsd/cxx/tree/options.hxx b/xsd/xsd/cxx/tree/options.hxx
new file mode 100644
index 0000000..b190dc5
--- /dev/null
+++ b/xsd/xsd/cxx/tree/options.hxx
@@ -0,0 +1,411 @@
+// This code was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef CXX_TREE_OPTIONS_HXX
+#define CXX_TREE_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <cstddef>
+
+#include <types.hxx>
+
+#include <cxx/options.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    class options: public ::CXX::options
+    {
+      public:
+      options (int& argc,
+               char** argv,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (int start,
+               int& argc,
+               char** argv,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (int& argc,
+               char** argv,
+               int& end,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (int start,
+               int& argc,
+               char** argv,
+               int& end,
+               bool erase = false,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options (::cli::scanner&,
+               ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+               ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+      options ();
+
+      // Option accessors.
+      //
+      const bool&
+      generate_polymorphic () const;
+
+      const NarrowStrings&
+      polymorphic_type () const;
+
+      bool
+      polymorphic_type_specified () const;
+
+      const bool&
+      polymorphic_type_all () const;
+
+      const unsigned long&
+      polymorphic_plate () const;
+
+      bool
+      polymorphic_plate_specified () const;
+
+      const NarrowStrings&
+      ordered_type () const;
+
+      bool
+      ordered_type_specified () const;
+
+      const bool&
+      ordered_type_derived () const;
+
+      const bool&
+      ordered_type_mixed () const;
+
+      const bool&
+      ordered_type_all () const;
+
+      const NarrowString&
+      order_container () const;
+
+      bool
+      order_container_specified () const;
+
+      const bool&
+      generate_serialization () const;
+
+      const bool&
+      generate_ostream () const;
+
+      const bool&
+      generate_doxygen () const;
+
+      const bool&
+      generate_comparison () const;
+
+      const bool&
+      generate_default_ctor () const;
+
+      const bool&
+      generate_from_base_ctor () const;
+
+      const bool&
+      suppress_assignment () const;
+
+      const bool&
+      generate_detach () const;
+
+      const bool&
+      generate_wildcard () const;
+
+      const bool&
+      generate_any_type () const;
+
+      const NarrowStrings&
+      generate_insertion () const;
+
+      bool
+      generate_insertion_specified () const;
+
+      const NarrowStrings&
+      generate_extraction () const;
+
+      bool
+      generate_extraction_specified () const;
+
+      const bool&
+      generate_forward () const;
+
+      const bool&
+      suppress_parsing () const;
+
+      const bool&
+      generate_element_type () const;
+
+      const bool&
+      generate_element_map () const;
+
+      const bool&
+      generate_intellisense () const;
+
+      const bool&
+      omit_default_attributes () const;
+
+      const NarrowString&
+      type_naming () const;
+
+      bool
+      type_naming_specified () const;
+
+      const NarrowString&
+      function_naming () const;
+
+      bool
+      function_naming_specified () const;
+
+      const NarrowStrings&
+      type_regex () const;
+
+      bool
+      type_regex_specified () const;
+
+      const NarrowStrings&
+      accessor_regex () const;
+
+      bool
+      accessor_regex_specified () const;
+
+      const NarrowStrings&
+      one_accessor_regex () const;
+
+      bool
+      one_accessor_regex_specified () const;
+
+      const NarrowStrings&
+      opt_accessor_regex () const;
+
+      bool
+      opt_accessor_regex_specified () const;
+
+      const NarrowStrings&
+      seq_accessor_regex () const;
+
+      bool
+      seq_accessor_regex_specified () const;
+
+      const NarrowStrings&
+      modifier_regex () const;
+
+      bool
+      modifier_regex_specified () const;
+
+      const NarrowStrings&
+      one_modifier_regex () const;
+
+      bool
+      one_modifier_regex_specified () const;
+
+      const NarrowStrings&
+      opt_modifier_regex () const;
+
+      bool
+      opt_modifier_regex_specified () const;
+
+      const NarrowStrings&
+      seq_modifier_regex () const;
+
+      bool
+      seq_modifier_regex_specified () const;
+
+      const NarrowStrings&
+      parser_regex () const;
+
+      bool
+      parser_regex_specified () const;
+
+      const NarrowStrings&
+      serializer_regex () const;
+
+      bool
+      serializer_regex_specified () const;
+
+      const NarrowStrings&
+      const_regex () const;
+
+      bool
+      const_regex_specified () const;
+
+      const NarrowStrings&
+      enumerator_regex () const;
+
+      bool
+      enumerator_regex_specified () const;
+
+      const NarrowStrings&
+      element_type_regex () const;
+
+      bool
+      element_type_regex_specified () const;
+
+      const bool&
+      name_regex_trace () const;
+
+      const bool&
+      root_element_first () const;
+
+      const bool&
+      root_element_last () const;
+
+      const bool&
+      root_element_all () const;
+
+      const bool&
+      root_element_none () const;
+
+      const NarrowStrings&
+      root_element () const;
+
+      bool
+      root_element_specified () const;
+
+      const NarrowStrings&
+      custom_type () const;
+
+      bool
+      custom_type_specified () const;
+
+      const NarrowStrings&
+      custom_type_regex () const;
+
+      bool
+      custom_type_regex_specified () const;
+
+      const std::size_t&
+      parts () const;
+
+      bool
+      parts_specified () const;
+
+      const NarrowString&
+      parts_suffix () const;
+
+      bool
+      parts_suffix_specified () const;
+
+      // Print usage information.
+      //
+      static void
+      print_usage (::std::wostream&);
+
+      // Implementation details.
+      //
+      protected:
+      bool
+      _parse (const char*, ::cli::scanner&);
+
+      private:
+      void
+      _parse (::cli::scanner&,
+              ::cli::unknown_mode option,
+              ::cli::unknown_mode argument);
+
+      public:
+      bool generate_polymorphic_;
+      NarrowStrings polymorphic_type_;
+      bool polymorphic_type_specified_;
+      bool polymorphic_type_all_;
+      unsigned long polymorphic_plate_;
+      bool polymorphic_plate_specified_;
+      NarrowStrings ordered_type_;
+      bool ordered_type_specified_;
+      bool ordered_type_derived_;
+      bool ordered_type_mixed_;
+      bool ordered_type_all_;
+      NarrowString order_container_;
+      bool order_container_specified_;
+      bool generate_serialization_;
+      bool generate_ostream_;
+      bool generate_doxygen_;
+      bool generate_comparison_;
+      bool generate_default_ctor_;
+      bool generate_from_base_ctor_;
+      bool suppress_assignment_;
+      bool generate_detach_;
+      bool generate_wildcard_;
+      bool generate_any_type_;
+      NarrowStrings generate_insertion_;
+      bool generate_insertion_specified_;
+      NarrowStrings generate_extraction_;
+      bool generate_extraction_specified_;
+      bool generate_forward_;
+      bool suppress_parsing_;
+      bool generate_element_type_;
+      bool generate_element_map_;
+      bool generate_intellisense_;
+      bool omit_default_attributes_;
+      NarrowString type_naming_;
+      bool type_naming_specified_;
+      NarrowString function_naming_;
+      bool function_naming_specified_;
+      NarrowStrings type_regex_;
+      bool type_regex_specified_;
+      NarrowStrings accessor_regex_;
+      bool accessor_regex_specified_;
+      NarrowStrings one_accessor_regex_;
+      bool one_accessor_regex_specified_;
+      NarrowStrings opt_accessor_regex_;
+      bool opt_accessor_regex_specified_;
+      NarrowStrings seq_accessor_regex_;
+      bool seq_accessor_regex_specified_;
+      NarrowStrings modifier_regex_;
+      bool modifier_regex_specified_;
+      NarrowStrings one_modifier_regex_;
+      bool one_modifier_regex_specified_;
+      NarrowStrings opt_modifier_regex_;
+      bool opt_modifier_regex_specified_;
+      NarrowStrings seq_modifier_regex_;
+      bool seq_modifier_regex_specified_;
+      NarrowStrings parser_regex_;
+      bool parser_regex_specified_;
+      NarrowStrings serializer_regex_;
+      bool serializer_regex_specified_;
+      NarrowStrings const_regex_;
+      bool const_regex_specified_;
+      NarrowStrings enumerator_regex_;
+      bool enumerator_regex_specified_;
+      NarrowStrings element_type_regex_;
+      bool element_type_regex_specified_;
+      bool name_regex_trace_;
+      bool root_element_first_;
+      bool root_element_last_;
+      bool root_element_all_;
+      bool root_element_none_;
+      NarrowStrings root_element_;
+      bool root_element_specified_;
+      NarrowStrings custom_type_;
+      bool custom_type_specified_;
+      NarrowStrings custom_type_regex_;
+      bool custom_type_regex_specified_;
+      std::size_t parts_;
+      bool parts_specified_;
+      NarrowString parts_suffix_;
+      bool parts_suffix_specified_;
+    };
+  }
+}
+
+#include <cxx/tree/options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // CXX_TREE_OPTIONS_HXX
diff --git a/xsd/xsd/cxx/tree/options.ixx b/xsd/xsd/cxx/tree/options.ixx
new file mode 100644
index 0000000..824fbee
--- /dev/null
+++ b/xsd/xsd/cxx/tree/options.ixx
@@ -0,0 +1,502 @@
+// This code was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace CXX
+{
+  namespace Tree
+  {
+    // options
+    //
+
+    inline const bool& options::
+    generate_polymorphic () const
+    {
+      return this->generate_polymorphic_;
+    }
+
+    inline const NarrowStrings& options::
+    polymorphic_type () const
+    {
+      return this->polymorphic_type_;
+    }
+
+    inline bool options::
+    polymorphic_type_specified () const
+    {
+      return this->polymorphic_type_specified_;
+    }
+
+    inline const bool& options::
+    polymorphic_type_all () const
+    {
+      return this->polymorphic_type_all_;
+    }
+
+    inline const unsigned long& options::
+    polymorphic_plate () const
+    {
+      return this->polymorphic_plate_;
+    }
+
+    inline bool options::
+    polymorphic_plate_specified () const
+    {
+      return this->polymorphic_plate_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    ordered_type () const
+    {
+      return this->ordered_type_;
+    }
+
+    inline bool options::
+    ordered_type_specified () const
+    {
+      return this->ordered_type_specified_;
+    }
+
+    inline const bool& options::
+    ordered_type_derived () const
+    {
+      return this->ordered_type_derived_;
+    }
+
+    inline const bool& options::
+    ordered_type_mixed () const
+    {
+      return this->ordered_type_mixed_;
+    }
+
+    inline const bool& options::
+    ordered_type_all () const
+    {
+      return this->ordered_type_all_;
+    }
+
+    inline const NarrowString& options::
+    order_container () const
+    {
+      return this->order_container_;
+    }
+
+    inline bool options::
+    order_container_specified () const
+    {
+      return this->order_container_specified_;
+    }
+
+    inline const bool& options::
+    generate_serialization () const
+    {
+      return this->generate_serialization_;
+    }
+
+    inline const bool& options::
+    generate_ostream () const
+    {
+      return this->generate_ostream_;
+    }
+
+    inline const bool& options::
+    generate_doxygen () const
+    {
+      return this->generate_doxygen_;
+    }
+
+    inline const bool& options::
+    generate_comparison () const
+    {
+      return this->generate_comparison_;
+    }
+
+    inline const bool& options::
+    generate_default_ctor () const
+    {
+      return this->generate_default_ctor_;
+    }
+
+    inline const bool& options::
+    generate_from_base_ctor () const
+    {
+      return this->generate_from_base_ctor_;
+    }
+
+    inline const bool& options::
+    suppress_assignment () const
+    {
+      return this->suppress_assignment_;
+    }
+
+    inline const bool& options::
+    generate_detach () const
+    {
+      return this->generate_detach_;
+    }
+
+    inline const bool& options::
+    generate_wildcard () const
+    {
+      return this->generate_wildcard_;
+    }
+
+    inline const bool& options::
+    generate_any_type () const
+    {
+      return this->generate_any_type_;
+    }
+
+    inline const NarrowStrings& options::
+    generate_insertion () const
+    {
+      return this->generate_insertion_;
+    }
+
+    inline bool options::
+    generate_insertion_specified () const
+    {
+      return this->generate_insertion_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    generate_extraction () const
+    {
+      return this->generate_extraction_;
+    }
+
+    inline bool options::
+    generate_extraction_specified () const
+    {
+      return this->generate_extraction_specified_;
+    }
+
+    inline const bool& options::
+    generate_forward () const
+    {
+      return this->generate_forward_;
+    }
+
+    inline const bool& options::
+    suppress_parsing () const
+    {
+      return this->suppress_parsing_;
+    }
+
+    inline const bool& options::
+    generate_element_type () const
+    {
+      return this->generate_element_type_;
+    }
+
+    inline const bool& options::
+    generate_element_map () const
+    {
+      return this->generate_element_map_;
+    }
+
+    inline const bool& options::
+    generate_intellisense () const
+    {
+      return this->generate_intellisense_;
+    }
+
+    inline const bool& options::
+    omit_default_attributes () const
+    {
+      return this->omit_default_attributes_;
+    }
+
+    inline const NarrowString& options::
+    type_naming () const
+    {
+      return this->type_naming_;
+    }
+
+    inline bool options::
+    type_naming_specified () const
+    {
+      return this->type_naming_specified_;
+    }
+
+    inline const NarrowString& options::
+    function_naming () const
+    {
+      return this->function_naming_;
+    }
+
+    inline bool options::
+    function_naming_specified () const
+    {
+      return this->function_naming_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    type_regex () const
+    {
+      return this->type_regex_;
+    }
+
+    inline bool options::
+    type_regex_specified () const
+    {
+      return this->type_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    accessor_regex () const
+    {
+      return this->accessor_regex_;
+    }
+
+    inline bool options::
+    accessor_regex_specified () const
+    {
+      return this->accessor_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    one_accessor_regex () const
+    {
+      return this->one_accessor_regex_;
+    }
+
+    inline bool options::
+    one_accessor_regex_specified () const
+    {
+      return this->one_accessor_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    opt_accessor_regex () const
+    {
+      return this->opt_accessor_regex_;
+    }
+
+    inline bool options::
+    opt_accessor_regex_specified () const
+    {
+      return this->opt_accessor_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    seq_accessor_regex () const
+    {
+      return this->seq_accessor_regex_;
+    }
+
+    inline bool options::
+    seq_accessor_regex_specified () const
+    {
+      return this->seq_accessor_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    modifier_regex () const
+    {
+      return this->modifier_regex_;
+    }
+
+    inline bool options::
+    modifier_regex_specified () const
+    {
+      return this->modifier_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    one_modifier_regex () const
+    {
+      return this->one_modifier_regex_;
+    }
+
+    inline bool options::
+    one_modifier_regex_specified () const
+    {
+      return this->one_modifier_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    opt_modifier_regex () const
+    {
+      return this->opt_modifier_regex_;
+    }
+
+    inline bool options::
+    opt_modifier_regex_specified () const
+    {
+      return this->opt_modifier_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    seq_modifier_regex () const
+    {
+      return this->seq_modifier_regex_;
+    }
+
+    inline bool options::
+    seq_modifier_regex_specified () const
+    {
+      return this->seq_modifier_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    parser_regex () const
+    {
+      return this->parser_regex_;
+    }
+
+    inline bool options::
+    parser_regex_specified () const
+    {
+      return this->parser_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    serializer_regex () const
+    {
+      return this->serializer_regex_;
+    }
+
+    inline bool options::
+    serializer_regex_specified () const
+    {
+      return this->serializer_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    const_regex () const
+    {
+      return this->const_regex_;
+    }
+
+    inline bool options::
+    const_regex_specified () const
+    {
+      return this->const_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    enumerator_regex () const
+    {
+      return this->enumerator_regex_;
+    }
+
+    inline bool options::
+    enumerator_regex_specified () const
+    {
+      return this->enumerator_regex_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    element_type_regex () const
+    {
+      return this->element_type_regex_;
+    }
+
+    inline bool options::
+    element_type_regex_specified () const
+    {
+      return this->element_type_regex_specified_;
+    }
+
+    inline const bool& options::
+    name_regex_trace () const
+    {
+      return this->name_regex_trace_;
+    }
+
+    inline const bool& options::
+    root_element_first () const
+    {
+      return this->root_element_first_;
+    }
+
+    inline const bool& options::
+    root_element_last () const
+    {
+      return this->root_element_last_;
+    }
+
+    inline const bool& options::
+    root_element_all () const
+    {
+      return this->root_element_all_;
+    }
+
+    inline const bool& options::
+    root_element_none () const
+    {
+      return this->root_element_none_;
+    }
+
+    inline const NarrowStrings& options::
+    root_element () const
+    {
+      return this->root_element_;
+    }
+
+    inline bool options::
+    root_element_specified () const
+    {
+      return this->root_element_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    custom_type () const
+    {
+      return this->custom_type_;
+    }
+
+    inline bool options::
+    custom_type_specified () const
+    {
+      return this->custom_type_specified_;
+    }
+
+    inline const NarrowStrings& options::
+    custom_type_regex () const
+    {
+      return this->custom_type_regex_;
+    }
+
+    inline bool options::
+    custom_type_regex_specified () const
+    {
+      return this->custom_type_regex_specified_;
+    }
+
+    inline const std::size_t& options::
+    parts () const
+    {
+      return this->parts_;
+    }
+
+    inline bool options::
+    parts_specified () const
+    {
+      return this->parts_specified_;
+    }
+
+    inline const NarrowString& options::
+    parts_suffix () const
+    {
+      return this->parts_suffix_;
+    }
+
+    inline bool options::
+    parts_suffix_specified () const
+    {
+      return this->parts_suffix_specified_;
+    }
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/xsd/xsd/cxx/tree/order-processor.cxx b/xsd/xsd/cxx/tree/order-processor.cxx
new file mode 100644
index 0000000..68eee8c
--- /dev/null
+++ b/xsd/xsd/cxx/tree/order-processor.cxx
@@ -0,0 +1,244 @@
+// file      : xsde/cxx/tree/order-processor.cxx
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#include <iostream>
+
+#include <cxx/tree/elements.hxx>
+#include <cxx/tree/order-processor.hxx>
+
+#include <xsd-frontend/semantic-graph.hxx>
+#include <xsd-frontend/traversal.hxx>
+
+using namespace std;
+
+namespace CXX
+{
+  namespace Tree
+  {
+    namespace
+    {
+      struct Member: Traversal::Element, Traversal::Any
+      {
+        Member (size_t count): count_ (count) {}
+
+        virtual void
+        traverse (SemanticGraph::Element& e)
+        {
+          if (Context::skip (e))
+            return;
+
+          e.context ().set ("ordered-id", count_++);
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          a.context ().set ("ordered-id", count_++);
+        }
+
+        size_t count_;
+      };
+
+      //
+      //
+      struct Type: Traversal::Complex
+      {
+        Type (TypeNameSet& ordered_types, bool derived, bool mixed, bool all)
+            : ordered_types_ (ordered_types),
+              derived_ (derived),
+              mixed_ (mixed),
+              all_ (all)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Complex& c)
+        {
+          SemanticGraph::Context& ctx (c.context ());
+
+          if (!ctx.count ("ordered"))
+          {
+            // First process our base.
+            //
+            if (c.inherits_p ())
+            {
+              SemanticGraph::Type& b (c.inherits ().base ());
+
+              if (!b.context ().count ("ordered"))
+                dispatch (b);
+            }
+
+            // See if our base (not necessarily immediate) is ordered.
+            //
+            using SemanticGraph::Complex;
+
+            Complex* b (0);
+
+            for (Complex* p (&c); p->inherits_p ();)
+            {
+              if ((b = dynamic_cast<Complex*> (&p->inherits ().base ())))
+              {
+                if (Context::ordered_p (*b))
+                  break;
+
+                p = b;
+              }
+              else
+                break;
+            }
+
+            bool o (all_ ||
+                    (derived_ && b != 0 && Context::ordered_p (*b)) ||
+                    (mixed_ && c.mixed_p ()) ||
+                    ordered_types_.find (c));
+            ctx.set ("ordered", o);
+
+            // Assign ids to elements and wildcards, calculate total count.
+            //
+            if (o)
+            {
+              size_t count (
+                b != 0 && Context::ordered_p (*b)
+                ? b->context ().get<size_t> ("ordered-count")
+                : 1);
+
+              ctx.set ("ordered-start", count);
+
+              Member m (count);
+              Traversal::Names n (m);
+              names (c, n);
+
+              // Assign content id for mixed text.
+              //
+              if (Context::mixed_p (c) && count == 1)
+                ctx.set ("mixed-ordered-id", m.count_++);
+
+              ctx.set ("ordered-count", m.count_);
+            }
+          }
+        }
+
+      private:
+        TypeNameSet& ordered_types_;
+        bool derived_;
+        bool mixed_;
+        bool all_;
+      };
+
+      // Go into sourced/included/imported schemas while making sure
+      // we don't process the same stuff more than once.
+      //
+      struct Uses: Traversal::Sources,
+                   Traversal::Includes,
+                   Traversal::Imports
+      {
+        Uses (char const* seen_key)
+            : seen_key_ (seen_key)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Sources& sr)
+        {
+          SemanticGraph::Schema& s (sr.schema ());
+
+          if (!s.context ().count (seen_key_))
+          {
+            s.context ().set (seen_key_, true);
+            Traversal::Sources::traverse (sr);
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::Includes& i)
+        {
+          SemanticGraph::Schema& s (i.schema ());
+
+          if (!s.context ().count (seen_key_))
+          {
+            s.context ().set (seen_key_, true);
+            Traversal::Includes::traverse (i);
+          }
+        }
+
+        virtual void
+        traverse (SemanticGraph::Imports& i)
+        {
+          SemanticGraph::Schema& s (i.schema ());
+
+          if (!s.context ().count (seen_key_))
+          {
+            s.context ().set (seen_key_, true);
+            Traversal::Imports::traverse (i);
+          }
+        }
+
+      private:
+        char const* seen_key_;
+      };
+
+      char const* seen_key = "cxx-tree-order-processor-seen";
+
+      bool
+      process_impl (options const& ops,
+                    SemanticGraph::Schema& tu,
+                    SemanticGraph::Path const&)
+      {
+        // Prepare a set of ordered types.
+        //
+        TypeNameSet ordered_types (ops.ordered_type ().begin (),
+                                   ops.ordered_type ().end ());
+
+        // Root schema in the file-per-type mode is just a bunch
+        // of includes without a namespace.
+        //
+        SemanticGraph::Schema::NamesIterator i (tu.names_begin ());
+
+        // Nothing to do if this is the XML Schema namespace.
+        //
+        if (i == tu.names_end () ||
+            i->named ().name () != L"http://www.w3.org/2001/XMLSchema")
+        {
+          // Note that we check first if this schema has already been
+          // processed which may happen in the file-per-type compilation
+          // mode.
+          //
+          if (!tu.context ().count (seen_key))
+          {
+            Traversal::Schema schema;
+            Uses uses (seen_key);
+
+            schema >> uses >> schema;
+
+            Traversal::Names schema_names;
+            Traversal::Namespace ns;
+            Traversal::Names ns_names;
+            Type type (ordered_types,
+                       ops.ordered_type_derived (),
+                       ops.ordered_type_mixed (),
+                       ops.ordered_type_all ());
+
+            schema >> schema_names >> ns >> ns_names >> type;
+
+            // Some twisted schemas do recusive self-inclusion.
+            //
+            tu.context ().set (seen_key, true);
+
+            schema.dispatch (tu);
+          }
+        }
+
+        return true;
+      }
+    }
+
+    bool OrderProcessor::
+    process (options const& ops,
+             SemanticGraph::Schema& tu,
+             SemanticGraph::Path const& file)
+    {
+      return process_impl (ops, tu, file);
+    }
+  }
+}
diff --git a/xsd/xsd/cxx/tree/order-processor.hxx b/xsd/xsd/cxx/tree/order-processor.hxx
new file mode 100644
index 0000000..fa68d21
--- /dev/null
+++ b/xsd/xsd/cxx/tree/order-processor.hxx
@@ -0,0 +1,30 @@
+// file      : xsde/cxx/tree/order-processor.hxx
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef CXX_TREE_ORDER_PROCESSOR_HXX
+#define CXX_TREE_ORDER_PROCESSOR_HXX
+
+#include <xsd-frontend/semantic-graph.hxx>
+
+#include <xsd.hxx>
+#include <types.hxx>
+
+#include <cxx/tree/options.hxx>
+
+namespace CXX
+{
+  namespace Tree
+  {
+    class OrderProcessor
+    {
+    public:
+      bool
+      process (options const&,
+               XSDFrontend::SemanticGraph::Schema&,
+               XSDFrontend::SemanticGraph::Path const& file);
+    };
+  }
+}
+
+#endif // CXX_TREE_ORDER_PROCESSOR_HXX
diff --git a/xsd/xsd/cxx/tree/parser-header.cxx b/xsd/xsd/cxx/tree/parser-header.cxx
index c1d1ab9..8aff44f 100644
--- a/xsd/xsd/cxx/tree/parser-header.cxx
+++ b/xsd/xsd/cxx/tree/parser-header.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/parser-header.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/parser-header.hxx>
@@ -23,7 +22,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (!doc_root_p (e))
@@ -71,7 +70,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (const " << string_type << "& uri," << endl
              << flags_type << " f = 0," << endl
              << "const " << properties_type << "& p = " << properties_type << " ());"
@@ -94,7 +93,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (const " << string_type << "& uri," << endl
              << error_handler << "& eh," << endl
              << flags_type << " f = 0," << endl
@@ -120,7 +119,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (const " << string_type << "& uri," << endl
              << xerces_ns << "::DOMErrorHandler& eh," << endl
              << flags_type << " f = 0," << endl
@@ -149,7 +148,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (::std::istream& is," << endl
              << flags_type << " f = 0," << endl
              << "const " << properties_type << "& p = " << properties_type << " ());"
@@ -172,7 +171,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (::std::istream& is," << endl
              << error_handler << "& eh," << endl
              << flags_type << " f = 0," << endl
@@ -198,7 +197,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (::std::istream& is," << endl
              << xerces_ns << "::DOMErrorHandler& eh," << endl
              << flags_type << " f = 0," << endl
@@ -225,7 +224,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (::std::istream& is," << endl
              << "const " << string_type << "& id," << endl
              << flags_type << " f = 0," << endl
@@ -256,7 +255,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (::std::istream& is," << endl
              << "const " << string_type << "& id," << endl
              << error_handler << "& eh," << endl
@@ -288,7 +287,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (::std::istream& is," << endl
              << "const " << string_type << "& id," << endl
              << xerces_ns << "::DOMErrorHandler& eh," << endl
@@ -318,7 +317,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (" << xerces_ns << "::InputSource& is," << endl
              << flags_type << " f = 0," << endl
              << "const " << properties_type << "& p = " << properties_type << " ());"
@@ -342,7 +341,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (" << xerces_ns << "::InputSource& is," << endl
              << error_handler << "& eh," << endl
              << flags_type << " f = 0," << endl
@@ -368,7 +367,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (" << xerces_ns << "::InputSource& is," << endl
              << xerces_ns << "::DOMErrorHandler& eh," << endl
              << flags_type << " f = 0," << endl
@@ -395,7 +394,7 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (const " << xerces_ns << "::DOMDocument& d," << endl
              << flags_type << " f = 0," << endl
              << "const " << properties_type << "& p = " << properties_type << " ());"
@@ -420,9 +419,9 @@ namespace CXX
           }
 
           os << inst_exp
-             << "::std::auto_ptr< " << type_name (e) << " >" << endl
+             << auto_ptr << "< " << type_name (e) << " >" << endl
              << name << " (" << dom_auto_ptr << "< " << xerces_ns <<
-            "::DOMDocument >& d," << endl
+            "::DOMDocument > d," << endl
              << flags_type << " f = 0," << endl
              << "const " << properties_type << "& p = " << properties_type << " ());"
              << endl;
@@ -449,7 +448,7 @@ namespace CXX
     }
 
 
-    Void
+    void
     generate_parser_header (Context& ctx)
     {
       ctx.os << "#include <iosfwd>" << endl
@@ -460,7 +459,7 @@ namespace CXX
              << endl;
 
       Traversal::Schema schema;
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names names_ns, names;
       Namespace ns (ctx);
       ElementFunction element (ctx);
diff --git a/xsd/xsd/cxx/tree/parser-header.hxx b/xsd/xsd/cxx/tree/parser-header.hxx
index 20ca7d4..dfe7843 100644
--- a/xsd/xsd/cxx/tree/parser-header.hxx
+++ b/xsd/xsd/cxx/tree/parser-header.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/parser-header.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_PARSER_HEADER_HXX
@@ -13,7 +12,7 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
+    void
     generate_parser_header (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/tree/parser-source.cxx b/xsd/xsd/cxx/tree/parser-source.cxx
index 7291cb8..c93368c 100644
--- a/xsd/xsd/cxx/tree/parser-source.cxx
+++ b/xsd/xsd/cxx/tree/parser-source.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/parser-source.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/parser-source.hxx>
@@ -23,7 +22,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (!doc_root_p (e))
@@ -38,9 +37,11 @@ namespace CXX
           // confused if the name is 'type'. (see tests/schema/anonymous)
           //
 
+          char const* d (std >= cxx_version::cxx11 ? "std::move (d)" : "d");
+
           // URI.
           //
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (const " << string_type << "& u," << endl
              << flags_type << " f," << endl
              << "const " << properties_type << "& p)"
@@ -56,22 +57,20 @@ namespace CXX
              << "::xsd::cxx::xml::dom::parse< " << char_type << " > (" << endl
              << "u, h, p, f";
 
-          if (options.value<CLI::disable_multi_import> ())
+          if (options.disable_multi_import ())
             os << " | ::xsd::cxx::xml::dom::no_muliple_imports";
 
-            os << "));"
+          os << "));"
              << endl
              << "h.throw_if_failed< ::xsd::cxx::tree::parsing< " <<
             char_type << " > > ();"
              << endl
-             << "::std::auto_ptr< " << type << " > r (" << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
              << fq_name (e, "parser") << " (" << endl
-             << "d, f | " << flags_type << "::own_dom, p));"
-             << endl
-             << "return r;"
+             << d << ", f | " << flags_type << "::own_dom, p));"
              << "}";
 
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (const " << string_type << "& u," << endl
              << error_handler << "& h," << endl
              << flags_type << " f," << endl
@@ -86,7 +85,7 @@ namespace CXX
              << "::xsd::cxx::xml::dom::parse< " << char_type << " > (" << endl
              << "u, h, p, f";
 
-          if (options.value<CLI::disable_multi_import> ())
+          if (options.disable_multi_import ())
             os << " | ::xsd::cxx::xml::dom::no_muliple_imports";
 
           os << "));"
@@ -94,14 +93,12 @@ namespace CXX
              << "if (!d.get ())" << endl
              << "throw ::xsd::cxx::tree::parsing< " << char_type << " > ();"
              << endl
-             << "::std::auto_ptr< " << type << " > r (" << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
              << fq_name (e, "parser") << " (" << endl
-             << "d, f | " << flags_type << "::own_dom, p));"
-             << endl
-             << "return r;"
+             << d << ", f | " << flags_type << "::own_dom, p));"
              << "}";
 
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (const " << string_type << "& u," << endl
              << xerces_ns << "::DOMErrorHandler& h," << endl
              << flags_type << " f," << endl
@@ -112,7 +109,7 @@ namespace CXX
              << "::xsd::cxx::xml::dom::parse< " << char_type << " > (" << endl
              << "u, h, p, f";
 
-          if (options.value<CLI::disable_multi_import> ())
+          if (options.disable_multi_import ())
             os << " | ::xsd::cxx::xml::dom::no_muliple_imports";
 
           os << "));"
@@ -120,17 +117,15 @@ namespace CXX
              << "if (!d.get ())" << endl
              << "throw ::xsd::cxx::tree::parsing< " << char_type << " > ();"
              << endl
-             << "::std::auto_ptr< " << type << " > r (" << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
              << fq_name (e, "parser") << " (" << endl
-             << "d, f | " << flags_type << "::own_dom, p));"
-             << endl
-             << "return r;"
+             << d << ", f | " << flags_type << "::own_dom, p));"
              << "}";
 
 
           // istream
           //
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (::std::istream& is," << endl
              << flags_type << " f," << endl
              << "const " << properties_type << "& p)"
@@ -143,7 +138,7 @@ namespace CXX
              << "return " << fq_name (e, "parser") << " (isrc, f, p);"
              << "}";
 
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (::std::istream& is," << endl
              << error_handler << "& h," << endl
              << flags_type << " f," << endl
@@ -157,7 +152,7 @@ namespace CXX
              << "return " << fq_name (e, "parser") << " (isrc, h, f, p);"
              << "}";
 
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (::std::istream& is," << endl
              << xerces_ns << "::DOMErrorHandler& h," << endl
              << flags_type << " f," << endl
@@ -167,7 +162,7 @@ namespace CXX
              << "return " << fq_name (e, "parser") << " (isrc, h, f, p);"
              << "}";
 
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (::std::istream& is," << endl
              << "const " << string_type << "& sid," << endl
              << flags_type << " f," << endl
@@ -181,7 +176,7 @@ namespace CXX
              << "return " << fq_name (e, "parser") << " (isrc, f, p);"
              << "}";
 
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (::std::istream& is," << endl
              << "const " << string_type << "& sid," << endl
              << error_handler << "& h," << endl
@@ -196,7 +191,7 @@ namespace CXX
              << "return " << fq_name (e, "parser") << " (isrc, h, f, p);"
              << "}";
 
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (::std::istream& is," << endl
              << "const " << string_type << "& sid," << endl
              << xerces_ns << "::DOMErrorHandler& h," << endl
@@ -210,7 +205,7 @@ namespace CXX
 
           // InputSource.
           //
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (" << xerces_ns << "::InputSource& i," << endl
              << flags_type << " f," << endl
              << "const " << properties_type << "& p)"
@@ -222,7 +217,7 @@ namespace CXX
              << "::xsd::cxx::xml::dom::parse< " << char_type << " > (" << endl
              << "i, h, p, f";
 
-          if (options.value<CLI::disable_multi_import> ())
+          if (options.disable_multi_import ())
             os << " | ::xsd::cxx::xml::dom::no_muliple_imports";
 
           os << "));"
@@ -230,14 +225,12 @@ namespace CXX
              << "h.throw_if_failed< ::xsd::cxx::tree::parsing< " <<
             char_type << " > > ();"
              << endl
-             << "::std::auto_ptr< " << type << " > r (" << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
              << fq_name (e, "parser") << " (" << endl
-             << "d, f | " << flags_type << "::own_dom, p));"
-             << endl
-             << "return r;"
+             << d << ", f | " << flags_type << "::own_dom, p));"
              << "}";
 
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (" << xerces_ns << "::InputSource& i," << endl
              << error_handler << "& h," << endl
              << flags_type << " f," << endl
@@ -248,7 +241,7 @@ namespace CXX
              << "::xsd::cxx::xml::dom::parse< " << char_type << " > (" << endl
              << "i, h, p, f";
 
-          if (options.value<CLI::disable_multi_import> ())
+          if (options.disable_multi_import ())
             os << " | ::xsd::cxx::xml::dom::no_muliple_imports";
 
           os << "));"
@@ -256,15 +249,13 @@ namespace CXX
              << "if (!d.get ())" << endl
              << "throw ::xsd::cxx::tree::parsing< " << char_type << " > ();"
              << endl
-             << "::std::auto_ptr< " << type << " > r (" << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
              << fq_name (e, "parser") << " (" << endl
-             << "d, f | " << flags_type << "::own_dom, p));"
-             << endl
-             << "return r;"
+             << d << ", f | " << flags_type << "::own_dom, p));"
              << "}";
 
 
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (" << xerces_ns << "::InputSource& i," << endl
              << xerces_ns << "::DOMErrorHandler& h," << endl
              << flags_type << " f," << endl
@@ -275,7 +266,7 @@ namespace CXX
              << "::xsd::cxx::xml::dom::parse< " << char_type << " > (" << endl
              << "i, h, p, f";
 
-          if (options.value<CLI::disable_multi_import> ())
+          if (options.disable_multi_import ())
             os << " | ::xsd::cxx::xml::dom::no_muliple_imports";
 
           os << "));"
@@ -283,18 +274,16 @@ namespace CXX
              << "if (!d.get ())" << endl
              << "throw ::xsd::cxx::tree::parsing< " << char_type << " > ();"
              << endl
-             << "::std::auto_ptr< " << type << " > r (" << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
              << fq_name (e, "parser") << " (" << endl
-             << "d, f | " << flags_type << "::own_dom, p));"
-             << endl
-             << "return r;"
+             << d << ", f | " << flags_type << "::own_dom, p));"
              << "}";
 
 
           // DOM.
           //
 
-          Boolean fund (false);
+          bool fund (false);
           {
             IsFundamentalType test (fund);
             test.dispatch (t);
@@ -304,44 +293,36 @@ namespace CXX
           // If this element's type is anonymous then we don't need to do
           // anything.
           //
-          Boolean poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
 
           // const DOMDocument&
           //
-          os << "::std::auto_ptr< " << type << " >" << endl
-             << name << " (const " << xerces_ns << "::DOMDocument& d," << endl
+          os << auto_ptr << "< " << type << " >" << endl
+             << name << " (const " << xerces_ns << "::DOMDocument& doc," << endl
              << flags_type << " f," << endl
              << "const " << properties_type << "& p)"
              << "{"
              << "if (f & " << flags_type << "::keep_dom)"
              << "{"
              << dom_auto_ptr << "< " << xerces_ns <<
-            "::DOMDocument > c (" << endl
+            "::DOMDocument > d (" << endl
              << "static_cast< " << xerces_ns <<
-            "::DOMDocument* > (d.cloneNode (true)));"
+            "::DOMDocument* > (doc.cloneNode (true)));"
              << endl
-             << "::std::auto_ptr< " << type << " > r (" << endl
+             << "return " << auto_ptr << "< " << type << " > (" << endl
              << fq_name (e, "parser") << " (" << endl
-             << "c, f | " << flags_type << "::own_dom, p));"
-             << endl
-             << "return r;"
+             << d << ", f | " << flags_type << "::own_dom, p));"
              << "}"
-             << "const " << xerces_ns << "::DOMElement& e (*d.getDocumentElement ());"
+             << "const " << xerces_ns << "::DOMElement& e (*doc.getDocumentElement ());"
              << "const " << qname_type << " n (" << endl
              << "::xsd::cxx::xml::dom::name< " << char_type << " > (e));"
              << endl;
 
           if (poly)
           {
-            // aCC cannot handle an inline call to type_factory_map_instance.
-            //
-            os << "::xsd::cxx::tree::type_factory_map< " << char_type <<
-              " >& tfm (" << endl
-               << "::xsd::cxx::tree::type_factory_map_instance< 0, " <<
-              char_type << " > ());"
-               << endl
-               << "::std::auto_ptr< ::xsd::cxx::tree::type > tmp (" << endl
-               << "tfm.create (" << endl
+            os << auto_ptr << "< ::xsd::cxx::tree::type > tmp (" << endl
+               << "::xsd::cxx::tree::type_factory_map_instance< " <<
+              poly_plate << ", " << char_type << " > ().create (" << endl
                << strlit (e.name ()) << "," << endl
                << strlit (e.namespace_().name ()) << "," << endl
                << "&::xsd::cxx::tree::factory_impl< " << type << " >," << endl
@@ -349,7 +330,7 @@ namespace CXX
                << endl
                << "if (tmp.get () != 0)"
                << "{"
-               << "::std::auto_ptr< " << type << " > r (" << endl
+               << auto_ptr << "< " << type << " > r (" << endl
                << "dynamic_cast< " << type << "* > (tmp.get ()));"
                << endl
                << "if (r.get ())" << endl
@@ -367,7 +348,7 @@ namespace CXX
 
             if (fund)
             {
-              os << "::std::auto_ptr< " << type << " > r (" << endl
+              os << auto_ptr << "< " << type << " > r (" << endl
                  << "new " << type << " (" << endl
                  << "::xsd::cxx::tree::traits< " << type << ", " <<
                 char_type;
@@ -382,7 +363,7 @@ namespace CXX
             }
             else
             {
-              os << "::std::auto_ptr< " << type << " > r (" << endl
+              os << auto_ptr << "< " << type << " > r (" << endl
                  << "::xsd::cxx::tree::traits< " << type << ", " <<
                 char_type << " >::create (" << endl
                  << "e, f, 0));";
@@ -400,11 +381,11 @@ namespace CXX
              << "}";
 
 
-          // dom::auto_ptr<DOMDocument>
+          // dom::auto_ptr/unique_ptr<DOMDocument>
           //
-          os << "::std::auto_ptr< " << type << " >" << endl
+          os << auto_ptr << "< " << type << " >" << endl
              << name << " (" << dom_auto_ptr << "< " << xerces_ns <<
-            "::DOMDocument >& d," << endl
+            "::DOMDocument > d," << endl
              << flags_type << " f," << endl
              << "const " << properties_type << "&)"
              << "{"
@@ -431,15 +412,9 @@ namespace CXX
 
           if (poly)
           {
-            // aCC cannot handle an inline call to type_factory_map_instance.
-            //
-            os << "::xsd::cxx::tree::type_factory_map< " << char_type <<
-              " >& tfm (" << endl
-               << "::xsd::cxx::tree::type_factory_map_instance< 0, " <<
-              char_type << " > ());"
-               << endl
-               << "::std::auto_ptr< ::xsd::cxx::tree::type > tmp (" << endl
-               << "tfm.create (" << endl
+            os << auto_ptr << "< ::xsd::cxx::tree::type > tmp (" << endl
+               << "::xsd::cxx::tree::type_factory_map_instance< " <<
+              poly_plate << ", " << char_type << " > ().create (" << endl
                << strlit (e.name ()) << "," << endl
                << strlit (e.namespace_().name ()) << "," << endl
                << "&::xsd::cxx::tree::factory_impl< " << type << " >," << endl
@@ -456,7 +431,7 @@ namespace CXX
 
             if (fund)
             {
-              os << "::std::auto_ptr< " << type << " > r (" << endl
+              os << auto_ptr << "< " << type << " > r (" << endl
                  << "new " << type << " (" << endl
                  << "::xsd::cxx::tree::traits< " << type << ", " <<
                 char_type;
@@ -471,7 +446,7 @@ namespace CXX
             }
             else
             {
-              os << "::std::auto_ptr< " << type << " > r (" << endl
+              os << auto_ptr << "< " << type << " > r (" << endl
                  << "::xsd::cxx::tree::traits< " << type << ", " <<
                 char_type << " >::create (" << endl
                  << "e, f, 0));";
@@ -481,7 +456,7 @@ namespace CXX
           if (poly)
           {
             os << endl
-               << "::std::auto_ptr< " << type << " > r (" << endl
+               << auto_ptr << "< " << type << " > r (" << endl
                << "dynamic_cast< " << type << "* > (tmp.get ()));"
                << endl
                << "if (r.get ())" << endl
@@ -517,10 +492,8 @@ namespace CXX
       };
     }
 
-    Void
-    generate_parser_source (Context& ctx,
-                            UnsignedLong first,
-                            UnsignedLong last)
+    void
+    generate_parser_source (Context& ctx, size_t first, size_t last)
     {
       ctx.os << "#include <istream>" << endl
              << "#include <xsd/cxx/xml/sax/std-input-source.hxx>" << endl
@@ -528,7 +501,7 @@ namespace CXX
              << endl;
 
       Traversal::Schema schema;
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names names_ns, names;
       Namespace ns (ctx, first, last);
       ElementFunction element (ctx);
diff --git a/xsd/xsd/cxx/tree/parser-source.hxx b/xsd/xsd/cxx/tree/parser-source.hxx
index 2a85571..a5cd597 100644
--- a/xsd/xsd/cxx/tree/parser-source.hxx
+++ b/xsd/xsd/cxx/tree/parser-source.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/parser-source.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_PARSER_SOURCE_HXX
@@ -12,8 +11,8 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
-    generate_parser_source (Context&, UnsignedLong first, UnsignedLong last);
+    void
+    generate_parser_source (Context&, size_t first, size_t last);
   }
 }
 
diff --git a/xsd/xsd/cxx/tree/polymorphism-processor.cxx b/xsd/xsd/cxx/tree/polymorphism-processor.cxx
index 0763f0f..cbd2471 100644
--- a/xsd/xsd/cxx/tree/polymorphism-processor.cxx
+++ b/xsd/xsd/cxx/tree/polymorphism-processor.cxx
@@ -1,19 +1,16 @@
 // file      : xsde/cxx/tree/polymorphism-processor.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
+#include <iostream>
+
 #include <cxx/tree/elements.hxx>
 #include <cxx/tree/polymorphism-processor.hxx>
 
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
 
-#include <cult/containers/set.hxx>
-
-#include <iostream>
-
-using std::wcerr;
+using namespace std;
 
 namespace CXX
 {
@@ -21,64 +18,17 @@ namespace CXX
   {
     namespace
     {
-      struct TypeSet
-      {
-        template <typename I>
-        TypeSet (I begin, I end)
-        {
-          for (; begin != end; ++begin)
-            insert (*begin);
-        }
-
-        Void
-        insert (String const& name)
-        {
-          Size p (name.rfind ('#'));
-
-          if (p == String::npos)
-            unames_.insert (name);
-          else
-            qnames_.insert (name);
-        }
-
-        Boolean
-        find (SemanticGraph::Type& t)
-        {
-          if (!unames_.empty ())
-          {
-            if (unames_.find (t.name ()) != unames_.end ())
-              return true;
-          }
-
-          if (!qnames_.empty ())
-          {
-            if (qnames_.find (t.scope ().name () + L"#" + t.name ()) !=
-                qnames_.end ())
-              return true;
-          }
-
-          return false;
-        }
-
-      private:
-        typedef Cult::Containers::Set<String> StringSet;
-
-        StringSet unames_;
-        StringSet qnames_;
-      };
-
-
       //
       //
       struct Type: Traversal::Type,
                    Traversal::Complex
       {
-        Type (TypeSet& poly_types)
+        Type (TypeNameSet& poly_types)
             : poly_types_ (poly_types)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Type& t)
         {
           SemanticGraph::Context& ctx (t.context ());
@@ -87,7 +37,7 @@ namespace CXX
             ctx.set ("polymorphic", poly_types_.find (t));
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           SemanticGraph::Context& ctx (c.context ());
@@ -96,7 +46,7 @@ namespace CXX
           {
             // First check our base.
             //
-            Boolean pb (false);
+            bool pb (false);
             if (c.inherits_p ())
             {
               SemanticGraph::Type& b (c.inherits ().base ());
@@ -104,7 +54,7 @@ namespace CXX
               if (!b.context ().count ("polymorphic"))
                 dispatch (b);
 
-              pb = b.context ().get<Boolean> ("polymorphic");
+              pb = b.context ().get<bool> ("polymorphic");
             }
 
             ctx.set ("polymorphic", pb || poly_types_.find (c));
@@ -112,7 +62,7 @@ namespace CXX
         }
 
       private:
-        TypeSet& poly_types_;
+        TypeNameSet& poly_types_;
       };
 
       struct FundType: Traversal::AnyType,
@@ -171,13 +121,13 @@ namespace CXX
                        Traversal::Fundamental::Entity,
                        Traversal::Fundamental::Entities
       {
-        FundType (TypeSet& poly_types, Boolean& valid)
+        FundType (TypeNameSet& poly_types, bool& valid)
             : poly_types_ (poly_types), valid_ (valid)
         {
         }
 
-        Void
-        check (SemanticGraph::Type& t, Boolean fund)
+        void
+        check (SemanticGraph::Type& t, bool fund)
         {
           SemanticGraph::Context& ctx (t.context ());
 
@@ -201,13 +151,13 @@ namespace CXX
 
         // anyType & anySimpleType.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyType& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnySimpleType& t)
         {
           check (t, false);
@@ -215,7 +165,7 @@ namespace CXX
 
         // Boolean.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Boolean& t)
         {
           check (t, true);
@@ -223,79 +173,79 @@ namespace CXX
 
         // Integral types.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Byte& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedByte& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Short& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedShort& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Int& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedInt& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Long& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::UnsignedLong& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Integer& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NonPositiveInteger& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NonNegativeInteger& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::PositiveInteger& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NegativeInteger& t)
         {
           check (t, true);
@@ -303,19 +253,19 @@ namespace CXX
 
         // Floats.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Float& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Double& t)
         {
           check (t, true);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Decimal& t)
         {
           check (t, true);
@@ -323,49 +273,49 @@ namespace CXX
 
         // Strings.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::String& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NormalizedString& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Token& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NameToken& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NameTokens& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Name& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::NCName& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Language& t)
         {
           check (t, false);
@@ -374,7 +324,7 @@ namespace CXX
 
         // Qualified name.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::QName& t)
         {
           check (t, false);
@@ -383,19 +333,19 @@ namespace CXX
 
         // ID/IDREF.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Id& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::IdRef& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::IdRefs& t)
         {
           check (t, false);
@@ -403,7 +353,7 @@ namespace CXX
 
         // URI.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::AnyURI& t)
         {
           check (t, false);
@@ -411,13 +361,13 @@ namespace CXX
 
         // Binary.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Base64Binary& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::HexBinary& t)
         {
           check (t, false);
@@ -426,55 +376,55 @@ namespace CXX
 
         // Date/time.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Date& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::DateTime& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Duration& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Day& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Month& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::MonthDay& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Year& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::YearMonth& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Time& t)
         {
           check (t, false);
@@ -482,27 +432,27 @@ namespace CXX
 
         // Entity.
         //
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Entity& t)
         {
           check (t, false);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Entities& t)
         {
           check (t, false);
         }
 
       private:
-        TypeSet& poly_types_;
-        Boolean& valid_;
+        TypeNameSet& poly_types_;
+        bool& valid_;
       };
 
       struct GlobalElement: Traversal::Element
       {
-        GlobalElement (TypeSet& poly_types,
-                       Boolean& valid,
+        GlobalElement (TypeNameSet& poly_types,
+                       bool& valid,
                        const WarningSet& disabled_warnings)
             : poly_types_ (poly_types), valid_ (valid), warning_ (true)
         {
@@ -511,7 +461,7 @@ namespace CXX
             warning_ = false;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           using SemanticGraph::Schema;
@@ -528,13 +478,13 @@ namespace CXX
 
           // We may need to override the previous value.
           //
-          if (ctx.count ("polymorphic") && ctx.get<Boolean> ("polymorphic"))
+          if (ctx.count ("polymorphic") && ctx.get<bool> ("polymorphic"))
             return;
 
           // Built-in types that are mapped to fundamental types cannot
           // be declared polymorphic.
           //
-          Boolean fund (false);
+          bool fund (false);
           IsFundamentalType test (fund);
           test.dispatch (rt);
 
@@ -585,7 +535,7 @@ namespace CXX
       private:
         // Return true if root sources s.
         //
-        Boolean
+        bool
         sources_p (SemanticGraph::Schema& root, SemanticGraph::Schema& s)
         {
           using SemanticGraph::Schema;
@@ -605,9 +555,9 @@ namespace CXX
         }
 
       private:
-        TypeSet& poly_types_;
-        Boolean& valid_;
-        Boolean warning_;
+        TypeNameSet& poly_types_;
+        bool& valid_;
+        bool warning_;
       };
 
       // Go into sourced/included/imported schemas while making sure
@@ -617,12 +567,12 @@ namespace CXX
                    Traversal::Includes,
                    Traversal::Imports
       {
-        Uses (Char const* seen_key)
+        Uses (char const* seen_key)
             : seen_key_ (seen_key)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Sources& sr)
         {
           SemanticGraph::Schema& s (sr.schema ());
@@ -634,7 +584,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Includes& i)
         {
           SemanticGraph::Schema& s (i.schema ());
@@ -646,7 +596,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Imports& i)
         {
           SemanticGraph::Schema& s (i.schema ());
@@ -659,25 +609,25 @@ namespace CXX
         }
 
       private:
-        Char const* seen_key_;
+        char const* seen_key_;
       };
 
-      Char const* pass_one_key = "cxx-tree-polymorphism-processor-seen-one";
-      Char const* pass_two_key = "cxx-tree-polymorphism-processor-seen-two";
+      char const* pass_one_key = "cxx-tree-polymorphism-processor-seen-one";
+      char const* pass_two_key = "cxx-tree-polymorphism-processor-seen-two";
 
-      Boolean
-      process_impl (CLI::Options const& ops,
+      bool
+      process_impl (options const& ops,
                     SemanticGraph::Schema& tu,
                     SemanticGraph::Path const&,
                     const WarningSet& disabled_warnings)
       {
-        Boolean valid (true);
+        bool valid (true);
 
         // Prepare a set of polymorphic types.
         //
 
-        TypeSet poly_types (ops.value<CLI::polymorphic_type> ().begin (),
-                            ops.value<CLI::polymorphic_type> ().end ());
+        TypeNameSet poly_types (ops.polymorphic_type ().begin (),
+                                ops.polymorphic_type ().end ());
 
         // Root schema in the file-per-type mode is just a bunch
         // of includes without a namespace.
@@ -779,8 +729,8 @@ namespace CXX
       }
     }
 
-    Boolean PolymorphismProcessor::
-    process (CLI::Options const& ops,
+    bool PolymorphismProcessor::
+    process (options const& ops,
              SemanticGraph::Schema& tu,
              SemanticGraph::Path const& file,
              const WarningSet& disabled_warnings)
diff --git a/xsd/xsd/cxx/tree/polymorphism-processor.hxx b/xsd/xsd/cxx/tree/polymorphism-processor.hxx
index 3fbeca8..7338790 100644
--- a/xsd/xsd/cxx/tree/polymorphism-processor.hxx
+++ b/xsd/xsd/cxx/tree/polymorphism-processor.hxx
@@ -1,30 +1,26 @@
 // file      : xsde/cxx/tree/polymorphism-processor.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_POLYMORPHISM_PROCESSOR_HXX
 #define CXX_TREE_POLYMORPHISM_PROCESSOR_HXX
 
-#include <cult/types.hxx>
-
 #include <xsd-frontend/semantic-graph.hxx>
 
-#include <cxx/tree/cli.hxx>
-
 #include <xsd.hxx>
+#include <types.hxx>
+
+#include <cxx/tree/options.hxx>
 
 namespace CXX
 {
   namespace Tree
   {
-    using namespace Cult::Types;
-
     class PolymorphismProcessor
     {
     public:
-      Boolean
-      process (CLI::Options const& options,
+      bool
+      process (options const&,
                XSDFrontend::SemanticGraph::Schema&,
                XSDFrontend::SemanticGraph::Path const& file,
                const WarningSet& disabled_warnings);
diff --git a/xsd/xsd/cxx/tree/serialization-header.cxx b/xsd/xsd/cxx/tree/serialization-header.cxx
index d024a38..67da857 100644
--- a/xsd/xsd/cxx/tree/serialization-header.cxx
+++ b/xsd/xsd/cxx/tree/serialization-header.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/serialization-header.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/serialization-header.hxx>
@@ -21,7 +20,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String name (ename (l));
@@ -67,7 +66,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String name (ename (u));
@@ -112,7 +111,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String name (ename (e));
@@ -156,7 +155,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           String name (ename (c));
@@ -175,7 +174,7 @@ namespace CXX
             "const " << name << "&);"
              << endl;
 
-          Boolean simple (true);
+          bool simple (true);
           {
             IsSimpleType t (simple);
             t.dispatch (c);
@@ -211,7 +210,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (doc_root_p (e))
@@ -237,7 +236,7 @@ namespace CXX
         }
 
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (!doc_root_p (e))
@@ -533,10 +532,10 @@ namespace CXX
 
     }
 
-    Void
+    void
     generate_serialization_header (Context& ctx)
     {
-      Boolean elemen_type (ctx.options.value<CLI::generate_element_type> ());
+      bool elemen_type (ctx.options.generate_element_type ());
 
       if (!elemen_type)
         ctx.os << "#include <iosfwd>" << endl
@@ -550,7 +549,7 @@ namespace CXX
 
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names names_ns, names;
 
       Namespace ns (ctx);
diff --git a/xsd/xsd/cxx/tree/serialization-header.hxx b/xsd/xsd/cxx/tree/serialization-header.hxx
index 86c6b6a..979bb2e 100644
--- a/xsd/xsd/cxx/tree/serialization-header.hxx
+++ b/xsd/xsd/cxx/tree/serialization-header.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/serialization-header.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_SERIALIZATION_HEADER_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
+    void
     generate_serialization_header (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/tree/serialization-source.cxx b/xsd/xsd/cxx/tree/serialization-source.cxx
index 40ae031..559a3cf 100644
--- a/xsd/xsd/cxx/tree/serialization-source.cxx
+++ b/xsd/xsd/cxx/tree/serialization-source.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/serialization-source.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/serialization-source.hxx>
@@ -42,7 +41,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String name (ename (l));
@@ -91,7 +90,9 @@ namespace CXX
              << "l << static_cast< const " << base << "& > (i);"
              << "}";
 
-          // Register with type factory map.
+          // Register with type factory map. If this type is anonymous
+          // but substitutes, then it will be registered as part of the
+          // substitution registration.
           //
           if (polymorphic && polymorphic_p (l) && !anonymous_p (l))
           {
@@ -100,8 +101,8 @@ namespace CXX
             String const& name (ename (l));
 
             os << "static" << endl
-               << "const ::xsd::cxx::tree::type_serializer_initializer< 0, " <<
-              char_type << ", " << name << " >" << endl
+               << "const ::xsd::cxx::tree::type_serializer_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                << "_xsd_" << name << "_type_serializer_init (" << endl
                << strlit (l.name ()) << "," << endl
                << strlit (xml_ns_name (l)) << ");"
@@ -131,7 +132,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String name (ename (u));
@@ -171,7 +172,9 @@ namespace CXX
              << "l << static_cast< const " << base << "& > (i);"
              << "}";
 
-          // Register with type factory map.
+          // Register with type factory map. If this type is anonymous
+          // but substitutes, then it will be registered as part of the
+          // substitution registration.
           //
           if (polymorphic && polymorphic_p (u) && !anonymous_p (u))
           {
@@ -180,8 +183,8 @@ namespace CXX
             String const& name (ename (u));
 
             os << "static" << endl
-               << "const ::xsd::cxx::tree::type_serializer_initializer< 0, " <<
-              char_type << ", " << name << " >" << endl
+               << "const ::xsd::cxx::tree::type_serializer_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                << "_xsd_" << name << "_type_serializer_init (" << endl
                << strlit (u.name ()) << "," << endl
                << strlit (xml_ns_name (u)) << ");"
@@ -200,7 +203,7 @@ namespace CXX
           inherits_base_ >> base_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String name (ename (e));
@@ -253,7 +256,9 @@ namespace CXX
              << "}";
 
 
-          // Register with type factory map.
+          // Register with type factory map. If this type is anonymous
+          // but substitutes, then it will be registered as part of the
+          // substitution registration.
           //
           if (polymorphic && polymorphic_p (e) && !anonymous_p (e))
           {
@@ -262,8 +267,8 @@ namespace CXX
             String const& name (ename (e));
 
             os << "static" << endl
-               << "const ::xsd::cxx::tree::type_serializer_initializer< 0, " <<
-              char_type << ", " << name << " >" << endl
+               << "const ::xsd::cxx::tree::type_serializer_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                << "_xsd_" << name << "_type_serializer_init (" << endl
                << strlit (e.name ()) << "," << endl
                << strlit (xml_ns_name (e)) << ");"
@@ -284,12 +289,17 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (skip (e))
             return;
 
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (e.scope ()));
+
+          bool ordered (ordered_p (c));
+
           String const& aname (eaname (e));
           String ns (e.qualified_p () ? e.namespace_ ().name () : "");
           String type (scope + L"::" + etype (e));
@@ -301,20 +311,23 @@ namespace CXX
           // dynamically-type with xsi:type.
           //
           SemanticGraph::Type& t (e.type ());
-          Boolean poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
 
           os << "// " << comment (e.name ()) << endl
              << "//" << endl;
 
-          // aCC cannot handle an inline call to type_serializer_map_instance.
-          //
+          if (ordered)
+            os << "case " << scope << "::" <<
+              e.context ().get<String> ("ordered-id-name") << ":"
+               << "{";
+
           if (poly)
           {
-            os << "{"
+            os << (ordered ? "" : "{")
                << "::xsd::cxx::tree::type_serializer_map< " << char_type
                << " >& tsm (" << endl
-               << "::xsd::cxx::tree::type_serializer_map_instance< 0, " <<
-              char_type << " > ());"
+               << "::xsd::cxx::tree::type_serializer_map_instance< " <<
+              poly_plate << ", " << char_type << " > ());"
                << endl;
           }
 
@@ -322,15 +335,22 @@ namespace CXX
           {
             // sequence
             //
-            os << "for (" << scope << "::" << econst_iterator (e) << endl
-               << "b (i." << aname << " ().begin ()), " <<
-              "n (i." << aname << " ().end ());" << endl
-               << "b != n; ++b)"
-               << "{";
+            if (ordered)
+              os << "const " << type << "& x (i." << aname <<
+                " ()[b->index]);"
+                 << endl;
+            else
+              os << "for (" << scope << "::" << econst_iterator (e) << endl
+                 << "b (i." << aname << " ().begin ()), " <<
+                "n (i." << aname << " ().end ());" << endl
+                 << "b != n; ++b)"
+                 << "{";
+
+            char const* x (ordered ? "x" : "*b");
 
             if (poly)
             {
-              os << "if (typeid (" << type << ") == typeid (*b))"
+              os << "if (typeid (" << type << ") == typeid (" << x << "))"
                  << "{"
                  << xerces_ns << "::DOMElement& s (" << endl
                  << "::xsd::cxx::xml::dom::create_element (" << endl
@@ -338,14 +358,14 @@ namespace CXX
                  << (ns ? strlit (ns) + L",\n" : L"")
                  << "e));"
                  << endl
-                 << "s << *b;"
+                 << "s << " << x << ";"
                  << "}"
                  << "else" << endl
                  << "tsm.serialize (" << endl
                  << strlit (e.name ()) << "," << endl
                  << strlit (ns) << "," << endl
                  << (e.global_p () ? "true" : "false") << ", " <<
-                (e.qualified_p () ? "true" : "false") << ", e, *b);";
+                (e.qualified_p () ? "true" : "false") << ", e, " << x << ");";
             }
             else
             {
@@ -360,30 +380,29 @@ namespace CXX
               {
               case st_other:
                 {
-                  os << "s << *b;";
+                  os << "s << " << x << ";";
                   break;
                 }
               case st_double:
                 {
-                  os << "s << " << as_double_type << " (*b);";
+                  os << "s << " << as_double_type << " (" << x << ");";
                   break;
                 }
               case st_decimal:
                 {
-                  os << "s << " << as_decimal_type << " (*b);";
+                  os << "s << " << as_decimal_type << " (" << x << ");";
                   break;
                 }
               }
             }
-
-            os << "}";
           }
           else if (min (e) == 0)
           {
             // optional
             //
-            os << "if (i." << aname << " ())"
-               << "{";
+            if (!ordered)
+              os << "if (i." << aname << " ())"
+                 << "{";
 
             if (poly)
             {
@@ -433,8 +452,6 @@ namespace CXX
                 }
               }
             }
-
-            os << "}";
           }
           else
           {
@@ -462,8 +479,10 @@ namespace CXX
             }
             else
             {
-              os << "{"
-                 << xerces_ns << "::DOMElement& s (" << endl
+              if (!ordered)
+                os << "{";
+
+              os << xerces_ns << "::DOMElement& s (" << endl
                  << "::xsd::cxx::xml::dom::create_element (" << endl
                  << strlit (e.name ()) << "," << endl
                  << (ns ? strlit (ns) + L",\n" : L"")
@@ -488,13 +507,26 @@ namespace CXX
                   break;
                 }
               }
-
-              os << "}";
             }
           }
 
-          if (poly)
+          if (ordered)
+          {
+            // See comment for bool text (false); below.
+            //
+            if (mixed_p (c) && c.context ().get<size_t> ("ordered-start") != 1)
+              os << "text = true;";
+
+            os << "continue;"
+               << "}";
+          }
+          else
+          {
             os << "}";
+
+            if (poly && (max (e) != 1 || min (e) == 0))
+              os << "}"; // There is no extra block for poly one.
+          }
         }
 
       private:
@@ -508,51 +540,80 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (a.scope ()));
+
+          bool ordered (ordered_p (c));
+
           String const& aname (eaname (a));
 
           os << "// " << ename (a) << endl
              << "//" << endl;
 
+          if (ordered)
+            os << "case " << scope << "::" <<
+              a.context ().get<String> ("ordered-id-name") << ":";
+
           if (max (a) != 1)
           {
             // sequence
             //
-            os << "for (" << scope << "::" << econst_iterator (a) << endl
-               << "b (i." << aname << " ().begin ()), " <<
-              "n (i." << aname << " ().end ());" << endl
-               << "b != n; ++b)"
-               << "{"
+            if (!ordered)
+              os << "for (" << scope << "::" << econst_iterator (a) << endl
+                 << "b (i." << aname << " ().begin ()), " <<
+                "n (i." << aname << " ().end ());" << endl
+                 << "b != n; ++b)";
+
+            os << "{"
                << "e.appendChild (" << endl
                << "e.getOwnerDocument ()->importNode (" << endl
                << "const_cast< " << xerces_ns <<
-              "::DOMElement* > (&(*b)), true));"
-               << "}";
+              "::DOMElement* > (&(" <<
+              (ordered ? (L"i." + aname + L" ()[b->index]") : L"*b") <<
+              ")), true));";
           }
           else if (min (a) == 0)
           {
             // optional
             //
-            os << "if (i." << aname << " ())"
-               << "{"
+            if (!ordered)
+              os << "if (i." << aname << " ())";
+
+            os << "{"
                << "e.appendChild (" << endl
                << "e.getOwnerDocument ()->importNode (" << endl
                << "const_cast< " << xerces_ns << "::DOMElement* > (&(*i." <<
-              aname << " ())), true));"
-               << "}";
+              aname << " ())), true));";
           }
           else
           {
             // one
             //
+            if (ordered)
+              os << "{";
+
             os << "e.appendChild (" << endl
                << "e.getOwnerDocument ()->importNode (" << endl
                << "const_cast< " << xerces_ns << "::DOMElement* > (&(i." <<
               aname << " ())), true));"
                << endl;
           }
+
+          if (ordered)
+          {
+            // See comment for bool text (false); below.
+            //
+            if (mixed_p (c) && c.context ().get<size_t> ("ordered-start") != 1)
+              os << "text = true;";
+
+            os << "continue;";
+          }
+
+          if (ordered || max (a) != 1 || min (a) == 0)
+            os << "}";
         }
 
       private:
@@ -566,7 +627,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           String const& aname (eaname (a));
@@ -611,8 +672,7 @@ namespace CXX
           {
             // Make sure we serialize required fixed attributes.
             //
-            if (a.optional_p () &&
-                options.value<CLI::omit_default_attributes> ())
+            if (a.optional_p () && options.omit_default_attributes ())
             {
               os << "if (i." << aname << " () != " << scope <<
                 "::" << edefault_value (a) << " ())";
@@ -660,7 +720,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           String const& aname (eaname (a));
@@ -697,9 +757,11 @@ namespace CXX
           inherits_ >> base_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
+          SemanticGraph::Context& ctx (c.context ());
+
           String name (ename (c));
 
           // If renamed name is empty then we do not need to generate
@@ -729,7 +791,7 @@ namespace CXX
           // Serialize anyAttribute content first so that is gets
           // overriden by schema-defined attributes.
           //
-          if (options.value<CLI::generate_wildcard> ())
+          if (options.generate_wildcard ())
           {
             AnyAttribute any_attribute (*this, name);
             Traversal::Names names (any_attribute);
@@ -738,24 +800,109 @@ namespace CXX
           }
 
           {
+            bool o (ordered_p (c));
+            size_t start, count;
+
+            if (o)
+            {
+              start = ctx.get<size_t> ("ordered-start");
+              count = ctx.get<size_t> ("ordered-count");
+
+              if (start != count)
+              {
+                String const& ci (ctx.get<String> ("order-const-iterator"));
+                String const& an (ctx.get<String> ("order-aname"));
+
+                // If we have mixed content and a base, then we have to
+                // skip the text content until we serialize one of "our"
+                // elements.
+                //
+                if (mixed_p (c) && start != 1)
+                  os << "bool text (false);"
+                     << endl;
+
+                os << "for (" << name << "::" << ci << endl
+                   << "b (i." << an << " ().begin ()), n (i." << an <<
+                  " ().end ());" << endl
+                   << "b != n; ++b)"
+                   << "{"
+                   << "switch (b->id)"
+                   << "{";
+              }
+            }
+
             Traversal::Names names;
             Any any (*this, name);
             Element element (*this, name);
-            Attribute attribute (*this, name);
 
             names >> element;
-            names >> attribute;
 
-            if (options.value<CLI::generate_wildcard> ())
+            if (options.generate_wildcard ())
               names >> any;
 
             Complex::names (c, names);
+
+            if (o)
+            {
+              if (start != count)
+              {
+                if (mixed_p (c))
+                {
+                  //@@ propagate mixed-ordered-id to derived
+
+                  os << "// text_content" << endl
+                     << "//" << endl
+                     << "case " << name << "::" <<
+                    ctx.get<String> ("mixed-ordered-id-name") << ":"
+                     << "{";
+
+                  // See the comment above.
+                  //
+                  if (start != 1)
+                    os << "if (text)" << endl;
+
+                  os << "e.appendChild (" << endl
+                     << "e.getOwnerDocument ()->createTextNode (" << endl
+                     << "::xsd::cxx::xml::string (" << endl
+                     << "i." << ctx.get<String> ("mixed-aname") <<
+                    " ()[b->index].c_str ()).c_str ()));";
+
+                  // os << "e << i." << ctx.get<String> ("mixed-aname") <<
+                  //  " ()[b->index];";
+
+                  os << "continue;"
+                     << "}";
+                }
+
+                // Ignore content before our id range and stop serializing
+                // if we see anything past. This handles inheritance.
+                //
+                os << "default:"
+                   << "{";
+
+                if (start != 1)
+                  os << "if (b->id < " << start << "UL)" << endl
+                     << "continue;";
+
+                os << "break;" // Stop (see break below).
+                   << "}";
+
+                os << "}"      // switch
+                   << "break;" // Unknown element past our elements.
+                   << "}";     // for
+              }
+            }
           }
 
-          os << "}";
+          {
+            Attribute attribute (*this, name);
+            Traversal::Names names (attribute);
+            Complex::names (c, names);
+          }
 
+          os << "}";
 
-          Boolean simple (true);
+          bool simple (true);
           {
             IsSimpleType t (simple);
             t.dispatch (c);
@@ -763,7 +910,7 @@ namespace CXX
 
           if (simple)
           {
-            Boolean hb (c.inherits_p ());
+            bool hb (c.inherits_p ());
 
             // operator<< (xercesc::DOMAttr)
             //
@@ -805,7 +952,9 @@ namespace CXX
             os << "}";
           }
 
-          // Register with type factory map.
+          // Register with type factory map. If this type is anonymous
+          // but substitutes, then it will be registered as part of the
+          // substitution registration.
           //
           if (polymorphic && polymorphic_p (c) && !anonymous_p (c))
           {
@@ -814,8 +963,8 @@ namespace CXX
             String const& name (ename (c));
 
             os << "static" << endl
-               << "const ::xsd::cxx::tree::type_serializer_initializer< 0, " <<
-              char_type << ", " << name << " >" << endl
+               << "const ::xsd::cxx::tree::type_serializer_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                << "_xsd_" << name << "_type_serializer_init (" << endl
                << strlit (c.name ()) << "," << endl
                << strlit (xml_ns_name (c)) << ");"
@@ -842,7 +991,7 @@ namespace CXX
           belongs_ >> type_name_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (polymorphic && e.substitutes_p ())
@@ -852,8 +1001,8 @@ namespace CXX
             String const& name (ename (e));
 
             os << "static" << endl
-               << "const ::xsd::cxx::tree::element_serializer_initializer< 0, " <<
-              char_type << ", ";
+               << "const ::xsd::cxx::tree::element_serializer_initializer< " <<
+                poly_plate << ", " << char_type << ", ";
 
             belongs (e, belongs_);
 
@@ -881,11 +1030,11 @@ namespace CXX
         ElementType (Context& c)
             : GlobalElementBase (c),
               Context (c),
-              element_map_ (c.options.value<CLI::generate_element_map> ())
+              element_map_ (c.options.generate_element_map ())
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (doc_root_p (e))
@@ -921,7 +1070,7 @@ namespace CXX
         }
 
       private:
-        Boolean element_map_;
+        bool element_map_;
       };
 
       struct ElementFunction: Traversal::Element,
@@ -933,7 +1082,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (!doc_root_p (e))
@@ -954,7 +1103,7 @@ namespace CXX
           // If this element's type is anonymous then we don't need to do
           // anything.
           //
-          Boolean poly (polymorphic &&
+          bool poly (polymorphic &&
                         polymorphic_p (type) &&
                         !anonymous_p (type));
 
@@ -1137,18 +1286,11 @@ namespace CXX
 
           if (poly)
           {
-            // aCC cannot handle an inline call to
-            // type_serializer_map_instance.
-            //
             os << "}"
                << "else"
                << "{"
-               << "::xsd::cxx::tree::type_serializer_map< " << char_type
-               << " >& tsm (" << endl
-               << "::xsd::cxx::tree::type_serializer_map_instance< 0, " <<
-              char_type << " > ());"
-               << endl
-               << "tsm.serialize (" << endl
+               << "::xsd::cxx::tree::type_serializer_map_instance< " <<
+              poly_plate << ", " << char_type << " > ().serialize (" << endl
                << strlit (e.name ()) << "," << endl
                << strlit (e.namespace_().name ()) << "," << endl
                << "e, n, s);"
@@ -1168,37 +1310,23 @@ namespace CXX
 
           if (poly)
           {
-            // aCC cannot handle an inline call to
-            // type_serializer_map_instance as well as the direct
-            // auto_ptr assignment.
-            //
             os << dom_auto_ptr << "< " << xerces_ns << "::DOMDocument > d;"
                << endl
                << "if (typeid (" << type_name (e) << ") == typeid (s))"
                << "{"
-               << dom_auto_ptr << "< " << xerces_ns <<
-              "::DOMDocument > r (" << endl
-               << "::xsd::cxx::xml::dom::serialize< " <<
+               << "d = ::xsd::cxx::xml::dom::serialize< " <<
               char_type << " > (" << endl
                << strlit (e.name ()) << "," << endl
                << strlit (ns) << "," << endl
-               << "m, f));"
-               << "d = r;"
+               << "m, f);"
                << "}"
                << "else"
                << "{"
-               << "::xsd::cxx::tree::type_serializer_map< " << char_type
-               << " >& tsm (" << endl
-               << "::xsd::cxx::tree::type_serializer_map_instance< 0, " <<
-              char_type << " > ());"
-               << endl
-               << dom_auto_ptr << "< " << xerces_ns <<
-              "::DOMDocument > r (" << endl
-               << "tsm.serialize (" << endl
+               << "d = ::xsd::cxx::tree::type_serializer_map_instance< " <<
+              poly_plate << ", " << char_type << " > ().serialize (" << endl
                << strlit (e.name ()) << "," << endl
                << strlit (e.namespace_().name ()) << "," << endl
-               << "m, s, f));"
-               << "d = r;"
+               << "m, s, f);"
                << "}";
           }
           else
@@ -1233,12 +1361,10 @@ namespace CXX
       };
     }
 
-    Void
-    generate_serialization_source (Context& ctx,
-                                   UnsignedLong first,
-                                   UnsignedLong last)
+    void
+    generate_serialization_source (Context& ctx, size_t first, size_t last)
     {
-      Boolean elemen_type (ctx.options.value<CLI::generate_element_type> ());
+      bool elemen_type (ctx.options.generate_element_type ());
 
       if (!elemen_type)
         ctx.os << "#include <ostream>" << endl
@@ -1252,8 +1378,8 @@ namespace CXX
         ctx.os << "#include <xsd/cxx/tree/type-serializer-map.hxx>" << endl
                << endl;
 
-        Boolean import_maps (ctx.options.value<CLI::import_maps> ());
-        Boolean export_maps (ctx.options.value<CLI::export_maps> ());
+        bool import_maps (ctx.options.import_maps ());
+        bool export_maps (ctx.options.export_maps ());
 
         if (import_maps || export_maps)
         {
@@ -1269,19 +1395,23 @@ namespace CXX
 
           if (export_maps)
             ctx.os << "template struct __declspec (dllexport) " <<
-              "type_serializer_plate< 0, " << ctx.char_type << " >;";
+              "type_serializer_plate< " << ctx.poly_plate << ", " <<
+              ctx.char_type << " >;";
 
           if (import_maps)
             ctx.os << "template struct __declspec (dllimport) " <<
-              "type_serializer_plate< 0, " << ctx.char_type << " >;";
+              "type_serializer_plate< " << ctx.poly_plate << ", " <<
+              ctx.char_type << " >;";
 
           ctx.os << "#elif defined(__GNUC__) && __GNUC__ >= 4" << endl
                  << "template struct __attribute__ ((visibility(\"default\"))) " <<
-            "type_serializer_plate< 0, " << ctx.char_type << " >;";
+            "type_serializer_plate< " << ctx.poly_plate << ", " <<
+            ctx.char_type << " >;";
 
           ctx.os << "#elif defined(XSD_MAP_VISIBILITY)" << endl
                  << "template struct XSD_MAP_VISIBILITY " <<
-            "type_serializer_plate< 0, " << ctx.char_type << " >;";
+            "type_serializer_plate< " << ctx.poly_plate << ", " <<
+            ctx.char_type << " >;";
 
           ctx.os << "#endif" << endl
                  << "}"  // tree
@@ -1294,15 +1424,15 @@ namespace CXX
         ctx.os << "namespace _xsd"
                << "{"
                << "static" << endl
-               << "const ::xsd::cxx::tree::type_serializer_plate< 0, " <<
-          ctx.char_type << " >" << endl
+               << "const ::xsd::cxx::tree::type_serializer_plate< " <<
+                ctx.poly_plate << ", " << ctx.char_type << " >" << endl
                << "type_serializer_plate_init;"
                << "}";
       }
 
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names names_ns, names;
 
       Namespace ns (ctx, first, last);
diff --git a/xsd/xsd/cxx/tree/serialization-source.hxx b/xsd/xsd/cxx/tree/serialization-source.hxx
index 322949a..1a74126 100644
--- a/xsd/xsd/cxx/tree/serialization-source.hxx
+++ b/xsd/xsd/cxx/tree/serialization-source.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/serialization-source.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_SERIALIZATION_SOURCE_HXX
@@ -12,10 +11,8 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
-    generate_serialization_source (Context&,
-                                   UnsignedLong first,
-                                   UnsignedLong last);
+    void
+    generate_serialization_source (Context&, size_t first, size_t last);
   }
 }
 
diff --git a/xsd/xsd/cxx/tree/stream-extraction-source.cxx b/xsd/xsd/cxx/tree/stream-extraction-source.cxx
index 1378bc6..ceb56c1 100644
--- a/xsd/xsd/cxx/tree/stream-extraction-source.cxx
+++ b/xsd/xsd/cxx/tree/stream-extraction-source.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/stream-extraction-source.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/stream-extraction-source.hxx>
@@ -14,8 +13,6 @@ namespace CXX
   {
     namespace
     {
-      typedef Containers::Vector<NarrowString> Streams;
-
       struct List: Traversal::List, Context
       {
         List (Context& c)
@@ -23,7 +20,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String name (ename (l));
@@ -45,9 +42,10 @@ namespace CXX
 
           base += L" >";
 
-          UnsignedLong n (0);
-          Streams const& st (options.value<CLI::generate_extraction> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          size_t n (0);
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ());
+               i != st.end (); ++i)
           {
             os << name << "::" << endl
                << name << " (" << istream_type << "< " <<
@@ -61,7 +59,9 @@ namespace CXX
 
             // Register with type map.
             //
-            if (polymorphic && polymorphic_p (l) && !anonymous_p (l))
+            if (polymorphic &&
+                polymorphic_p (l) &&
+                (!anonymous_p (l) || anonymous_substitutes_p (l)))
             {
               // Note that we are using the original type name.
               //
@@ -69,8 +69,8 @@ namespace CXX
 
               os << "static" << endl
                  << "const ::xsd::cxx::tree::stream_extraction_initializer< " <<
-                "0, " << i->c_str () << ", " <<
-                char_type << ", " << name << " >" << endl
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
                  << "_xsd_" << name << "_stream_extraction_init_" <<
                 n++ << " (" << endl
                  << strlit (l.name ()) << "," << endl
@@ -101,7 +101,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String name (ename (u));
@@ -114,9 +114,10 @@ namespace CXX
 
           String const& base (xs_string_type);
 
-          UnsignedLong n (0);
-          Streams const& st (options.value<CLI::generate_extraction> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          size_t n (0);
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             os << name << "::" << endl
                << name << " (" << istream_type << "< " <<
@@ -129,7 +130,9 @@ namespace CXX
 
             // Register with type map.
             //
-            if (polymorphic && polymorphic_p (u) && !anonymous_p (u))
+            if (polymorphic &&
+                polymorphic_p (u) &&
+                (!anonymous_p (u) || anonymous_substitutes_p (u)))
             {
               // Note that we are using the original type name.
               //
@@ -137,8 +140,8 @@ namespace CXX
 
               os << "static" << endl
                  << "const ::xsd::cxx::tree::stream_extraction_initializer< " <<
-                "0, " << i->c_str () << ", " <<
-                char_type << ", " << name << " >" << endl
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
                  << "_xsd_" << name << "_stream_extraction_init_" <<
                 n++ << " (" << endl
                  << strlit (u.name ()) << "," << endl
@@ -158,7 +161,7 @@ namespace CXX
           inherits_base_ >> base_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String name (ename (e));
@@ -169,15 +172,30 @@ namespace CXX
           if (renamed_type (e, name) && !name)
             return;
 
-          Boolean string_based (false);
+          bool string_based (false);
           {
             IsStringBasedType t (string_based);
             t.dispatch (e);
           }
 
-          UnsignedLong n (0);
-          Streams const& st (options.value<CLI::generate_extraction> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          bool enum_based (false);
+          if (string_based)
+          {
+            SemanticGraph::Enumeration* base_enum (0);
+            IsEnumBasedType t (base_enum);
+            t.dispatch (e);
+
+            enum_based = (base_enum != 0);
+          }
+
+          String value;
+          if (string_based)
+            value = evalue (e);
+
+          size_t n (0);
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             os << name << "::" << endl
                << name << " (" << istream_type << "< " <<
@@ -188,8 +206,18 @@ namespace CXX
 
             inherits (e, inherits_base_);
 
-            os << " (s, f, c)"
-               << "{";
+            if (string_based && !enum_based)
+            {
+              // Use copy c-tor to pass the flags and container.
+              //
+              os << " (" << endl;
+              inherits (e, inherits_base_);
+              os << " (_xsd_" << name << "_literals_[s.read_uint ()]), f, c)";
+            }
+            else
+              os << " (s, f, c)";
+
+            os << "{";
 
             if (string_based)
               os << "_xsd_" << name << "_convert ();";
@@ -198,7 +226,9 @@ namespace CXX
 
             // Register with type map.
             //
-            if (polymorphic && polymorphic_p (e) && !anonymous_p (e))
+            if (polymorphic &&
+                polymorphic_p (e) &&
+                (!anonymous_p (e) || anonymous_substitutes_p (e)))
             {
               // Note that we are using the original type name.
               //
@@ -206,8 +236,8 @@ namespace CXX
 
               os << "static" << endl
                  << "const ::xsd::cxx::tree::stream_extraction_initializer< " <<
-                "0, " << i->c_str () << ", " <<
-                char_type << ", " << name << " >" << endl
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
                  << "_xsd_" << name << "_stream_extraction_init_" <<
                 n++ << " (" << endl
                  << strlit (e.name ()) << "," << endl
@@ -229,14 +259,14 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Member& m)
         {
           if (skip (m))
             return;
 
           os << "," << endl
-             << "  " << emember (m) << " (f, this)";
+             << "  " << emember (m) << " (this)";
         }
       };
 
@@ -249,7 +279,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           String const& member (emember (a));
@@ -261,7 +291,7 @@ namespace CXX
              << "  " << member << " (this->" << dom_doc << " ())";
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute& a)
         {
           String const& member (emember (a));
@@ -281,7 +311,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (skip (e))
@@ -291,8 +321,9 @@ namespace CXX
 
           SemanticGraph::Type& t (e.type ());
           String type (etype (e));
+          String tr (etraits (e)); // traits type name
 
-          Boolean fund (false);
+          bool fund (false);
           {
             IsFundamentalType traverser (fund);
             traverser.dispatch (t);
@@ -304,7 +335,12 @@ namespace CXX
           // from which makes it impossible to substitute or dynamically-
           // type with xsi:type.
           //
-          Boolean poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+
+          char const* r (
+            (poly || !fund) && std >= cxx_version::cxx11
+            ? "::std::move (r)"
+            : "r");
 
           if (max (e) != 1)
           {
@@ -327,16 +363,17 @@ namespace CXX
             if (poly)
             {
               os << "bool d;"
-                 << "::std::auto_ptr< " << type << " > r;"
+                 << auto_ptr << "< " << type << " > r;"
                  << "s >> d;"
                  << endl
                  << "if (!d)" << endl
                  << "r.reset (new " << type << " (s, f, this));"
                  << "else"
                  << "{"
-                 << "::std::auto_ptr< ::xsd::cxx::tree::type > tmp (" << endl
-                 << "::xsd::cxx::tree::stream_extraction_map_instance< 0, " <<
-                stream << ", " << char_type << " > ().extract (" << endl
+                 << auto_ptr << "< ::xsd::cxx::tree::type > tmp (" << endl
+                 << "::xsd::cxx::tree::stream_extraction_map_instance< " <<
+                poly_plate << ", " << stream << ", " << char_type <<
+                " > ().extract (" << endl
                  << "s, f, this));"
                  << "r.reset (dynamic_cast< " << type << "* > (tmp.get ()));"
                  << "if (r.get ())" << endl
@@ -353,11 +390,11 @@ namespace CXX
             }
             else
             {
-              os << "::std::auto_ptr< " << type << " > r (new " << type <<
-                " (s, f, this));";
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << tr << "::create (s, f, this));";
             }
 
-            os << "c.push_back (r);"
+            os << "c.push_back (" << r << ");"
                << "}" // while
                << "}" // if
                << "}";
@@ -375,16 +412,17 @@ namespace CXX
             if (poly)
             {
               os << "bool d;"
-                 << "::std::auto_ptr< " << type << " > r;"
+                 << auto_ptr << "< " << type << " > r;"
                  << "s >> d;"
                  << endl
                  << "if (!d)" << endl
                  << "r.reset (new " << type << " (s, f, this));"
                  << "else"
                  << "{"
-                 << "::std::auto_ptr< ::xsd::cxx::tree::type > tmp (" << endl
-                 << "::xsd::cxx::tree::stream_extraction_map_instance< 0, " <<
-                stream << ", " << char_type << " > ().extract (" << endl
+                 << auto_ptr << "< ::xsd::cxx::tree::type > tmp (" << endl
+                 << "::xsd::cxx::tree::stream_extraction_map_instance< " <<
+                poly_plate << ", " << stream << ", " << char_type <<
+                " > ().extract (" << endl
                  << "s, f, this));"
                  << "r.reset (dynamic_cast< " << type << "* > (tmp.get ()));"
                  << "if (r.get ())" << endl
@@ -401,11 +439,11 @@ namespace CXX
             }
             else
             {
-              os << "::std::auto_ptr< " << type << " > r (new " << type <<
-                " (s, f, this));";
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << tr << "::create (s, f, this));";
             }
 
-            os << "this->" << member << ".set (r);"
+            os << "this->" << member << ".set (" << r << ");"
                << "}" // if (p)
                << "}";
           }
@@ -418,16 +456,17 @@ namespace CXX
             if (poly)
             {
               os << "bool d;"
-                 << "::std::auto_ptr< " << type << " > r;"
+                 << auto_ptr << "< " << type << " > r;"
                  << "s >> d;"
                  << endl
                  << "if (!d)" << endl
                  << "r.reset (new " << type << " (s, f, this));"
                  << "else"
                  << "{"
-                 << "::std::auto_ptr< ::xsd::cxx::tree::type > tmp (" << endl
-                 << "::xsd::cxx::tree::stream_extraction_map_instance< 0, " <<
-                stream << ", " << char_type << " > ().extract (" << endl
+                 << auto_ptr << "< ::xsd::cxx::tree::type > tmp (" << endl
+                 << "::xsd::cxx::tree::stream_extraction_map_instance< " <<
+                poly_plate << ", " << stream << ", " << char_type <<
+                " > ().extract (" << endl
                  << "s, f, this));"
                  << "r.reset (dynamic_cast< " << type << "* > (tmp.get ()));"
                  << "if (r.get ())" << endl
@@ -444,11 +483,11 @@ namespace CXX
             }
             else
             {
-              os << "::std::auto_ptr< " << type << " > r (new " << type <<
-                " (s, f, this));";
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << tr << "::create (s, f, this));";
             }
 
-            os << "this->" << member << ".set (r);"
+            os << "this->" << member << ".set (" << r << ");"
                << "}";
           }
         }
@@ -464,13 +503,14 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           String const& member (emember (a));
           String type (etype (a));
+          String tr (etraits (a)); // traits type name
 
-          Boolean fund (false);
+          bool fund (false);
           {
             IsFundamentalType traverser (fund);
             traverser.dispatch (a.type ());
@@ -492,9 +532,8 @@ namespace CXX
             }
             else
             {
-              os << "::std::auto_ptr< " << type << " > r (new " << type <<
-                " (s, f, this));"
-                 << "this->" << member << ".set (r);";
+              os << "this->" << member << ".set (" << tr <<
+                "::create (s, f, this));";
             }
 
             os << "}" // if (p)
@@ -512,9 +551,8 @@ namespace CXX
             }
             else
             {
-              os << "::std::auto_ptr< " << type << " > r (new " << type <<
-                " (s, f, this));"
-                 << "this->" << member << ".set (r);";
+              os << "this->" << member << ".set (" << tr <<
+                "::create (s, f, this));";
             }
 
             os << "}";
@@ -530,11 +568,11 @@ namespace CXX
           inherits_ >> base_;
           names_ctor_member_ >> ctor_member_;
 
-          if (options.value<CLI::generate_wildcard> ())
+          if (options.generate_wildcard ())
             names_ctor_member_ >> ctor_any_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           String name (ename (c));
@@ -545,9 +583,9 @@ namespace CXX
           if (renamed_type (c, name) && !name)
             return;
 
-          Boolean has_members (has<Traversal::Member> (c));
+          bool has_members (has<Traversal::Member> (c));
 
-          Boolean facets (false);
+          bool facets (false);
           if (c.inherits_p ())
           {
             // See if we have any facets that we need to handle.
@@ -565,9 +603,10 @@ namespace CXX
             }
           }
 
-          UnsignedLong n (0);
-          Streams const& st (options.value<CLI::generate_extraction> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          size_t n (0);
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
 
             os << name << "::" << endl
@@ -613,7 +652,8 @@ namespace CXX
                  << unclash (name, "parse") << " (" <<
                 istream_type << "< " << i->c_str () << " >& s," << endl
                  << flags_type << " f)"
-                 << "{";
+                 << "{"
+                 << "XSD_UNUSED (f);"; // Can be unused.
               {
                 Element element (*this, *i);
                 Attribute attribute (*this);
@@ -631,7 +671,9 @@ namespace CXX
 
             // Register with type map.
             //
-            if (polymorphic && polymorphic_p (c) && !anonymous_p (c))
+            if (polymorphic &&
+                polymorphic_p (c) &&
+                (!anonymous_p (c) || anonymous_substitutes_p (c)))
             {
               // Note that we are using the original type name.
               //
@@ -639,8 +681,8 @@ namespace CXX
 
               os << "static" << endl
                  << "const ::xsd::cxx::tree::stream_extraction_initializer< " <<
-                "0, " << i->c_str () << ", " <<
-                char_type << ", " << name << " >" << endl
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
                  << "_xsd_" << name << "_stream_extraction_init_" <<
                 n++ << " (" << endl
                  << strlit (c.name ()) << "," << endl
@@ -661,18 +703,18 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_stream_extraction_source (Context& ctx)
     {
       if (ctx.polymorphic)
       {
-        Streams const& st (ctx.options.value<CLI::generate_extraction> ());
+        NarrowStrings const& st (ctx.options.generate_extraction ());
 
         ctx.os << "#include <xsd/cxx/tree/stream-extraction-map.hxx>" << endl
                << endl;
 
-        Boolean import_maps (ctx.options.value<CLI::import_maps> ());
-        Boolean export_maps (ctx.options.value<CLI::export_maps> ());
+        bool import_maps (ctx.options.import_maps ());
+        bool export_maps (ctx.options.export_maps ());
 
         if (import_maps || export_maps)
         {
@@ -685,7 +727,8 @@ namespace CXX
                  << "namespace tree"
                  << "{";
 
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             String stream (*i);
 
@@ -693,22 +736,22 @@ namespace CXX
 
             if (export_maps)
               ctx.os << "template struct __declspec (dllexport) " <<
-                "stream_extraction_plate< 0, " << stream << ", " <<
-                ctx.char_type << " >;";
+                "stream_extraction_plate< " << ctx.poly_plate << ", " <<
+                stream << ", " << ctx.char_type << " >;";
 
             if (import_maps)
               ctx.os << "template struct __declspec (dllimport) " <<
-                "stream_extraction_plate< 0, " << stream << ", " <<
-                ctx.char_type << " >;";
+                "stream_extraction_plate< " << ctx.poly_plate << ", " <<
+                stream << ", " << ctx.char_type << " >;";
 
             ctx.os << "#elif defined(__GNUC__) && __GNUC__ >= 4" << endl
                    << "template struct __attribute__ ((visibility(\"default\"))) " <<
-              "stream_extraction_plate< 0, " << stream << ", " <<
-              ctx.char_type << " >;"
+              "stream_extraction_plate< " << ctx.poly_plate << ", " <<
+              stream << ", " << ctx.char_type << " >;"
                    << "#elif defined(XSD_MAP_VISIBILITY)" << endl
                    << "template struct XSD_MAP_VISIBILITY " <<
-              "stream_extraction_plate< 0, " << stream << ", " <<
-              ctx.char_type << " >;"
+              "stream_extraction_plate< " << ctx.poly_plate << ", " <<
+              stream << ", " << ctx.char_type << " >;"
                    << "#endif" << endl;
           }
 
@@ -723,14 +766,16 @@ namespace CXX
         ctx.os << "namespace _xsd"
                << "{";
 
-        UnsignedLong n (0);
-        for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+        size_t n (0);
+        for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+             ++i)
         {
           String stream (*i);
 
           ctx.os << "static" << endl
-                 << "const ::xsd::cxx::tree::stream_extraction_plate< 0, " <<
-            stream << ", " << ctx.char_type << " >" << endl
+                 << "const ::xsd::cxx::tree::stream_extraction_plate< " <<
+            ctx.poly_plate << ", " << stream << ", " << ctx.char_type <<
+            " >" << endl
                  << "stream_extraction_plate_init_" << n++ << ";";
         }
 
@@ -739,7 +784,7 @@ namespace CXX
 
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names names_ns, names;
 
       Namespace ns (ctx);
diff --git a/xsd/xsd/cxx/tree/stream-extraction-source.hxx b/xsd/xsd/cxx/tree/stream-extraction-source.hxx
index 23ab17c..9104281 100644
--- a/xsd/xsd/cxx/tree/stream-extraction-source.hxx
+++ b/xsd/xsd/cxx/tree/stream-extraction-source.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/stream-extraction-source.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_EXTRACTION_SOURCE_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
+    void
     generate_stream_extraction_source (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/tree/stream-header.cxx b/xsd/xsd/cxx/tree/stream-header.cxx
index 02e2651..9ba9b3b 100644
--- a/xsd/xsd/cxx/tree/stream-header.cxx
+++ b/xsd/xsd/cxx/tree/stream-header.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/stream-header.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/stream-header.hxx>
@@ -21,7 +20,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String name (ename (l));
@@ -48,7 +47,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String name (ename (u));
@@ -75,7 +74,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String name (ename (e));
@@ -86,13 +85,13 @@ namespace CXX
           if (renamed_type (e, name) && !name)
             return;
 
-          Boolean string_based (false);
+          bool string_based (false);
           {
             IsStringBasedType t (string_based);
             t.dispatch (e);
           }
 
-          Boolean enum_based (false);
+          bool enum_based (false);
           if (string_based)
           {
             SemanticGraph::Enumeration* be (0);
@@ -129,7 +128,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           String name (ename (c));
@@ -149,7 +148,7 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_stream_header (Context& ctx)
     {
       String c (ctx.char_type);
@@ -159,7 +158,7 @@ namespace CXX
 
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names names_ns, names;
 
       Namespace ns (ctx);
diff --git a/xsd/xsd/cxx/tree/stream-header.hxx b/xsd/xsd/cxx/tree/stream-header.hxx
index 246a06e..36eea87 100644
--- a/xsd/xsd/cxx/tree/stream-header.hxx
+++ b/xsd/xsd/cxx/tree/stream-header.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/stream-header.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_STREAM_HEADER_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
+    void
     generate_stream_header (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/tree/stream-insertion-header.cxx b/xsd/xsd/cxx/tree/stream-insertion-header.cxx
index 1669fdd..e9ee438 100644
--- a/xsd/xsd/cxx/tree/stream-insertion-header.cxx
+++ b/xsd/xsd/cxx/tree/stream-insertion-header.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/stream-insertion-header.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/stream-insertion-header.hxx>
@@ -14,8 +13,6 @@ namespace CXX
   {
     namespace
     {
-      typedef Containers::Vector<NarrowString> Streams;
-
       struct List: Traversal::List, Context
       {
         List (Context& c)
@@ -23,7 +20,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String name (ename (l));
@@ -34,8 +31,9 @@ namespace CXX
           if (renamed_type (l, name) && !name)
             return;
 
-          Streams const& st (options.value<CLI::generate_insertion> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             String stream_type (ostream_type + L"< " + String (*i) + L" >");
 
@@ -56,7 +54,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String name (ename (u));
@@ -67,8 +65,9 @@ namespace CXX
           if (renamed_type (u, name) && !name)
             return;
 
-          Streams const& st (options.value<CLI::generate_insertion> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             String stream_type (ostream_type + L"< " + String (*i) + L" >");
 
@@ -89,7 +88,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String name (ename (e));
@@ -100,8 +99,9 @@ namespace CXX
           if (renamed_type (e, name) && !name)
             return;
 
-          Streams const& st (options.value<CLI::generate_insertion> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             String stream_type (ostream_type + L"< " + String (*i) + L" >");
 
@@ -121,7 +121,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           String name (ename (c));
@@ -132,8 +132,9 @@ namespace CXX
           if (renamed_type (c, name) && !name)
             return;
 
-          Streams const& st (options.value<CLI::generate_insertion> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             String stream_type (ostream_type + L"< " + String (*i) + L" >");
 
@@ -147,14 +148,14 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_stream_insertion_header (Context& ctx)
     {
       String c (ctx.char_type);
 
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names names_ns, names;
 
       Namespace ns (ctx);
diff --git a/xsd/xsd/cxx/tree/stream-insertion-header.hxx b/xsd/xsd/cxx/tree/stream-insertion-header.hxx
index ca93713..31b6328 100644
--- a/xsd/xsd/cxx/tree/stream-insertion-header.hxx
+++ b/xsd/xsd/cxx/tree/stream-insertion-header.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/stream-insertion-header.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_STREAM_INSERTION_HEADER_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
+    void
     generate_stream_insertion_header (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/tree/stream-insertion-source.cxx b/xsd/xsd/cxx/tree/stream-insertion-source.cxx
index 09faf71..2c82cfd 100644
--- a/xsd/xsd/cxx/tree/stream-insertion-source.cxx
+++ b/xsd/xsd/cxx/tree/stream-insertion-source.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/stream-insertion-source.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/stream-insertion-source.hxx>
@@ -14,8 +13,6 @@ namespace CXX
   {
     namespace
     {
-      typedef Containers::Vector<NarrowString> Streams;
-
       struct List: Traversal::List, Context
       {
         List (Context& c)
@@ -23,7 +20,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String name (ename (l));
@@ -45,9 +42,10 @@ namespace CXX
 
           base += L" >";
 
-          UnsignedLong n (0);
-          Streams const& st (options.value<CLI::generate_insertion> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          size_t n (0);
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             String stream_type ("::xsd::cxx::tree::ostream< " + *i + " >");
 
@@ -60,7 +58,9 @@ namespace CXX
 
             // Register with type map.
             //
-            if (polymorphic && polymorphic_p (l) && !anonymous_p (l))
+            if (polymorphic &&
+                polymorphic_p (l) &&
+                (!anonymous_p (l) || anonymous_substitutes_p (l)))
             {
               // Note that we are using the original type name.
               //
@@ -68,8 +68,8 @@ namespace CXX
 
               os << "static" << endl
                  << "const ::xsd::cxx::tree::stream_insertion_initializer< " <<
-                "0, " << i->c_str () << ", " <<
-                char_type << ", " << name << " >" << endl
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
                  << "_xsd_" << name << "_stream_insertion_init_" <<
                 n++ << " (" << endl
                  << strlit (l.name ()) << "," << endl
@@ -100,7 +100,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String name (ename (u));
@@ -113,9 +113,10 @@ namespace CXX
 
           String const& base (xs_string_type);
 
-          UnsignedLong n (0);
-          Streams const& st (options.value<CLI::generate_insertion> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          size_t n (0);
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             String stream_type ("::xsd::cxx::tree::ostream< " + *i + " >");
 
@@ -128,7 +129,9 @@ namespace CXX
 
             // Register with type map.
             //
-            if (polymorphic && polymorphic_p (u) && !anonymous_p (u))
+            if (polymorphic &&
+                polymorphic_p (u) &&
+                (!anonymous_p (u) || anonymous_substitutes_p (u)))
             {
               // Note that we are using the original type name.
               //
@@ -136,8 +139,8 @@ namespace CXX
 
               os << "static" << endl
                  << "const ::xsd::cxx::tree::stream_insertion_initializer< " <<
-                "0, " << i->c_str () << ", " <<
-                char_type << ", " << name << " >" << endl
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
                  << "_xsd_" << name << "_stream_insertion_init_" <<
                 n++ << " (" << endl
                  << strlit (u.name ()) << "," << endl
@@ -157,7 +160,7 @@ namespace CXX
           inherits_base_ >> base_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String name (ename (e));
@@ -168,26 +171,57 @@ namespace CXX
           if (renamed_type (e, name) && !name)
             return;
 
-          UnsignedLong n (0);
-          Streams const& st (options.value<CLI::generate_insertion> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          bool string_based (false);
+          {
+            IsStringBasedType t (string_based);
+            t.dispatch (e);
+          }
+
+          bool enum_based (false);
+          if (string_based)
+          {
+            SemanticGraph::Enumeration* base_enum (0);
+            IsEnumBasedType t (base_enum);
+            t.dispatch (e);
+
+            enum_based = (base_enum != 0);
+          }
+
+          String value;
+          if (string_based)
+            value = evalue (e);
+
+          size_t n (0);
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             String stream_type ("::xsd::cxx::tree::ostream< " + *i + " >");
 
             os << stream_type << "&" << endl
                << "operator<< (" << stream_type << "& s," << endl
                << "const " << name << "& x)"
-               << "{"
-               << "return s << static_cast< const ";
+               << "{";
 
-            inherits (e, inherits_base_);
+            if (!string_based || enum_based)
+            {
+              os << "return s << static_cast< const ";
+              inherits (e, inherits_base_);
+              os << "& > (x);";
+            }
+            else
+            {
+              os << name << "::" << value << " v (x);"
+                 << "return s << static_cast< unsigned int > (v);";
+            }
 
-            os << "& > (x);"
-               << "}";
+            os << "}";
 
             // Register with type map.
             //
-            if (polymorphic && polymorphic_p (e) && !anonymous_p (e))
+            if (polymorphic &&
+                polymorphic_p (e) &&
+                (!anonymous_p (e) || anonymous_substitutes_p (e)))
             {
               // Note that we are using the original type name.
               //
@@ -195,8 +229,8 @@ namespace CXX
 
               os << "static" << endl
                  << "const ::xsd::cxx::tree::stream_insertion_initializer< " <<
-                "0, " << i->c_str () << ", " <<
-                char_type << ", " << name << " >" << endl
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
                  << "_xsd_" << name << "_stream_insertion_init_" <<
                 n++ << " (" << endl
                  << strlit (e.name ()) << "," << endl
@@ -218,7 +252,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (skip (e)) return;
@@ -233,7 +267,7 @@ namespace CXX
           // from which makes it impossible to substitute or dynamically-
           // type with xsi:type.
           //
-          Boolean poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
 
           if (max (e) != 1)
           {
@@ -257,8 +291,9 @@ namespace CXX
                  << "if (!d)" << endl
                  << "s << *i;"
                  << "else" << endl
-                 << "::xsd::cxx::tree::stream_insertion_map_instance< 0, " <<
-                stream << ", " << char_type << " > ().insert (s, *i);";
+                 << "::xsd::cxx::tree::stream_insertion_map_instance< " <<
+                poly_plate << ", " << stream << ", " << char_type <<
+                " > ().insert (s, *i);";
             }
             else
               os << "s << *i;";
@@ -284,8 +319,9 @@ namespace CXX
                  << "if (!d)" << endl
                  << "s << i;"
                  << "else" << endl
-                 << "::xsd::cxx::tree::stream_insertion_map_instance< 0, " <<
-                stream << ", " << char_type << " > ().insert (s, i);"
+                 << "::xsd::cxx::tree::stream_insertion_map_instance< " <<
+                poly_plate << ", " << stream << ", " << char_type <<
+                " > ().insert (s, i);"
                  << "}";
             }
             else
@@ -307,8 +343,9 @@ namespace CXX
                  << "if (!d)" << endl
                  << "s << i;"
                  << "else" << endl
-                 << "::xsd::cxx::tree::stream_insertion_map_instance< 0, " <<
-                stream << ", " << char_type << " > ().insert (s, i);"
+                 << "::xsd::cxx::tree::stream_insertion_map_instance< " <<
+                poly_plate << ", " << stream << ", " << char_type <<
+                " > ().insert (s, i);"
                  << "}";
             }
             else
@@ -328,7 +365,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           String const& aname (eaname (a));
@@ -358,7 +395,7 @@ namespace CXX
           inherits_ >> base_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           String name (ename (c));
@@ -369,11 +406,12 @@ namespace CXX
           if (renamed_type (c, name) && !name)
             return;
 
-          Boolean has_body (has<Traversal::Member> (c) || c.inherits_p ());
+          bool has_body (has<Traversal::Member> (c) || c.inherits_p ());
 
-          UnsignedLong n (0);
-          Streams const& st (options.value<CLI::generate_insertion> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          size_t n (0);
+          NarrowStrings const& st (options.generate_insertion ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             String stream_type ("::xsd::cxx::tree::ostream< " + *i + " >");
 
@@ -408,7 +446,9 @@ namespace CXX
 
             // Register with type map.
             //
-            if (polymorphic && polymorphic_p (c) && !anonymous_p (c))
+            if (polymorphic &&
+                polymorphic_p (c) &&
+                (!anonymous_p (c) || anonymous_substitutes_p (c)))
             {
               // Note that we are using the original type name.
               //
@@ -416,8 +456,8 @@ namespace CXX
 
               os << "static" << endl
                  << "const ::xsd::cxx::tree::stream_insertion_initializer< " <<
-                "0, " << i->c_str () << ", " <<
-                char_type << ", " << name << " >" << endl
+                poly_plate << ", " << i->c_str () << ", " << char_type <<
+                ", " << name << " >" << endl
                  << "_xsd_" << name << "_stream_insertion_init_" <<
                 n++ << " (" << endl
                  << strlit (c.name ()) << "," << endl
@@ -433,18 +473,18 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_stream_insertion_source (Context& ctx)
     {
       if (ctx.polymorphic)
       {
-        Streams const& st (ctx.options.value<CLI::generate_insertion> ());
+        NarrowStrings const& st (ctx.options.generate_insertion ());
 
         ctx.os << "#include <xsd/cxx/tree/stream-insertion-map.hxx>" << endl
                << endl;
 
-        Boolean import_maps (ctx.options.value<CLI::import_maps> ());
-        Boolean export_maps (ctx.options.value<CLI::export_maps> ());
+        bool import_maps (ctx.options.import_maps ());
+        bool export_maps (ctx.options.export_maps ());
 
         if (import_maps || export_maps)
         {
@@ -457,7 +497,8 @@ namespace CXX
                  << "namespace tree"
                  << "{";
 
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             String stream (*i);
 
@@ -465,22 +506,22 @@ namespace CXX
 
             if (export_maps)
               ctx.os << "template struct __declspec (dllexport) " <<
-                "stream_insertion_plate< 0, " << stream << ", " <<
-                ctx.char_type << " >;";
+                "stream_insertion_plate< " << ctx.poly_plate << ", " <<
+                stream << ", " << ctx.char_type << " >;";
 
             if (import_maps)
               ctx.os << "template struct __declspec (dllimport) " <<
-                "stream_insertion_plate< 0, " << stream << ", " <<
-                ctx.char_type << " >;";
+                "stream_insertion_plate< " << ctx.poly_plate << ", " <<
+                stream << ", " << ctx.char_type << " >;";
 
             ctx.os << "#elif defined(__GNUC__) && __GNUC__ >= 4" << endl
                    << "template struct __attribute__ ((visibility(\"default\"))) " <<
-              "stream_insertion_plate< 0, " << stream << ", " <<
-              ctx.char_type << " >;"
+              "stream_insertion_plate< " << ctx.poly_plate << ", " <<
+              stream << ", " << ctx.char_type << " >;"
                    << "#elif defined(XSD_MAP_VISIBILITY)" << endl
                    << "template struct XSD_MAP_VISIBILITY " <<
-              "stream_insertion_plate< 0, " << stream << ", " <<
-              ctx.char_type << " >;"
+              "stream_insertion_plate< " << ctx.poly_plate << ", " <<
+              stream << ", " << ctx.char_type << " >;"
                    << "#endif" << endl;
           }
 
@@ -494,14 +535,16 @@ namespace CXX
         ctx.os << "namespace _xsd"
                << "{";
 
-        UnsignedLong n (0);
-        for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+        size_t n (0);
+        for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+             ++i)
         {
           String stream (*i);
 
           ctx.os << "static" << endl
-                 << "const ::xsd::cxx::tree::stream_insertion_plate< 0, " <<
-            stream << ", " << ctx.char_type << " >" << endl
+                 << "const ::xsd::cxx::tree::stream_insertion_plate< " <<
+            ctx.poly_plate << ", " << stream << ", " << ctx.char_type <<
+            " >" << endl
                  << "stream_insertion_plate_init_" << n++ << ";";
         }
 
@@ -510,7 +553,7 @@ namespace CXX
 
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names names_ns, names;
 
       Namespace ns (ctx);
diff --git a/xsd/xsd/cxx/tree/stream-insertion-source.hxx b/xsd/xsd/cxx/tree/stream-insertion-source.hxx
index b270912..d2d5534 100644
--- a/xsd/xsd/cxx/tree/stream-insertion-source.hxx
+++ b/xsd/xsd/cxx/tree/stream-insertion-source.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/stream-insertion-source.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_INSERTION_SOURCE_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
+    void
     generate_stream_insertion_source (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/tree/stream-source.cxx b/xsd/xsd/cxx/tree/stream-source.cxx
index e8a7fc4..935ad40 100644
--- a/xsd/xsd/cxx/tree/stream-source.cxx
+++ b/xsd/xsd/cxx/tree/stream-source.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/stream-source.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/stream-source.hxx>
@@ -21,7 +20,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String name (ename (l));
@@ -52,15 +51,17 @@ namespace CXX
 
           // Register with ostream map.
           //
-          if (polymorphic && polymorphic_p (l) && !anonymous_p (l))
+          if (polymorphic &&
+              polymorphic_p (l) &&
+              (!anonymous_p (l) || anonymous_substitutes_p (l)))
           {
             // Note that we are using the original type name.
             //
             String const& name (ename (l));
 
             os << "static" << endl
-               << "const ::xsd::cxx::tree::std_ostream_initializer< 0, " <<
-              char_type << ", " << name << " >" << endl
+               << "const ::xsd::cxx::tree::std_ostream_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                << "_xsd_" << name << "_std_ostream_init;"
                << endl;
           }
@@ -87,7 +88,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String name (ename (u));
@@ -107,15 +108,17 @@ namespace CXX
 
           // Register with ostream map.
           //
-          if (polymorphic && polymorphic_p (u) && !anonymous_p (u))
+          if (polymorphic &&
+              polymorphic_p (u) &&
+              (!anonymous_p (u) || anonymous_substitutes_p (u)))
           {
             // Note that we are using the original type name.
             //
             String const& name (ename (u));
 
             os << "static" << endl
-               << "const ::xsd::cxx::tree::std_ostream_initializer< 0, " <<
-              char_type << ", " << name << " >" << endl
+               << "const ::xsd::cxx::tree::std_ostream_initializer< " <<
+              poly_plate << ", " << char_type << ", " << name << " >" << endl
                << "_xsd_" << name << "_std_ostream_init;"
                << endl;
           }
@@ -131,7 +134,7 @@ namespace CXX
           inherits_base_ >> base_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String name (ename (e));
@@ -142,13 +145,13 @@ namespace CXX
           if (renamed_type (e, name) && !name)
             return;
 
-          Boolean string_based (false);
+          bool string_based (false);
           {
             IsStringBasedType t (string_based);
             t.dispatch (e);
           }
 
-          Boolean enum_based (false);
+          bool enum_based (false);
           if (string_based)
           {
             SemanticGraph::Enumeration* be (0);
@@ -185,15 +188,17 @@ namespace CXX
 
           // Register with ostream map.
           //
-          if (polymorphic && polymorphic_p (e) && !anonymous_p (e))
+          if (polymorphic &&
+              polymorphic_p (e) &&
+              (!anonymous_p (e) || anonymous_substitutes_p (e)))
           {
             // Note that we are using the original type name.
             //
             String const& name (ename (e));
 
             os << "static" << endl
-               << "const ::xsd::cxx::tree::std_ostream_initializer< 0, " <<
-              char_type << ", " << name << " >" << endl
+               << "const ::xsd::cxx::tree::std_ostream_initializer< " <<
+              poly_plate << ", " << char_type << ", " << name << " >" << endl
                << "_xsd_" << name << "_std_ostream_init;"
                << endl;
           }
@@ -211,7 +216,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (skip (e))
@@ -226,17 +231,15 @@ namespace CXX
           // dynamically-type with xsi:type.
           //
           SemanticGraph::Type& t (e.type ());
-          Boolean poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
 
-          // aCC cannot handle an inline call to std_ostream_map_instance.
-          //
           if (poly)
           {
             os << "{"
                << "::xsd::cxx::tree::std_ostream_map< " << char_type
                << " >& om (" << endl
-               << "::xsd::cxx::tree::std_ostream_map_instance< 0, " <<
-              char_type << " > ());"
+               << "::xsd::cxx::tree::std_ostream_map_instance< " <<
+              poly_plate << ", " << char_type << " > ());"
                << endl;
           }
 
@@ -304,7 +307,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           String const& aname (eaname (a));
@@ -334,7 +337,7 @@ namespace CXX
           inherits_ >> base_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           String name (ename (c));
@@ -347,7 +350,7 @@ namespace CXX
 
           //
           //
-          Boolean has_body (has<Traversal::Member> (c) || c.inherits_p ());
+          bool has_body (has<Traversal::Member> (c) || c.inherits_p ());
 
           os << std_ostream_type << "&" << endl
              << "operator<< (" << std_ostream_type << "& o, " <<
@@ -380,15 +383,17 @@ namespace CXX
 
           // Register with ostream map.
           //
-          if (polymorphic && polymorphic_p (c) && !anonymous_p (c))
+          if (polymorphic &&
+              polymorphic_p (c) &&
+              (!anonymous_p (c) || anonymous_substitutes_p (c)))
           {
             // Note that we are using the original type name.
             //
             String const& name (ename (c));
 
             os << "static" << endl
-               << "const ::xsd::cxx::tree::std_ostream_initializer< 0, " <<
-              char_type << ", " << name << " >" << endl
+               << "const ::xsd::cxx::tree::std_ostream_initializer< " <<
+              poly_plate << ", " << char_type << ", " << name << " >" << endl
                << "_xsd_" << name << "_std_ostream_init;"
                << endl;
           }
@@ -400,10 +405,8 @@ namespace CXX
       };
     }
 
-    Void
-    generate_stream_source (Context& ctx,
-                            UnsignedLong first,
-                            UnsignedLong last)
+    void
+    generate_stream_source (Context& ctx, size_t first, size_t last)
     {
       String c (ctx.char_type);
 
@@ -415,8 +418,8 @@ namespace CXX
         ctx.os << "#include <xsd/cxx/tree/std-ostream-map.hxx>" << endl
                << endl;
 
-        Boolean import_maps (ctx.options.value<CLI::import_maps> ());
-        Boolean export_maps (ctx.options.value<CLI::export_maps> ());
+        bool import_maps (ctx.options.import_maps ());
+        bool export_maps (ctx.options.export_maps ());
 
         if (import_maps || export_maps)
         {
@@ -432,19 +435,23 @@ namespace CXX
 
           if (export_maps)
             ctx.os << "template struct __declspec (dllexport) " <<
-              "std_ostream_plate< 0, " << ctx.char_type << " >;";
+              "std_ostream_plate< " << ctx.poly_plate << ", " <<
+              ctx.char_type << " >;";
 
           if (import_maps)
             ctx.os << "template struct __declspec (dllimport) " <<
-              "std_ostream_plate< 0, " << ctx.char_type << " >;";
+              "std_ostream_plate< " << ctx.poly_plate << ", " <<
+              ctx.char_type << " >;";
 
           ctx.os << "#elif defined(__GNUC__) && __GNUC__ >= 4" << endl
                  << "template struct __attribute__ ((visibility(\"default\"))) " <<
-            "std_ostream_plate< 0, " << ctx.char_type << " >;";
+            "std_ostream_plate< " << ctx.poly_plate << ", " << ctx.char_type <<
+            " >;";
 
           ctx.os << "#elif defined(XSD_MAP_VISIBILITY)" << endl
                  << "template struct XSD_MAP_VISIBILITY " <<
-            "std_ostream_plate< 0, " << ctx.char_type << " >;";
+            "std_ostream_plate< " << ctx.poly_plate << ", " << ctx.char_type <<
+            " >;";
 
           ctx.os << "#endif" << endl
                  << "}"  // tree
@@ -457,15 +464,15 @@ namespace CXX
         ctx.os << "namespace _xsd"
                << "{"
                << "static" << endl
-               << "const ::xsd::cxx::tree::std_ostream_plate< 0, " <<
-          ctx.char_type << " >" << endl
+               << "const ::xsd::cxx::tree::std_ostream_plate< " <<
+          ctx.poly_plate << ", " << ctx.char_type << " >" << endl
                << "std_ostream_plate_init;"
                << "}";
       }
 
       Traversal::Schema schema;
 
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names names_ns, names;
 
       Namespace ns (ctx, first, last);
diff --git a/xsd/xsd/cxx/tree/stream-source.hxx b/xsd/xsd/cxx/tree/stream-source.hxx
index 13e8f37..f13a23e 100644
--- a/xsd/xsd/cxx/tree/stream-source.hxx
+++ b/xsd/xsd/cxx/tree/stream-source.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/stream-source.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_STREAM_SOURCE_HXX
@@ -12,10 +11,8 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
-    generate_stream_source (Context&,
-                            UnsignedLong first,
-                            UnsignedLong last);
+    void
+    generate_stream_source (Context&, size_t first, size_t last);
   }
 }
 
diff --git a/xsd/xsd/cxx/tree/tree-forward.cxx b/xsd/xsd/cxx/tree/tree-forward.cxx
index 214cc75..5afae3c 100644
--- a/xsd/xsd/cxx/tree/tree-forward.cxx
+++ b/xsd/xsd/cxx/tree/tree-forward.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/tree-forward.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <cxx/tree/tree-forward.hxx>
@@ -22,7 +21,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String const& name (ename (l));
@@ -52,7 +51,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String const& name (ename (u));
@@ -82,7 +81,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String const& name (ename (e));
@@ -112,7 +111,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           String const& name (ename (c));
@@ -136,16 +135,16 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_forward (Context& ctx)
     {
-      NarrowString xml_schema (ctx.options.value<CLI::extern_xml_schema> ());
+      NarrowString xml_schema (ctx.options.extern_xml_schema ());
 
       // Inlcude or Emit fundamental types.
       //
       if (xml_schema)
       {
-        String name (ctx.hxx_expr->merge (xml_schema));
+        String name (ctx.hxx_expr->replace (xml_schema));
 
         ctx.os << "#include " << ctx.process_include_path (name) << endl
                << endl;
@@ -164,21 +163,21 @@ namespace CXX
                << "#include <xsd/cxx/tree/types.hxx>" << endl
                << endl;
 
-        if (!ctx.options.value<CLI::suppress_parsing> () ||
-            ctx.options.value<CLI::generate_serialization> ())
+        if (!ctx.options.suppress_parsing () ||
+            ctx.options.generate_serialization ())
         {
           ctx.os << "#include <xsd/cxx/xml/error-handler.hxx>" << endl
                  << endl;
         }
 
-        if (!ctx.options.value<CLI::suppress_parsing> () ||
-            ctx.options.value<CLI::generate_serialization> ())
+        if (!ctx.options.suppress_parsing () ||
+            ctx.options.generate_serialization ())
         {
           ctx.os << "#include <xsd/cxx/xml/dom/auto-ptr.hxx>" << endl
                  << endl;
         }
 
-        Boolean element_map (ctx.options.value<CLI::generate_element_map> ());
+        bool element_map (ctx.options.generate_element_map ());
 
         if (element_map)
           ctx.os << "#include <xsd/cxx/tree/element-map.hxx>" << endl
@@ -188,7 +187,7 @@ namespace CXX
         // later in the individual generators for each feature because
         // those headers provide implementation for the fundamental types.
         //
-        if (!ctx.options.value<CLI::suppress_parsing> ())
+        if (!ctx.options.suppress_parsing ())
         {
           ctx.os << "#include <xsd/cxx/tree/parsing.hxx>" << endl;
 
@@ -210,7 +209,7 @@ namespace CXX
           ctx.os << endl;
         }
 
-        if (ctx.options.value<CLI::generate_serialization> ())
+        if (ctx.options.generate_serialization ())
         {
           ctx.os << "#include <xsd/cxx/xml/dom/serialization-header.hxx>" << endl
                  << "#include <xsd/cxx/tree/serialization.hxx>" << endl;
@@ -233,18 +232,17 @@ namespace CXX
           ctx.os << endl;
         }
 
-        if (ctx.options.value<CLI::generate_ostream> ())
+        if (ctx.options.generate_ostream ())
         {
           ctx.os << "#include <xsd/cxx/tree/std-ostream-operators.hxx>" << endl
                  << endl;
         }
 
-        typedef Containers::Vector<NarrowString> Streams;
-
-        Streams const& ist (ctx.options.value<CLI::generate_insertion> ());
+        NarrowStrings const& ist (ctx.options.generate_insertion ());
         if (!ist.empty ())
         {
-          for (Streams::ConstIterator i (ist.begin ()); i != ist.end (); ++i)
+          for (NarrowStrings::const_iterator i (ist.begin ()); i != ist.end ();
+               ++i)
           {
             if (*i == "ACE_OutputCDR")
               ctx.os << "#include <xsd/cxx/tree/ace-cdr-stream-insertion.hxx>"
@@ -258,10 +256,11 @@ namespace CXX
                  << endl;
         }
 
-        Streams const& est (ctx.options.value<CLI::generate_extraction> ());
+        NarrowStrings const& est (ctx.options.generate_extraction ());
         if (!est.empty ())
         {
-          for (Streams::ConstIterator i (est.begin ()); i != est.end (); ++i)
+          for (NarrowStrings::const_iterator i (est.begin ()); i != est.end ();
+               ++i)
           {
             if (*i == "ACE_InputCDR")
               ctx.os << "#include <xsd/cxx/tree/ace-cdr-stream-extraction.hxx>"
@@ -288,7 +287,7 @@ namespace CXX
 
       // First emit header includes.
       //
-      if (ctx.options.value<CLI::generate_forward> ())
+      if (ctx.options.generate_forward ())
       {
         Traversal::Schema schema;
         Includes includes (ctx, Includes::forward);
@@ -302,7 +301,7 @@ namespace CXX
              << "//" << endl;
 
       Traversal::Schema schema;
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names names_ns, names;
       Namespace ns (ctx);
 
diff --git a/xsd/xsd/cxx/tree/tree-forward.hxx b/xsd/xsd/cxx/tree/tree-forward.hxx
index efe0e02..5b08a10 100644
--- a/xsd/xsd/cxx/tree/tree-forward.hxx
+++ b/xsd/xsd/cxx/tree/tree-forward.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/tree-forward.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_TREE_FORWARD_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
+    void
     generate_forward (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/tree/tree-header.cxx b/xsd/xsd/cxx/tree/tree-header.cxx
index 9b5acc6..f0c3560 100644
--- a/xsd/xsd/cxx/tree/tree-header.cxx
+++ b/xsd/xsd/cxx/tree/tree-header.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/tree-header.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <xsd-frontend/semantic-graph.hxx>
@@ -16,8 +15,6 @@ namespace CXX
   {
     namespace
     {
-      typedef Containers::Vector<NarrowString> Streams;
-
       // List mapping.
       //
       struct List: Traversal::List, Context
@@ -27,7 +24,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String name (ename (l));
@@ -142,8 +139,9 @@ namespace CXX
 
           // c-tor (istream&)
           //
-          Streams const& st (options.value<CLI::generate_extraction> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             if (doxygen)
             {
@@ -167,7 +165,7 @@ namespace CXX
                << endl;
           }
 
-          if (!options.value<CLI::suppress_parsing> ())
+          if (!options.suppress_parsing ())
           {
             // c-tor (xercesc::DOMElement)
             //
@@ -293,6 +291,22 @@ namespace CXX
              << "~" << name << " ();";
 
           os << "};";
+
+          // Comparison operators.
+          //
+          if (options.generate_comparison ())
+          {
+            os << inst_exp
+               << "bool" << endl
+               << "operator== (const " << name << "&, const " << name << "&);"
+               << endl;
+
+            os << inst_exp
+               << "bool" << endl
+               << "operator!= (const " << name << "&, const " << name << "&);"
+               << endl
+               << endl;
+          }
         }
 
       private:
@@ -318,7 +332,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String name (ename (u));
@@ -353,7 +367,7 @@ namespace CXX
              << "public:" << endl
              << endl;
 
-          if (options.value<CLI::generate_default_ctor> ())
+          if (options.generate_default_ctor ())
           {
             // c-tor ()
             //
@@ -400,8 +414,9 @@ namespace CXX
 
           // c-tor (istream&)
           //
-          Streams const& st (options.value<CLI::generate_extraction> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             if (doxygen)
             {
@@ -425,7 +440,7 @@ namespace CXX
                << endl;
           }
 
-          if (!options.value<CLI::suppress_parsing> ())
+          if (!options.suppress_parsing ())
           {
             // c-tor (xercesc::DOMElement)
             //
@@ -551,7 +566,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (doxygen && e.annotated_p ())
@@ -579,7 +594,7 @@ namespace CXX
           names_ >> enumerator_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String name (ename (e));
@@ -590,13 +605,13 @@ namespace CXX
           if (renamed_type (e, name) && !name)
             return;
 
-          Boolean string_based (false);
+          bool string_based (false);
           {
             IsStringBasedType t (string_based);
             t.dispatch (e);
           }
 
-          Boolean enum_based (false);
+          bool enum_based (false);
           SemanticGraph::Enumeration* base_enum (0);
 
           if (string_based)
@@ -614,7 +629,7 @@ namespace CXX
 
           // Get to the ultimate base and see if is a fundamental type.
           //
-          Boolean fund_based (false);
+          bool fund_based (false);
           SemanticGraph::Type& ult_base (ultimate_base (e));
           {
             IsFundamentalType t (fund_based);
@@ -623,7 +638,7 @@ namespace CXX
 
           // Count enumerators.
           //
-          UnsignedLong enum_count (0);
+          size_t enum_count (0);
 
           for (Type::NamesIterator i (e.names_begin ()), end (e.names_end ());
                i != end; ++i)
@@ -688,7 +703,7 @@ namespace CXX
 
           // default c-tor
           //
-          if (options.value<CLI::generate_default_ctor> ())
+          if (options.generate_default_ctor ())
           {
             if (doxygen)
             {
@@ -808,8 +823,9 @@ namespace CXX
 
           // c-tor (istream&)
           //
-          Streams const& st (options.value<CLI::generate_extraction> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             if (doxygen)
             {
@@ -833,7 +849,7 @@ namespace CXX
                << endl;
           }
 
-          if (!options.value<CLI::suppress_parsing> ())
+          if (!options.suppress_parsing ())
           {
             // c-tor (xercesc::DOMElement)
             //
@@ -1031,7 +1047,7 @@ namespace CXX
           os << "};";
         }
 
-        virtual Void
+        virtual void
         comma (Type&)
         {
           os << "," << endl;
@@ -1058,7 +1074,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
           if (skip (m))
@@ -1069,14 +1085,14 @@ namespace CXX
           String kind (m.is_a<SemanticGraph::Element> ()
                        ? "element" : "attribute");
 
-          Boolean fund (false);
+          bool fund (false);
           {
             IsFundamentalType t (fund);
             t.dispatch (m.type ());
           }
 
-          Boolean def_attr (m.default_p () &&
-                            m.is_a<SemanticGraph::Attribute> ());
+          bool def_attr (m.default_p () &&
+                         m.is_a<SemanticGraph::Attribute> ());
 
           if (max (m) != 1)
           {
@@ -1249,7 +1265,7 @@ namespace CXX
               }
 
               os << "void" << endl
-                 << mname << " (::std::auto_ptr< " << type << " > p);"
+                 << mname << " (" << auto_ptr << "< " << type << " > p);"
                  << endl;
             }
           }
@@ -1338,7 +1354,7 @@ namespace CXX
                 }
 
                 os << "void" << endl
-                   << mname << " (::std::auto_ptr< " << type << " > p);"
+                   << mname << " (" << auto_ptr << "< " << type << " > p);"
                    << endl;
 
               }
@@ -1362,7 +1378,7 @@ namespace CXX
                      << " */" << endl;
                 }
 
-                os << "::std::auto_ptr< " << type << " >" << endl
+                os << auto_ptr << "< " << type << " >" << endl
                    << edname (m) << " ();"
                    << endl;
               }
@@ -1373,7 +1389,7 @@ namespace CXX
           //
           if (m.default_p ())
           {
-            Boolean simple (true);
+            bool simple (true);
 
             if (m.is_a<SemanticGraph::Element> ())
             {
@@ -1383,7 +1399,7 @@ namespace CXX
 
             if (simple)
             {
-              Boolean lit (false);
+              bool lit (false);
               {
                 IsLiteralValue test (lit);
                 test.dispatch (m.type ());
@@ -1425,7 +1441,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           String const& aname (eaname (a));
@@ -1698,7 +1714,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute& a)
         {
           String const& aname (eaname (a));
@@ -1778,16 +1794,19 @@ namespace CXX
           belongs_ >> type_name_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
           if (skip (m))
             return;
 
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (m.scope ()));
+
           String const& type (etype (m));
-          Boolean el (m.is_a<SemanticGraph::Element> ());
+          bool el (m.is_a<SemanticGraph::Element> ());
 
-          Boolean def_attr (m.default_p () && !el);
+          bool def_attr (m.default_p () && !el);
 
           if (doxygen)
           {
@@ -1826,7 +1845,7 @@ namespace CXX
           else
           {
             os << "// " << comment (m.name ()) << endl
-               << "// " << endl;
+               << "//" << endl;
           }
 
           // Typedefs.
@@ -1849,7 +1868,7 @@ namespace CXX
           if (max (m) != 1)
           {
             String const& container (econtainer (m));
-            Boolean isense (options.value<CLI::generate_intellisense> ());
+            bool isense (options.generate_intellisense ());
 
             // sequence
             //
@@ -1872,7 +1891,7 @@ namespace CXX
                  << " */" << endl;
             }
 
-            // IntelliSense does not not like aliases and fully-qualified
+            // IntelliSense does not like aliases and fully-qualified
             // names here.
             //
             if (!isense)
@@ -1941,6 +1960,24 @@ namespace CXX
           os << " > " << etraits (m) << ";"
              << endl;
 
+
+          // Element id.
+          //
+          if (el && ordered_p (c))
+          {
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Element id used for capturing content " <<
+                "order." << endl
+                 << " */" << endl;
+
+            SemanticGraph::Context& ctx (m.context ());
+
+            os << "static const ::std::size_t " <<
+              ctx.get<String> ("ordered-id-name") << " = " <<
+              ctx.get<size_t> ("ordered-id") << "UL;" << endl;
+          }
+
           member_function_.traverse (m);
 
           if (doxygen)
@@ -1967,9 +2004,12 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (a.scope ()));
+
           if (doxygen)
           {
             os << "/**" << endl
@@ -1990,7 +2030,7 @@ namespace CXX
           else
           {
             os << "// " << ename (a) << endl
-               << "// " << endl;
+               << "//" << endl;
           }
 
           // Typedefs.
@@ -2060,6 +2100,23 @@ namespace CXX
               os << endl;
           }
 
+          // Wildcard id.
+          //
+          if (ordered_p (c))
+          {
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Wildcard id used for capturing content " <<
+                "order." << endl
+                 << " */" << endl;
+
+            SemanticGraph::Context& ctx (a.context ());
+
+            os << "static const ::std::size_t " <<
+              ctx.get<String> ("ordered-id-name") << " = " <<
+              ctx.get<size_t> ("ordered-id") << "UL;" << endl;
+          }
+
           any_function_.traverse (a);
 
           if (doxygen)
@@ -2069,7 +2126,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute& a)
         {
           String const& container (econtainer (a));
@@ -2095,7 +2152,7 @@ namespace CXX
           else
           {
             os << "// " << ename (a) << endl
-               << "// " << endl;
+               << "//" << endl;
           }
 
           if (doxygen)
@@ -2152,14 +2209,14 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
           if (skip (m)) return;
 
           String const& member (emember (m));
 
-          Boolean def_attr (m.default_p () &&
+          bool def_attr (m.default_p () &&
                             m.is_a<SemanticGraph::Attribute> ());
 
           if (max (m) != 1)
@@ -2186,7 +2243,7 @@ namespace CXX
           //
           if (m.default_p ())
           {
-            Boolean simple (true);
+            bool simple (true);
 
             if (m.is_a<SemanticGraph::Element> ())
             {
@@ -2196,7 +2253,7 @@ namespace CXX
 
             if (simple)
             {
-              Boolean lit (false);
+              bool lit (false);
               {
                 IsLiteralValue test (lit);
                 test.dispatch (m.type ());
@@ -2221,7 +2278,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           String const& member (emember (a));
@@ -2246,7 +2303,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute& a)
         {
           os << econtainer (a) << " " << emember (a) << ";";
@@ -2269,15 +2326,15 @@ namespace CXX
           inherits_member_ >> member_name_;
 
           names_ >> member_;
-          if (options.value<CLI::generate_wildcard> ())
+          if (options.generate_wildcard ())
             names_ >> any_;
 
           names_data_ >> data_member_;
-          if (options.value<CLI::generate_wildcard> ())
+          if (options.generate_wildcard ())
             names_data_ >> data_any_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           String name (ename (c));
@@ -2288,20 +2345,25 @@ namespace CXX
           if (renamed_type (c, name) && !name)
             return;
 
-          Boolean has_members (has<Traversal::Member> (c));
+          SemanticGraph::Context& ctx (c.context ());
+
+          bool has_members (has<Traversal::Member> (c));
 
-          Boolean hae (has<Traversal::Any> (c));
-          Boolean haa (has<Traversal::AnyAttribute> (c));
+          bool hae (has<Traversal::Any> (c));
+          bool haa (has<Traversal::AnyAttribute> (c));
 
-          Boolean gen_wildcard (options.value<CLI::generate_wildcard> ());
+          bool gen_wildcard (options.generate_wildcard ());
 
-          Boolean simple (true);
+          bool mixed (mixed_p (c) && !ctx.count ("mixed-in-base"));
+          bool ordered (ordered_p (c) && !ctx.count ("order-in-base"));
+
+          bool simple (true);
           {
             IsSimpleType t (simple);
             t.dispatch (c);
           }
 
-          Boolean string_based (false);
+          bool string_based (false);
           {
             IsStringBasedType t (string_based);
             t.dispatch (c);
@@ -2344,17 +2406,148 @@ namespace CXX
           //
           names (c, names_);
 
-          // dom_document accessors.
+          // Mixed content.
           //
-          if (edom_document_member_p (c))
+          if (mixed)
           {
+            String const& type (ctx.get<String> ("mixed-type"));
+            String const& cont (ctx.get<String> ("mixed-container"));
+            String const& iter (ctx.get<String> ("mixed-iterator"));
+            String const& citer (ctx.get<String> ("mixed-const-iterator"));
 
-            if (!doxygen)
-            {
-              os << "// DOMDocument for wildcard content." << endl
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @name " << comment ("text_content") << endl
+                 << " *" << endl
+                 << " * @brief Accessor and modifier functions for text " <<
+                "content." << endl
+                 << " */" << endl
+                 << "//@{" << endl;
+            else
+              os << "// text_content" << endl
                  << "//" << endl;
-            }
 
+            // Typedefs.
+            //
+            bool isense (options.generate_intellisense ());
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Text content type." << endl
+                 << " */" << endl;
+
+            os << "typedef " << xs_string_type << " " << type << ";";
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Text content sequence container type." << endl
+                 << " */" << endl;
+
+            os << "typedef ::xsd::cxx::tree::sequence< " << type <<
+              " > " << cont << ";";
+
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Text content iterator type." << endl
+                 << " */" << endl;
+
+            // IntelliSense does not like aliases and fully-qualified
+            // names here.
+            //
+            if (!isense)
+              os << "typedef " << cont << "::iterator " << iter<< ";";
+            else
+              os << "typedef ::xsd::cxx::tree::sequence< " << type <<
+                " >::iterator " << iter << ";";
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Text content constant iterator type." << endl
+                 << " */" << endl;
+
+            if (!isense)
+              os << "typedef " << cont << "::const_iterator " << citer<< ";";
+            else
+              os << "typedef ::xsd::cxx::tree::sequence< " << type <<
+                " >::const_iterator " << citer << ";";
+
+            os << endl;
+
+            // Content id.
+            //
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Text content id used for capturing content " <<
+                "order." << endl
+                 << " */" << endl;
+
+            os << "static const ::std::size_t " <<
+              ctx.get<String> ("mixed-ordered-id-name") << " = " <<
+              ctx.get<size_t> ("mixed-ordered-id") << "UL;" << endl;
+
+            // Accessors and modifiers.
+            //
+            String const& aname (ctx.get<String> ("mixed-aname"));
+            String const& mname (ctx.get<String> ("mixed-mname"));
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Return a read-only (constant) reference " <<
+                "to the text" << endl
+                 << " * content sequence." << endl
+                 << " *" << endl
+                 << " * @return A constant reference to the sequence " <<
+                "container." << endl
+                 << " */" << endl;
+
+            os << "const " << cont << "&" << endl
+               << aname << " () const;"
+               << endl;
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Return a read-write reference to the " <<
+                "text content" << endl
+                 << " * sequence." << endl
+                 << " *" << endl
+                 << " * @return A reference to the sequence container." << endl
+                 << " */" << endl;
+
+            os << cont << "&" << endl
+               << aname << " ();"
+               << endl;
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Copy elements from a given sequence." << endl
+                 << " *" << endl
+                 << " * @param s A sequence to copy entries from." << endl
+                 << " *" << endl
+                 << " * For each element in @a s this function " <<
+                "add it to the sequence." << endl
+                 << " * Note that this operation " <<
+                "completely changes the sequence and" << endl
+                 << " * all old elements will be lost." << endl
+                 << " */" << endl;
+
+            os << "void" << endl
+               << mname << " (const " << cont << "& s);"
+               << endl;
+
+            if (doxygen)
+              os << "//@}" << endl
+                 << endl;
+          }
+
+          // dom_document accessors.
+          //
+          if (edom_document_member_p (c))
+          {
             if (doxygen)
             {
               os << "/**" << endl
@@ -2369,6 +2562,9 @@ namespace CXX
                  << " * the raw XML content corresponding to wildcards." << endl
                  << " */" << endl;
             }
+            else
+              os << "// DOMDocument for wildcard content." << endl
+                 << "//" << endl;
 
             os << "const " << xerces_ns << "::DOMDocument&" << endl
                << edom_document (c) << " () const;"
@@ -2393,6 +2589,137 @@ namespace CXX
                << endl;
           }
 
+          // Order container.
+          //
+          if (ordered)
+          {
+            String const& type (ctx.get<String> ("order-type"));
+            String const& cont (ctx.get<String> ("order-container"));
+            String const& iter (ctx.get<String> ("order-iterator"));
+            String const& citer (ctx.get<String> ("order-const-iterator"));
+
+            String const ct (options.order_container_specified ()
+                             ? options.order_container ()
+                             : "::std::vector");
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @name " << comment ("content_order") << endl
+                 << " *" << endl
+                 << " * @brief Accessor and modifier functions for content " <<
+                "order." << endl
+                 << " */" << endl
+                 << "//@{" << endl;
+            else
+              os << "// content_order" << endl
+                 << "//" << endl;
+
+            // Typedefs.
+            //
+            bool isense (options.generate_intellisense ());
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Content order entry type." << endl
+                 << " */" << endl;
+
+            os << "typedef " << ns_name (xs_ns ()) << "::" <<
+              xs_ns ().context ().get<String> ("content-order") << " " <<
+              type << ";";
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Content order sequence container type." << endl
+                 << " */" << endl;
+
+            os << "typedef " << ct << "< " << type << " > " << cont << ";";
+
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Content order iterator type." << endl
+                 << " */" << endl;
+
+            // IntelliSense does not like aliases and fully-qualified
+            // names here.
+            //
+            if (!isense)
+              os << "typedef " << cont << "::iterator " << iter<< ";";
+            else
+              os << "typedef " << ct << "< " << type << " >::iterator " <<
+                iter << ";";
+
+            if (doxygen)
+              os << endl
+                 << "/**" << endl
+                 << " * @brief Content order constant iterator type." << endl
+                 << " */" << endl;
+
+            if (!isense)
+              os << "typedef " << cont << "::const_iterator " << citer<< ";";
+            else
+              os << "typedef " <<  ct << "< " << type <<
+                " >::const_iterator " << citer << ";";
+
+            os << endl;
+
+            // Accessors and modifiers.
+            //
+            String const& aname (ctx.get<String> ("order-aname"));
+            String const& mname (ctx.get<String> ("order-mname"));
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Return a read-only (constant) reference " <<
+                "to the content" << endl
+                 << " * order sequence." << endl
+                 << " *" << endl
+                 << " * @return A constant reference to the sequence " <<
+                "container." << endl
+                 << " */" << endl;
+
+            os << "const " << cont << "&" << endl
+               << aname << " () const;"
+               << endl;
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Return a read-write reference to the " <<
+                "content order" << endl
+                 << " * sequence." << endl
+                 << " *" << endl
+                 << " * @return A reference to the sequence container." << endl
+                 << " */" << endl;
+
+            os << cont << "&" << endl
+               << aname << " ();"
+               << endl;
+
+            if (doxygen)
+              os << "/**" << endl
+                 << " * @brief Copy elements from a given sequence." << endl
+                 << " *" << endl
+                 << " * @param s A sequence to copy entries from." << endl
+                 << " *" << endl
+                 << " * For each element in @a s this function " <<
+                "add it to the sequence." << endl
+                 << " * Note that this operation " <<
+                "completely changes the sequence and" << endl
+                 << " * all old elements will be lost." << endl
+                 << " */" << endl;
+
+            os << "void" << endl
+               << mname << " (const " << cont << "& s);"
+               << endl;
+
+            if (doxygen)
+              os << "//@}" << endl
+                 << endl;
+          }
+
           if (doxygen)
           {
             os << "/**" << endl
@@ -2407,15 +2734,15 @@ namespace CXX
                << "//" << endl;
           }
 
-          Boolean generate_no_base_ctor (false);
+          bool generate_no_base_ctor (false);
           {
             GenerateWithoutBaseCtor t (generate_no_base_ctor);
             t.traverse (c);
           }
 
-          Boolean has_complex_non_op_args (false);
-          Boolean has_poly_non_op_args (false);
-          Boolean complex_poly_args_clash (true);
+          bool has_complex_non_op_args (false);
+          bool has_poly_non_op_args (false);
+          bool complex_poly_args_clash (true);
           {
             HasComplexPolyNonOptArgs t (*this, true,
                                         has_complex_non_op_args,
@@ -2426,7 +2753,7 @@ namespace CXX
 
           // default c-tor
           //
-          if (options.value<CLI::generate_default_ctor> ())
+          if (options.generate_default_ctor ())
           {
             // c-tor (ultimate-base, all-non-optional-members) will become
             // default c-tor if our inheritance hierarchy has no required
@@ -2434,7 +2761,7 @@ namespace CXX
             // c-tor (all-non-optional-members) if we have no required
             // members.
             //
-            Boolean generate (false);
+            bool generate (false);
             {
               GenerateDefaultCtor t (*this, generate, generate_no_base_ctor);
               t.traverse (c);
@@ -2460,7 +2787,7 @@ namespace CXX
 
           // c-tor (base, all-non-optional-members)
           //
-          if (options.value<CLI::generate_from_base_ctor> ())
+          if (options.generate_from_base_ctor ())
           {
             // c-tor (base, all-non-optional-members) will be equivalent to
             // c-tor (ultimate-base, all-non-optional-members) unless our
@@ -2470,7 +2797,7 @@ namespace CXX
             // customized version may not necessarily be convertible to
             // the base without loss of information.
             //
-            Boolean generate (false);
+            bool generate (false);
             {
               GenerateFromBaseCtor t (*this, generate);
               t.traverse (c);
@@ -2478,9 +2805,9 @@ namespace CXX
 
             if (generate)
             {
-              Boolean has_complex_non_op_args (false);
-              Boolean has_poly_non_op_args (false);
-              Boolean complex_poly_args_clash (true);
+              bool has_complex_non_op_args (false);
+              bool has_poly_non_op_args (false);
+              bool complex_poly_args_clash (true);
               {
                 HasComplexPolyNonOptArgs t (*this, false,
                                             has_complex_non_op_args,
@@ -2505,7 +2832,7 @@ namespace CXX
               inherits (c, inherits_member_);
               os << "&";
               {
-                FromBaseCtorArg args (*this, FromBaseCtorArg::arg_type, false);
+                FromBaseCtorArg args (*this, CtorArgType::type, false);
                 Traversal::Names args_names (args);
                 names (c, args_names);
               }
@@ -2524,7 +2851,7 @@ namespace CXX
                     "base and" << endl
                      << " * initializers for required elements and "
                      << "attributes" << endl
-                     << " * (auto_ptr version)." << endl
+                     << " * (" << auto_ptr << " version)." << endl
                      << " *" << endl
                      << " * This constructor will try to use the passed " <<
                     "values directly" << endl
@@ -2537,7 +2864,7 @@ namespace CXX
                 os << "&";
                 {
                   FromBaseCtorArg args (
-                    *this, FromBaseCtorArg::arg_complex_auto_ptr, false);
+                    *this, CtorArgType::complex_auto_ptr, false);
                   Traversal::Names args_names (args);
                   names (c, args_names);
                 }
@@ -2558,7 +2885,7 @@ namespace CXX
                     "base and" << endl
                      << " * initializers for required elements and "
                      << "attributes" << endl
-                     << " * (auto_ptr version)." << endl
+                     << " * (" << auto_ptr << " version)." << endl
                      << " *" << endl
                      << " * This constructor will try to use the passed " <<
                     "values directly" << endl
@@ -2571,7 +2898,7 @@ namespace CXX
                 os << "&";
                 {
                   FromBaseCtorArg args (
-                    *this, FromBaseCtorArg::arg_poly_auto_ptr, false);
+                    *this, CtorArgType::poly_auto_ptr, false);
                   Traversal::Names args_names (args);
                   names (c, args_names);
                 }
@@ -2597,7 +2924,7 @@ namespace CXX
             os << name << " (";
             {
               CtorArgsWithoutBase ctor_args (
-                *this, CtorArgsWithoutBase::arg_type, false, true);
+                *this, CtorArgType::type, false, true);
               ctor_args.dispatch (c);
             }
             os << ");"
@@ -2615,7 +2942,8 @@ namespace CXX
                 os << "/**" << endl
                    << " * @brief Create an instance from initializers " <<
                   "for required " << endl
-                   << " * elements and attributes (auto_ptr version)." << endl
+                   << " * elements and attributes (" << auto_ptr <<
+                  " version)." << endl
                    << " *" << endl
                    << " * This constructor will try to use the passed " <<
                   "values directly" << endl
@@ -2626,7 +2954,7 @@ namespace CXX
               os << name << " (";
               {
                 CtorArgsWithoutBase ctor_args (
-                  *this, CtorArgsWithoutBase::arg_complex_auto_ptr, false, true);
+                  *this, CtorArgType::complex_auto_ptr, false, true);
                 ctor_args.dispatch (c);
               }
               os << ");"
@@ -2644,7 +2972,8 @@ namespace CXX
                 os << "/**" << endl
                    << " * @brief Create an instance from initializers " <<
                   "for required " << endl
-                   << " * elements and attributes (auto_ptr version)." << endl
+                   << " * elements and attributes (" << auto_ptr <<
+                  " version)." << endl
                    << " *" << endl
                    << " * This constructor will try to use the passed " <<
                   "values directly" << endl
@@ -2655,7 +2984,7 @@ namespace CXX
               os << name << " (";
               {
                 CtorArgsWithoutBase ctor_args (
-                  *this, CtorArgsWithoutBase::arg_poly_auto_ptr, false, true);
+                  *this, CtorArgType::poly_auto_ptr, false, true);
                 ctor_args.dispatch (c);
               }
               os << ");"
@@ -2686,7 +3015,7 @@ namespace CXX
 
               {
                 CtorArgsWithoutBase ctor_args (
-                  *this, CtorArgsWithoutBase::arg_type, false, false);
+                  *this, CtorArgType::type, false, false);
                 ctor_args.dispatch (c);
               }
 
@@ -2709,7 +3038,7 @@ namespace CXX
 
             {
               CtorArgsWithoutBase ctor_args (
-                *this, CtorArgsWithoutBase::arg_type, false, false);
+                *this, CtorArgType::type, false, false);
               ctor_args.dispatch (c);
             }
 
@@ -2731,7 +3060,7 @@ namespace CXX
 
             {
               CtorArgsWithoutBase ctor_args (
-                *this, CtorArgsWithoutBase::arg_type, false, false);
+                *this, CtorArgType::type, false, false);
               ctor_args.dispatch (c);
             }
 
@@ -2755,7 +3084,7 @@ namespace CXX
           os << name << " (";
 
           {
-            CtorArgs ctor_args (*this, CtorArgs::arg_type);
+            CtorArgs ctor_args (*this, CtorArgType::type);
             ctor_args.dispatch (c);
           }
 
@@ -2774,7 +3103,7 @@ namespace CXX
                 "base and" << endl
                  << " * initializers for required elements and " <<
                 "attributes" << endl
-                 << " * (auto_ptr version)." << endl
+                 << " * (" << auto_ptr << " version)." << endl
                  << " *" << endl
                  << " * This constructor will try to use the passed " <<
                 "values directly" << endl
@@ -2785,7 +3114,7 @@ namespace CXX
             os << name << " (";
 
             {
-              CtorArgs ctor_args (*this, CtorArgs::arg_complex_auto_ptr);
+              CtorArgs ctor_args (*this, CtorArgType::complex_auto_ptr);
               ctor_args.dispatch (c);
             }
 
@@ -2805,7 +3134,7 @@ namespace CXX
                 "base and" << endl
                  << " * initializers for required elements and " <<
                 "attributes" << endl
-                 << " * (auto_ptr version)." << endl
+                 << " * (" << auto_ptr << " version)." << endl
                  << " *" << endl
                  << " * This constructor will try to use the passed " <<
                 "values directly" << endl
@@ -2816,7 +3145,7 @@ namespace CXX
             os << name << " (";
 
             {
-              CtorArgs ctor_args (*this, CtorArgs::arg_poly_auto_ptr);
+              CtorArgs ctor_args (*this, CtorArgType::poly_auto_ptr);
               ctor_args.dispatch (c);
             }
 
@@ -2826,8 +3155,9 @@ namespace CXX
 
           // c-tor (istream&)
           //
-          Streams const& st (options.value<CLI::generate_extraction> ());
-          for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+          NarrowStrings const& st (options.generate_extraction ());
+          for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+               ++i)
           {
             if (doxygen)
             {
@@ -2852,7 +3182,7 @@ namespace CXX
           }
 
 
-          if (!options.value<CLI::suppress_parsing> ())
+          if (!options.suppress_parsing ())
           {
             // c-tor (xercesc::DOMElement)
             //
@@ -2969,12 +3299,61 @@ namespace CXX
              << container << "* c = 0) const;"
              << endl;
 
+          // operator=
+          //
+          bool priv (false);
+
+          if (!simple)
+          {
+            if (options.suppress_assignment ())
+            {
+              priv = true;
+              os << "private:" << endl;
+
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Disabled copy assignment operator." << endl
+                   << " *" << endl
+                   << " * @param x An instance to make a copy of." << endl
+                   << " * @return A reference to itself." << endl
+                   << " */" << endl;
+              }
+
+              os << name << "&" << endl
+                 << "operator= (const " << name << "& x);"
+                 << endl;
+            }
+            else if (has_members || (gen_wildcard && (hae || haa)))
+            {
+              if (doxygen)
+              {
+                os << "/**" << endl
+                   << " * @brief Copy assignment operator." << endl
+                   << " *" << endl
+                   << " * @param x An instance to make a copy of." << endl
+                   << " * @return A reference to itself." << endl
+                   << " *" << endl
+                   << " * For polymorphic object models use the @c _clone " <<
+                  "function instead." << endl
+                   << " */" << endl;
+              }
+
+              os << name << "&" << endl
+                 << "operator= (const " << name << "& x);"
+                 << endl;
+            }
+          }
+
           if (doxygen)
           {
             os << "//@}" << endl
                << endl;
           }
 
+          if (priv)
+            os << "public:" << endl;
+
           // d-tor
           //
           if (doxygen)
@@ -2990,7 +3369,7 @@ namespace CXX
 
           // Data members and implementation functions.
           //
-          if (has_members || hae || (haa && gen_wildcard))
+          if (has_members || hae || (haa && gen_wildcard) || ordered || mixed)
           {
             os << "// Implementation." << endl
                << "//" << endl;
@@ -3000,9 +3379,10 @@ namespace CXX
                  << "//@cond" << endl
                  << endl;
 
-            if (!options.value<CLI::suppress_parsing> ())
+            if (!options.suppress_parsing () &&
+                (has_members || hae || (haa && gen_wildcard) || mixed))
             {
-              // parse (xercesc::DOMElement)
+              // parse ()
               //
               os << "protected:" << endl
                  << "void" << endl
@@ -3019,7 +3399,8 @@ namespace CXX
             //
             if (has_members)
             {
-              for (Streams::ConstIterator i (st.begin ()); i != st.end (); ++i)
+              for (NarrowStrings::const_iterator i (st.begin ()); i != st.end ();
+                   ++i)
               {
                 os << "void" << endl
                    << unclash (name, "parse") << " (" <<
@@ -3029,7 +3410,7 @@ namespace CXX
               }
             }
 
-            //
+            // DOM document.
             //
             if (edom_document_member_p (c))
             {
@@ -3038,6 +3419,24 @@ namespace CXX
                  << endl;
             }
 
+            // Mixed text content.
+            //
+            if (mixed)
+            {
+              os << ctx.get<String> ("mixed-container") << " " <<
+                ctx.get<String> ("mixed-member") << ";"
+                 << endl;
+            }
+
+            // Order container.
+            //
+            if (ordered)
+            {
+              os << ctx.get<String> ("order-container") << " " <<
+                ctx.get<String> ("order-member") << ";"
+                 << endl;
+            }
+
             //
             //
             names (c, names_data_);
@@ -3051,7 +3450,7 @@ namespace CXX
 
           // Comparison operators.
           //
-          if (options.value<CLI::generate_comparison> () &&
+          if (options.generate_comparison () &&
               (has_members || !c.inherits_p () ||
                ((hae || haa) && gen_wildcard)))
           {
@@ -3095,7 +3494,7 @@ namespace CXX
           belongs_ >> type_name_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (!doc_root_p (e))
@@ -3103,13 +3502,13 @@ namespace CXX
 
           SemanticGraph::Type& t (e.type ());
 
-          Boolean fund (false);
+          bool fund (false);
           {
             IsFundamentalType test (fund);
             test.dispatch (t);
           }
 
-          Boolean simple (true);
+          bool simple (true);
           if (!fund)
           {
             IsSimpleType test (simple);
@@ -3274,7 +3673,7 @@ namespace CXX
             }
 
             os << "void" << endl
-               << mname << " (::std::auto_ptr< " << type << " > p);"
+               << mname << " (" << auto_ptr << "< " << type << " > p);"
                << endl;
           }
 
@@ -3296,7 +3695,7 @@ namespace CXX
                  << " */" << endl;
             }
 
-            os << "::std::auto_ptr< " << type << " >" << endl
+            os << auto_ptr << "< " << type << " >" << endl
                << edname (e) << " ();"
                << endl;
           }
@@ -3357,7 +3756,7 @@ namespace CXX
 
           // default c-tor
           //
-          if (options.value<CLI::generate_default_ctor> ())
+          if (options.generate_default_ctor ())
           {
             if (doxygen)
             {
@@ -3403,7 +3802,8 @@ namespace CXX
               os << "/**" << endl
                  << " * @brief Create an instance from an initializer " <<
                 "for" << endl
-                 << " * the element value (auto_ptr version)." << endl
+                 << " * the element value (" << auto_ptr <<
+                " version)." << endl
                  << " *" << endl
                  << " * @param p Element value to use." << endl
                  << " *" << endl
@@ -3413,11 +3813,11 @@ namespace CXX
                  << " */" << endl;
             }
 
-            os << name << " (::std::auto_ptr< " << type << " > p);"
+            os << name << " (" << auto_ptr << "< " << type << " > p);"
                << endl;
           }
 
-          if (!options.value<CLI::suppress_parsing> ())
+          if (!options.suppress_parsing ())
           {
             // c-tor (xercesc::DOMElement)
             //
@@ -3608,7 +4008,7 @@ namespace CXX
       };
     }
 
-    Void
+    void
     generate_tree_header (Context& ctx)
     {
       if (ctx.generate_xml_schema)
@@ -3625,21 +4025,21 @@ namespace CXX
                << "#include <xsd/cxx/tree/types.hxx>" << endl
                << endl;
 
-        if (!ctx.options.value<CLI::suppress_parsing> () ||
-            ctx.options.value<CLI::generate_serialization> ())
+        if (!ctx.options.suppress_parsing () ||
+            ctx.options.generate_serialization ())
         {
           ctx.os << "#include <xsd/cxx/xml/error-handler.hxx>" << endl
                  << endl;
         }
 
-        if (!ctx.options.value<CLI::suppress_parsing> () ||
-            ctx.options.value<CLI::generate_serialization> ())
+        if (!ctx.options.suppress_parsing () ||
+            ctx.options.generate_serialization ())
         {
           ctx.os << "#include <xsd/cxx/xml/dom/auto-ptr.hxx>" << endl
                  << endl;
         }
 
-        Boolean element_map (ctx.options.value<CLI::generate_element_map> ());
+        bool element_map (ctx.options.generate_element_map ());
 
         if (element_map)
           ctx.os << "#include <xsd/cxx/tree/element-map.hxx>" << endl
@@ -3649,7 +4049,7 @@ namespace CXX
         // later in the individual generators for each feature because
         // those headers provide implementation for the fundamental types.
         //
-        if (!ctx.options.value<CLI::suppress_parsing> ())
+        if (!ctx.options.suppress_parsing ())
         {
           ctx.os << "#include <xsd/cxx/tree/parsing.hxx>" << endl;
 
@@ -3670,7 +4070,7 @@ namespace CXX
           ctx.os << endl;
         }
 
-        if (ctx.options.value<CLI::generate_serialization> ())
+        if (ctx.options.generate_serialization ())
         {
           ctx.os << "#include <xsd/cxx/xml/dom/serialization-header.hxx>" << endl
                  << "#include <xsd/cxx/tree/serialization.hxx>" << endl;
@@ -3692,16 +4092,17 @@ namespace CXX
           ctx.os << endl;
         }
 
-        if (ctx.options.value<CLI::generate_ostream> ())
+        if (ctx.options.generate_ostream ())
         {
           ctx.os << "#include <xsd/cxx/tree/std-ostream-operators.hxx>" << endl
                  << endl;
         }
 
-        Streams const& ist (ctx.options.value<CLI::generate_insertion> ());
+        NarrowStrings const& ist (ctx.options.generate_insertion ());
         if (!ist.empty ())
         {
-          for (Streams::ConstIterator i (ist.begin ()); i != ist.end (); ++i)
+          for (NarrowStrings::const_iterator i (ist.begin ()); i != ist.end ();
+               ++i)
           {
             if (*i == "ACE_OutputCDR")
               ctx.os << "#include <xsd/cxx/tree/ace-cdr-stream-insertion.hxx>"
@@ -3715,10 +4116,11 @@ namespace CXX
                  << endl;
         }
 
-        Streams const& est (ctx.options.value<CLI::generate_extraction> ());
+        NarrowStrings const& est (ctx.options.generate_extraction ());
         if (!est.empty ())
         {
-          for (Streams::ConstIterator i (est.begin ()); i != est.end (); ++i)
+          for (NarrowStrings::const_iterator i (est.begin ()); i != est.end ();
+               ++i)
           {
             if (*i == "ACE_InputCDR")
               ctx.os << "#include <xsd/cxx/tree/ace-cdr-stream-extraction.hxx>"
@@ -3746,12 +4148,25 @@ namespace CXX
       }
       else
       {
-        Boolean inline_ (ctx.options.value<CLI::generate_inline> ());
+        bool inline_ (ctx.options.generate_inline ());
 
-        ctx.os << "#include <memory>    // std::auto_ptr" << endl
+        ctx.os << "#include <memory>    // " << ctx.auto_ptr << endl
                << "#include <limits>    // std::numeric_limits" << endl
-               << "#include <algorithm> // std::binary_search" << endl
-               << endl;
+               << "#include <algorithm> // std::binary_search" << endl;
+
+        if (ctx.std >= cxx_version::cxx11)
+          ctx.os << "#include <utility>   // std::move" << endl;
+
+        if (!ctx.options.ordered_type ().empty () ||
+            ctx.options.ordered_type_all ())
+        {
+          ctx.os << "#include <cstddef>   // std::size_t" << endl;
+
+          if (!ctx.options.order_container_specified ())
+            ctx.os << "#include <vector>" << endl;
+        }
+
+        ctx.os << endl;
 
         if (ctx.char_type == L"char" && ctx.char_encoding != L"custom")
         {
@@ -3766,23 +4181,23 @@ namespace CXX
                << "#include <xsd/cxx/tree/list.hxx>" << endl
                << endl;
 
-        if (!ctx.options.value<CLI::suppress_parsing> ())
+        if (!ctx.options.suppress_parsing ())
         {
           ctx.os << "#include <xsd/cxx/xml/dom/parsing-header.hxx>" << endl
                  << endl;
         }
 
-        if (ctx.options.value<CLI::generate_wildcard> ())
+        if (ctx.options.generate_wildcard ())
         {
-          if (ctx.options.value<CLI::suppress_parsing> () ||
-              !ctx.options.value<CLI::generate_serialization> ())
+          if (ctx.options.suppress_parsing () ||
+              !ctx.options.generate_serialization ())
             ctx.os << "#include <xsd/cxx/xml/dom/auto-ptr.hxx>" << endl;
 
           ctx.os << "#include <xsd/cxx/tree/containers-wildcard.hxx>" << endl
                  << endl;
         }
 
-        if (!ctx.options.value<CLI::generate_extraction> ().empty ())
+        if (!ctx.options.generate_extraction ().empty ())
           ctx.os << "#include <xsd/cxx/tree/istream-fwd.hxx>" << endl
                  << endl;
 
@@ -3820,7 +4235,7 @@ namespace CXX
         {
           Traversal::Schema schema;
 
-          Traversal::Sources sources;
+          Sources sources;
           Traversal::Names names_ns, names;
 
           DocumentedNamespace ns (ctx);
@@ -3839,7 +4254,7 @@ namespace CXX
           names >> complex;
           names >> enumeration;
 
-          if (ctx.options.value<CLI::generate_element_type> ())
+          if (ctx.options.generate_element_type ())
             names >> element;
 
           schema.dispatch (ctx.schema_root);
diff --git a/xsd/xsd/cxx/tree/tree-header.hxx b/xsd/xsd/cxx/tree/tree-header.hxx
index bb3b417..7c97364 100644
--- a/xsd/xsd/cxx/tree/tree-header.hxx
+++ b/xsd/xsd/cxx/tree/tree-header.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/tree-header.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_TREE_HEADER_HXX
@@ -12,7 +11,7 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
+    void
     generate_tree_header (Context&);
   }
 }
diff --git a/xsd/xsd/cxx/tree/tree-inline.cxx b/xsd/xsd/cxx/tree/tree-inline.cxx
index 5bf309b..500ee73 100644
--- a/xsd/xsd/cxx/tree/tree-inline.cxx
+++ b/xsd/xsd/cxx/tree/tree-inline.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/tree-inline.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <xsd-frontend/semantic-graph.hxx>
@@ -22,7 +21,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String name (ename (l));
@@ -54,7 +53,7 @@ namespace CXX
           os << inl
              << name << "::" << endl
              << name << " ()" << endl
-             << ": " << base_type << " ( " << flags_type << " (0), this)"
+             << ": " << base_type << " (this)"
              << "{"
              << "}";
 
@@ -83,6 +82,28 @@ namespace CXX
              << "  " << base_type << " (o, f, this)"
              << "{"
              << "}";
+
+          // Comparison operators.
+          //
+          if (options.generate_comparison ())
+          {
+            os << inl
+               << "bool" << endl
+               << "operator== (const " << name << "& x, " <<
+              "const " << name << "& y)"
+               << "{"
+               << "const " << base_type << "& bx (x);"
+               << "return bx == y;"
+               << "}";
+
+            os << inl
+               << "bool" << endl
+               << "operator!= (const " << name << "& x, " <<
+              "const " << name << "& y)"
+               << "{"
+               << "return !(x == y);"
+               << "}";
+          }
         }
 
       private:
@@ -106,7 +127,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String name (ename (u));
@@ -123,7 +144,7 @@ namespace CXX
              << "//" << endl
              << endl;
 
-          if (options.value<CLI::generate_default_ctor> ())
+          if (options.generate_default_ctor ())
           {
             // c-tor ()
             //
@@ -182,7 +203,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           // This type should be ultimately string based.
@@ -196,7 +217,7 @@ namespace CXX
           os << ")";
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Type& t)
         {
           base_type_name_.dispatch (t);
@@ -217,7 +238,7 @@ namespace CXX
           inherits_member_ >> member_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String name (ename (e));
@@ -228,13 +249,13 @@ namespace CXX
           if (renamed_type (e, name) && !name)
             return;
 
-          Boolean string_based (false);
+          bool string_based (false);
           {
             IsStringBasedType t (string_based);
             t.dispatch (e);
           }
 
-          Boolean enum_based (false);
+          bool enum_based (false);
           if (string_based)
           {
             SemanticGraph::Enumeration* be (0);
@@ -250,7 +271,7 @@ namespace CXX
 
           // Get to the ultimate base and see if is a fundamental type.
           //
-          Boolean fund_based (false);
+          bool fund_based (false);
           SemanticGraph::Type& ult_base (ultimate_base (e));
           {
             IsFundamentalType t (fund_based);
@@ -276,7 +297,7 @@ namespace CXX
 
           // default c-tor
           //
-          if (options.value<CLI::generate_default_ctor> ())
+          if (options.generate_default_ctor ())
           {
             os << inl
                << name << "::" <<  endl
@@ -427,7 +448,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
           if (skip (m))
@@ -437,13 +458,13 @@ namespace CXX
           String const& mname (emname (m));
           String const& member (emember (m));
 
-          Boolean fund (false);
+          bool fund (false);
           {
             IsFundamentalType t (fund);
             t.dispatch (m.type ());
           }
 
-          Boolean def_attr (m.default_p () &&
+          bool def_attr (m.default_p () &&
                             m.is_a<SemanticGraph::Attribute> ());
 
           if (max (m) != 1)
@@ -537,9 +558,10 @@ namespace CXX
             if (!fund)
               os << inl
                  << "void " << scope_ << "::" << endl
-                 << mname << " (::std::auto_ptr< " << type << " > x)"
+                 << mname << " (" << auto_ptr << "< " << type << " > x)"
                  << "{"
-                 << "this->" << member << ".set (x);"
+                 << "this->" << member << ".set (" <<
+                (std >= cxx_version::cxx11 ? "std::move (x)" : "x") << ");"
                  << "}";
           }
           else
@@ -589,9 +611,10 @@ namespace CXX
               if (!fund)
                 os << inl
                    << "void " << scope_ << "::" << endl
-                   << mname << " (::std::auto_ptr< " << type << " > x)"
+                   << mname << " (" << auto_ptr << "< " << type << " > x)"
                    << "{"
-                   << "this->" << member << ".set (x);"
+                   << "this->" << member << ".set (" <<
+                  (std >= cxx_version::cxx11 ? "std::move (x)" : "x") << ");"
                    << "}";
 
               // auto_ptr<type>
@@ -599,7 +622,7 @@ namespace CXX
               //
               if (detach && !fund)
                 os << inl
-                   << "::std::auto_ptr< " << q_type << " > " <<
+                   << auto_ptr << "< " << q_type << " > " <<
                   scope_ << "::" << endl
                    << edname (m) << " ()"
                    << "{"
@@ -613,7 +636,7 @@ namespace CXX
           //
           if (m.default_p ())
           {
-            Boolean simple (true);
+            bool simple (true);
 
             if (m.is_a<SemanticGraph::Element> ())
             {
@@ -660,7 +683,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           String const& aname (eaname (a));
@@ -810,7 +833,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute& a)
         {
           String const& aname (eaname (a));
@@ -862,7 +885,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           String name (ename (c));
@@ -883,13 +906,48 @@ namespace CXX
           Member member (*this, name);
           Traversal::Names names;
 
-          if (options.value<CLI::generate_wildcard> ())
+          if (options.generate_wildcard ())
             names >> any;
 
           names >> member;
 
           Complex::names (c, names);
 
+          // Mixed text content.
+          //
+          if (mixed_p (c) && !c.context ().count ("mixed-in-base"))
+          {
+            SemanticGraph::Context& ctx (c.context ());
+
+            String const& cont (ctx.get<String> ("mixed-container"));
+            String const& memb (ctx.get<String> ("mixed-member"));
+
+            String const& aname (ctx.get<String> ("mixed-aname"));
+            String const& mname (ctx.get<String> ("mixed-mname"));
+
+            os << inl
+               << "const " << name << "::" << cont << "& " <<
+              name << "::" << endl
+               << aname << " () const"
+               << "{"
+               << "return this->" << memb << ";"
+               << "}";
+
+            os << inl
+               << name << "::" << cont << "& " << name << "::" << endl
+               << aname << " ()"
+               << "{"
+               << "return this->" << memb << ";"
+               << "}";
+
+            os << inl
+               << "void " << name << "::" << endl
+               << mname << " (const " << cont << "& s)"
+               << "{"
+               << "this->" << memb << " = s;"
+               << "}";
+          }
+
           // dom_document accessors.
           //
           if (edom_document_member_p (c))
@@ -899,14 +957,49 @@ namespace CXX
               name << "::" << endl
                << edom_document (c) << " () const"
                << "{"
-               << "return *" << edom_document_member (c) << ";"
+               << "return *this->" << edom_document_member (c) << ";"
                << "}";
 
             os << inl
                << xerces_ns << "::DOMDocument& " << name << "::" << endl
                << edom_document (c) << " ()"
                << "{"
-               << "return *" << edom_document_member (c) << ";"
+               << "return *this->" << edom_document_member (c) << ";"
+               << "}";
+          }
+
+          // Order container.
+          //
+          if (ordered_p (c) && !c.context ().count ("order-in-base"))
+          {
+            SemanticGraph::Context& ctx (c.context ());
+
+            String const& cont (ctx.get<String> ("order-container"));
+            String const& memb (ctx.get<String> ("order-member"));
+
+            String const& aname (ctx.get<String> ("order-aname"));
+            String const& mname (ctx.get<String> ("order-mname"));
+
+            os << inl
+               << "const " << name << "::" << cont << "& " <<
+              name << "::" << endl
+               << aname << " () const"
+               << "{"
+               << "return this->" << memb << ";"
+               << "}";
+
+            os << inl
+               << name << "::" << cont << "& " << name << "::" << endl
+               << aname << " ()"
+               << "{"
+               << "return this->" << memb << ";"
+               << "}";
+
+            os << inl
+               << "void " << name << "::" << endl
+               << mname << " (const " << cont << "& s)"
+               << "{"
+               << "this->" << memb << " = s;"
                << "}";
           }
 
@@ -924,13 +1017,13 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (!doc_root_p (e))
             return;
 
-          Boolean fund (false);
+          bool fund (false);
           {
             IsFundamentalType test (fund);
             test.dispatch (e.type ());
@@ -976,7 +1069,7 @@ namespace CXX
              << "void " << name << "::" << endl
              << mname << " (const " << type << "& x)"
              << "{"
-             << "return this->" << member << ".set (x);"
+             << "this->" << member << ".set (x);"
              << "}";
 
           // void
@@ -986,9 +1079,10 @@ namespace CXX
           {
             os << inl
                << "void " << name << "::" << endl
-               << mname << " (::std::auto_ptr< " << type << " > p)"
+               << mname << " (" << auto_ptr  << "< " << type << " > x)"
                << "{"
-               << "return this->" << member << ".set (p);"
+               << "this->" << member << ".set (" <<
+              (std >= cxx_version::cxx11 ? "std::move (x)" : "x") << ");"
                << "}";
           }
 
@@ -997,7 +1091,7 @@ namespace CXX
           //
           if (detach && !fund)
             os << inl
-               << "::std::auto_ptr< " << name << "::" << type << " > " <<
+               << auto_ptr << "< " << name << "::" << type << " > " <<
               name << "::" << endl
                << edname (e) << " ()"
                << "{"
@@ -1007,12 +1101,12 @@ namespace CXX
       };
     }
 
-    Void
-    generate_tree_inline (Context& ctx, UnsignedLong first, UnsignedLong last)
+    void
+    generate_tree_inline (Context& ctx, size_t first, size_t last)
     {
       // Generate includes.
       //
-      if (ctx.options.value<CLI::generate_inline> ())
+      if (ctx.options.generate_inline ())
       {
         Traversal::Schema schema;
         Includes includes (ctx, Includes::inline_);
@@ -1035,7 +1129,7 @@ namespace CXX
       }
 
       Traversal::Schema schema;
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names names_ns, names;
       Namespace ns (ctx, first, last);
 
@@ -1053,7 +1147,7 @@ namespace CXX
       names >> complex;
       names >> enumeration;
 
-      if (ctx.options.value<CLI::generate_element_type> ())
+      if (ctx.options.generate_element_type ())
         names >> element;
 
       schema.dispatch (ctx.schema_root);
diff --git a/xsd/xsd/cxx/tree/tree-inline.hxx b/xsd/xsd/cxx/tree/tree-inline.hxx
index ffe4341..351ab38 100644
--- a/xsd/xsd/cxx/tree/tree-inline.hxx
+++ b/xsd/xsd/cxx/tree/tree-inline.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/tree-inline.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_TREE_INLINE_HXX
@@ -12,8 +11,8 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
-    generate_tree_inline (Context&, UnsignedLong first, UnsignedLong last);
+    void
+    generate_tree_inline (Context&, size_t first, size_t last);
   }
 }
 
diff --git a/xsd/xsd/cxx/tree/tree-source.cxx b/xsd/xsd/cxx/tree/tree-source.cxx
index 4a17b00..8a01c5a 100644
--- a/xsd/xsd/cxx/tree/tree-source.cxx
+++ b/xsd/xsd/cxx/tree/tree-source.cxx
@@ -1,9 +1,9 @@
 // file      : xsd/cxx/tree/tree-source.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
-#include <cult/containers/list.hxx>
+#include <map>
+#include <list>
 
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
@@ -11,6 +11,8 @@
 #include <cxx/tree/tree-source.hxx>
 #include <cxx/tree/default-value.hxx>
 
+using namespace std;
+
 namespace CXX
 {
   namespace Tree
@@ -24,7 +26,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& l)
         {
           String name (ename (l));
@@ -39,7 +41,7 @@ namespace CXX
              << "//" << endl
              << endl;
 
-          if (!options.value<CLI::suppress_parsing> ())
+          if (!options.suppress_parsing ())
           {
             SemanticGraph::Type& item_type (l.argumented ().type ());
             String base (L"::xsd::cxx::tree::list< " +
@@ -105,27 +107,35 @@ namespace CXX
 
           // Register with type factory map.
           //
-          if (polymorphic && polymorphic_p (l) && !anonymous_p (l))
+          if (polymorphic && polymorphic_p (l))
           {
             // Note that we are using the original type name.
             //
             String const& name (ename (l));
 
-            if (!options.value<CLI::suppress_parsing> ())
+            // If this type is anonymous but substitutes, then it will
+            // be registered as part of the substitution registration.
+            //
+            if (!anonymous_p (l) && !options.suppress_parsing ())
+            {
               os << "static" << endl
-                 << "const ::xsd::cxx::tree::type_factory_initializer< 0, " <<
-                char_type << ", " << name << " >" << endl
+                 << "const ::xsd::cxx::tree::type_factory_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                  << "_xsd_" << name << "_type_factory_init (" << endl
                  << strlit (l.name ()) << "," << endl
                  << strlit (xml_ns_name (l)) << ");"
                  << endl;
+            }
 
-            if (options.value<CLI::generate_comparison> ())
+            if ((!anonymous_p (l) || anonymous_substitutes_p (l)) &&
+                options.generate_comparison ())
+            {
               os << "static" << endl
-                 << "const ::xsd::cxx::tree::comparison_initializer< 0, " <<
-                char_type << ", " << name << " >" << endl
+                 << "const ::xsd::cxx::tree::comparison_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                  << "_xsd_" << name << "_comparison_init;"
                  << endl;
+            }
           }
         }
 
@@ -150,7 +160,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           String name (ename (u));
@@ -167,7 +177,7 @@ namespace CXX
              << "//" << endl
              << endl;
 
-          if (!options.value<CLI::suppress_parsing> ())
+          if (!options.suppress_parsing ())
           {
             // c-tor (xercesc::DOMElement)
             //
@@ -212,27 +222,35 @@ namespace CXX
 
           // Register with type factory map.
           //
-          if (polymorphic && polymorphic_p (u) && !anonymous_p (u))
+          if (polymorphic && polymorphic_p (u))
           {
             // Note that we are using the original type name.
             //
             String const& name (ename (u));
 
-            if (!options.value<CLI::suppress_parsing> ())
+            // If this type is anonymous but substitutes, then it will
+            // be registered as part of the substitution registration.
+            //
+            if (!anonymous_p (u) && !options.suppress_parsing ())
+            {
               os << "static" << endl
-                 << "const ::xsd::cxx::tree::type_factory_initializer< 0, " <<
-                char_type << ", " << name << " >" << endl
+                 << "const ::xsd::cxx::tree::type_factory_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                  << "_xsd_" << name << "_type_factory_init (" << endl
                  << strlit (u.name ()) << "," << endl
                  << strlit (xml_ns_name (u)) << ");"
                  << endl;
+            }
 
-            if (options.value<CLI::generate_comparison> ())
+            if ((!anonymous_p (u) || anonymous_substitutes_p (u)) &&
+                options.generate_comparison ())
+            {
               os << "static" << endl
-                 << "const ::xsd::cxx::tree::comparison_initializer< 0, " <<
-                char_type << ", " << name << " >" << endl
+                 << "const ::xsd::cxx::tree::comparison_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                  << "_xsd_" << name << "_comparison_init;"
                  << endl;
+            }
           }
         }
       };
@@ -248,7 +266,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           os << strlit (e.name ());
@@ -269,13 +287,13 @@ namespace CXX
         String name_;
       };
 
-      Boolean
+      bool
       operator< (LiteralInfo const& x, LiteralInfo const& y)
       {
         return x.value_ < y.value_;
       }
 
-      typedef Cult::Containers::List<LiteralInfo> LiteralInfoList;
+      typedef list<LiteralInfo> LiteralInfoList;
 
 
       // Populate LiteralInfoList
@@ -288,7 +306,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           list_.push_back (LiteralInfo (e.name (), ename (e)));
@@ -307,7 +325,7 @@ namespace CXX
           names_enumerator_literal_ >> enumerator_literal_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           String name (ename (e));
@@ -318,14 +336,14 @@ namespace CXX
           if (renamed_type (e, name) && !name)
             return;
 
-          Boolean string_based (false);
+          bool string_based (false);
           {
             IsStringBasedType t (string_based);
             t.dispatch (e);
           }
 
           SemanticGraph::Enumeration* be (0);
-          Boolean enum_based (false);
+          bool enum_based (false);
           if (string_based)
           {
             IsEnumBasedType t (be);
@@ -338,7 +356,7 @@ namespace CXX
           if (string_based)
             value = evalue (e);
 
-          UnsignedLong enum_count (0);
+          size_t enum_count (0);
 
           for (Type::NamesIterator i (e.names_begin ()), end (e.names_end ());
                i != end; ++i)
@@ -359,7 +377,7 @@ namespace CXX
              << "//" << endl
              << endl;
 
-          if (!options.value<CLI::suppress_parsing> ())
+          if (!options.suppress_parsing ())
           {
             // c-tor (xercesc::DOMElement)
             //
@@ -490,7 +508,7 @@ namespace CXX
 
             String fq_name (ns_scope + L"::" + name);
 
-            for (LiteralInfoList::Iterator
+            for (LiteralInfoList::iterator
                    b (l.begin ()), i (b), end (l.end ()); i != end; ++i)
             {
               if (i != b)
@@ -504,31 +522,39 @@ namespace CXX
 
           // Register with type factory map.
           //
-          if (polymorphic && polymorphic_p (e) && !anonymous_p (e))
+          if (polymorphic && polymorphic_p (e))
           {
             // Note that we are using the original type name.
             //
             String const& name (ename (e));
 
-            if (!options.value<CLI::suppress_parsing> ())
+            // If this type is anonymous but substitutes, then it will
+            // be registered as part of the substitution registration.
+            //
+            if (!anonymous_p (e) && !options.suppress_parsing ())
+            {
               os << "static" << endl
-                 << "const ::xsd::cxx::tree::type_factory_initializer< 0, " <<
-                char_type << ", " << name << " >" << endl
+                 << "const ::xsd::cxx::tree::type_factory_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                  << "_xsd_" << name << "_type_factory_init (" << endl
                  << strlit (e.name ()) << "," << endl
                  << strlit (xml_ns_name (e)) << ");"
                  << endl;
+            }
 
-            if (options.value<CLI::generate_comparison> ())
+            if ((!anonymous_p (e) || anonymous_substitutes_p (e)) &&
+                options.generate_comparison ())
+            {
               os << "static" << endl
-                 << "const ::xsd::cxx::tree::comparison_initializer< 0, " <<
-                char_type << ", " << name << " >" << endl
+                 << "const ::xsd::cxx::tree::comparison_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                  << "_xsd_" << name << "_comparison_init;"
                  << endl;
+            }
           }
         }
 
-        virtual Void
+        virtual void
         comma (Type&)
         {
           os << "," << endl;
@@ -549,7 +575,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
 	  if (skip (m))
@@ -560,7 +586,7 @@ namespace CXX
           if (m.default_p ())
           {
             SemanticGraph::Type& t (m.type ());
-            Boolean simple (true);
+            bool simple (true);
 
             if (m.is_a<SemanticGraph::Element> ())
             {
@@ -570,7 +596,7 @@ namespace CXX
 
             if (simple)
             {
-              Boolean lit (false);
+              bool lit (false);
               {
                 IsLiteralValue test (lit);
                 test.dispatch (t);
@@ -661,12 +687,15 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (skip (e))
             return;
 
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (e.scope ()));
+
           String const& member (emember (e));
 
           String tr (etraits (e)); // traits type name
@@ -674,7 +703,7 @@ namespace CXX
 
           SemanticGraph::Type& t (e.type ());
 
-          Boolean fund (false);
+          bool fund (false);
           {
             IsFundamentalType traverser (fund);
             traverser.dispatch (t);
@@ -686,23 +715,17 @@ namespace CXX
           // derived from which makes it impossible to substitute or
           // dynamically-type with xsi:type.
           //
-          Boolean poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
 
           os << "// " << comment (e.name ()) << endl
              << "//" << endl;
 
           if (poly)
           {
-            // aCC cannot handle an inline call to type_factory_map_instance.
-            //
             os << "{"
-               << "::xsd::cxx::tree::type_factory_map< " << char_type <<
-              " >& tfm (" << endl
-               << "::xsd::cxx::tree::type_factory_map_instance< 0, " <<
-              char_type << " > ());"
-               << endl
-               << "::std::auto_ptr< ::xsd::cxx::tree::type > tmp (" << endl
-               << "tfm.create (" << endl
+               << auto_ptr << "< ::xsd::cxx::tree::type > tmp (" << endl
+               << "::xsd::cxx::tree::type_factory_map_instance< " <<
+              poly_plate << ", " << char_type << " > ().create (" << endl
                << strlit (e.name ()) << "," << endl
                << (e.qualified_p ()
                    ? strlit (e.namespace_ ().name ())
@@ -732,8 +755,14 @@ namespace CXX
 
             if (!fund)
             {
-              os << "::std::auto_ptr< " << type << " > r (" << endl
-                 << tr << "::create (i, f, this));"
+              os << auto_ptr << "< " << type << " > r (" << endl
+                 << tr << "::create (i, f";
+
+              if (t.is_a<SemanticGraph::AnyType> () &&
+                  options.generate_any_type ())
+                os << " | " << flags_type << "::extract_content";
+
+              os << ", this));"
                  << endl;
             }
           }
@@ -772,7 +801,7 @@ namespace CXX
             {
               // Cast to static type.
               //
-              os << "::std::auto_ptr< " << type << " > r (" << endl
+              os << auto_ptr << "< " << type << " > r (" << endl
                  << "dynamic_cast< " << type << "* > (tmp.get ()));"
                  << endl
                  << "if (r.get ())" << endl
@@ -783,23 +812,25 @@ namespace CXX
                  << endl;
             }
 
+            char const* r (std >= cxx_version::cxx11 ? "::std::move (r)" : "r");
+
             if (max (e) != 1)
             {
               // sequence
               //
-              os << "this->" << member << ".push_back (r);";
+              os << "this->" << member << ".push_back (" << r << ");";
             }
             else if (min (e) == 0)
             {
               // optional
               //
-              os << "this->" << member << ".set (r);";
+              os << "this->" << member << ".set (" << r << ");";
             }
             else
             {
               // one
               //
-              os << "this->" << member << ".set (r);";
+              os << "this->" << member << ".set (" << r << ");";
             }
           }
           else
@@ -827,6 +858,27 @@ namespace CXX
             }
           }
 
+          // Capture order.
+          //
+          if (ordered_p (c))
+          {
+            SemanticGraph::Context& ctx (c.context ());
+
+            String const& t (ctx.get<String> ("order-type"));
+            String const& m (ctx.get<String> ("order-member"));
+
+            os << "this->" << m << ".push_back (" << endl
+               << t << " (" <<
+              e.context ().get<String> ("ordered-id-name");
+
+            // sequence
+            //
+            if (max (e) != 1)
+              os << ", " << "this->" << member << ".size () - 1";
+
+            os << "));";
+          }
+
           os << "continue;";
 
           // End of check block.
@@ -863,7 +915,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (skip (e))
@@ -893,15 +945,16 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           String const& member (emember (a));
 
+          SemanticGraph::Complex& c (
+            dynamic_cast<SemanticGraph::Complex&> (a.scope ()));
+
           String const& ns (a.definition_namespace ().name ());
-          String const& dom_doc (
-            edom_document (
-              dynamic_cast<SemanticGraph::Complex&> (a.scope ())));
+          String const& dom_doc (edom_document (c));
 
           os << "// " << ename (a) << endl
              << "//" << endl
@@ -982,7 +1035,7 @@ namespace CXX
           {
             // sequence
             //
-            os << "this->" << member << " .push_back (r);";
+            os << "this->" << member << ".push_back (r);";
           }
           else if (min (a) == 0)
           {
@@ -997,6 +1050,31 @@ namespace CXX
             os << "this->" << member << ".set (r);";
           }
 
+          // Capture order.
+          //
+          if (ordered_p (c))
+          {
+            SemanticGraph::Context& ctx (c.context ());
+
+            String const& t (ctx.get<String> ("order-type"));
+            String const& m (ctx.get<String> ("order-member"));
+
+            os << "this->" << m << ".push_back (" << endl
+               << t << " (" <<
+              a.context ().get<String> ("ordered-id-name") << ", ";
+
+            if (max (a) != 1)
+              // sequence
+              //
+              os << "this->" << member << ".size () - 1";
+            else
+              // optional & one
+              //
+              os << "0";
+
+            os << "));";
+          }
+
           os << "continue;";
 
           // End of check block.
@@ -1030,7 +1108,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           if (max (a) == 1 && min (a) == 1)
@@ -1055,7 +1133,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           String const& member (emember (a));
@@ -1075,26 +1153,8 @@ namespace CXX
                << "{";
           }
 
-          Boolean fund (false);
-          {
-            IsFundamentalType traverser (fund);
-            traverser.dispatch (a.type ());
-          }
-
-          if (fund)
-          {
-            os << "this->" << member << ".set (" << tr <<
-              "::create (i, f, this));";
-          }
-          else
-          {
-            String type (etype (a));
-
-            os << "::std::auto_ptr< " << type << " > r (" << endl
-               << tr << "::create (i, f, this));"
-               << endl
-               << "this->" << member << ".set (r);";
-          }
+          os << "this->" << member << ".set (" << tr <<
+            "::create (i, f, this));";
 
           os << "continue;"
              << "}";
@@ -1109,7 +1169,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           String const& member (emember (a));
@@ -1202,7 +1262,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
           String const& member (emember (a));
@@ -1238,33 +1298,31 @@ namespace CXX
                        Traversal::Type,
                        Context
       {
-        // If base_arg is empty then no base argument is
-        // generated.
+        // If base_arg is empty then no base argument is generated.
         //
-        CtorBase (Context& c, String const& base_arg)
-            : Context (c), base_arg_ (base_arg)
+        CtorBase (Context& c, CtorArgType at, String const& base_arg)
+            : Context (c), args_ (c, at, base_arg)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Type&)
         {
-          if (base_arg_)
-            os << base_arg_;
+          if (args_.base_arg_)
+            os << args_.base_arg_;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Enumeration&)
         {
-          if (base_arg_)
-            os << base_arg_;
+          if (args_.base_arg_)
+            os << args_.base_arg_;
         }
 
-        Void
+        void
         traverse (SemanticGraph::Complex& c)
         {
-          Args args (*this, base_arg_);
-          args.traverse (c);
+          args_.traverse (c);
         }
 
       private:
@@ -1279,31 +1337,32 @@ namespace CXX
                      Traversal::Attribute,
                      Context
         {
-          Args (Context& c, String const& base_arg)
-              : Context (c), base_arg_ (base_arg), first_ (true)
+          Args (Context& c, CtorArgType at, String const& base_arg)
+              : Context (c),
+                arg_type_ (at), base_arg_ (base_arg), first_ (true)
           {
             *this >> inherits_ >> *this;
             *this >> names_ >> *this;
           }
 
-          virtual Void
+          virtual void
           traverse (SemanticGraph::Type&)
           {
             if (base_arg_)
               os << comma () << base_arg_;
           }
 
-          virtual Void
+          virtual void
           traverse (SemanticGraph::Enumeration&)
           {
             if (base_arg_)
               os << comma () << base_arg_;
           }
 
-          virtual Void
+          virtual void
           traverse (SemanticGraph::Any& a)
           {
-            if (!options.value<CLI::generate_wildcard> ())
+            if (!options.generate_wildcard ())
               return;
 
             if (min (a) == 1 && max (a) == 1)
@@ -1314,18 +1373,43 @@ namespace CXX
             }
           }
 
-          virtual Void
+          virtual void
           traverse (SemanticGraph::Element& e)
           {
             if (!skip (e) && min (e) == 1 && max (e) == 1)
             {
               // one
               //
-              os << comma () << ename (e);
+              bool move (false);
+
+              if (std >= cxx_version::cxx11)
+              {
+                switch (arg_type_)
+                {
+                case CtorArgType::complex_auto_ptr:
+                  {
+                    bool simple (true);
+                    IsSimpleType t (simple);
+                    t.dispatch (e.type ());
+                    move = !simple;
+                    break;
+                  }
+                case CtorArgType::poly_auto_ptr:
+                  {
+                    move = polymorphic && polymorphic_p (e.type ());
+                    break;
+                  }
+                case CtorArgType::type:
+                  break;
+                }
+              }
+
+              os << comma () << (move ? "std::move (" : "") << ename (e) <<
+                (move ? ")" : "");
             }
           }
 
-          virtual Void
+          virtual void
           traverse (SemanticGraph::Attribute& a)
           {
             // Note that we are not including attributes with default
@@ -1345,20 +1429,23 @@ namespace CXX
           String
           comma ()
           {
-            Boolean tmp (first_);
+            bool tmp (first_);
             first_ = false;
             return tmp ? "" : ",\n";
           }
 
-        private:
+        public:
+          CtorArgType arg_type_;
           String base_arg_;
-          Boolean first_;
+
+        private:
+          bool first_;
 
           Traversal::Inherits inherits_;
           Traversal::Names names_;
         };
 
-        String base_arg_;
+        Args args_;
       };
 
 
@@ -1366,12 +1453,12 @@ namespace CXX
                          Traversal::Attribute,
                          Context
       {
-        CtorMember (Context& c)
-            : Context (c)
+        CtorMember (Context& c, CtorArgType at)
+            : Context (c), arg_type_ (at)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element& e)
         {
           if (skip (e))
@@ -1384,38 +1471,62 @@ namespace CXX
             // sequence
             //
             os << "," << endl
-               << "  " << member << " (" << flags_type << " (), this)";
+               << "  " << member << " (this)";
           }
           else if (min (e) == 0)
           {
             // optional
             //
             os << "," << endl
-               << "  " << member << " (" << flags_type << " (), this)";
+               << "  " << member << " (this)";
           }
           else
           {
             // one
             //
+            bool move (false);
+
+            if (std >= cxx_version::cxx11)
+            {
+              switch (arg_type_)
+              {
+              case CtorArgType::complex_auto_ptr:
+                {
+                  bool simple (true);
+                  IsSimpleType t (simple);
+                  t.dispatch (e.type ());
+                  move = !simple;
+                  break;
+                }
+              case CtorArgType::poly_auto_ptr:
+                {
+                  move = polymorphic && polymorphic_p (e.type ());
+                  break;
+                }
+              case CtorArgType::type:
+                break;
+              }
+            }
+
             os << "," << endl
-               << "  " << member << " (" << ename (e) << ", " <<
-              flags_type << " (), this)";
+               << "  " << member << " (" << (move ? "std::move (" : "") <<
+              ename (e) << (move ? ")" : "") << ", this)";
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Attribute& a)
         {
           String const& member (emember (a));
 
-          Boolean def (a.default_p ());
+          bool def (a.default_p ());
 
           if (min (a) == 0 && !def)
           {
             // optional
             //
             os << "," << endl
-               << "  " << member << " (" << flags_type << " (), this)";
+               << "  " << member << " (this)";
           }
           else
           {
@@ -1429,16 +1540,18 @@ namespace CXX
               //
               os << "," << endl
                  << "  " << member << " (" <<
-                edefault_value (a) << " (), " << flags_type << " (), this)";
+                edefault_value (a) << " (), this)";
             }
             else
             {
               os << "," << endl
-                 << "  " << member << " (" << ename (a) << ", " <<
-                flags_type << " (), this)";
+                 << "  " << member << " (" << ename (a) << ", this)";
             }
           }
         }
+
+      private:
+        CtorArgType arg_type_;
       };
 
       struct CtorAny: Traversal::Any,
@@ -1450,7 +1563,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           String const& member (emember (a));
@@ -1482,7 +1595,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute& a)
         {
           String const& dom_doc (
@@ -1502,7 +1615,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Member& m)
         {
           if (skip (m))
@@ -1528,7 +1641,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           String const& member (emember (a));
@@ -1541,7 +1654,7 @@ namespace CXX
             arg_name << "." << member << ", this->" << dom_doc << " ())";
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute& a)
         {
           String const& member (emember (a));
@@ -1558,6 +1671,48 @@ namespace CXX
         String arg_name;
       };
 
+      struct AssignMember: Traversal::Member, Context
+      {
+        AssignMember (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Member& m)
+        {
+          if (skip (m))
+            return;
+
+          String const& member (emember (m));
+          os << "this->" << member << " = x." << member << ";";
+        }
+      };
+
+      struct AssignAny: Traversal::Any,
+                        Traversal::AnyAttribute,
+                        Context
+      {
+        AssignAny (Context& c)
+            : Context (c)
+        {
+        }
+
+        virtual void
+        traverse (SemanticGraph::Any& a)
+        {
+          String const& member (emember (a));
+          os << "this->" << member << " = x." << member << ";";
+        }
+
+        virtual void
+        traverse (SemanticGraph::AnyAttribute& a)
+        {
+          String const& member (emember (a));
+          os << "this->" << member << " = x." << member << ";";
+        }
+      };
+
 
       // Element parsing c-tor initializers.
       //
@@ -1568,7 +1723,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& m)
         {
           if (skip (m))
@@ -1577,7 +1732,7 @@ namespace CXX
           String const& member (emember (m));
 
           os << "," << endl
-             << "  " << member << " (f, this)";
+             << "  " << member << " (this)";
         }
       };
 
@@ -1590,7 +1745,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           String const& member (emember (a));
@@ -1602,7 +1757,7 @@ namespace CXX
              << "  " << member << " (this->" << dom_doc << " ())";
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute& a)
         {
           String const& member (emember (a));
@@ -1627,7 +1782,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element& e)
         {
           if (skip (e))
@@ -1636,10 +1791,10 @@ namespace CXX
           String const& member (emember (e));
 
           os << "," << endl
-             << "  " << member << " (" << flags_type << " (), this)";
+             << "  " << member << " (this)";
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Attribute& a)
         {
           String const& member (emember (a));
@@ -1651,11 +1806,11 @@ namespace CXX
             //
             os << "," << endl
                << "  " << member << " (" <<
-              edefault_value (a) << " (), " << flags_type << " (), this)";
+              edefault_value (a) << " (), this)";
           }
           else
             os << "," << endl
-               << "  " << member << " (" << flags_type << " (), this)";
+               << "  " << member << " (this)";
         }
       };
 
@@ -1668,7 +1823,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           String const& member (emember (a));
@@ -1680,7 +1835,7 @@ namespace CXX
              << "  " << member << " (this->" << dom_doc << " ())";
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute& a)
         {
           String const& member (emember (a));
@@ -1707,39 +1862,39 @@ namespace CXX
       {
         // generate should initially be false.
         //
-        HasComparisonOperator (Context& c, Boolean& generate)
+        HasComparisonOperator (Context& c, bool& generate)
             : Context (c), generate_ (generate)
         {
           *this >> inherits_ >> *this;
           *this >> names_ >> *this;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Fundamental::Type&)
         {
           // All built-in types are comparable.
           generate_ = true;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::List&)
         {
           generate_ = true;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Union&)
         {
           generate_ = true;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Enumeration& e)
         {
           Traversal::Enumeration::inherits (e);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           Complex::names (c);
@@ -1748,29 +1903,29 @@ namespace CXX
             Complex::inherits (c);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Member& m)
         {
           if (!skip (m))
             generate_ = true;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any&)
         {
-          if (options.value<CLI::generate_wildcard> ())
+          if (options.generate_wildcard ())
             generate_ = true;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute&)
         {
-          if (options.value<CLI::generate_wildcard> ())
+          if (options.generate_wildcard ())
             generate_ = true;
         }
 
       private:
-        Boolean& generate_;
+        bool& generate_;
 
         Traversal::Inherits inherits_;
         Traversal::Names names_;
@@ -1787,7 +1942,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element& e)
         {
           if (skip (e))
@@ -1802,7 +1957,7 @@ namespace CXX
           // dynamically-type with xsi:type.
           //
           SemanticGraph::Type& t (e.type ());
-          Boolean poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
+          bool poly (polymorphic && polymorphic_p (t) && !anonymous_p (t));
 
           if (!poly)
           {
@@ -1812,13 +1967,11 @@ namespace CXX
           }
           else
           {
-            // aCC cannot handle an inline call to comparison_map_instance.
-            //
             os << "{"
                << "::xsd::cxx::tree::comparison_map< " << char_type
                << " >& cm (" << endl
-               << "::xsd::cxx::tree::comparison_map_instance< 0, " <<
-              char_type << " > ());"
+               << "::xsd::cxx::tree::comparison_map_instance< " <<
+              poly_plate << ", " << char_type << " > ());"
                << endl;
 
             if (max (e) != 1)
@@ -1878,7 +2031,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Attribute& a)
         {
           String const& aname (eaname (a));
@@ -1898,7 +2051,7 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           String const& aname (eaname (a));
@@ -1914,7 +2067,7 @@ namespace CXX
              << endl;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute& a)
         {
           String const& aname (eaname (a));
@@ -1935,50 +2088,53 @@ namespace CXX
                                Traversal::AnyAttribute,
                                Context
       {
-        HasParseFunction (Context& c, Boolean& has_el, Boolean& has_at)
+        HasParseFunction (Context& c, bool& has_el, bool& has_at)
             : Context (c), has_el_ (has_el), has_at_ (has_at)
         {
           *this >> names_ >> *this;
           *this >> inherits_ >> *this;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
+          if (mixed_p (c) && !c.context ().count ("mixed-in-base"))
+            has_el_ = true;
+
           names (c);
 
           if (!(has_el_ && has_at_))
             inherits (c);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element&)
         {
           has_el_ = true;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any&)
         {
           has_el_ = true;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Attribute&)
         {
           has_at_ = true;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::AnyAttribute&)
         {
-          if (options.value<CLI::generate_wildcard> ())
+          if (options.generate_wildcard ())
             has_at_ = true;
         }
 
       private:
-        Boolean& has_el_;
-        Boolean& has_at_;
+        bool& has_el_;
+        bool& has_at_;
 
         Traversal::Names names_;
         Traversal::Inherits inherits_;
@@ -1993,14 +2149,14 @@ namespace CXX
         {
         }
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           Facets f;
           FacetCollector col (f);
           col.traverse (c);
 
-          for (Facets::ConstIterator i (f.begin ()); i != f.end (); ++i)
+          for (Facets::const_iterator i (f.begin ()); i != f.end (); ++i)
           {
             if (i->first == L"fractionDigits")
               os << "{::xsd::cxx::tree::facet::fraction_digits, " <<
@@ -2012,7 +2168,7 @@ namespace CXX
         }
 
       private:
-        typedef Cult::Containers::Map<String, String> Facets;
+        typedef map<String, String> Facets;
 
         struct FacetCollector: Traversal::Complex
         {
@@ -2022,7 +2178,7 @@ namespace CXX
             *this >> inherits_ >> *this;
           }
 
-          virtual Void
+          virtual void
           traverse (Type& c)
           {
             if (c.inherits_p ())
@@ -2075,21 +2231,25 @@ namespace CXX
               default_ctor_any_init_ (c),
               default_ctor_member_init_ (c),
               ctor_any_ (c),
-              ctor_member_ (c),
+              ctor_member_ (c, CtorArgType::type),
               element_ctor_any_ (c),
               element_ctor_member_ (c),
+              assign_any_ (c),
+              assign_member_ (c),
               comparison_any_ (c),
               comparison_member_ (c),
               facet_array_ (c)
         {
+          bool gen_wildcard (options.generate_wildcard ());
+
           inherits_member_ >> member_name_;
 
           names_element_ >> element_;
-          if (options.value<CLI::generate_wildcard> ())
+          if (gen_wildcard)
             names_element_ >> any_;
 
           names_element_test_ >> element_test_;
-          if (options.value<CLI::generate_wildcard> ())
+          if (gen_wildcard)
             names_element_test_ >> any_test_;
 
           names_attribute_ >> attribute_;
@@ -2097,26 +2257,32 @@ namespace CXX
           names_any_attribute_ >> any_attribute_;
 
           default_ctor_init_names_ >> default_ctor_member_init_;
-          if (options.value<CLI::generate_wildcard> ())
+          if (gen_wildcard)
             default_ctor_init_names_ >> default_ctor_any_init_;
 
           ctor_names_ >> ctor_member_;
-          if (options.value<CLI::generate_wildcard> ())
+          if (gen_wildcard)
             ctor_names_ >> ctor_any_;
 
           element_ctor_names_ >> element_ctor_member_;
-          if (options.value<CLI::generate_wildcard> ())
+          if (gen_wildcard)
             element_ctor_names_ >> element_ctor_any_;
 
+          assign_names_ >> assign_member_;
+          if (gen_wildcard)
+            assign_names_ >> assign_any_;
+
           comparison_names_ >> comparison_member_;
-          if (options.value<CLI::generate_wildcard> ())
+          if (gen_wildcard)
             comparison_names_ >> comparison_any_;
         }
 
 
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
+          bool gen_wildcard (options.generate_wildcard ());
+
           String name (ename (c));
 
           // If renamed name is empty then we do not need to generate
@@ -2125,7 +2291,12 @@ namespace CXX
           if (renamed_type (c, name) && !name)
             return;
 
-          Boolean string_based (false);
+          SemanticGraph::Context& ctx (c.context ());
+
+          bool mixed (mixed_p (c) && !ctx.count ("mixed-in-base"));
+          bool ordered (ordered_p (c) && !ctx.count ("order-in-base"));
+
+          bool string_based (false);
           {
             IsStringBasedType t (string_based);
             t.dispatch (c);
@@ -2137,7 +2308,7 @@ namespace CXX
             t.dispatch (c);
           }
 
-          Boolean facets (false);
+          bool facets (false);
           String base; // base type name
           if (c.inherits_p ())
           {
@@ -2200,15 +2371,15 @@ namespace CXX
 
           // c-tors
           //
-          Boolean generate_no_base_ctor (false);
+          bool generate_no_base_ctor (false);
           {
             GenerateWithoutBaseCtor t (generate_no_base_ctor);
             t.traverse (c);
           }
 
-          Boolean has_complex_non_op_args (false);
-          Boolean has_poly_non_op_args (false);
-          Boolean complex_poly_args_clash (true);
+          bool has_complex_non_op_args (false);
+          bool has_poly_non_op_args (false);
+          bool complex_poly_args_clash (true);
           {
             HasComplexPolyNonOptArgs t (*this, true,
                                         has_complex_non_op_args,
@@ -2219,9 +2390,9 @@ namespace CXX
 
           // default c-tor
           //
-          if (options.value<CLI::generate_default_ctor> ())
+          if (options.generate_default_ctor ())
           {
-            Boolean generate (false);
+            bool generate (false);
             {
               GenerateDefaultCtor t (*this, generate, generate_no_base_ctor);
               t.traverse (c);
@@ -2241,6 +2412,12 @@ namespace CXX
                   " > ())";
               }
 
+              if (mixed)
+              {
+                os << "," << endl
+                   << "  " << ctx.get<String> ("mixed-member") << " (this)";
+              }
+
               names (c, default_ctor_init_names_);
 
               os << "{";
@@ -2252,9 +2429,9 @@ namespace CXX
 
           // c-tor (base, all-non-optional-members)
           //
-          if (options.value<CLI::generate_from_base_ctor> ())
+          if (options.generate_from_base_ctor ())
           {
-            Boolean generate (false);
+            bool generate (false);
             {
               GenerateFromBaseCtor t (*this, generate);
               t.traverse (c);
@@ -2262,9 +2439,9 @@ namespace CXX
 
             if (generate)
             {
-              Boolean has_complex_non_op_args (false);
-              Boolean has_poly_non_op_args (false);
-              Boolean complex_poly_args_clash (true);
+              bool has_complex_non_op_args (false);
+              bool has_poly_non_op_args (false);
+              bool complex_poly_args_clash (true);
               {
                 HasComplexPolyNonOptArgs t (*this, false,
                                             has_complex_non_op_args,
@@ -2281,7 +2458,7 @@ namespace CXX
               inherits (c, inherits_member_);
               os << "& " << base_arg;
               {
-                FromBaseCtorArg args (*this, FromBaseCtorArg::arg_type, true);
+                FromBaseCtorArg args (*this, CtorArgType::type, true);
                 Traversal::Names args_names (args);
                 names (c, args_names);
               }
@@ -2296,6 +2473,12 @@ namespace CXX
                   " > ())";
               }
 
+              if (mixed)
+              {
+                os << "," << endl
+                   << "  " << ctx.get<String> ("mixed-member") << " (this)";
+              }
+
               names (c, ctor_names_);
 
               os << "{";
@@ -2308,13 +2491,14 @@ namespace CXX
               //
               if (has_complex_non_op_args)
               {
+                CtorArgType const at (CtorArgType::complex_auto_ptr);
+
                 os << name << "::" << endl
                    << name << " (const ";
                 inherits (c, inherits_member_);
                 os << "& " << base_arg;
                 {
-                  FromBaseCtorArg args (
-                    *this, FromBaseCtorArg::arg_complex_auto_ptr, true);
+                  FromBaseCtorArg args (*this, at, true);
                   Traversal::Names args_names (args);
                   names (c, args_names);
                 }
@@ -2329,7 +2513,21 @@ namespace CXX
                     " > ())";
                 }
 
-                names (c, ctor_names_);
+                if (mixed)
+                {
+                  os << "," << endl
+                     << "  " << ctx.get<String> ("mixed-member") << " (this)";
+                }
+
+                {
+                  CtorMember t (*this, at);
+                  Traversal::Names n (t);
+
+                  if (gen_wildcard)
+                    n >> ctor_any_;
+
+                  names (c, n);
+                }
 
                 os << "{";
                 if (facets)
@@ -2343,13 +2541,14 @@ namespace CXX
               if (polymorphic &&
                   has_poly_non_op_args && !complex_poly_args_clash)
               {
+                CtorArgType const at (CtorArgType::poly_auto_ptr);
+
                 os << name << "::" << endl
                    << name << " (const ";
                 inherits (c, inherits_member_);
                 os << "& " << base_arg;
                 {
-                  FromBaseCtorArg args (
-                    *this, FromBaseCtorArg::arg_poly_auto_ptr, true);
+                  FromBaseCtorArg args (*this, at, true);
                   Traversal::Names args_names (args);
                   names (c, args_names);
                 }
@@ -2364,7 +2563,21 @@ namespace CXX
                     " > ())";
                 }
 
-                names (c, ctor_names_);
+                if (mixed)
+                {
+                  os << "," << endl
+                     << "  " << ctx.get<String> ("mixed-member") << " (this)";
+                }
+
+                {
+                  CtorMember t (*this, at);
+                  Traversal::Names n (t);
+
+                  if (gen_wildcard)
+                    n >> ctor_any_;
+
+                  names (c, n);
+                }
 
                 os << "{";
                 if (facets)
@@ -2378,17 +2591,18 @@ namespace CXX
           //
           if (generate_no_base_ctor)
           {
+            CtorArgType const at (CtorArgType::type);
+
             os << name << "::" << endl
                << name << " (";
             {
-              CtorArgsWithoutBase ctor_args (
-                *this, CtorArgsWithoutBase::arg_type, true, true);
+              CtorArgsWithoutBase ctor_args (*this, at, true, true);
               ctor_args.dispatch (c);
             }
             os << ")" << endl
                << ": " << base << " (";
             {
-              CtorBase base (*this, "");
+              CtorBase base (*this, at, "");
               Traversal::Inherits inherits_base (base);
 
               inherits (c, inherits_base);
@@ -2403,6 +2617,12 @@ namespace CXX
                 " > ())";
             }
 
+            if (mixed)
+            {
+              os << "," << endl
+                 << "  " << ctx.get<String> ("mixed-member") << " (this)";
+            }
+
             names (c, ctor_names_);
 
             os << "{";
@@ -2416,17 +2636,18 @@ namespace CXX
             //
             if (has_complex_non_op_args)
             {
+              CtorArgType const at (CtorArgType::complex_auto_ptr);
+
               os << name << "::" << endl
                  << name << " (";
               {
-                CtorArgsWithoutBase ctor_args (
-                  *this, CtorArgsWithoutBase::arg_complex_auto_ptr, true, true);
+                CtorArgsWithoutBase ctor_args (*this, at, true, true);
                 ctor_args.dispatch (c);
               }
               os << ")" << endl
                  << ": " << base << " (";
               {
-                CtorBase base (*this, "");
+                CtorBase base (*this, at, "");
                 Traversal::Inherits inherits_base (base);
 
                 inherits (c, inherits_base);
@@ -2441,7 +2662,21 @@ namespace CXX
                   " > ())";
               }
 
-              names (c, ctor_names_);
+              if (mixed)
+              {
+                os << "," << endl
+                   << "  " << ctx.get<String> ("mixed-member") << " (this)";
+              }
+
+              {
+                CtorMember t (*this, at);
+                Traversal::Names n (t);
+
+                if (gen_wildcard)
+                  n >> ctor_any_;
+
+                names (c, n);
+              }
 
               os << "{";
               if (facets)
@@ -2455,17 +2690,18 @@ namespace CXX
             if (polymorphic &&
                 has_poly_non_op_args && !complex_poly_args_clash)
             {
+              CtorArgType const at (CtorArgType::poly_auto_ptr);
+
               os << name << "::" << endl
                  << name << " (";
               {
-                CtorArgsWithoutBase ctor_args (
-                  *this, CtorArgsWithoutBase::arg_poly_auto_ptr, true, true);
+                CtorArgsWithoutBase ctor_args (*this, at, true, true);
                 ctor_args.dispatch (c);
               }
               os << ")" << endl
                  << ": " << base << " (";
               {
-                CtorBase base (*this, "");
+                CtorBase base (*this, at, "");
                 Traversal::Inherits inherits_base (base);
 
                 inherits (c, inherits_base);
@@ -2480,7 +2716,21 @@ namespace CXX
                   " > ())";
               }
 
-              names (c, ctor_names_);
+              if (mixed)
+              {
+                os << "," << endl
+                   << "  " << ctx.get<String> ("mixed-member") << " (this)";
+              }
+
+              {
+                CtorMember t (*this, at);
+                Traversal::Names n (t);
+
+                if (gen_wildcard)
+                  n >> ctor_any_;
+
+                names (c, n);
+              }
 
               os << "{";
               if (facets)
@@ -2497,6 +2747,7 @@ namespace CXX
             {
               // c-tor (enum-value, all-non-optional-members)
               //
+              CtorArgType const at (CtorArgType::type);
               String base_arg (L"_xsd_" + ename (*enum_base) + L"_base");
 
               os << name << "::" << endl
@@ -2504,8 +2755,7 @@ namespace CXX
                 evalue (*enum_base) << " " << base_arg;
 
               {
-                CtorArgsWithoutBase ctor_args (
-                  *this, CtorArgsWithoutBase::arg_type, true, false);
+                CtorArgsWithoutBase ctor_args (*this, at, true, false);
                 ctor_args.dispatch (c);
               }
 
@@ -2513,7 +2763,7 @@ namespace CXX
                  << ": " << base << " (";
 
               {
-                CtorBase base (*this, base_arg);
+                CtorBase base (*this, at, base_arg);
                 Traversal::Inherits inherits_base (base);
 
                 inherits (c, inherits_base);
@@ -2529,6 +2779,8 @@ namespace CXX
                   " > ())";
               }
 
+              // Cannot be mixed.
+
               names (c, ctor_names_);
 
               os << "{";
@@ -2537,6 +2789,7 @@ namespace CXX
               os << "}";
             }
 
+            CtorArgType const at (CtorArgType::type);
             String base_arg (L"_xsd_" + ename (ultimate_base (c)) + L"_base");
 
             // c-tor (const char*, all-non-optional-members)
@@ -2545,8 +2798,7 @@ namespace CXX
                << name << " (const " << char_type << "* " << base_arg;
 
             {
-              CtorArgsWithoutBase ctor_args (
-                *this, CtorArgsWithoutBase::arg_type, true, false);
+              CtorArgsWithoutBase ctor_args (*this, at, true, false);
               ctor_args.dispatch (c);
             }
 
@@ -2554,7 +2806,7 @@ namespace CXX
                << ": " << base << " (";
 
             {
-              CtorBase base (*this, base_arg);
+              CtorBase base (*this, at, base_arg);
               Traversal::Inherits inherits_base (base);
 
               inherits (c, inherits_base);
@@ -2570,6 +2822,8 @@ namespace CXX
                 " > ())";
             }
 
+            // Cannot be mixed.
+
             names (c, ctor_names_);
 
             os << "{";
@@ -2584,8 +2838,7 @@ namespace CXX
                << name << " (const " << string_type << "& " << base_arg;
 
             {
-              CtorArgsWithoutBase ctor_args (
-                *this, CtorArgsWithoutBase::arg_type, true, false);
+              CtorArgsWithoutBase ctor_args (*this, at, true, false);
               ctor_args.dispatch (c);
             }
 
@@ -2593,7 +2846,7 @@ namespace CXX
                << ": " << base << " (";
 
             {
-              CtorBase base (*this, base_arg);
+              CtorBase base (*this, at, base_arg);
               Traversal::Inherits inherits_base (base);
 
               inherits (c, inherits_base);
@@ -2609,6 +2862,8 @@ namespace CXX
                 " > ())";
             }
 
+            // Cannot be mixed.
+
             names (c, ctor_names_);
 
             os << "{";
@@ -2619,57 +2874,66 @@ namespace CXX
 
           // c-tor (ultimate-base, all-non-optional-members)
           //
+          {
+            CtorArgType const at (CtorArgType::type);
 
-          os << name << "::" << endl
-             << name << " (";
+            os << name << "::" << endl
+               << name << " (";
 
-          String base_arg;
+            String base_arg;
 
-          {
-            CtorArgs ctor_args (*this, CtorArgs::arg_type, base_arg);
-            ctor_args.dispatch (c);
-          }
+            {
+              CtorArgs ctor_args (*this, at, base_arg);
+              ctor_args.dispatch (c);
+            }
 
-          os << ")" << endl
-             << ": " << base << " (";
+            os << ")" << endl
+               << ": " << base << " (";
 
-          {
-            CtorBase base (*this, base_arg);
-	    Traversal::Inherits inherits_base (base);
+            {
+              CtorBase base (*this, at, base_arg);
+              Traversal::Inherits inherits_base (base);
 
-            inherits (c, inherits_base);
-          }
+              inherits (c, inherits_base);
+            }
 
-          os << ")";
+            os << ")";
 
-          if (edom_document_member_p (c))
-          {
-            os << "," << endl
-               << "  " << edom_document_member (c) << " (" <<
-              "::xsd::cxx::xml::dom::create_document< " << char_type <<
-              " > ())";
-          }
+            if (edom_document_member_p (c))
+            {
+              os << "," << endl
+                 << "  " << edom_document_member (c) << " (" <<
+                "::xsd::cxx::xml::dom::create_document< " << char_type <<
+                " > ())";
+            }
 
-          names (c, ctor_names_);
+            if (mixed)
+            {
+              os << "," << endl
+                 << "  " << ctx.get<String> ("mixed-member") << " (this)";
+            }
 
-          os << "{";
-          if (facets)
-            os << "this->_facet_table (_xsd_" << name << "_facet_table);";
-          os << "}";
+            names (c, ctor_names_);
+
+            os << "{";
+            if (facets)
+              os << "this->_facet_table (_xsd_" << name << "_facet_table);";
+            os << "}";
+          }
 
           // If we have any complex arguments in the previous c-tor
           // then also generate the auto_ptr version.
           //
           if (has_complex_non_op_args)
           {
+            CtorArgType const at (CtorArgType::complex_auto_ptr);
+            String base_arg;
+
             os << name << "::" << endl
                << name << " (";
 
-            String base_arg;
-
             {
-              CtorArgs ctor_args (
-                *this, CtorArgs::arg_complex_auto_ptr, base_arg);
+              CtorArgs ctor_args (*this, at, base_arg);
               ctor_args.dispatch (c);
             }
 
@@ -2677,7 +2941,7 @@ namespace CXX
                << ": " << base << " (";
 
             {
-              CtorBase base (*this, base_arg);
+              CtorBase base (*this, at, base_arg);
               Traversal::Inherits inherits_base (base);
 
               inherits (c, inherits_base);
@@ -2693,7 +2957,21 @@ namespace CXX
                 " > ())";
             }
 
-            names (c, ctor_names_);
+            if (mixed)
+            {
+              os << "," << endl
+                 << "  " << ctx.get<String> ("mixed-member") << " (this)";
+            }
+
+            {
+              CtorMember t (*this, at);
+              Traversal::Names n (t);
+
+              if (gen_wildcard)
+                n >> ctor_any_;
+
+              names (c, n);
+            }
 
             os << "{";
             if (facets)
@@ -2707,14 +2985,14 @@ namespace CXX
           if (polymorphic &&
               has_poly_non_op_args && !complex_poly_args_clash)
           {
+            CtorArgType const at (CtorArgType::poly_auto_ptr);
+            String base_arg;
+
             os << name << "::" << endl
                << name << " (";
 
-            String base_arg;
-
             {
-              CtorArgs ctor_args (
-                *this, CtorArgs::arg_poly_auto_ptr, base_arg);
+              CtorArgs ctor_args (*this, at, base_arg);
               ctor_args.dispatch (c);
             }
 
@@ -2722,7 +3000,7 @@ namespace CXX
                << ": " << base << " (";
 
             {
-              CtorBase base (*this, base_arg);
+              CtorBase base (*this, at, base_arg);
               Traversal::Inherits inherits_base (base);
 
               inherits (c, inherits_base);
@@ -2738,7 +3016,21 @@ namespace CXX
                 " > ())";
             }
 
-            names (c, ctor_names_);
+            if (mixed)
+            {
+              os << "," << endl
+                 << "  " << ctx.get<String> ("mixed-member") << " (this)";
+            }
+
+            {
+              CtorMember t (*this, at);
+              Traversal::Names n (t);
+
+              if (gen_wildcard)
+                n >> ctor_any_;
+
+              names (c, n);
+            }
 
             os << "{";
             if (facets)
@@ -2764,6 +3056,20 @@ namespace CXX
               " > ())";
           }
 
+          if (mixed)
+          {
+            String const& m (ctx.get<String> ("mixed-member"));
+            os << "," << endl
+               << "  " << m << " (x." << m << ", f, this)";
+          }
+
+          if (ordered)
+          {
+            String const& m (ctx.get<String> ("order-member"));
+            os << "," << endl
+               << "  " << m << " (x." << m << ")";
+          }
+
           {
             CopyAny copy_any (*this, "x");
             CopyMember copy_member (*this, "x");
@@ -2771,7 +3077,7 @@ namespace CXX
 
             names >> copy_member;
 
-            if (options.value<CLI::generate_wildcard> ())
+            if (gen_wildcard)
               names >> copy_any;
 
             Complex::names (c, names);
@@ -2784,17 +3090,15 @@ namespace CXX
 
           //
           //
-          Boolean he (has<Traversal::Element> (c));
-          Boolean hae (has<Traversal::Any> (c));
+          bool he (has<Traversal::Element> (c));
+          bool hae (has<Traversal::Any> (c));
 
-          Boolean ha (has<Traversal::Attribute> (c));
-          Boolean haa (has<Traversal::AnyAttribute> (c));
-
-          Boolean gen_wildcard (options.value<CLI::generate_wildcard> ());
+          bool ha (has<Traversal::Attribute> (c));
+          bool haa (has<Traversal::AnyAttribute> (c));
 
           //
           //
-          if (!options.value<CLI::suppress_parsing> ())
+          if (!options.suppress_parsing ())
           {
             // c-tor (xercesc::DOMElement)
             //
@@ -2804,7 +3108,7 @@ namespace CXX
                << container << "* c)" << endl
                << ": " << base << " (e, f";
 
-            if (he || ha || hae || (haa && gen_wildcard))
+            if (he || ha || hae || (haa && gen_wildcard) || mixed)
               os << " | " << flags_type << "::base";
 
             os << ", c)";
@@ -2817,6 +3121,12 @@ namespace CXX
                 " > ())";
             }
 
+            if (mixed)
+            {
+              os << "," << endl
+                 << "  " << ctx.get<String> ("mixed-member") << " (this)";
+            }
+
             names (c, element_ctor_names_);
 
             os << "{";
@@ -2825,12 +3135,12 @@ namespace CXX
               os << "this->_facet_table (_xsd_" << name << "_facet_table);"
                  << endl;
 
-            Boolean base_has_el (false), base_has_at (false);
+            bool base_has_el (false), base_has_at (false);
 
             // We are only interested in this information if we are
-            // generating out own parse().
+            // generating our own parse().
             //
-            if (he || ha || hae || (haa && gen_wildcard))
+            if (he || ha || hae || (haa && gen_wildcard) || mixed)
             {
               if (c.inherits_p ())
               {
@@ -2839,13 +3149,14 @@ namespace CXX
               }
             }
 
-            //@@ throw if p is no exhausted at the end.
+            //@@ Throw if p is not exhausted at the end.
             //
-            if (he || ha || hae || (haa && gen_wildcard))
+            if (he || ha || hae || (haa && gen_wildcard) || mixed)
               os << "if ((f & " << flags_type << "::base) == 0)"
                  << "{"
                  << parser_type << " p (e, " <<
-                (he || hae || base_has_el ? "true, " : "false, ") <<
+                (he || hae || base_has_el || mixed_p (c) ? "true, " : "false, ") <<
+                (mixed_p (c) ? "true, " : "false, ") <<
                 (ha || (haa && gen_wildcard) || base_has_at ? "true" : "false")
                  << ");"
                  << "this->" << unclash (name, "parse") << " (p, f);"
@@ -2853,7 +3164,7 @@ namespace CXX
 
             os << "}";
 
-            Boolean simple (true);
+            bool simple (true);
             {
               IsSimpleType t (simple);
               t.dispatch (c);
@@ -2891,7 +3202,7 @@ namespace CXX
               os << "}";
             }
 
-            if (he || ha || hae || (haa && gen_wildcard))
+            if (he || ha || hae || (haa && gen_wildcard) || mixed)
             {
               os << "void " << name << "::" << endl
                  << unclash (name, "parse") << " (" <<
@@ -2906,17 +3217,45 @@ namespace CXX
                 os << "this->" << base << "::parse (p, f);"
                    << endl;
 
-              if (he || hae)
+              if (he || hae || mixed_p (c))
               {
-                os << "for (; p.more_elements (); p.next_element ())"
-                   << "{"
-                   << "const " << xerces_ns << "::DOMElement& i (" <<
-                  "p.cur_element ());"
-                   << "const " << qname_type << " n (" << endl
-                   << "::xsd::cxx::xml::dom::name< " << char_type << " > (i));"
-                   << endl;
+                bool m (mixed_p (c));
+
+                os << "for (; p.more_content (); p.next_content (" <<
+                  (m ? "true" : "false") << "))"
+                   << "{";
 
-                names (c, names_element_);
+                if (m)
+                {
+                  String const& ma (ctx.get<String> ("mixed-aname"));
+                  String const& mi (ctx.get<String> ("mixed-ordered-id-name"));
+                  String const& oa (ctx.get<String> ("order-aname"));
+                  String const& ot (ctx.get<String> ("order-type"));
+
+                  os << "if (p.cur_is_text ())"
+                     << "{"
+                     << "const " << xerces_ns << "::DOMText& t (" <<
+                    "p.cur_text ());"
+                     << "this->" << ma << " ().push_back (" << endl
+                     << "::xsd::cxx::xml::transcode< " << char_type << " > (" <<
+                    "t.getData (), t.getLength ()));"
+                     << "this->" << oa << " ().push_back (" << endl
+                     << ot << " (" << mi << "," << endl
+                     << "this->" << ma << " ().size () - 1));"
+                     << "continue;"
+                     << "}";
+                }
+
+                if (he || hae)
+                {
+                  os << "const " << xerces_ns << "::DOMElement& i (" <<
+                    "p.cur_element ());"
+                     << "const " << qname_type << " n (" << endl
+                     << "::xsd::cxx::xml::dom::name< " << char_type << " > (i));"
+                     << endl;
+
+                  names (c, names_element_);
+                }
 
                 os << "break;"
                    << "}";
@@ -2977,6 +3316,45 @@ namespace CXX
              << "return new class " << name << " (*this, f, c);"
              << "}";
 
+          // operator=
+          //
+          if (!options.suppress_assignment () &&
+              (he || ha || (gen_wildcard && (hae || haa))))
+          {
+            os << name << "& " << name << "::" << endl
+               << "operator= (const " << name << "& x)"
+               << "{"
+               << "if (this != &x)"
+               << "{"
+               << "static_cast< " << base << "& > (*this) = x;";
+
+            // Note that here we don't assign the DOMDocument that is
+            // used to hold wildcard fragments. Each document has its
+            // own copy.
+
+            // Mixed text content.
+            //
+            if (mixed)
+            {
+              String const& m (ctx.get<String> ("mixed-member"));
+              os << "this->" << m << " = x." << m << ";";
+            }
+
+            // Order container.
+            //
+            if (ordered)
+            {
+              String const& m (ctx.get<String> ("order-member"));
+              os << "this->" << m << " = x." << m << ";";
+            }
+
+            names (c, assign_names_);
+
+            os << "}"
+               << "return *this;"
+               << "}";
+          }
+
           // d-tor
           //
           os << name << "::" << endl
@@ -2986,36 +3364,44 @@ namespace CXX
 
           // Register with type factory map.
           //
-          if (polymorphic && polymorphic_p (c) && !anonymous_p (c))
+          if (polymorphic && polymorphic_p (c))
           {
             // Note that we are using the original type name.
             //
             String const& name (ename (c));
 
-            if (!options.value<CLI::suppress_parsing> ())
+            // If this type is anonymous but substitutes, then it will
+            // be registered as part of the substitution registration.
+            //
+            if (!anonymous_p (c) && !options.suppress_parsing ())
+            {
               os << "static" << endl
-                 << "const ::xsd::cxx::tree::type_factory_initializer< 0, " <<
-                char_type << ", " << name << " >" << endl
+                 << "const ::xsd::cxx::tree::type_factory_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                  << "_xsd_" << name << "_type_factory_init (" << endl
                  << strlit (c.name ()) << "," << endl
                  << strlit (xml_ns_name (c)) << ");"
                  << endl;
+            }
 
-            if (options.value<CLI::generate_comparison> ())
+            if ((!anonymous_p (c) || anonymous_substitutes_p (c)) &&
+                options.generate_comparison ())
+            {
               os << "static" << endl
-                 << "const ::xsd::cxx::tree::comparison_initializer< 0, " <<
-                char_type << ", " << name << " >" << endl
+                 << "const ::xsd::cxx::tree::comparison_initializer< " <<
+                poly_plate << ", " << char_type << ", " << name << " >" << endl
                  << "_xsd_" << name << "_comparison_init;"
                  << endl;
+            }
           }
 
           // Comparison operators.
           //
-          if (options.value<CLI::generate_comparison> () &&
-              (he || ha || !c.inherits_p () ||
+          if (options.generate_comparison () &&
+              (he || ha || mixed || ordered || !c.inherits_p () ||
                ((hae || haa) && gen_wildcard)))
           {
-            Boolean base_comp (false);
+            bool base_comp (false);
 
             if (c.inherits_p ())
             {
@@ -3023,8 +3409,8 @@ namespace CXX
               test.dispatch (c.inherits ().base ());
             }
 
-            Boolean has_body (he || ha || base_comp ||
-                              ((hae || haa) && gen_wildcard));
+            bool has_body (he || ha || ordered || mixed || base_comp ||
+                           ((hae || haa) && gen_wildcard));
 
             os << "bool" << endl
                << "operator== (const " << name << "&" <<
@@ -3042,6 +3428,22 @@ namespace CXX
               Complex::names (c, comparison_names_);
             }
 
+            if (mixed)
+            {
+              String const& an (ctx.get<String> ("mixed-aname"));
+              os << "if (!(x." << an << " () == y." << an << " ()))" << endl
+                 << "return false;"
+                 << endl;
+            }
+
+            if (ordered)
+            {
+              String const& an (ctx.get<String> ("order-aname"));
+              os << "if (!(x." << an << " () == y." << an << " ()))" << endl
+                 << "return false;"
+                 << endl;
+            }
+
             os << "return true;"
                << "}";
 
@@ -3088,6 +3490,10 @@ namespace CXX
         ElementCtorMember element_ctor_member_;
         Traversal::Names element_ctor_names_;
 
+        AssignAny assign_any_;
+        AssignMember assign_member_;
+        Traversal::Names assign_names_;
+
         AnyComparison comparison_any_;
         MemberComparison comparison_member_;
         Traversal::Names comparison_names_;
@@ -3105,27 +3511,27 @@ namespace CXX
         GlobalElement (Context& c)
             : GlobalElementBase (c),
               Context (c),
-              element_type_ (c.options.value<CLI::generate_element_type> ()),
-              element_map_ (c.options.value<CLI::generate_element_map> ()),
+              element_type_ (c.options.generate_element_type ()),
+              element_map_ (c.options.generate_element_map ()),
               type_name_ (c)
         {
           belongs_ >> type_name_;
         }
 
-        virtual Void
+        virtual void
         traverse (Type& e)
         {
           if (element_type_ && doc_root_p (e))
           {
             SemanticGraph::Type& t (e.type ());
 
-            Boolean fund (false);
+            bool fund (false);
             {
               IsFundamentalType test (fund);
               test.dispatch (t);
             }
 
-            Boolean simple (true);
+            bool simple (true);
             if (!fund)
             {
               IsSimpleType test (simple);
@@ -3166,11 +3572,11 @@ namespace CXX
 
             // default c-tor
             //
-            if (options.value<CLI::generate_default_ctor> ())
+            if (options.generate_default_ctor ())
             {
               os << name << "::" << endl
                  << name << " ()" << endl
-                 << ": " << member << " (0, 0)"
+                 << ": " << member << " (0)"
                  << "{"
                  << "}";
             }
@@ -3179,7 +3585,7 @@ namespace CXX
             //
             os << name << "::" << endl
                << name << " (const " << type << "& x)" << endl
-               << ": " << member << " (x, 0, 0)"
+               << ": " << member << " (x, 0)"
                << "{"
                << "}";
 
@@ -3189,8 +3595,8 @@ namespace CXX
             if (!simple || (polymorphic && polymorphic_p (t)))
             {
               os << name << "::" << endl
-                 << name << " (::std::auto_ptr< " << type << " > p)" << endl
-                 << ": " << member << " (p, 0, 0)"
+                 << name << " (" << auto_ptr << "< " << type << " > p)" << endl
+                 << ": " << member << " (p, 0)"
                  << "{"
                  << "}";
             }
@@ -3201,7 +3607,7 @@ namespace CXX
             String const& name_member (ec.get<String> ("element-name-member"));
             String const& ns_member (ec.get<String> ("element-ns-member"));
 
-            Boolean parsing (!options.value<CLI::suppress_parsing> ());
+            bool parsing (!options.suppress_parsing ());
             if (parsing)
             {
               String const& tr (etraits (e));
@@ -3209,7 +3615,7 @@ namespace CXX
               os << name << "::" << endl
                  << name << " (const " << xerces_ns << "::DOMElement& e, " <<
                 flags_type << " f)" << endl
-                 << ": " << member << " (f, 0)"
+                 << ": " << member << " (0)"
                  << "{"
                  << "const " << qname_type << " n (" << endl
                  << "::xsd::cxx::xml::dom::name< " << char_type << " > (e));"
@@ -3302,14 +3708,14 @@ namespace CXX
           }
 
           if (polymorphic && e.substitutes_p () &&
-              !options.value<CLI::suppress_parsing> ())
+              !options.suppress_parsing ())
           {
             String const& name (ename (e));
             Type& r (e.substitutes ().root ());
 
             os << "static" << endl
-               << "const ::xsd::cxx::tree::element_factory_initializer< 0, " <<
-              char_type << ", ";
+               << "const ::xsd::cxx::tree::element_factory_initializer< " <<
+              poly_plate << ", " << char_type << ", ";
 
             belongs (e, belongs_);
 
@@ -3325,32 +3731,30 @@ namespace CXX
         }
 
       private:
-        Boolean element_type_;
-        Boolean element_map_;
+        bool element_type_;
+        bool element_map_;
         Traversal::Belongs belongs_;
         MemberTypeName type_name_;
       };
     }
 
-    Void
-    generate_tree_source (Context& ctx,
-                          UnsignedLong first,
-                          UnsignedLong last)
+    void
+    generate_tree_source (Context& ctx, size_t first, size_t last)
     {
-      if (ctx.options.value<CLI::generate_wildcard> ())
+      if (ctx.options.generate_wildcard ())
       {
         ctx.os << "#include <xsd/cxx/xml/dom/wildcard-source.hxx>" << endl
                << endl;
       }
 
-      if (!ctx.options.value<CLI::suppress_parsing> ())
+      if (!ctx.options.suppress_parsing ())
         ctx.os << "#include <xsd/cxx/xml/dom/parsing-source.hxx>" << endl
                << endl;
 
       if (ctx.polymorphic)
       {
-        Boolean parsing (!ctx.options.value<CLI::suppress_parsing> ());
-        Boolean comparison (ctx.options.value<CLI::generate_comparison> ());
+        bool parsing (!ctx.options.suppress_parsing ());
+        bool comparison (ctx.options.generate_comparison ());
 
         if (parsing)
           ctx.os << "#include <xsd/cxx/tree/type-factory-map.hxx>" << endl
@@ -3362,8 +3766,8 @@ namespace CXX
 
         if (parsing || comparison)
         {
-          Boolean import_maps (ctx.options.value<CLI::import_maps> ());
-          Boolean export_maps (ctx.options.value<CLI::export_maps> ());
+          bool import_maps (ctx.options.import_maps ());
+          bool export_maps (ctx.options.export_maps ());
 
           if (import_maps || export_maps)
           {
@@ -3379,39 +3783,47 @@ namespace CXX
 
             if (parsing && export_maps)
               ctx.os << "template struct __declspec (dllexport) " <<
-                "type_factory_plate< 0, " << ctx.char_type << " >;";
+                "type_factory_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
 
             if (parsing && import_maps)
               ctx.os << "template struct __declspec (dllimport) " <<
-                "type_factory_plate< 0, " << ctx.char_type << " >;";
+                "type_factory_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
 
             if (comparison && export_maps)
               ctx.os << "template struct __declspec (dllexport) " <<
-                "comparison_plate< 0, " << ctx.char_type << " >;";
+                "comparison_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
 
             if (comparison && import_maps)
               ctx.os << "template struct __declspec (dllimport) " <<
-                "comparison_plate< 0, " << ctx.char_type << " >;";
+                "comparison_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
 
             ctx.os << "#elif defined(__GNUC__) && __GNUC__ >= 4" << endl;
 
             if (parsing)
               ctx.os << "template struct __attribute__ ((visibility(\"default\"))) " <<
-                "type_factory_plate< 0, " << ctx.char_type << " >;";
+                "type_factory_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
 
             if (comparison)
               ctx.os << "template struct __attribute__ ((visibility(\"default\"))) " <<
-                "comparison_plate< 0, " << ctx.char_type << " >;";
+                "comparison_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
 
             ctx.os << "#elif defined(XSD_MAP_VISIBILITY)" << endl;
 
             if (parsing)
               ctx.os << "template struct XSD_MAP_VISIBILITY " <<
-                "type_factory_plate< 0, " << ctx.char_type << " >;";
+                "type_factory_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
 
             if (comparison)
               ctx.os << "template struct XSD_MAP_VISIBILITY " <<
-                "comparison_plate< 0, " << ctx.char_type << " >;";
+                "comparison_plate< " << ctx.poly_plate << ", " <<
+                ctx.char_type << " >;";
 
             ctx.os << "#endif" << endl
                    << "}"  // tree
@@ -3426,15 +3838,15 @@ namespace CXX
 
           if (parsing)
             ctx.os << "static" << endl
-                   << "const ::xsd::cxx::tree::type_factory_plate< 0, " <<
-              ctx.char_type << " >" << endl
+                   << "const ::xsd::cxx::tree::type_factory_plate< " <<
+              ctx.poly_plate << ", " << ctx.char_type << " >" << endl
                    << "type_factory_plate_init;"
                    << endl;
 
           if (comparison)
             ctx.os << "static" << endl
-                   << "const ::xsd::cxx::tree::comparison_plate< 0, " <<
-              ctx.char_type << " >" << endl
+                   << "const ::xsd::cxx::tree::comparison_plate< " <<
+              ctx.poly_plate << ", " << ctx.char_type << " >" << endl
                    << "comparison_plate_init;"
                    << endl;
 
@@ -3443,7 +3855,7 @@ namespace CXX
       }
 
       Traversal::Schema schema;
-      Traversal::Sources sources;
+      Sources sources;
       Traversal::Names names_ns, names;
       Namespace ns (ctx, first, last);
 
diff --git a/xsd/xsd/cxx/tree/tree-source.hxx b/xsd/xsd/cxx/tree/tree-source.hxx
index a1b4778..b2d96f7 100644
--- a/xsd/xsd/cxx/tree/tree-source.hxx
+++ b/xsd/xsd/cxx/tree/tree-source.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/cxx/tree/tree-source.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_TREE_SOURCE_HXX
@@ -12,8 +11,8 @@ namespace CXX
 {
   namespace Tree
   {
-    Void
-    generate_tree_source (Context&, UnsignedLong first, UnsignedLong last);
+    void
+    generate_tree_source (Context&, size_t first, size_t last);
   }
 }
 
diff --git a/xsd/xsd/cxx/tree/validator.cxx b/xsd/xsd/cxx/tree/validator.cxx
index 88451ba..ce3dcd8 100644
--- a/xsd/xsd/cxx/tree/validator.cxx
+++ b/xsd/xsd/cxx/tree/validator.cxx
@@ -1,20 +1,18 @@
 // file      : xsd/cxx/tree/validator.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
-#include <cxx/tree/validator.hxx>
+#include <set>
+#include <iostream>
 
-#include <cult/containers/set.hxx>
+#include <cxx/tree/validator.hxx>
 
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
 
 #include <cxx/tree/elements.hxx>
 
-#include <iostream>
-
-using std::wcerr;
+using namespace std;
 
 namespace CXX
 {
@@ -27,15 +25,15 @@ namespace CXX
       public:
         ValidationContext (SemanticGraph::Schema& root,
                            SemanticGraph::Path const& path,
-                           CLI::Options const& options,
+                           Tree::options const& ops,
                            const WarningSet& disabled_warnings,
                            Counts const& counts,
-                           Boolean generate_xml_schema,
-                           Boolean& valid_)
+                           bool generate_xml_schema,
+                           bool& valid_)
             : Context (std::wcerr,
                        root,
                        path,
-                       options,
+                       ops,
                        counts,
                        generate_xml_schema,
                        0,
@@ -53,8 +51,8 @@ namespace CXX
         }
 
       public:
-        Boolean
-        is_disabled (Char const* w)
+        bool
+        is_disabled (char const* w)
         {
           return disabled_warnings_all_ ||
             disabled_warnings_.find (w) != disabled_warnings_.end ();
@@ -95,12 +93,12 @@ namespace CXX
 
       protected:
         const WarningSet& disabled_warnings_;
-        Boolean disabled_warnings_all_;
+        bool disabled_warnings_all_;
 
-        Boolean& valid;
+        bool& valid;
 
-        Boolean& subst_group_warning_issued;
-        Boolean subst_group_warning_issued_;
+        bool& subst_group_warning_issued;
+        bool subst_group_warning_issued_;
       };
 
 
@@ -122,7 +120,7 @@ namespace CXX
           {
           }
 
-          virtual Void
+          virtual void
           traverse (SemanticGraph::Element& e)
           {
 	    if (skip (e))
@@ -130,13 +128,13 @@ namespace CXX
 
             using SemanticGraph::Any;
 
-            Boolean q (e.qualified_p ());
+            bool q (e.qualified_p ());
             String ns (q ? e.namespace_ ().name () : "");
 
             for (Any::NamespaceIterator i (any_.namespace_begin ());
                  i != any_.namespace_end (); ++i)
             {
-              Boolean failed (false);
+              bool failed (false);
 
               if (*i == L"##any")
               {
@@ -205,14 +203,14 @@ namespace CXX
           {
           }
 
-          virtual Void
+          virtual void
           post (Type& c)
           {
             // Go down the inheritance hierarchy.
             //
             if (down_)
             {
-              Boolean up = up_;
+              bool up = up_;
               up_ = false;
 
               if (c.inherits_p ())
@@ -225,7 +223,7 @@ namespace CXX
             //
             if (up_)
             {
-              Boolean down = down_;
+              bool down = down_;
               down_ = false;
 
               for (Type::BegetsIterator i (c.begets_begin ());
@@ -239,10 +237,10 @@ namespace CXX
           }
 
         private:
-          Boolean up_, down_;
+          bool up_, down_;
         };
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           using SemanticGraph::Compositor;
@@ -295,7 +293,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           using SemanticGraph::Schema;
@@ -341,7 +339,7 @@ namespace CXX
           Complex::traverse (c);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Type& t)
         {
           // This is also used to traverse Complex.
@@ -352,7 +350,7 @@ namespace CXX
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element& e)
         {
           if (is_disabled ("T002"))
@@ -379,7 +377,7 @@ namespace CXX
 
         // Return true if root sources s.
         //
-        Boolean
+        bool
         sources_p (SemanticGraph::Schema& root, SemanticGraph::Schema& s)
         {
           using SemanticGraph::Schema;
@@ -399,9 +397,9 @@ namespace CXX
         }
 
       private:
-        Containers::Set<String> types_;
+        set<String> types_;
 
-        Traversal::Sources sources_;
+        Sources sources_;
 
         Traversal::Names schema_names_;
         Traversal::Namespace ns_;
@@ -432,7 +430,7 @@ namespace CXX
           *this >> names_;
         }
 
-        Boolean
+        bool
         traverse_common (SemanticGraph::Member& m)
         {
           SemanticGraph::Type& t (m.type ());
@@ -461,7 +459,7 @@ namespace CXX
                     << "automatically name them"
                     << endl;
 
-              if (!options.value<CLI::show_anonymous> ())
+              if (!options.show_anonymous ())
                 wcerr << t.file ()
                       << ": info: use --show-anonymous option to see these "
                       << "types" << endl;
@@ -473,14 +471,14 @@ namespace CXX
           return false;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element& e)
         {
 	  if (skip (e)) return;
 
           if (traverse_common (e))
           {
-            if (options.value<CLI::show_anonymous> ())
+            if (options.show_anonymous ())
             {
               wcerr << e.file () << ":" << e.line () << ":" << e.column ()
                     << ": error: element '" << xpath (e) << "' "
@@ -491,12 +489,12 @@ namespace CXX
             Traversal::Element::traverse (e);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Attribute& a)
         {
           if (traverse_common (a))
           {
-            if (options.value<CLI::show_anonymous> ())
+            if (options.show_anonymous ())
             {
               wcerr << a.file () << ":" << a.line () << ":" << a.column ()
                     << ": error: attribute '" << xpath (a) << "' "
@@ -508,11 +506,11 @@ namespace CXX
         }
 
       private:
-        Boolean anonymous_error_issued_;
+        bool anonymous_error_issued_;
 
-        Containers::Set<String> types_;
+        set<String> types_;
 
-        Traversal::Sources sources_;
+        Sources sources_;
 
         Traversal::Names schema_names_;
         Traversal::Namespace ns_;
@@ -521,27 +519,21 @@ namespace CXX
       };
     }
 
-    Validator::
-    Validator ()
-    {
-      // Dummy ctor, helps with long symbols on HP-UX.
-    }
-
-    Boolean Validator::
-    validate (CLI::Options const& options,
+    bool Validator::
+    validate (options const& ops,
               SemanticGraph::Schema& schema,
               SemanticGraph::Path const& path,
               const WarningSet& disabled_warnings,
               Counts const& counts)
     {
-      Boolean valid (true);
+      bool valid (true);
       ValidationContext ctx (
-        schema, path, options, disabled_warnings, counts, false, valid);
+        schema, path, ops, disabled_warnings, counts, false, valid);
 
       //
       //
-      Boolean import_maps (options.value<CLI::import_maps> ());
-      Boolean export_maps (options.value<CLI::export_maps> ());
+      bool import_maps (ops.import_maps ());
+      bool export_maps (ops.export_maps ());
 
       if (import_maps && export_maps)
       {
@@ -569,17 +561,17 @@ namespace CXX
 
       //
       //
-      if (options.value<CLI::char_type> () != "char" &&
-          options.value<CLI::char_type> () != "wchar_t" &&
+      if (ops.char_type () != "char" &&
+          ops.char_type () != "wchar_t" &&
           !ctx.is_disabled ("T003"))
       {
         wcerr << "warning T003: unknown base character type '" <<
-          options.value<CLI::char_type> ().c_str () << "'" << endl;
+          ops.char_type ().c_str () << "'" << endl;
       }
 
       //
       //
-      NarrowString tn (options.value<CLI::type_naming> ());
+      NarrowString tn (ops.type_naming ());
 
       if (tn != "knr" && tn != "ucc" && tn != "java")
       {
@@ -589,7 +581,7 @@ namespace CXX
         return false;
       }
 
-      NarrowString fn (options.value<CLI::function_naming> ());
+      NarrowString fn (ops.function_naming ());
 
       if (fn != "knr" && fn != "lcc" && fn != "java")
       {
@@ -601,11 +593,11 @@ namespace CXX
 
       //
       //
-      Boolean element_type (options.value<CLI::generate_element_type> ());
-      Boolean par (!options.value<CLI::suppress_parsing> ());
-      Boolean ser (options.value<CLI::generate_serialization> ());
+      bool element_type (ops.generate_element_type ());
+      bool par (!ops.suppress_parsing ());
+      bool ser (ops.generate_serialization ());
 
-      if (options.value<CLI::generate_element_map> ())
+      if (ops.generate_element_map ())
       {
         if (!element_type)
         {
@@ -631,11 +623,11 @@ namespace CXX
 
       if (counts.global_elements > 1 &&
           (element_type || par || ser) &&
-          !options.value<CLI::root_element_first> () &&
-          !options.value<CLI::root_element_last> () &&
-          !options.value<CLI::root_element_all> () &&
-          !options.value<CLI::root_element_none> () &&
-          options.value<CLI::root_element> ().empty () &&
+          !ops.root_element_first () &&
+          !ops.root_element_last () &&
+          !ops.root_element_all () &&
+          !ops.root_element_none () &&
+          ops.root_element ().empty () &&
           !ctx.is_disabled ("T004"))
       {
         wcerr << schema.file () << ": warning T004: generating ";
diff --git a/xsd/xsd/cxx/tree/validator.hxx b/xsd/xsd/cxx/tree/validator.hxx
index da0c441..58ec85e 100644
--- a/xsd/xsd/cxx/tree/validator.hxx
+++ b/xsd/xsd/cxx/tree/validator.hxx
@@ -1,13 +1,12 @@
 // file      : xsd/cxx/tree/validator.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef CXX_TREE_VALIDATOR_HXX
 #define CXX_TREE_VALIDATOR_HXX
 
 #include <cxx/tree/elements.hxx>
-#include <cxx/tree/cli.hxx>
+#include <cxx/tree/options.hxx>
 
 #include <xsd.hxx>
 
@@ -18,10 +17,8 @@ namespace CXX
     class Validator
     {
     public:
-      Validator (); // Dummy ctor, helps with long symbols on HP-UX.
-
-      Boolean
-      validate (CLI::Options const& options,
+      bool
+      validate (options const&,
                 SemanticGraph::Schema&,
                 SemanticGraph::Path const& tu,
                 const WarningSet& disabled_warnings,
diff --git a/xsd/xsd/elements.hxx b/xsd/xsd/elements.hxx
index 3a535a6..b09803f 100644
--- a/xsd/xsd/elements.hxx
+++ b/xsd/xsd/elements.hxx
@@ -1,37 +1,30 @@
 // file      : xsd/elements.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef ELEMENTS_HXX
 #define ELEMENTS_HXX
 
-#include <cult/types.hxx>
-
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
 
-using namespace Cult;
-typedef WideString String;
+#include <types.hxx>
 
 namespace SemanticGraph = XSDFrontend::SemanticGraph;
 namespace Traversal = XSDFrontend::Traversal;
 
-
 // Anonymous feedback via belongs edge.
 //
-struct AnonymousBase : Traversal::Element,
-                       Traversal::Attribute
+struct AnonymousBase : Traversal::Element, Traversal::Attribute
 {
-  AnonymousBase (Traversal::NodeDispatcherBase& d1)
+  AnonymousBase (Traversal::NodeDispatcher& d1)
       : complex_ (&d1, 0)
   {
     edge_traverser (belongs_);
     belongs_.node_traverser (complex_);
   }
 
-  AnonymousBase (Traversal::NodeDispatcherBase& d1,
-                 Traversal::NodeDispatcherBase& d2)
+  AnonymousBase (Traversal::NodeDispatcher& d1, Traversal::NodeDispatcher& d2)
       : complex_ (&d1, &d2)
   {
     edge_traverser (belongs_);
@@ -65,7 +58,7 @@ public:
 
 public:
 
-  virtual Void
+  virtual void
   traverse (SemanticGraph::Element& e)
   {
     SemanticGraph::Type& t (e.type ());
@@ -84,7 +77,7 @@ public:
     }
   }
 
-  virtual Void
+  virtual void
   traverse (SemanticGraph::Attribute& a)
   {
     SemanticGraph::Type& t (a.type ());
@@ -106,13 +99,12 @@ public:
 private:
   struct Complex : Traversal::Complex
   {
-    Complex (Traversal::NodeDispatcherBase* d1,
-             Traversal::NodeDispatcherBase* d2)
+    Complex (Traversal::NodeDispatcher* d1, Traversal::NodeDispatcher* d2)
         : d1_ (d1), d2_ (d2)
     {
     }
 
-    virtual Void
+    virtual void
     traverse (SemanticGraph::Complex& c)
     {
       if (d1_)
@@ -123,8 +115,8 @@ private:
     }
 
   private:
-    Traversal::NodeDispatcherBase* d1_;
-    Traversal::NodeDispatcherBase* d2_;
+    Traversal::NodeDispatcher* d1_;
+    Traversal::NodeDispatcher* d2_;
 
   } complex_;
 
diff --git a/xsd/xsd/makefile b/xsd/xsd/makefile
index cc04568..d57022d 100644
--- a/xsd/xsd/makefile
+++ b/xsd/xsd/makefile
@@ -1,6 +1,5 @@
 # file      : xsd/makefile
-# author    : Boris Kolpackov <boris@codesynthesis.com>
-# copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+# copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 # license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 include $(dir $(lastword $(MAKEFILE_LIST)))../build/bootstrap.make
@@ -8,7 +7,8 @@ include $(dir $(lastword $(MAKEFILE_LIST)))../build/bootstrap.make
 cxx_tun := xsd.cxx
 
 cxx_tun += cxx/elements.cxx                            \
-           cxx/literal-map.cxx
+           cxx/literal-map.cxx                         \
+           cxx/option-types.cxx
 
 cxx_tun += cxx/parser/elements.cxx                     \
            cxx/parser/validator.cxx                    \
@@ -31,6 +31,7 @@ cxx_tun += cxx/tree/elements.cxx                      \
            cxx/tree/validator.cxx                     \
            cxx/tree/counter.cxx                       \
            cxx/tree/name-processor.cxx                \
+           cxx/tree/order-processor.cxx               \
            cxx/tree/polymorphism-processor.cxx        \
 	   cxx/tree/default-value.cxx                 \
            cxx/tree/generator.cxx                     \
@@ -49,18 +50,24 @@ cxx_tun += cxx/tree/elements.cxx                      \
            cxx/tree/stream-extraction-source.cxx
 
 
-# Type map
+# Type map.
 #
 cxx_tun += type-map/lexer.cxx  \
            type-map/parser.cxx
 
-# Processing
+# Processing.
 #
 cxx_tun += processing/cardinality/processor.cxx \
            processing/inheritance/processor.cxx
 
+# Options file.
+#
+cli_tun := options.cli            \
+           cxx/options.cli        \
+           cxx/tree/options.cli   \
+           cxx/parser/options.cli
 
-cxx_obj := $(addprefix $(out_base)/,$(cxx_tun:.cxx=.o))
+cxx_obj := $(addprefix $(out_base)/,$(cxx_tun:.cxx=.o) $(cli_tun:.cli=.o))
 cxx_od  := $(cxx_obj:.o=.o.d)
 
 xsd      := $(out_base)/xsd
@@ -72,20 +79,12 @@ clean    := $(out_base)/.clean
 # Import.
 #
 $(call import,\
-  $(scf_root)/import/libcult/stub.make,\
-  l: cult.l,cpp-options: cult.l.cpp-options)
-
-$(call import,\
-  $(scf_root)/import/libbackend-elements/stub.make,\
-  l: be.l,cpp-options: be.l.cpp-options)
-
-$(call import,\
-  $(scf_root)/import/libboost/regex/stub.make,\
-  l: re.l,cpp-options: re.l.cpp-options)
+  $(scf_root)/import/cli/stub.make,\
+  cli: cli,cli-rules: cli_rules)
 
 $(call import,\
-  $(scf_root)/import/libboost/filesystem/stub.make,\
-  l: fs.l,cpp-options: fs.l.cpp-options)
+  $(scf_root)/import/libcutl/stub.make,\
+  l: cutl.l,cpp-options: cutl.l.cpp-options)
 
 $(call import,\
   $(scf_root)/import/libxsd-frontend/stub.make,\
@@ -97,18 +96,52 @@ $(call import,\
 
 # Build.
 #
-$(xsd): $(cxx_obj) $(xsd_fe.l) $(be.l) $(cult.l) $(fs.l) $(re.l) $(xerces_c.l)
+$(xsd): $(cxx_obj) $(xsd_fe.l) $(cutl.l) $(xerces_c.l)
 
-$(cxx_obj) $(cxx_od): cpp_options := -I$(src_base)
+$(cxx_obj) $(cxx_od): cpp_options := -I$(out_base) -I$(src_base)
 $(cxx_obj) $(cxx_od):      \
   $(xsd_fe.l.cpp-options)  \
-  $(be.l.cpp-options)      \
-  $(cult.l.cpp-options)    \
-  $(fs.l.cpp-options)      \
-  $(re.l.cpp-options)      \
+  $(cutl.l.cpp-options)    \
   $(xerces_c.l.cpp-options)
 
-$(call include-dep,$(cxx_od))
+genf := $(cli_tun:.cli=.hxx) $(cli_tun:.cli=.ixx) $(cli_tun:.cli=.cxx)
+gen  := $(addprefix $(out_base)/,$(genf))
+
+# Don't depend on installed executable since it may not exist.
+#
+ifneq ($(cli),cli)
+$(gen): $(cli)
+endif
+$(gen): cli := $(cli)
+$(gen): cli_options +=         \
+-I $(src_base)                 \
+--generate-specifier           \
+--ostream-type ::std::wostream \
+--exclude-base                 \
+--suppress-undocumented        \
+--generate-file-scanner        \
+--include-with-brackets        \
+--option-length 28             \
+--cxx-prologue '\#include <options-parser.hxx>'
+
+#--include-prefix xsd
+#--guard-prefix XSD
+
+$(addprefix $(out_base)/cxx/options,.hxx .ixx .cxx): $(src_base)/options.cli
+$(addprefix $(out_base)/cxx/options,.hxx .ixx .cxx): cli_options += \
+--include-prefix cxx --guard-prefix CXX
+
+$(addprefix $(out_base)/cxx/tree/options,.hxx .ixx .cxx): \
+$(src_base)/options.cli $(src_base)/cxx/options.cli
+$(addprefix $(out_base)/cxx/tree/options,.hxx .ixx .cxx): cli_options += \
+--include-prefix cxx/tree --guard-prefix CXX_TREE
+
+$(addprefix $(out_base)/cxx/parser/options,.hxx .ixx .cxx): \
+$(src_base)/options.cli $(src_base)/cxx/options.cli
+$(addprefix $(out_base)/cxx/parser/options,.hxx .ixx .cxx): cli_options += \
+--include-prefix cxx/parser --guard-prefix CXX_PARSER
+
+$(call include-dep,$(cxx_od),$(cxx_obj),$(gen))
 
 # Alias for default target.
 #
@@ -134,12 +167,16 @@ $(clean):                            \
   $(addsuffix .cxx.clean,$(cxx_obj)) \
   $(addsuffix .cxx.clean,$(cxx_od))
 
+ifneq ($(xsd_clean_gen),n)
+$(clean): $(addprefix $(out_base)/,$(cli_tun:.cli=.cxx.cli.clean))
+endif
+
 # Generated .gitignore.
 #
 ifeq ($(out_base),$(src_base))
 $(xsd): | $(out_base)/.gitignore
 
-$(out_base)/.gitignore: files := xsd
+$(out_base)/.gitignore: files := xsd $(genf)
 $(clean): $(out_base)/.gitignore.clean
 
 $(call include,$(bld_root)/git/gitignore.make)
@@ -147,6 +184,7 @@ endif
 
 # How to.
 #
+$(call include,$(cli_rules))
 $(call include,$(bld_root)/cxx/o-e.make)
 $(call include,$(bld_root)/cxx/cxx-o.make)
 $(call include,$(bld_root)/cxx/cxx-d.make)
diff --git a/xsd/xsd/options-parser.hxx b/xsd/xsd/options-parser.hxx
new file mode 100644
index 0000000..0f370cd
--- /dev/null
+++ b/xsd/xsd/options-parser.hxx
@@ -0,0 +1,30 @@
+// file      : xsd/options-parser.hxx
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef OPTIONS_PARSER_HXX
+#define OPTIONS_PARSER_HXX
+
+#include <types.hxx>
+#include <options.hxx>
+
+namespace cli
+{
+  template <>
+  struct parser<NarrowString>
+  {
+    static void
+    parse (NarrowString& x, bool& xs, scanner& s)
+    {
+      xs = true;
+      const char* o (s.next ());
+
+      if (s.more ())
+        x = s.next ();
+      else
+        throw missing_value (o);
+    }
+  };
+}
+
+#endif // OPTIONS_PARSER_HXX
diff --git a/xsd/xsd/options.cli b/xsd/xsd/options.cli
new file mode 100644
index 0000000..1ebb38e
--- /dev/null
+++ b/xsd/xsd/options.cli
@@ -0,0 +1,313 @@
+// file      : xsd/options.cli
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+include <cstddef>; // std::size_t
+
+include <types.hxx>; // NarrowString, NarrowStrings
+
+class help_options
+{
+  // These are all documented elsewhere.
+  //
+  bool --help;
+  bool --version;
+  bool --proprietary-license;
+};
+
+class options = 0
+{
+  NarrowStrings --disable-warning
+  {
+    "<warn>",
+    "Disable printing warning with id <warn>. If \cb{all} is specified for
+     the warning id then all warnings are disabled."
+  };
+
+  // The following option is "fake" in that it is actually handled by
+  // argv_file_scanner. We have it here to get the documentation.
+  //
+  std::string --options-file
+  {
+    "<file>",
+    "Read additional options from <file>. Each option should appearing on a
+     separate line optionally followed by space and an option value. Empty
+     lines and lines starting with \cb{#} are ignored. Option values can
+     be enclosed in double (\cb{\"}) or single (\cb{'}) quotes  to preserve
+     leading and trailing whitespaces as well as to specify empty values.
+     If the value itself contains trailing or leading quotes, enclose it
+     with an extra pair of quotes, for example \cb{'\"x\"'}. Non-leading
+     and non-trailing quotes are interpreted as being part of the option
+     value.
+
+     The semantics of providing options in a file is equivalent to providing
+     the same set of options in the same order on the command line at the
+     point where the \cb{--options-file} option is specified except that
+     the shell escaping and quoting is not required. You can repeat this
+     option to specify more than one options file."
+  };
+
+  // SLOC/license options.
+  //
+  bool --show-sloc
+  {
+    "Show the number of generated physical source lines of code (SLOC)."
+  };
+
+  std::size_t --sloc-limit
+  {
+    "<num>",
+    "Check that the number of generated physical source lines of code (SLOC)
+     does not exceed <num>."
+  };
+
+  bool --proprietary-license
+  {
+    "Indicate that the generated code is licensed under a proprietary
+     license instead of the GPL."
+  };
+
+  NarrowString --custom-literals
+  {
+    "<file>",
+    "Load custom XML string to C++ literal mappings from <file>. This
+     mechanism can be useful if you are using a custom character encoding
+     and some of the strings in your schemas, for example element/attribute
+     names or enumeration values, contain non-ASCII characters. In this
+     case you will need to provide a custom mapping to C++ literals for
+     such strings. The format of this file is specified in the
+     \cb{custom-literals.xsd} XML Schema file that can be found in the
+     documentation directory."
+  };
+
+  // Anonymous type morphing.
+  //
+  bool --preserve-anonymous
+  {
+    "Preserve anonymous types. By default anonymous types are automatically
+     named with names derived from the enclosing elements/attributes. Because
+     mappings implemented by this compiler require all types to be named,
+     this option is only useful if you want to make sure your schemas don't
+     have anonymous types."
+  };
+
+  bool --show-anonymous
+  {
+    "Show elements and attributes that are of anonymous types. This option
+     only makes sense together with the \cb{--preserve-anonymous} option."
+  };
+
+  NarrowStrings --anonymous-regex
+  {
+    "<regex>",
+    "Add <regex> to the list of regular expressions used to derive names for
+     anonymous types from the enclosing attributes/elements. <regex> is a
+     Perl-like regular expression in the form
+     \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}.
+     Any character can be used as a delimiter instead of \cb{/}. Escaping of
+     the delimiter character in \ci{pattern} or \ci{replacement} is not
+     supported.
+
+     All the regular expressions are pushed into a stack with the last
+     specified expression considered first. The first match that succeeds is
+     used. Regular expressions are applied to a string in the form
+
+     \c{\i{filename} \i{namespace} \i{xpath}}
+
+     For instance:
+
+     \cb{hello.xsd http://example.com/hello element}
+
+     \cb{hello.xsd http://example.com/hello type/element}
+
+     As an example, the following expression makes all the derived names
+     start with capital letters. This could be useful when your naming
+     convention requires type names to start with capital letters:
+
+     \cb{%.* .* (.+/)*(.+)%\\u$2%}
+
+     See also the REGEX AND SHELL QUOTING section below."
+  };
+
+  bool --anonymous-regex-trace
+  {
+    "Trace the process of applying regular expressions specified with the
+     \cb{--anonymous-regex} option. Use this option to find out why your
+     regular expressions don't do what you expected them to do."
+  };
+
+  bool --morph-anonymous; // Deprecated and therefore undocumented.
+
+  // Location options.
+  //
+  NarrowStrings --location-map
+  {
+    "<ol>=<nl>",
+    "Map the original schema location <ol> that is specified in the XML
+     Schema include or import elements to new schema location <nl>. Repeat
+     this option to map more than one schema location. For example, the
+     following option maps the \cb{http://example.com/foo.xsd} URL to the
+     \cb{foo.xsd} local file.
+
+     \cb{--location-map http://example.com/foo.xsd=foo.xsd}"
+  };
+
+  NarrowStrings --location-regex
+  {
+    "<regex>",
+    "Add <regex> to the list of regular expressions used to map schema
+     locations that are specified in the XML Schema include or import
+     elements. <regex> is a Perl-like regular expression in the form
+     \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. Any character can
+     be used as a delimiter instead of \cb{/}. Escaping of the delimiter
+     character in \ci{pattern} or \ci{replacement} is not supported. All
+     the regular expressions are pushed into a stack with the last specified
+     expression considered first. The first match that succeeds is used.
+
+     For example, the following expression maps URL locations in the form
+     \cb{http://example.com/foo/bar.xsd} to local files in the form
+     \cb{bar.xsd}:
+
+     \cb{%http://.+/(.+)%$1%}
+
+     See also the REGEX AND SHELL QUOTING section below."
+  };
+
+  bool --location-regex-trace
+  {
+    "Trace the process of applying regular expressions specified with the
+     \cb{--location-regex} option. Use this option to find out why your
+     regular expressions don't do what you expected them to do."
+  };
+
+  // File-per-type option.
+  //
+  bool --file-per-type
+  {
+    "Generate a separate set of C++ files for each type defined in XML
+     Schema. Note that in this mode you only need to compile the root
+     schema(s) and the code will be generated for all included and
+     imported schemas. This compilation mode is primarily useful when
+     some of your schemas cannot be compiled separately or have cyclic
+     dependencies which involve type inheritance. Other options related
+     to this mode are: \cb{--type-file-regex}, \cb{--schema-file-regex},
+     \cb{--fat-type-file}, and \cb{--file-list}."
+  };
+
+  NarrowStrings --type-file-regex
+  {
+    "<regex>",
+    "Add <regex> to the list of regular expressions used to translate type
+     names to file names when the \cb{--file-per-type} option is specified.
+     <regex> is a Perl-like regular expression in the form
+     \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. Any character can be
+     used as a delimiter instead of \cb{/}. Escaping of the delimiter
+     character in \ci{pattern} or \ci{replacement} is not supported. All
+     the regular expressions are pushed into a stack with the last specified
+     expression considered first. The first match that succeeds is used.
+     Regular expressions are applied to a string in the form
+
+     \c{\i{namespace} \i{type-name}}
+
+     For example, the following expression maps type \cb{foo} that is
+     defined in the \cb{http://example.com/bar} namespace to file name
+     \cb{bar-foo}:
+
+     \cb{%http://example.com/(.+) (.+)%$1-$2%}
+
+     See also the REGEX AND SHELL QUOTING section below."
+  };
+
+  bool --type-file-regex-trace
+  {
+    "Trace the process of applying regular expressions specified with the
+     \cb{--type-file-regex} option. Use this option to find out why your
+     regular expressions don't do what you expected them to do."
+  };
+
+  NarrowStrings --schema-file-regex
+  {
+    "<regex>",
+    "Add <regex> to the list of regular expressions used to translate schema
+     file names when the \cb{--file-per-type} option is specified. <regex> is
+     a Perl-like regular expression in the form
+     \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. Any character can be used
+     as a delimiter instead of \cb{/}. Escaping of the delimiter character in
+     \ci{pattern} or \ci{replacement} is not supported. All the regular
+     expressions are pushed into a stack with the last specified expression
+     considered first. The first match that succeeds is used. Regular
+     Expressions are applied to the absolute filesystem path of a schema file
+     and the result, including the directory part, if any, is used to derive
+     the \cb{#include} directive paths as well as the generated C++ file
+     paths. This option, along with \cb{--type-file-regex} are primarily
+     useful to place the generated files into subdirectories or to resolve
+     file name conflicts.
+
+     For example, the following expression maps schema files in the
+     \cb{foo/1.0.0/} subdirectory to the files in the \cb{foo/} subdirectory.
+     As a result, the \cb{#include} directive paths for such schemas will be
+     in the \cb{foo/schema.hxx} form and the generated C++ files will be
+     placed into the \cb{foo/} subdirectory:
+
+     \cb{%.*/foo/1.0.0/(.+)%foo/$1%}
+
+     See also the REGEX AND SHELL QUOTING section below."
+  };
+
+  bool --schema-file-regex-trace
+  {
+    "Trace the process of applying regular expressions specified with the
+     \cb{--schema-file-regex} option. Use this option to find out why your
+     regular expressions don't do what you expected them to do."
+  };
+
+  bool --fat-type-file
+  {
+    "Generate code corresponding to global elements into type files instead
+     of schema files when the \cb{--type-file-regex} option is specified.
+     This option is primarily useful when trying to minimize the amount of
+     object code that is linked to an executable by packaging compiled
+     generated code into a static (archive) library."
+  };
+
+  // File list options.
+  //
+  NarrowString --file-list
+  {
+    "<file>",
+    "Write a list of generated C++ files to <file>. This option is primarily
+     useful in the file-per-type compilation mode (\cb{--file-per-type}) to
+     create a list of generated C++ files, for example, as a makefile
+     fragment."
+  };
+
+  NarrowString --file-list-prologue
+  {
+    "<text>",
+    "Insert <text> at the beginning of the file list. As a convenience, all
+     occurrences of the \cb{\\n} character sequence in <text> are replaced
+     with new lines. This option can, for example, be used to assign the
+     generated file list to a makefile variable."
+  };
+
+  NarrowString --file-list-epilogue
+  {
+    "<text>",
+    "Insert <text> at the end of the file list. As a convenience, all
+     occurrences of the \cb{\\n} character sequence in <text> are replaced
+     with new lines."
+  };
+
+  NarrowString --file-list-delim = "\n"
+  {
+    "<text>",
+    "Delimit file names written to the file list with <text> instead of new
+     lines. As a convenience, all occurrences of the \cb{\\n} character
+     sequence in <text> are replaced with new lines."
+  };
+
+  // Undocumented.
+  //
+  bool --disable-multi-import;
+  bool --disable-full-check;
+};
diff --git a/xsd/xsd/options.cxx b/xsd/xsd/options.cxx
new file mode 100644
index 0000000..3af99f2
--- /dev/null
+++ b/xsd/xsd/options.cxx
@@ -0,0 +1,976 @@
+// This code was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <options-parser.hxx>
+//
+// End prologue.
+
+#include <options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+#include <fstream>
+
+namespace cli
+{
+  // unknown_option
+  //
+  unknown_option::
+  ~unknown_option () throw ()
+  {
+  }
+
+  void unknown_option::
+  print (::std::wostream& os) const
+  {
+    os << "unknown option '" << option ().c_str () << "'";
+  }
+
+  const char* unknown_option::
+  what () const throw ()
+  {
+    return "unknown option";
+  }
+
+  // unknown_argument
+  //
+  unknown_argument::
+  ~unknown_argument () throw ()
+  {
+  }
+
+  void unknown_argument::
+  print (::std::wostream& os) const
+  {
+    os << "unknown argument '" << argument ().c_str () << "'";
+  }
+
+  const char* unknown_argument::
+  what () const throw ()
+  {
+    return "unknown argument";
+  }
+
+  // missing_value
+  //
+  missing_value::
+  ~missing_value () throw ()
+  {
+  }
+
+  void missing_value::
+  print (::std::wostream& os) const
+  {
+    os << "missing value for option '" << option ().c_str () << "'";
+  }
+
+  const char* missing_value::
+  what () const throw ()
+  {
+    return "missing option value";
+  }
+
+  // invalid_value
+  //
+  invalid_value::
+  ~invalid_value () throw ()
+  {
+  }
+
+  void invalid_value::
+  print (::std::wostream& os) const
+  {
+    os << "invalid value '" << value ().c_str () << "' for option '"
+       << option ().c_str () << "'";
+  }
+
+  const char* invalid_value::
+  what () const throw ()
+  {
+    return "invalid option value";
+  }
+
+  // eos_reached
+  //
+  void eos_reached::
+  print (::std::wostream& os) const
+  {
+    os << what ();
+  }
+
+  const char* eos_reached::
+  what () const throw ()
+  {
+    return "end of argument stream reached";
+  }
+
+  // file_io_failure
+  //
+  file_io_failure::
+  ~file_io_failure () throw ()
+  {
+  }
+
+  void file_io_failure::
+  print (::std::wostream& os) const
+  {
+    os << "unable to open file '" << file ().c_str () << "' or read failure";
+  }
+
+  const char* file_io_failure::
+  what () const throw ()
+  {
+    return "unable to open file or read failure";
+  }
+
+  // unmatched_quote
+  //
+  unmatched_quote::
+  ~unmatched_quote () throw ()
+  {
+  }
+
+  void unmatched_quote::
+  print (::std::wostream& os) const
+  {
+    os << "unmatched quote in argument '" << argument ().c_str () << "'";
+  }
+
+  const char* unmatched_quote::
+  what () const throw ()
+  {
+    return "unmatched quote";
+  }
+
+  // scanner
+  //
+  scanner::
+  ~scanner ()
+  {
+  }
+
+  // argv_scanner
+  //
+  bool argv_scanner::
+  more ()
+  {
+    return i_ < argc_;
+  }
+
+  const char* argv_scanner::
+  peek ()
+  {
+    if (i_ < argc_)
+      return argv_[i_];
+    else
+      throw eos_reached ();
+  }
+
+  const char* argv_scanner::
+  next ()
+  {
+    if (i_ < argc_)
+    {
+      const char* r (argv_[i_]);
+
+      if (erase_)
+      {
+        for (int i (i_ + 1); i < argc_; ++i)
+          argv_[i - 1] = argv_[i];
+
+        --argc_;
+        argv_[argc_] = 0;
+      }
+      else
+        ++i_;
+
+      return r;
+    }
+    else
+      throw eos_reached ();
+  }
+
+  void argv_scanner::
+  skip ()
+  {
+    if (i_ < argc_)
+      ++i_;
+    else
+      throw eos_reached ();
+  }
+
+  // argv_file_scanner
+  //
+  bool argv_file_scanner::
+  more ()
+  {
+    if (!args_.empty ())
+      return true;
+
+    while (base::more ())
+    {
+      // See if the next argument is the file option.
+      //
+      const char* a (base::peek ());
+      const option_info* oi;
+
+      if (!skip_ && (oi = find (a)))
+      {
+        base::next ();
+
+        if (!base::more ())
+          throw missing_value (oi->option);
+
+        if (oi->search_func != 0)
+        {
+          std::string f (oi->search_func (base::next (), oi->arg));
+
+          if (!f.empty ())
+            load (f);
+        }
+        else
+          load (base::next ());
+
+        if (!args_.empty ())
+          return true;
+      }
+      else
+      {
+        if (!skip_)
+          skip_ = (std::strcmp (a, "--") == 0);
+
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  const char* argv_file_scanner::
+  peek ()
+  {
+    if (!more ())
+      throw eos_reached ();
+
+    return args_.empty () ? base::peek () : args_.front ().c_str ();
+  }
+
+  const char* argv_file_scanner::
+  next ()
+  {
+    if (!more ())
+      throw eos_reached ();
+
+    if (args_.empty ())
+      return base::next ();
+    else
+    {
+      hold_.swap (args_.front ());
+      args_.pop_front ();
+      return hold_.c_str ();
+    }
+  }
+
+  void argv_file_scanner::
+  skip ()
+  {
+    if (!more ())
+      throw eos_reached ();
+
+    if (args_.empty ())
+      return base::skip ();
+    else
+      args_.pop_front ();
+  }
+
+  const argv_file_scanner::option_info* argv_file_scanner::
+  find (const char* a) const
+  {
+    for (std::size_t i (0); i < options_count_; ++i)
+      if (std::strcmp (a, options_[i].option) == 0)
+        return &options_[i];
+
+    return 0;
+  }
+
+  void argv_file_scanner::
+  load (const std::string& file)
+  {
+    using namespace std;
+
+    ifstream is (file.c_str ());
+
+    if (!is.is_open ())
+      throw file_io_failure (file);
+
+    while (!is.eof ())
+    {
+      string line;
+      getline (is, line);
+
+      if (is.fail () && !is.eof ())
+        throw file_io_failure (file);
+
+      string::size_type n (line.size ());
+
+      // Trim the line from leading and trailing whitespaces.
+      //
+      if (n != 0)
+      {
+        const char* f (line.c_str ());
+        const char* l (f + n);
+
+        const char* of (f);
+        while (f < l && (*f == ' ' || *f == '\t' || *f == '\r'))
+          ++f;
+
+        --l;
+
+        const char* ol (l);
+        while (l > f && (*l == ' ' || *l == '\t' || *l == '\r'))
+          --l;
+
+        if (f != of || l != ol)
+          line = f <= l ? string (f, l - f + 1) : string ();
+      }
+
+      // Ignore empty lines, those that start with #.
+      //
+      if (line.empty () || line[0] == '#')
+        continue;
+
+      string::size_type p (line.find (' '));
+
+      if (p == string::npos)
+      {
+        if (!skip_)
+          skip_ = (line == "--");
+
+        args_.push_back (line);
+      }
+      else
+      {
+        string s1 (line, 0, p);
+
+        // Skip leading whitespaces in the argument.
+        //
+        n = line.size ();
+        for (++p; p < n; ++p)
+        {
+          char c (line[p]);
+
+          if (c != ' ' && c != '\t' && c != '\r')
+            break;
+        }
+
+        string s2 (line, p);
+
+        // If the string is wrapped in quotes, remove them.
+        //
+        n = s2.size ();
+        char cf (s2[0]), cl (s2[n - 1]);
+
+        if (cf == '"' || cf == '\'' || cl == '"' || cl == '\'')
+        {
+          if (n == 1 || cf != cl)
+            throw unmatched_quote (s2);
+
+          s2 = string (s2, 1, n - 2);
+        }
+
+        const option_info* oi;
+        if (!skip_ && (oi = find (s1.c_str ())))
+        {
+          if (s2.empty ())
+            throw missing_value (oi->option);
+
+          if (oi->search_func != 0)
+          {
+            std::string f (oi->search_func (s2.c_str (), oi->arg));
+
+            if (!f.empty ())
+              load (f);
+          }
+          else
+            load (s2);
+        }
+        else
+        {
+          args_.push_back (s1);
+          args_.push_back (s2);
+        }
+      }
+    }
+  }
+
+  template <typename X>
+  struct parser
+  {
+    static void
+    parse (X& x, bool& xs, scanner& s)
+    {
+      std::string o (s.next ());
+
+      if (s.more ())
+      {
+        std::string v (s.next ());
+        std::istringstream is (v);
+        if (!(is >> x && is.eof ()))
+          throw invalid_value (o, v);
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <>
+  struct parser<bool>
+  {
+    static void
+    parse (bool& x, scanner& s)
+    {
+      s.next ();
+      x = true;
+    }
+  };
+
+  template <>
+  struct parser<std::string>
+  {
+    static void
+    parse (std::string& x, bool& xs, scanner& s)
+    {
+      const char* o (s.next ());
+
+      if (s.more ())
+        x = s.next ();
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X>
+  struct parser<std::vector<X> >
+  {
+    static void
+    parse (std::vector<X>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.push_back (x);
+      xs = true;
+    }
+  };
+
+  template <typename X>
+  struct parser<std::set<X> >
+  {
+    static void
+    parse (std::set<X>& c, bool& xs, scanner& s)
+    {
+      X x;
+      bool dummy;
+      parser<X>::parse (x, dummy, s);
+      c.insert (x);
+      xs = true;
+    }
+  };
+
+  template <typename K, typename V>
+  struct parser<std::map<K, V> >
+  {
+    static void
+    parse (std::map<K, V>& m, bool& xs, scanner& s)
+    {
+      std::string o (s.next ());
+
+      if (s.more ())
+      {
+        std::string ov (s.next ());
+        std::string::size_type p = ov.find ('=');
+
+        if (p == std::string::npos)
+        {
+          K k = K ();
+
+          if (!ov.empty ())
+          {
+            std::istringstream ks (ov);
+
+            if (!(ks >> k && ks.eof ()))
+              throw invalid_value (o, ov);
+          }
+
+          m[k] = V ();
+        }
+        else
+        {
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, p + 1);
+
+          if (!kstr.empty ())
+          {
+            std::istringstream ks (kstr);
+
+            if (!(ks >> k && ks.eof ()))
+              throw invalid_value (o, ov);
+          }
+
+          if (!vstr.empty ())
+          {
+            std::istringstream vs (vstr);
+
+            if (!(vs >> v && vs.eof ()))
+              throw invalid_value (o, ov);
+          }
+
+          m[k] = v;
+        }
+      }
+      else
+        throw missing_value (o);
+
+      xs = true;
+    }
+  };
+
+  template <typename X, typename T, T X::*M>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, s);
+  }
+
+  template <typename X, typename T, T X::*M, bool X::*S>
+  void
+  thunk (X& x, scanner& s)
+  {
+    parser<T>::parse (x.*M, x.*S, s);
+  }
+}
+
+#include <map>
+#include <cstring>
+
+// help_options
+//
+
+help_options::
+help_options ()
+: help_ (),
+  version_ (),
+  proprietary_license_ ()
+{
+}
+
+help_options::
+help_options (int& argc,
+              char** argv,
+              bool erase,
+              ::cli::unknown_mode opt,
+              ::cli::unknown_mode arg)
+: help_ (),
+  version_ (),
+  proprietary_license_ ()
+{
+  ::cli::argv_scanner s (argc, argv, erase);
+  _parse (s, opt, arg);
+}
+
+help_options::
+help_options (int start,
+              int& argc,
+              char** argv,
+              bool erase,
+              ::cli::unknown_mode opt,
+              ::cli::unknown_mode arg)
+: help_ (),
+  version_ (),
+  proprietary_license_ ()
+{
+  ::cli::argv_scanner s (start, argc, argv, erase);
+  _parse (s, opt, arg);
+}
+
+help_options::
+help_options (int& argc,
+              char** argv,
+              int& end,
+              bool erase,
+              ::cli::unknown_mode opt,
+              ::cli::unknown_mode arg)
+: help_ (),
+  version_ (),
+  proprietary_license_ ()
+{
+  ::cli::argv_scanner s (argc, argv, erase);
+  _parse (s, opt, arg);
+  end = s.end ();
+}
+
+help_options::
+help_options (int start,
+              int& argc,
+              char** argv,
+              int& end,
+              bool erase,
+              ::cli::unknown_mode opt,
+              ::cli::unknown_mode arg)
+: help_ (),
+  version_ (),
+  proprietary_license_ ()
+{
+  ::cli::argv_scanner s (start, argc, argv, erase);
+  _parse (s, opt, arg);
+  end = s.end ();
+}
+
+help_options::
+help_options (::cli::scanner& s,
+              ::cli::unknown_mode opt,
+              ::cli::unknown_mode arg)
+: help_ (),
+  version_ (),
+  proprietary_license_ ()
+{
+  _parse (s, opt, arg);
+}
+
+void help_options::
+print_usage (::std::wostream&)
+{
+}
+
+typedef
+std::map<std::string, void (*) (help_options&, ::cli::scanner&)>
+_cli_help_options_map;
+
+static _cli_help_options_map _cli_help_options_map_;
+
+struct _cli_help_options_map_init
+{
+  _cli_help_options_map_init ()
+  {
+    _cli_help_options_map_["--help"] = 
+    &::cli::thunk< help_options, bool, &help_options::help_ >;
+    _cli_help_options_map_["--version"] = 
+    &::cli::thunk< help_options, bool, &help_options::version_ >;
+    _cli_help_options_map_["--proprietary-license"] = 
+    &::cli::thunk< help_options, bool, &help_options::proprietary_license_ >;
+  }
+};
+
+static _cli_help_options_map_init _cli_help_options_map_init_;
+
+bool help_options::
+_parse (const char* o, ::cli::scanner& s)
+{
+  _cli_help_options_map::const_iterator i (_cli_help_options_map_.find (o));
+
+  if (i != _cli_help_options_map_.end ())
+  {
+    (*(i->second)) (*this, s);
+    return true;
+  }
+
+  return false;
+}
+
+void help_options::
+_parse (::cli::scanner& s,
+        ::cli::unknown_mode opt_mode,
+        ::cli::unknown_mode arg_mode)
+{
+  bool opt = true;
+
+  while (s.more ())
+  {
+    const char* o = s.peek ();
+
+    if (std::strcmp (o, "--") == 0)
+    {
+      s.skip ();
+      opt = false;
+      continue;
+    }
+
+    if (opt && _parse (o, s));
+    else if (opt && std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+    {
+      switch (opt_mode)
+      {
+        case ::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          continue;
+        }
+        case ::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::cli::unknown_mode::fail:
+        {
+          throw ::cli::unknown_option (o);
+        }
+      }
+
+      break;
+    }
+    else
+    {
+      switch (arg_mode)
+      {
+        case ::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          continue;
+        }
+        case ::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::cli::unknown_mode::fail:
+        {
+          throw ::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+  }
+}
+
+// options
+//
+
+options::
+options ()
+: disable_warning_ (),
+  disable_warning_specified_ (false),
+  options_file_ (),
+  options_file_specified_ (false),
+  show_sloc_ (),
+  sloc_limit_ (),
+  sloc_limit_specified_ (false),
+  proprietary_license_ (),
+  custom_literals_ (),
+  custom_literals_specified_ (false),
+  preserve_anonymous_ (),
+  show_anonymous_ (),
+  anonymous_regex_ (),
+  anonymous_regex_specified_ (false),
+  anonymous_regex_trace_ (),
+  morph_anonymous_ (),
+  location_map_ (),
+  location_map_specified_ (false),
+  location_regex_ (),
+  location_regex_specified_ (false),
+  location_regex_trace_ (),
+  file_per_type_ (),
+  type_file_regex_ (),
+  type_file_regex_specified_ (false),
+  type_file_regex_trace_ (),
+  schema_file_regex_ (),
+  schema_file_regex_specified_ (false),
+  schema_file_regex_trace_ (),
+  fat_type_file_ (),
+  file_list_ (),
+  file_list_specified_ (false),
+  file_list_prologue_ (),
+  file_list_prologue_specified_ (false),
+  file_list_epilogue_ (),
+  file_list_epilogue_specified_ (false),
+  file_list_delim_ ("\n"),
+  file_list_delim_specified_ (false),
+  disable_multi_import_ (),
+  disable_full_check_ ()
+{
+}
+
+void options::
+print_usage (::std::wostream& os)
+{
+  os << "--disable-warning <warn>     Disable printing warning with id <warn>." << ::std::endl;
+
+  os << "--options-file <file>        Read additional options from <file>." << ::std::endl;
+
+  os << "--show-sloc                  Show the number of generated physical source lines" << ::std::endl
+     << "                             of code (SLOC)." << ::std::endl;
+
+  os << "--sloc-limit <num>           Check that the number of generated physical source" << ::std::endl
+     << "                             lines of code (SLOC) does not exceed <num>." << ::std::endl;
+
+  os << "--proprietary-license        Indicate that the generated code is licensed under" << ::std::endl
+     << "                             a proprietary license instead of the GPL." << ::std::endl;
+
+  os << "--custom-literals <file>     Load custom XML string to C++ literal mappings" << ::std::endl
+     << "                             from <file>." << ::std::endl;
+
+  os << "--preserve-anonymous         Preserve anonymous types." << ::std::endl;
+
+  os << "--show-anonymous             Show elements and attributes that are of anonymous" << ::std::endl
+     << "                             types." << ::std::endl;
+
+  os << "--anonymous-regex <regex>    Add <regex> to the list of regular expressions" << ::std::endl
+     << "                             used to derive names for anonymous types from the" << ::std::endl
+     << "                             enclosing attributes/elements." << ::std::endl;
+
+  os << "--anonymous-regex-trace      Trace the process of applying regular expressions" << ::std::endl
+     << "                             specified with the '--anonymous-regex' option." << ::std::endl;
+
+  os << "--location-map <ol>=<nl>     Map the original schema location <ol> that is" << ::std::endl
+     << "                             specified in the XML Schema include or import" << ::std::endl
+     << "                             elements to new schema location <nl>." << ::std::endl;
+
+  os << "--location-regex <regex>     Add <regex> to the list of regular expressions" << ::std::endl
+     << "                             used to map schema locations that are specified in" << ::std::endl
+     << "                             the XML Schema include or import elements." << ::std::endl;
+
+  os << "--location-regex-trace       Trace the process of applying regular expressions" << ::std::endl
+     << "                             specified with the '--location-regex' option." << ::std::endl;
+
+  os << "--file-per-type              Generate a separate set of C++ files for each type" << ::std::endl
+     << "                             defined in XML Schema." << ::std::endl;
+
+  os << "--type-file-regex <regex>    Add <regex> to the list of regular expressions" << ::std::endl
+     << "                             used to translate type names to file names when" << ::std::endl
+     << "                             the '--file-per-type' option is specified." << ::std::endl;
+
+  os << "--type-file-regex-trace      Trace the process of applying regular expressions" << ::std::endl
+     << "                             specified with the '--type-file-regex' option." << ::std::endl;
+
+  os << "--schema-file-regex <regex>  Add <regex> to the list of regular expressions" << ::std::endl
+     << "                             used to translate schema file names when the" << ::std::endl
+     << "                             '--file-per-type' option is specified." << ::std::endl;
+
+  os << "--schema-file-regex-trace    Trace the process of applying regular expressions" << ::std::endl
+     << "                             specified with the '--schema-file-regex' option." << ::std::endl;
+
+  os << "--fat-type-file              Generate code corresponding to global elements" << ::std::endl
+     << "                             into type files instead of schema files when the" << ::std::endl
+     << "                             '--type-file-regex' option is specified." << ::std::endl;
+
+  os << "--file-list <file>           Write a list of generated C++ files to <file>." << ::std::endl;
+
+  os << "--file-list-prologue <text>  Insert <text> at the beginning of the file list." << ::std::endl;
+
+  os << "--file-list-epilogue <text>  Insert <text> at the end of the file list." << ::std::endl;
+
+  os << "--file-list-delim <text>     Delimit file names written to the file list with" << ::std::endl
+     << "                             <text> instead of new lines." << ::std::endl;
+}
+
+typedef
+std::map<std::string, void (*) (options&, ::cli::scanner&)>
+_cli_options_map;
+
+static _cli_options_map _cli_options_map_;
+
+struct _cli_options_map_init
+{
+  _cli_options_map_init ()
+  {
+    _cli_options_map_["--disable-warning"] = 
+    &::cli::thunk< options, NarrowStrings, &options::disable_warning_,
+      &options::disable_warning_specified_ >;
+    _cli_options_map_["--options-file"] = 
+    &::cli::thunk< options, std::string, &options::options_file_,
+      &options::options_file_specified_ >;
+    _cli_options_map_["--show-sloc"] = 
+    &::cli::thunk< options, bool, &options::show_sloc_ >;
+    _cli_options_map_["--sloc-limit"] = 
+    &::cli::thunk< options, std::size_t, &options::sloc_limit_,
+      &options::sloc_limit_specified_ >;
+    _cli_options_map_["--proprietary-license"] = 
+    &::cli::thunk< options, bool, &options::proprietary_license_ >;
+    _cli_options_map_["--custom-literals"] = 
+    &::cli::thunk< options, NarrowString, &options::custom_literals_,
+      &options::custom_literals_specified_ >;
+    _cli_options_map_["--preserve-anonymous"] = 
+    &::cli::thunk< options, bool, &options::preserve_anonymous_ >;
+    _cli_options_map_["--show-anonymous"] = 
+    &::cli::thunk< options, bool, &options::show_anonymous_ >;
+    _cli_options_map_["--anonymous-regex"] = 
+    &::cli::thunk< options, NarrowStrings, &options::anonymous_regex_,
+      &options::anonymous_regex_specified_ >;
+    _cli_options_map_["--anonymous-regex-trace"] = 
+    &::cli::thunk< options, bool, &options::anonymous_regex_trace_ >;
+    _cli_options_map_["--morph-anonymous"] = 
+    &::cli::thunk< options, bool, &options::morph_anonymous_ >;
+    _cli_options_map_["--location-map"] = 
+    &::cli::thunk< options, NarrowStrings, &options::location_map_,
+      &options::location_map_specified_ >;
+    _cli_options_map_["--location-regex"] = 
+    &::cli::thunk< options, NarrowStrings, &options::location_regex_,
+      &options::location_regex_specified_ >;
+    _cli_options_map_["--location-regex-trace"] = 
+    &::cli::thunk< options, bool, &options::location_regex_trace_ >;
+    _cli_options_map_["--file-per-type"] = 
+    &::cli::thunk< options, bool, &options::file_per_type_ >;
+    _cli_options_map_["--type-file-regex"] = 
+    &::cli::thunk< options, NarrowStrings, &options::type_file_regex_,
+      &options::type_file_regex_specified_ >;
+    _cli_options_map_["--type-file-regex-trace"] = 
+    &::cli::thunk< options, bool, &options::type_file_regex_trace_ >;
+    _cli_options_map_["--schema-file-regex"] = 
+    &::cli::thunk< options, NarrowStrings, &options::schema_file_regex_,
+      &options::schema_file_regex_specified_ >;
+    _cli_options_map_["--schema-file-regex-trace"] = 
+    &::cli::thunk< options, bool, &options::schema_file_regex_trace_ >;
+    _cli_options_map_["--fat-type-file"] = 
+    &::cli::thunk< options, bool, &options::fat_type_file_ >;
+    _cli_options_map_["--file-list"] = 
+    &::cli::thunk< options, NarrowString, &options::file_list_,
+      &options::file_list_specified_ >;
+    _cli_options_map_["--file-list-prologue"] = 
+    &::cli::thunk< options, NarrowString, &options::file_list_prologue_,
+      &options::file_list_prologue_specified_ >;
+    _cli_options_map_["--file-list-epilogue"] = 
+    &::cli::thunk< options, NarrowString, &options::file_list_epilogue_,
+      &options::file_list_epilogue_specified_ >;
+    _cli_options_map_["--file-list-delim"] = 
+    &::cli::thunk< options, NarrowString, &options::file_list_delim_,
+      &options::file_list_delim_specified_ >;
+    _cli_options_map_["--disable-multi-import"] = 
+    &::cli::thunk< options, bool, &options::disable_multi_import_ >;
+    _cli_options_map_["--disable-full-check"] = 
+    &::cli::thunk< options, bool, &options::disable_full_check_ >;
+  }
+};
+
+static _cli_options_map_init _cli_options_map_init_;
+
+bool options::
+_parse (const char* o, ::cli::scanner& s)
+{
+  _cli_options_map::const_iterator i (_cli_options_map_.find (o));
+
+  if (i != _cli_options_map_.end ())
+  {
+    (*(i->second)) (*this, s);
+    return true;
+  }
+
+  return false;
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/xsd/xsd/options.hxx b/xsd/xsd/options.hxx
new file mode 100644
index 0000000..ed243bc
--- /dev/null
+++ b/xsd/xsd/options.hxx
@@ -0,0 +1,575 @@
+// This code was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef OPTIONS_HXX
+#define OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <deque>
+#include <iosfwd>
+#include <string>
+#include <cstddef>
+#include <exception>
+
+namespace cli
+{
+  class unknown_mode
+  {
+    public:
+    enum value
+    {
+      skip,
+      stop,
+      fail
+    };
+
+    unknown_mode (value v);
+
+    operator value () const 
+    {
+      return v_;
+    }
+
+    private:
+    value v_;
+  };
+
+  // Exceptions.
+  //
+
+  class exception: public std::exception
+  {
+    public:
+    virtual void
+    print (::std::wostream&) const = 0;
+  };
+
+  ::std::wostream&
+  operator<< (::std::wostream&, const exception&);
+
+  class unknown_option: public exception
+  {
+    public:
+    virtual
+    ~unknown_option () throw ();
+
+    unknown_option (const std::string& option);
+
+    const std::string&
+    option () const;
+
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const throw ();
+
+    private:
+    std::string option_;
+  };
+
+  class unknown_argument: public exception
+  {
+    public:
+    virtual
+    ~unknown_argument () throw ();
+
+    unknown_argument (const std::string& argument);
+
+    const std::string&
+    argument () const;
+
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const throw ();
+
+    private:
+    std::string argument_;
+  };
+
+  class missing_value: public exception
+  {
+    public:
+    virtual
+    ~missing_value () throw ();
+
+    missing_value (const std::string& option);
+
+    const std::string&
+    option () const;
+
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const throw ();
+
+    private:
+    std::string option_;
+  };
+
+  class invalid_value: public exception
+  {
+    public:
+    virtual
+    ~invalid_value () throw ();
+
+    invalid_value (const std::string& option,
+                   const std::string& value);
+
+    const std::string&
+    option () const;
+
+    const std::string&
+    value () const;
+
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const throw ();
+
+    private:
+    std::string option_;
+    std::string value_;
+  };
+
+  class eos_reached: public exception
+  {
+    public:
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const throw ();
+  };
+
+  class file_io_failure: public exception
+  {
+    public:
+    virtual
+    ~file_io_failure () throw ();
+
+    file_io_failure (const std::string& file);
+
+    const std::string&
+    file () const;
+
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const throw ();
+
+    private:
+    std::string file_;
+  };
+
+  class unmatched_quote: public exception
+  {
+    public:
+    virtual
+    ~unmatched_quote () throw ();
+
+    unmatched_quote (const std::string& argument);
+
+    const std::string&
+    argument () const;
+
+    virtual void
+    print (::std::wostream&) const;
+
+    virtual const char*
+    what () const throw ();
+
+    private:
+    std::string argument_;
+  };
+
+  class scanner
+  {
+    public:
+    virtual
+    ~scanner ();
+
+    virtual bool
+    more () = 0;
+
+    virtual const char*
+    peek () = 0;
+
+    virtual const char*
+    next () = 0;
+
+    virtual void
+    skip () = 0;
+  };
+
+  class argv_scanner: public scanner
+  {
+    public:
+    argv_scanner (int& argc, char** argv, bool erase = false);
+    argv_scanner (int start, int& argc, char** argv, bool erase = false);
+
+    int
+    end () const;
+
+    virtual bool
+    more ();
+
+    virtual const char*
+    peek ();
+
+    virtual const char*
+    next ();
+
+    virtual void
+    skip ();
+
+    private:
+    int i_;
+    int& argc_;
+    char** argv_;
+    bool erase_;
+  };
+
+  class argv_file_scanner: public argv_scanner
+  {
+    public:
+    argv_file_scanner (int& argc,
+                       char** argv,
+                       const std::string& option,
+                       bool erase = false);
+
+    argv_file_scanner (int start,
+                       int& argc,
+                       char** argv,
+                       const std::string& option,
+                       bool erase = false);
+
+    struct option_info
+    {
+      // If search_func is not NULL, it is called, with the arg
+      // value as the second argument, to locate the options file.
+      // If it returns an empty string, then the file is ignored.
+      //
+      const char* option;
+      std::string (*search_func) (const char*, void* arg);
+      void* arg;
+    };
+
+    argv_file_scanner (int& argc,
+                        char** argv,
+                        const option_info* options,
+                        std::size_t options_count,
+                        bool erase = false);
+
+    argv_file_scanner (int start,
+                       int& argc,
+                       char** argv,
+                       const option_info* options,
+                       std::size_t options_count,
+                       bool erase = false);
+
+    virtual bool
+    more ();
+
+    virtual const char*
+    peek ();
+
+    virtual const char*
+    next ();
+
+    virtual void
+    skip ();
+
+    private:
+    const option_info*
+    find (const char*) const;
+
+    void
+    load (const std::string& file);
+
+    typedef argv_scanner base;
+
+    const std::string option_;
+    option_info option_info_;
+    const option_info* options_;
+    std::size_t options_count_;
+
+    std::string hold_;
+    std::deque<std::string> args_;
+    bool skip_;
+  };
+
+  template <typename X>
+  struct parser;
+}
+
+#include <cstddef>
+
+#include <types.hxx>
+
+class help_options
+{
+  public:
+  help_options (int& argc,
+                char** argv,
+                bool erase = false,
+                ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+                ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+  help_options (int start,
+                int& argc,
+                char** argv,
+                bool erase = false,
+                ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+                ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+  help_options (int& argc,
+                char** argv,
+                int& end,
+                bool erase = false,
+                ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+                ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+  help_options (int start,
+                int& argc,
+                char** argv,
+                int& end,
+                bool erase = false,
+                ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+                ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+  help_options (::cli::scanner&,
+                ::cli::unknown_mode option = ::cli::unknown_mode::fail,
+                ::cli::unknown_mode argument = ::cli::unknown_mode::stop);
+
+  help_options ();
+
+  // Option accessors.
+  //
+  const bool&
+  help () const;
+
+  const bool&
+  version () const;
+
+  const bool&
+  proprietary_license () const;
+
+  // Print usage information.
+  //
+  static void
+  print_usage (::std::wostream&);
+
+  // Implementation details.
+  //
+  protected:
+  bool
+  _parse (const char*, ::cli::scanner&);
+
+  private:
+  void
+  _parse (::cli::scanner&,
+          ::cli::unknown_mode option,
+          ::cli::unknown_mode argument);
+
+  public:
+  bool help_;
+  bool version_;
+  bool proprietary_license_;
+};
+
+class options
+{
+  public:
+  // Option accessors.
+  //
+  const NarrowStrings&
+  disable_warning () const;
+
+  bool
+  disable_warning_specified () const;
+
+  const std::string&
+  options_file () const;
+
+  bool
+  options_file_specified () const;
+
+  const bool&
+  show_sloc () const;
+
+  const std::size_t&
+  sloc_limit () const;
+
+  bool
+  sloc_limit_specified () const;
+
+  const bool&
+  proprietary_license () const;
+
+  const NarrowString&
+  custom_literals () const;
+
+  bool
+  custom_literals_specified () const;
+
+  const bool&
+  preserve_anonymous () const;
+
+  const bool&
+  show_anonymous () const;
+
+  const NarrowStrings&
+  anonymous_regex () const;
+
+  bool
+  anonymous_regex_specified () const;
+
+  const bool&
+  anonymous_regex_trace () const;
+
+  const bool&
+  morph_anonymous () const;
+
+  const NarrowStrings&
+  location_map () const;
+
+  bool
+  location_map_specified () const;
+
+  const NarrowStrings&
+  location_regex () const;
+
+  bool
+  location_regex_specified () const;
+
+  const bool&
+  location_regex_trace () const;
+
+  const bool&
+  file_per_type () const;
+
+  const NarrowStrings&
+  type_file_regex () const;
+
+  bool
+  type_file_regex_specified () const;
+
+  const bool&
+  type_file_regex_trace () const;
+
+  const NarrowStrings&
+  schema_file_regex () const;
+
+  bool
+  schema_file_regex_specified () const;
+
+  const bool&
+  schema_file_regex_trace () const;
+
+  const bool&
+  fat_type_file () const;
+
+  const NarrowString&
+  file_list () const;
+
+  bool
+  file_list_specified () const;
+
+  const NarrowString&
+  file_list_prologue () const;
+
+  bool
+  file_list_prologue_specified () const;
+
+  const NarrowString&
+  file_list_epilogue () const;
+
+  bool
+  file_list_epilogue_specified () const;
+
+  const NarrowString&
+  file_list_delim () const;
+
+  bool
+  file_list_delim_specified () const;
+
+  const bool&
+  disable_multi_import () const;
+
+  const bool&
+  disable_full_check () const;
+
+  // Print usage information.
+  //
+  static void
+  print_usage (::std::wostream&);
+
+  // Implementation details.
+  //
+  protected:
+  options ();
+
+  bool
+  _parse (const char*, ::cli::scanner&);
+
+  public:
+  NarrowStrings disable_warning_;
+  bool disable_warning_specified_;
+  std::string options_file_;
+  bool options_file_specified_;
+  bool show_sloc_;
+  std::size_t sloc_limit_;
+  bool sloc_limit_specified_;
+  bool proprietary_license_;
+  NarrowString custom_literals_;
+  bool custom_literals_specified_;
+  bool preserve_anonymous_;
+  bool show_anonymous_;
+  NarrowStrings anonymous_regex_;
+  bool anonymous_regex_specified_;
+  bool anonymous_regex_trace_;
+  bool morph_anonymous_;
+  NarrowStrings location_map_;
+  bool location_map_specified_;
+  NarrowStrings location_regex_;
+  bool location_regex_specified_;
+  bool location_regex_trace_;
+  bool file_per_type_;
+  NarrowStrings type_file_regex_;
+  bool type_file_regex_specified_;
+  bool type_file_regex_trace_;
+  NarrowStrings schema_file_regex_;
+  bool schema_file_regex_specified_;
+  bool schema_file_regex_trace_;
+  bool fat_type_file_;
+  NarrowString file_list_;
+  bool file_list_specified_;
+  NarrowString file_list_prologue_;
+  bool file_list_prologue_specified_;
+  NarrowString file_list_epilogue_;
+  bool file_list_epilogue_specified_;
+  NarrowString file_list_delim_;
+  bool file_list_delim_specified_;
+  bool disable_multi_import_;
+  bool disable_full_check_;
+};
+
+#include <options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // OPTIONS_HXX
diff --git a/xsd/xsd/options.ixx b/xsd/xsd/options.ixx
new file mode 100644
index 0000000..f30c651
--- /dev/null
+++ b/xsd/xsd/options.ixx
@@ -0,0 +1,462 @@
+// This code was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace cli
+{
+  // unknown_mode
+  //
+  inline unknown_mode::
+  unknown_mode (value v)
+  : v_ (v)
+  {
+  }
+
+  // exception
+  //
+  inline ::std::wostream&
+  operator<< (::std::wostream& os, const exception& e)
+  {
+    e.print (os);
+    return os;
+  }
+
+  // unknown_option
+  //
+  inline unknown_option::
+  unknown_option (const std::string& option)
+  : option_ (option)
+  {
+  }
+
+  inline const std::string& unknown_option::
+  option () const
+  {
+    return option_;
+  }
+
+  // unknown_argument
+  //
+  inline unknown_argument::
+  unknown_argument (const std::string& argument)
+  : argument_ (argument)
+  {
+  }
+
+  inline const std::string& unknown_argument::
+  argument () const
+  {
+    return argument_;
+  }
+
+  // missing_value
+  //
+  inline missing_value::
+  missing_value (const std::string& option)
+  : option_ (option)
+  {
+  }
+
+  inline const std::string& missing_value::
+  option () const
+  {
+    return option_;
+  }
+
+  // invalid_value
+  //
+  inline invalid_value::
+  invalid_value (const std::string& option,
+                 const std::string& value)
+  : option_ (option),  value_ (value)
+  {
+  }
+
+  inline const std::string& invalid_value::
+  option () const
+  {
+    return option_;
+  }
+
+  inline const std::string& invalid_value::
+  value () const
+  {
+    return value_;
+  }
+
+  // file_io_failure
+  //
+  inline file_io_failure::
+  file_io_failure (const std::string& file)
+  : file_ (file)
+  {
+  }
+
+  inline const std::string& file_io_failure::
+  file () const
+  {
+    return file_;
+  }
+
+  // unmatched_quote
+  //
+  inline unmatched_quote::
+  unmatched_quote (const std::string& argument)
+  : argument_ (argument)
+  {
+  }
+
+  inline const std::string& unmatched_quote::
+  argument () const
+  {
+    return argument_;
+  }
+
+  // argv_scanner
+  //
+  inline argv_scanner::
+  argv_scanner (int& argc, char** argv, bool erase)
+  : i_ (1), argc_ (argc), argv_ (argv), erase_ (erase)
+  {
+  }
+
+  inline argv_scanner::
+  argv_scanner (int start, int& argc, char** argv, bool erase)
+  : i_ (start), argc_ (argc), argv_ (argv), erase_ (erase)
+  {
+  }
+
+  inline int argv_scanner::
+  end () const
+  {
+    return i_;
+  }
+
+  // argv_file_scanner
+  //
+  inline argv_file_scanner::
+  argv_file_scanner (int& argc,
+                     char** argv,
+                     const std::string& option,
+                     bool erase)
+  : argv_scanner (argc, argv, erase),
+    option_ (option),
+    options_ (&option_info_),
+    options_count_ (1),
+    skip_ (false)
+  {
+    option_info_.option = option_.c_str ();
+    option_info_.search_func = 0;
+  }
+
+  inline argv_file_scanner::
+  argv_file_scanner (int start,
+                     int& argc,
+                     char** argv,
+                     const std::string& option,
+                     bool erase)
+  : argv_scanner (start, argc, argv, erase),
+    option_ (option),
+    options_ (&option_info_),
+    options_count_ (1),
+    skip_ (false)
+  {
+    option_info_.option = option_.c_str ();
+    option_info_.search_func = 0;
+  }
+
+  inline argv_file_scanner::
+  argv_file_scanner (int& argc,
+                     char** argv,
+                     const option_info* options,
+                     std::size_t options_count,
+                     bool erase)
+  : argv_scanner (argc, argv, erase),
+    options_ (options),
+    options_count_ (options_count),
+    skip_ (false)
+  {
+  }
+
+  inline argv_file_scanner::
+  argv_file_scanner (int start,
+                     int& argc,
+                     char** argv,
+                     const option_info* options,
+                     std::size_t options_count,
+                     bool erase)
+  : argv_scanner (start, argc, argv, erase),
+    options_ (options),
+    options_count_ (options_count),
+    skip_ (false)
+  {
+  }
+}
+
+// help_options
+//
+
+inline const bool& help_options::
+help () const
+{
+  return this->help_;
+}
+
+inline const bool& help_options::
+version () const
+{
+  return this->version_;
+}
+
+inline const bool& help_options::
+proprietary_license () const
+{
+  return this->proprietary_license_;
+}
+
+// options
+//
+
+inline const NarrowStrings& options::
+disable_warning () const
+{
+  return this->disable_warning_;
+}
+
+inline bool options::
+disable_warning_specified () const
+{
+  return this->disable_warning_specified_;
+}
+
+inline const std::string& options::
+options_file () const
+{
+  return this->options_file_;
+}
+
+inline bool options::
+options_file_specified () const
+{
+  return this->options_file_specified_;
+}
+
+inline const bool& options::
+show_sloc () const
+{
+  return this->show_sloc_;
+}
+
+inline const std::size_t& options::
+sloc_limit () const
+{
+  return this->sloc_limit_;
+}
+
+inline bool options::
+sloc_limit_specified () const
+{
+  return this->sloc_limit_specified_;
+}
+
+inline const bool& options::
+proprietary_license () const
+{
+  return this->proprietary_license_;
+}
+
+inline const NarrowString& options::
+custom_literals () const
+{
+  return this->custom_literals_;
+}
+
+inline bool options::
+custom_literals_specified () const
+{
+  return this->custom_literals_specified_;
+}
+
+inline const bool& options::
+preserve_anonymous () const
+{
+  return this->preserve_anonymous_;
+}
+
+inline const bool& options::
+show_anonymous () const
+{
+  return this->show_anonymous_;
+}
+
+inline const NarrowStrings& options::
+anonymous_regex () const
+{
+  return this->anonymous_regex_;
+}
+
+inline bool options::
+anonymous_regex_specified () const
+{
+  return this->anonymous_regex_specified_;
+}
+
+inline const bool& options::
+anonymous_regex_trace () const
+{
+  return this->anonymous_regex_trace_;
+}
+
+inline const bool& options::
+morph_anonymous () const
+{
+  return this->morph_anonymous_;
+}
+
+inline const NarrowStrings& options::
+location_map () const
+{
+  return this->location_map_;
+}
+
+inline bool options::
+location_map_specified () const
+{
+  return this->location_map_specified_;
+}
+
+inline const NarrowStrings& options::
+location_regex () const
+{
+  return this->location_regex_;
+}
+
+inline bool options::
+location_regex_specified () const
+{
+  return this->location_regex_specified_;
+}
+
+inline const bool& options::
+location_regex_trace () const
+{
+  return this->location_regex_trace_;
+}
+
+inline const bool& options::
+file_per_type () const
+{
+  return this->file_per_type_;
+}
+
+inline const NarrowStrings& options::
+type_file_regex () const
+{
+  return this->type_file_regex_;
+}
+
+inline bool options::
+type_file_regex_specified () const
+{
+  return this->type_file_regex_specified_;
+}
+
+inline const bool& options::
+type_file_regex_trace () const
+{
+  return this->type_file_regex_trace_;
+}
+
+inline const NarrowStrings& options::
+schema_file_regex () const
+{
+  return this->schema_file_regex_;
+}
+
+inline bool options::
+schema_file_regex_specified () const
+{
+  return this->schema_file_regex_specified_;
+}
+
+inline const bool& options::
+schema_file_regex_trace () const
+{
+  return this->schema_file_regex_trace_;
+}
+
+inline const bool& options::
+fat_type_file () const
+{
+  return this->fat_type_file_;
+}
+
+inline const NarrowString& options::
+file_list () const
+{
+  return this->file_list_;
+}
+
+inline bool options::
+file_list_specified () const
+{
+  return this->file_list_specified_;
+}
+
+inline const NarrowString& options::
+file_list_prologue () const
+{
+  return this->file_list_prologue_;
+}
+
+inline bool options::
+file_list_prologue_specified () const
+{
+  return this->file_list_prologue_specified_;
+}
+
+inline const NarrowString& options::
+file_list_epilogue () const
+{
+  return this->file_list_epilogue_;
+}
+
+inline bool options::
+file_list_epilogue_specified () const
+{
+  return this->file_list_epilogue_specified_;
+}
+
+inline const NarrowString& options::
+file_list_delim () const
+{
+  return this->file_list_delim_;
+}
+
+inline bool options::
+file_list_delim_specified () const
+{
+  return this->file_list_delim_specified_;
+}
+
+inline const bool& options::
+disable_multi_import () const
+{
+  return this->disable_multi_import_;
+}
+
+inline const bool& options::
+disable_full_check () const
+{
+  return this->disable_full_check_;
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/xsd/xsd/processing/cardinality/processor.cxx b/xsd/xsd/processing/cardinality/processor.cxx
index 473c412..f43395a 100644
--- a/xsd/xsd/processing/cardinality/processor.cxx
+++ b/xsd/xsd/processing/cardinality/processor.cxx
@@ -1,26 +1,23 @@
 // file      : processing/cardinality/processor.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
-#include <processing/cardinality/processor.hxx>
-
-#include <elements.hxx>
+#include <map>
 
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
 
-#include <cult/containers/map.hxx>
+#include <elements.hxx>
+
+#include <processing/cardinality/processor.hxx>
+
+using namespace std;
 
 namespace Processing
 {
-  using namespace Cult;
-
   namespace SemanticGraph = XSDFrontend::SemanticGraph;
   namespace Traversal = XSDFrontend::Traversal;
 
-  typedef WideString String;
-
   namespace Cardinality
   {
     namespace
@@ -39,8 +36,7 @@ namespace Processing
         {
         }
 
-        ElementInfo (SemanticGraph::Element& e,
-                     UnsignedLong min_, UnsignedLong max_)
+        ElementInfo (SemanticGraph::Element& e, size_t min_, size_t max_)
             : min (min_), max (max_), e_ (&e)
         {
         }
@@ -53,13 +49,13 @@ namespace Processing
         }
 
       public:
-        UnsignedLong min, max;
+        size_t min, max;
 
       private:
         SemanticGraph::Element* e_;
       };
 
-      typedef Cult::Containers::Map<String, ElementInfo> ElementInfoMap;
+      typedef map<String, ElementInfo> ElementInfoMap;
 
       //
       //
@@ -75,8 +71,7 @@ namespace Processing
         {
         }
 
-        AnyInfo (SemanticGraph::Any& a,
-                 UnsignedLong min_, UnsignedLong max_)
+        AnyInfo (SemanticGraph::Any& a, size_t min_, size_t max_)
             : min (min_), max (max_), a_ (&a)
         {
         }
@@ -89,13 +84,13 @@ namespace Processing
         }
 
       public:
-        UnsignedLong min, max;
+        size_t min, max;
 
       private:
         SemanticGraph::Any* a_;
       };
 
-      typedef Cult::Containers::Map<String, AnyInfo> AnyInfoMap;
+      typedef map<String, AnyInfo> AnyInfoMap;
 
       //
       //
@@ -105,13 +100,13 @@ namespace Processing
                        Traversal::Element,
                        Traversal::Any
       {
-        virtual Void
+        virtual void
         traverse (SemanticGraph::All& a)
         {
           traverse_sequence (a);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Choice& c)
         {
           using SemanticGraph::Compositor;
@@ -135,20 +130,26 @@ namespace Processing
               // those that are we need to choose minimum between
               // the two for min and maximum for max.
               //
-              for (ElementInfoMap::Iterator i (el_map.begin ());
+              for (ElementInfoMap::iterator i (el_map.begin ());
                    i != el_map.end (); ++i)
               {
                 String const& name (i->first);
                 ElementInfo& ei (i->second);
 
-                ElementInfoMap::Iterator j (t.el_map.find (name));
+                ElementInfoMap::iterator j (t.el_map.find (name));
 
                 if (j == t.el_map.end ())
                   ei.min = 0;
                 else
                 {
                   ei.min = j->second.min < ei.min ? j->second.min : ei.min;
-                  ei.max = j->second.max > ei.max ? j->second.max : ei.max;
+
+                  // Unbounded is encoded as 0.
+                  //
+                  if (j->second.max == 0 || ei.max == 0)
+                    ei.max = 0;
+                  else
+                    ei.max = j->second.max > ei.max ? j->second.max : ei.max;
                 }
               }
 
@@ -156,13 +157,13 @@ namespace Processing
               // not in the map, we need to add to the map and set their
               // min to 0.
               //
-              for (ElementInfoMap::Iterator i (t.el_map.begin ());
+              for (ElementInfoMap::iterator i (t.el_map.begin ());
                    i != t.el_map.end (); ++i)
               {
                 String const& name (i->first);
                 ElementInfo& ei (i->second);
 
-                ElementInfoMap::Iterator j (el_map.find (name));
+                ElementInfoMap::iterator j (el_map.find (name));
 
                 if (j == el_map.end ())
                   el_map[name] = ElementInfo (ei.element (), 0, ei.max);
@@ -173,7 +174,7 @@ namespace Processing
             // we need to copy them from each arm of choice and set min to
             // 0.
             //
-            for (AnyInfoMap::Iterator i (t.any_map.begin ());
+            for (AnyInfoMap::iterator i (t.any_map.begin ());
                  i != t.any_map.end (); ++i)
             {
               String const& name (i->first);
@@ -187,19 +188,19 @@ namespace Processing
 
           // Choice's min and max.
           //
-          UnsignedLong cmin (c.min ()), cmax (c.max ());
+          size_t cmin (c.min ()), cmax (c.max ());
 
           // Iterate over elements and wildcards in the maps and multiply
           // their cardinality by cmin and cmax.
           //
-          for (ElementInfoMap::Iterator i (el_map.begin ());
+          for (ElementInfoMap::iterator i (el_map.begin ());
                i != el_map.end (); ++i)
           {
             i->second.min *= cmin;
             i->second.max *= cmax;
           }
 
-          for (AnyInfoMap::Iterator i (any_map.begin ());
+          for (AnyInfoMap::iterator i (any_map.begin ());
                i != any_map.end (); ++i)
           {
             i->second.min *= cmin; // Not really necessary since min == 0.
@@ -207,20 +208,20 @@ namespace Processing
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Sequence& s)
         {
           traverse_sequence (s);
         }
 
-        Void
+        void
         traverse_sequence (SemanticGraph::Compositor& c)
         {
           using SemanticGraph::Compositor;
 
           // Sequence's min and max.
           //
-          UnsignedLong smin (c.min ()), smax (c.max ());
+          size_t smin (c.min ()), smax (c.max ());
 
           // Go over all particles we contain and add them to the map.
           //
@@ -232,14 +233,14 @@ namespace Processing
 
             // Handle elements.
             //
-            for (ElementInfoMap::Iterator i (t.el_map.begin ());
+            for (ElementInfoMap::iterator i (t.el_map.begin ());
                  i != t.el_map.end (); ++i)
             {
               String const& name (i->first);
               ElementInfo& ei (i->second);
-              UnsignedLong min (ei.min * smin);
-              UnsignedLong max (ei.max * smax);
-              ElementInfoMap::Iterator j (el_map.find (name));
+              size_t min (ei.min * smin);
+              size_t max (ei.max * smax);
+              ElementInfoMap::iterator j (el_map.find (name));
 
               if (j != el_map.end ())
               {
@@ -255,13 +256,13 @@ namespace Processing
 
             // Handle wildcards.
             //
-            for (AnyInfoMap::Iterator i (t.any_map.begin ());
+            for (AnyInfoMap::iterator i (t.any_map.begin ());
                  i != t.any_map.end (); ++i)
             {
               String const& name (i->first);
               AnyInfo& ai (i->second);
-              UnsignedLong min (ai.min * smin);
-              UnsignedLong max (ai.max * smax);
+              size_t min (ai.min * smin);
+              size_t max (ai.max * smax);
 
               assert (any_map.find (name) == any_map.end ());
 
@@ -270,7 +271,7 @@ namespace Processing
           }
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element& e)
         {
           SemanticGraph::ContainsParticle& cp (e.contained_particle ());
@@ -282,7 +283,7 @@ namespace Processing
           el_map[name] = ElementInfo (e, cp.min (), cp.max ());
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Any& a)
         {
           SemanticGraph::ContainsParticle& cp (a.contained_particle ());
@@ -300,7 +301,7 @@ namespace Processing
       //
       struct Complex: Traversal::Complex
       {
-        virtual Void
+        virtual void
         traverse (Type& c)
         {
           if (c.contains_compositor_p ())
@@ -308,21 +309,21 @@ namespace Processing
             Particle t;
             t.dispatch (c.contains_compositor ().compositor ());
 
-            for (ElementInfoMap::Iterator i (t.el_map.begin ());
+            for (ElementInfoMap::iterator i (t.el_map.begin ());
                  i != t.el_map.end (); ++i)
             {
               ElementInfo& ei (i->second);
-              FrontendElements::Context& ctx (ei.element ().context ());
+              SemanticGraph::Context& ctx (ei.element ().context ());
 
               ctx.set ("min", ei.min);
               ctx.set ("max", ei.max);
             }
 
-            for (AnyInfoMap::Iterator i (t.any_map.begin ());
+            for (AnyInfoMap::iterator i (t.any_map.begin ());
                  i != t.any_map.end (); ++i)
             {
               AnyInfo& ai (i->second);
-              FrontendElements::Context& ctx (ai.any ().context ());
+              SemanticGraph::Context& ctx (ai.any ().context ());
 
               ctx.set ("min", ai.min);
               ctx.set ("max", ai.max);
@@ -340,13 +341,13 @@ namespace Processing
       //
       struct Attribute: Traversal::Attribute
       {
-        virtual Void
+        virtual void
         traverse (Type& a)
         {
-          FrontendElements::Context& ctx (a.context ());
+          SemanticGraph::Context& ctx (a.context ());
 
-          ctx.set ("min", a.optional_p () ? 0UL : 1UL);
-          ctx.set ("max", 1UL);
+          ctx.set ("min", size_t (a.optional_p () ? 0 : 1));
+          ctx.set ("max", size_t (1));
         }
       };
 
@@ -355,7 +356,7 @@ namespace Processing
       //
       struct Uses: Traversal::Uses
       {
-        virtual Void
+        virtual void
         traverse (Type& u)
         {
           SemanticGraph::Schema& s (u.schema ());
@@ -369,7 +370,7 @@ namespace Processing
       };
     }
 
-    Void Processor::
+    void Processor::
     process (SemanticGraph::Schema& tu, SemanticGraph::Path const&)
     {
       Traversal::Schema schema;
diff --git a/xsd/xsd/processing/cardinality/processor.hxx b/xsd/xsd/processing/cardinality/processor.hxx
index 31c6ef8..2b4ebe0 100644
--- a/xsd/xsd/processing/cardinality/processor.hxx
+++ b/xsd/xsd/processing/cardinality/processor.hxx
@@ -1,28 +1,25 @@
 // file      : processing/cardinality/processor.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef PROCESSING_CARDINALITY_PROCESSOR_HXX
 #define PROCESSING_CARDINALITY_PROCESSOR_HXX
 
-#include <cult/types.hxx>
-
 #include <xsd-frontend/semantic-graph/elements.hxx> // Path
 #include <xsd-frontend/semantic-graph/schema.hxx>
 
+#include <types.hxx>
+
 namespace Processing
 {
   namespace Cardinality
   {
-    using namespace Cult::Types;
-
     class Processor
     {
     public:
       struct Failed {};
 
-      Void
+      void
       process (XSDFrontend::SemanticGraph::Schema&,
                XSDFrontend::SemanticGraph::Path const& file);
     };
diff --git a/xsd/xsd/processing/inheritance/processor.cxx b/xsd/xsd/processing/inheritance/processor.cxx
index d92ea6c..6680a39 100644
--- a/xsd/xsd/processing/inheritance/processor.cxx
+++ b/xsd/xsd/processing/inheritance/processor.cxx
@@ -1,8 +1,10 @@
 // file      : processing/inheritance/processor.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
+#include <set>
+#include <iostream>
+
 #include <processing/inheritance/processor.hxx>
 
 #include <elements.hxx>
@@ -10,21 +12,13 @@
 #include <xsd-frontend/semantic-graph.hxx>
 #include <xsd-frontend/traversal.hxx>
 
-#include <cult/containers/set.hxx>
-
-#include <iostream>
-using std::wcerr;
-using std::endl;
+using namespace std;
 
 namespace Processing
 {
-  using namespace Cult;
-
   namespace SemanticGraph = XSDFrontend::SemanticGraph;
   namespace Traversal = XSDFrontend::Traversal;
 
-  typedef WideString String;
-
   namespace Inheritance
   {
     namespace
@@ -43,15 +37,14 @@ namespace Processing
         String member_xpath;
       };
 
-      inline Boolean
+      inline bool
       operator< (Dep const& a, Dep const& b)
       {
         return &a.type < &b.type;
       }
 
-      typedef Containers::Set<Dep> DepSet;
-      typedef Containers::Set<SemanticGraph::Type*> TypeSet;
-
+      typedef set<Dep> DepSet;
+      typedef set<SemanticGraph::Type*> TypeSet;
 
       String
       xpath (SemanticGraph::Nameable& n)
@@ -88,7 +81,7 @@ namespace Processing
           *this >> names_ >> *this;
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           using SemanticGraph::Complex;
@@ -103,14 +96,14 @@ namespace Processing
           names (c);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Member& m)
         {
           SemanticGraph::Type& t (m.type ());
 
           if (!t.named_p () && types_seen_.find (&t) == types_seen_.end ())
           {
-            FrontendElements::Context& ctx (t.context ());
+            SemanticGraph::Context& ctx (t.context ());
 
             last_xpath_ = xpath (m);
 
@@ -158,14 +151,14 @@ namespace Processing
         }
 
         template <typename E>
-        Void
+        void
         add_edge_left (E& e)
         {
           node_.add_edge_left (e, arg_);
         }
 
         template <typename E>
-        Void
+        void
         add_edge_right (E& e)
         {
           node_.add_edge_right (e, arg_);
@@ -185,26 +178,26 @@ namespace Processing
       {
         Global (SemanticGraph::Schema& root,
                 SemanticGraph::Schema& schema,
-                Boolean& failed)
+                bool& failed)
             : root_ (root), schema_ (schema), failed_ (failed)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Type& t)
         {
           if (t.named_p ())
             types_seen_.insert (&t);
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Complex& c)
         {
           check_dep (c, c);
           types_seen_.insert (&c);
         };
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Element& e)
         {
           SemanticGraph::Type& t (e.type ());
@@ -218,7 +211,7 @@ namespace Processing
         };
 
       private:
-        Void
+        void
         check_dep (SemanticGraph::Nameable& global,
                    SemanticGraph::Type& type)
         {
@@ -236,12 +229,19 @@ namespace Processing
             complex.dispatch (type);
           }
 
-          for (DepSet::ConstIterator i (prereqs.begin ());
+          for (DepSet::const_iterator i (prereqs.begin ());
                i != prereqs.end (); ++i)
           {
             Dep const& dep (*i);
             Type& t (dep.type);
 
+            // Ignore IDREF templates.
+            //
+            if (!t.named_p () &&
+                (t.is_a<SemanticGraph::Fundamental::IdRef> () ||
+                 t.is_a<SemanticGraph::Fundamental::IdRefs> ()))
+              continue;
+
             // We won't be able to generate compilable code in case of a
             // dependency on ourselves (e.g., a member element with
             // anonymous type that inherits from us).
@@ -311,7 +311,6 @@ namespace Processing
                 continue;
               }
 
-
               //wcerr << "type '" << t.name () << "' needs to be moved " <<
               //  "before " << (global.is_a<Type> () ? "type" : "element") <<
               //  " '" << global.name () << "'" << endl;
@@ -328,6 +327,11 @@ namespace Processing
               // Insert a new Names edge before global.
               //
               {
+                // t.scope () and global.scope () can be different in
+                // case of the chameleon inclusion.
+                //
+                Scope& scope (global.scope ());
+
                 // Convert to the insert-after call.
                 //
                 Scope::NamesIterator i (scope.find (global.named ()));
@@ -353,7 +357,7 @@ namespace Processing
       private:
         // Return true if root sources s.
         //
-        Boolean
+        bool
         sources_p (SemanticGraph::Schema& root, SemanticGraph::Schema& s)
         {
           using SemanticGraph::Schema;
@@ -376,40 +380,55 @@ namespace Processing
         SemanticGraph::Schema& root_;
         SemanticGraph::Schema& schema_;
         TypeSet types_seen_;
-        Boolean& failed_;
+        bool& failed_;
       };
 
 
+      // Sources traverser that goes into each schema only once.
+      //
+      struct Sources: Traversal::Sources
+      {
+        virtual void
+        traverse (SemanticGraph::Sources& s)
+        {
+          if (schemas_.insert (&s.schema ()).second)
+            Traversal::Sources::traverse (s);
+        }
+
+      private:
+        set<SemanticGraph::Schema*> schemas_;
+      };
+
       // Go into included/imported schemas while making sure we don't
       // process the same stuff more than once.
       //
       struct Uses: Traversal::Includes, Traversal::Imports
       {
-        Uses (SemanticGraph::Schema& root, Boolean& failed)
+        Uses (SemanticGraph::Schema& root, bool& failed)
             : root_ (root), failed_ (failed)
         {
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Includes& i)
         {
           traverse (i.schema ());
         }
 
-        virtual Void
+        virtual void
         traverse (SemanticGraph::Imports& i)
         {
           traverse (i.schema ());
         }
 
       private:
-        Void
+        void
         traverse (SemanticGraph::Schema& s)
         {
           if (!s.context ().count ("processing-inheritance-seen"))
           {
             Traversal::Schema schema;
-            Traversal::Sources sources;
+            Sources sources;
 
             schema >> sources >> schema;
             schema >> *this;
@@ -431,21 +450,21 @@ namespace Processing
 
       private:
         SemanticGraph::Schema& root_;
-        Boolean& failed_;
+        bool& failed_;
       };
     }
 
-    Void Processor::
+    void Processor::
     process (SemanticGraph::Schema& tu, SemanticGraph::Path const&)
     {
-      Boolean failed (false);
+      bool failed (false);
 
       // We need to process include/imported schemas since other
       // parts of the process, for example, name processors can
       // rely on the order of types in the schema.
       //
       Traversal::Schema schema;
-      Traversal::Sources sources;
+      Sources sources;
       Uses uses (tu, failed);
 
       schema >> sources >> schema;
diff --git a/xsd/xsd/processing/inheritance/processor.hxx b/xsd/xsd/processing/inheritance/processor.hxx
index aba3b49..46a33c7 100644
--- a/xsd/xsd/processing/inheritance/processor.hxx
+++ b/xsd/xsd/processing/inheritance/processor.hxx
@@ -1,28 +1,25 @@
 // file      : processing/inheritance/processor.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2006-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2006-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef PROCESSING_INHERITANCE_PROCESSOR_HXX
 #define PROCESSING_INHERITANCE_PROCESSOR_HXX
 
-#include <cult/types.hxx>
-
 #include <xsd-frontend/semantic-graph/elements.hxx> // Path
 #include <xsd-frontend/semantic-graph/schema.hxx>
 
+#include <types.hxx>
+
 namespace Processing
 {
   namespace Inheritance
   {
-    using namespace Cult::Types;
-
     class Processor
     {
     public:
       struct Failed {};
 
-      Void
+      void
       process (XSDFrontend::SemanticGraph::Schema&,
                XSDFrontend::SemanticGraph::Path const& file);
     };
diff --git a/xsd/xsd/type-map/lexer.cxx b/xsd/xsd/type-map/lexer.cxx
index 96e42de..fe7ecfc 100644
--- a/xsd/xsd/type-map/lexer.cxx
+++ b/xsd/xsd/type-map/lexer.cxx
@@ -1,6 +1,5 @@
 // file      : xsd/type-map/lexer.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2007-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2007-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <iostream>
@@ -68,7 +67,7 @@ namespace TypeMap
     if (is_.eof ())
       return Token (Token::eos, L"<end-of-stream>", line_);
 
-    Boolean quote (c == '"');
+    bool quote (c == '"');
 
     if (!quote)
       lexeme += c;
diff --git a/xsd/xsd/type-map/lexer.hxx b/xsd/xsd/type-map/lexer.hxx
index 923c85f..0d3af42 100644
--- a/xsd/xsd/type-map/lexer.hxx
+++ b/xsd/xsd/type-map/lexer.hxx
@@ -1,6 +1,5 @@
 // file      : xsd/type-map/lexer.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2007-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2007-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef XSD_TYPE_MAP_LEXER_HXX
@@ -9,13 +8,10 @@
 #include <locale>
 #include <iosfwd>
 
-#include <cult/types.hxx>
+#include <types.hxx>
 
 namespace TypeMap
 {
-  using namespace Cult::Types;
-  typedef WideString String;
-
   class Lexer
   {
   public:
@@ -29,7 +25,7 @@ namespace TypeMap
         eos
       };
 
-      Token (Type type, String const& lexeme, UnsignedLong line)
+      Token (Type type, String const& lexeme, size_t line)
           : type_ (type), lexeme_ (lexeme), line_ (line)
       {
       }
@@ -46,7 +42,7 @@ namespace TypeMap
         return lexeme_;
       }
 
-      UnsignedLong
+      size_t
       line () const
       {
         return line_;
@@ -55,7 +51,7 @@ namespace TypeMap
     private:
       Type type_;
       String lexeme_;
-      UnsignedLong line_;
+      size_t line_;
     };
 
     Lexer (std::istream&, String const& path);
@@ -69,12 +65,11 @@ namespace TypeMap
     std::locale locale_;
     std::istream& is_;
     String path_;
-    UnsignedLong line_;
+    size_t line_;
     String held_lexeme_;
-    Boolean comment_;
+    bool comment_;
   };
 
 }
 
 #endif // XSD_TYPE_MAP_LEXER_HXX
-
diff --git a/xsd/xsd/type-map/parser.cxx b/xsd/xsd/type-map/parser.cxx
index 9f5e2b5..e391cf7 100644
--- a/xsd/xsd/type-map/parser.cxx
+++ b/xsd/xsd/type-map/parser.cxx
@@ -1,11 +1,10 @@
 // file      : xsd/type-map/parser.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2007-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2007-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #include <iostream>
 
-#include <backend-elements/regex.hxx>
+#include <cutl/re.hxx>
 
 #include <type-map/parser.hxx>
 
@@ -14,14 +13,14 @@ using std::endl;
 namespace TypeMap
 {
   typedef Lexer::Token Token;
-  typedef BackendElements::Regex::Format<WideChar> Format;
+  typedef cutl::re::wformat Format;
 
   Parser::Parser (Lexer& lex, String const& path)
       : lex_ (lex), path_ (path), e (std::wcerr)
   {
   }
 
-  Boolean Parser::
+  bool Parser::
   parse (Namespaces& ns)
   {
     try
@@ -83,7 +82,7 @@ namespace TypeMap
     return true;
   }
 
-  Boolean Parser::
+  bool Parser::
   namespace_ (Namespaces& ns)
   {
     // First get XML namespace.
@@ -99,7 +98,7 @@ namespace TypeMap
     catch (Format const& ex)
     {
       e << path_ << ":" << t.line () << ": invalid namespace pattern: "
-        << ex.description () << endl;
+        << ex.description ().c_str () << endl;
       return false;
     }
 
@@ -115,7 +114,7 @@ namespace TypeMap
     //
     t = lex_.next ();
 
-    Boolean has_cxx_name (false);
+    bool has_cxx_name (false);
     String cxx_name;
 
     if (t.type () != Token::token)
@@ -191,7 +190,7 @@ namespace TypeMap
     return true;
   }
 
-  Boolean Parser::
+  bool Parser::
   include (Namespace& n)
   {
     Token t (lex_.next ());
@@ -222,7 +221,7 @@ namespace TypeMap
     return true;
   }
 
-  Boolean Parser::
+  bool Parser::
   type (Token t, Namespace& n)
   {
     Pattern xsd_name;
@@ -234,7 +233,7 @@ namespace TypeMap
     catch (Format const& ex)
     {
       e << path_ << ":" << t.line () << ": invalid namespace pattern: "
-        << ex.description () << endl;
+        << ex.description ().c_str () << endl;
       return false;
     }
 
diff --git a/xsd/xsd/type-map/parser.hxx b/xsd/xsd/type-map/parser.hxx
index 038d2ec..c91bb12 100644
--- a/xsd/xsd/type-map/parser.hxx
+++ b/xsd/xsd/type-map/parser.hxx
@@ -1,21 +1,17 @@
 // file      : xsd/type-map/parser.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2007-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2007-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef XSD_TYPE_MAP_PARSER_HXX
 #define XSD_TYPE_MAP_PARSER_HXX
 
-#include <cult/types.hxx>
+#include <types.hxx>
 
 #include <type-map/type-map.hxx>
 #include <type-map/lexer.hxx>
 
 namespace TypeMap
 {
-  using namespace Cult::Types;
-  typedef WideString String;
-
   class Parser
   {
   public:
@@ -23,17 +19,17 @@ namespace TypeMap
 
     // Merge parsed namespaces.
     //
-    Boolean
+    bool
     parse (Namespaces&);
 
   private:
-    Boolean
+    bool
     namespace_ (Namespaces&);
 
-    Boolean
+    bool
     include (Namespace&);
 
-    Boolean
+    bool
     type (Lexer::Token, Namespace&);
 
   private:
diff --git a/xsd/xsd/type-map/type-map.hxx b/xsd/xsd/type-map/type-map.hxx
index 34ceefa..cdb8a0c 100644
--- a/xsd/xsd/type-map/type-map.hxx
+++ b/xsd/xsd/type-map/type-map.hxx
@@ -1,25 +1,32 @@
 // file      : xsd/type-map/type-map.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2007-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2007-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef XSD_TYPE_MAP_TYPE_MAP_HXX
 #define XSD_TYPE_MAP_TYPE_MAP_HXX
 
-#include <cult/types.hxx>
-#include <cult/containers/vector.hxx>
+#include <vector>
 
-#include <backend-elements/regex.hxx>
+#include <cutl/re.hxx>
+
+#include <types.hxx>
 
 namespace TypeMap
 {
-  using namespace Cult::Types;
-  typedef WideString String;
-  typedef BackendElements::Regex::Pattern<WideChar> Pattern;
+  typedef cutl::re::wregex Pattern;
 
   class Type
   {
   public:
+    Type (String const& xsd_name,
+          String const& cxx_ret_name,
+          String const& cxx_arg_name)
+        : xsd_name_ (xsd_name),
+          cxx_ret_name_ (cxx_ret_name),
+          cxx_arg_name_ (cxx_arg_name)
+    {
+    }
+
     Type (Pattern const& xsd_name,
           String const& cxx_ret_name,
           String const& cxx_arg_name)
@@ -56,6 +63,11 @@ namespace TypeMap
   class Namespace
   {
   public:
+    Namespace (String const& xsd_name)
+        : xsd_name_ (xsd_name), has_cxx_name_ (false)
+    {
+    }
+
     Namespace (Pattern const& xsd_name)
         : xsd_name_ (xsd_name), has_cxx_name_ (false)
     {
@@ -67,7 +79,7 @@ namespace TypeMap
     }
 
     Namespace (Pattern const& xsd_name,
-               Boolean has_cxx_name,
+               bool has_cxx_name,
                String const& cxx_name)
         : xsd_name_ (xsd_name),
           has_cxx_name_ (has_cxx_name),
@@ -77,8 +89,8 @@ namespace TypeMap
 
     //
     //
-    typedef Cult::Containers::Vector<String> Includes;
-    typedef Includes::ConstIterator IncludesIterator;
+    typedef std::vector<String> Includes;
+    typedef Includes::const_iterator IncludesIterator;
 
     IncludesIterator
     includes_begin () const
@@ -92,7 +104,7 @@ namespace TypeMap
       return includes_.end ();
     }
 
-    Void
+    void
     includes_push_back (String const& i)
     {
       includes_.push_back (i);
@@ -100,8 +112,8 @@ namespace TypeMap
 
     //
     //
-    typedef Cult::Containers::Vector<Type> Types;
-    typedef Types::ConstIterator TypesIterator;
+    typedef std::vector<Type> Types;
+    typedef Types::const_iterator TypesIterator;
 
     TypesIterator
     types_begin () const
@@ -115,7 +127,15 @@ namespace TypeMap
       return types_.end ();
     }
 
-    Void
+    void
+    types_push_back (String const& xsd_type,
+                     String const& cxx_ret_type,
+                     String const& cxx_arg_type = L"")
+    {
+      types_.push_back (Type (xsd_type, cxx_ret_type, cxx_arg_type));
+    }
+
+    void
     types_push_back (Pattern const& xsd_type,
                      String const& cxx_ret_type,
                      String const& cxx_arg_type = L"")
@@ -133,7 +153,7 @@ namespace TypeMap
 
     //
     //
-    Boolean
+    bool
     has_cxx_name () const
     {
       return has_cxx_name_;
@@ -149,12 +169,11 @@ namespace TypeMap
     Includes includes_;
     Types types_;
     Pattern xsd_name_;
-    Boolean has_cxx_name_;
+    bool has_cxx_name_;
     String cxx_name_;
   };
 
-  typedef Cult::Containers::Vector<Namespace> Namespaces;
+  typedef std::vector<Namespace> Namespaces;
 }
 
 #endif // XSD_TYPE_MAP_TYPE_MAP_HXX
-
diff --git a/xsd/xsd/types.hxx b/xsd/xsd/types.hxx
new file mode 100644
index 0000000..6850b42
--- /dev/null
+++ b/xsd/xsd/types.hxx
@@ -0,0 +1,20 @@
+// file      : xsd/types.hxx
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef TYPES_HXX
+#define TYPES_HXX
+
+#include <vector>
+#include <cstddef> // std::size_t
+
+#include <xsd-frontend/types.hxx>
+
+using std::size_t;
+
+using XSDFrontend::String;
+using XSDFrontend::NarrowString;
+
+typedef std::vector<NarrowString> NarrowStrings;
+
+#endif // TYPES_HXX
diff --git a/xsd/xsd/usage.hxx b/xsd/xsd/usage.hxx
deleted file mode 100644
index 63ce413..0000000
--- a/xsd/xsd/usage.hxx
+++ /dev/null
@@ -1,226 +0,0 @@
-// file      : xsd/usage.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
-// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
-
-#ifndef USAGE_HXX
-#define USAGE_HXX
-
-#include <cult/types.hxx>
-
-#include <backend-elements/indentation/buffer.hxx>
-#include <backend-elements/indentation/clip.hxx>
-
-namespace CLI
-{
-  using namespace Cult::Types;
-
-  template <typename C>
-  class OptionsUsage: public BackendElements::Indentation::Buffer<C>
-  {
-    typedef BackendElements::Indentation::Buffer<C> Buffer;
-
-  public:
-    typedef
-    typename Buffer::Traits
-    Traits;
-
-    typedef
-    typename Buffer::AsChar
-    AsChar;
-
-    typedef
-    typename Buffer::AsInt
-    AsInt;
-
-    typedef
-    typename Buffer::Write
-    Write;
-
-  public:
-    OptionsUsage (Buffer& out)
-        : out_ (out),
-          option_length_ (0),
-          construct_ (Construct::newline)
-    {
-    }
-
-  public:
-    virtual AsInt
-    put (AsChar c)
-    {
-      AsInt result (Traits::to_int_type (c));
-
-      try
-      {
-        switch (c)
-        {
-        case '\n':
-          {
-            switch (construct_)
-            {
-            case Construct::newline:
-              {
-                result = out_.put (c);
-                break;
-              }
-            case Construct::option:
-              {
-                construct_ = Construct::newline;
-                break;
-              }
-            case Construct::description:
-              {
-                result = out_.put (c);
-                construct_ = Construct::newline;
-                break;
-              }
-            default:
-              {
-                abort ();
-              }
-            }
-
-            break;
-          }
-        case '-':
-          {
-            switch (construct_)
-            {
-            case Construct::newline:
-              {
-                construct_ = Construct::option;
-
-                option_length_ = 0;
-
-                output_indentation ();
-                result = out_.put (c);
-
-                ++option_length_;
-
-                break;
-              }
-            case Construct::option:
-              {
-                ++option_length_;
-                //fall through
-              }
-            case Construct::description:
-              {
-                result = out_.put (c);
-                break;
-              }
-            default:
-              {
-                abort ();
-              }
-            }
-
-            break;
-          }
-        default:
-          {
-            switch (construct_)
-            {
-            case Construct::newline:
-              {
-                construct_ = Construct::description;
-
-                output_indentation ();
-
-                result = out_.put (c);
-                break;
-              }
-            case Construct::option:
-              {
-                ++option_length_;
-                //fall through
-              }
-            default:
-              {
-                result = out_.put (c);
-                break;
-              }
-            }
-
-            break;
-          }
-        }
-      }
-      catch (Write const&)
-      {
-        result = Traits::eof ();
-      }
-
-      return result;
-    }
-
-    virtual Void
-    unbuffer ()
-    {
-    }
-
-  private:
-    Void
-    output_indentation ()
-    {
-      UnsignedLong spaces;
-
-      switch (construct_)
-      {
-      case Construct::option:
-        {
-          spaces = 2;
-          option_length_ += 2;
-          break;
-        }
-      case Construct::description:
-        {
-          spaces = 29;
-
-          if (option_length_)
-          {
-            if (option_length_ > spaces)
-              spaces = 1;
-            else
-              spaces -= option_length_;
-
-            option_length_ = 0;
-          }
-
-          break;
-        }
-      default:
-        {
-          abort ();
-        }
-      }
-
-      while (spaces--)
-        out_.put (' ');
-    }
-
-  private:
-    Buffer& out_;
-    UnsignedLong option_length_;
-
-    struct Construct
-    {
-      enum Value
-      {
-        newline,
-        option,
-        description
-      };
-    };
-
-    typename Construct::Value construct_;
-  };
-
-  //@@ rename Indentation to Indent in be?
-  //
-  namespace Indent = BackendElements::Indentation;
-}
-
-#endif // USAGE_HXX
-
diff --git a/xsd/xsd/xsd.cxx b/xsd/xsd/xsd.cxx
index 2e2f6ce..f333d76 100644
--- a/xsd/xsd/xsd.cxx
+++ b/xsd/xsd/xsd.cxx
@@ -1,20 +1,17 @@
 // file      : xsd/xsd.cxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
-#include <cult/types.hxx>
-
-#include <cult/trace/log.hxx>
+#include <map>
+#include <vector>
+#include <memory>  // std::auto_ptr
+#include <cstddef> // std::size_t
+#include <iostream>
+#include <fstream>
 
-#include <cult/containers/map.hxx>
-#include <cult/containers/vector.hxx>
+#include <xercesc/util/PlatformUtils.hpp>
 
-#include <cult/cli/exceptions.hxx>
-#include <cult/cli/file-arguments.hxx>
-#include <cult/cli/options.hxx>
-#include <cult/cli/options-spec.hxx>
-#include <cult/cli/options-parser.hxx>
+#include <cutl/re.hxx>
 
 #include <xsd-frontend/parser.hxx>
 #include <xsd-frontend/transformations/anonymous.hxx>
@@ -23,8 +20,8 @@
 #include <xsd-frontend/transformations/schema-per-type.hxx>
 #include <xsd-frontend/transformations/simplifier.hxx>
 
-#include <backend-elements/regex.hxx>
-#include <backend-elements/indentation/clip.hxx>
+#include <cxx/tree/options.hxx>
+#include <cxx/parser/options.hxx>
 
 #include <cxx/tree/generator.hxx>
 #include <cxx/parser/generator.hxx>
@@ -32,98 +29,16 @@
 #include <processing/cardinality/processor.hxx>
 #include <processing/inheritance/processor.hxx>
 
-#include <iostream>
-#include <boost/filesystem/fstream.hpp>
-
-#include <xercesc/util/PlatformUtils.hpp>
-
 #include <xsd.hxx>
-#include <usage.hxx>
+#include <types.hxx>
+#include <options.hxx>
 
 #include "../libxsd/xsd/cxx/version.hxx"
 
-using namespace Cult::Types;
-
-typedef Cult::Containers::Vector<NarrowString> NarrowStrings;
-
 namespace SemanticGraph = XSDFrontend::SemanticGraph;
 namespace Transformations = XSDFrontend::Transformations;
 
-using std::wcerr;
-using std::endl;
-
-namespace CLI
-{
-  using namespace Cult::CLI;
-
-  typedef Char const Key[];
-
-  extern Key help                = "help";
-  extern Key version             = "version";
-  extern Key proprietary_license = "proprietary-license";
-
-  typedef Cult::CLI::Options
-  <
-    help,                Boolean,
-    version,             Boolean,
-    proprietary_license, Boolean
-  >
-  HelpOptions;
-
-  struct HelpOptionsSpec: Cult::CLI::OptionsSpec<HelpOptions> {};
-
-
-  extern Key disable_warning         = "disable-warning";
-  extern Key sloc_limit              = "sloc-limit";
-  extern Key morph_anonymous         = "morph-anonymous";
-  extern Key preserve_anonymous      = "preserve-anonymous";
-  extern Key anonymous_regex         = "anonymous-regex";
-  extern Key anonymous_regex_trace   = "anonymous-regex-trace";
-  extern Key location_map            = "location-map";
-  extern Key location_regex          = "location-regex";
-  extern Key location_regex_trace    = "location-regex-trace";
-  extern Key custom_literals         = "custom-literals";
-  extern Key file_per_type           = "file-per-type";
-  extern Key type_file_regex         = "type-file-regex";
-  extern Key type_file_regex_trace   = "type-file-regex-trace";
-  extern Key schema_file_regex       = "schema-file-regex";
-  extern Key schema_file_regex_trace = "schema-file-regex-trace";
-  extern Key file_list               = "file-list";
-  extern Key file_list_prologue      = "file-list-prologue";
-  extern Key file_list_epilogue      = "file-list-epilogue";
-  extern Key file_list_delim         = "file-list-delim";
-  extern Key disable_multi_import    = "disable-multi-import"; // Undocumented.
-  extern Key disable_full_check      = "disable-full-check";   // Undocumented.
-
-
-  typedef Cult::CLI::Options
-  <
-    disable_warning,         Cult::Containers::Vector<NarrowString>,
-    sloc_limit,              UnsignedLong,
-    morph_anonymous,         Boolean,
-    preserve_anonymous,      Boolean,
-    anonymous_regex,         NarrowStrings,
-    anonymous_regex_trace,   Boolean,
-    location_map,            NarrowStrings,
-    location_regex,          NarrowStrings,
-    location_regex_trace,    Boolean,
-    custom_literals,         NarrowString,
-    file_per_type,           Boolean,
-    type_file_regex,         NarrowStrings,
-    type_file_regex_trace,   Boolean,
-    schema_file_regex,       NarrowStrings,
-    schema_file_regex_trace, Boolean,
-    file_list,               NarrowString,
-    file_list_prologue,      NarrowString,
-    file_list_epilogue,      NarrowString,
-    file_list_delim,         NarrowString,
-    disable_multi_import,    Boolean,
-    disable_full_check,      Boolean
-  >
-  CommonOptions;
-
-  struct CommonOptionsSpec: Cult::CLI::OptionsSpec<CommonOptions> {};
-}
+using namespace std;
 
 //
 //
@@ -133,24 +48,24 @@ struct LocationTranslator: XSDFrontend::LocationTranslator
 
   LocationTranslator (NarrowStrings const& map,
                       NarrowStrings const& regex,
-                      Boolean trace);
+                      bool trace);
 
   virtual NarrowString
   translate (NarrowString const&);
 
 private:
-  typedef Cult::Containers::Map<NarrowString, NarrowString> Map;
+  typedef map<NarrowString, NarrowString> Map;
 
-  typedef BackendElements::Regex::Expression<Char> Regex;
-  typedef BackendElements::Regex::Format<Char> RegexFormat;
-  typedef Cult::Containers::Vector<Regex> RegexVector;
+  typedef cutl::re::regexsub Regex;
+  typedef cutl::re::format RegexFormat;
+  typedef vector<Regex> RegexVector;
 
-  typedef Cult::Containers::Map<NarrowString, NarrowString> Cache;
+  typedef map<NarrowString, NarrowString> Cache;
 
   Map map_;
   RegexVector regex_;
   Cache cache_;
-  Boolean trace_;
+  bool trace_;
 };
 
 //
@@ -159,21 +74,21 @@ struct AnonymousNameTranslator: Transformations::AnonymousNameTranslator
 {
   struct Failed {};
 
-  AnonymousNameTranslator (NarrowStrings const& regex, Boolean trace);
+  AnonymousNameTranslator (NarrowStrings const& regex, bool trace);
 
-  virtual WideString
-  translate (WideString const& file,
-             WideString const& ns,
-             WideString const& name,
-             WideString const& xpath);
+  virtual String
+  translate (String const& file,
+             String const& ns,
+             String const& name,
+             String const& xpath);
 
 private:
-  typedef BackendElements::Regex::Expression<WideChar> Regex;
-  typedef BackendElements::Regex::Format<WideChar> RegexFormat;
-  typedef Cult::Containers::Vector<Regex> RegexVector;
+  typedef cutl::re::wregexsub Regex;
+  typedef cutl::re::wformat RegexFormat;
+  typedef vector<Regex> RegexVector;
 
   RegexVector regex_;
-  Boolean trace_;
+  bool trace_;
 
 };
 
@@ -184,30 +99,30 @@ struct SchemaPerTypeTranslator: Transformations::SchemaPerTypeTranslator
   struct Failed {};
 
   SchemaPerTypeTranslator (NarrowStrings const& type_regex,
-                           Boolean type_trace,
+                           bool type_trace,
                            NarrowStrings const& schema_regex,
-                           Boolean schema_trace);
+                           bool schema_trace);
 
-  virtual WideString
-  translate_type (WideString const& ns, WideString const& name);
+  virtual String
+  translate_type (String const& ns, String const& name);
 
   virtual NarrowString
   translate_schema (NarrowString const& file);
 
 private:
-  typedef BackendElements::Regex::Expression<WideChar> TypeRegex;
-  typedef BackendElements::Regex::Format<WideChar> TypeRegexFormat;
-  typedef Cult::Containers::Vector<TypeRegex> TypeRegexVector;
+  typedef cutl::re::wregexsub TypeRegex;
+  typedef cutl::re::wformat TypeRegexFormat;
+  typedef vector<TypeRegex> TypeRegexVector;
 
   TypeRegexVector type_regex_;
-  Boolean type_trace_;
+  bool type_trace_;
 
-  typedef BackendElements::Regex::Expression<Char> SchemaRegex;
-  typedef BackendElements::Regex::Format<Char> SchemaRegexFormat;
-  typedef Cult::Containers::Vector<SchemaRegex> SchemaRegexVector;
+  typedef cutl::re::regexsub SchemaRegex;
+  typedef cutl::re::format SchemaRegexFormat;
+  typedef vector<SchemaRegex> SchemaRegexVector;
 
   SchemaRegexVector schema_regex_;
-  Boolean schema_trace_;
+  bool schema_trace_;
 };
 
 //
@@ -227,57 +142,48 @@ struct XercesInitializer
 
 // Expand the \n escape sequence.
 //
-Void
+void
 expand_nl (NarrowString& s);
 
-
-Int
-main (Int argc, Char* argv[])
+int
+main (int argc, char* argv[])
 {
-  std::wostream& e (wcerr);
-
-  Cult::Trace::Log::instance ().level (0);
+  wostream& e (wcerr);
 
   try
   {
-    CLI::FileArguments args (argc, argv, "--options-file");
-
-    CLI::HelpOptions help_options (
-      CLI::parse (CLI::HelpOptionsSpec (), args, CLI::UnknownMode::stop));
+    cli::argv_file_scanner args (argc, argv, "--options-file");
+    help_options help_ops (args, cli::unknown_mode::stop);
 
     NarrowString cmd;
+    if (args.more ())
+      cmd = args.next ();
 
-    if (args.size () > 1)
+    if (help_ops.version () || cmd == "version")
     {
-      cmd = args[1];
-      args.erase (1);
-    }
+      wostream& o (wcout);
 
-    if (help_options.value<CLI::version> () || cmd == "version")
-    {
-      e << "CodeSynthesis XSD XML Schema to C++ compiler " <<
+      o << "CodeSynthesis XSD XML Schema to C++ compiler " <<
         XSD_STR_VERSION << endl
-        << "Copyright (C) 2005-2010 Code Synthesis Tools CC" << endl;
+        << "Copyright (c) 2005-2014 Code Synthesis Tools CC" << endl;
 
-      if (!help_options.value<CLI::proprietary_license> () &&
-          cmd == "version")
+      if (!help_ops.proprietary_license () && cmd == "version")
       {
         // Parse the options after the command to detect trailing
         // --proprietary-license.
         //
-        help_options = CLI::parse (
-          CLI::HelpOptionsSpec (), args, CLI::UnknownMode::stop);
+        help_ops = help_options (args, cli::unknown_mode::stop);
       }
 
-      if (help_options.value<CLI::proprietary_license> ())
+      if (help_ops.proprietary_license ())
       {
-        e << "The compiler was invoked in the Proprietary License mode. You "
+        o << "The compiler was invoked in the Proprietary License mode. You "
           << "should have\nreceived a proprietary license from Code Synthesis "
           << "Tools CC that entitles\nyou to use it in this mode." << endl;
       }
       else
       {
-        e << "This is free software; see the source for copying conditions. "
+        o << "This is free software; see the source for copying conditions. "
           << "There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS "
           << "FOR A PARTICULAR PURPOSE." << endl;
       }
@@ -285,15 +191,17 @@ main (Int argc, Char* argv[])
       return 0;
     }
 
-    if (help_options.value<CLI::help> () || cmd == "help")
+    if (help_ops.help () || cmd == "help")
     {
-      if (cmd == "help" && args.size () > 1)
+      wostream& o (wcout);
+
+      if (cmd == "help" && args.more ())
       {
-        NarrowString arg (args[1]);
+        NarrowString arg (args.next ());
 
         if (arg == "cxx-tree")
         {
-          e << "Usage: " << args[0] << " cxx-tree [options] file [file ...]"
+          o << "Usage: " << argv[0] << " cxx-tree [options] file [file ...]"
             << endl
             << "Options:" << endl;
 
@@ -301,7 +209,7 @@ main (Int argc, Char* argv[])
         }
         else if (arg == "cxx-parser")
         {
-          e << "Usage: " << args[0] << " cxx-parser [options] file [file ...]"
+          o << "Usage: " << argv[0] << " cxx-parser [options] file [file ...]"
             << endl
             << "Options:" << endl;
 
@@ -309,135 +217,33 @@ main (Int argc, Char* argv[])
         }
         else
         {
-          e << "error: unknown command '" << arg.c_str () << "'" << endl
-            << "info: try '" << args[0] << " help' for the list of commands"
+          o << "error: unknown command '" << arg.c_str () << "'" << endl
+            << "info: try '" << argv[0] << " help' for the list of commands"
             << endl;
 
           return 1;
         }
 
-        ::CLI::Indent::Clip< ::CLI::OptionsUsage, WideChar> clip (e);
-
-        // Disable warning option.
-        //
-        e << "--disable-warning <warn>" << endl
-          << " Disable printing warning with id <warn>. If 'all'\n"
-          << " is specified for the warning id then all warnings\n"
-          << " are disabled."
-          << endl;
-
-        // Anonymous morphing options.
-        //
-        e << "--preserve-anonymous" << endl
-          << " Preserve anonymous types. By default anonymous\n"
-          << " types are automatically named with names derived\n"
-          << " from the enclosing elements/attributes."
-          << endl;
-
-        e << "--anonymous-regex <regex>" << endl
-          << " Add the provided regular expression to the list of\n"
-          << " regular expressions used to derive names for\n"
-          << " anonymous types from the names of the enclosing\n"
-          << " attributes/elements."
-          << endl;
-
-        e << "--anonymous-regex-trace" << endl
-          << " Trace the process of applying regular expressions\n"
-          << " specified with the --anonymous-regex option."
-          << endl;
-
-        // Location mapping options.
-        //
-        e << "--location-map <ol>=<nl>" << endl
-          << " Map the original schema location <ol> that is\n"
-          << " specified in the XML Schema include or import\n"
-          << " elements to new schema location <nl>. Repeat\n"
-          << " this option to map more than one schema location."
-          << endl;
-
-        e << "--location-regex <regex>" << endl
-          << " Add <regex> to the list of regular expressions\n"
-          << " used to map schema locations that are specified\n"
-          << " in the XML Schema include or import elements."
-          << endl;
-
-        e << "--location-regex-trace" << endl
-          << " Trace the process of applying regular expressions\n"
-          << " specified with the --location-regex option."
-          << endl;
-
-        // File-per-type compilation mode options.
-        //
-        e << "--file-per-type" << endl
-          << " Generate a separate set of C++ files for each\n"
-          << " type defined in XML Schema."
-          << endl;
-
-        e << "--type-file-regex <regex>" << endl
-          << " Add the provided regular expression to the list of\n"
-          << " regular expressions used to translate type names\n"
-          << " to file names when the --file-per-type option is\n"
-          << " specified."
-          << endl;
-
-        e << "--type-file-regex-trace" << endl
-          << " Trace the process of applying regular expressions\n"
-          << " specified with the --type-file-regex option."
-          << endl;
-
-        e << "--schema-file-regex <regex>" << endl
-          << " Add the provided regular expression to the list\n"
-          << " of regular expressions used to translate schema\n"
-          << " file names when the --file-per-type option is\n"
-          << " specified."
-          << endl;
-
-        e << "--schema-file-regex-trace" << endl
-          << " Trace the process of applying regular expressions\n"
-          << " specified with the --schema-file-regex option."
-          << endl;
-
-        // File list options.
+        // Add frontend options at the end.
         //
-        e << "--file-list <file>" << endl
-          << " Write a list of generated C++ files to <file>."
-          << endl;
-
-        e << "--file-list-prologue <p>" << endl
-          << " Insert <p> at the beginning of the file list. All\n"
-          << " occurrences of the \\n character sequence in <p>\n"
-          << " are replaced with new lines."
-          << endl;
-
-        e << "--file-list-prologue <e>" << endl
-          << " Insert <e> at the end of the file list. All\n"
-          << " occurrences of the \\n character sequence in <e>\n"
-          << " are replaced with new lines."
-          << endl;
-
-        e << "--file-list-delim <d>" << endl
-          << " Delimit file names written to the file list with\n"
-          << " <d> instead of new lines. All occurrences of the\n"
-          << " \\n character sequence in <d> are replaced with\n"
-          << " new lines."
-          << endl;
+        options::print_usage (o);
       }
       else
       {
-        e << "Usage: " << args[0] << " <cmd> ..." << endl
+        o << "Usage: " << argv[0] << " <cmd> ..." << endl
           << "Commands:" << endl;
 
-        e << "  help            Print usage information and exit. Use\n"
+        o << "  help            Print usage information and exit. Use\n"
           << "                  'help <cmd>' for command-specific options."
           << endl;
 
-        e << "  version         Print version and exit."
+        o << "  version         Print version and exit."
           << endl;
 
-        e << "  cxx-tree        Generate the C++/Tree mapping."
+        o << "  cxx-tree        Generate the C++/Tree mapping."
           << endl;
 
-        e << "  cxx-parser      Generate the C++/Parser mapping."
+        o << "  cxx-parser      Generate the C++/Parser mapping."
           << endl;
       }
 
@@ -447,7 +253,7 @@ main (Int argc, Char* argv[])
     if (cmd.empty ())
     {
       e << "error: no command specified" << endl
-        << "info: try '" << args[0] << " help' for usage information" << endl;
+        << "info: try '" << argv[0] << " help' for usage information" << endl;
 
       return 1;
     }
@@ -455,7 +261,7 @@ main (Int argc, Char* argv[])
     if (cmd != "cxx-tree" && cmd != "cxx-parser")
     {
       e << "error: unknown command '" << cmd.c_str () << "'" << endl
-        << "info: try '" << args[0] << " help' for the list of commands"
+        << "info: try '" << argv[0] << " help' for the list of commands"
         << endl;
 
       return 1;
@@ -464,81 +270,57 @@ main (Int argc, Char* argv[])
     // We need to parse command line options before we can get to
     // the arguments.
     //
-    CLI::CommonOptionsSpec common_spec;
-    common_spec.option<CLI::file_list_delim> ().default_value ("\n");
+    auto_ptr<CXX::Tree::options> tree_ops (
+      cmd == "cxx-tree" ? new CXX::Tree::options (args) : 0);
+
+    auto_ptr<CXX::Parser::options> parser_ops (
+      cmd == "cxx-parser" ? new CXX::Parser::options (args) : 0);
 
-    CLI::CommonOptions common_ops (
-      CLI::parse (
-        common_spec,
-        args,
-        CLI::UnknownMode::skip,
-        CLI::UnknownMode::skip));
+    CXX::options& common_ops (
+      cmd == "cxx-tree"
+      ? static_cast<CXX::options&> (*tree_ops)
+      : static_cast<CXX::options&> (*parser_ops));
 
+    // Disabled warnings.
+    //
     WarningSet disabled_w;
     {
-      typedef Cult::Containers::Vector<NarrowString> Warnings;
-      Warnings const& w (common_ops.value<CLI::disable_warning> ());
+      NarrowStrings const& w (common_ops.disable_warning ());
 
-      for (Warnings::ConstIterator i (w.begin ()); i != w.end (); ++i)
+      for (NarrowStrings::const_iterator i (w.begin ()); i != w.end (); ++i)
         disabled_w.insert (*i);
     }
 
-    Boolean disabled_w_all (disabled_w.find ("all") != disabled_w.end ());
+    bool disabled_w_all (disabled_w.find ("all") != disabled_w.end ());
 
-    if (common_ops.value<CLI::morph_anonymous> () &&
-        !disabled_w_all && disabled_w.find ("D001") == disabled_w.end ())
+    if (common_ops.morph_anonymous () &&
+        !disabled_w_all &&
+        disabled_w.find ("D001") == disabled_w.end ())
     {
       e << "warning D001: the --morph-anonymous option is on by default and "
         << "no longer required"
         << endl;
     }
 
-    Evptr<CXX::Tree::CLI::Options> tree_ops;
-    Evptr<CXX::Parser::CLI::Options> parser_ops;
-
-    Boolean show_sloc (false);
-
-    if (cmd == "cxx-tree")
-    {
-      tree_ops = new CXX::Tree::CLI::Options (
-        CLI::parse (CXX::Tree::Generator::options_spec (), args));
-
-      tree_ops->value<CXX::Tree::CLI::disable_multi_import> () =
-        common_ops.value<CLI::disable_multi_import> ();
-
-      show_sloc = tree_ops->value<CXX::Tree::CLI::show_sloc> ();
-    }
-    else if (cmd == "cxx-parser")
-    {
-      parser_ops = new CXX::Parser::CLI::Options (
-        CLI::parse (CXX::Parser::Generator::options_spec (), args));
-
-      show_sloc = parser_ops->value<CXX::Parser::CLI::show_sloc> ();
-    }
+    // Collect all the files to compile in a vector.
+    //
+    NarrowStrings files;
 
+    while (args.more ())
+      files.push_back (args.next ());
 
-    if (args.size () < 2)
+    if (files.empty ())
     {
       e << "error: no input file specified" << endl;
       return 1;
     }
 
-    Boolean fpt (common_ops.value<CLI::file_per_type> ());
+    bool fpt (common_ops.file_per_type ());
 
     if (cmd == "cxx-tree" || cmd == "cxx-parser")
     {
-      Boolean gen (false), use (false);
-
-      if (cmd == "cxx-tree")
-      {
-        gen = tree_ops->value<CXX::Tree::CLI::generate_xml_schema> ();
-        use = tree_ops->value<CXX::Tree::CLI::extern_xml_schema> ();
-      }
-      else if (cmd == "cxx-parser")
-      {
-        gen = parser_ops->value<CXX::Parser::CLI::generate_xml_schema> ();
-        use = parser_ops->value<CXX::Parser::CLI::extern_xml_schema> ();
-      }
+      bool gen (common_ops.generate_xml_schema ());
+      bool use (common_ops.extern_xml_schema ());
 
       // Things get complicated when we are compiling several schemas at
       // once (non-file-per-type mode) and use the --generate-xml-schema/
@@ -549,7 +331,7 @@ main (Int argc, Char* argv[])
       //
       if (!fpt)
       {
-        if (args.size () > 2 && gen && !use)
+        if (files.size () > 1 && gen && !use)
         {
           e << "error: --extern-xml-schema is required when compiling more "
             << "than one schema and --generate-xml-schema is specified"
@@ -558,7 +340,7 @@ main (Int argc, Char* argv[])
           return 1;
         }
 
-        if (args.size () == 2 && gen && use)
+        if (files.size () == 1 && gen && use)
         {
           e << "error: --generate-xml-schema and --extern-xml-schema are "
             << "mutually exclusive when compiling a single schema" << endl;
@@ -596,22 +378,22 @@ main (Int argc, Char* argv[])
     //
     FileList file_list;
     AutoUnlinks unlinks;
-    UnsignedLong sloc (0);
+    size_t sloc (0);
 
     LocationTranslator loc_translator (
-      common_ops.value<CLI::location_map> (),
-      common_ops.value<CLI::location_regex> (),
-      common_ops.value<CLI::location_regex_trace> ());
+      common_ops.location_map (),
+      common_ops.location_regex (),
+      common_ops.location_regex_trace ());
 
     AnonymousNameTranslator anon_translator (
-      common_ops.value<CLI::anonymous_regex> (),
-      common_ops.value<CLI::anonymous_regex_trace> ());
+      common_ops.anonymous_regex (),
+      common_ops.anonymous_regex_trace ());
 
     // Load custom string literals, if any.
     //
     CXX::StringLiteralMap string_literal_map;
 
-    if (NarrowString file = common_ops.value<CLI::custom_literals> ())
+    if (NarrowString file = common_ops.custom_literals ())
     {
       XercesInitializer xerces_init;
 
@@ -628,7 +410,7 @@ main (Int argc, Char* argv[])
       // File-per-schema compilation mode.
       //
 
-      for (Size i (1); i < args.size (); ++i)
+      for (size_t i (0); i < files.size (); ++i)
       {
         // Parse schema.
         //
@@ -636,15 +418,11 @@ main (Int argc, Char* argv[])
 
         try
         {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-          tu = SemanticGraph::Path (args[i], boost::filesystem::native);
-#else
-          tu = SemanticGraph::Path (args[i]);
-#endif
+          tu = SemanticGraph::Path (files[i]);
         }
         catch (SemanticGraph::InvalidPath const&)
         {
-          e << "error: '" << args[i] << "' is not a valid "
+          e << "error: '" << files[i].c_str () << "' is not a valid "
             << "filesystem path" << endl;
 
           return 1;
@@ -652,12 +430,12 @@ main (Int argc, Char* argv[])
 
         XSDFrontend::Parser parser (
           cmd != "cxx-tree",
-          !common_ops.value<CLI::disable_multi_import> (),
-          !common_ops.value<CLI::disable_full_check> (),
+          !common_ops.disable_multi_import (),
+          !common_ops.disable_full_check (),
           loc_translator,
           disabled_w);
 
-        Evptr<SemanticGraph::Schema> schema;
+        auto_ptr<SemanticGraph::Schema> schema;
 
         if (cmd == "cxx-tree" || cmd == "cxx-parser")
         {
@@ -667,44 +445,14 @@ main (Int argc, Char* argv[])
           // will need to rely on the presence of the --extern-xml-schema
           // to tell us which (fake) schema file corresponds to XML Schema.
           //
-          Boolean gen_xml_schema (false);
+          bool gen_xml_schema (common_ops.generate_xml_schema ());
 
-          if (cmd == "cxx-tree")
-          {
-            gen_xml_schema =
-              tree_ops->value<CXX::Tree::CLI::generate_xml_schema> ();
-
-            if (gen_xml_schema)
-            {
-              if (NarrowString name =
-                  tree_ops->value<CXX::Tree::CLI::extern_xml_schema> ())
-              {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-                if (tu.native_file_string () != name)
-#else
-                if (tu.string () != name)
-#endif
-                  gen_xml_schema = false;
-              }
-            }
-          }
-          else if (cmd == "cxx-parser")
+          if (gen_xml_schema)
           {
-            gen_xml_schema =
-              parser_ops->value<CXX::Parser::CLI::generate_xml_schema> ();
-
-            if (gen_xml_schema)
+            if (NarrowString name = common_ops.extern_xml_schema ())
             {
-              if (NarrowString name =
-                  parser_ops->value<CXX::Parser::CLI::extern_xml_schema> ())
-              {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-                if (tu.native_file_string () != name)
-#else
-                if (tu.string () != name)
-#endif
-                  gen_xml_schema = false;
-              }
+              if (tu.string () != name)
+                gen_xml_schema = false;
             }
           }
 
@@ -718,7 +466,7 @@ main (Int argc, Char* argv[])
 
         // Morph anonymous types.
         //
-        if (!common_ops.value<CLI::preserve_anonymous> ())
+        if (!common_ops.preserve_anonymous ())
         {
           try
           {
@@ -835,21 +583,15 @@ main (Int argc, Char* argv[])
       //
       SemanticGraph::Paths paths;
 
-      for (Size i (1); i < args.size (); ++i)
+      for (size_t i (0); i < files.size (); ++i)
       {
         try
         {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-          paths.push_back (
-            SemanticGraph::Path (args[i], boost::filesystem::native));
-#else
-          paths.push_back (
-            SemanticGraph::Path (args[i]));
-#endif
+          paths.push_back (SemanticGraph::Path (files[i]));
         }
         catch (SemanticGraph::InvalidPath const&)
         {
-          e << "error: '" << args[i] << "' is not a valid "
+          e << "error: '" << files[i].c_str () << "' is not a valid "
             << "filesystem path" << endl;
 
           return 1;
@@ -858,7 +600,7 @@ main (Int argc, Char* argv[])
 
       if (cmd == "cxx-parser" &&
           paths.size () > 1 &&
-          parser_ops->value<CXX::Parser::CLI::generate_test_driver> ())
+          parser_ops->generate_test_driver ())
       {
         e << "info: generating test driver for the first schema only: '" <<
           paths[0] << "'" << endl;
@@ -866,21 +608,21 @@ main (Int argc, Char* argv[])
 
       XSDFrontend::Parser parser (
         cmd != "cxx-tree",
-        !common_ops.value<CLI::disable_multi_import> (),
-        !common_ops.value<CLI::disable_full_check> (),
+        !common_ops.disable_multi_import (),
+        !common_ops.disable_full_check (),
         loc_translator,
         disabled_w);
 
-      Evptr<SemanticGraph::Schema> schema (parser.parse (paths));
+      auto_ptr<SemanticGraph::Schema> schema (parser.parse (paths));
 
       // Morph anonymous types.
       //
-      if (!common_ops.value<CLI::preserve_anonymous> ())
+      if (!common_ops.preserve_anonymous ())
       {
         try
         {
           Transformations::Anonymous trans (anon_translator);
-          trans.transform (*schema, "", false);
+          trans.transform (*schema, SemanticGraph::Path (), false);
         }
         catch (Transformations::Anonymous::Failed const&)
         {
@@ -893,7 +635,7 @@ main (Int argc, Char* argv[])
       if (cmd == "cxx-tree")
       {
         Transformations::EnumSynthesis trans;
-        trans.transform (*schema, "");
+        trans.transform (*schema, SemanticGraph::Path ());
       }
 
       // Simplify the schema graph.
@@ -901,7 +643,7 @@ main (Int argc, Char* argv[])
       if (cmd == "cxx-parser")
       {
         Transformations::Simplifier trans;
-        trans.transform (*schema, "");
+        trans.transform (*schema, SemanticGraph::Path ());
       }
 
       // Normalize and annotate complex content restrictions.
@@ -911,7 +653,7 @@ main (Int argc, Char* argv[])
         try
         {
           Transformations::Restriction trans;
-          trans.transform (*schema, "");
+          trans.transform (*schema, SemanticGraph::Path ());
         }
         catch (Transformations::Restriction::Failed const&)
         {
@@ -923,26 +665,29 @@ main (Int argc, Char* argv[])
       //
       {
         Processing::Cardinality::Processor proc;
-        proc.process (*schema, "");
+        proc.process (*schema, SemanticGraph::Path ());
       }
 
       // Rearrange the graph so that each type is in a seperate
       // schema file.
       //
-      typedef Cult::Containers::Vector<SemanticGraph::Schema*> Schemas;
+      typedef vector<SemanticGraph::Schema*> Schemas;
 
       SchemaPerTypeTranslator type_translator (
-        common_ops.value<CLI::type_file_regex> (),
-        common_ops.value<CLI::type_file_regex_trace> (),
-        common_ops.value<CLI::schema_file_regex> (),
-        common_ops.value<CLI::schema_file_regex_trace> ());
+        common_ops.type_file_regex (),
+        common_ops.type_file_regex_trace (),
+        common_ops.schema_file_regex (),
+        common_ops.schema_file_regex_trace ());
+
+      Transformations::SchemaPerType trans (
+        type_translator,
+        common_ops.fat_type_file ());
 
-      Transformations::SchemaPerType trans (type_translator);
       Schemas schemas (trans.transform (*schema));
 
       // Generate code.
       //
-      for (Schemas::Iterator b (schemas.begin ()), i (b), e (schemas.end ());
+      for (Schemas::iterator b (schemas.begin ()), i (b), e (schemas.end ());
            i != e; ++i)
       {
         SemanticGraph::Schema& s (**i);
@@ -1001,24 +746,16 @@ main (Int argc, Char* argv[])
 
     // See if we need to produce the file list.
     //
-    if (NarrowString fl = common_ops.value<CLI::file_list> ())
+    if (NarrowString fl = common_ops.file_list ())
     {
-      typedef boost::filesystem::ofstream OutputFileStream;
+      typedef std::ofstream OutputFileStream;
 
       try
       {
         OutputFileStream ofs;
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
         SemanticGraph::Path path (fl);
-#else
-        SemanticGraph::Path path (fl.c_str());
-#endif
 
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-        ofs.open (fl, std::ios_base::out);
-#else
-        ofs.open (fl.c_str(), std::ios_base::out);
-#endif
+        ofs.open (path.string ().c_str (), ios_base::out);
 
         if (!ofs.is_open ())
         {
@@ -1026,16 +763,16 @@ main (Int argc, Char* argv[])
           return 1;
         }
 
-        NarrowString d (common_ops.value<CLI::file_list_delim> ());
+        NarrowString d (common_ops.file_list_delim ());
         expand_nl (d);
 
-        if (NarrowString p = common_ops.value<CLI::file_list_prologue> ())
+        if (NarrowString p = common_ops.file_list_prologue ())
         {
           expand_nl (p);
           ofs << p;
         }
 
-        for (FileList::Iterator i (file_list.begin ()), e (file_list.end ());
+        for (FileList::iterator i (file_list.begin ()), e (file_list.end ());
              i != e;)
         {
           ofs << *i;
@@ -1044,7 +781,7 @@ main (Int argc, Char* argv[])
             ofs << d;
         }
 
-        if (NarrowString e = common_ops.value<CLI::file_list_epilogue> ())
+        if (NarrowString e = common_ops.file_list_epilogue ())
         {
           expand_nl (e);
           ofs << e;
@@ -1058,10 +795,10 @@ main (Int argc, Char* argv[])
       }
     }
 
-    if (show_sloc)
+    if (common_ops.show_sloc ())
       e << "total: " << sloc << endl;
 
-    if (UnsignedLong sloc_limit = common_ops.value<CLI::sloc_limit> ())
+    if (size_t sloc_limit = common_ops.sloc_limit ())
     {
       if (sloc_limit < sloc)
       {
@@ -1096,26 +833,10 @@ main (Int argc, Char* argv[])
   {
     // Diagnostic has already been issued.
   }
-  catch (CLI::UnexpectedOption const& e)
+  catch (cli::exception const& ex)
   {
-    wcerr << "error: unknown option '" << e.option ().c_str () << "'" << endl
-          << "info: try '" << argv[0] << " help' for usage information"
-          << endl;
-  }
-  catch (CLI::OptionFormat const& e)
-  {
-    wcerr << "error: value for option '" << e.option ().c_str ()
-          << "' is invalid or missing" << endl
-          << "info: try '" << argv[0] << " help' for usage information"
-          << endl;
-  }
-  catch (CLI::OptionFile const& e)
-  {
-    if (e.value ())
-      wcerr << "error: " << e.value ().c_str () << ": "
-            << e.description ().c_str () << endl;
-    else
-      wcerr << "error: missing --options-file argument" << endl;
+    wcerr << ex << endl;
+    wcerr << "try '" << argv[0] << " help' for usage information" << endl;
   }
 
   return 1;
@@ -1127,16 +848,16 @@ main (Int argc, Char* argv[])
 LocationTranslator::
 LocationTranslator (NarrowStrings const& map,
                     NarrowStrings const& regex,
-                    Boolean trace)
+                    bool trace)
     : trace_ (trace)
 {
   // Map.
   //
-  for (NarrowStrings::ConstIterator i (map.begin ()); i != map.end (); ++i)
+  for (NarrowStrings::const_iterator i (map.begin ()); i != map.end (); ++i)
   {
     // Split the string in two parts at the last '='.
     //
-    Size pos (i->rfind ('='));
+    size_t pos (i->rfind ('='));
 
     if (pos == NarrowString::npos)
     {
@@ -1151,7 +872,7 @@ LocationTranslator (NarrowStrings const& map,
 
   // Regex.
   //
-  for (NarrowStrings::ConstIterator i (regex.begin ()); i != regex.end (); ++i)
+  for (NarrowStrings::const_iterator i (regex.begin ()); i != regex.end (); ++i)
   {
     try
     {
@@ -1160,7 +881,7 @@ LocationTranslator (NarrowStrings const& map,
     catch (RegexFormat const& e)
     {
       wcerr << "error: invalid location regex: '" <<
-        e.expression ().c_str () << "': " <<
+        e.regex ().c_str () << "': " <<
         e.description ().c_str () << endl;
 
       throw Failed ();
@@ -1173,14 +894,14 @@ translate (NarrowString const& l)
 {
   // First check the cache.
   //
-  Cache::ConstIterator ci (cache_.find (l));
+  Cache::const_iterator ci (cache_.find (l));
 
   if (ci != cache_.end ())
     return ci->second;
 
   // Then check the direct map.
   //
-  Map::ConstIterator mi (map_.find (l));
+  Map::const_iterator mi (map_.find (l));
 
   if (mi != map_.end ())
   {
@@ -1193,15 +914,15 @@ translate (NarrowString const& l)
   if (trace_)
     wcerr << "location: '" << l.c_str () << "'" << endl;
 
-  for (RegexVector::ReverseIterator i (regex_.rbegin ());
+  for (RegexVector::reverse_iterator i (regex_.rbegin ());
        i != regex_.rend (); ++i)
   {
     if (trace_)
-      wcerr << "try: '" << i->pattern () << "' : ";
+      wcerr << "try: '" << i->regex ().str ().c_str () << "' : ";
 
     if (i->match (l))
     {
-      NarrowString r (i->merge (l));
+      NarrowString r (i->replace (l));
 
       if (trace_)
         wcerr << "'" << r.c_str () << "' : +" << endl;
@@ -1224,45 +945,45 @@ translate (NarrowString const& l)
 //
 
 AnonymousNameTranslator::
-AnonymousNameTranslator (NarrowStrings const& regex, Boolean trace)
+AnonymousNameTranslator (NarrowStrings const& regex, bool trace)
     : trace_ (trace)
 {
-  for (NarrowStrings::ConstIterator i (regex.begin ()); i != regex.end (); ++i)
+  for (NarrowStrings::const_iterator i (regex.begin ()); i != regex.end (); ++i)
   {
     try
     {
-      regex_.push_back (Regex (*i));
+      regex_.push_back (Regex (String (*i)));
     }
     catch (RegexFormat const& e)
     {
       wcerr << "error: invalid anonymous type regex: '" <<
-        e.expression () << "': " << e.description () << endl;
+        e.regex () << "': " << e.description ().c_str () << endl;
 
       throw Failed ();
     }
   }
 }
 
-WideString AnonymousNameTranslator::
-translate (WideString const& file,
-           WideString const& ns,
-           WideString const& name,
-           WideString const& xpath)
+String AnonymousNameTranslator::
+translate (String const& file,
+           String const& ns,
+           String const& name,
+           String const& xpath)
 {
-  WideString s (file + L' ' + ns + L' ' + xpath);
+  String s (file + L' ' + ns + L' ' + xpath);
 
   if (trace_)
     wcerr << "anonymous type: '" << s << "'" << endl;
 
-  for (RegexVector::ReverseIterator i (regex_.rbegin ());
+  for (RegexVector::reverse_iterator i (regex_.rbegin ());
        i != regex_.rend (); ++i)
   {
     if (trace_)
-      wcerr << "try: '" << i->pattern () << "' : ";
+      wcerr << "try: '" << i->regex () << "' : ";
 
     if (i->match (s))
     {
-      WideString r (i->merge (s));
+      String r (i->replace (s));
 
       if (trace_)
         wcerr << "'" << r << "' : +" << endl;
@@ -1284,28 +1005,28 @@ translate (WideString const& file,
 
 SchemaPerTypeTranslator::
 SchemaPerTypeTranslator (NarrowStrings const& type_regex,
-                         Boolean type_trace,
+                         bool type_trace,
                          NarrowStrings const& schema_regex,
-                         Boolean schema_trace)
+                         bool schema_trace)
     : type_trace_ (type_trace), schema_trace_ (schema_trace)
 {
-  for (NarrowStrings::ConstIterator i (type_regex.begin ());
+  for (NarrowStrings::const_iterator i (type_regex.begin ());
        i != type_regex.end (); ++i)
   {
     try
     {
-      type_regex_.push_back (TypeRegex (*i));
+      type_regex_.push_back (TypeRegex (String (*i)));
     }
     catch (TypeRegexFormat const& e)
     {
       wcerr << "error: invalid type file regex: '" <<
-        e.expression () << "': " << e.description () << endl;
+        e.regex () << "': " << e.description ().c_str () << endl;
 
       throw Failed ();
     }
   }
 
-  for (NarrowStrings::ConstIterator i (schema_regex.begin ());
+  for (NarrowStrings::const_iterator i (schema_regex.begin ());
        i != schema_regex.end (); ++i)
   {
     try
@@ -1315,30 +1036,30 @@ SchemaPerTypeTranslator (NarrowStrings const& type_regex,
     catch (SchemaRegexFormat const& e)
     {
       wcerr << "error: invalid type file regex: '" <<
-        e.expression ().c_str () << "': " << e.description ().c_str () << endl;
+        e.regex ().c_str () << "': " << e.description ().c_str () << endl;
 
       throw Failed ();
     }
   }
 }
 
-WideString SchemaPerTypeTranslator::
-translate_type (WideString const& ns, WideString const& name)
+String SchemaPerTypeTranslator::
+translate_type (String const& ns, String const& name)
 {
-  WideString s (ns + L' ' + name);
+  String s (ns + L' ' + name);
 
   if (type_trace_)
     wcerr << "type: '" << s << "'" << endl;
 
-  for (TypeRegexVector::ReverseIterator i (type_regex_.rbegin ());
+  for (TypeRegexVector::reverse_iterator i (type_regex_.rbegin ());
        i != type_regex_.rend (); ++i)
   {
     if (type_trace_)
-      wcerr << "try: '" << i->pattern () << "' : ";
+      wcerr << "try: '" << i->regex () << "' : ";
 
     if (i->match (s))
     {
-      WideString r (i->merge (s));
+      String r (i->replace (s));
 
       if (type_trace_)
         wcerr << "'" << r << "' : +" << endl;
@@ -1361,15 +1082,15 @@ translate_schema (NarrowString const& file)
   if (schema_trace_)
     wcerr << "schema: '" << file.c_str () << "'" << endl;
 
-  for (SchemaRegexVector::ReverseIterator i (schema_regex_.rbegin ());
+  for (SchemaRegexVector::reverse_iterator i (schema_regex_.rbegin ());
        i != schema_regex_.rend (); ++i)
   {
     if (schema_trace_)
-      wcerr << "try: '" << i->pattern () << "' : ";
+      wcerr << "try: '" << i->regex ().str ().c_str () << "' : ";
 
     if (i->match (file))
     {
-      NarrowString r (i->merge (file));
+      NarrowString r (i->replace (file));
 
       if (schema_trace_)
         wcerr << "'" << r.c_str () << "' : +" << endl;
@@ -1388,10 +1109,10 @@ translate_schema (NarrowString const& file)
 
 //
 //
-Void
+void
 expand_nl (NarrowString& s)
 {
-  for (Size i (0); i < s.size ();)
+  for (size_t i (0); i < s.size ();)
   {
     if (s[i] == '\\' && (i + 1) < s.size () && s[i + 1] == 'n')
     {
diff --git a/xsd/xsd/xsd.hxx b/xsd/xsd/xsd.hxx
index 508c8da..8b9d6fe 100644
--- a/xsd/xsd/xsd.hxx
+++ b/xsd/xsd/xsd.hxx
@@ -1,84 +1,25 @@
 // file      : xsd/xsd.hxx
-// author    : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2010 Code Synthesis Tools CC
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
 // license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
 #ifndef XSD_HXX
 #define XSD_HXX
 
-#include <xsd-frontend/semantic-graph/elements.hxx> // Path
-
-#include <cult/types.hxx>
-#include <cult/containers/set.hxx>
-#include <cult/containers/vector.hxx>
-
-
+#include <set>
+#include <vector>
 #include <cstdio> // std::remove
 
-using namespace Cult::Types;
-
-//
-//
-typedef Cult::Containers::Set<NarrowString> WarningSet;
+#include <cutl/shared-ptr.hxx>
+#include <cutl/fs/auto-remove.hxx>
 
-//
-//
-typedef Cult::Containers::Vector<NarrowString> FileList;
-
-//
-//
-struct AutoUnlink
-{
-  AutoUnlink (XSDFrontend::SemanticGraph::Path const& file)
-      : file_ (file), canceled_ (false)
-  {
-  }
-
-  ~AutoUnlink ()
-  {
-    if (!canceled_)
-    {
-#if !defined(BOOST_FILESYSTEM_VERSION) || BOOST_FILESYSTEM_VERSION == 2
-      std::remove (file_.native_file_string ().c_str ());
-#else
-      std::remove (file_.string ().c_str ());
-#endif
-    }
-  }
-
-  void
-  cancel ()
-  {
-    canceled_ = true;
-  }
-
-private:
-  XSDFrontend::SemanticGraph::Path file_;
-  Boolean canceled_;
-};
+#include <xsd-frontend/semantic-graph/elements.hxx> // Path
 
-//
-//
-struct AutoUnlinks
-{
-  Void
-  add (XSDFrontend::SemanticGraph::Path const& file)
-  {
-    unlinks_.push_back (Evptr<AutoUnlink> (new AutoUnlink (file)));
-  }
+#include <types.hxx>
 
-  Void
-  cancel ()
-  {
-    for (Unlinks::Iterator i (unlinks_.begin ()); i != unlinks_.end (); ++i)
-    {
-      (*i)->cancel ();
-    }
-  }
+typedef std::set<NarrowString> WarningSet;
+typedef std::vector<NarrowString> FileList;
 
-private:
-  typedef Cult::Containers::Vector<Evptr<AutoUnlink> > Unlinks;
-  Unlinks unlinks_;
-};
+typedef cutl::fs::auto_remove AutoUnlink;
+typedef cutl::fs::auto_removes AutoUnlinks;
 
 #endif // XSD_HXX