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

Subject: [Boost-commit] svn:boost r61190 - in trunk/libs/spirit/example/scheme: . test
From: joel_at_[hidden]
Date: 2010-04-10 21:35:50

Author: djowel
Date: 2010-04-10 21:35:46 EDT (Sat, 10 Apr 2010)
New Revision: 61190
URL: http://svn.boost.org/trac/boost/changeset/61190

Log:
putting stuff into header files
Added:
   trunk/libs/spirit/example/scheme/scheme_compiler.hpp   (contents, props changed)
   trunk/libs/spirit/example/scheme/scheme_interpreter.hpp   (contents, props changed)
Text files modified: 
   trunk/libs/spirit/example/scheme/test/scheme.cpp |   314 --------------------------------------- 
   1 files changed, 2 insertions(+), 312 deletions(-)

Added: trunk/libs/spirit/example/scheme/scheme_compiler.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/scheme/scheme_compiler.hpp	2010-04-10 21:35:46 EDT (Sat, 10 Apr 2010)
@@ -0,0 +1,183 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_SCHEME_INTERPRETER)
+#define BOOST_SPIRIT_SCHEME_INTERPRETERnamespace scheme
+
+#include <vector>
+#include <map>
+#include <boost/bind.hpp>
+
+namespace scheme
+{
+///////////////////////////////////////////////////////////////////////////////
+//  Utilities
+///////////////////////////////////////////////////////////////////////////////
+    inline std::string get_symbol(utree const& s)
+    {
+        utf8_symbol_range symbol = s.as<utf8_symbol_range>();
+        return std::string(symbol.begin(), symbol.end());
+    }
+
+///////////////////////////////////////////////////////////////////////////////
+//  The compiler
+///////////////////////////////////////////////////////////////////////////////
+    typedef boost::function<function(function_list&)> function_compiler;
+
+    class compiler_environment
+    {
+    public:
+
+        compiler_environment(compiler_environment* parent = 0)
+          : outer(parent) {}
+
+        void define(std::string const& name, function_compiler const& def)
+        {
+            // $$$ use exceptions here $$$
+            BOOST_ASSERT(definitions.find(name) == definitions.end());
+            definitions[name] = def;
+        }
+
+        function_compiler* find(std::string const& name)
+        {
+            std::map<std::string, function_compiler>::iterator
+                i = definitions.find(name);
+            if (i != definitions.end())
+                return &i->second;
+            else if (outer != 0)
+                return outer->find(name);
+            return 0;
+        }
+
+        compiler_environment* parent() const { return outer; }
+
+    private:
+
+        compiler_environment* outer;
+        std::map<std::string, function_compiler> definitions;
+    };
+
+    function compile(utree const& ast, compiler_environment& env);
+
+    struct compiler
+    {
+        typedef function result_type;
+
+        mutable compiler_environment& env;
+        compiler(compiler_environment& env)
+          : env(env)
+        {
+        }
+
+        function operator()(nil) const
+        {
+            return scheme::val(utree());
+        }
+
+        template <typename T>
+        function operator()(T const& val) const
+        {
+            return scheme::val(utree(val));
+        }
+
+        function operator()(utf8_symbol_range const& str) const
+        {
+            std::string name(str.begin(), str.end());
+
+            if (function_compiler* mf = env.find(name))
+            {
+                function_list flist;
+                return (*mf)(flist);
+            }
+            // $$$ throw? $$$
+            return function();
+        }
+
+        void define_function(
+            std::string const& name,
+            std::vector<std::string> const& args,
+            utree const& body) const
+        {
+            compiler_environment local_env(env);
+            for (std::size_t i = 0; i < args.size(); ++i)
+                local_env.define(args[i], boost::bind(arg, i));
+            env.define(name,
+                function_compiler(call(compile(body, local_env), args.size())));
+        }
+
+        void define_nullary_function(
+            std::string const& name,
+            utree const& body) const
+        {
+            env.define(name,
+                function_compiler(call(compile(body, env), 0)));
+        }
+
+        template <typename Iterator>
+        function operator()(boost::iterator_range<Iterator> const& range) const
+        {
+            std::string name(get_symbol(*range.begin()));
+
+            if (name == "define")
+            {
+                Iterator i = range.begin(); ++i;
+                if (i->which() == utree_type::list_type)
+                {
+                    // a function
+                    utree const& decl = *i++;
+                    Iterator di = decl.begin();
+                    std::string fname(get_symbol(*di++));
+                    std::vector<std::string> args;
+                    while (di != decl.end())
+                        args.push_back(get_symbol(*di++));
+                    define_function(fname, args, *i);
+                }
+                else
+                {
+                    // constants (nullary functions)
+                    std::string fname(get_symbol(*i++));
+                    define_nullary_function(fname, *i);
+                }
+                return function(val(utree(utf8_symbol("<function>"))));
+            }
+
+            if (function_compiler* mf = env.find(name))
+            {
+                function_list flist;
+                Iterator i = range.begin(); ++i;
+                for (; i != range.end(); ++i)
+                    flist.push_back(compile(*i, env));
+                return (*mf)(flist);
+            }
+
+            return function(); // $$$ implement me $$$
+        }
+    };
+
+    function compile(utree const& ast, compiler_environment& env)
+    {
+        return utree::visit(ast, compiler(env));
+    }
+
+    void compile_all(
+        utree const& ast,
+        compiler_environment& env,
+        function_list& results)
+    {
+        BOOST_FOREACH(utree const& program, ast)
+        {
+            scheme::function f = compile(program, env);
+            results.push_back(f);
+        }
+    }
+
+    void build_basic_environment(compiler_environment& env)
+    {
+        env.define("+", plus_composer());
+    }
+}
+
+#endif

Added: trunk/libs/spirit/example/scheme/scheme_interpreter.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/scheme/scheme_interpreter.hpp	2010-04-10 21:35:46 EDT (Sat, 10 Apr 2010)
@@ -0,0 +1,151 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_SCHEME_INTERPRETER)
+#define BOOST_SPIRIT_SCHEME_INTERPRETERnamespace scheme
+
+#include <list>
+#include <boost/function.hpp>
+#include <boost/foreach.hpp>
+
+namespace scheme
+{
+///////////////////////////////////////////////////////////////////////////////
+//  The runtime interpreter
+///////////////////////////////////////////////////////////////////////////////
+
+    typedef boost::function<utree(utree const& args)> function;
+    typedef std::list<function> function_list;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // values
+    ///////////////////////////////////////////////////////////////////////////
+    struct value
+    {
+        utree val;
+        value(utree const& val) : val(val) {}
+
+        typedef utree result_type;
+        utree operator()(utree const& /*args*/) const
+        {
+            return utree(boost::ref(val));
+        }
+    };
+
+    struct value_composer
+    {
+        typedef function result_type;
+        function operator()(utree const& val) const
+        {
+            return function(value(val));
+        }
+    };
+
+    value_composer const val = {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // arguments
+    ///////////////////////////////////////////////////////////////////////////
+    struct argument
+    {
+        int n;
+        argument(int n) : n(n) {}
+
+        typedef utree result_type;
+        utree operator()(utree const& args) const
+        {
+            return utree(boost::ref(args[n]));
+        }
+    };
+
+    struct argument_composer
+    {
+        typedef function result_type;
+        function operator()(int n) const
+        {
+            return function(argument(n));
+        }
+    };
+
+    argument_composer const arg = {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // plus
+    ///////////////////////////////////////////////////////////////////////////
+    struct plus_function
+    {
+        function_list elements;
+        plus_function(function_list const& elements)
+          : elements(elements) {}
+
+        typedef utree result_type;
+        utree operator()(utree const& args) const
+        {
+            utree result(0);
+            BOOST_FOREACH(function const& element, elements)
+            {
+                result = result + element(args);
+            }
+            return result;
+        }
+    };
+
+    struct plus_composer
+    {
+        typedef function result_type;
+        function operator()(function_list const& elements)
+        {
+            return function(plus_function(elements));
+        }
+    };
+
+    plus_composer const plus = {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    // call
+    ///////////////////////////////////////////////////////////////////////////
+    struct call_function
+    {
+        function_list elements;
+        function f;
+        call_function(function const& f, function_list const& elements)
+          : elements(elements), f(f) {}
+
+        typedef utree result_type;
+        utree operator()(utree const& args) const
+        {
+            utree fargs;
+            BOOST_FOREACH(function const& element, elements)
+            {
+                fargs.push_back(element(args));
+            }
+            return f(fargs);
+        }
+    };
+
+    struct call_composer
+    {
+        function f;
+        int arity;
+        call_composer(function const& f, int arity)
+          : f(f), arity(arity) {}
+
+        typedef function result_type;
+        function operator()(function_list const& elements)
+        {
+            // $$$ use throw $$$
+            BOOST_ASSERT(elements.size() == arity);
+            return function(call_function(f, elements));
+        }
+    };
+
+    inline call_composer const call(function const& f, int arity)
+    {
+        return call_composer(f, arity);
+    }
+}
+
+#endif

Modified: trunk/libs/spirit/example/scheme/test/scheme.cpp
==============================================================================
--- trunk/libs/spirit/example/scheme/test/scheme.cpp	(original)
+++ trunk/libs/spirit/example/scheme/test/scheme.cpp	2010-04-10 21:35:46 EDT (Sat, 10 Apr 2010)
@@ -8,6 +8,8 @@
 
 #include "../input/sexpr.hpp"
 #include "../input/parse_sexpr_impl.hpp"
+#include "../scheme_interpreter.hpp"
+#include "../scheme_compiler.hpp"
 #include <iostream>
 #include <fstream>
 
@@ -17,318 +19,6 @@
     return out;
 }
 
-#include <vector>
-#include <list>
-#include <map>
-#include <boost/function.hpp>
-#include <boost/foreach.hpp>
-#include <boost/bind.hpp>
-
-namespace scheme
-{
-///////////////////////////////////////////////////////////////////////////////
-//  Utilities
-///////////////////////////////////////////////////////////////////////////////
-    inline std::string get_symbol(utree const& s)
-    {
-        utf8_symbol_range symbol = s.as<utf8_symbol_range>();
-        return std::string(symbol.begin(), symbol.end());
-    }
-
-///////////////////////////////////////////////////////////////////////////////
-//  The runtime interpreter
-///////////////////////////////////////////////////////////////////////////////
-
-    typedef boost::function<utree(utree const& args)> function;
-    typedef std::list<function> function_list;
-
-    ///////////////////////////////////////////////////////////////////////////
-    // values
-    ///////////////////////////////////////////////////////////////////////////
-    struct value
-    {
-        utree val;
-        value(utree const& val) : val(val) {}
-
-        typedef utree result_type;
-        utree operator()(utree const& /*args*/) const
-        {
-            return utree(boost::ref(val));
-        }
-    };
-
-    struct value_composer
-    {
-        typedef function result_type;
-        function operator()(utree const& val) const
-        {
-            return function(value(val));
-        }
-    };
-
-    value_composer const val = {};
-
-    ///////////////////////////////////////////////////////////////////////////
-    // arguments
-    ///////////////////////////////////////////////////////////////////////////
-    struct argument
-    {
-        int n;
-        argument(int n) : n(n) {}
-
-        typedef utree result_type;
-        utree operator()(utree const& args) const
-        {
-            return utree(boost::ref(args[n]));
-        }
-    };
-
-    struct argument_composer
-    {
-        typedef function result_type;
-        function operator()(int n) const
-        {
-            return function(argument(n));
-        }
-    };
-
-    argument_composer const arg = {};
-
-    ///////////////////////////////////////////////////////////////////////////
-    // composite
-    ///////////////////////////////////////////////////////////////////////////
-    struct composite
-    {
-        function_list elements;
-        composite(function_list const& elements)
-          : elements(elements) {}
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    // plus
-    ///////////////////////////////////////////////////////////////////////////
-    struct plus_function : composite
-    {
-        plus_function(function_list const& elements)
-          : composite(elements) {}
-
-        typedef utree result_type;
-        utree operator()(utree const& args) const
-        {
-            utree result(0);
-            BOOST_FOREACH(function const& element, elements)
-            {
-                result = result + element(args);
-            }
-            return result;
-        }
-    };
-
-    struct plus_composer
-    {
-        typedef function result_type;
-        function operator()(function_list& elements)
-        {
-            return function(plus_function(elements));
-        }
-    };
-
-    plus_composer const plus = {};
-
-    ///////////////////////////////////////////////////////////////////////////
-    // call
-    ///////////////////////////////////////////////////////////////////////////
-    struct call_function : composite
-    {
-        function f;
-        call_function(function const& f, function_list const& elements)
-          : composite(elements), f(f) {}
-
-        typedef utree result_type;
-        utree operator()(utree const& args) const
-        {
-            utree fargs;
-            BOOST_FOREACH(function const& operand, elements)
-            {
-                fargs.push_back(operand(args));
-            }
-            return f(fargs);
-        }
-    };
-
-    struct call_composer
-    {
-        function f;
-        int arity;
-        call_composer(function const& f, int arity)
-          : f(f), arity(arity) {}
-
-        typedef function result_type;
-        function operator()(function_list& elements)
-        {
-            // $$$ use throw $$$
-            BOOST_ASSERT(elements.size() == arity);
-            return function(call_function(f, elements));
-        }
-    };
-
-    inline call_composer const call(function const& f, int arity)
-    {
-        return call_composer(f, arity);
-    }
-
-///////////////////////////////////////////////////////////////////////////////
-//  The compiler
-///////////////////////////////////////////////////////////////////////////////
-    typedef boost::function<function(function_list&)> function_compiler;
-
-    struct compiler_environment
-    {
-        compiler_environment(compiler_environment* parent = 0)
-          : parent(parent) {}
-
-        void define(std::string const& name, function_compiler const& def)
-        {
-            // $$$ use exceptions here $$$
-            BOOST_ASSERT(definitions.find(name) == definitions.end());
-            definitions[name] = def;
-        }
-
-        function_compiler* find(std::string const& name)
-        {
-            std::map<std::string, function_compiler>::iterator
-                i = definitions.find(name);
-            if (i != definitions.end())
-                return &i->second;
-            else if (parent != 0)
-                return parent->find(name);
-            return 0;
-        }
-
-        compiler_environment* parent;
-        std::map<std::string, function_compiler> definitions;
-    };
-
-    function compile(utree const& ast, compiler_environment& env);
-
-    struct compiler
-    {
-        typedef function result_type;
-
-        mutable compiler_environment& env;
-        compiler(compiler_environment& env)
-          : env(env)
-        {
-        }
-
-        function operator()(nil) const
-        {
-            return scheme::val(utree());
-        }
-
-        template <typename T>
-        function operator()(T const& val) const
-        {
-            return scheme::val(utree(val));
-        }
-
-        function operator()(utf8_symbol_range const& str) const
-        {
-            std::string name(str.begin(), str.end());
-
-            if (function_compiler* mf = env.find(name))
-            {
-                function_list flist;
-                return (*mf)(flist);
-            }
-            // $$$ throw? $$$
-            return function();
-        }
-
-        void define_function(
-            std::string const& name,
-            std::vector<std::string> const& args,
-            utree const& body) const
-        {
-            compiler_environment local_env(env);
-            for (std::size_t i = 0; i < args.size(); ++i)
-                local_env.define(args[i], boost::bind(arg, i));
-            env.define(name,
-                function_compiler(call(compile(body, local_env), args.size())));
-        }
-
-        void define_nullary_function(
-            std::string const& name,
-            utree const& body) const
-        {
-            env.define(name,
-                function_compiler(call(compile(body, env), 0)));
-        }
-
-        template <typename Iterator>
-        function operator()(boost::iterator_range<Iterator> const& range) const
-        {
-            std::string name(get_symbol(*range.begin()));
-
-            if (name == "define")
-            {
-                Iterator i = range.begin(); ++i;
-                if (i->which() == utree_type::list_type)
-                {
-                    // a function
-                    utree const& decl = *i++;
-                    Iterator di = decl.begin();
-                    std::string fname(get_symbol(*di++));
-                    std::vector<std::string> args;
-                    while (di != decl.end())
-                        args.push_back(get_symbol(*di++));
-                    define_function(fname, args, *i);
-                }
-                else
-                {
-                    // constants (nullary functions)
-                    std::string fname(get_symbol(*i++));
-                    define_nullary_function(fname, *i);
-                }
-                return function(val(utree(utf8_symbol("<function>"))));
-            }
-
-            if (function_compiler* mf = env.find(name))
-            {
-                function_list flist;
-                Iterator i = range.begin(); ++i;
-                for (; i != range.end(); ++i)
-                    flist.push_back(compile(*i, env));
-                return (*mf)(flist);
-            }
-
-            return function(); // $$$ implement me $$$
-        }
-    };
-
-    function compile(utree const& ast, compiler_environment& env)
-    {
-        return utree::visit(ast, compiler(env));
-    }
-
-    void compile_all(
-        utree const& ast,
-        compiler_environment& env,
-        function_list& results)
-    {
-        BOOST_FOREACH(utree const& program, ast)
-        {
-            scheme::function f = compile(program, env);
-            results.push_back(f);
-        }
-    }
-
-    void build_basic_environment(compiler_environment& env)
-    {
-        env.define("+", plus_composer());
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 //  Main program
 ///////////////////////////////////////////////////////////////////////////////