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

Subject: [Boost-commit] svn:boost r61127 - in trunk/libs/spirit/example/scheme: . detail input test
From: joel_at_[hidden]
Date: 2010-04-07 10:23:58

Author: djowel
Date: 2010-04-07 10:23:57 EDT (Wed, 07 Apr 2010)
New Revision: 61127
URL: http://svn.boost.org/trac/boost/changeset/61127

Log:
very rough sketch (scheme interpreter)
Text files modified: 
   trunk/libs/spirit/example/scheme/detail/utree_detail2.hpp |    34 ++++                                    
   trunk/libs/spirit/example/scheme/input/sexpr.hpp          |     1                                         
   trunk/libs/spirit/example/scheme/test/scheme.cpp          |   263 +++++++++++++++++++++++++++------------ 
   trunk/libs/spirit/example/scheme/utree.hpp                |    17 +-                                      
   trunk/libs/spirit/example/scheme/utree_operators.hpp      |    57 +++++--                                 
   5 files changed, 261 insertions(+), 111 deletions(-)

Modified: trunk/libs/spirit/example/scheme/detail/utree_detail2.hpp
==============================================================================
--- trunk/libs/spirit/example/scheme/detail/utree_detail2.hpp	(original)
+++ trunk/libs/spirit/example/scheme/detail/utree_detail2.hpp	2010-04-07 10:23:57 EDT (Wed, 07 Apr 2010)
@@ -820,7 +820,7 @@
         return 0;
     }
 
-    inline int utree::which() const
+    inline utree_type::info utree::which() const
     {
         return get_type();
     }
@@ -934,10 +934,36 @@
         }
     }
 
-    inline utree::utree(construct_list)
+    template <typename To>
+    struct utree_cast
     {
-        l.default_construct();
-        set_type(type::list_type);
+        typedef To result_type;
+
+        template <typename From>
+        To dispatch(From const& val, boost::mpl::true_) const
+        {
+            return To(val); // From is convertible to To
+        }
+
+        template <typename From>
+        To dispatch(From const& val, boost::mpl::false_) const
+        {
+            // From is NOT convertible to To !!!
+            BOOST_ASSERT(false);
+            return To();
+        }
+
+        template <typename From>
+        To operator()(From const& val) const
+        {
+            return dispatch(val, boost::is_convertible<From, To>());
+        }
+    };
+
+    template <typename T>
+    inline T utree::as() const
+    {
+        return utree::visit(*this, utree_cast<T>());
     }
 }
 

Modified: trunk/libs/spirit/example/scheme/input/sexpr.hpp
==============================================================================
--- trunk/libs/spirit/example/scheme/input/sexpr.hpp	(original)
+++ trunk/libs/spirit/example/scheme/input/sexpr.hpp	2010-04-07 10:23:57 EDT (Wed, 07 Apr 2010)
@@ -18,6 +18,7 @@
 #include <boost/regex/pending/unicode_iterator.hpp>
 
 #include "../utree.hpp"
+#include "../utree_operators.hpp"
 
 namespace scheme { namespace input
 {

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-07 10:23:57 EDT (Wed, 07 Apr 2010)
@@ -17,131 +17,234 @@
     return out;
 }
 
-#include <boost/unordered_map.hpp>
+#include <vector>
+#include <list>
+#include <map>
+#include <boost/function.hpp>
+#include <boost/foreach.hpp>
 
 namespace scheme
 {
-    class environment
-    {
-    public:
+///////////////////////////////////////////////////////////////////////////////
+//  The runtime interpreter
+///////////////////////////////////////////////////////////////////////////////
 
-        environment(environment* parent = 0)
-          : bindings(), parent(parent) {}
+    typedef boost::function<utree(utree const& args)> function;
+    typedef std::list<function> function_list;
 
-        void define(std::string const& name, utree const& def)
-        {
-            // check for duplicate names
-            BOOST_ASSERT(bindings.find(name) == bindings.end());
-            // $$$ TODO Use exceptions $$$
-            bindings[name] = def;
-        }
+    ///////////////////////////////////////////////////////////////////////////
+    // values
+    ///////////////////////////////////////////////////////////////////////////
+    struct value_impl
+    {
+        utree val;
+        value_impl(utree const& val) : val(val) {}
 
-        utree* find(std::string const& name)
+        typedef utree result_type;
+        utree operator()(utree const& /*args*/) const
         {
-            map::iterator i = bindings.find(name);
-            if (i == bindings.end())
-            {
-                if (parent)
-                    return parent->find(name);
-                return 0;
-            }
-            return &i->second;
+            return utree(boost::ref(val));
         }
+    };
 
-    private:
+    inline function val(utree const& val)
+    {
+        return function(value_impl(val));
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // arguments
+    ///////////////////////////////////////////////////////////////////////////
+    struct argument_impl
+    {
+        int n;
+        argument_impl(int n) : n(n) {}
 
-        typedef boost::unordered_map<std::string, utree> map;
-        map bindings;
-        environment* parent;
+        typedef utree result_type;
+        utree operator()(utree const& args) const
+        {
+            return utree(boost::ref(args[n]));
+        }
     };
 
+    inline function arg(int n)
+    {
+        return function(argument_impl(n));
+    }
+
     ///////////////////////////////////////////////////////////////////////////
-    // Intrinsic functions
+    // reference
     ///////////////////////////////////////////////////////////////////////////
-    struct arithmetic_function
+    struct reference_impl
     {
-        typedef bool result_type;
+        function& f;
+        reference_impl(function& f) : f(f) {}
 
-        template <typename A, typename B>
-        bool dispatch(const A&, const B&, boost::mpl::false_) const
+        typedef utree result_type;
+        utree operator()(utree const& args) const
         {
-            return false; // cannot compare different types by default
+            return f(args);
         }
+    };
+
+    inline function ref(function& f)
+    {
+        return function(reference_impl(f));
+    }
 
-        template <typename A, typename B>
-        bool dispatch(const A& a, const B& b, boost::mpl::true_) const
+    ///////////////////////////////////////////////////////////////////////////
+    // plus
+    ///////////////////////////////////////////////////////////////////////////
+    struct plus_impl
+    {
+        function_list operands;
+
+        plus_impl(function_list& operands_)
         {
-            return a == b; // for arithmetic types
+            // we take ownership of the operands
+            operands_.swap(operands);
         }
 
-        template <typename A, typename B>
-        bool operator()(const A& a, const B& b) const
+        typedef utree result_type;
+        utree operator()(utree const& args) const
         {
-            return dispatch(a, b,
-                boost::mpl::and_<
-                    boost::is_arithmetic<A>,
-                    boost::is_arithmetic<B> >());
+            utree result(0);
+            BOOST_FOREACH(function const& operand, operands)
+            {
+                result = result + operand(args);
+            }
+            return result;
         }
     };
 
-    utree plus(environment*, utree& args)
+    struct make_plus
     {
+        typedef function result_type;
+        function operator()(function_list& operands)
+        {
+            // check arity here!
+            return function(plus_impl(operands));
+        }
+    };
 
-    }
-}
+    make_plus const plus = {};
 
 ///////////////////////////////////////////////////////////////////////////////
-//  Main program
+//  The compiler
 ///////////////////////////////////////////////////////////////////////////////
-int main(int argc, char **argv)
-{
-    char const* filename;
-    if (argc > 1)
-    {
-        filename = argv[1];
-    }
-    else
+    typedef boost::function<function(function_list&)> make_function;
+
+    struct compiler_environment
     {
-        std::cerr << "Error: No input file provided." << std::endl;
-        return 1;
-    }
+        compiler_environment() {}
 
-    std::ifstream in(filename, std::ios_base::in);
+        void define(std::string const& name, make_function const& def)
+        {
+            // $$$ use exceptions here $$$
+            BOOST_ASSERT(definitions.find(name) == definitions.end());
+            definitions[name] = def;
+        }
 
-    if (!in)
-    {
-        std::cerr << "Error: Could not open input file: "
-            << filename << std::endl;
-        return 1;
-    }
+        make_function* find(std::string const& name)
+        {
+            std::map<std::string, make_function>::iterator
+                i = definitions.find(name);
+            if (i != definitions.end())
+                return &i->second;
+            return 0;
+        }
+
+        std::map<std::string, make_function> definitions;
+    };
 
-    // Ignore the BOM marking the beginning of a UTF-8 file in Windows
-    char c = in.peek();
-    if (c == '\xef')
+    function compile(utree const& ast, compiler_environment& env);
+
+    struct compiler
     {
-        char s[3];
-        in >> s[0] >> s[1] >> s[2];
-        s[3] = '\0';
-        if (s != std::string("\xef\xbb\xbf"))
+        typedef function result_type;
+
+        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
+        {
+            return function(); // $$$ implement me $$$
+        }
+
+        template <typename Iterator>
+        function operator()(boost::iterator_range<Iterator> const& range) const
         {
-            std::cerr << "Error: Unexpected characters from input file: "
-                << filename << std::endl;
-            return 1;
+            utf8_symbol_range symbol = range.begin()->as<utf8_symbol_range>();
+            std::string fname(symbol.begin(), symbol.end());
+            if (make_function* mf = env.find(fname))
+            {
+                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));
     }
 
-    scheme::utree result;
-    if (scheme::input::parse_sexpr(in, result))
+    void build_basic_environment(compiler_environment& env)
     {
-        std::cout << "success: ";
-        println(std::cout, result);
-        std::cout << std::endl;
+        env.define("+", make_plus());
     }
-    else
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::string in;
+    while (std::getline(std::cin, in))
     {
-        std::cout << "parse error" << std::endl;
+        if (in.empty() || in[0] == 'q' || in[0] == 'Q')
+            break;
+
+        typedef std::string::const_iterator iterator_type;
+        scheme::utree result;
+        scheme::input::sexpr<iterator_type> p;
+        scheme::input::white_space<iterator_type> ws;
+
+        iterator_type first = in.begin();
+        iterator_type last = in.end();
+        if (phrase_parse(first, last, p, ws, result))
+        {
+            std::cout << "success: ";
+            scheme::compiler_environment env;
+            scheme::build_basic_environment(env);
+            scheme::function f = compile(result, env);
+            std::cout << "result: " << f(scheme::utree()) << std::endl;
+        }
+        else
+        {
+            std::cout << "parse error" << std::endl;
+        }
     }
 
+    std::cout << "Bye... :-) \n\n";
     return 0;
 }
 

Modified: trunk/libs/spirit/example/scheme/utree.hpp
==============================================================================
--- trunk/libs/spirit/example/scheme/utree.hpp	(original)
+++ trunk/libs/spirit/example/scheme/utree.hpp	2010-04-07 10:23:57 EDT (Wed, 07 Apr 2010)
@@ -55,8 +55,8 @@
     ///////////////////////////////////////////////////////////////////////////
     // Function pointer
     ///////////////////////////////////////////////////////////////////////////
-    class utree; // forward
-    typedef utree (*function_ptr)(environment* env, utree& args);
+    class utree;
+    typedef utree (*function_ptr)(environment& env);
 
     ///////////////////////////////////////////////////////////////////////////
     // A typed string with parametric Base storage. The storage can be any
@@ -261,7 +261,10 @@
         bool empty() const;
         std::size_t size() const;
 
-        int which() const;
+        utree_type::info which() const;
+
+        template <typename T>
+        T as() const;
 
     private:
 
@@ -270,8 +273,9 @@
         template <typename UTreeX, typename UTreeY>
         friend struct detail::visit_impl;
         friend struct detail::index_impl;
-        friend struct ulist;
-        template <typename T> friend struct detail::get_impl;
+
+        template <typename T>
+        friend struct detail::get_impl;
 
         type::info get_type() const;
         void set_type(type::info t);
@@ -279,9 +283,6 @@
         void free();
         void copy(utree const& other);
 
-        struct construct_list {};
-        utree(construct_list);
-
         union
         {
             detail::fast_string s;

Modified: trunk/libs/spirit/example/scheme/utree_operators.hpp
==============================================================================
--- trunk/libs/spirit/example/scheme/utree_operators.hpp	(original)
+++ trunk/libs/spirit/example/scheme/utree_operators.hpp	2010-04-07 10:23:57 EDT (Wed, 07 Apr 2010)
@@ -206,6 +206,11 @@
             }
             (*this)(')');
         }
+
+        void operator()(function_ptr fptr) const
+        {
+            out << "function-pointer(" << fptr << ')';
+        }
     };
 
     template <typename Base>
@@ -213,6 +218,8 @@
     {
         typedef utree result_type;
 
+        // In scheme, anything except false is true
+
         // binary
         utree operator()(bool a, bool b) const
         {
@@ -220,25 +227,37 @@
         }
 
         // binary
+        template <typename A>
+        utree operator()(A const& a, bool b) const
+        {
+            return Base::eval(true, b);
+        }
+
+        // binary
+        template <typename B>
+        utree operator()(bool a, B const& b) const
+        {
+            return Base::eval(a, true);
+        }
+
+        // binary
         template <typename A, typename B>
         utree operator()(A const& a, B const& b) const
         {
-            // $$$ Throw exception here? $$$
-            return utree(); // cannot apply to non booleans
+            return Base::eval(true, true);
         }
 
         // unary
         utree operator()(bool a) const
         {
-            return Base::eval(a); // for boolean types
+            return Base::eval(a);
         }
 
         // unary
         template <typename A>
         utree operator()(A const& a) const
         {
-            // $$$ Throw exception here? $$$
-            return utree(); // cannot apply to non booleans
+            return Base::eval(true);
         }
     };
 
@@ -248,21 +267,21 @@
         typedef utree result_type;
 
         template <typename A, typename B>
-        utree dispatch(A&, B&, boost::mpl::false_) const
+        utree dispatch(A const&, B const&, boost::mpl::false_) const
         {
             // $$$ Throw exception here? $$$
             return utree(); // cannot apply to non-arithmetic types
         }
 
         template <typename A, typename B>
-        utree dispatch(A& a, B& b, boost::mpl::true_) const
+        utree dispatch(A const& a, B const& b, boost::mpl::true_) const
         {
             return Base::eval(a, b); // for arithmetic types
         }
 
         // binary
         template <typename A, typename B>
-        utree operator()(A& a, B& b) const
+        utree operator()(A const& a, B const& b) const
         {
             return dispatch(a, b,
                 boost::mpl::and_<
@@ -271,21 +290,21 @@
         }
 
         template <typename A>
-        utree dispatch(A&, boost::mpl::false_) const
+        utree dispatch(A const&, boost::mpl::false_) const
         {
             // $$$ Throw exception here? $$$
             return utree(); // cannot apply to non-arithmetic types
         }
 
         template <typename A>
-        utree dispatch(A& a, boost::mpl::true_) const
+        utree dispatch(A const& a, boost::mpl::true_) const
         {
             return Base::eval(a); // for arithmetic types
         }
 
         // unary
         template <typename A>
-        utree operator()(A& a) const
+        utree operator()(A const& a) const
         {
             return dispatch(a, boost::is_arithmetic<A>());
         }
@@ -297,21 +316,21 @@
         typedef utree result_type;
 
         template <typename A, typename B>
-        utree dispatch(A&, B&, boost::mpl::false_) const
+        utree dispatch(A const&, B const&, boost::mpl::false_) const
         {
             // $$$ Throw exception here? $$$
             return utree(); // cannot apply to non-integral types
         }
 
         template <typename A, typename B>
-        utree dispatch(A& a, B& b, boost::mpl::true_) const
+        utree dispatch(A const& a, B const& b, boost::mpl::true_) const
         {
             return Base::eval(a, b); // for integral types
         }
 
         // binary
         template <typename A, typename B>
-        utree operator()(A& a, B& b) const
+        utree operator()(A const a, B const& b) const
         {
             return dispatch(a, b,
                 boost::mpl::and_<
@@ -320,21 +339,21 @@
         }
 
         template <typename A>
-        utree dispatch(A&, boost::mpl::false_) const
+        utree dispatch(A const&, boost::mpl::false_) const
         {
             // $$$ Throw exception here? $$$
             return utree(); // cannot apply to non-integral types
         }
 
         template <typename A>
-        utree dispatch(A& a, boost::mpl::true_) const
+        utree dispatch(A const& a, boost::mpl::true_) const
         {
             return Base::eval(a); // for integral types
         }
 
         // unary
         template <typename A>
-        utree operator()(A& a) const
+        utree operator()(A const& a) const
         {
             return dispatch(a, boost::is_integral<A>());
         }
@@ -344,12 +363,12 @@
     struct BOOST_PP_CAT(function_impl_, name)                                   \
     {                                                                           \
         template <typename A, typename B>                                       \
-        static utree eval(A& a, B& b)                                           \
+        static utree eval(A const& a, B const& b)                               \
         {                                                                       \
             return utree(expr);                                                 \
         }                                                                       \
         template <typename A>                                                   \
-        static utree eval(A& a)                                                 \
+        static utree eval(A const& a)                                           \
         {                                                                       \
             return utree(expr);                                                 \
         }                                                                       \