[Boost-commit] svn:boost r61237 - trunk/libs/spirit/example/scheme

Subject: [Boost-commit] svn:boost r61237 - trunk/libs/spirit/example/scheme
From: joel_at_[hidden]
Date: 2010-04-13 01:03:05

Author: djowel
Date: 2010-04-13 01:03:05 EDT (Tue, 13 Apr 2010)
New Revision: 61237
URL: http://svn.boost.org/trac/boost/changeset/61237

Log:
perfection! (almost)
Text files modified: 
   trunk/libs/spirit/example/scheme/scheme_compiler.hpp    |    66 ++++++++++++++++++++------------------- 
   trunk/libs/spirit/example/scheme/scheme_interpreter.hpp |    27 +--------------                         
   2 files changed, 37 insertions(+), 56 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-13 01:03:05 EDT (Tue, 13 Apr 2010)
@@ -17,32 +17,10 @@
 namespace scheme
 {
 ///////////////////////////////////////////////////////////////////////////////
-//  Utilities
+//  The environment
 ///////////////////////////////////////////////////////////////////////////////
-    inline std::string get_symbol(utree const& s)
-    {
-        utf8_symbol_range symbol = s.as<utf8_symbol_range>();
-        return std::string(symbol.begin(), symbol.end());
-    }
-
-    struct external_function : composite<external_function>
-    {
-        // we must hold f by reference because functions can be recursive
-        boost::reference_wrapper<actor const> f;
-
-        external_function(actor const& f)
-          : f(f) {}
+    typedef boost::function<actor(actor_list const&)> compiled_function;
 
-        using base_type::operator();
-        actor operator()(actor_list const& elements) const
-        {
-            return actor(apply_function(f, elements));
-        }
-    };
-
-///////////////////////////////////////////////////////////////////////////////
-//  The compiler
-///////////////////////////////////////////////////////////////////////////////
     class environment
     {
     public:
@@ -50,17 +28,17 @@
         environment(environment* parent = 0)
           : outer(parent) {}
 
-        template <typename FunctionCall>
-        void define(std::string const& name, FunctionCall const& f)
+        template <typename Function>
+        void define(std::string const& name, Function const& f)
         {
             // $$$ use exceptions here? $$$
             BOOST_ASSERT(definitions.find(name) == definitions.end());
-            definitions[name] = function_call(f);
+            definitions[name] = compiled_function(f);
         }
 
-        function_call* find(std::string const& name)
+        compiled_function* find(std::string const& name)
         {
-            std::map<std::string, function_call>::iterator
+            std::map<std::string, compiled_function>::iterator
                 i = definitions.find(name);
             if (i != definitions.end())
                 return &i->second;
@@ -74,11 +52,29 @@
     private:
 
         environment* outer;
-        std::map<std::string, function_call> definitions;
+        std::map<std::string, compiled_function> definitions;
     };
 
     actor compile(utree const& ast, environment& env, actor_list& fragments);
 
+///////////////////////////////////////////////////////////////////////////////
+//  The compiler
+///////////////////////////////////////////////////////////////////////////////
+    struct external_function : composite<external_function>
+    {
+        // we must hold f by reference because functions can be recursive
+        boost::reference_wrapper<actor const> f;
+
+        external_function(actor const& f)
+          : f(f) {}
+
+        using base_type::operator();
+        actor operator()(actor_list const& elements) const
+        {
+            return actor(lambda_function(f, elements));
+        }
+    };
+
     struct compiler
     {
         typedef actor result_type;
@@ -104,7 +100,7 @@
         actor operator()(utf8_symbol_range const& str) const
         {
             std::string name(str.begin(), str.end());
-            if (function_call* mf = env.find(name))
+            if (compiled_function* mf = env.find(name))
             {
                 actor_list flist;
                 return (*mf)(flist);
@@ -167,7 +163,7 @@
                 return actor(val(utf8_symbol("<define " + fname + ">")));
             }
 
-            if (function_call* mf = env.find(name))
+            if (compiled_function* mf = env.find(name))
             {
                 actor_list flist;
                 Iterator i = range.begin(); ++i;
@@ -178,6 +174,12 @@
 
             return actor(); // $$$ implement me $$$
         }
+
+        static std::string get_symbol(utree const& s)
+        {
+            utf8_symbol_range symbol = s.as<utf8_symbol_range>();
+            return std::string(symbol.begin(), symbol.end());
+        }
     };
 
     inline actor compile(

Modified: trunk/libs/spirit/example/scheme/scheme_interpreter.hpp
==============================================================================
--- trunk/libs/spirit/example/scheme/scheme_interpreter.hpp	(original)
+++ trunk/libs/spirit/example/scheme/scheme_interpreter.hpp	2010-04-13 01:03:05 EDT (Tue, 13 Apr 2010)
@@ -30,7 +30,6 @@
     typedef std::list<actor> actor_list;
     typedef boost::iterator_range<utree const*> args_type;
     typedef boost::function<utree(args_type args)> actor_function;
-    typedef boost::function<actor(actor_list const&)> delayed_function;
 
     struct actor
     {
@@ -201,35 +200,15 @@
     };
 
     ///////////////////////////////////////////////////////////////////////////
-    // function_call
-    ///////////////////////////////////////////////////////////////////////////
-    struct function_call : composite<function_call>
-    {
-        delayed_function f;
-
-        function_call()
-          : f() {}
-
-        function_call(delayed_function const& f)
-          : f(f) {}
-
-        using base_type::operator();
-        actor operator()(actor_list const& elements) const
-        {
-            return f(elements);
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
     // function
     ///////////////////////////////////////////////////////////////////////////
-    struct apply_function
+    struct lambda_function
     {
         actor_list elements;
         // we must hold f by reference because functions can be recursive
         boost::reference_wrapper<actor const> f;
 
-        apply_function(actor const& f, actor_list const& elements)
+        lambda_function(actor const& f, actor_list const& elements)
           : elements(elements), f(f) {}
 
         typedef utree result_type;
@@ -264,7 +243,7 @@
         using base_type::operator();
         actor operator()(actor_list const& elements) const
         {
-            return actor(apply_function(f, elements));
+            return actor(lambda_function(f, elements));
         }
 
         function& operator=(function const& other)