From c90e0f7b3ab78b4df877db5f45b87b3af91db5ab Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Fri, 2 Apr 2010 19:38:00 +0200
Subject: Move parser into a separate set of files

---
 odb/parser.hxx | 148 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 148 insertions(+)
 create mode 100644 odb/parser.hxx

(limited to 'odb/parser.hxx')

diff --git a/odb/parser.hxx b/odb/parser.hxx
new file mode 100644
index 0000000..128abb5
--- /dev/null
+++ b/odb/parser.hxx
@@ -0,0 +1,148 @@
+// file      : odb/parser.hxx
+// author    : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2009-2010 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_PARSER_HXX
+#define ODB_PARSER_HXX
+
+#include <odb/gcc.hxx>
+
+#include <set>
+#include <string>
+#include <memory>  // std::auto_ptr
+#include <ostream>
+
+#include <odb/pragma.hxx>
+#include <odb/options.hxx>
+#include <odb/semantics.hxx>
+
+class parser
+{
+public:
+  class failed {};
+
+  parser (options const& ops, loc_pragmas const&, decl_pragmas const&);
+
+  std::auto_ptr<semantics::unit>
+  parse (tree global_scope, semantics::path const& main_file);
+
+private:
+  typedef semantics::path path;
+  typedef semantics::access access;
+
+  // Extended GGC tree declaration that is either a tree node or a
+  // pragma. If this declaration is a pragma, then the assoc flag
+  // indicated whether this pragma has been associated with a
+  // declaration.
+  //
+  struct tree_decl
+  {
+    tree decl;
+    pragma const* prag;
+    mutable bool assoc; // Allow modification via std::set iterator.
+
+    tree_decl (tree d): decl (d), prag (0) {}
+    tree_decl (pragma const& p): decl (0), prag (&p), assoc (false) {}
+
+    bool
+    operator< (tree_decl const& y) const;
+  };
+
+  typedef std::multiset<tree_decl> decl_set;
+
+private:
+  void
+  collect (tree ns);
+
+  void
+  emit ();
+
+  // Emit a type declaration. This is either a named class-type definition/
+  // declaration or a typedef. In the former case the function returns the
+  // newly created type node. In the latter case it returns 0.
+  //
+  semantics::type*
+  emit_type_decl (tree);
+
+  // Emit a template declaration.
+  //
+  void
+  emit_template_decl (tree);
+
+  semantics::class_template&
+  emit_class_template (tree, bool stub = false);
+
+  semantics::union_template&
+  emit_union_template (tree, bool stub = false);
+
+  template <typename T>
+  T&
+  emit_class (tree, path const& f, size_t l, size_t c, bool stub = false);
+
+  template <typename T>
+  T&
+  emit_union (tree, path const& f, size_t l, size_t c, bool stub = false);
+
+  semantics::enum_&
+  emit_enum (tree, path const& f, size_t l, size_t c, bool stub = false);
+
+  // Create new or find existing semantic graph type.
+  //
+  semantics::type&
+  emit_type (tree, path const& f, size_t l, size_t c);
+
+  semantics::type&
+  create_type (tree, path const& f, size_t l, size_t c);
+
+  std::string
+  emit_type_name (tree, bool direct = true);
+
+
+  // Pragma handling.
+  //
+  void
+  process_pragmas (tree,
+                   semantics::node&,
+                   std::string const& name,
+                   decl_set::const_iterator begin,
+                   decl_set::const_iterator cur,
+                   decl_set::const_iterator end);
+
+  void
+  diagnose_unassoc_pragmas (decl_set const&);
+
+  // Return declaration's fully-qualified scope name (e.g., ::foo::bar).
+  //
+  std::string
+  fq_scope (tree);
+
+  // Return declaration's access.
+  //
+  access
+  decl_access (tree);
+
+  //
+  //
+  template <typename T>
+  void
+  define_fund (tree);
+
+private:
+  options const& ops_;
+  loc_pragmas const& loc_pragmas_;
+  decl_pragmas const& decl_pragmas_;
+
+  bool trace;
+  std::ostream& ts;
+
+  semantics::unit* unit_;
+  semantics::scope* scope_;
+
+  std::size_t error_;
+
+  decl_set decls_;
+};
+
+
+#endif // ODB_PARSER_HXX
-- 
cgit v1.1