[Boost-commit] svn:boost r61564 - in trunk/libs/spirit/example/scheme: scheme test test/scheme

Subject: [Boost-commit] svn:boost r61564 - in trunk/libs/spirit/example/scheme: scheme test test/scheme
From: joel_at_[hidden]
Date: 2010-04-25 22:02:49

Author: djowel
Date: 2010-04-25 22:02:48 EDT (Sun, 25 Apr 2010)
New Revision: 61564
URL: http://svn.boost.org/trac/boost/changeset/61564

Log:
updates
Text files modified: 
   trunk/libs/spirit/example/scheme/scheme/compiler.hpp          |    15 ++-                                     
   trunk/libs/spirit/example/scheme/test/qi_interpreter.cpp      |   146 +++++++++++++++++++++++++++++++++++---- 
   trunk/libs/spirit/example/scheme/test/scheme/scheme_test3.cpp |    14 +++                                     
   3 files changed, 149 insertions(+), 26 deletions(-)

Modified: trunk/libs/spirit/example/scheme/scheme/compiler.hpp
==============================================================================
--- trunk/libs/spirit/example/scheme/scheme/compiler.hpp	(original)
+++ trunk/libs/spirit/example/scheme/scheme/compiler.hpp	2010-04-25 22:02:48 EDT (Sun, 25 Apr 2010)
@@ -555,11 +555,12 @@
         interpreter(
             Source& in,
             std::string const& source_file = "",
-            environment* outer = 0)
-          : env(outer)
+            environment* envp = 0)
         {
-            if (outer == 0)
+            if (envp == 0)
                 build_basic_environment(env);
+            else
+                env = *envp;
 
             if (input::parse_sexpr_list(in, program, source_file))
             {
@@ -569,11 +570,13 @@
 
         interpreter(
             utree const& program,
-            environment* outer = 0)
-          : env(outer)
+            environment* envp = 0)
         {
-            if (outer == 0)
+            if (envp == 0)
                 build_basic_environment(env);
+            else
+                env = *envp;
+
             compile_all(program, env, flist, fragments);
         }
 

Modified: trunk/libs/spirit/example/scheme/test/qi_interpreter.cpp
==============================================================================
--- trunk/libs/spirit/example/scheme/test/qi_interpreter.cpp	(original)
+++ trunk/libs/spirit/example/scheme/test/qi_interpreter.cpp	2010-04-25 22:02:48 EDT (Sun, 25 Apr 2010)
@@ -13,7 +13,9 @@
 #include <utree/io.hpp>
 #include <boost/spirit/include/qi.hpp>
 
-namespace scheme
+#include "../../../test/qi/test.hpp"
+
+namespace scheme { namespace qi
 {
     ///////////////////////////////////////////////////////////////////////////
     // parser compiler
@@ -24,6 +26,10 @@
     typedef qi::rule<char const*> skipper_type;
     typedef qi::rule<char const*, utree(), skipper_type> rule_type;
 
+    ///////////////////////////////////////////////////////////////////////////
+    // All rule are stored here. Rules are held in the utree by its id;
+    // i.e. it's index in the vector.
+    ///////////////////////////////////////////////////////////////////////////
     template <typename Rule>
     class rule_fragments
     {
@@ -32,18 +38,21 @@
         rule_fragments() {};
 
         template <typename Expr>
-        boost::tuple<Rule const&, int>
-        new_rule(Expr const& expr)
+        int new_rule(Expr const& expr)
         {
             rules.push_back(Rule());
             rules.front() = expr;
-            return boost::tuple<Rule const&, int>(
-                rules.front(), rules.size()-1);
+            return rules.size()-1;
         }
 
         Rule const& get_rule(int id) const
         {
-            return rules[i];
+            return rules[id];
+        }
+
+        Rule const& get_rule(utree const& id) const
+        {
+            return rules[id.get<int>()];
         }
 
     private:
@@ -51,6 +60,11 @@
         std::vector<Rule> rules;
     };
 
+    ///////////////////////////////////////////////////////////////////////////
+    // Composes primitive parsers held by index. Handles the compilation of
+    // primitive (nullary) parsers such as int_, double_, alpha, space and all
+    // those that require no arguments.
+    ///////////////////////////////////////////////////////////////////////////
     struct primitive_parser_composite : composite<primitive_parser_composite>
     {
         int id;
@@ -69,43 +83,141 @@
     inline primitive_parser_composite
     make_primitive_parser_composite(Fragments& fragments, Expr const& expr)
     {
-        return primitive_parser_composite(
-            boost::get<1>(fragments.new_rule(expr)));
+        return primitive_parser_composite(fragments.new_rule(expr));
     }
 
+    ///////////////////////////////////////////////////////////////////////////
+    // Handles the compilation of char_
+    ///////////////////////////////////////////////////////////////////////////
     template <typename Fragments>
-    void build_qi_environment(Fragments& fragments, environment& env)
+    struct char_function : actor<char_function<Fragments> >
+    {
+        Fragments& fragments;
+        function a;
+        function b;
+        char_function(
+            Fragments& fragments, function const& a, function const& b)
+          : a(a), b(b), fragments(fragments)
+        {
+        }
+
+        utree eval(utree const& a) const
+        {
+            // $$$ use exceptions here $$$.
+            BOOST_ASSERT(a.which() == utree_type::string_type);
+
+            utf8_string_range a_ = a.get<utf8_string_range>();
+            if (a_.size() == 1)
+            {
+                // char_('x')
+                return fragments.new_rule(qi::char_(a_[0]));
+            }
+            else
+            {
+                // char_("some-regex")
+                return fragments.new_rule(
+                    qi::char_(std::string(a_.begin(), a_.end())));
+            }
+        }
+
+        utree eval(utree const& a, utree const& b) const
+        {
+            // $$$ use exceptions here $$$.
+            BOOST_ASSERT(a.which() == utree_type::string_type);
+            BOOST_ASSERT(b.which() == utree_type::string_type);
+
+            utf8_string_range a_ = a.get<utf8_string_range>();
+            utf8_string_range b_ = b.get<utf8_string_range>();
+            // $$$ use exceptions here $$$.
+            BOOST_ASSERT(a_.size() == 1);
+            BOOST_ASSERT(b_.size() == 1);
+
+            // char_('x', 'y')
+            return fragments.new_rule(qi::char_(a_[0], b_[0]));
+        }
+
+        utree eval(scope const& env) const
+        {
+            if (b.empty())
+                return eval(a(env));
+            else
+                return eval(a(env), b(env));
+        }
+    };
+
+    template <typename Fragments>
+    struct unary_char_composite
+      : composite<unary_char_composite<Fragments> >
+    {
+        Fragments& fragments;
+        unary_char_composite(Fragments& fragments)
+          : fragments(fragments) {}
+
+        function compose(actor_list const& elements) const
+        {
+            typedef char_function<Fragments> function_type;
+            actor_list::const_iterator i = elements.begin();
+
+            function empty;
+            function const& a = *i++;
+            function const& b = (i == elements.end())? empty : *i;
+            return function(function_type(fragments, a, b));
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Build our scheme compiler environment.
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Fragments>
+    void build_environment(Fragments& fragments, environment& env)
     {
         build_basic_environment(env);
+
         env.define("qi:space",
             make_primitive_parser_composite(fragments, qi::space), 0, true);
+
         env.define("qi:alpha",
             make_primitive_parser_composite(fragments, qi::alpha), 0, true);
+
         env.define("qi:int_",
             make_primitive_parser_composite(fragments, qi::int_), 0, true);
+
+        env.define("qi:char_",
+            unary_char_composite<Fragments>(fragments), 1, false);
     }
-}
+}}
 
 ///////////////////////////////////////////////////////////////////////////////
 //  Main program
 ///////////////////////////////////////////////////////////////////////////////
 int main()
 {
+    using scheme::utree;
     using scheme::interpreter;
     using scheme::environment;
-    using scheme::build_qi_environment;
-    using scheme::rule_fragments;
-    using scheme::rule_type;
-    using scheme::utree;
+    using scheme::qi::build_environment;
+    using scheme::qi::rule_fragments;
+    using scheme::qi::rule_type;
+    using spirit_test::test;
 
     environment env;
     rule_fragments<rule_type> fragments;
-    build_qi_environment(fragments, env);
+    build_environment(fragments, env);
+
+    scheme::qi::skipper_type space = boost::spirit::qi::space;
 
     {
-        utree src = "(define foo 123)";
+        utree src =
+            "(define r (qi:char_ \"x\"))"
+            "(define r2 (qi:int_))";
         interpreter parser(src, "parse.scm", &env);
-        std::cout << parser["qi:int_"]() << std::endl;
+        //~ std::cout << parser["r"]() << std::endl;
+        //~ std::cout << parser["r2"]() << std::endl;
+
+        BOOST_TEST(test("x", fragments.get_rule(parser["r"]()), space));
+        BOOST_TEST(!test("y", fragments.get_rule(parser["r"]()), space));
+
+
     }
 
     return boost::report_errors();

Modified: trunk/libs/spirit/example/scheme/test/scheme/scheme_test3.cpp
==============================================================================
--- trunk/libs/spirit/example/scheme/test/scheme/scheme_test3.cpp	(original)
+++ trunk/libs/spirit/example/scheme/test/scheme/scheme_test3.cpp	2010-04-25 22:02:48 EDT (Sun, 25 Apr 2010)
@@ -20,9 +20,17 @@
     using scheme::interpreter;
     using scheme::utree;
 
-    utree src = "(define (factorial n) (if (<= n 0) 1 (* n (factorial (- n 1)))))";
-    scheme::interpreter program(src);
-    BOOST_TEST(program["factorial"](10) == 3628800);
+    {
+        utree src = "(define n 123)";
+        scheme::interpreter program(src);
+        BOOST_TEST(program["n"]() == 123);
+    }
+
+    {
+        utree src = "(define (factorial n) (if (<= n 0) 1 (* n (factorial (- n 1)))))";
+        scheme::interpreter program(src);
+        BOOST_TEST(program["factorial"](10) == 3628800);
+    }
 
     return boost::report_errors();
 }