remerge

1 files changed, 997 insertions, 0 deletions

diff --git a/libxsd-frontend/xsd-frontend/semantic-graph/elements.hxx b/libxsd-frontend/xsd-frontend/semantic-graph/elements.hxx
new file mode 100644
index 0000000..98fb180
--- /dev/null
+++ b/libxsd-frontend/xsd-frontend/semantic-graph/elements.hxx
@@ -0,0 +1,997 @@
+// file      : xsd-frontend/semantic-graph/elements.hxx
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_FRONTEND_SEMANTIC_GRAPH_ELEMENTS_HXX
+#define XSD_FRONTEND_SEMANTIC_GRAPH_ELEMENTS_HXX
+
+#include <set>
+#include <map>
+#include <list>
+#include <vector>
+#include <iosfwd>
+#include <utility> // std::pair
+#include <cstdlib> // abort
+#include <cassert>
+
+#include <cutl/container/graph.hxx>
+#include <cutl/container/pointer-iterator.hxx>
+#include <cutl/compiler/context.hxx>
+#include <cutl/fs/path.hxx>
+
+#include <xsd-frontend/types.hxx>
+
+namespace XSDFrontend
+{
+  namespace SemanticGraph
+  {
+    using namespace cutl;
+
+    using container::pointer_iterator;
+
+    //
+    //
+    typedef fs::path Path;
+    typedef fs::invalid_path InvalidPath;
+    typedef std::vector<Path> Paths;
+
+    typedef compiler::context Context;
+
+    //
+    //
+    class Node;
+    class Edge;
+
+    //
+    //
+    class Annotates;
+    class Annotation;
+
+    //
+    //
+    class Edge
+    {
+    public:
+      Context&
+      context () const
+      {
+        return context_;
+      }
+
+      virtual
+      ~Edge ()
+      {
+      }
+
+    public:
+      template <typename X>
+      bool
+      is_a () const
+      {
+        return dynamic_cast<X const*> (this) != 0;
+      }
+
+    private:
+      mutable Context context_;
+    };
+
+    inline bool
+    operator== (Edge const& x, Edge const& y)
+    {
+      return &x == &y;
+    }
+
+
+    //
+    //
+    class Node
+    {
+    public:
+      Context&
+      context () const
+      {
+        return context_;
+      }
+
+    public:
+      Path const&
+      file () const
+      {
+        return file_;
+      }
+
+      unsigned long
+      line () const
+      {
+        return line_;
+      }
+
+      unsigned long
+      column () const
+      {
+        return column_;
+      }
+
+    public:
+      bool
+      annotated_p () const
+      {
+        return annotates_ != 0;
+      }
+
+      Annotates&
+      annotated () const
+      {
+        return *annotates_;
+      }
+
+      Annotation&
+      annotation ();
+
+    public:
+      template <typename X>
+      bool
+      is_a () const
+      {
+        return dynamic_cast<X const*> (this) != 0;
+      }
+
+    public:
+      virtual
+      ~Node () {}
+
+      Node (Path const& file, unsigned long line, unsigned long column)
+          : annotates_ (0), file_ (file), line_ (line), column_ (column)
+      {
+      }
+
+      void
+      add_edge_right (Annotates& a)
+      {
+        annotates_ = &a;
+      }
+
+    protected:
+      Node () // For virtual inheritance.
+      {
+        abort (); // Told you so!
+      }
+
+    private:
+      mutable Context context_;
+      Annotates* annotates_;
+      Path file_;
+      unsigned long line_;
+      unsigned long column_;
+    };
+
+    inline bool
+    operator== (Node const& x, Node const& y)
+    {
+      return &x == &y;
+    }
+
+    //
+    //
+    typedef container::graph<Node, Edge> graph;
+
+    //
+    //
+    typedef String Name;
+
+
+    //
+    //
+    class Scope;
+    class Nameable;
+
+
+    //
+    //
+    class Names: public virtual Edge
+    {
+    public:
+      Name
+      name () const
+      {
+        return name_;
+      }
+
+      Scope&
+      scope () const
+      {
+        return *scope_;
+      }
+
+      Nameable&
+      named () const
+      {
+        return *named_;
+      }
+
+    public:
+      Names (Name const& name): name_ (name) {}
+
+      void
+      set_left_node (Scope& n)
+      {
+        scope_ = &n;
+      }
+
+      void
+      set_right_node (Nameable& n)
+      {
+        named_ = &n;
+      }
+
+      void
+      clear_left_node (Scope& n)
+      {
+        assert (scope_ == &n);
+        scope_ = 0;
+      }
+
+      void
+      clear_right_node (Nameable& n)
+      {
+        assert (named_ == &n);
+        named_ = 0;
+      }
+
+    private:
+      Scope* scope_;
+      Nameable* named_;
+      Name name_;
+    };
+
+
+    class Nameable: public virtual Node
+    {
+    public:
+      bool
+      named_p () const
+      {
+        return named_ != 0;
+      }
+
+      Name
+      name () const
+      {
+        assert (named_p ());
+        return named_->name ();
+      }
+
+      Scope&
+      scope ()
+      {
+        assert (named_p ());
+        return named_->scope ();
+      }
+
+      Names&
+      named ()
+      {
+        assert (named_p ());
+        return *named_;
+      }
+
+    public:
+      Nameable (): named_ (0) {}
+
+      void
+      add_edge_right (Names& e)
+      {
+        named_ = &e;
+      }
+
+      void
+      remove_edge_right (Names& e)
+      {
+        assert (named_ == &e);
+        named_ = 0;
+      }
+
+      using Node::add_edge_right;
+
+    private:
+      Names* named_;
+    };
+
+    //
+    //
+    typedef std::set<Nameable*> Nameables;
+
+    //
+    //
+    class Scope: public virtual Nameable
+    {
+    protected:
+      typedef std::list<Names*> NamesList;
+      typedef std::map<Names*, NamesList::iterator> ListIteratorMap;
+      typedef std::map<Name, NamesList> NamesMap;
+
+    public:
+      typedef pointer_iterator<NamesList::iterator> NamesIterator;
+      typedef pointer_iterator<NamesList::const_iterator> NamesConstIterator;
+
+      typedef
+      std::pair<NamesConstIterator, NamesConstIterator>
+      NamesIteratorPair;
+
+      NamesIterator
+      names_begin ()
+      {
+        return names_.begin ();
+      }
+
+      NamesIterator
+      names_end ()
+      {
+        return names_.end ();
+      }
+
+      NamesConstIterator
+      names_begin () const
+      {
+        return names_.begin ();
+      }
+
+      NamesConstIterator
+      names_end () const
+      {
+        return names_.end ();
+      }
+
+      virtual NamesIteratorPair
+      find (Name const& name) const
+      {
+        NamesMap::const_iterator i (names_map_.find (name));
+
+        if (i == names_map_.end ())
+          return NamesIteratorPair (names_.end (), names_.end ());
+        else
+          return NamesIteratorPair (i->second.begin (), i->second.end ());
+      }
+
+      NamesIterator
+      find (Names& e)
+      {
+        ListIteratorMap::iterator i (iterator_map_.find (&e));
+        return i != iterator_map_.end () ? i->second : names_.end ();
+      }
+
+    public:
+      Scope (Path const& file, unsigned long line, unsigned long column)
+          : Node (file, line, column)
+      {
+      }
+
+      void
+      add_edge_left (Names& e)
+      {
+        NamesList::iterator i (names_.insert (names_.end (), &e));
+        iterator_map_[&e] = i;
+        names_map_[e.name ()].push_back (&e);
+      }
+
+      void
+      remove_edge_left (Names& e)
+      {
+        ListIteratorMap::iterator i (iterator_map_.find (&e));
+        assert (i != iterator_map_.end ());
+
+        names_.erase (i->second);
+        iterator_map_.erase (i);
+
+        NamesMap::iterator j (names_map_.find (e.name ()));
+
+        for (NamesList::iterator i (j->second.begin ());
+             i != j->second.end (); ++i)
+        {
+          if (*i == &e)
+            i = j->second.erase (i);
+        }
+      }
+
+      void
+      add_edge_left (Names& e, NamesIterator const& after)
+      {
+        NamesList::iterator i;
+
+        if (after.base () == names_.end ())
+          i = names_.insert (names_.begin (), &e);
+        else
+        {
+          NamesList::iterator j (after.base ());
+          i = names_.insert (++j, &e);
+        }
+
+        iterator_map_[&e] = i;
+        names_map_[e.name ()].push_back (&e);
+      }
+
+      using Nameable::add_edge_right;
+
+    protected:
+      Scope () {}
+
+    private:
+      NamesList names_;
+      ListIteratorMap iterator_map_;
+      NamesMap names_map_;
+    };
+
+
+    //
+    //
+    class Belongs;
+    class Inherits;
+    class Arguments;
+
+    class Type: public virtual Nameable
+    {
+    protected:
+      typedef std::vector<Belongs*> Classifies;
+      typedef std::vector<Inherits*> Begets;
+      typedef std::set<Arguments*> ArgumentsSet;
+
+    public:
+      typedef pointer_iterator<Classifies::const_iterator> ClassifiesIterator;
+
+      ClassifiesIterator
+      classifies_begin () const
+      {
+        return classifies_.begin ();
+      }
+
+      ClassifiesIterator
+      classifies_end () const
+      {
+        return classifies_.end ();
+      }
+
+      //
+      //
+      bool
+      inherits_p () const
+      {
+        return inherits_ != 0;
+      }
+
+      Inherits&
+      inherits () const
+      {
+        assert (inherits_ != 0);
+        return *inherits_;
+      }
+
+      //
+      //
+      typedef pointer_iterator<Begets::const_iterator> BegetsIterator;
+
+      BegetsIterator
+      begets_begin () const
+      {
+        return begets_.begin ();
+      }
+
+      BegetsIterator
+      begets_end () const
+      {
+        return begets_.end ();
+      }
+
+      //
+      //
+      typedef pointer_iterator<ArgumentsSet::const_iterator> ArgumentsIterator;
+
+      ArgumentsIterator
+      arguments_begin () const
+      {
+        return arguments_.begin ();
+      }
+
+      ArgumentsIterator
+      arguments_end () const
+      {
+        return arguments_.end ();
+      }
+
+    public:
+      Type (): inherits_ (0) {}
+
+      void
+      add_edge_right (Belongs& e)
+      {
+        classifies_.push_back (&e);
+      }
+
+      void
+      add_edge_right (Inherits& e)
+      {
+        begets_.push_back (&e);
+      }
+
+      using Nameable::add_edge_right;
+
+      void
+      add_edge_left (Arguments& a)
+      {
+        arguments_.insert (&a);
+      }
+
+      void
+      remove_edge_left (Arguments&);
+
+      void
+      add_edge_left (Inherits& e)
+      {
+        inherits_ = &e;
+      }
+
+    private:
+      Inherits* inherits_;
+      Begets begets_;
+      Classifies classifies_;
+      ArgumentsSet arguments_;
+    };
+
+    class Instance: public virtual Nameable
+    {
+    public:
+      Belongs&
+      belongs () const
+      {
+        return *belongs_;
+      }
+
+      Type&
+      type () const;
+
+      bool
+      typed_p () const
+      {
+        return belongs_ != 0;
+      }
+
+    public:
+      Instance (): belongs_ (0) {}
+
+      void
+      add_edge_left (Belongs& e)
+      {
+        belongs_ = &e;
+      }
+
+    private:
+      Belongs* belongs_;
+    };
+
+
+    class Belongs: public virtual Edge
+    {
+    public:
+      Instance&
+      instance () const
+      {
+        return *instance_;
+      }
+
+      Type&
+      type () const
+      {
+        return *type_;
+      }
+
+    public:
+      void
+      set_left_node (Instance& n)
+      {
+        instance_ = &n;
+      }
+
+      void
+      set_right_node (Type& n)
+      {
+        type_ = &n;
+      }
+
+    private:
+      Instance* instance_;
+      Type* type_;
+    };
+
+
+    //
+    //
+    class Inherits: public virtual Edge
+    {
+    public:
+      Type&
+      base () const
+      {
+        return *base_;
+      }
+
+      Type&
+      derived () const
+      {
+        return *derived_;
+      }
+
+    public:
+      void
+      set_left_node (Type& n)
+      {
+        derived_ = &n;
+      }
+
+      void
+      set_right_node (Type& n)
+      {
+        base_ = &n;
+      }
+
+    private:
+      Type* base_;
+      Type* derived_;
+    };
+
+    class Extends: public virtual Inherits
+    {
+    };
+
+    class Restricts: public virtual Inherits
+    {
+    public:
+      typedef std::map<String, String> Facets;
+      typedef Facets::iterator FacetIterator;
+
+      bool
+      facet_empty ()
+      {
+        return facets_.empty ();
+      }
+
+      FacetIterator
+      facet_begin ()
+      {
+        return facets_.begin ();
+      }
+
+      FacetIterator
+      facet_end ()
+      {
+        return facets_.end ();
+      }
+
+      FacetIterator
+      facet_find (String const& name)
+      {
+        return facets_.find (name);
+      }
+
+      void
+      facet_insert (String const& name, String const& value)
+      {
+        facets_[name] = value;
+      }
+
+      Facets const&
+      facets () const
+      {
+        return facets_;
+      }
+
+    protected:
+      Facets facets_;
+    };
+
+
+    //
+    //
+    class Member;
+    class Namespace;
+
+    class BelongsToNamespace: public virtual Edge
+    {
+    public:
+      Member&
+      member () const
+      {
+        assert (member_ != 0);
+        return *member_;
+      }
+
+      Namespace&
+      namespace_ () const
+      {
+        assert (namespace__ != 0);
+        return *namespace__;
+      }
+
+    public:
+      BelongsToNamespace (): member_ (0), namespace__ (0) {}
+
+      void
+      set_left_node (Member& n)
+      {
+        member_ = &n;
+      }
+
+      void
+      set_right_node (Namespace& n)
+      {
+        namespace__ = &n;
+      }
+
+    private:
+      Member* member_;
+      Namespace* namespace__;
+    };
+
+    //
+    //
+    class Member: public virtual Instance
+    {
+    public:
+      // Member is global either if it is defined outside any type
+      // or it is a ref="" of a global member.
+      //
+      bool
+      global_p () const
+      {
+        return global_;
+      }
+
+      bool
+      qualified_p () const
+      {
+        return qualified_;
+      }
+
+      // Note that only qualified members belong to a namespace.
+      //
+      Namespace&
+      namespace_ () const
+      {
+        assert (belongs_to_namespace_ != 0);
+        return belongs_to_namespace_->namespace_ ();
+      }
+
+
+      // Default and fixed value API. Note that the fixed value semantics
+      // is a superset of the default value semantics. As such setting the
+      // fixed value appears as if the default value was also set.
+      //
+      bool
+      default_p () const
+      {
+        return value_type_ != ValueType::none;
+      }
+
+      bool
+      fixed_p () const
+      {
+        return value_type_ == ValueType::fixed;
+      }
+
+      struct NoValue {};
+
+      String
+      value () const
+      {
+        if (value_type_ != ValueType::none)
+          return value_;
+        else
+          throw NoValue ();
+      }
+
+      //
+      //
+      void
+      default_ (String const& v)
+      {
+        value_ = v;
+        value_type_ = ValueType::default_;
+      }
+
+      void
+      fixed (String const& v)
+      {
+        value_ = v;
+        value_type_ = ValueType::fixed;
+      }
+
+    public:
+      Member (bool global, bool qualified)
+          : global_ (global),
+            qualified_ (qualified),
+            belongs_to_namespace_ (0),
+            value_type_ (ValueType::none)
+      {
+      }
+
+      void
+      add_edge_left (BelongsToNamespace& e)
+      {
+        // In the parser we sometimes re-add the same adge.
+        //
+        belongs_to_namespace_ = &e;
+      }
+
+      using Instance::add_edge_left;
+
+    private:
+      bool global_;
+      bool qualified_;
+      BelongsToNamespace* belongs_to_namespace_;
+
+      struct ValueType
+      {
+        enum Value
+        {
+          none,
+          default_,
+          fixed
+        };
+      };
+
+      String value_;
+      ValueType::Value value_type_;
+    };
+
+
+    // Parametric types.
+    //
+
+    class Specialization: public virtual Type
+    {
+      typedef std::vector<Arguments*> Argumented;
+
+    public:
+      typedef pointer_iterator<Argumented::iterator> ArgumentedIterator;
+      typedef
+      pointer_iterator<Argumented::const_iterator>
+      ArgumentedConstIterator;
+
+      ArgumentedIterator
+      argumented_begin ()
+      {
+        return argumented_.begin ();
+      }
+
+      ArgumentedConstIterator
+      argumented_begin () const
+      {
+        return argumented_.begin ();
+      }
+
+      ArgumentedIterator
+      argumented_end ()
+      {
+        return argumented_.end ();
+      }
+
+      ArgumentedConstIterator
+      argumented_end () const
+      {
+        return argumented_.end ();
+      }
+
+      // Shortcut for one-argument specializations.
+      //
+      Arguments&
+      argumented () const
+      {
+        return *argumented_[0];
+      }
+
+    public:
+      using Type::add_edge_right;
+
+      void
+      add_edge_right (Arguments& a)
+      {
+        argumented_.push_back (&a);
+      }
+
+      void
+      add_edge_right (Arguments& a, ArgumentedIterator const& pos)
+      {
+        argumented_.insert (pos.base (), &a);
+      }
+
+      void
+      remove_edge_right (Arguments&);
+
+    private:
+      Argumented argumented_;
+    };
+
+    class Arguments: public virtual Edge
+    {
+    public:
+      Type&
+      type () const
+      {
+        return *type_;
+      }
+
+      Specialization&
+      specialization () const
+      {
+        return *specialization_;
+      }
+
+    public:
+      void
+      set_left_node (Type& n)
+      {
+        type_ = &n;
+      }
+
+      void
+      clear_left_node (Type& n)
+      {
+        assert (type_ == &n);
+        type_ = 0;
+      }
+
+      void
+      set_right_node (Specialization& s)
+      {
+        specialization_ = &s;
+      }
+
+      void
+      clear_right_node (Specialization& s)
+      {
+        assert (specialization_ == &s);
+        specialization_ = 0;
+      }
+
+    private:
+      Type* type_;
+      Specialization* specialization_;
+    };
+
+
+    //
+    //
+    class AnyType: public virtual Type
+    {
+    public:
+      AnyType (Path const& file, unsigned long line, unsigned long column)
+          : Node (file, line, column)
+      {
+      }
+
+    protected:
+      AnyType () {} // For virtual inheritance.
+    };
+
+
+    //
+    //
+    class AnySimpleType: public virtual Type
+    {
+    public:
+      AnySimpleType (Path const& file, unsigned long line, unsigned long column)
+          : Node (file, line, column)
+      {
+      }
+
+    protected:
+      AnySimpleType () {} // For virtual inheritance.
+    };
+  }
+}
+
+// ADL won't find it because Path is a typedef. Note that this
+// function prints in native format.
+//
+std::wostream&
+operator<< (std::wostream& os, XSDFrontend::SemanticGraph::Path const& path);
+
+#endif  // XSD_FRONTEND_SEMANTIC_GRAPH_ELEMENTS_HXX