/home/chris/Projects/eval/eval.hpp

Go to the documentation of this file.

// Copyright (C) 2008 Christian Hoermann (0oo0oo0.c@gmail.com)
//
// 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)



#ifndef EVAL_EVAL_H
#define EVAL_EVAL_H

#include <iostream>
#include <stdexcept>
#include <fstream>
#include <string>
#include <utility>

#define PHOENIX_LIMIT 4

#include <boost/spirit/core.hpp>
#include <boost/spirit/attribute.hpp>
#include <boost/spirit/utility/distinct.hpp>
#include <boost/spirit/utility/confix.hpp>
#include <boost/spirit/utility/escape_char.hpp>
#include <boost/spirit/phoenix/functions.hpp>
#include <boost/scoped_array.hpp>

#include "execution_context.hpp"




namespace eval
{
    namespace detail
    {

        struct eval_closure_str : boost::spirit::closure<eval_closure_str, std::string>
        {
            member1 str;
        };

        struct eval_closure_str_char : boost::spirit::closure<eval_closure_str_char,
                                                              std::string, char>
        {
            member1 str;
            member2 temp;
        };
 
        struct eval_closure_str2 : boost::spirit::closure<eval_closure_str2, std::string,
                                                          std::string>
        {
            member1 str;
            member2 temp;
        };

        struct eval_closure_val : boost::spirit::closure<eval_closure_val, val>
        {
            member1 value;
        };

        struct eval_closure_exp : boost::spirit::closure<eval_closure_exp, val, std::string>
        {
            member1 value;
            member2 op;
        };

        struct eval_closure_args : boost::spirit::closure<eval_closure_args,
                                                          val, std::string, fwrap_args>
        {
            member1 rv;
            member2 name;
            member3 args;
        };


        struct push_back_
        {
            template<typename ContainerT, typename ItemT>
            struct result
            {
                typedef void type;
            };

            template <typename ContainerT, typename ItemT>
            void operator()(ContainerT& c, const ItemT& item) const
            {
                c.push_back(item);
            }
        };

        phoenix::function<push_back_> const push_back = push_back_();



        struct declare_global_
        {
            template<typename ExecutionContextT, typename NameT>
            struct result
            {
                typedef void type;
            };

            template<typename ExecutionContextT, typename NameT>
            void operator()(ExecutionContextT *e, NameT& name) const
            {
                e->add_global(name, val());
            }
        };

        const phoenix::function<declare_global_> declare_global = declare_global_();



        struct lookup_global_
        {
            template<typename ExecutionContextT, typename NameT>
            struct result
            {
                typedef val&  type;
            };

            template<typename ExecutionContextT, typename NameT>
            val& operator()(ExecutionContextT *e, NameT& name) const
            {
                return e->get_global(name);
            }
        };

        const phoenix::function<lookup_global_> lookup_global = lookup_global_();



        struct call_function_
        {
            template<typename ExecutionContextT, typename NameT, typename ArgsVecT>
            struct result
            {
                typedef val type;
            };

            template<typename ExecutionContextT, typename NameT, typename ArgsVecT>
            val operator()(ExecutionContextT *e, NameT& name, ArgsVecT& args) const
            {
                return e->call_function(name, args);
            }
        };

        const phoenix::function<call_function_> call_function = call_function_();



        struct call_method_
        {
            template<typename ExecutionContextT, typename NameT, typename ArgsVecT>
            struct result
            {
                typedef val type;
            };

            template<typename ExecutionContextT, typename NameT, typename ArgsVecT>
            val operator()(ExecutionContextT *e, NameT& name, ArgsVecT& args) const
            {
                return e->call_method(name, args);
            }
        };

        const phoenix::function<call_method_> call_method = call_method_();


        struct call_operator_
        {
            template<typename ExecutionContextT, typename NameT, typename LhsT, typename RhsT>
            struct result
            {
                typedef val type;
            };

            template<typename ExecutionContextT, typename NameT, typename LhsT, typename RhsT>
            val operator()(ExecutionContextT *e, NameT& op, LhsT& lhs, RhsT& rhs) const
            {
                fwrap_args args;
                args.push_back(lhs);
                args.push_back(rhs);
                return e->call_function_or_method("operator" + op, args);
            }
        };

        const phoenix::function<call_operator_> call_operator = call_operator_();



        struct wrap_literal_
        {
            template<typename ValT>
            struct result
            {
                typedef val type;
            };

            template<typename ValT>
            val operator()(ValT v) const
            {
                const ValT *val_ptr = new ValT(v);
                return val(val_ptr, TRANSFER_OWNERSHIP);
            }
        };

        const phoenix::function<wrap_literal_> wrap_literal = wrap_literal_();



        struct wrap_string_literal_
        {
            template<typename StringT>
            struct result
            {
                typedef val type;
            };

            template<typename StringT>
            val operator()(StringT& str) const
            {
                char *c_str = new char [str.size() + 1];
                std::memcpy(c_str, str.c_str(), str.size());
                c_str[str.size()] = '\0';
                return val(const_cast<const char *>(c_str), TRANSFER_OWNERSHIP_ARRAY);
            }
        };
      
        const phoenix::function<wrap_string_literal_> wrap_string_literal = wrap_string_literal_();



        const boost::spirit::distinct_parser<> keyword_p("a-zA-Z0-9_");


        struct eval_p : public boost::spirit::grammar<eval_p>
        {
            explicit eval_p(execution_context& e)
              : _e(&e)
            {
            }

            template<typename ScannerT>
            struct definition
            {
                definition(const eval_p& self)
                {
                    // TODO: This code could be tied up by using some using declarations
                    prog = *stmt;

                    stmt = ( declaration
                           | assignment
                           | expression
                           )
                           >> boost::spirit::ch_p(';');

                    // We use a std::string in the closure to be able to filter out
                    // spaces / comments. (TODO: spaces and comments should only be allowed
                    // after < or > or , or ::, but this might lead to problems with
                    // 2 word identifiers (e.g. unsigned int).)
                    identifier =  +(
                                     !boost::spirit::str_p("::")[identifier.str += "::"]
                                      >>
                                      boost::spirit::lexeme_d[
                                                               (   
                                                                   boost::spirit::alpha_p
                                                                 | boost::spirit::ch_p('_')
                                                               )
                                                              >>
                                                              *(   
                                                                   boost::spirit::alnum_p
                                                                 | boost::spirit::ch_p('_')
                                                               )
                                                             ]
                                                             [
                                                               identifier.str +=
                                                                   phoenix::construct_<std::string>
                                                                     (phoenix::arg1, phoenix::arg2)
                                                             ]
                                      >>
                                     !( 
                                        boost::spirit::ch_p('<')[identifier.temp = "<"]
                                        >> 
                                         (
                                             boost::spirit::ch_p('>')[identifier.temp += ">"]
                                           | 
                                             (  
                                               identifier[identifier.temp += phoenix::arg1]
                                               >>
                                               *(
                                                  boost::spirit::ch_p(',')[identifier.temp += ',']
                                                  >> identifier[identifier.temp += phoenix::arg1]
                                                )
                                               >> boost::spirit::ch_p('>')[identifier.temp += '>']
                                             )
                                         )
                                      )[identifier.str += identifier.temp]
                                   )
                               ;


                    declaration = keyword_p("val")
                                  >> identifier
                                             [declare_global(phoenix::val(self._e), phoenix::arg1)]
                                ;

                    assignment =  identifier[assignment.str = phoenix::arg1]
                                  >>
                                  boost::spirit::ch_p('=')
                                  >>
                                  expression[lookup_global(phoenix::val(self._e), assignment.str)
                                                                                  = phoenix::arg1]
                               ;


                    expression = unary_expression[expression.value = phoenix::arg1]
                                 >> *( op[expression.op = phoenix::arg1]
                                       >> unary_expression
                                          [expression.value = call_operator(phoenix::val(self._e),
                                                                            expression.op,
                                                                            expression.value,
                                                                            phoenix::arg1)]
                                     )
                               ;

                    // just support the << and >> operators for now (eventually we will need
                    // to factor in precedence and brackets).
                    op = ( boost::spirit::str_p("<<")
                         | boost::spirit::str_p(">>")
                         )[op.str = phoenix::construct_<std::string>(phoenix::arg1, phoenix::arg2)]
                       ;

                    unary_expression = method_call[unary_expression.value = phoenix::arg1]
                                     | fn_call[unary_expression.value = phoenix::arg1]
                                     | terminal[unary_expression.value = phoenix::arg1]
                                     ;

                    terminal = identifier[terminal.value = lookup_global(phoenix::val(self._e),
                                                                         phoenix::arg1)]
                             | boost::spirit::strict_real_p[terminal.value =
                                                                       wrap_literal(phoenix::arg1)]
                             | boost::spirit::int_p[terminal.value = wrap_literal(phoenix::arg1)]
                             | string_literal[terminal.value = wrap_string_literal(phoenix::arg1)]
                                // No character literatls, since "x" can be converted to char/int
                                // for function calls. This may eventually change. Also, if we had
                                // char literals, they could be converted to char * for function
                                // calls (this would be problematic, because the char * would not
                                // be null terminated).
                             ;
 
                    string_literal = boost::spirit::lexeme_d[
                                        boost::spirit::ch_p('"')
                                        >> *( boost::spirit::c_escape_ch_p
                                                 [string_literal.temp = phoenix::arg1]
                                              - boost::spirit::ch_p('"')
                                            ) [string_literal.str += string_literal.temp]
                                        >> boost::spirit::ch_p('"')
                                     ]
                                   ;
        
                    fn_call = identifier[fn_call.name = phoenix::arg1]
                              >> boost::spirit::ch_p('(')              
                              >> (   boost::spirit::ch_p(')')
                                   | (  expression[push_back(fn_call.args, phoenix::arg1)]
                                        >> *( boost::spirit::ch_p(',')
                                              >> expression[push_back(fn_call.args,
                                                                      phoenix::arg1)]
                                            )
                                        >> boost::spirit::ch_p(')')
                                     )
                                 )
                                 [fn_call.rv = call_function(phoenix::val(self._e),
                                                             fn_call.name, fn_call.args)]
                            ;

                   method_call = identifier[method_call.name = phoenix::arg1]
                                 >> boost::spirit::ch_p('.')
                                    [push_back(method_call.args, lookup_global(
                                                                             phoenix::val(self._e),
                                                                             method_call.name))]
                                 >> identifier[method_call.name = phoenix::arg1]
                                 >> boost::spirit::ch_p('(')              
                                 >> (   boost::spirit::ch_p(')')
                                      | (  expression[push_back(method_call.args, phoenix::arg1)]
                                           >> *( boost::spirit::ch_p(',')
                                                 >> expression[push_back(method_call.args,
                                                                         phoenix::arg1)]
                                               )
                                           >> boost::spirit::ch_p(')')
                                        )
                                    )
                                    [method_call.rv = call_method(phoenix::val(self._e),
                                                               method_call.name, method_call.args)]
                               ;

                }


                typedef boost::spirit::rule<ScannerT, eval_closure_str::context_t> str_rule_t;
                typedef boost::spirit::rule<ScannerT, eval_closure_str2::context_t> str2_rule_t;
                typedef boost::spirit::rule<ScannerT, eval_closure_str_char::context_t>
                                                                                   str_char_rule_t;
                typedef boost::spirit::rule<ScannerT, eval_closure_val::context_t> val_rule_t;
                typedef boost::spirit::rule<ScannerT, eval_closure_exp::context_t> exp_rule_t;
                typedef boost::spirit::rule<ScannerT, eval_closure_args::context_t> args_rule_t;
                str_rule_t assignment, op;
                str2_rule_t identifier;
                str_char_rule_t string_literal;
                val_rule_t binary_expression, unary_expression, terminal;
                exp_rule_t expression;
                args_rule_t fn_call, method_call;

                boost::spirit::rule<ScannerT> declaration, stmt, prog;

                const boost::spirit::rule<ScannerT>& start() const
                {
                    return prog;
                }
            };

            execution_context *_e;
        };

        struct space_comment_p : public boost::spirit::grammar<space_comment_p>
        {
            template<typename ScannerT>
            struct definition
            {
                definition(const space_comment_p& self)
                {
                    space_or_comment = boost::spirit::space_p
                                     | boost::spirit::comment_p("/*", "*/")
                                     | boost::spirit::comment_p("//")
                                     ;
                }
            
                boost::spirit::rule<ScannerT> space_or_comment;

                const boost::spirit::rule<ScannerT>& start() const
                {
                    return space_or_comment;
                }
            };
        };


    } // namespace detail


    class file_not_found_exception : public std::invalid_argument
    {
    public:
        explicit file_not_found_exception(const std::string& file)
          : std::invalid_argument("eval::file_not_found_exception: Failed to read " + file)
        {
        }
    };

    class syntax_error : public std::logic_error
    {
    public:
        explicit syntax_error(const std::string& err, const char *code)
          : std::logic_error("eval::syntax_error: '" + err + "' at '"
                             + (std::strlen(code) > 100 ? std::string(code, 100)
                                                        : std::string(code))
                             + "'")
        {
        }
    };


    inline void eval(execution_context& e, const char *code)
    {
        detail::eval_p p(e);
        detail::space_comment_p skip_p;
        boost::spirit::parse_info<> info = boost::spirit::parse(code, p, skip_p);

        // info.full appears to be false if the last characters are not matched by p, even
        // if they may be matched by skip_p (i.e. a file ending with spaces means !info.full
        // in this case).
        if (!info.full && (!info.hit || !boost::spirit::parse(info.stop, *skip_p).full))
        {
            throw syntax_error("failed parsing somewhere around", info.stop);
        }
    }

      inline void eval_file(execution_context& e, const char *filename)
    {
        // We could also use spirit's file_iterators (forward iterators for files),
        // but for small files, reading the whole file into memory seems more efficient.
        std::ifstream file(filename, std::ios::in | std::ios::binary | std::ios::ate);
        if(!file.is_open())
        {
            throw file_not_found_exception(filename);
        }
        std::ifstream::pos_type file_size = file.tellg();
        boost::scoped_array<char> data(new char [static_cast<std::size_t>(file_size) + 1]);
        file.seekg(0, std::ios::beg);
        file.read(data.get(), file_size);
        if(!file)
        {
            throw file_not_found_exception(filename);
        }
        file.close();
        data[file_size] = '\0';
        eval(e, data.get()); 
    }





}


#endif

---