Fix registration of module loading functions

CMakeLists.txt

@@ -2,22 +2,44 @@ cmake_minimum_required(VERSION 2.6)
 
 project(chaiscript)
 
-SET (CMAKE_BUILD_TYPE gdb)
-SET (CMAKE_C_FLAGS_GDB " -Wall -ggdb")
-SET (CMAKE_CXX_FLAGS_GDB " -Wall -ggdb")
+FIND_LIBRARY(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
 
-#SET (CMAKE_BUILD_TYPE rel)
-#SET (CMAKE_C_FLAGS_REL " -Wall -O3")
-#SET (CMAKE_CXX_FLAGS_REL " -Wall -O3")
+MESSAGE(STATUS "Detecting readline support")
+if (READLINE_LIBRARY)
+    MESSAGE(STATUS "Found: ${READLINE_LIBRARY}")
+    SET (READLINE_LIB readline)
+    SET (READLINE_FLAG " -DREADLINE_AVAILABLE")
+else(READLINE_LIBRARY)
+    MESSAGE(STATUS "Not Found")
+    SET (READLINE_LIB )
+    SET (READLINE_FLAG )
+endif(READLINE_LIBRARY)
+
+SET (CMAKE_C_FLAGS_REL " -Wall -O3 ${READLINE_FLAG}")
+SET (CMAKE_CXX_FLAGS_REL " -Wall -O3 ${READLINE_FLAG}")
+
+SET (CMAKE_C_FLAGS " -Wall -ggdb ${READLINE_FLAG}")
+SET (CMAKE_CXX_FLAGS " -Wall -ggdb ${READLINE_FLAG}")
 
 include_directories(include)
  
-find_package(Boost 1.36.0)
+find_package(Boost 1.36.0 COMPONENTS thread)
+
 if (Boost_FOUND)
 	include_directories(${Boost_INCLUDE_DIRS})
 	add_executable(chaiscript_eval src/main.cpp)
 	#add_executable(dispatchkit_test contrib/test/dispatchkit_test.cpp)
-	target_link_libraries(chaiscript_eval ${Boost_LIBRARIES})
+	target_link_libraries(chaiscript_eval dl ${Boost_LIBRARIES} ${READLINE_LIB})
+
+        add_library(test MODULE src/test_module.cpp)
+	target_link_libraries(test ${Boost_LIBRARIES})
+
+        add_library(stl_extra MODULE src/stl_extra.cpp)
+	target_link_libraries(stl_extra ${Boost_LIBRARIES})
+
 	install(TARGETS chaiscript_eval DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/bin)
+        
+else(Boost_FOUND)
+        message(FATAL_ERROR "Can not find Boost")
 endif(Boost_FOUND)
 

contrib/codeanalysis/analyzedata.sh

@@ -0,0 +1,43 @@
+
+function analyze_data
+{
+  echo -n "$1," >> $2
+  awk 'END {printf "%s,", $1}' r$1-codesize.out >> $2
+  awk '{printf "%s,", $1}' r$1-numunittests.out >> $2
+  awk 'END {printf "%s,", $1}' r$1-unittestsoutput.out >> $2
+
+  awk '{printf "%s,", $1}' r$1-debugbinarysize.out  >> $2
+  awk 'NR>1{exit} 1 {printf "%s,", $2}' r$1-debugbuildtime.out >> $2
+  awk 'NR>1{exit} 1 {printf "%s,", $2}' r$1-debugprofiletime.out >> $2
+
+  awk '{printf "%s,", $1}' r$1-releasebinarysize.out  >> $2
+  awk 'NR>1{exit} 1 {printf "%s,", $2}' r$1-releasebuildtime.out >> $2
+  awk 'NR>1{exit} 1 {printf "%s,", $2}' r$1-releasemodulesbuildtime.out >> $2
+  awk 'NR>1{exit} 1 {printf "%s,", $2}' r$1-releaseprofiletime.out >> $2
+  awk 'NR>1{exit} 1 {printf "%s,", $2}' r$1-releaseunittestruntime.out >> $2
+
+  if [ -x r$1-threadfreebinarysize.out ]
+  then
+    awk '{printf "%s,", $1}' r$1-threadfreebinarysize.out  >> $2
+    awk 'NR>1{exit} 1 {printf "%s,", $2}' r$1-threadfreeprofiletime.out >> $2
+
+    awk 'NR>1{exit} 1 {printf "%s,", $2}' r$1-1threadruntime.out >> $2
+    awk 'NR>1{exit} 1 {printf "%s,", $2}' r$1-2threadruntime.out >> $2
+    awk 'NR>1{exit} 1 {printf "%s,", $2}' r$1-4threadruntime.out >> $2
+    awk 'NR>1{exit} 1 {printf "%s,", $2}' r$1-8threadruntime.out >> $2
+  else
+    echo -n ",,,,,," >> $2
+  fi
+
+  awk -F "\n" 'NR>1{exit} 1 {printf "\"%s\"\n", $1}' r$1-revisionlog.out >> $2
+}
+
+
+filename=output-$1-$2.csv
+
+echo "Revision, LOC, Num Unit Tests, Successful Unit Tests, Debug Binary Size, Debug Build Time, Debug Profile Time, Release Binary Size, Release Core Build Time, Release Modules Build Time, Release Profile Time, Release Unit Tests Time, Threadless Binary Size, Threadless Profile Time, 1 Thread Profile Time, 2 Threads Profile Time, 4 Threads Profile Time, 8 Threads Profile Time, Revision Log" > $filename
+
+for i in `seq $1 $2` 
+do
+  analyze_data $i $filename
+done

contrib/codeanalysis/codeanalysis.sh

@@ -0,0 +1,81 @@
+
+function run_test
+{
+  echo "****Getting r$1 from SVN"
+  svn export --quiet -r$1 http://chaiscript.googlecode.com/svn/trunk chaiscript-r$1
+
+  pushd chaiscript-r$1
+
+  echo "****Getting svn revision log"
+  svn propget svn:log --revprop -r$1  http://chaiscript.googlecode.com/svn/trunk > ../r$1-revisionlog.out
+
+  echo "****Editing CMakeLists.txt to allow for build type switching"
+  # Clean up CMakeLists.txt so that we can set the build type at configure time
+  sed -i -e "s/SET (CMAKE_BUILD_TYPE.*//"  CMakeLists.txt
+
+  echo "****Compiling Debug Build"
+  cmake -D CMAKE_BUILD_TYPE=Debug CMakeLists.txt
+  /usr/bin/time -p make chaiscript_eval 2> ../r$1-debugbuildtime.out
+
+  echo "****Analyzing Debug Build"
+  /usr/bin/time -p ./chaiscript_eval ../profile.chai 2>../r$1-debugprofiletime.out
+  ls -s --block-size=1 ./chaiscript_eval > ../r$1-debugbinarysize.out
+
+  make clean
+
+  echo "****Compiling Release Build"
+  cmake -D CMAKE_BUILD_TYPE=Release CMakeLists.txt
+  /usr/bin/time -p make chaiscript_eval 2> ../r$1-releasebuildtime.out
+
+  echo "****Analyzing Release Build"
+  /usr/bin/time -p ./chaiscript_eval ../profile.chai 2>../r$1-releaseprofiletime.out
+  ls -s --block-size=1 ./chaiscript_eval > ../r$1-releasebinarysize.out
+
+  echo "****Analyzing Code Size"
+  find ./include -name "*.hpp" | xargs wc > ../r$1-codesize.out
+
+  echo "****Building Remaining Modules"
+  /usr/bin/time -p make 2> ../r$1-releasemodulesbuildtime.out
+
+  echo "****Running unit tests"
+  /usr/bin/time -p ./run_unit_tests.sh 2> ../r$1-releaseunittestruntime.out > ../r$1-unittestsoutput.out
+
+  echo "****Counting number of unit tests"
+  find unittests/ -name "*.chai" | wc | awk '{print $1}' > ../r$1-numunittests.out
+
+
+  echo "****Running multithreaded tests"
+  if [ -e src/multithreaded.cpp ]
+  then
+    # Run multithreaded tests
+    echo "****Building multithreaded test"
+    pushd src
+    g++ multithreaded.cpp -lboost_thread-mt -ldl -omultithreaded -I../include -O3
+    echo "****Testing 1 thread runtime"
+    /usr/bin/time -p ./multithreaded 1 2> ../../r$1-1threadruntime.out
+    echo "****Testing 2 thread runtime"
+    /usr/bin/time -p ./multithreaded 1 1 2> ../../r$1-2threadruntime.out
+    echo "****Testing 4 thread runtime"
+    /usr/bin/time -p ./multithreaded 1 1 1 1 2> ../../r$1-4threadruntime.out
+    echo "****Testing 8 thread runtime"
+    /usr/bin/time -p ./multithreaded 1 1 1 1 1 1 1 1 2> ../../r$1-8threadruntime.out
+
+
+    echo "****Compiling thread-free version"
+    g++ main.cpp -ldl -othreadfree -I../include -O3 -DCHAISCRIPT_NO_THREADS
+    echo "****Analyzing thread-free version"
+    /usr/bin/time -p ./threadfree ../../profile.chai 2>../../r$1-threadfreeprofiletime.out
+    ls -s --block-size=1 ./threadfree > ../../r$1-threadfreebinarysize.out
+
+    popd
+  else
+    echo "Multithreaded test non-existent"
+  fi
+
+  popd
+}
+
+for i in `seq $1 $2` 
+do
+  run_test $i
+done

contrib/codeanalysis/profile.chai

@@ -0,0 +1,15 @@
+var total = 0
+ 
+for (var i = 0.0; i < 10000.0; i += 0.1) {
+  total += int(double(i) + int(10));
+  if (i < 9000.0)
+  {
+    total += double(11);
+    if (i > double(4000.0))
+    {
+      total += double(10);
+    }
+  }
+}
+ 
+print(total)

include/chaiscript/chaiscript.hpp

@@ -20,126 +20,14 @@
 #include "dispatchkit/dispatchkit.hpp"
 #include "dispatchkit/bootstrap.hpp"
 #include "dispatchkit/bootstrap_stl.hpp"
+#include "dispatchkit/function_call.hpp"
+#include "dispatchkit/dynamic_object.hpp"
 
-namespace chaiscript
-{
-    /**
-     * Types of AST nodes available to the parser and eval
-     */
-    class Token_Type { public: enum Type { Error, Int, Float, Id, Char, Str, Eol, Fun_Call, Arg_List, Variable, Equation, Var_Decl,
-        Expression, Comparison, Additive, Multiplicative, Negate, Not, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
-        Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Map_Pair, Value_Range,
-        Inline_Range, Annotation }; };
-
-    /**
-     * Helper lookup to get the name of each node type
-     */
-    const char *token_type_to_string(int tokentype) {
-        const char *token_types[] = { "Internal Parser Error", "Int", "Float", "Id", "Char", "Str", "Eol", "Fun_Call", "Arg_List", "Variable", "Equation", "Var_Decl",
-            "Expression", "Comparison", "Additive", "Multiplicative", "Negate", "Not", "Array_Call", "Dot_Access", "Quoted_String", "Single_Quoted_String",
-            "Lambda", "Block", "Def", "While", "If", "For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Map_Pair", "Value_Range",
-            "Inline_Range", "Annotation"};
-
-        return token_types[tokentype];
-    }
-
-    /**
-     * Convenience type for file positions
-     */
-    struct File_Position {
-        int line;
-        int column;
-
-        File_Position(int file_line, int file_column)
-            : line(file_line), column(file_column) { }
-
-        File_Position() : line(0), column(0) { }
-    };
-
-    typedef boost::shared_ptr<struct Token> TokenPtr;
-
-    /**
-     * The struct that doubles as both a parser token and an AST node
-     */
-    struct Token {
-        std::string text;
-        int identifier;
-        const char *filename;
-        File_Position start, end;
-
-        std::vector<TokenPtr> children;
-        TokenPtr annotation;
-
-        Token(const std::string &token_text, int id, const char *fname) : text(token_text), identifier(id), filename(fname) { }
-
-        Token(const std::string &token_text, int id, const char *fname, int start_line, int start_col, int end_line, int end_col) :
-            text(token_text), identifier(id), filename(fname) {
-
-            start.line = start_line;
-            start.column = start_col;
-            end.line = end_line;
-            end.column = end_col;
-        }
-    };
-
-    /**
-     * Errors generated inside the parser
-     */
-    struct Parse_Error : public std::runtime_error {
-        std::string reason;
-        File_Position position;
-        const char *filename;
-
-        Parse_Error(const std::string &why, const File_Position &where, const char *fname) :
-            std::runtime_error("Parse error: \"" + why + "\" in '"
-                + std::string(fname) + "' at: (" + boost::lexical_cast<std::string>(where.line+1) + ", " +
-                 boost::lexical_cast<std::string>(where.column) + ")"),
-            reason(why), position(where), filename(fname) 
-        { }
-
-        Parse_Error(const std::string &why, const TokenPtr &where) 
-            : std::runtime_error("Parse error: \"" + why + "\" in '"
-                + where->filename + "' line: " + boost::lexical_cast<std::string>(where->start.line+1)),
-              reason(why), position(where->start), filename(where->filename) {
-        }
-
-        virtual ~Parse_Error() throw() {}
-    };
-
-    /**
-     * Errors generated inside the evaluator
-     */
-    struct Eval_Error : public std::runtime_error {
-        std::string reason;
-        TokenPtr location;
-
-        Eval_Error(const std::string &why, const TokenPtr where)
-          : std::runtime_error("Eval error: \"" + why + "\" in '"
-              + where->filename + "' line: " + boost::lexical_cast<std::string>(where->start.line+1)),
-            reason(why), location(where) { }
-
-        virtual ~Eval_Error() throw() {}
-    };
-
-    /**
-     * Special type for returned values
-     */
-    struct Return_Value {
-        dispatchkit::Boxed_Value retval;
-        TokenPtr location;
-
-        Return_Value(const dispatchkit::Boxed_Value &return_value, const TokenPtr where) : retval(return_value), location(where) { }
-    };
-
-    /**
-     * Special type indicating a call to 'break'
-     */
-    struct Break_Loop {
-        TokenPtr location;
-
-        Break_Loop(const TokenPtr where) : location(where) { }
-    };
-}
+#ifdef  BOOST_HAS_DECLSPEC
+#define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)
+#else
+#define CHAISCRIPT_MODULE_EXPORT extern "C" 
+#endif
 
 #include "language/chaiscript_eval.hpp"
 #include "language/chaiscript_engine.hpp"

include/chaiscript/chaiscript_threading.hpp

@@ -0,0 +1,73 @@
+#ifndef __chaiscript_threading_hpp__
+#define __chaiscript_threading_hpp__
+
+#ifndef CHAISCRIPT_NO_THREADS
+#include <boost/thread.hpp>
+#else
+#warning "ChaiScript is compiling without thread safety."
+#endif
+
+namespace chaiscript
+{
+  namespace threading
+  {
+
+#ifndef CHAISCRIPT_NO_THREADS
+
+    template<typename T>
+      class Thread_Storage
+      {
+        public:
+          ~Thread_Storage()
+          {
+            m_thread_storage.reset();
+          }
+
+          inline T *operator->() const
+          {
+            if (!m_thread_storage.get())
+            {
+              m_thread_storage.reset(new T());
+            }
+
+            return m_thread_storage.get();
+          }
+
+          inline T &operator*() const
+          {
+            return *(this->operator->());
+          }
+
+        private:
+          mutable boost::thread_specific_ptr<T> m_thread_storage;
+      };
+
+#else
+
+    template<typename T>
+      class Thread_Storage
+      {
+        public:
+          inline T *operator->() const
+          {
+            return &obj;
+          }
+
+          inline T &operator*() const
+          {
+            return obj;
+          }
+
+        private:
+          mutable T obj;
+      };
+
+#endif
+
+  }
+}
+
+
+
+#endif
+

include/chaiscript/dispatchkit/bind_first.hpp

@@ -0,0 +1,65 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#include <boost/preprocessor.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+
+#define param(z,n,text) BOOST_PP_CAT(text, BOOST_PP_INC(n)) 
+
+#ifndef  BOOST_PP_IS_ITERATING
+#ifndef __bind_first_hpp__
+#define __bind_first_hpp__
+
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <boost/ref.hpp>
+
+#define BOOST_PP_ITERATION_LIMITS ( 0, 8 )
+#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/bind_first.hpp>
+
+#include BOOST_PP_ITERATE()
+
+
+# endif
+#else
+# define n BOOST_PP_ITERATION()
+# define m BOOST_PP_INC(n)
+
+namespace chaiscript
+{
+ 
+  template<typename Ret, typename O, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
+    boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> 
+      bind_first(Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param)), const O &o)
+      {
+        return boost::bind(f, o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+      }
+
+  template<typename Ret, typename O, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
+    boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> 
+      bind_first(Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param))const, const O &o)
+      {
+        return boost::bind(f, o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+      }
+
+  template<typename Ret,typename O BOOST_PP_COMMA_IF(m) BOOST_PP_ENUM_PARAMS(m, typename Param) >
+    boost::function<Ret (BOOST_PP_ENUM(n, param, Param))> 
+      bind_first(Ret (*f)(BOOST_PP_ENUM_PARAMS(m, Param)), const O &o)
+      {
+        return boost::bind(f, o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+      }
+
+  template<typename Ret,typename O BOOST_PP_COMMA_IF(m) BOOST_PP_ENUM_PARAMS(m, typename Param) >
+    boost::function<Ret (BOOST_PP_ENUM(n, param, Param))> 
+      bind_first(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(m, Param))> &f, const O &o)
+      {
+        return boost::bind(f, o BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, param, _));
+      }
+
+
+}
+
+#endif

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -5,43 +5,37 @@
 // http://www.chaiscript.com
 
 /**
- * This file contains utility functions for registration of STL container
- * classes. The methodology used is based on the SGI STL concepts.
- * http://www.sgi.com/tech/stl/table_of_contents.html
- */
+* This file contains utility functions for registration of STL container
+* classes. The methodology used is based on the SGI STL concepts.
+* http://www.sgi.com/tech/stl/table_of_contents.html
+*/
 
-#ifndef __bootstrap_stl_hpp
+#ifndef __bootstrap_stl_hpp__
 #define __bootstrap_stl_hpp__
 
 #include "dispatchkit.hpp"
 #include "register_function.hpp"
 
 
-namespace dispatchkit
+namespace chaiscript 
 {
-  /**
-   * Input_Range, based on the D concept of ranges.
-   * \todo Update the Range code to base its capabilities on
-   *       the type_traits of the iterator passed in
-   */
-  template<typename Container>
-    struct Input_Range
+  namespace bootstrap
+  {
+    /**
+    * Bidir_Range, based on the D concept of ranges.
+    * \todo Update the Range code to base its capabilities on
+    *       the user_typetraits of the iterator passed in
+    */
+    template<typename Container>
+    struct Bidir_Range
     {
-      Input_Range(Container &c)
+      typedef typename std::iterator_traits<typename Container::iterator>::reference reference_type;
+
+      Bidir_Range(Container &c)
         : m_begin(c.begin()), m_end(c.end())
       {
       }
 
-      Input_Range(typename Container::iterator itr)
-        : m_begin(itr), m_end(itr)
-      {
-      }
-
-      Input_Range(const std::pair<typename Container::iterator, typename Container::iterator> &t_p)
-        : m_begin(t_p.first), m_end(t_p.second)
-      {
-      }
-
       bool empty() const
       {
         return m_begin == m_end;
@@ -56,7 +50,16 @@ namespace dispatchkit
         ++m_begin;
       }
 
-      typename std::iterator_traits<typename Container::iterator>::reference front() const
+      void pop_back()
+      {
+        if (empty())
+        {
+          throw std::range_error("Range empty");
+        }
+        --m_end;
+      }
+
+      reference_type front() const
       {
         if (empty())
         {
@@ -65,120 +68,149 @@ namespace dispatchkit
         return *m_begin;
       }
 
+      reference_type back() const
+      {
+        if (empty())
+        {
+          throw std::range_error("Range empty");
+        }
+        typename Container::iterator pos = m_end;
+        --pos;
+        return *(pos);
+      }
+
       typename Container::iterator m_begin;
       typename Container::iterator m_end;
     };
 
-  
-  /**
-   * Add Input_Range support for the given ContainerType
-   */
-  template<typename ContainerType>
-    void bootstrap_input_range(Dispatch_Engine &system, const std::string &type)
+    template<typename Range>
+    struct Retro
     {
-      system.register_type<Input_Range<ContainerType> >(type+"_Range");
-      system.register_type<typename ContainerType::iterator>(type+"_Iterator");
+      Retro(const Range &r)
+        : m_r(r)
+      {}
 
-      system.register_function(build_constructor<Input_Range<ContainerType>, ContainerType &>(), "range");
-      system.register_function(build_constructor<Input_Range<ContainerType>, 
-          typename ContainerType::iterator>(), "range");
+      bool empty() { return m_r.empty(); }
+      void pop_front() { m_r.pop_back(); }
+      void pop_back() { m_r.pop_front(); }
+      typename Range::reference_type front() { return m_r.back(); }
+      typename Range::reference_type back() { return m_r.front(); }
 
-      typedef std::pair<typename ContainerType::iterator, typename ContainerType::iterator> ItrPair;
-
-      system.register_function(build_constructor<Input_Range<ContainerType>, 
-          const ItrPair &>(), "range");
-      system.register_type<ItrPair>(type+"_Iterator_Pair");
+    private:
+      Range m_r;
+    };
 
 
-      register_function(system, &Input_Range<ContainerType>::empty, "empty");
-      register_function(system, &Input_Range<ContainerType>::pop_front, "pop_front");
-      register_function(system, &Input_Range<ContainerType>::front, "front");
-      system.register_function(build_constructor<Input_Range<ContainerType>, const Input_Range<ContainerType> &>(), "clone");
+    /**
+    * Add Bidir_Range support for the given ContainerType
+    */
+    template<typename ContainerType>
+    ModulePtr input_range_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      m->add(user_type<Bidir_Range<ContainerType> >(), type + "_Range");
+
+      copy_constructor<Bidir_Range<ContainerType> >(type + "_Range", m);
+
+      m->add(constructor<Bidir_Range<ContainerType> (ContainerType &)>(), "range");
+
+      m->add(fun(&Bidir_Range<ContainerType>::empty), "empty");
+      m->add(fun(&Bidir_Range<ContainerType>::pop_front), "pop_front");
+      m->add(fun(&Bidir_Range<ContainerType>::front), "front");
+      m->add(fun(&Bidir_Range<ContainerType>::pop_back), "pop_back");
+      m->add(fun(&Bidir_Range<ContainerType>::back), "back");
+
+      return m;
     } 
-  
-  /**
-   * Add reversible_container concept to the given ContainerType
-   * http://www.sgi.com/tech/stl/ReversibleContainer.html
-   */
-  template<typename ContainerType>
-  void bootstrap_reversible_container(Dispatch_Engine &/*system*/, const std::string &/*type*/)
-  {
-  }
 
-  /**
-   * Add random_access_container concept to the given ContainerType
-   * http://www.sgi.com/tech/stl/RandomAccessContainer.html
-   */
-  template<typename ContainerType>
-  void bootstrap_random_access_container(Dispatch_Engine &system, const std::string &type)
-  {
-    bootstrap_reversible_container<ContainerType>(system, type);
-    typedef typename ContainerType::reference(ContainerType::*indexoper)(size_t);
+    /**
+    * Add reversible_container concept to the given ContainerType
+    * http://www.sgi.com/tech/stl/ReversibleContainer.html
+    */
+    template<typename ContainerType>
+    ModulePtr reversible_container_type(const std::string &, ModulePtr m = ModulePtr(new Module()))
+    {
+      return m;
+    }
 
-    //In the interest of runtime safety for the system, we prefer the at() method for [] access,
-    //to throw an exception in an out of bounds condition.
-    system.register_function(
-        boost::function<typename ContainerType::reference (ContainerType *, int)>(indexoper(&ContainerType::at)), "[]");
-    system.register_function(
-        boost::function<typename ContainerType::reference (ContainerType *, int)>(indexoper(&ContainerType::operator[])), "at");
+    /**
+    * Add random_access_container concept to the given ContainerType
+    * http://www.sgi.com/tech/stl/RandomAccessContainer.html
+    */
+    template<typename ContainerType>
+    ModulePtr random_access_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      reversible_container_type<ContainerType>(type, m);
+      typedef typename ContainerType::reference(ContainerType::*indexoper)(size_t);
 
-  }
+      //In the interest of runtime safety for the m, we prefer the at() method for [] access,
+      //to throw an exception in an out of bounds condition.
+      m->add(
+        fun(boost::function<typename ContainerType::reference (ContainerType *, int)>(static_cast<indexoper>(&ContainerType::at))), "[]");
 
-  /**
-   * Add assignable concept to the given ContainerType
-   * http://www.sgi.com/tech/stl/Assignable.html
-   */
-  template<typename ContainerType>
-  void bootstrap_assignable(Dispatch_Engine &system, const std::string &type)
-  {
-    add_basic_constructors<ContainerType>(system, type);
-    add_oper_assign<ContainerType>(system);
-  }
+      return m;
+    }
 
-  /**
-   * Add container concept to the given ContainerType
-   * http://www.sgi.com/tech/stl/Container.html
-   */
-  template<typename ContainerType>
-  void bootstrap_container(Dispatch_Engine &system, const std::string &type)
-  {
-    bootstrap_assignable<ContainerType>(system, type);
+    /**
+    * Add assignable concept to the given ContainerType
+    * http://www.sgi.com/tech/stl/Assignable.html
+    */
+    template<typename ContainerType>
+    ModulePtr assignable_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      basic_constructors<ContainerType>(type, m);
+      oper_assign<ContainerType>(m);
+      return m;
+    }
 
-    register_function(system, &ContainerType::size, "size");
-    register_function(system, &ContainerType::max_size, "max_size");
-    register_function(system, &ContainerType::empty, "empty");
-  }
+    /**
+    * Add container concept to the given ContainerType
+    * http://www.sgi.com/tech/stl/Container.html
+    */
+    template<typename ContainerType>
+    ModulePtr container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      assignable_type<ContainerType>(type, m);
 
-  /**
-   * Add forward container concept to the given ContainerType
-   * http://www.sgi.com/tech/stl/ForwardContainer.html
-   */
-  template<typename ContainerType>
-  void bootstrap_forward_container(Dispatch_Engine &system, const std::string &type)
-  {
-    bootstrap_input_range<ContainerType>(system, type);
-    bootstrap_container<ContainerType>(system, type);
-  }
+      m->add(fun<size_t (ContainerType::*)() const>(&ContainerType::size), "size");
+      m->add(fun<bool (ContainerType::*)() const>(&ContainerType::empty), "empty");
+      m->add(fun<void (ContainerType::*)()>(&ContainerType::clear), "clear");
 
-  /**
-   * Add default constructable concept to the given Type
-   * http://www.sgi.com/tech/stl/DefaultConstructible.html
-   */
-  template<typename Type>
-  void bootstrap_default_constructible(Dispatch_Engine &system, const std::string &type)
-  {
-    system.register_function(build_constructor<Type>(), type);
-  }
+      return m;
+    }
 
-  /**
-   * Algorithm for inserting at a specific position into a container
-   */
-  template<typename Type>
+    /**
+    * Add forward container concept to the given ContainerType
+    * http://www.sgi.com/tech/stl/ForwardContainer.html
+    */
+    template<typename ContainerType>
+    ModulePtr forward_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      input_range_type<ContainerType>(type, m);
+      container_type<ContainerType>(type, m);
+
+      return m;
+    }
+
+    /**
+    * Add default constructable concept to the given Type
+    * http://www.sgi.com/tech/stl/DefaultConstructible.html
+    */
+    template<typename Type>
+    ModulePtr default_constructible_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      m->add(constructor<Type ()>(), type);
+      return m;
+    }
+
+    /**
+    * Algorithm for inserting at a specific position into a container
+    */
+    template<typename Type>
     void insert_at(Type &container, int pos, const typename Type::value_type &v)
     {
       typename Type::iterator itr = container.begin();
       typename Type::iterator end = container.end();
-      
+
       if (pos < 0 || std::distance(itr, end) < pos)
       {
         throw std::range_error("Cannot insert past end of range");
@@ -188,15 +220,15 @@ namespace dispatchkit
       container.insert(itr, v);
     }
 
-  /**
-   * Algorithm for erasing a specific position from a container
-   */
-  template<typename Type>
+    /**
+    * Algorithm for erasing a specific position from a container
+    */
+    template<typename Type>
     void erase_at(Type &container, int pos)
     {
       typename Type::iterator itr = container.begin();
       typename Type::iterator end = container.end();
-      
+
       if (pos < 0 || std::distance(itr, end) < (pos-1))
       {
         throw std::range_error("Cannot erase past end of range");
@@ -206,178 +238,245 @@ namespace dispatchkit
       container.erase(itr);
     }
 
-  /**
-   * Add sequence concept to the given ContainerType
-   * http://www.sgi.com/tech/stl/Sequence.html
-   */
-  template<typename ContainerType>
-  void bootstrap_sequence(Dispatch_Engine &system, const std::string &type)
-  {
-    bootstrap_forward_container<ContainerType>(system, type);
-    bootstrap_default_constructible<ContainerType>(system, type);
-
-    std::string insert_name;
-    if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
+    /**
+    * Add sequence concept to the given ContainerType
+    * http://www.sgi.com/tech/stl/Sequence.html
+    */
+    template<typename ContainerType>
+    ModulePtr sequence_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
-      insert_name = "insert_ref_at";
-    } else {
-      insert_name = "insert_at";
+      forward_container_type<ContainerType>(type, m);
+      default_constructible_type<ContainerType>(type, m);
+
+      std::string insert_name;
+      if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
+      {
+        insert_name = "insert_ref_at";
+      } else {
+        insert_name = "insert_at";
+      }
+
+      m->add(fun(&insert_at<ContainerType>), insert_name);
+      m->add(fun(&erase_at<ContainerType>), "erase_at");
+
+      return m;
     }
 
-    register_function(system, &insert_at<ContainerType>, insert_name);
-    register_function(system, &erase_at<ContainerType>, "erase_at");
-  }
-
-  /**
-   * Add back insertion sequence concept to the given ContainerType
-   * http://www.sgi.com/tech/stl/BackInsertionSequence.html
-   */
-  template<typename ContainerType>
-  void bootstrap_back_insertion_sequence(Dispatch_Engine &system, const std::string &type)
-  {
-    bootstrap_sequence<ContainerType>(system, type);
-
-
-    typedef typename ContainerType::reference (ContainerType::*backptr)();
-
-    register_function(system, (backptr(&ContainerType::back)), "back");
-
-    std::string push_back_name;
-    if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
+    /**
+    * Add back insertion sequence concept to the given ContainerType
+    * http://www.sgi.com/tech/stl/BackInsertionSequence.html
+    */
+    template<typename ContainerType>
+    ModulePtr back_insertion_sequence_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
-      push_back_name = "push_back_ref";
-    } else {
-      push_back_name = "push_back";
+      sequence_type<ContainerType>(type, m);
+
+
+      typedef typename ContainerType::reference (ContainerType::*backptr)();
+
+      m->add(fun(static_cast<backptr>(&ContainerType::back)), "back");
+
+      std::string push_back_name;
+      if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
+      {
+        push_back_name = "push_back_ref";
+      } else {
+        push_back_name = "push_back";
+      }
+
+      m->add(fun(&ContainerType::push_back), push_back_name);
+      m->add(fun(&ContainerType::pop_back), "pop_back");
+      return m;
     }
 
-    register_function(system, &ContainerType::push_back, push_back_name);
-    register_function(system, &ContainerType::pop_back, "pop_back");
-  }
 
-  /**
-   * Create a vector type with associated concepts
-   * http://www.sgi.com/tech/stl/Vector.html
-   */
-  template<typename VectorType>
-  void bootstrap_vector(Dispatch_Engine &system, const std::string &type)
-  {
-    system.register_type<VectorType>(type);
-    bootstrap_random_access_container<VectorType>(system, type);
-    bootstrap_back_insertion_sequence<VectorType>(system, type);
-  }
-
-  /**
-   * Create a vector type with associated concepts
-   * http://www.sgi.com/tech/stl/Vector.html
-   */
-  template<typename ContainerType>
-    void bootstrap_associative_container(Dispatch_Engine &system, const std::string &type)
+    /**
+     *Front insertion sequence
+     *http://www.sgi.com/tech/stl/FrontInsertionSequence.html
+     */
+    template<typename ContainerType>
+    ModulePtr front_insertion_sequence_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
-      bootstrap_forward_container<ContainerType>(system, type);
-      bootstrap_default_constructible<ContainerType>(system, type);
+      sequence_type<ContainerType>(type, m);
+
+      typedef typename ContainerType::reference (ContainerType::*frontptr)();
+
+      m->add(fun(static_cast<frontptr>(&ContainerType::front)), "front");
+
+      std::string push_front_name;
+      if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
+      {
+        push_front_name = "push_front_ref";
+      } else {
+        push_front_name = "push_front";
+      }
+      m->add(fun(&ContainerType::push_front), push_front_name);
+      m->add(fun(&ContainerType::pop_front), "pop_front");
+      return m;
     }
 
-  /**
-   * bootstrap a given PairType
-   * http://www.sgi.com/tech/stl/pair.html
-   */
-  template<typename PairType>
-    void bootstrap_pair(Dispatch_Engine &system, const std::string &type)
+    /**
+     * hopefully working List type
+     * http://www.sgi.com/tech/stl/List.html
+     */
+    template<typename ListType>
+    ModulePtr list_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
-      system.register_type<PairType>(type);
-
-      register_member(system, &PairType::first, "first");
-      register_member(system, &PairType::second, "second");
-
-      system.register_function(build_constructor<PairType >(), type);
-      system.register_function(build_constructor<PairType, const PairType &>(), type);
-      system.register_function(build_constructor<PairType, const PairType &>(), "clone");
-      system.register_function(build_constructor<PairType, const typename PairType::first_type &, const typename PairType::second_type &>(), type);
-     }
-
-
-  /**
-   * Add pair associative container concept to the given ContainerType
-   * http://www.sgi.com/tech/stl/PairAssociativeContainer.html
-   */
-  template<typename ContainerType>
-    void bootstrap_pair_associative_container(Dispatch_Engine &system, const std::string &type)
-    {
-      bootstrap_associative_container<ContainerType>(system, type);
-      bootstrap_pair<typename ContainerType::value_type>(system, type + "_Pair");
+      m->add(user_type<ListType>(), type);
+      front_insertion_sequence_type<ListType>(type, m);
+      back_insertion_sequence_type<ListType>(type, m);
+      return m;
     }
 
-  /**
-   * Add unique associative container concept to the given ContainerType
-   * http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
-   */
-  template<typename ContainerType>
-    void bootstrap_unique_associative_container(Dispatch_Engine &system, const std::string &type)
+    /**
+    * Create a vector type with associated concepts
+    * http://www.sgi.com/tech/stl/Vector.html
+    */
+    template<typename VectorType>
+    ModulePtr vector_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
-      bootstrap_associative_container<ContainerType>(system, type);
-      register_function(system, &ContainerType::count, "count");
+      m->add(user_type<VectorType>(), type);
+      random_access_container_type<VectorType>(type, m);
+      back_insertion_sequence_type<VectorType>(type, m);
+      return m;
     }
 
-  /**
-   * Add sorted associative container concept to the given ContainerType
-   * http://www.sgi.com/tech/stl/SortedAssociativeContainer.html
-   */
-  template<typename ContainerType>
-    void bootstrap_sorted_associative_container(Dispatch_Engine &system, const std::string &type)
+    /**
+    * Create a vector type with associated concepts
+    * http://www.sgi.com/tech/stl/Vector.html
+    */
+    template<typename ContainerType>
+    ModulePtr associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      forward_container_type<ContainerType>(type, m);
+      default_constructible_type<ContainerType>(type, m);
+      return m;
+    }
+
+    /**
+    * bootstrap a given PairType
+    * http://www.sgi.com/tech/stl/pair.html
+    */
+    template<typename PairType>
+    ModulePtr pair_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      m->add(user_type<PairType>(), type);
+
+      m->add(fun(&PairType::first), "first");
+      m->add(fun(&PairType::second), "second");
+
+      basic_constructors<PairType>(type, m);
+      m->add(constructor<PairType (const typename PairType::first_type &, const typename PairType::second_type &)>(), type);
+
+      return m;
+    }
+
+
+    /**
+    * Add pair associative container concept to the given ContainerType
+    * http://www.sgi.com/tech/stl/PairAssociativeContainer.html
+    */
+    template<typename ContainerType>
+    ModulePtr pair_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      associative_container_type<ContainerType>(type, m);
+      pair_type<typename ContainerType::value_type>(type + "_Pair", m);
+
+      return m;
+    }
+
+    /**
+    * Add unique associative container concept to the given ContainerType
+    * http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
+    */
+    template<typename ContainerType>
+    ModulePtr unique_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      associative_container_type<ContainerType>(type, m);
+      m->add(fun<size_t (ContainerType::*)(const typename ContainerType::key_type &) const>(&ContainerType::count), "count");
+
+      return m;
+    }
+
+    /**
+    * Add sorted associative container concept to the given ContainerType
+    * http://www.sgi.com/tech/stl/SortedAssociativeContainer.html
+    */
+    template<typename ContainerType>
+    ModulePtr sorted_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
       typedef std::pair<typename ContainerType::iterator, typename ContainerType::iterator> 
-                        (ContainerType::*eq_range)(const typename ContainerType::key_type &);
+        (ContainerType::*eq_range)(const typename ContainerType::key_type &);
 
-      bootstrap_reversible_container<ContainerType>(system, type);
-      bootstrap_associative_container<ContainerType>(system, type);
-      register_function(system, eq_range(&ContainerType::equal_range), "equal_range");
-     }
+      reversible_container_type<ContainerType>(type, m);
+      associative_container_type<ContainerType>(type, m);
 
-  /**
-   * Add unique sorted associative container concept to the given ContainerType
-   * http://www.sgi.com/tech/stl/UniqueSortedAssociativeContainer.html
-   */
-  template<typename ContainerType>
-    void bootstrap_unique_sorted_associative_container(Dispatch_Engine &system, const std::string &type)
-    {
-      bootstrap_sorted_associative_container<ContainerType>(system, type);
-      bootstrap_unique_associative_container<ContainerType>(system, type);
+      return m;
     }
 
-  /**
-   * Add a MapType container
-   * http://www.sgi.com/tech/stl/Map.html
-   */
-  template<typename MapType>
-    void bootstrap_map(Dispatch_Engine &system, const std::string &type)
+    /**
+    * Add unique sorted associative container concept to the given ContainerType
+    * http://www.sgi.com/tech/stl/UniqueSortedAssociativeContainer.html
+    */
+    template<typename ContainerType>
+    ModulePtr unique_sorted_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
-      system.register_type<MapType>(type);
-      register_function(system, &MapType::operator[], "[]");
-      bootstrap_unique_sorted_associative_container<MapType>(system, type);
-      bootstrap_pair_associative_container<MapType>(system, type);
+      sorted_associative_container_type<ContainerType>(type, m);
+      unique_associative_container_type<ContainerType>(type, m);
+
+      return m;
     }
 
-  /**
-   * Add a String container
-   * http://www.sgi.com/tech/stl/basic_string.html
-   */
-  template<typename String>
-    void bootstrap_string(Dispatch_Engine &system, const std::string &type)
+    /**
+    * Add a MapType container
+    * http://www.sgi.com/tech/stl/Map.html
+    */
+    template<typename MapType>
+    ModulePtr map_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
-      system.register_type<String>(type);
-      add_oper_add<String>(system);
-      add_oper_add_equals<String>(system);
-      add_opers_comparison<String>(system);
-      bootstrap_random_access_container<String>(system, type);
-      bootstrap_sequence<String>(system, type);
+      m->add(user_type<MapType>(), type);
+      m->add(fun(&MapType::operator[]), "[]");
+      unique_sorted_associative_container_type<MapType>(type, m);
+      pair_associative_container_type<MapType>(type, m);
+
+      return m;
+    }
+
+    /**
+    * Add a String container
+    * http://www.sgi.com/tech/stl/basic_string.html
+    */
+    template<typename String>
+    ModulePtr string_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    {
+      m->add(user_type<String>(), type);
+      oper_add<String>(m);
+      oper_add_equals<String>(m);
+      opers_comparison<String>(m);
+      random_access_container_type<String>(type, m);
+      sequence_type<String>(type, m);
+
+      //Special case: add push_back to string (which doesn't support other back_insertion operations
+      std::string push_back_name;
+      if (typeid(typename String::value_type) == typeid(Boxed_Value))
+      {
+        push_back_name = "push_back_ref";
+      } else {
+        push_back_name = "push_back";
+      }
+      m->add(fun(&String::push_back), push_back_name);
+
       typedef typename String::size_type (String::*find_func)(const String &, typename String::size_type) const;
-      register_function(system, find_func(&String::find), "find");
-      register_function(system, find_func(&String::rfind), "rfind");
-      register_function(system, find_func(&String::find_first_of), "find_first_of");
-      register_function(system, find_func(&String::find_last_of), "find_last_of");
-      register_function(system, find_func(&String::find_first_not_of), "find_first_not_of");
-      register_function(system, find_func(&String::find_last_not_of), "find_last_not_of");
+      m->add(fun(static_cast<find_func>(&String::find)), "find");
+      m->add(fun(static_cast<find_func>(&String::rfind)), "rfind");
+      m->add(fun(static_cast<find_func>(&String::find_first_of)), "find_first_of");
+      m->add(fun(static_cast<find_func>(&String::find_last_of)), "find_last_of");
+      m->add(fun(static_cast<find_func>(&String::find_first_not_of)), "find_first_not_of");
+      m->add(fun(static_cast<find_func>(&String::find_last_not_of)), "find_last_not_of");
+
+      return m;
     }
+  }
 }
 
 #endif

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -8,6 +8,7 @@
 #define __boxed_value_hpp__
 
 #include "type_info.hpp"
+#include "../chaiscript_threading.hpp"
 #include <map>
 #include <boost/shared_ptr.hpp>
 #include <boost/any.hpp>
@@ -17,7 +18,7 @@
 #include <boost/cstdint.hpp>
 #include <boost/type_traits/add_const.hpp>
 
-namespace dispatchkit
+namespace chaiscript 
 {
   /**
    * Boxed_Value is the main tool of the dispatchkit. It allows
@@ -97,11 +98,6 @@ namespace dispatchkit
           return *this;
         }
 
-        static bool get_false()
-        {
-          return false;
-        }
-
         Type_Info m_type_info;
         boost::any m_obj;
         bool m_is_ref;
@@ -116,51 +112,80 @@ namespace dispatchkit
        */
       struct Object_Cache
       {
+        Object_Cache()
+          : m_cullcount(0)
+        {
+        }
+
         boost::shared_ptr<Data> get(Boxed_Value::Void_Type)
         {
           return boost::shared_ptr<Data> (new Data(
-                Get_Type_Info<void>::get(),
+                detail::Get_Type_Info<void>::get(),
                 boost::any(), 
                 false)
               );
         }
 
         template<typename T>
-          boost::shared_ptr<Data> get(boost::shared_ptr<T> obj)
+          boost::shared_ptr<Data> get(const boost::shared_ptr<T> *obj)
           {
+            return get(*obj);
+          }
+
+        template<typename T>
+          boost::shared_ptr<Data> get(const boost::shared_ptr<T> &obj)
+          {
+            bool b_const = boost::is_const<T>::value; 
+
             boost::shared_ptr<Data> data(new Data(
-                  Get_Type_Info<T>::get(), 
+                  detail::Get_Type_Info<T>::get(), 
                   boost::any(obj), 
                   false,
                   boost::shared_ptr<Data::Shared_Ptr_Proxy>(new Data::Shared_Ptr_Proxy_Impl<T>()))
                 );
 
-            std::map<void *, Data >::iterator itr
-              = m_ptrs.find(obj.get());
+            std::map<std::pair<const void *, bool>, Data>::iterator itr
+              = m_ptrs.find(std::make_pair(obj.get(), b_const));
 
             if (itr != m_ptrs.end())
             {
               (*data) = (itr->second);
             } else {
-              m_ptrs.insert(std::make_pair(obj.get(), *data));
+              m_ptrs.insert(std::make_pair(std::make_pair(obj.get(), b_const), *data));
             }
 
             return data;
           }
 
+        template<typename T>
+          boost::shared_ptr<Data> get(T *t)
+          {
+            return get(boost::ref(*t));
+          }
+
         template<typename T>
           boost::shared_ptr<Data> get(boost::reference_wrapper<T> obj)
           {
+            bool b_const = boost::is_const<T>::value; 
+
             boost::shared_ptr<Data> data(new Data(
-                  Get_Type_Info<T>::get(),
+                  detail::Get_Type_Info<T>::get(),
                   boost::any(obj), 
                   true)
                 );
 
-            std::map<void *, Data >::iterator itr
-              = m_ptrs.find(obj.get_pointer());
+            std::map<std::pair<const void *, bool>, Data >::iterator itr
+              = m_ptrs.find(std::make_pair(obj.get_pointer(), b_const) );
 
-            if (itr != m_ptrs.end())
+            // If the ptr is found in the cache and it is the correct type,
+            // return it. It may be the incorrect type when two variables share the
+            // same memory location. Example:
+            // struct test { int x; };
+            // test t;
+            // Both t and t.x share the same memory location, but do not represent
+            // objects of the same type.
+            if (itr != m_ptrs.end() 
+                && itr->second.m_type_info.bare_equal(data->m_type_info))
             {
               (*data) = (itr->second);
             } 
@@ -172,7 +197,7 @@ namespace dispatchkit
           boost::shared_ptr<Data> get(const T& t)
           {
             boost::shared_ptr<Data> data(new Data(
-                  Get_Type_Info<T>::get(), 
+                  detail::Get_Type_Info<T>::get(), 
                   boost::any(boost::shared_ptr<T>(new T(t))), 
                   false,
                   boost::shared_ptr<Data::Shared_Ptr_Proxy>(new Data::Shared_Ptr_Proxy_Impl<T>()))
@@ -180,7 +205,7 @@ namespace dispatchkit
 
             boost::shared_ptr<T> *ptr = boost::any_cast<boost::shared_ptr<T> >(&data->m_obj);
 
-            m_ptrs.insert(std::make_pair(ptr->get(), *data));
+            m_ptrs.insert(std::make_pair(std::make_pair(ptr->get(), false), *data));
             return data;
           }
 
@@ -197,15 +222,23 @@ namespace dispatchkit
          * Drop objects from the cache where there is only one (ie, our)
          * reference to it, so it may be destructed
          */
-        void cull()
+        void cull(bool force = false)
         {
-          std::map<void *, Data >::iterator itr = m_ptrs.begin();
+          
+          ++m_cullcount;
+          if (force || m_cullcount % 10 != 0)
+          {
+            return;
+          }
+
+
+          std::map<std::pair<const void *, bool>, Data>::iterator itr = m_ptrs.begin();
 
           while (itr != m_ptrs.end())
           {
             if (itr->second.m_ptr_proxy->unique(&itr->second.m_obj) == 1)
             {
-              std::map<void *, Data >::iterator todel = itr;
+              std::map<std::pair<const void *, bool>, Data >::iterator todel = itr;
               ++itr;
               m_ptrs.erase(todel);
             } else {
@@ -214,7 +247,8 @@ namespace dispatchkit
           }
         }
 
-        std::map<void *, Data > m_ptrs;
+        std::map<std::pair<const void *, bool>, Data > m_ptrs;
+        int m_cullcount;
       };
 
     public:
@@ -251,11 +285,16 @@ namespace dispatchkit
       /**
        * Return a reference to the static global Object_Cache
        */
-      Object_Cache &get_object_cache()
+      static Object_Cache &get_object_cache()
       {
-        static Object_Cache oc;
-        return oc;
-      }    
+        static chaiscript::threading::Thread_Storage<Object_Cache> oc;
+        return *oc;
+      }   
+
+      static void clear_cache()
+      {
+        get_object_cache().m_ptrs.clear();
+      }
 
       /**
        * copy the values stored in rhs.m_data to m_data
@@ -286,7 +325,7 @@ namespace dispatchkit
        */
       bool is_unknown() const
       {
-        return m_data->m_type_info.m_is_unknown;
+        return m_data->m_type_info.is_unknown();
       }
 
       boost::any get() const
@@ -304,145 +343,231 @@ namespace dispatchkit
   };
 
 
-  // Cast_Helper helper classes
+  namespace detail
+  {
+    // Cast_Helper helper classes
 
-  /**
-   * Generic Cast_Helper, for casting to any type
-   */
-  template<typename Result>
-    struct Cast_Helper
-    {
-      typedef typename boost::reference_wrapper<typename boost::add_const<Result>::type > Result_Type;
-
-      static Result_Type cast(const Boxed_Value &ob)
+    /**
+     * Generic Cast_Helper, for casting to any type
+     */
+    template<typename Result>
+      struct Cast_Helper
       {
-        if (ob.is_ref())
+        typedef typename boost::reference_wrapper<typename boost::add_const<Result>::type > Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob)
         {
-          return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
-        } else {
-          return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));   
+          if (ob.is_ref())
+          {
+            if (!ob.get_type_info().is_const())
+            {
+              return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
+            } else {
+              return boost::any_cast<boost::reference_wrapper<const Result> >(ob.get());
+            }
+          } else {
+            if (!ob.get_type_info().is_const())
+            {
+              return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));   
+            } else {
+              return boost::cref(*(boost::any_cast<boost::shared_ptr<const Result> >(ob.get())));   
+            }
+          }
         }
-      }
-    };
+      };
 
-  /**
-   * Cast_Helper for casting to a const & type
-   */
-  template<typename Result>
-    struct Cast_Helper<const Result &>
-    {
-      typedef typename boost::reference_wrapper<typename boost::add_const<Result>::type > Result_Type;
-        
-      static Result_Type cast(const Boxed_Value &ob)
+    /**
+     * Cast_Helper for casting to a const & type
+     */
+    template<typename Result>
+      struct Cast_Helper<const Result &>
       {
-        if (ob.is_ref())
+        typedef typename boost::reference_wrapper<typename boost::add_const<Result>::type > Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob)
         {
-          return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
-        } else {
-          return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));   
+          if (ob.is_ref())
+          {
+            if (!ob.get_type_info().is_const())
+            {
+              return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
+            } else {
+              return boost::any_cast<boost::reference_wrapper<const Result> >(ob.get());
+            }
+          } else {
+            if (!ob.get_type_info().is_const())
+            {
+              return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));   
+            } else {
+              return boost::cref(*(boost::any_cast<boost::shared_ptr<const Result> >(ob.get())));   
+            }
+          }
         }
-      }
-    };
+      };
 
-  /**
-   * Cast_Helper for casting to a const * type
-   */
-  template<typename Result>
-    struct Cast_Helper<const Result *>
-    {
-      typedef const Result * Result_Type;
-
-      static Result_Type cast(const Boxed_Value &ob)
+    /**
+     * Cast_Helper for casting to a const * type
+     */
+    template<typename Result>
+      struct Cast_Helper<const Result *>
       {
-        if (ob.is_ref())
+        typedef const Result * Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob)
         {
-          return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
-        } else {
-          return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
+          if (ob.is_ref())
+          {
+            if (!ob.get_type_info().is_const())
+            {
+              return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
+            } else {
+              return (boost::any_cast<boost::reference_wrapper<const Result> >(ob.get())).get_pointer();
+            }
+          } else {
+            if (!ob.get_type_info().is_const())
+            {
+              return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
+            } else {
+              return (boost::any_cast<boost::shared_ptr<const Result> >(ob.get())).get();
+            }
+          }
         }
-      }
-    };
+      };
 
-  /**
-   * Cast_Helper for casting to a * type
-   */
-  template<typename Result>
-    struct Cast_Helper<Result *>
-    {
-      typedef Result * Result_Type;
-
-      static Result_Type cast(const Boxed_Value &ob)
+    /**
+     * Cast_Helper for casting to a * type
+     */
+    template<typename Result>
+      struct Cast_Helper<Result *>
       {
-        if (ob.is_ref())
+        typedef Result * Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob)
         {
-          return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
-        } else {
-          return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
+          if (ob.is_ref())
+          {
+            return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
+          } else {
+            return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
+          }
         }
-      }
-    };
+      };
 
-  /**
-   * Cast_Helper for casting to a & type
-   */
-  template<typename Result>
-    struct Cast_Helper<Result &>
-    {
-      typedef typename boost::reference_wrapper<Result> Result_Type;
-
-      static Result_Type cast(const Boxed_Value &ob)
+    /**
+     * Cast_Helper for casting to a & type
+     */
+    template<typename Result>
+      struct Cast_Helper<Result &>
       {
-        if (ob.is_ref())
+        typedef typename boost::reference_wrapper<Result> Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob)
         {
-          return boost::any_cast<boost::reference_wrapper<Result> >(ob.get());
-        } else {
-          return boost::ref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
+          if (ob.is_ref())
+          {
+            return boost::any_cast<boost::reference_wrapper<Result> >(ob.get());
+          } else {
+            return boost::ref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
+          }
         }
-      }
-    };
+      };
 
-  /**
-   * Cast_Helper for casting to a boost::shared_ptr<> type
-   */
-  template<typename Result>
-    struct Cast_Helper<typename boost::shared_ptr<Result> >
-    {
-      typedef typename boost::shared_ptr<Result> Result_Type;
-        
-      static Result_Type cast(const Boxed_Value &ob)
+    /**
+     * Cast_Helper for casting to a boost::shared_ptr<> type
+     */
+    template<typename Result>
+      struct Cast_Helper<typename boost::shared_ptr<Result> >
       {
-        return boost::any_cast<boost::shared_ptr<Result> >(ob.get());
-      }
-    };
+        typedef typename boost::shared_ptr<Result> Result_Type;
 
+        static Result_Type cast(const Boxed_Value &ob)
+        {
+          return boost::any_cast<boost::shared_ptr<Result> >(ob.get());
+        }
+      };
 
-  /**
-   * Cast_Helper for casting to a Boxed_Value type
-   */
-  template<>
-    struct Cast_Helper<Boxed_Value>
-    {
-      typedef Boxed_Value Result_Type;
-
-      static Result_Type cast(const Boxed_Value &ob)
+    /**
+     * Cast_Helper for casting to a boost::shared_ptr<const> type
+     */
+    template<typename Result>
+      struct Cast_Helper<typename boost::shared_ptr<const Result> >
       {
-        return ob;    
-      }
-    };
+        typedef typename boost::shared_ptr<const Result> Result_Type;
 
-  /**
-   * Cast_Helper for casting to a const Boxed_Value & type
-   */
-  template<>
-    struct Cast_Helper<const Boxed_Value &>
-    {
-      typedef Boxed_Value Result_Type;
+        static Result_Type cast(const Boxed_Value &ob)
+        {
+          if (!ob.get_type_info().is_const())
+          {
+            return boost::const_pointer_cast<const Result>(boost::any_cast<boost::shared_ptr<Result> >(ob.get()));
+          } else {
+            return boost::any_cast<boost::shared_ptr<const Result> >(ob.get());
+          }
+        }
+      };
 
-      static Result_Type cast(const Boxed_Value &ob)
+    /**
+     * Cast_Helper for casting to a const boost::shared_ptr<> & type
+     */
+    template<typename Result>
+      struct Cast_Helper<const boost::shared_ptr<Result> &>
       {
-        return ob;    
-      }
-    };
+        typedef typename boost::shared_ptr<Result> Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob)
+        {
+          return boost::any_cast<boost::shared_ptr<Result> >(ob.get());
+        }
+      };
+
+    /**
+     * Cast_Helper for casting to a const boost::shared_ptr<const> & type
+     */
+    template<typename Result>
+      struct Cast_Helper<const boost::shared_ptr<const Result> &>
+      {
+        typedef typename boost::shared_ptr<const Result> Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob)
+        {
+          if (!ob.get_type_info().is_const())
+          {
+            return boost::const_pointer_cast<const Result>(boost::any_cast<boost::shared_ptr<Result> >(ob.get()));
+          } else {
+            return boost::any_cast<boost::shared_ptr<const Result> >(ob.get());
+          }
+        }
+      };
+
+
+
+    /**
+     * Cast_Helper for casting to a Boxed_Value type
+     */
+    template<>
+      struct Cast_Helper<Boxed_Value>
+      {
+        typedef const Boxed_Value & Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob)
+        {
+          return ob;    
+        }
+      };
+
+    /**
+     * Cast_Helper for casting to a const Boxed_Value & type
+     */
+    template<>
+      struct Cast_Helper<const Boxed_Value &>
+      {
+        typedef const Boxed_Value & Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob)
+        {
+          return ob;    
+        }
+      };
+  }
 
   /**
    * class that is thrown in the event of a bad_boxed_cast. That is,
@@ -452,7 +577,7 @@ namespace dispatchkit
   {
     public:
       bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to) throw()
-        : from(t_from.m_type_info), to(&t_to), m_what("Cannot perform boxed_cast")
+        : from(t_from), to(&t_to), m_what("Cannot perform boxed_cast")
       {
       }
 
@@ -467,7 +592,8 @@ namespace dispatchkit
       {
         return m_what.c_str();
       }
-      const std::type_info *from;
+
+      Type_Info from;
       const std::type_info *to;
 
     private:
@@ -480,10 +606,10 @@ namespace dispatchkit
    * int &i = boxed_cast<int &>(boxedvalue);
    */
   template<typename Type>
-  typename Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv)
+  typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv)
   {
     try {
-      return Cast_Helper<Type>::cast(bv);
+      return detail::Cast_Helper<Type>::cast(bv);
     } catch (const boost::bad_any_cast &) {
       throw bad_boxed_cast(bv.get_type_info(), typeid(Type));
     }
@@ -498,12 +624,12 @@ namespace dispatchkit
     Boxed_POD_Value(const Boxed_Value &v)
       : d(0), i(0), m_isfloat(false)
     {
-      if (!v.get_type_info().m_type_info)
+      if (v.get_type_info().is_unknown())
       {
         throw boost::bad_any_cast();
       }
 
-      const std::type_info &inp_ = *v.get_type_info().m_type_info;
+      const Type_Info &inp_ = v.get_type_info();
 
       if (inp_ == typeid(double))
       {
@@ -619,19 +745,61 @@ namespace dispatchkit
     bool m_isfloat;
   };
 
-  /**
-   * Cast_Helper for converting from Boxed_Value to Boxed_POD_Value
-   */
-  template<>
-    struct Cast_Helper<Boxed_POD_Value>
-    {
-      typedef Boxed_POD_Value Result_Type;
-
-      static Result_Type cast(const Boxed_Value &ob)
+  namespace detail
+  {
+    /**
+     * Cast_Helper for converting from Boxed_Value to Boxed_POD_Value
+     */
+    template<>
+      struct Cast_Helper<Boxed_POD_Value>
       {
-        return Boxed_POD_Value(ob);
-      }
-    };
+        typedef Boxed_POD_Value Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob)
+        {
+          return Boxed_POD_Value(ob);
+        }
+      };
+  }
+
+  template<typename T>
+    Boxed_Value var(T t)
+    {
+      return Boxed_Value(t);
+    }
+
+  template<typename T>
+    Boxed_Value const_var(T *t)
+    {
+      return Boxed_Value( const_cast<typename boost::add_const<T>::type>(t) );
+    }
+
+  template<typename T>
+    Boxed_Value const_var(const boost::shared_ptr<T> &t)
+    {
+      return Boxed_Value( boost::const_pointer_cast<typename boost::add_const<T>::type>(t) );
+    }
+
+  template<typename T>
+    Boxed_Value const_var(const boost::reference_wrapper<T> &t)
+    {
+      return Boxed_Value( boost::cref(t.get()) );
+    }
+
+  template<typename T>
+    Boxed_Value const_var(const T &t)
+    {
+      return Boxed_Value(boost::shared_ptr<typename boost::add_const<T>::type >(new T(t)));
+    }
+
+  /**
+   * Return true if the two Boxed_Values share the same internal type
+   */
+  static bool type_match(Boxed_Value l, Boxed_Value r)
+  {
+    return l.get_type_info() == r.get_type_info();
+  }
+
 }
 
 #endif

include/chaiscript/dispatchkit/dispatchkit.hpp

@@ -13,6 +13,7 @@
 #include <set>
 #include <boost/shared_ptr.hpp>
 #include <boost/lexical_cast.hpp>
+#include <boost/tuple/tuple.hpp>
 #include <stdexcept>
 #include <vector>
 #include <iostream>
@@ -22,49 +23,113 @@
 #include "type_info.hpp"
 #include "proxy_functions.hpp"
 #include "proxy_constructors.hpp"
+#include "dynamic_object.hpp"
+#include "../chaiscript_threading.hpp"
 
-namespace dispatchkit
+namespace chaiscript
 {
+  class Module
+  {
+    public:
+      Module &add(const Type_Info &ti, const std::string &name)
+      {
+        m_typeinfos.push_back(std::make_pair(ti, name));
+        return *this;
+      }
+
+      Module &add(const Proxy_Function &f, const std::string &name)
+      {
+        m_funcs.push_back(std::make_pair(f, name));
+        return *this;
+      }
+
+      //Add a bit of chaiscript to eval during module implementation
+      Module &eval(const std::string &str)
+      {
+        m_evals.push_back(str);
+        return *this;
+      }
+
+
+      template<typename Eval, typename Engine>
+        void apply(Eval &t_eval, Engine &t_engine) const
+        {
+          apply(m_typeinfos.begin(), m_typeinfos.end(), t_engine);
+          apply(m_funcs.begin(), m_funcs.end(), t_engine);
+          apply_eval(m_evals.begin(), m_evals.end(), t_eval);
+        }
+
+    private:
+      std::vector<std::pair<Type_Info, std::string> > m_typeinfos;
+      std::vector<std::pair<Proxy_Function, std::string> > m_funcs;
+      std::vector<std::string> m_evals;
+
+      template<typename T, typename InItr>
+        void apply(InItr begin, InItr end, T &t) const
+        {
+          while (begin != end)
+          {
+            t.add(begin->first, begin->second);
+            ++begin;
+          }
+        }
+
+      template<typename T, typename InItr>
+        void apply_eval(InItr begin, InItr end, T &t) const
+        {
+          while (begin != end)
+          {
+            t.eval(*begin);
+            ++begin;
+          }
+        }
+
+
+  };
+
+  typedef boost::shared_ptr<Module> ModulePtr;
+
   /**
    * A Proxy_Function implementation that is able to take
    * a vector of Proxy_Functions and perform a dispatch on them. It is 
    * used specifically in the case of dealing with Function object variables
    */
-  class Dispatch_Function : public Proxy_Function
+  class Dispatch_Function : public Proxy_Function_Base
   {
     public:
-      Dispatch_Function(const std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > &t_funcs)
-        : m_funcs(t_funcs)
+      Dispatch_Function(const std::vector<std::pair<std::string, Proxy_Function > > &t_funcs)
+        : Proxy_Function_Base(std::vector<Type_Info>()),
+          m_funcs(t_funcs)
       {
       }
 
-      virtual bool operator==(const Proxy_Function &) const
+      virtual bool operator==(const Proxy_Function_Base &) const
       {
         return false;
       }
 
       virtual ~Dispatch_Function() {}
 
-      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params)
+      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
       {
-        return dispatch(m_funcs, params);
+        return dispatch(m_funcs.begin(), m_funcs.end(), params);
       }
 
-      virtual std::vector<Type_Info> get_param_types() const
+      virtual int get_arity() const
       {
-        return std::vector<Type_Info>();
+        return -1;
       }
 
-      virtual bool types_match(const std::vector<Boxed_Value> &types) const
+      virtual bool call_match(const std::vector<Boxed_Value> &vals) const
       {
-        typedef std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > function_vec;
+        typedef std::vector<std::pair<std::string, Proxy_Function > > function_vec;
 
         function_vec::const_iterator begin = m_funcs.begin();
         function_vec::const_iterator end = m_funcs.end();
 
         while (begin != end)
         {
-          if (begin->second->types_match(types))
+          if (begin->second->call_match(vals))
           {
             return true;
           } else {
@@ -81,9 +146,26 @@ namespace dispatchkit
       }
 
     private:
-      std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > m_funcs;
+      std::vector<std::pair<std::string, Proxy_Function > > m_funcs;
   };  
-  
+
+
+  /**
+   * Exception thrown in the case that a multi method dispatch fails
+   * because no matching function was found
+   * at runtime due to either an arity_error, a guard_error or a bad_boxed_cast
+   * exception
+   */
+  struct reserved_word_error : std::runtime_error
+  {
+    reserved_word_error(const std::string &word) throw()
+      : std::runtime_error("Reserved word not allowed in object name: " + word)
+    {
+    }
+
+    virtual ~reserved_word_error() throw() {}
+  };
+
 
   /**
    * Main class for the dispatchkit. Handles management
@@ -92,68 +174,92 @@ namespace dispatchkit
   class Dispatch_Engine
   {
     public:
-      typedef std::map<std::string, dispatchkit::Type_Info> Type_Name_Map;
+      typedef std::map<std::string, chaiscript::Type_Info> Type_Name_Map;
       typedef std::map<std::string, Boxed_Value> Scope;
-      typedef std::deque<Scope> Stack;
+      typedef boost::tuples::tuple<std::map<std::string, Boxed_Value>, std::deque<Scope>, bool> StackData;
+      typedef boost::shared_ptr<StackData> Stack;
 
       Dispatch_Engine()
         : m_place_holder(boost::shared_ptr<Placeholder_Object>(new Placeholder_Object()))
       {
-        m_scopes.push_back(Scope());
+        StackData &stack = get_stack_data();
+        stack.get<1>().push_back(Scope());
+      }
+
+      ~Dispatch_Engine()
+      {
+        Boxed_Value::clear_cache();
       }
 
       /**
        * Add a new named Proxy_Function to the system
        */
-      bool register_function(const boost::shared_ptr<Proxy_Function> &f, const std::string &name)
+      bool add(const Proxy_Function &f, const std::string &name)
       {
+        validate_object_name(name);
+
+        StackData &stack = get_stack_data();
+        stack.get<0>().erase(name);
         return add_function(f, name);
       }
 
-      /**
-       * Add a generic, named boost::function() to the system
-       */
-      template<typename Function>
-        bool register_function(const Function &func, const std::string &name)
-        {
-          return add_function(boost::shared_ptr<Proxy_Function>(new Proxy_Function_Impl<Function>(func)), name);
-        }
- 
       /**
        * Set the value of an object, by name. If the object
        * is not available in the current scope it is created
        */
-      template<typename Class>
-        void set_object(const std::string &name, const Class &obj)
-        {
-          for (int i = m_scopes.size()-1; i >= 0; --i)
-          {
-            std::map<std::string, Boxed_Value>::const_iterator itr = m_scopes[i].find(name);
-            if (itr != m_scopes[i].end())
-            {
-              m_scopes[i][name] = Boxed_Value(obj);
-              return;
-            }
-          }
+      void add(const Boxed_Value &obj, const std::string &name)
+      {
+        validate_object_name(name);
+        StackData &stack = get_stack_data();
 
-          add_object(name, obj);
+        for (int i = stack.get<1>().size()-1; i >= 0; --i)
+        {
+          std::map<std::string, Boxed_Value>::const_iterator itr = (stack.get<1>())[i].find(name);
+          if (itr != (stack.get<1>())[i].end())
+          {
+            stack.get<0>().erase(name);
+            (stack.get<1>())[i][name] = obj;
+            return;
+          }
         }
 
+        add_object(name, obj);
+      }
+
       /**
        * Adds a named object to the current scope
        */
-      template<typename Class>
-        void add_object(const std::string &name, const Class &obj)
-        {
-          m_scopes.back()[name] = Boxed_Value(obj);
-        }
+      void add_object(const std::string &name, const Boxed_Value &obj)
+      {
+        StackData &stack = get_stack_data();
+        validate_object_name(name);
+        stack.get<0>().erase(name);
+        stack.get<1>().back()[name] = obj;
+      }
+
+      /**
+       * Adds a new shared object, between all the threads
+       */
+      void add_shared_object(const Boxed_Value &obj, const std::string &name)
+      {
+        StackData &stack = get_stack_data();
+        validate_object_name(name);
+        stack.get<0>().erase(name);
+        
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::unique_lock<boost::shared_mutex> l(m_shared_object_mutex);
+#endif
+
+        m_shared_objects[name] = obj;
+      }
 
       /**
        * Adds a new scope to the stack
        */
       void new_scope()
       {
-        m_scopes.push_back(Scope());
+        StackData &stack = get_stack_data();
+        stack.get<1>().push_back(Scope());
       }
 
       /**
@@ -161,33 +267,58 @@ namespace dispatchkit
        */
       void pop_scope()
       {
-        if (m_scopes.size() > 1)
+        StackData &stack = get_stack_data();
+        if (stack.get<1>().size() > 1)
         {
-          m_scopes.pop_back();
+          Scope &scope(stack.get<1>().back());
+          for (Scope::const_iterator itr = scope.begin();
+               itr != scope.end();
+               ++itr)
+          {
+            stack.get<0>().erase(itr->first);
+          }
+          stack.get<1>().pop_back();
         } else {
           throw std::range_error("Unable to pop global stack");
         }
       }
 
-      /**
-       * Returns the current stack
-       */
-      Stack get_stack()
-      {
-        return m_scopes;
-      }
-
       /**
        * Swaps out the stack with a new stack
        * \returns the old stack
        * \param[in] s The new stack
        */
-      Stack set_stack(Stack s)
+      Stack set_stack(const Stack &s)
       {
-        std::swap(s, m_scopes);
+        Stack old = m_stack_holder->stack;
+        m_stack_holder->stack = s;
+        return old;
+      }
+
+      Stack new_stack() const
+      {
+        Stack s(new Stack::element_type());
+        s->get<1>().push_back(Scope());
+        s->get<2>() = false;
         return s;
       }
 
+      Stack get_stack() const
+      {
+        return m_stack_holder->stack;
+      }
+
+      void sync_cache()
+      {
+        m_stack_holder->stack->get<0>().clear();
+
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::shared_lock<boost::shared_mutex> l(m_mutex);
+#endif
+
+        get_function_cache() = m_functions;
+      }
+
       /**
        * Searches the current stack for an object of the given name
        * includes a special overload for the _ place holder object to
@@ -195,44 +326,82 @@ namespace dispatchkit
        */
       Boxed_Value get_object(const std::string &name) const
       {
+        // Is it a placeholder object?
         if (name == "_")
         {
           return m_place_holder;
         }
 
-        for (int i = m_scopes.size()-1; i >= 0; --i)
+        StackData &stack = get_stack_data();
+        std::map<std::string, Boxed_Value> &cache = stack.get<0>();
+
+        // Is it in the cache?
+        std::map<std::string, Boxed_Value>::const_iterator itr = cache.find(name);
+        if (itr != cache.end())
         {
-          std::map<std::string, Boxed_Value>::const_iterator itr = m_scopes[i].find(name);
-          if (itr != m_scopes[i].end())
+          return itr->second;
+        }
+
+        // Is it in the stack?
+        for (int i = stack.get<1>().size()-1; i >= 0; --i)
+        {
+          std::map<std::string, Boxed_Value>::const_iterator stackitr = (stack.get<1>())[i].find(name);
+          if (stackitr != (stack.get<1>())[i].end())
           {
+            cache[name] = stackitr->second;
+            return stackitr->second;
+          }
+        }
+
+        // Are we in the 0th stack and should check the shared objects?
+        if (stack.get<2>())
+        {
+#ifndef CHAISCRIPT_NO_THREADS
+          boost::shared_lock<boost::shared_mutex> l(m_shared_object_mutex);
+#endif
+
+          itr = m_shared_objects.find(name);
+          if (itr != m_shared_objects.end())
+          {
+            cache[name] = itr->second;
             return itr->second;
           }
         }
 
-        std::vector<std::pair<std::string, std::multimap<std::string, boost::shared_ptr<Proxy_Function> >::mapped_type> > funcs = get_function_impl(name, false);
+        // If all that failed, then check to see if it's a function
+        std::vector<std::pair<std::string, std::multimap<std::string, Proxy_Function >::mapped_type> > funcs = get_function(name);
 
         if (funcs.empty())
         {
           throw std::range_error("Object not known: " + name);
         } else {
-          return Boxed_Value(boost::shared_ptr<Proxy_Function>(new Dispatch_Function(funcs)));
+          Boxed_Value f(Const_Proxy_Function(new Dispatch_Function(funcs)));
+          cache[name] = f;
+          return f;
         }
       }
 
       /**
        * Registers a new named type
        */
-      template<typename Type>
-        void register_type(const std::string &name)
-        {
-          m_types.insert(std::make_pair(name, Get_Type_Info<Type>::get()));
-        }
+      void add(const Type_Info &ti, const std::string &name)
+      {
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::unique_lock<boost::shared_mutex> l(m_mutex);
+#endif
+
+        m_types.insert(std::make_pair(name, ti));
+      }
 
       /**
        * Returns the type info for a named type
        */
       Type_Info get_type(const std::string &name) const
       {
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::shared_lock<boost::shared_mutex> l(m_mutex);
+#endif
+
         Type_Name_Map::const_iterator itr = m_types.find(name);
 
         if (itr != m_types.end())
@@ -250,17 +419,21 @@ namespace dispatchkit
        */
       std::string get_type_name(const Type_Info &ti) const
       {
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::shared_lock<boost::shared_mutex> l(m_mutex);
+#endif
+
         for (Type_Name_Map::const_iterator itr = m_types.begin();
              itr != m_types.end();
              ++itr)
         {
-          if (itr->second.m_bare_type_info == ti.m_bare_type_info)
+          if (itr->second.bare_equal(ti))
           {
             return itr->first;
           }
         }
 
-        return ti.m_bare_type_info->name();
+        return ti.bare_name();
       }
 
       /**
@@ -268,55 +441,194 @@ namespace dispatchkit
        */
       std::vector<std::pair<std::string, Type_Info> > get_types() const
       {
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::shared_lock<boost::shared_mutex> l(m_mutex);
+#endif
+
         return std::vector<std::pair<std::string, Type_Info> >(m_types.begin(), m_types.end());
       }
 
       /**
        * Return a function by name
        */
-      std::vector<std::pair<std::string, std::multimap<std::string, boost::shared_ptr<Proxy_Function> >::mapped_type> > 
+      std::vector<std::pair<std::string, std::multimap<std::string, Proxy_Function >::mapped_type> > 
         get_function(const std::string &t_name) const
       {
-        return get_function_impl(t_name, true);
+        std::pair<std::multimap<std::string, Proxy_Function >::const_iterator, std::multimap<std::string, Proxy_Function >::const_iterator> range
+          = get_function_cache().equal_range(t_name);
+
+        return  std::vector<std::pair<std::string, std::multimap<std::string, Proxy_Function >::mapped_type> >(range.first, range.second);
       }
- 
+
+      /**
+       * Return true if a function exists
+       */
+      bool function_exists(const std::string &name) const
+      {
+        std::multimap<std::string, Proxy_Function> &functions = get_function_cache();
+        return functions.find(name) != functions.end();
+      }
+
       /**
        * Get a vector of all registered functions
        */
-      std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > get_functions() const
+      std::vector<std::pair<std::string, Proxy_Function > > get_functions() const
       {
-        return std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > >(m_functions.begin(), m_functions.end());
+        std::multimap<std::string, Proxy_Function> &functions = get_function_cache();
+        return std::vector<std::pair<std::string, Proxy_Function > >(functions.begin(), functions.end());
       }
 
+      void add_reserved_word(const std::string &name)
+      {
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::unique_lock<boost::shared_mutex> l(m_mutex);
+#endif
+
+        m_reserved_words.insert(name);
+      }
+
+      Boxed_Value call_function(const std::string &t_name, const std::vector<Boxed_Value> &params) const
+      {
+        std::multimap<std::string, Proxy_Function> &functions = get_function_cache();
+        std::pair<std::multimap<std::string, Proxy_Function >::const_iterator, std::multimap<std::string, Proxy_Function >::const_iterator> range
+          = functions.equal_range(t_name);
+
+        return  dispatch(range.first, range.second, params);
+      }
+
+      /**
+       * Dump object info to stdout
+       */
+        void dump_object(Boxed_Value o) const
+        {
+          Type_Info ti = o.get_type_info();
+          std::cout << (ti.is_const()?"const ":"") << get_type_name(ti) << std::endl;
+        }
+
+      /**
+       * Dump type info to stdout
+       */
+        void dump_type(const Type_Info &type) const
+        {
+          std::cout << (type.is_const()?"const ":"") << get_type_name(type);
+        }
+
+      /**
+       * Dump function to stdout
+       */
+        void dump_function(const std::pair<const std::string, Proxy_Function > &f) const
+        {
+          std::vector<Type_Info> params = f.second->get_param_types();
+          std::string annotation = f.second->annotation();
+
+          if (annotation.size() > 0) {
+            std::cout << annotation;
+          }
+          dump_type(params.front());
+          std::cout << " " << f.first << "(";
+
+          for (std::vector<Type_Info>::const_iterator itr = params.begin() + 1;
+              itr != params.end();
+              )
+          {
+            dump_type(*itr);
+            ++itr;
+
+            if (itr != params.end())
+            {
+              std::cout << ", ";
+            }
+          }
+
+          std::cout << ") " << std::endl;
+        }
+
+      /**
+       * Dump all system info to stdout
+       */
+        void dump_system() const
+        {
+          std::cout << "Registered Types: " << std::endl;
+          std::vector<std::pair<std::string, Type_Info> > types = get_types();
+          for (std::vector<std::pair<std::string, Type_Info> >::const_iterator itr = types.begin();
+              itr != types.end();
+              ++itr)
+          {
+            std::cout << itr->first << ": ";
+            std::cout << itr->second.bare_name();
+            std::cout << std::endl;
+          }
+
+          std::cout << std::endl;  
+          std::vector<std::pair<std::string, Proxy_Function > > funcs = get_functions();
+
+          std::cout << "Functions: " << std::endl;
+          for (std::vector<std::pair<std::string, Proxy_Function > >::const_iterator itr = funcs.begin();
+              itr != funcs.end();
+              ++itr)
+          {
+            dump_function(*itr);
+          }
+          std::cout << std::endl;
+        }
+
+      /**
+       * return true if the Boxed_Value matches the registered type by name
+       */
+      bool is_type(Boxed_Value r, const std::string &user_typename) const
+      {
+        try {
+          if (get_type(user_typename).bare_equal(r.get_type_info()))
+          {
+            return true;
+          }
+        } catch (const std::range_error &) {
+        }
+
+        try {
+          const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(r);
+          return d.get_type_name() == user_typename;
+        } catch (const std::bad_cast &) {
+        }
+
+        return false;
+      }
+
+      std::string type_name(Boxed_Value obj) const
+      {
+        return get_type_name(obj.get_type_info());
+      }
+
+
     private:
       /**
-       * Implementation detail for searching for a function by name.
-       * Looks for all registered global functions and optionally for an object
-       * in scope with the same name
+       * Returns the current stack
+       * make const/non const versions
        */
-      std::vector<std::pair<std::string, std::multimap<std::string, boost::shared_ptr<Proxy_Function> >::mapped_type> > 
-        get_function_impl(const std::string &t_name, bool include_objects) const
+      StackData &get_stack_data() const
       {
-        std::vector<std::pair<std::string, std::multimap<std::string, boost::shared_ptr<Proxy_Function> >::mapped_type> > funcs;
+        return *(m_stack_holder->stack);
+      }
 
-        if (include_objects)
+      std::multimap<std::string, Proxy_Function> &get_function_cache() const
+      {
+        return m_stack_holder->function_cache;
+      }
+
+
+      /**
+       * Throw a reserved_word exception if the name is not allowed
+       */
+      void validate_object_name(const std::string &name) const
+      {
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::shared_lock<boost::shared_mutex> l(m_mutex);
+#endif
+
+        if (m_reserved_words.find(name) != m_reserved_words.end())
         {
-          try {
-            funcs.insert(funcs.end(), 
-              std::make_pair(
-                  t_name, 
-                  boxed_cast<std::multimap<std::string, boost::shared_ptr<Proxy_Function> >::mapped_type>(get_object(t_name)))
-                );
-          } catch (const bad_boxed_cast &) {
-          } catch (const std::range_error &) {
-          }
+          throw reserved_word_error(name);
         }
-
-        std::pair<std::multimap<std::string, boost::shared_ptr<Proxy_Function> >::const_iterator, std::multimap<std::string, boost::shared_ptr<Proxy_Function> >::const_iterator> range
-          = m_functions.equal_range(t_name);
-
-        funcs.insert(funcs.end(), range.first, range.second);
-        return funcs;
       }
 
       /**
@@ -324,9 +636,13 @@ namespace dispatchkit
        * true if the function was added, false if a function with the
        * same signature and name already exists.
        */
-      bool add_function(const boost::shared_ptr<Proxy_Function> &f, const std::string &t_name)
+      bool add_function(const Proxy_Function &f, const std::string &t_name)
       {
-        std::pair<std::multimap<std::string, boost::shared_ptr<Proxy_Function> >::const_iterator, std::multimap<std::string, boost::shared_ptr<Proxy_Function> >::const_iterator> range
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::unique_lock<boost::shared_mutex> l(m_mutex);
+#endif
+
+        std::pair<std::multimap<std::string, Proxy_Function >::const_iterator, std::multimap<std::string, Proxy_Function >::const_iterator> range
           = m_functions.equal_range(t_name);
 
         while (range.first != range.second)
@@ -339,90 +655,41 @@ namespace dispatchkit
         }
 
         m_functions.insert(std::make_pair(t_name, f));
+        get_function_cache().insert(std::make_pair(t_name, f));
+
         return true;
       }
 
-      std::deque<Scope> m_scopes;
+#ifndef CHAISCRIPT_NO_THREADS
+      mutable boost::shared_mutex m_mutex;
+      mutable boost::shared_mutex m_shared_object_mutex;
+#endif
+
+      struct Stack_Holder
+      {
+        Stack_Holder()
+          : stack(new StackData())
+        {
+          stack->get<2>() = true;
+        }
+
+        Stack stack;
+
+        std::multimap<std::string, Proxy_Function> function_cache;
+      };  
+
+      chaiscript::threading::Thread_Storage<Stack_Holder> m_stack_holder;
+
+
+      std::multimap<std::string, Proxy_Function> m_functions;
+      std::map<std::string, Boxed_Value> m_shared_objects;
 
-      std::multimap<std::string, boost::shared_ptr<Proxy_Function> > m_functions;
       Type_Name_Map m_types;
       Boxed_Value m_place_holder;
+
+      std::set<std::string> m_reserved_words;
   };
 
-  /**
-   * Dump object info to stdout
-   */
-  void dump_object(Boxed_Value o, const Dispatch_Engine &e)
-  {
-    std::cout << e.get_type_name(o.get_type_info()) << std::endl;
-  }
-
-  /**
-   * Dump type info to stdout
-   */
-  void dump_type(const Type_Info &type, const Dispatch_Engine &e)
-  {
-    std::cout << e.get_type_name(type);
-  }
-
-  /**
-   * Dump function to stdout
-   */
-  void dump_function(const std::pair<const std::string, boost::shared_ptr<Proxy_Function> > &f, const Dispatch_Engine &e)
-  {
-    std::vector<Type_Info> params = f.second->get_param_types();
-    std::string annotation = f.second->annotation();
-
-    if (annotation.size() > 0) {
-        std::cout << annotation;
-    }
-    dump_type(params.front(), e);
-    std::cout << " " << f.first << "(";
-
-    for (std::vector<Type_Info>::const_iterator itr = params.begin() + 1;
-         itr != params.end();
-         )
-    {
-      dump_type(*itr, e);
-      ++itr;
-
-      if (itr != params.end())
-      {
-        std::cout << ", ";
-      }
-    }
-
-    std::cout << ") " << std::endl;
-  }
-
-  /**
-   * Dump all system info to stdout
-   */
-  void dump_system(const Dispatch_Engine &s)
-  {
-    std::cout << "Registered Types: " << std::endl;
-    std::vector<std::pair<std::string, Type_Info> > types = s.get_types();
-    for (std::vector<std::pair<std::string, Type_Info> >::const_iterator itr = types.begin();
-         itr != types.end();
-         ++itr)
-    {
-      std::cout << itr->first << ": ";
-      std::cout << itr->second.m_bare_type_info->name();
-      std::cout << std::endl;
-    }
-
-    std::cout << std::endl;  
-    std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > funcs = s.get_functions();
-
-    std::cout << "Functions: " << std::endl;
-    for (std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > >::const_iterator itr = funcs.begin();
-         itr != funcs.end();
-         ++itr)
-    {
-      dump_function(*itr, s);
-    }
-    std::cout << std::endl;
-  }
 }
 
 #endif

include/chaiscript/dispatchkit/dynamic_object.hpp

@@ -0,0 +1,226 @@
+#ifndef __DYNAMIC_OBJECT_HPP__
+#define __DYNAMIC_OBJECT_HPP__
+
+#include <boost/optional.hpp>
+
+namespace chaiscript
+{
+  class Dynamic_Object
+  {
+    public:
+      Dynamic_Object(const std::string &t_type_name)
+        : m_type_name(t_type_name)
+      {
+      }
+
+      std::string get_type_name() const
+      {
+        return m_type_name;
+      }
+
+      Boxed_Value get_attr(const std::string &t_attr_name)
+      {
+        return m_attrs[t_attr_name];
+      }
+
+      std::map<std::string, Boxed_Value> get_attrs()
+      {
+        return m_attrs;
+      }
+
+    private:
+      std::string m_type_name;
+
+      std::map<std::string, Boxed_Value> m_attrs;
+  };
+
+  struct Dynamic_Object_Attribute
+  {
+    static Boxed_Value func(const std::string &t_type_name, const std::string &t_attr_name,
+        Dynamic_Object &t_do)
+    {
+      if (t_do.get_type_name() != t_type_name) 
+      {
+        throw bad_boxed_cast("Dynamic object type mismatch");
+      }
+
+      return t_do.get_attr(t_attr_name);
+    }
+  };
+
+  /**
+   * A Proxy_Function implementation designed for calling a function
+   * that is automatically guarded based on the first param based on the
+   * param's type name
+   */
+  class Dynamic_Object_Function : public Proxy_Function_Base
+  {
+    public:
+      Dynamic_Object_Function(
+          const std::string &t_type_name,
+          const Proxy_Function &t_func,
+          const boost::optional<Type_Info> &t_ti = boost::optional<Type_Info>())
+        : Proxy_Function_Base(t_func->get_param_types()),
+          m_type_name(t_type_name), m_func(t_func), m_ti(t_ti)
+      {
+        assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
+            && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+      }
+
+      virtual ~Dynamic_Object_Function() {}
+
+      virtual bool operator==(const Proxy_Function_Base &f) const
+      {
+        try
+        {
+          const Dynamic_Object_Function &df = dynamic_cast<const Dynamic_Object_Function &>(f);
+          return df.m_type_name == m_type_name && (*df.m_func) == (*m_func);
+        } catch (const std::bad_cast &) {
+          return false;
+        }
+      }
+
+      virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+      {
+        if (dynamic_object_typename_match(vals, m_type_name, m_ti))
+        {
+          return m_func->call_match(vals);
+        } else {
+          return false;
+        }
+      }    
+
+      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
+      {
+        if (dynamic_object_typename_match(params, m_type_name, m_ti))
+        {
+          return (*m_func)(params);
+        } else {
+          throw guard_error();
+        } 
+      }
+
+      virtual int get_arity() const
+      {
+	return m_func->get_arity();
+      }
+
+      virtual std::string annotation() const
+      {
+        return m_func->annotation();
+      }
+
+    private:
+      static bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
+          const boost::optional<Type_Info> &ti) 
+      {
+        if (bvs.size() > 0)
+        {
+          try {
+            const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bvs[0]);
+            return name == "Dynamic_Object" || d.get_type_name() == name;
+          } catch (const std::bad_cast &) {
+            if (ti)
+            {
+              return bvs[0].get_type_info().bare_equal(*ti);
+            } else {
+              return false;
+            }
+          }
+        } else {
+          return false;
+        }
+      }
+
+      std::string m_type_name;
+      Proxy_Function m_func;
+      boost::optional<Type_Info> m_ti;
+
+  };
+
+
+  /**
+   * A Proxy_Function implementation designed for creating a new
+   * Dynamic_Object
+   * that is automatically guarded based on the first param based on the
+   * param's type name
+   */
+  class Dynamic_Object_Constructor : public Proxy_Function_Base
+  {
+    public:
+      Dynamic_Object_Constructor(
+          const std::string &t_type_name,
+          const Proxy_Function &t_func)
+        : Proxy_Function_Base(build_type_list(t_func->get_param_types())),
+          m_type_name(t_type_name), m_func(t_func)
+      {
+        assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
+            && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+      }
+
+      static std::vector<Type_Info> build_type_list(const std::vector<Type_Info> &tl)
+      {
+        std::vector<Type_Info>::const_iterator begin = tl.begin();
+        std::vector<Type_Info>::const_iterator end = tl.end();
+
+        if (begin != end)
+        {
+          ++begin;
+        }
+
+        return std::vector<Type_Info>(begin, end);
+      }
+
+      virtual ~Dynamic_Object_Constructor() {}
+
+      virtual bool operator==(const Proxy_Function_Base &f) const
+      {
+        try
+        {
+          const Dynamic_Object_Constructor &dc = dynamic_cast<const Dynamic_Object_Constructor&>(f);
+          return dc.m_type_name == m_type_name && (*dc.m_func) == (*m_func);
+        } catch (const std::bad_cast &) {
+          return false;
+        }
+      }
+
+      virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+      {
+        std::vector<Boxed_Value> new_vals;
+        new_vals.push_back(Boxed_Value(Dynamic_Object(m_type_name)));
+        new_vals.insert(new_vals.end(), vals.begin(), vals.end());
+
+        return m_func->call_match(new_vals);
+      }    
+
+      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
+      {
+        std::vector<Boxed_Value> new_params;
+        chaiscript::Boxed_Value bv = var(Dynamic_Object(m_type_name));
+        new_params.push_back(bv);
+        new_params.insert(new_params.end(), params.begin(), params.end());
+
+        (*m_func)(new_params);
+
+        return bv;
+      }
+
+      virtual int get_arity() const
+      {
+        // "this" is not considered part of the arity
+	return m_func->get_arity() - 1; 
+      }
+
+      virtual std::string annotation() const
+      {
+        return m_func->annotation();
+      }
+
+    private:
+      std::string m_type_name;
+      Proxy_Function m_func;
+
+  };
+}
+#endif
+

include/chaiscript/dispatchkit/function_call.hpp

@@ -4,13 +4,6 @@
 // and Jason Turner (lefticus@gmail.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
-
-#define addparam(z,n,text)  params.push_back(Boxed_Value(BOOST_PP_CAT(p, n) ));
-#define curry(z,n,text)  BOOST_PP_CAT(_, BOOST_PP_INC(n))
-
-
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef __function_call_hpp__
 #define __function_call_hpp__
 
@@ -20,52 +13,9 @@
 #include <string>
 #include <vector>
 #include "proxy_functions.hpp"
+#include "function_call_detail.hpp"
 
-namespace dispatchkit
-{
-  /**
-   * Internal helper class for handling the return
-   * value of a build_function_caller
-   */
-  template<typename Ret>
-    class Function_Caller_Ret
-    {
-      public:
-        Function_Caller_Ret()
-        {
-        }
-
-        Ret call(const std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > &t_funcs, 
-                 const std::vector<Boxed_Value> &params)
-        {
-          return boxed_cast<Ret>(dispatch(t_funcs, params));
-        }
-    };
-
-  /**
-   * Specialization for void return types
-   */
-  template<>
-    class Function_Caller_Ret<void>
-    {
-      public:
-        Function_Caller_Ret()
-        {
-        }
-
-        void call(const std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > &t_funcs, 
-                  const std::vector<Boxed_Value> &params)
-        {
-          dispatch(t_funcs, params);
-        }
-    };
-}
-
-#define BOOST_PP_ITERATION_LIMITS ( 0, 9 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/function_call.hpp>
-#include BOOST_PP_ITERATE()
-
-namespace dispatchkit
+namespace chaiscript
 {
   /**
    * Build a function caller that knows how to dispatch on a set of functions
@@ -77,10 +27,10 @@ namespace dispatchkit
    */
   template<typename FunctionType>
     boost::function<FunctionType>
-      build_function_caller(const std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > &funcs)
+      functor(const std::vector<std::pair<std::string, Proxy_Function > > &funcs)
       {
-        FunctionType *p;
-        return build_function_caller_helper(p, funcs);
+        FunctionType *p=0;
+        return detail::build_function_caller_helper(p, funcs);
       }
 
   /**
@@ -88,7 +38,7 @@ namespace dispatchkit
    * useful in the case that a function is being pass out from scripting back
    * into code
    * example: 
-   * void my_function(boost::shared_ptr<Proxy_Function> f)
+   * void my_function(Proxy_Function f)
    * {
    *   boost::function<void (int)> local_f = 
    *      build_function_caller(f);
@@ -98,11 +48,11 @@ namespace dispatchkit
    */
   template<typename FunctionType>
     boost::function<FunctionType>
-      build_function_caller(boost::shared_ptr<Proxy_Function> func)
+      functor(Proxy_Function func)
       {
-        std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > funcs;
+        std::vector<std::pair<std::string, Proxy_Function > > funcs;
         funcs.push_back(std::make_pair(std::string(), func));
-        return build_function_caller<FunctionType>(funcs);
+        return functor<FunctionType>(funcs);
       }
 
   /**
@@ -111,58 +61,11 @@ namespace dispatchkit
    */
   template<typename FunctionType>
     boost::function<FunctionType>
-      build_function_caller(const Boxed_Value &bv)
+      functor(const Boxed_Value &bv)
       {
-        return build_function_caller<FunctionType>(boxed_cast<boost::shared_ptr<Proxy_Function> >(bv));
+        return functor<FunctionType>(boxed_cast<Proxy_Function >(bv));
       }
 
-  /**
-   * Helper for calling script code as if it were native C++ code
-   * example:
-   * boost::function<int (int, int)> f = build_functor(chai, "func(x, y){x+y}");
-   * \return a boost::function representing the passed in script
-   * \param[in] e ScriptEngine to build the script execution from
-   * \param[in] script Script code to build a function from
-   */
-  template<typename FunctionType, typename ScriptEngine>
-    boost::function<FunctionType> build_functor(ScriptEngine &e, const std::string &script)
-    {
-      return build_function_caller<FunctionType>(e.evaluate_string(script));
-    }
-}
-
-# endif
-#else
-# define n BOOST_PP_ITERATION()
-
-namespace dispatchkit
-{
-  /**
-   * used internally for unwrapping a function call's types
-   */
-  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-    Ret function_caller(const std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > &funcs 
-        BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
-    {
-      std::vector<Boxed_Value> params;
-
-      BOOST_PP_REPEAT(n, addparam, ~)
-
-      return Function_Caller_Ret<Ret>().call(funcs, params);
-    }
-
-  /**
-   * used internally for unwrapping a function call's types
-   */
-  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-    boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param)) > 
-      build_function_caller_helper(Ret (BOOST_PP_ENUM_PARAMS(n, Param)), const std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > &funcs)
-      {
-        return boost::bind(&function_caller<Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>, funcs
-            BOOST_PP_ENUM_TRAILING(n, curry, ~));
-      }
-
-
 }
 
 #endif

include/chaiscript/dispatchkit/function_call_detail.hpp

@@ -0,0 +1,98 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#include <boost/preprocessor.hpp>
+
+#define addparam(z,n,text)  params.push_back(boost::is_reference<Param ## n>::value?Boxed_Value(boost::ref(BOOST_PP_CAT(p, n))):Boxed_Value(BOOST_PP_CAT(p, n) ));
+#define curry(z,n,text)  BOOST_PP_CAT(_, BOOST_PP_INC(n))
+
+
+#ifndef  BOOST_PP_IS_ITERATING
+#ifndef __function_call_detail_hpp__
+#define __function_call_detail_hpp__
+
+#include <boost/shared_ptr.hpp>
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+#include <string>
+#include <vector>
+#include "proxy_functions.hpp"
+
+namespace chaiscript
+{
+  namespace detail
+  {
+    /**
+     * Internal helper class for handling the return
+     * value of a build_function_caller
+     */
+    template<typename Ret>
+      struct Function_Caller_Ret
+      {
+        static Ret call(const std::vector<std::pair<std::string, Proxy_Function > > &t_funcs, 
+            const std::vector<Boxed_Value> &params)
+        {
+          return boxed_cast<Ret>(dispatch(t_funcs, params));
+        }
+      };
+
+    /**
+     * Specialization for void return types
+     */
+    template<>
+      struct Function_Caller_Ret<void>
+      {
+        static void call(const std::vector<std::pair<std::string, Proxy_Function > > &t_funcs, 
+            const std::vector<Boxed_Value> &params)
+        {
+          dispatch(t_funcs, params);
+        }
+      };
+  }
+}
+
+#define BOOST_PP_ITERATION_LIMITS ( 0, 9 )
+#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/function_call_detail.hpp>
+#include BOOST_PP_ITERATE()
+
+# endif
+#else
+# define n BOOST_PP_ITERATION()
+
+namespace chaiscript
+{
+  namespace detail
+  {
+    /**
+     * used internally for unwrapping a function call's types
+     */
+    template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
+      Ret function_caller(const std::vector<std::pair<std::string, Proxy_Function > > &funcs 
+          BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
+      {
+        std::vector<Boxed_Value> params;
+
+        BOOST_PP_REPEAT(n, addparam, ~)
+
+          return Function_Caller_Ret<Ret>::call(funcs, params);
+      }
+
+    /**
+     * used internally for unwrapping a function call's types
+     */
+    template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
+      boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param)) > 
+      build_function_caller_helper(Ret (BOOST_PP_ENUM_PARAMS(n, Param)), const std::vector<std::pair<std::string, Proxy_Function> > &funcs)
+      {
+        return boost::bind(&function_caller<Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>, funcs
+            BOOST_PP_ENUM_TRAILING(n, curry, ~));
+      }
+
+  }
+}
+
+#endif
+

include/chaiscript/dispatchkit/handle_return.hpp

@@ -0,0 +1,99 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#ifndef __handle_return_hpp__
+#define __handle_return_hpp__
+
+#include "boxed_value.hpp"
+#include "type_info.hpp"
+#include <string>
+#include <boost/function.hpp>
+
+#include <stdexcept>
+#include <vector>
+
+namespace chaiscript
+{
+  /**
+   * Used internally for handling a return value from a Proxy_Function call
+   */
+  template<typename Ret>
+    struct Handle_Return
+    {
+      static Boxed_Value handle(const Ret &r)
+      {
+        return Boxed_Value(r);
+      }
+    };
+
+  template<typename Ret>
+    struct Handle_Return<boost::shared_ptr<Ret> &>
+    {
+      static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+      {
+        return Boxed_Value(r);
+      }
+    };
+
+  template<typename Ret>
+    struct Handle_Return<const boost::shared_ptr<Ret> &>
+    {
+      static Boxed_Value handle(const boost::shared_ptr<Ret> &r)
+      {
+        return Boxed_Value(r);
+      }
+    };
+
+  /**
+   * Used internally for handling a return value from a Proxy_Function call
+   */
+  template<typename Ret>
+    struct Handle_Return<Ret &>
+    {
+      static Boxed_Value handle(Ret &r)
+      {
+        return Boxed_Value(boost::ref(r));
+      }
+    };
+
+  /**
+   * Used internally for handling a return value from a Proxy_Function call
+   */
+  template<>
+    struct Handle_Return<Boxed_Value>
+    {
+      static Boxed_Value handle(const Boxed_Value &r)
+      {
+        return r;
+      }
+    };
+
+  /**
+   * Used internally for handling a return value from a Proxy_Function call
+   */
+  template<>
+    struct Handle_Return<Boxed_Value &>
+    {
+      static Boxed_Value handle(const Boxed_Value &r)
+      {
+        return r;
+      }
+    };
+
+  /**
+   * Used internally for handling a return value from a Proxy_Function call
+   */
+  template<>
+    struct Handle_Return<void>
+    {
+      static Boxed_Value handle()
+      {
+        return Boxed_Value(Boxed_Value::Void_Type());
+      }
+    };
+}
+
+#endif

include/chaiscript/dispatchkit/proxy_constructors.hpp

@@ -19,33 +19,47 @@
 #define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/proxy_constructors.hpp>
 #include BOOST_PP_ITERATE()
 # endif
+
+namespace chaiscript
+{
+  template<typename T>
+    Proxy_Function constructor()
+    {
+      T *f = 0;
+      return (detail::build_constructor_(f));
+    }
+}
+
 #else
 # define n BOOST_PP_ITERATION()
 
-namespace dispatchkit
+namespace chaiscript
 {
-  /**
-   * A constructor function, used for creating a new object
-   * of a given type with a given set of params
-   */
-  template<typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-    boost::shared_ptr<Class> constructor( BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
-    {
-      return boost::shared_ptr<Class>(new Class( BOOST_PP_ENUM_PARAMS(n, p) ));
-    }
+  namespace detail
+  {
+    /**
+     * A constructor function, used for creating a new object
+     * of a given type with a given set of params
+     */
+    template<typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
+      boost::shared_ptr<Class> constructor_( BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
+      {
+        return boost::shared_ptr<Class>(new Class( BOOST_PP_ENUM_PARAMS(n, p) ));
+      }
 
-  /**
-   * Helper function for build a constructor function
-   * example:
-   * dispatchengine.register_function(build_constructor<MyClass, int, const std::string&>, "MyClass");
-   * \todo See if it is possible to make this not be a variadic function
-   */
-  template<typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-    boost::function<boost::shared_ptr<Class> (BOOST_PP_ENUM_PARAMS(n, Param))> build_constructor()
-    {
-      typedef boost::shared_ptr<Class> (*func)(BOOST_PP_ENUM_PARAMS(n, Param));
-      return boost::function<boost::shared_ptr<Class> (BOOST_PP_ENUM_PARAMS(n, Param))>(func(&(constructor<Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>)));
-    }
+    /**
+     * Helper function for build a constructor function
+     * example:
+     * dispatchengine.register_function(build_constructor<MyClass, int, const std::string&>, "MyClass");
+     * \todo See if it is possible to make this not be a variadic function
+     */
+    template<typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
+      Proxy_Function build_constructor_(Class (*)(BOOST_PP_ENUM_PARAMS(n, Param)))
+      {
+        typedef boost::shared_ptr<Class> (sig)(BOOST_PP_ENUM_PARAMS(n, Param));
+        return Proxy_Function(new Proxy_Function_Impl<sig>(boost::function<sig>(&(constructor_<Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>))));
+      }
+  }
 }
 
 #endif

include/chaiscript/dispatchkit/proxy_functions.hpp

@@ -4,98 +4,28 @@
 // and Jason Turner (lefticus@gmail.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
 
-#define gettypeinfo(z,n,text)  ti.push_back(Get_Type_Info<Param ## n>::get());
-#define casthelper(z,n,text) ,dispatchkit::boxed_cast< Param ## n >(params[n])
-#define comparetype(z,n,text)  && ((Get_Type_Info<Param ## n>::get() == params[n].get_type_info()))
-#define trycast(z,n,text) dispatchkit::boxed_cast<Param ## n>(params[n]);
-
-
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef __proxy_functions_hpp__
 #define __proxy_functions_hpp__
 
+
 #include "boxed_value.hpp"
 #include "type_info.hpp"
 #include <string>
 #include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <stdexcept>
 #include <vector>
+#include "proxy_functions_detail.hpp"
 
-namespace dispatchkit
+namespace chaiscript
 {
-  /**
-   * Used internally for handling a return value from a Proxy_Function call
-   */
-  template<typename Ret>
-    struct Handle_Return
-    {
-      Boxed_Value operator()(const boost::function<Ret ()> &f)
-      {
-        return Boxed_Value(f());
-      }
-    };
-
-  /**
-   * Used internally for handling a return value from a Proxy_Function call
-   */
-  template<typename Ret>
-    struct Handle_Return<Ret &>
-    {
-      Boxed_Value operator()(const boost::function<Ret &()> &f)
-      {
-        return Boxed_Value(boost::ref(f()));
-      }
-    };
-
-  /**
-   * Used internally for handling a return value from a Proxy_Function call
-   */
-  template<>
-    struct Handle_Return<Boxed_Value>
-    {
-      Boxed_Value operator()(const boost::function<Boxed_Value ()> &f)
-      {
-        return f();
-      }
-    };
-
-  /**
-   * Used internally for handling a return value from a Proxy_Function call
-   */
-  template<>
-    struct Handle_Return<Boxed_Value &>
-    {
-      Boxed_Value operator()(const boost::function<Boxed_Value &()> &f)
-      {
-        return f();
-      }
-    };
-
-  /**
-   * Used internally for handling a return value from a Proxy_Function call
-   */
-  template<>
-    struct Handle_Return<void>
-    {
-      Boxed_Value operator()(const boost::function<void ()> &f)
-      {
-        f();
-        return Boxed_Value(Boxed_Value::Void_Type());
-      }
-    };
-
   /**
    * Helper for building a list of parameters for calling a Proxy_Function
    * it does automatic conversion to Boxed_Value types via operator<<
    *
    * example usage:
    * Boxed_Value retval = dispatch(dispatchengine.get_function("+"), 
-   *                               dispatchkit::Param_List_Builder() << 5 << 6);
+   *                               chaiscript::Param_List_Builder() << 5 << 6);
    */
   struct Param_List_Builder
   {
@@ -120,30 +50,6 @@ namespace dispatchkit
     std::vector<Boxed_Value> objects;
   };
 
-  /**
-   * Exception thrown when there is a mismatch in number of
-   * parameters during Proxy_Function execution
-   */
-  struct arity_error : std::range_error
-  {
-    arity_error(int t_got, int t_expected)
-      : std::range_error("Function dispatch arity mismatch"),
-        got(t_got), expected(t_expected)
-    {
-    }
-
-    virtual ~arity_error() throw() {}
-    int got;
-    int expected;
-  };
-}
-
-#define BOOST_PP_ITERATION_LIMITS ( 0, 10 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/proxy_functions.hpp>
-#include BOOST_PP_ITERATE()
-
-namespace dispatchkit
-{
   /**
    * Pure virtual base class for all Proxy_Function implementations
    * Proxy_Functions are a type erasure of type safe C++
@@ -152,17 +58,89 @@ namespace dispatchkit
    * Dispatch_Engine only knows how to work with Proxy_Function, no other
    * function classes.
    */
-  class Proxy_Function
+  class Proxy_Function_Base
   {
     public:
-      virtual ~Proxy_Function() {}
-      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) = 0;
-      virtual std::vector<Type_Info> get_param_types() const = 0;
-      virtual bool operator==(const Proxy_Function &) const = 0;
-      virtual bool types_match(const std::vector<Boxed_Value> &types) const = 0;
+      virtual ~Proxy_Function_Base() {}
+      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const = 0;
+
+      std::vector<Type_Info> get_param_types() const { return m_types; }
+
+      virtual bool operator==(const Proxy_Function_Base &) const = 0;
+      virtual bool call_match(const std::vector<Boxed_Value> &vals) const = 0;
+
+      //! Return true if the function is a possible match
+      //! to the passed in values
+      bool filter(const std::vector<Boxed_Value> &vals) const
+      {
+        int arity = get_arity();
+
+        if (arity < 0)
+        {
+          return true;
+        } else if (size_t(arity) == vals.size()) {
+          if (arity == 0)
+          {
+            return true;
+          } else {
+            const std::vector<Type_Info> &types = get_param_types();
+
+            if (types.size() < 2)
+            {
+              return true;
+            }
+
+            const Type_Info &ti = types[1];
+
+            if (ti.is_unknown() || vals[0].get_type_info().is_unknown()
+                || ti.bare_equal(user_type<Boxed_Value>())
+                || ti.bare_equal(user_type<Boxed_POD_Value>())
+                || ti.bare_equal(vals[0].get_type_info()))
+            {
+              return true;
+            } else {
+              return false;
+            }
+          }
+        } else {
+          return false;
+        }
+      }
+
+      virtual int get_arity() const = 0;
+
       virtual std::string annotation() const = 0;
+
+    protected:
+      Proxy_Function_Base(const std::vector<Type_Info> &t_types)
+        : m_types(t_types)
+      {
+      }
+
+      bool compare_types(const std::vector<Type_Info> &tis, const std::vector<Boxed_Value> &bvs) const
+      {
+        if (tis.size() - 1 != bvs.size())
+        {
+          return false;
+        } else {
+          const int size = bvs.size();
+          for (int i = 0; i < size; ++i)
+          {
+            if (!(tis[i+1].bare_equal(bvs[i].get_type_info()) && tis[i+1].is_const() >= bvs[i].get_type_info().is_const() ))
+            {
+              return false;
+            }
+          }
+        }
+        return true;
+      }
+
+      std::vector<Type_Info> m_types;
   };
 
+  typedef boost::shared_ptr<Proxy_Function_Base> Proxy_Function;
+  typedef boost::shared_ptr<const Proxy_Function_Base> Const_Proxy_Function;
+
   /**
    * Exception thrown if a function's guard fails to execute
    */
@@ -181,32 +159,33 @@ namespace dispatchkit
    * A Proxy_Function implementation that is not type safe, the called function
    * is expecting a vector<Boxed_Value> that it works with how it chooses.
    */
-  class Dynamic_Proxy_Function : public Proxy_Function
+  class Dynamic_Proxy_Function : public Proxy_Function_Base
   {
     public:
       Dynamic_Proxy_Function(
           const boost::function<Boxed_Value (const std::vector<Boxed_Value> &)> &t_f, 
           int t_arity=-1,
           const std::string &t_description = "",
-          const boost::shared_ptr<Proxy_Function> &t_guard = boost::shared_ptr<Proxy_Function>())
-        : m_f(t_f), m_arity(t_arity), m_description(t_description), m_guard(t_guard)
+          const Proxy_Function &t_guard = Proxy_Function())
+        : Proxy_Function_Base(build_param_type_list(t_arity)),
+          m_f(t_f), m_arity(t_arity), m_description(t_description), m_guard(t_guard)
       {
       }
 
-      virtual bool operator==(const Proxy_Function &) const
+      virtual bool operator==(const Proxy_Function_Base &) const
       {
         return false;
       }
 
-      virtual bool types_match(const std::vector<Boxed_Value> &types) const
+      virtual bool call_match(const std::vector<Boxed_Value> &vals) const
       {
-          return (m_arity < 0 || types.size() == size_t(m_arity))
-            && test_guard(types);
+          return (m_arity < 0 || vals.size() == size_t(m_arity))
+            && test_guard(vals);
       }    
 
       virtual ~Dynamic_Proxy_Function() {}
 
-      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params)
+      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
       {
         if (m_arity < 0 || params.size() == size_t(m_arity))
         {
@@ -223,23 +202,9 @@ namespace dispatchkit
         } 
       }
 
-      virtual std::vector<Type_Info> get_param_types() const
+      virtual int get_arity() const
       {
-        std::vector<Type_Info> types;
-
-        types.push_back(Get_Type_Info<Boxed_Value>::get());
-
-        if (m_arity >= 0)
-        {
-          for (int i = 0; i < m_arity; ++i)
-          {
-            types.push_back(Get_Type_Info<Boxed_Value>::get());
-          }
-        } else {
-          types.push_back(Get_Type_Info<std::vector<Boxed_Value> >::get());
-        }
-
-        return types;
+	return m_arity;
       }
 
       virtual std::string annotation() const
@@ -264,10 +229,29 @@ namespace dispatchkit
         }
       }
 
+      static std::vector<Type_Info> build_param_type_list(int arity)
+      {
+        std::vector<Type_Info> types;
+
+        types.push_back(detail::Get_Type_Info<Boxed_Value>::get());
+
+        if (arity >= 0)
+        {
+          for (int i = 0; i < arity; ++i)
+          {
+            types.push_back(detail::Get_Type_Info<Boxed_Value>::get());
+          }
+        } else {
+          types.push_back(detail::Get_Type_Info<std::vector<Boxed_Value> >::get());
+        }
+
+        return types;
+      }
+
       boost::function<Boxed_Value (const std::vector<Boxed_Value> &)> m_f;
       int m_arity;
       std::string m_description;
-      boost::shared_ptr<Proxy_Function> m_guard;
+      Proxy_Function m_guard;
   };
 
   /**
@@ -284,29 +268,29 @@ namespace dispatchkit
    * at runtime, when call() is executed.
    * it is used for bind(function, param1, _, param2) style calls
    */
-  class Bound_Function : public Proxy_Function
+  class Bound_Function : public Proxy_Function_Base
   {
     public:
-      Bound_Function(const boost::shared_ptr<Proxy_Function> &t_f, 
+      Bound_Function(const Const_Proxy_Function &t_f, 
                      const std::vector<Boxed_Value> &t_args)
-        : m_f(t_f), m_args(t_args)
+        : Proxy_Function_Base(std::vector<Type_Info>()),
+          m_f(t_f), m_args(t_args), m_arity(m_f->get_arity()<0?-1:(m_f->get_arity() - m_args.size()))
       {
       }
 
-      virtual bool operator==(const Proxy_Function &) const
+      virtual bool operator==(const Proxy_Function_Base &) const
       {
         return false;
       }
 
       virtual ~Bound_Function() {}
 
-      virtual bool types_match(const std::vector<Boxed_Value> &types) const
+      virtual bool call_match(const std::vector<Boxed_Value> &vals) const
       {
-        std::vector<Boxed_Value> params = build_param_list(types);
-        return m_f->types_match(params);
+        return m_f->call_match(build_param_list(vals));
       }
 
-      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params)
+      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
       {
         return (*m_f)(build_param_list(params));
       }
@@ -323,7 +307,7 @@ namespace dispatchkit
         while (true)
         {
           while (barg != m_args.end() 
-                 && !(barg->get_type_info() == Get_Type_Info<Placeholder_Object>::get()))
+                 && !(barg->get_type_info() == detail::Get_Type_Info<Placeholder_Object>::get()))
           {
             args.push_back(*barg);
             ++barg;
@@ -336,7 +320,7 @@ namespace dispatchkit
           }
 
           if (barg != m_args.end() 
-              && barg->get_type_info() == Get_Type_Info<Placeholder_Object>::get())
+              && barg->get_type_info() == detail::Get_Type_Info<Placeholder_Object>::get())
           {
             ++barg;
           } 
@@ -349,9 +333,9 @@ namespace dispatchkit
         return args;
       }
 
-      virtual std::vector<Type_Info> get_param_types() const
+      virtual int get_arity() const
       {
-        return std::vector<Type_Info>();
+        return m_arity;
       }
 
       virtual std::string annotation() const
@@ -360,8 +344,9 @@ namespace dispatchkit
       }
 
     private:
-      boost::shared_ptr<Proxy_Function> m_f;
+      Const_Proxy_Function m_f;
       std::vector<Boxed_Value> m_args;
+      int m_arity;
   };
 
   /**
@@ -370,17 +355,18 @@ namespace dispatchkit
    * type checking of Boxed_Value parameters, in a type safe manner
    */
   template<typename Func>
-    class Proxy_Function_Impl : public Proxy_Function
+    class Proxy_Function_Impl : public Proxy_Function_Base
   {
     public:
-      Proxy_Function_Impl(const Func &f)
-        : m_f(f)
+      Proxy_Function_Impl(const boost::function<Func> &f)
+        : Proxy_Function_Base(build_param_type_list(static_cast<Func *>(0))),
+          m_f(f), m_dummy_func(0)
       {
       }
 
       virtual ~Proxy_Function_Impl() {}
 
-      virtual bool operator==(const Proxy_Function &t_func) const
+      virtual bool operator==(const Proxy_Function_Base &t_func) const
       {
         try {
           dynamic_cast<const Proxy_Function_Impl<Func> &>(t_func);
@@ -390,19 +376,25 @@ namespace dispatchkit
         }
       }
  
-      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params)
+      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
       {
-        return call_func(m_f, params);
+        return Do_Call<typename boost::function<Func>::result_type>::go(m_f, params);
       }
 
-      virtual std::vector<Type_Info> get_param_types() const
+      virtual int get_arity() const
       {
-        return build_param_type_list(m_f);
+        return m_types.size() - 1;
       }
 
-      virtual bool types_match(const std::vector<Boxed_Value> &types) const
+
+      virtual bool call_match(const std::vector<Boxed_Value> &vals) const
       {
-        return compare_types(m_f, types);
+        if (int(vals.size()) != get_arity()) 
+        {
+          return false;
+        }
+
+        return compare_types(m_types, vals) || compare_types_cast(m_dummy_func, vals);
       }
 
       virtual std::string annotation() const
@@ -411,7 +403,8 @@ namespace dispatchkit
       }
 
     private:
-      Func m_f;
+      boost::function<Func> m_f;
+      Func *m_dummy_func;
   };
 
   /**
@@ -435,15 +428,17 @@ namespace dispatchkit
    * each function against the set of parameters, in order, until a matching
    * function is found or throw dispatch_error if no matching function is found
    */
-  Boxed_Value dispatch(const std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > &funcs,
+  template<typename InItr>
+  Boxed_Value dispatch(InItr begin, InItr end,
       const std::vector<Boxed_Value> &plist)
   {
-    for (std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > >::const_iterator itr = funcs.begin();
-        itr != funcs.end();
-        ++itr)
+    while (begin != end)
     {
       try {
-        return (*itr->second)(plist);
+        if (begin->second->filter(plist))
+        {
+          return (*begin->second)(plist);
+        }
       } catch (const bad_boxed_cast &) {
         //parameter failed to cast, try again
       } catch (const arity_error &) {
@@ -452,75 +447,24 @@ namespace dispatchkit
         //guard failed to allow the function to execute,
         //try again
       }
+      ++begin;
     }
+
     throw dispatch_error();
   }
+
+  /**
+   * Take a vector of functions and a vector of parameters. Attempt to execute
+   * each function against the set of parameters, in order, until a matching
+   * function is found or throw dispatch_error if no matching function is found
+   */
+  template<typename Funcs>
+  Boxed_Value dispatch(const Funcs &funcs,
+      const std::vector<Boxed_Value> &plist)
+  {
+    return dispatch(funcs.begin(), funcs.end(), plist);
+  }
 }
 
-# endif
-#else
-# define n BOOST_PP_ITERATION()
-
-namespace dispatchkit
-{
-  /**
-   * Used by Proxy_Function_Impl to return a list of all param types
-   * it contains.
-   */
-  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-    std::vector<Type_Info> build_param_type_list(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &)
-    {
-      std::vector<Type_Info> ti;
-      ti.push_back(Get_Type_Info<Ret>::get());
-
-      BOOST_PP_REPEAT(n, gettypeinfo, ~)
-
-      return ti;
-    }
-
-  /**
-   * Used by Proxy_Function_Impl to perform typesafe execution of a function.
-   * The function attempts to unbox each paramter to the expected type.
-   * if any unboxing fails the execution of the function fails and
-   * the bad_boxed_cast is passed up to the caller.
-   */
-  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
-    Boxed_Value call_func(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f,
-        const std::vector<Boxed_Value> &params)
-    {
-      if (params.size() != n)
-      {
-        throw arity_error(params.size(), n);
-      } else {
-        return Handle_Return<Ret>()(boost::bind(f BOOST_PP_REPEAT(n, casthelper, ~)));
-      }
-    }
-
-  /**
-   * Used by Proxy_Function_Impl to determine if it is equivalent to another
-   * Proxy_Function_Impl object. This function is primarly used to prevent
-   * registration of two functions with the exact same signatures
-   */
-  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
-    bool compare_types(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &,
-        const std::vector<Boxed_Value> &params)
-    {
-      if (params.size() != n)
-      {
-        return false;
-      } else {
-        bool val = true BOOST_PP_REPEAT(n, comparetype, ~);
-        if (val) return true;
-
-        try {
-          BOOST_PP_REPEAT(n, trycast, ~);
-        } catch (const bad_boxed_cast &) {
-          return false;
-        }
-
-        return true;
-      }
-    }
-}
 
 #endif

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

@@ -0,0 +1,133 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#include <boost/preprocessor.hpp>
+
+#define gettypeinfo(z,n,text)  ti.push_back(detail::Get_Type_Info<Param ## n>::get());
+#define casthelper(z,n,text) BOOST_PP_COMMA_IF(n) chaiscript::boxed_cast< Param ## n >(params[n])
+#define trycast(z,n,text) chaiscript::boxed_cast<Param ## n>(params[n]);
+
+#ifndef  BOOST_PP_IS_ITERATING
+#ifndef __proxy_functions_detail_hpp__
+#define __proxy_functions_detail_hpp__
+
+#include "boxed_value.hpp"
+#include "type_info.hpp"
+#include "handle_return.hpp"
+#include <string>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <boost/lexical_cast.hpp>
+
+#include <stdexcept>
+#include <vector>
+
+namespace chaiscript
+{
+  /**
+   * Exception thrown when there is a mismatch in number of
+   * parameters during Proxy_Function execution
+   */
+  struct arity_error : std::range_error
+  {
+    arity_error(int t_got, int t_expected)
+      : std::range_error("Function dispatch arity mismatch"),
+      got(t_got), expected(t_expected)
+    {
+    }
+
+    virtual ~arity_error() throw() {}
+    int got;
+    int expected;
+  };
+
+  template<typename Ret>
+    struct Do_Call
+    {
+      template<typename Fun>
+      static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
+      {
+        return Handle_Return<Ret>::handle(call_func(fun, params));
+      }
+    };
+
+  template<>
+    struct Do_Call<void>
+    {
+      template<typename Fun>
+      static Boxed_Value go(const boost::function<Fun> &fun, const std::vector<Boxed_Value> &params)
+      {
+        call_func(fun, params);
+        return Handle_Return<void>::handle();
+      };
+    };
+}
+
+#define BOOST_PP_ITERATION_LIMITS ( 0, 10 )
+#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/proxy_functions_detail.hpp>
+#include BOOST_PP_ITERATE()
+
+
+# endif
+#else
+# define n BOOST_PP_ITERATION()
+
+namespace chaiscript
+{
+  /**
+   * Used by Proxy_Function_Impl to return a list of all param types
+   * it contains.
+   */
+  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
+    std::vector<Type_Info> build_param_type_list(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)))
+    {
+      std::vector<Type_Info> ti;
+      ti.push_back(detail::Get_Type_Info<Ret>::get());
+
+      BOOST_PP_REPEAT(n, gettypeinfo, ~) 
+
+      return ti;
+    }
+
+  /**
+   * Used by Proxy_Function_Impl to perform typesafe execution of a function.
+   * The function attempts to unbox each paramter to the expected type.
+   * if any unboxing fails the execution of the function fails and
+   * the bad_boxed_cast is passed up to the caller.
+   */
+  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
+    Ret call_func(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f,
+        const std::vector<Boxed_Value> &params)
+    {
+      if (params.size() != n)
+      {
+        throw arity_error(params.size(), n);
+      } else {
+        return f(BOOST_PP_REPEAT(n, casthelper, ~));
+      }
+    }
+
+  /**
+   * Used by Proxy_Function_Impl to determine if it is equivalent to another
+   * Proxy_Function_Impl object. This function is primarly used to prevent
+   * registration of two functions with the exact same signatures
+   */
+  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
+    bool compare_types_cast(Ret (*)(BOOST_PP_ENUM_PARAMS(n, Param)),
+        const std::vector<Boxed_Value> & BOOST_PP_IF(n, params, ))
+    {
+      try {
+        BOOST_PP_REPEAT(n, trycast, ~);
+      } catch (const bad_boxed_cast &) {
+        return false;
+      }
+
+      return true;
+    }
+
+}
+
+#endif

include/chaiscript/dispatchkit/register_function.hpp

@@ -4,76 +4,87 @@
 // and Jason Turner (lefticus@gmail.com)
 // http://www.chaiscript.com
 
-#include <boost/preprocessor.hpp>
-
-#ifndef  BOOST_PP_IS_ITERATING
 #ifndef __register_function_hpp__
 #define __register_function_hpp__
 
 #include "dispatchkit.hpp"
+#include "bind_first.hpp"
 #include <boost/function.hpp>
 #include <boost/bind.hpp>
+#include <boost/function_types/components.hpp>
+#include <boost/function_types/function_type.hpp>
 
-namespace dispatchkit
+namespace chaiscript
 {
-  /**
-   * Helper function for register_member function
-   */
-  template<typename T, typename Class>
-    T &get_member(T Class::* m, Class *obj)
+  namespace detail
+  {
+    /**
+     * Helper function for register_member function
+     */
+    template<typename T, typename Class>
+      T &get_member(T Class::* m, Class *obj)
+      {
+        return (obj->*m);
+      }
+
+    template<typename T>
+    boost::function<T> mk_boost_fun(const boost::function<T> &f)
     {
-      return obj->*m;
+      return f;
     }
 
-  /**
-   * Automatically create a get_member helper function for an object 
-   * to allow for runtime dispatched access to public data members
-   * for example, the case of std::pair<>::first and std::pair<>::second
-   */
-  template<typename T, typename Class>
-    void register_member(Dispatch_Engine &s, T Class::* m, const std::string &name)
+    template<typename T>
+    boost::function< 
+             typename boost::function_types::function_type<boost::function_types::components<T> >::type 
+          >  mk_boost_fun(T t)
     {
-      s.register_function(boost::function<T (Class *)>(boost::bind(&get_member<T, Class>, m, _1)), name);
+      return 
+          boost::function< 
+             typename boost::function_types::function_type<boost::function_types::components<T> >::type 
+          >(t);
     }
+
+    template<typename T, typename Class>
+      Proxy_Function fun_helper(T Class::* m)
+      {
+        return fun_helper(boost::function<T& (Class *)>(boost::bind(&detail::get_member<T, Class>, m, _1)));
+      }
+
+
+    template<typename T>
+      Proxy_Function fun_helper(const boost::function<T> &f)
+      {
+        return Proxy_Function(new Proxy_Function_Impl<T>(f));
+      }
+  }
+
+  template<typename T>
+    Proxy_Function fun(const boost::function<T> &f)
+    {
+      return detail::fun_helper(f);
+    }
+
+  template<typename T>
+    Proxy_Function fun(T t)
+    {
+      return detail::fun_helper(detail::mk_boost_fun(t));
+    }
+
+
+  template<typename T, typename Q>
+    Proxy_Function fun(T t, const Q &q)
+    {
+      return detail::fun_helper(bind_first(t, q));
+    }
+
+  template<typename T, typename Q, typename R>
+    Proxy_Function fun(T t, const Q &q, const R &r)
+    {
+      return detail::fun_helper(bind_first(bind_first(t, q), r));
+    }
+   
 }
 
-#define BOOST_PP_ITERATION_LIMITS ( 0, 10 )
-#define BOOST_PP_FILENAME_1 <chaiscript/dispatchkit/register_function.hpp>
-#include BOOST_PP_ITERATE()
-
-# endif
-#else
-# define n BOOST_PP_ITERATION()
-
-namespace dispatchkit
-{
-  /**
-   * Register a global function of n parameters with name 
-   */
-  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
-    void register_function(Dispatch_Engine &s, Ret (*f)(BOOST_PP_ENUM_PARAMS(n, Param)), const std::string &name)
-    {
-      s.register_function(boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))>(f), name);
-    }
-
-  /**
-   * Register a class method of n parameters with name 
-   */
-  template<typename Ret, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
-    void register_function(Dispatch_Engine &s, Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param)), const std::string &name)
-    {
-      s.register_function(boost::function<Ret (Class* BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param))>(f), name);
-    }
-
-  /**
-   * Register a const class method of n parameters with name 
-   */
-  template<typename Ret, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
-    void register_function(Dispatch_Engine &s, Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param))const, const std::string &name)
-    {
-      s.register_function(boost::function<Ret (const Class* BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param))>(f), name);
-    }
-}
 
 #endif
 

include/chaiscript/dispatchkit/type_info.hpp

@@ -16,105 +16,165 @@
 #include <boost/type_traits/remove_pointer.hpp>
 #include <boost/ref.hpp>
 
-namespace dispatchkit
+namespace chaiscript
 {
   /**
    * compile time deduced information about a type
    */
-  struct Type_Info
+  class Type_Info
   {
-    Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
-        const std::type_info *t_ti, const std::type_info *t_bareti)
-      : m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
+    public:
+      Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
+          const std::type_info *t_ti, const std::type_info *t_bareti)
+        : m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
         m_is_void(t_is_void),
-      m_type_info(t_ti), m_bare_type_info(t_bareti),
-      m_is_unknown(false)
-    {
-    }
+        m_type_info(t_ti), m_bare_type_info(t_bareti),
+        m_is_unknown(false)
+      {
+      }
 
-    Type_Info()
-      : m_is_const(false), m_is_reference(false), m_is_pointer(false),
-      m_is_void(false), m_type_info(0), m_bare_type_info(0),
-      m_is_unknown(true)
-    {
-    }
+      Type_Info()
+        : m_is_const(false), m_is_reference(false), m_is_pointer(false),
+        m_is_void(false), m_type_info(0), m_bare_type_info(0),
+        m_is_unknown(true)
+      {
+      }
 
-    Type_Info(const Type_Info &ti)
-    : m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
-      m_is_pointer(ti.m_is_pointer),
-      m_is_void(ti.m_is_void), m_type_info(ti.m_type_info), 
-      m_bare_type_info(ti.m_bare_type_info),
-      m_is_unknown(ti.m_is_unknown)
-    {
-    }
-    Type_Info &operator=(const Type_Info &ti)
-    {
-      m_is_const = ti.m_is_const;
-      m_is_reference = ti.m_is_reference;
-      m_is_pointer = ti.m_is_pointer;
-      m_is_void = ti.m_is_void;
-      m_type_info = ti.m_type_info;
-      m_bare_type_info = ti.m_bare_type_info;
-      m_is_unknown = ti.m_is_unknown;
-      return *this;
-    }
-    bool operator<(const Type_Info &ti) const
-    {
-      return m_type_info < ti.m_type_info;
-    }
+      Type_Info(const Type_Info &ti)
+        : m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
+        m_is_pointer(ti.m_is_pointer),
+        m_is_void(ti.m_is_void), m_type_info(ti.m_type_info), 
+        m_bare_type_info(ti.m_bare_type_info),
+        m_is_unknown(ti.m_is_unknown)
+      {
+      }
 
-    bool operator==(const Type_Info &ti) const
-    {
-      return ti.m_type_info == m_type_info;
-    }
+      Type_Info &operator=(const Type_Info &ti)
+      {
+        m_is_const = ti.m_is_const;
+        m_is_reference = ti.m_is_reference;
+        m_is_pointer = ti.m_is_pointer;
+        m_is_void = ti.m_is_void;
+        m_type_info = ti.m_type_info;
+        m_bare_type_info = ti.m_bare_type_info;
+        m_is_unknown = ti.m_is_unknown;
+        return *this;
+      }
 
-    bool m_is_const;
-    bool m_is_reference;
-    bool m_is_pointer;
-    bool m_is_void;
-    const std::type_info *m_type_info;
-    const std::type_info *m_bare_type_info;
-    bool m_is_unknown;
+      bool operator<(const Type_Info &ti) const
+      {
+        return m_type_info < ti.m_type_info;
+      }
+
+      bool operator==(const Type_Info &ti) const
+      {
+        return ti.m_type_info == m_type_info 
+          || (ti.m_type_info && m_type_info && *ti.m_type_info == *m_type_info);
+      }
+
+      bool operator==(const std::type_info &ti) const
+      {
+        return m_type_info != 0 && (*m_type_info) == ti;
+      }
+
+      bool bare_equal(const Type_Info &ti) const
+      {
+        return ti.m_bare_type_info == m_bare_type_info 
+          || (ti.m_bare_type_info && m_bare_type_info && *ti.m_bare_type_info == *m_bare_type_info);
+      }
+
+      bool is_const() const { return m_is_const; }
+      bool is_reference() const { return m_is_reference; }
+      bool is_void() const { return m_is_void; }
+      bool is_unknown() const { return m_is_unknown || m_bare_type_info == 0; }
+
+      std::string bare_name() const
+      {
+        if (m_bare_type_info)
+        {
+          return m_bare_type_info->name();
+        } else {
+          return "";
+        }
+      }
+
+    private:
+      bool m_is_const;
+      bool m_is_reference;
+      bool m_is_pointer;
+      bool m_is_void;
+      const std::type_info *m_type_info;
+      const std::type_info *m_bare_type_info;
+      bool m_is_unknown;
   };
 
-  /**
-   * Helper used to create a Type_Info object
-   */
-  template<typename T>
-    struct Get_Type_Info
-    {
-      static Type_Info get()
+  namespace detail
+  {
+    /**
+     * Helper used to create a Type_Info object
+     */
+    template<typename T>
+      struct Get_Type_Info
       {
-        return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-            boost::is_void<T>::value,
-            &typeid(T), 
-            &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
-      }
-    };
+        static Type_Info get()
+        {
+          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
+              boost::is_void<T>::value,
+              &typeid(T), 
+              &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
+        }
+      };
+
+    template<typename T>
+      struct Get_Type_Info<boost::shared_ptr<T> >
+      {
+        static Type_Info get()
+        {
+          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
+              boost::is_void<T>::value,
+              &typeid(boost::shared_ptr<T> ), 
+              &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
+        }
+      };
+
+    template<typename T>
+      struct Get_Type_Info<const boost::shared_ptr<T> &>
+      {
+        static Type_Info get()
+        {
+          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
+              boost::is_void<T>::value,
+              &typeid(const boost::shared_ptr<T> &), 
+              &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
+        }
+      };
+
+    template<typename T>
+      struct Get_Type_Info<boost::reference_wrapper<T> >
+      {
+        static Type_Info get()
+        {
+          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
+              boost::is_void<T>::value,
+              &typeid(boost::reference_wrapper<T> ), 
+              &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
+        }
+      };
+  }
+  
+  template<typename T>
+  Type_Info user_type(T)
+  {
+    return detail::Get_Type_Info<T>::get();
+  }
+
 
   template<typename T>
-    struct Get_Type_Info<boost::shared_ptr<T> >
-    {
-      static Type_Info get()
-      {
-        return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-            boost::is_void<T>::value,
-            &typeid(boost::shared_ptr<T> ), 
-            &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
-      }
-    };
+  Type_Info user_type()
+  {
+    return detail::Get_Type_Info<T>::get();
+  }
 
-  template<typename T>
-    struct Get_Type_Info<boost::reference_wrapper<T> >
-    {
-      static Type_Info get()
-      {
-        return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-            boost::is_void<T>::value,
-            &typeid(boost::reference_wrapper<T> ), 
-            &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
-      }
-    };
 }
 
 #endif

include/chaiscript/language/chaiscript_common.hpp

@@ -0,0 +1,135 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#ifndef _CHAISCRIPT_COMMON_HPP
+#define	_CHAISCRIPT_COMMON_HPP
+
+
+#ifdef  BOOST_HAS_DECLSPEC
+#define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)
+#else
+#define CHAISCRIPT_MODULE_EXPORT extern "C"
+#endif
+
+namespace chaiscript
+{
+    typedef ModulePtr (*Create_Module_Func)();
+
+    /**
+     * Types of AST nodes available to the parser and eval
+     */
+    class Token_Type { public: enum Type { Error, Int, Float, Id, Char, Str, Eol, Fun_Call, Inplace_Fun_Call, Arg_List, Variable, Equation, Var_Decl,
+        Expression, Comparison, Additive, Multiplicative, Negate, Not, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
+        Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Map_Pair, Value_Range,
+        Inline_Range, Annotation, Try, Catch, Finally, Method, Attr_Decl, Shift }; };
+
+    namespace
+    {
+      /**
+       * Helper lookup to get the name of each node type
+       */
+      const char *token_type_to_string(int tokentype) {
+        const char *token_types[] = { "Internal Parser Error", "Int", "Float", "Id", "Char", "Str", "Eol", "Fun_Call", "Inplace_Fun_Call", "Arg_List", "Variable", "Equation", "Var_Decl",
+          "Expression", "Comparison", "Additive", "Multiplicative", "Negate", "Not", "Array_Call", "Dot_Access", "Quoted_String", "Single_Quoted_String",
+          "Lambda", "Block", "Def", "While", "If", "For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Map_Pair", "Value_Range",
+          "Inline_Range", "Annotation", "Try", "Catch", "Finally", "Method", "Attr_Decl", "Shift"};
+
+        return token_types[tokentype];
+      }
+    }
+
+    /**
+     * Convenience type for file positions
+     */
+    struct File_Position {
+        int line;
+        int column;
+
+        File_Position(int file_line, int file_column)
+            : line(file_line), column(file_column) { }
+
+        File_Position() : line(0), column(0) { }
+    };
+
+    typedef boost::shared_ptr<struct Token> TokenPtr;
+
+    /**
+     * The struct that doubles as both a parser token and an AST node
+     */
+    struct Token {
+        std::string text;
+        int identifier;
+        const char *filename;
+        File_Position start, end;
+        bool is_cached;
+        Boxed_Value cached_value;
+
+        std::vector<TokenPtr> children;
+        TokenPtr annotation;
+
+        Token(const std::string &token_text, int id, const char *fname) :
+            text(token_text), identifier(id), filename(fname), is_cached(false) { }
+
+        Token(const std::string &token_text, int id, const char *fname, int start_line, int start_col, int end_line, int end_col) :
+            text(token_text), identifier(id), filename(fname), is_cached(false) {
+
+            start.line = start_line;
+            start.column = start_col;
+            end.line = end_line;
+            end.column = end_col;
+        }
+    };
+
+    /**
+     * Errors generated during parsing or evaluation
+     */
+    struct Eval_Error : public std::runtime_error {
+        std::string reason;
+        File_Position start_position;
+        File_Position end_position;
+        const char *filename;
+
+        Eval_Error(const std::string &why, const File_Position &where, const char *fname) :
+            std::runtime_error("Error: \"" + why + "\" " +
+                (std::string(fname) != "__EVAL__" ? ("in '" + std::string(fname) + "' ") : "during evaluation ") +
+                + "at (" + boost::lexical_cast<std::string>(where.line) + ", " +
+                boost::lexical_cast<std::string>(where.column) + ")"),
+            reason(why), start_position(where), end_position(where), filename(fname)
+        { }
+
+        Eval_Error(const std::string &why, const TokenPtr &where)
+            : std::runtime_error("Error: \"" + why + "\" " +
+                (std::string(where->filename) != "__EVAL__" ? ("in '" + std::string(where->filename) + "' ") : "during evaluation ") +
+                "at (" + boost::lexical_cast<std::string>(where->start.line) + ", " +
+                boost::lexical_cast<std::string>(where->start.column) + ")"),
+              reason(why), start_position(where->start), end_position(where->end), filename(where->filename) {
+        }
+
+        virtual ~Eval_Error() throw() {}
+    };
+
+    /**
+     * Special type for returned values
+     */
+    struct Return_Value {
+        Boxed_Value retval;
+        TokenPtr location;
+
+        Return_Value(const Boxed_Value &return_value, const TokenPtr where) : retval(return_value), location(where) { }
+    };
+
+    /**
+     * Special type indicating a call to 'break'
+     */
+    struct Break_Loop {
+        TokenPtr location;
+
+        Break_Loop(const TokenPtr where) : location(where) { }
+    };
+}
+
+#endif	/* _CHAISCRIPT_COMMON_HPP */
+

include/chaiscript/language/chaiscript_engine.hpp

@@ -10,22 +10,427 @@
 #include <exception>
 #include <fstream>
 
+#include <chaiscript/language/chaiscript_common.hpp>
 
-#include "chaiscript_prelude.hpp"
-#include "chaiscript_parser.hpp"
+#ifdef _POSIX_VERSION
+#include <dlfcn.h>
+#else
+#ifdef WIN32
+#include <Windows.h>
+#endif
+#endif
+
+#include <chaiscript/language/chaiscript_prelude.hpp>
+#include <chaiscript/language/chaiscript_parser.hpp>
 
 namespace chaiscript
 {
+    struct load_module_error : std::runtime_error
+    {
+       load_module_error(const std::string &reason) throw()
+         : std::runtime_error(reason)
+       {
+       }
+
+       virtual ~load_module_error() throw()
+       {
+       }
+    };
+
+#ifdef _POSIX_VERSION
+    struct Loadable_Module
+    {
+        struct DLModule
+        {
+           DLModule(const std::string &t_filename)
+             : m_data(dlopen(t_filename.c_str(), RTLD_NOW))
+           {
+              if (!m_data)
+              {
+                 throw load_module_error(dlerror());
+              }
+           }
+
+           DLModule(const DLModule &); // Explicitly unimplemented copy constructor
+           DLModule &operator=(const DLModule &); // Explicitly unimplemented assignment operator
+
+           ~DLModule()
+           {
+              dlclose(m_data);
+           }
+
+           void *m_data;
+        };
+
+        template<typename T>
+        struct DLSym
+        {
+            DLSym(DLModule &t_mod, const std::string &t_symbol)
+              : m_symbol(reinterpret_cast<T>(dlsym(t_mod.m_data, t_symbol.c_str())))
+            {
+              if (!m_symbol)
+              {
+                 throw load_module_error(dlerror());
+              }
+            }
+
+            T m_symbol;
+        };
+
+        Loadable_Module(const std::string &t_module_name, const std::string &t_filename)
+          : m_dlmodule(t_filename), m_func(m_dlmodule, "create_chaiscript_module_" + t_module_name)
+        {
+        }
+
+        ModulePtr get()
+        {
+          return m_func.m_symbol();
+        }
+
+        DLModule m_dlmodule;
+        DLSym<Create_Module_Func> m_func;
+    };
+#else
+
+#ifdef WIN32
+
+
+    struct Loadable_Module
+    {
+        template<typename T>
+        static std::wstring towstring(const T &str) 
+        {
+            return std::wstring(str.begin(), str.end());
+        }
+
+        template<typename T>
+        static std::string tostring(const T &str)
+        {
+            return std::string(str.begin(), str.end());
+        }
+
+#ifdef _UNICODE
+        template<typename T>
+        static std::wstring toproperstring(const T &str)
+        {
+            return towstring(str);
+        }
+#else
+        template<typename T>
+        static std::string toproperstring(const T &str)
+        {
+            return tostring(str);
+        }
+#endif
+
+        static std::string GetErrorMessage(DWORD err)
+        {
+#ifdef _UNICODE
+            typedef LPWSTR StringType;
+            std::wstring retval = L"Unknown Error";
+#else
+            typedef LPSTR StringType;
+            std::string retval = "Unknown Error";
+#endif
+            StringType lpMsgBuf = 0;
+
+            FormatMessage(
+                FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+                FORMAT_MESSAGE_FROM_SYSTEM |
+                FORMAT_MESSAGE_IGNORE_INSERTS,
+                NULL,
+                err,
+                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                (StringType)&lpMsgBuf,
+                0, NULL );        
+
+            if (lpMsgBuf)
+            {
+              retval = lpMsgBuf;
+            }
+
+            LocalFree(lpMsgBuf);
+            return tostring(retval);
+        }
+
+        struct DLModule
+        {
+           DLModule(const std::string &t_filename)
+             : m_data(LoadLibrary(toproperstring(t_filename).c_str()))
+           {
+              if (!m_data)
+              {
+                 throw load_module_error(GetErrorMessage(GetLastError()));
+              }
+           }
+
+           ~DLModule()
+           {
+              FreeLibrary(m_data);
+           }
+
+           HMODULE m_data;
+        };
+
+        template<typename T>
+        struct DLSym
+        {
+            DLSym(DLModule &t_mod, const std::string &t_symbol)
+              : m_symbol(reinterpret_cast<T>(GetProcAddress(t_mod.m_data, t_symbol.c_str())))
+            {
+              if (!m_symbol)
+              {
+                 throw load_module_error(GetErrorMessage(GetLastError()));
+              }
+            }
+
+            T m_symbol;
+        };
+
+        Loadable_Module(const std::string &t_module_name, const std::string &t_filename)
+          : m_dlmodule(t_filename), m_func(m_dlmodule, "create_chaiscript_module_" + t_module_name)
+        {
+        }
+
+        ModulePtr get()
+        {
+          return m_func.m_symbol();
+        }
+
+        DLModule m_dlmodule;
+        DLSym<Create_Module_Func> m_func;
+    };
+
+#else
+    struct Loadable_Module
+    {
+        Loadable_Module(const std::string &, const std::string &)
+        {
+          throw load_module_error("Loadable module support not available for your platform");
+        }
+
+        ModulePtr get()
+        {
+          throw load_module_error("Loadable module support not available for your platform");
+        }
+    };
+#endif
+#endif
+
+    typedef boost::shared_ptr<Loadable_Module> Loadable_Module_Ptr;
+
+
     template <typename Eval_Engine>
     class ChaiScript_System {
+#ifndef CHAISCRIPT_NO_THREADS
+        mutable boost::shared_mutex mutex;
+        mutable boost::recursive_mutex use_mutex;
+#endif
+
+        std::set<std::string> loaded_files;
+        std::map<std::string, Loadable_Module_Ptr> loaded_modules;
+
         Eval_Engine engine;
-        ChaiScript_Parser parser;
+
+
+        /**
+         * Evaluates the given string in by parsing it and running the results through the evaluator
+         */
+        Boxed_Value do_eval(const std::string &input, const std::string &filename = "__EVAL__", bool internal = false) {
+            ChaiScript_Parser parser;
+
+            if (!internal)
+            {
+                engine.sync_cache();
+            }
+
+            //debug_print(tokens);
+            Boxed_Value value;
+
+            // Keep a cache of all loaded filenames and use the char * from this cache to pass 
+            // to the parser. This is so that the parser does not have the overhead of passing 
+            // around and copying strings
+            // 
+            if (filename != "__EVAL__")
+            {
+#ifndef CHAISCRIPT_NO_THREADS
+                boost::unique_lock<boost::shared_mutex> l(mutex);
+#endif
+                loaded_files.insert(filename);
+                try {
+                    if (parser.parse(input, loaded_files.find(filename)->c_str())) {
+#ifndef CHAISCRIPT_NO_THREADS
+                        l.unlock();
+#endif
+                        //parser.show_match_stack();
+                        value = eval_token<Eval_Engine>(engine, parser.ast());
+                    }
+                }
+                catch (const Return_Value &rv) {
+                    value = rv.retval;
+                }
+            } else {
+                try {
+#ifndef CHAISCRIPT_NO_THREADS
+                    boost::shared_lock<boost::shared_mutex> l(mutex);
+#endif
+                    const char *fname = loaded_files.find("__EVAL__")->c_str();
+#ifndef CHAISCRIPT_NO_THREADS
+                    l.unlock();
+#endif
+ 
+                    if (parser.parse(input, fname)) {
+                        //parser.show_match_stack();
+                        value = eval_token<Eval_Engine>(engine, parser.ast());
+                    }
+                }
+                catch (const Return_Value &rv) {
+                    value = rv.retval;
+                }
+            }
+
+            if (!internal)
+            {
+                engine.sync_cache();
+            }
+
+            return value;
+        }
+
+        /**
+         * Evaluates the given boxed string, used during eval() inside of a script
+         */
+        const Boxed_Value internal_eval(const std::string &e) {
+            return do_eval(e, "__EVAL__", true);
+        }
+
+        void use(const std::string &filename)
+        {
+#ifndef CHAISCRIPT_NO_THREADS
+          boost::lock_guard<boost::recursive_mutex> l(use_mutex);
+          boost::shared_lock<boost::shared_mutex> l2(mutex);
+#endif
+
+          if (loaded_files.count(filename) == 0)
+          {
+#ifndef CHAISCRIPT_NO_THREADS
+            l2.unlock();
+#endif
+            eval_file(filename);
+          } else {
+            engine.sync_cache();
+          }
+
+        }
+
 
     public:
         ChaiScript_System()  {
+            loaded_files.insert("__EVAL__"); // Make sure the default name is already registered
             build_eval_system();
         }
 
+        /**
+         * Adds a shared object, that can be used by all threads, to the system
+         */
+        ChaiScript_System &add_shared_object(const Boxed_Value &bv, const std::string &name)
+        {
+            engine.add_shared_object(bv, name);
+            return *this;
+        }
+
+        /**
+         * Adds an object to the system: type, function, object
+         */
+        template<typename T>
+          ChaiScript_System &add(const T &t, const std::string &name)
+          {
+              engine.add(t, name);
+              return *this;
+          }
+
+        /**
+         * Adds a module object to the system
+         */
+        ChaiScript_System &add(const ModulePtr &p)
+        {
+            p->apply(*this, this->get_eval_engine());
+            return *this;
+        }
+
+        /**
+         * Load a dynamic library containing a chaiscript module
+         */
+        void load_module(const std::string &t_module_name)
+        {
+            std::vector<std::string> prefixes;
+            prefixes.push_back("lib");
+            prefixes.push_back("");
+
+            std::vector<std::string> postfixes;
+            postfixes.push_back(".dll");
+            postfixes.push_back(".so");
+            postfixes.push_back("");
+
+            for (size_t i = 0; i < prefixes.size(); ++i)
+            {
+                for (size_t j = 0; j < postfixes.size(); ++j)
+                {
+                    try {
+                        std::string name = prefixes[i] + t_module_name + postfixes[j];
+                        load_module(t_module_name, name);
+                        return;
+                    } catch (const load_module_error &) {
+                        // Try next set
+                    }
+                }
+            }
+
+            throw load_module_error("Unable to find module: " + t_module_name);
+        }
+
+        /**
+         * Load a dynamic library and provide the file name to load it from
+         */
+        void load_module(const std::string &t_module_name, const std::string &t_filename)
+        {
+#ifndef CHAISCRIPT_NO_THREADS
+            boost::lock_guard<boost::recursive_mutex> l(use_mutex);
+#endif
+
+            if (loaded_modules.count(t_module_name) == 0)
+            {
+                Loadable_Module_Ptr lm(new Loadable_Module(t_module_name, t_filename));
+                loaded_modules[t_module_name] = lm;
+                add(lm->get());
+            } else {
+                engine.sync_cache();
+            }
+        }
+
+
+        /**
+         * Helper for calling script code as if it were native C++ code
+         * example:
+         * boost::function<int (int, int)> f = build_functor(chai, "func(x, y){x+y}");
+         * \return a boost::function representing the passed in script
+         * \param[in] script Script code to build a function from
+         */
+        template<typename FunctionType>
+          boost::function<FunctionType> functor(const std::string &script)
+          {
+              return chaiscript::functor<FunctionType>(eval(script));
+          }
+
+        /**
+         * Evaluate a string via eval method
+         */
+        Boxed_Value operator()(const std::string &script)
+        {
+            return do_eval(script);
+        }
+
+
         /**
          * Returns the current evaluation engine
          */
@@ -43,25 +448,14 @@ namespace chaiscript
             }
         }
 
-        /**
-         * Evaluates the given boxed string, used during eval() inside of a script
-         */
-        const dispatchkit::Boxed_Value eval(const std::vector<dispatchkit::Boxed_Value> &vals) {
-            std::string val;
-            val = dispatchkit::boxed_cast<std::string &>(vals[0]);
-
-            return evaluate_string(val);
-        }
-
         /**
          * Helper function for loading a file
          */
-        std::string load_file(const char *filename) {
-            std::ifstream infile (filename, std::ios::in | std::ios::ate);
+        std::string load_file(const std::string &filename) {
+            std::ifstream infile (filename.c_str(), std::ios::in | std::ios::ate);
 
             if (!infile.is_open()) {
-                std::string fname = filename;
-                throw std::runtime_error("Can not open: " + fname);
+                throw std::runtime_error("Can not open: " + filename);
             }
 
             std::streampos size = infile.tellg();
@@ -79,48 +473,80 @@ namespace chaiscript
          * Builds all the requirements for ChaiScript, including its evaluator and a run of its prelude.
          */
         void build_eval_system() {
-            dispatchkit::Bootstrap::bootstrap(engine);
-            dispatchkit::bootstrap_vector<std::vector<dispatchkit::Boxed_Value> >(engine, "Vector");
-            dispatchkit::bootstrap_string<std::string>(engine, "string");
-            dispatchkit::bootstrap_map<std::map<std::string, dispatchkit::Boxed_Value> >(engine, "Map");
-            dispatchkit::bootstrap_pair<std::pair<dispatchkit::Boxed_Value, dispatchkit::Boxed_Value > >(engine, "Pair");
+            using namespace bootstrap;
+            engine.add_reserved_word("def");
+            engine.add_reserved_word("fun");
+            engine.add_reserved_word("while");
+            engine.add_reserved_word("for");
+            engine.add_reserved_word("if");
+            engine.add_reserved_word("else");
+            engine.add_reserved_word("&&");
+            engine.add_reserved_word("||");
+            engine.add_reserved_word(",");
+            engine.add_reserved_word(":=");
+            engine.add_reserved_word("var");
+            engine.add_reserved_word("return");
+            engine.add_reserved_word("break");
+            engine.add_reserved_word("true");
+            engine.add_reserved_word("false");
+            engine.add_reserved_word("_");
 
-            engine.register_function(boost::shared_ptr<dispatchkit::Proxy_Function>(
-                  new dispatchkit::Dynamic_Proxy_Function(boost::bind(&ChaiScript_System<Eval_Engine>::eval, boost::ref(*this), _1), 1)), "eval");
+            add(Bootstrap::bootstrap());
 
-            evaluate_string(chaiscript_prelude);
+            engine.add(fun(&Eval_Engine::dump_system, boost::ref(engine)), "dump_system");
+            engine.add(fun(&Eval_Engine::dump_object, boost::ref(engine)), "dump_object");
+            engine.add(fun(&Eval_Engine::is_type, boost::ref(engine)), "is_type");
+            engine.add(fun(&Eval_Engine::type_name, boost::ref(engine)), "type_name");
+            engine.add(fun(&Eval_Engine::function_exists, boost::ref(engine)), "function_exists");
+
+
+            typedef void (ChaiScript_System<Eval_Engine>::*load_mod_1)(const std::string&);
+            typedef void (ChaiScript_System<Eval_Engine>::*load_mod_2)(const std::string&, const std::string&);
+
+            engine.add(fun(static_cast<load_mod_1>(&ChaiScript_System<Eval_Engine>::load_module), this), "load_module");
+            engine.add(fun(static_cast<load_mod_2>(&ChaiScript_System<Eval_Engine>::load_module), this), "load_module");
+
+
+            add(vector_type<std::vector<Boxed_Value> >("Vector"));
+            add(string_type<std::string>("string"));
+            add(map_type<std::map<std::string, Boxed_Value> >("Map"));
+            add(pair_type<std::pair<Boxed_Value, Boxed_Value > >("Pair"));
+
+            engine.add(fun(&ChaiScript_System<Eval_Engine>::use, this), "use");
+            engine.add(fun(&ChaiScript_System<Eval_Engine>::internal_eval, this), "eval");
+
+
+            do_eval(chaiscript_prelude, "standard prelude");
         }
 
-        /**
-         * Evaluates the given string in by parsing it and running the results through the evaluator
-         */
-        dispatchkit::Boxed_Value evaluate_string(const std::string &input, const char *filename = "__EVAL__") {
-            //debug_print(tokens);
-            dispatchkit::Boxed_Value value;
-            parser.clear_match_stack();
+        template<typename T>
+          T eval(const std::string &input)
+          {
+              return boxed_cast<T>(do_eval(input));
+          }
 
-            try {
-                if (parser.parse(input, filename)) {
-                    //parser.show_match_stack();
-                    value = eval_token<Eval_Engine>(engine, parser.ast());
-                }
-            }
-            catch (const Return_Value &rv) {
-                value = rv.retval;
-            }
-
-            return value;
+        Boxed_Value eval(const std::string &input)
+        {
+            return do_eval(input);
         }
 
         /**
          * Loads the file specified by filename, evaluates it, and returns the result
          */
-        dispatchkit::Boxed_Value evaluate_file(const char *filename) {
-            return evaluate_string(load_file(filename), filename);
+        Boxed_Value eval_file(const std::string &filename) {
+            return do_eval(load_file(filename), filename);
+        }
+
+        /**
+         * Loads the file specified by filename, evaluates it, and returns the as the specified type
+         */
+        template<typename T>
+        T eval_file(const std::string &filename) {
+            return boxed_cast<T>(do_eval(load_file(filename), filename));
         }
     };
 
-    typedef ChaiScript_System<dispatchkit::Dispatch_Engine> ChaiScript_Engine;
+    typedef ChaiScript_System<Dispatch_Engine> ChaiScript;
 }
 #endif /* CHAISCRIPT_ENGINE_HPP_ */
 

include/chaiscript/language/chaiscript_prelude.hpp

@@ -9,257 +9,321 @@
 
 //Note, the expression "[x,y]" in "collate" is parsed as two separate expressions
 //by C++, so CODE_STRING, takes two expressions and adds in the missing comma
-#define CODE_STRING(x, y) #x ", " #y
+#define CODE_STRING(x, y) #x ", " #y 
 
 #define chaiscript_prelude CODE_STRING(\
+def lt(l, r) { if (call_exists(`<`, l, r)) { l < r } else { type_name(l) < type_name(r) } } \n\
+def gt(l, r) { if (call_exists(`>`, l, r)) { l > r } else { type_name(l) > type_name(r) } } \n\
+def eq(l, r) { if (call_exists(`==`, l, r)) { l == r } else { false } } \n\
+def new(x) { eval(type_name(x))(); } \n\
+def clone(x) : function_exists(type_name(x)) && call_exists(eval(type_name(x)), x)  { eval(type_name(x))(x); } \n\
 # to_string for Pair()\n\
-def to_string(x) : call_exists(first, x) && call_exists(second, x) { \
-  "<" + x.first.to_string() + ", " + x.second.to_string() + ">"; \
-}\
+def to_string(x) : call_exists(first, x) && call_exists(second, x) { \n\
+  "<" + x.first.to_string() + ", " + x.second.to_string() + ">"; \n\
+}\n\
 # to_string for containers\n\
-def to_string(x) : call_exists(range, x) && !x.is_type("string"){ \
-  "[" + x.join(", ") + "]"; \
-}\
+def to_string(x) : call_exists(range, x) && !x.is_type("string"){ \n\
+  "[" + x.join(", ") + "]"; \n\
+}\n\
 # Basic to_string function\n\
-def to_string(x) { \
-  return internal_to_string(x); \
-}\
+def to_string(x) { \n\
+  internal_to_string(x); \n\
+}\n\
 # Prints to console with no carriage return\n\
-def puts(x) { \
-  print_string(x.to_string()); \
-} \
+def puts(x) { \n\
+  print_string(x.to_string()); \n\
+} \n\
 # Prints to console with carriage return\n\
-def print(x) { \
-  println_string(x.to_string()); \
-} \
+def print(x) { \n\
+  println_string(x.to_string()); \n\
+} \n\
 # Returns the maximum value of two numbers\n\
-def max(a, b) { if (a>b) { a } else { b } } \
+def max(a, b) { if (a>b) { a } else { b } } \n\
 # Returns the minimum value of two numbers\n\
-def min(a, b) { if (a<b) { a } else { b } } \
+def min(a, b) { if (a<b) { a } else { b } } \n\
 # Returns true if the value is odd\n\
-def odd(x)  { if (x % 2 == 1) { true } else { false } } \
+def odd(x)  { if (x % 2 == 1) { true } else { false } } \n\
 # Returns true if the value is even\n\
-def even(x) { if (x % 2 == 0) { true } else { false } } \
+def even(x) { if (x % 2 == 0) { true } else { false } } \n\
 # Pushes the second value onto the container first value while making a clone of the value\n\
-def push_back(container, x) { container.push_back_ref(clone(x)) } \n\
+def push_back(container, x) : call_exists(push_back_ref, container, x) { container.push_back_ref(clone(x)) } \n\
+# Pushes the second value onto the front of the container first value while making a clone of the value\n\
+def push_front(container, x) : call_exists(push_front_ref, container, x) { container.push_front_ref(clone(x)) } \n\
 # Inserts the third value at the position of the second value into the container of the first\n\
 # while making a clone. \n\
 def insert_at(container, pos, x) { container.insert_ref_at(pos, clone(x)); } \n\
+# Returns the reverse of the given container\n\
+def reverse(container) {\n\
+  var retval = new(container); \n\
+  var r = range(container); \n\
+  while (!r.empty()) { \n\
+    retval.push_back(r.back()); \n\
+    r.pop_back(); \n\
+  } \n\
+  retval; \n\
+} \n\
+# Return a range from a range \n\
+def range(r) : call_exists(empty, r) && call_exists(pop_front, r) && call_exists(pop_back, r) && call_exists(back, r) && call_exists(front, r) { return clone(r); }\n\
+# The retro attribute that contains the underlying range \n\
+attr retro::m_range; \n\
+# Creates a retro from a retro by returning the original range\n\
+def retro(r) : call_exists(get_type_name, r) && get_type_name(r) == "retro" { clone(r.m_range) }\n\
+# Creates a retro range from a range\n\
+def retro::retro(r) : call_exists(empty, r) && call_exists(pop_front, r) && call_exists(pop_back, r) && call_exists(back, r) && call_exists(front, r) { this.m_range = r; }\n\
+# Returns the first value of a retro\n\
+def retro::front()  { back(this.m_range) }\n\
+# Returns the last value of a retro\n\
+def retro::back()  { front(this.m_range) }\n\
+# Moves the back iterator of a retro towards the front by one \n\
+def retro::pop_back()  { pop_front(this.m_range) }\n\
+# Moves the front iterator of a retro towards the back by one \n\
+def retro::pop_front()  { pop_back(this.m_range) } \n\
+# returns true if the retro is out of elements \n\
+def retro::empty() { empty(this.m_range); } \n\
 # Performs the second value function over the container first value\n\
-def for_each(container, func) : call_exists(range, container) { \
-  var range = range(container); \
-  while (!range.empty()) { \
-    func(range.front()); \
-    range.pop_front(); \
-  } \
-} \
-def back_inserter(container) { \
-  return bind(push_back, container, _);     \
-}\
-\
-def map(container, func, inserter) : call_exists(range, container) { \
-  var range = range(container); \
-  while (!range.empty()) { \
-    inserter(func(range.front())); \
-    range.pop_front(); \
-  } \
-} \
-# Performs the second value function over the container first value. Creates a new Vector with the results\n\
-def map(container, func) { \
-  var retval = Vector();\
-  map(container, func, back_inserter(retval));\
-  return retval;\
-}\
+def for_each(container, func) : call_exists(range, container) { \n\
+  var t_range = range(container); \n\
+  while (!t_range.empty()) { \n\
+    func(t_range.front()); \n\
+    t_range.pop_front(); \n\
+  } \n\
+} \n\
+def back_inserter(container) { \n\
+  bind(push_back, container, _);     \n\
+}\n\
+\n\
+def contains(container, item, compare_func) : call_exists(range, container) { \n\
+  var t_range = range(container); \n\
+  while (!t_range.empty()) { \n\
+    if ( compare_func(t_range.front(), item) ) { return true; } \n\
+    t_range.pop_front(); \n\
+  } \n\
+  return false; \n\
+} \n\
+def contains(container, item) { return contains(container, item, eq) } \n\
+def map(container, func, inserter) : call_exists(range, container) { \n\
+  var range = range(container); \n\
+  while (!range.empty()) { \n\
+    inserter(func(range.front())); \n\
+    range.pop_front(); \n\
+  } \n\
+} \n\
+# Performs the second value function over the container first value. Creates a new container with the results\n\
+def map(container, func) { \n\
+  var retval = new(container); \n\
+  map(container, func, back_inserter(retval));\n\
+  retval;\n\
+}\n\
 # Performs the second value function over the container first value. Starts with initial and continues with each element.\n\
-def foldl(container, func, initial) : call_exists(range, container){ \
-  var retval = initial; \
-  var range = range(container); \
-  while (!range.empty()) { \
-    retval = (func(range.front(), retval)); \
-    range.pop_front(); \
-  } \
-  retval; \
-} \
+def foldl(container, func, initial) : call_exists(range, container){ \n\
+  var retval = initial; \n\
+  var range = range(container); \n\
+  while (!range.empty()) { \n\
+    retval = (func(range.front(), retval)); \n\
+    range.pop_front(); \n\
+  } \n\
+  retval; \n\
+} \n\
 # Returns the sum of the elements of the given value\n\
-def sum(container) { foldl(container, `+`, 0.0) } \
+def sum(container) { foldl(container, `+`, 0.0) } \n\
 # Returns the product of the elements of the given value\n\
-def product(container) { foldl(container, `*`, 1.0) } \
-# Returns a new Vector with the elements of the first value concatenated with the elements of the second value\n\
-def concat(x, y) : call_exists(clone, x) { \
-  var retval = x; \
-  var len = y.size(); \
-  var i = 0; \
-  while (i < len) { \
-    retval.push_back(y[i]); \
-    ++i; \
-  } \
-  retval; \
-} \
-def take(container, num, inserter) : call_exists(range, container) { \
-  var r = range(container); \
-  var i = num; \
-  while ((i > 0) && (!r.empty())) { \
-    inserter(r.front()); \
-    r.pop_front(); \
-    --i; \
-  } \
-} \
-# Returns a new Vector with the given number of elements taken from the container\n\
-def take(container, num) {\
-  var retval = Vector(); \
-  take(container, num, back_inserter(retval)); \
-  return retval; \
-}\
-def take_while(container, f, inserter) : call_exists(range, container) { \
-  var r = range(container); \
-  while ((!r.empty()) && f(r.front())) { \
-    inserter(r.front()); \
-    r.pop_front(); \
-  } \
-} \
-# Returns a new Vector with the given elements match the second value function\n\
-def take_while(container, f) {\
-  var retval = Vector(); \
-  take_while(container, f, back_inserter(retval)); \
-  return retval;\
-}\
-def drop(container, num, inserter) : call_exists(range, container) { \
-  var r = range(container); \
-  var i = num; \
-  while ((i > 0) && (!r.empty())) { \
-    r.pop_front(); \
-    --i; \
-  } \
-  while (!r.empty()) { \
-    inserter(r.front()); \
-    r.pop_front(); \
-  } \
-} \
-# Returns a new Vector with the given number of elements dropped from the given container \n\
-def drop(container, num) {\
-  var retval = Vector(); \
-  drop(container, num, back_inserter(retval)); \
-  return retval; \
-}\
-def drop_while(container, f, inserter) : call_exists(range, container) { \
-  var r = range(container); \
-  while ((!r.empty())&& f(r.front())) { \
-    r.pop_front(); \
-  } \
-  while (!r.empty()) { \
-    inserter(r.front()); \
-    r.pop_front(); \
-  } \
-} \
-# Returns a new Vector with the given elements dropped that match the second value function\n\
-def drop_while(container, f) {\
-  var retval = Vector(); \
-  drop_while(container, f, back_inserter(retval)); \
-  return retval; \
-}\
+def product(container) { foldl(container, `*`, 1.0) } \n\
+# Returns a new container with the elements of the first value concatenated with the elements of the second value\n\
+def concat(x, y) : call_exists(clone, x) { \n\
+  var retval = x; \n\
+  var len = y.size(); \n\
+  var i = 0; \n\
+  while (i < len) { \n\
+    retval.push_back(y[i]); \n\
+    ++i; \n\
+  } \n\
+  retval; \n\
+} \n\
+def take(container, num, inserter) : call_exists(range, container) { \n\
+  var r = range(container); \n\
+  var i = num; \n\
+  while ((i > 0) && (!r.empty())) { \n\
+    inserter(r.front()); \n\
+    r.pop_front(); \n\
+    --i; \n\
+  } \n\
+} \n\
+# Returns a new container with the given number of elements taken from the container\n\
+def take(container, num) {\n\
+  var retval = new(container); \n\
+  take(container, num, back_inserter(retval)); \n\
+  retval; \n\
+}\n\
+def take_while(container, f, inserter) : call_exists(range, container) { \n\
+  var r = range(container); \n\
+  while ((!r.empty()) && f(r.front())) { \n\
+    inserter(r.front()); \n\
+    r.pop_front(); \n\
+  } \n\
+} \n\
+# Returns a new container with the given elements match the second value function\n\
+def take_while(container, f) {\n\
+  var retval = new(container); \n\
+  take_while(container, f, back_inserter(retval)); \n\
+  retval;\n\
+}\n\
+def drop(container, num, inserter) : call_exists(range, container) { \n\
+  var r = range(container); \n\
+  var i = num; \n\
+  while ((i > 0) && (!r.empty())) { \n\
+    r.pop_front(); \n\
+    --i; \n\
+  } \n\
+  while (!r.empty()) { \n\
+    inserter(r.front()); \n\
+    r.pop_front(); \n\
+  } \n\
+} \n\
+# Returns a new container with the given number of elements dropped from the given container \n\
+def drop(container, num) {\n\
+  var retval = new(container); \n\
+  drop(container, num, back_inserter(retval)); \n\
+  retval; \n\
+}\n\
+def drop_while(container, f, inserter) : call_exists(range, container) { \n\
+  var r = range(container); \n\
+  while ((!r.empty())&& f(r.front())) { \n\
+    r.pop_front(); \n\
+  } \n\
+  while (!r.empty()) { \n\
+    inserter(r.front()); \n\
+    r.pop_front(); \n\
+  } \n\
+} \n\
+# Returns a new container with the given elements dropped that match the second value function\n\
+def drop_while(container, f) {\n\
+  var retval = new(container); \n\
+  drop_while(container, f, back_inserter(retval)); \n\
+  retval; \n\
+}\n\
 # Applies the second value function to the container. Starts with the first two elements. Expects at least 2 elements.\n\
-def reduce(container, func) : container.size() >= 2 && call_exists(range, container) { \
-  var r = range(container); \
-  var retval = r.front(); \
-  r.pop_front(); \
-  retval = func(retval, r.front()); \
-  r.pop_front(); \
-  while (!r.empty()) { \
-    retval = func(retval, r.front()); \
-    r.pop_front(); \
-  } \
-  retval; \
-} \
+def reduce(container, func) : container.size() >= 2 && call_exists(range, container) { \n\
+  var r = range(container); \n\
+  var retval = r.front(); \n\
+  r.pop_front(); \n\
+  retval = func(retval, r.front()); \n\
+  r.pop_front(); \n\
+  while (!r.empty()) { \n\
+    retval = func(retval, r.front()); \n\
+    r.pop_front(); \n\
+  } \n\
+  retval; \n\
+} \n\
 # Returns a string of the elements in container delimited by the second value string\n\
-def join(container, delim) { \
-  var retval = ""; \
-  var range = range(container); \
-  if (!range.empty()) { \
-    retval += to_string(range.front()); \
-    range.pop_front(); \
-    while (!range.empty()) { \
-      retval += delim; \
-      retval += to_string(range.front()); \
-      range.pop_front(); \
-    } \
-  } \
-  retval; \
-} \
-def filter(container, f, inserter) : call_exists(range, container) { \
-  var r = range(container); \
-  while (!r.empty()) { \
-    if (f(r.front())) { \
-      inserter(r.front()); \
-    } \
-    r.pop_front(); \
-  } \
-} \
+def join(container, delim) { \n\
+  var retval = ""; \n\
+  var range = range(container); \n\
+  if (!range.empty()) { \n\
+    retval += to_string(range.front()); \n\
+    range.pop_front(); \n\
+    while (!range.empty()) { \n\
+      retval += delim; \n\
+      retval += to_string(range.front()); \n\
+      range.pop_front(); \n\
+    } \n\
+  } \n\
+  retval; \n\
+} \n\
+def filter(container, f, inserter) : call_exists(range, container) { \n\
+  var r = range(container); \n\
+  while (!r.empty()) { \n\
+    if (f(r.front())) { \n\
+      inserter(r.front()); \n\
+    } \n\
+    r.pop_front(); \n\
+  } \n\
+} \n\
 # Returns a new Vector which match the second value function\n\
-def filter(container, f) { \
-  var retval = Vector(); \
-  filter(container, f, back_inserter(retval));\
-  return retval;\
-}\
-def generate_range(x, y, inserter) { \
-  var i = x; \
-  while (i <= y) { \
-    inserter(i); \
-    ++i; \
-  } \
-} \
+def filter(container, f) { \n\
+  var retval = new(container); \n\
+  filter(container, f, back_inserter(retval));\n\
+  retval;\n\
+}\n\
+def generate_range(x, y, inserter) { \n\
+  var i = x; \n\
+  while (i <= y) { \n\
+    inserter(i); \n\
+    ++i; \n\
+  } \n\
+} \n\
 # Returns a new Vector which represents the range from the first value to the second value\n\
-def generate_range(x, y) { \
-  var retval = Vector(); \
-  generate_range(x,y,back_inserter(retval)); \
-  return retval; \
-}\
+def generate_range(x, y) { \n\
+  var retval = Vector(); \n\
+  generate_range(x,y,back_inserter(retval)); \n\
+  retval; \n\
+}\n\
 # Returns a new Vector with the first value to the second value as its elements\n\
-def collate(x, y) { \
-  [x, y]; \
-} \
-def zip_with(f, x, y, inserter) : call_exists(range, x) && call_exists(range, y) { \
-  var r_x = range(x); \
-  var r_y = range(y); \
-  while (!r_x.empty() && !r_y.empty()) { \
-    inserter(f(r_x.front(), r_y.front())); \
-    r_x.pop_front(); \
-    r_y.pop_front(); \
-  } \
-} \
+def collate(x, y) { \n\
+  [x, y]; \n\
+} \n\
+def zip_with(f, x, y, inserter) : call_exists(range, x) && call_exists(range, y) { \n\
+  var r_x = range(x); \n\
+  var r_y = range(y); \n\
+  while (!r_x.empty() && !r_y.empty()) { \n\
+    inserter(f(r_x.front(), r_y.front())); \n\
+    r_x.pop_front(); \n\
+    r_y.pop_front(); \n\
+  } \n\
+} \n\
 # Returns a new Vector which joins matching elements of the second and third value with the first value function\n\
-def zip_with(f, x, y) { \
-  var retval = Vector(); \
-  zip_with(f,x,y,back_inserter(retval)); \
-  return retval;\
-}\
+def zip_with(f, x, y) { \n\
+  var retval = Vector(); \n\
+  zip_with(f,x,y,back_inserter(retval)); \n\
+  retval;\n\
+}\n\
 # Returns a new Vector which joins matching elements of the first and second\n\
-def zip(x, y) { \
-  zip_with(collate, x, y); \
-}\
+def zip(x, y) { \n\
+  zip_with(collate, x, y); \n\
+}\n\
 # Returns the position of the second value string in the first value string\n\
-def find(str, substr) { \
-  return int(find(str, substr, size_t(0))); \
-} \
+def string::find(substr) : is_type(substr, "string") { \n\
+  int(find(this, substr, size_t(0))); \n\
+} \n\
 # Returns the position of last match of the second value string in the first value string\n\
-def rfind(str, substr) { \
-  return int(rfind(str, substr, size_t(-1))); \
-} \
+def string::rfind(substr) : is_type(substr, "string") { \n\
+  int(rfind(this, substr, size_t(-1))); \n\
+} \n\
 # Returns the position of the first match of elements in the second value string in the first value string\n\
-def find_first_of(str, list) { \
-  return int(find_first_of(str, list, size_t(0))); \
-} \
+def string::find_first_of(list) : is_type(list, "string") { \n\
+  int(find_first_of(this, list, size_t(0))); \n\
+} \n\
 # Returns the position of the last match of elements in the second value string in the first value string\n\
-def find_last_of(str, list) { \
-  return int(find_last_of(str, list, size_t(-1))); \
-} \
+def string::find_last_of(list) : is_type(list, "string") { \n\
+  int(find_last_of(this, list, size_t(-1))); \n\
+} \n\
 # Returns the position of the first non-matching element in the second value string in the first value string\n\
-def find_first_not_of(str, list) { \
-  return int(find_first_not_of(str, list, size_t(0))); \
-} \
+def string::find_first_not_of(list) : is_type(list, "string") { \n\
+  int(find_first_not_of(this, list, size_t(0))); \n\
+} \n\
 # Returns the position of the last non-matching element in the second value string in the first value string\n\
-def find_last_not_of(str, list) { \
-  return int(find_last_not_of(str, list, size_t(-1))); \
-} \
+def string::find_last_not_of(list) : is_type(list, "string") { \n\
+  int(find_last_not_of(this, list, size_t(-1))); \n\
+} \n\
+def string::ltrim() { \n\
+  drop_while(this, fun(x) { x == ' ' || x == '\t' }); \n\
+} \n\
+def string::rtrim() { \n\
+  reverse(drop_while(reverse(this), fun(x) { x == ' ' || x == '\t' })); \n\
+} \n\
+def string::trim() { \n\
+  ltrim(rtrim(this)); \n\
+} \n\
+def find(container, value, compare_func) : call_exists(range, container) && is_type(compare_func, "function") { \n\
+  var range = range(container); \n\
+  while (!range.empty()) { \n\
+    if (compare_func(range.front(), value)) { \n\
+      return range; \n\
+    } else { \n\
+      range.pop_front(); \n\
+    } \n\
+  } \n\
+  return range; \n\
+} \n\
+def find(container, value) { return find(container, value, eq) } \
 )
-
 #endif /* CHAISCRIPT_PRELUDE_HPP_ */

msvc/chai-example/chai-example.vcproj

@@ -0,0 +1,197 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="chai-example"
+	ProjectGUID="{CE422E94-B360-4588-8C65-6A9BE80798F9}"
+	RootNamespace="chaiexample"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\chaiscript\Boost.vsprops"
+			CharacterSet="0"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\chaiscript\Boost.vsprops"
+			CharacterSet="0"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\example.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

msvc/chaiscript/Boost.vsprops

@@ -6,6 +6,14 @@
 	>
 	<Tool
 		Name="VCCLCompilerTool"
-		AdditionalIncludeDirectories="&quot;C:\Programming\Boost\include\boost-1_38&quot;"
+		AdditionalIncludeDirectories="&quot;C:\boost\include\boost-1_38&quot;"
+	/>
+	<Tool
+		Name="VCLibrarianTool"
+		AdditionalLibraryDirectories="C:\Programming\Boost\lib"
+	/>
+	<Tool
+		Name="VCLinkerTool"
+		AdditionalLibraryDirectories="C:\Boost\lib"
 	/>
 </VisualStudioPropertySheet>

msvc/chaiscript/chaiscript.sln

@@ -3,6 +3,10 @@ Microsoft Visual Studio Solution File, Format Version 10.00
 # Visual C++ Express 2008
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "chaiscript", "chaiscript.vcproj", "{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "chai-example", "..\chai-example\chai-example.vcproj", "{CE422E94-B360-4588-8C65-6A9BE80798F9}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_module", "..\test_module\test_module.vcproj", "{775EDCC2-102F-4E75-A860-9AF398D04145}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
@@ -13,6 +17,14 @@ Global
 		{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Debug|Win32.Build.0 = Debug|Win32
 		{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Release|Win32.ActiveCfg = Release|Win32
 		{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Release|Win32.Build.0 = Release|Win32
+		{CE422E94-B360-4588-8C65-6A9BE80798F9}.Debug|Win32.ActiveCfg = Debug|Win32
+		{CE422E94-B360-4588-8C65-6A9BE80798F9}.Debug|Win32.Build.0 = Debug|Win32
+		{CE422E94-B360-4588-8C65-6A9BE80798F9}.Release|Win32.ActiveCfg = Release|Win32
+		{CE422E94-B360-4588-8C65-6A9BE80798F9}.Release|Win32.Build.0 = Release|Win32
+		{775EDCC2-102F-4E75-A860-9AF398D04145}.Debug|Win32.ActiveCfg = Debug|Win32
+		{775EDCC2-102F-4E75-A860-9AF398D04145}.Debug|Win32.Build.0 = Debug|Win32
+		{775EDCC2-102F-4E75-A860-9AF398D04145}.Release|Win32.ActiveCfg = Release|Win32
+		{775EDCC2-102F-4E75-A860-9AF398D04145}.Release|Win32.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

msvc/chaiscript/chaiscript.vcproj

@@ -23,7 +23,7 @@
 			ConfigurationType="1"
 			InheritedPropertySheets=".\Boost.vsprops"
 			UseOfMFC="2"
-			CharacterSet="0"
+			CharacterSet="1"
 			>
 			<Tool
 				Name="VCPreBuildEventTool"
@@ -49,7 +49,7 @@
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="3"
-				DisableLanguageExtensions="true"
+				DisableLanguageExtensions="false"
 				TreatWChar_tAsBuiltInType="false"
 				UsePrecompiledHeader="0"
 				WarningLevel="4"
@@ -100,7 +100,7 @@
 			IntermediateDirectory="$(ConfigurationName)"
 			ConfigurationType="1"
 			InheritedPropertySheets=".\Boost.vsprops"
-			CharacterSet="0"
+			CharacterSet="1"
 			WholeProgramOptimization="1"
 			>
 			<Tool
@@ -122,7 +122,7 @@
 				Name="VCCLCompilerTool"
 				Optimization="3"
 				EnableIntrinsicFunctions="true"
-				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\dispatchkit&quot;;&quot;$(ProjectDir)\..\..\chaiscript&quot;"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
 				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
 				RuntimeLibrary="2"
 				EnableFunctionLevelLinking="true"
@@ -221,14 +221,30 @@
 				RelativePath="..\..\include\chaiscript\language\chaiscript_prelude.hpp"
 				>
 			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\chaiscript_threading.hpp"
+				>
+			</File>
 			<File
 				RelativePath="..\..\include\chaiscript\dispatchkit\dispatchkit.hpp"
 				>
 			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\dynamic_object.hpp"
+				>
+			</File>
 			<File
 				RelativePath="..\..\include\chaiscript\dispatchkit\function_call.hpp"
 				>
 			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\function_call_detail.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\handle_return.hpp"
+				>
+			</File>
 			<File
 				RelativePath="..\..\include\chaiscript\dispatchkit\proxy_constructors.hpp"
 				>
@@ -237,6 +253,10 @@
 				RelativePath="..\..\include\chaiscript\dispatchkit\proxy_functions.hpp"
 				>
 			</File>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\proxy_functions_detail.hpp"
+				>
+			</File>
 			<File
 				RelativePath="..\..\include\chaiscript\dispatchkit\register_function.hpp"
 				>

msvc/test_module/test_module.vcproj

@@ -0,0 +1,198 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="test_module"
+	ProjectGUID="{775EDCC2-102F-4E75-A860-9AF398D04145}"
+	RootNamespace="test_module"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="2"
+			InheritedPropertySheets="..\chaiscript\Boost.vsprops"
+			UseOfMFC="0"
+			CharacterSet="0"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;TEST_MODULE_EXPORTS"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="2"
+			InheritedPropertySheets="..\chaiscript\Boost.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;TEST_MODULE_EXPORTS"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\test_module.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

run_unit_tests.sh

@@ -1,5 +1,6 @@
 #!/bin/bash
 
+
 successes=0
 failures=0
 
@@ -8,7 +9,7 @@ for file in unittests/*.chai
 do
   tstname=${file%.*}
 	tst="$tstname.txt"
-	./chaiscript_eval $file > /tmp/tstout.txt
+	LD_LIBRARY_PATH=. ./chaiscript_eval $file > /tmp/tstout.txt
 	diff $tst /tmp/tstout.txt
 	if [ "$?" -eq "0" ]
 	then

run_unit_tests_win.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+successes=0
+failures=0
+
+echo -n "Running unit tests"
+for file in unittests/*.chai
+do
+  tstname=${file%.*}
+	tst="$tstname.txt"
+	./chaiscript_eval $file > /tmp/tstout.txt
+        cat $tst > /tmp/tstmaster.txt
+        awk 'sub("$", "\r")' $tst > /tmp/tstmaster.txt
+	diff /tmp/tstmaster.txt /tmp/tstout.txt
+	if [ "$?" -eq "0" ]
+	then
+		echo -n "."
+		successes=$((successes+1))
+	else
+		echo "[from failed test $file]"
+		failures=$((failures+1))
+	fi
+done
+echo ""
+
+total=$((successes+failures))
+echo "$successes out of $total succeeded"

samples/if.chai

@@ -2,7 +2,7 @@ var i = 0
 if (i == 0) {
 	print("i is 0")
 }
-elseif (i == 1) {
+else if (i == 1) {
 	print("i is 1")
 }
 else {

src/example.cpp

@@ -22,14 +22,30 @@ void log(const std::string &module, const std::string &msg)
   std::cout << "[" << boost::posix_time::microsec_clock::local_time() << "] <" << module << "> " << msg << std::endl;
 }
 
+void bound_log(const std::string &msg)
+{
+  log(msg);
+}
+
+void hello_world(const chaiscript::Boxed_Value &o)
+{
+  std::cout << "Hello World" << std::endl;
+}
+
+void hello_constructor(const chaiscript::Boxed_Value &o)
+{
+  std::cout << "Hello Constructor" << std::endl;
+}
+
+
 struct System
 {
   std::map<std::string, boost::function<std::string (const std::string &) > > m_callbacks;
 
   void add_callback(const std::string &t_name, 
-      boost::shared_ptr<dispatchkit::Proxy_Function> t_func)
+      const chaiscript::Proxy_Function &t_func)
   {
-    m_callbacks[t_name] = dispatchkit::build_function_caller<std::string (const std::string &)>(t_func);
+    m_callbacks[t_name] = chaiscript::functor<std::string (const std::string &)>(t_func);
   }
 
 
@@ -45,48 +61,107 @@ struct System
   }
 };
 
+void take_shared_ptr(const boost::shared_ptr<const std::string> &p)
+{
+  std::cout << *p << std::endl;
+}
 
 int main(int argc, char *argv[]) {
+  using namespace chaiscript;
 
-
-  chaiscript::ChaiScript_Engine chai;
+  ChaiScript chai;
 
   //Create a new system object and share it with the chaiscript engine
   System system;
-  chai.get_eval_engine().add_object("system", boost::ref(system));
+  chai.add(var(&system), "system");
+
+  //Add a bound callback method
+  chai.add(fun(&System::add_callback, system), "add_callback_bound");
 
   //Register the two methods of the System structure.
-  dispatchkit::register_function(chai.get_eval_engine(), &System::add_callback, "add_callback");
-  dispatchkit::register_function(chai.get_eval_engine(), &System::do_callbacks, "do_callbacks");
+  chai.add(fun(&System::add_callback), "add_callback");
+  chai.add(fun(&System::do_callbacks), "do_callbacks");
+
+  chai.add(fun(&take_shared_ptr), "take_shared_ptr");
 
   // Let's use chaiscript to add a new lambda callback to our system. 
   // The function "{ 'Callback1' + x }" is created in chaiscript and passed into our C++ application
   // in the "add_callback" function of struct System the chaiscript function is converted into a 
   // boost::function, so it can be handled and called easily and type-safely
-  chai.evaluate_string("system.add_callback('#1', fun(x) { 'Callback1 ' + x });");
+  chai.eval("system.add_callback(\"#1\", fun(x) { \"Callback1 \" + x });");
   
   // Because we are sharing the "system" object with the chaiscript engine we have equal
   // access to it both from within chaiscript and from C++ code
   system.do_callbacks("TestString");
-  chai.evaluate_string("system.do_callbacks(\"TestString\");");
+  chai.eval("system.do_callbacks(\"TestString\");");
 
   // The log function is overloaded, therefore we have to give the C++ compiler a hint as to which
   // version we want to register. One way to do this is to create a typedef of the function pointer
   // then cast your function to that typedef.
   typedef void (*PlainLog)(const std::string &);
   typedef void (*ModuleLog)(const std::string &, const std::string &);
-  dispatchkit::register_function(chai.get_eval_engine(), PlainLog(&log), "log");
-  dispatchkit::register_function(chai.get_eval_engine(), ModuleLog(&log), "log");
+  chai.add(fun(PlainLog(&log)), "log");
+  chai.add(fun(ModuleLog(&log)), "log");
 
-  chai.evaluate_string("log('Test Message')");
-  chai.evaluate_string("log('Test Module', 'Test Message');");
+  chai.eval("log(\"Test Message\")");
+
+  // A shortcut to using eval is just to use the chai operator()
+  chai("log(\"Test Module\", \"Test Message\");");
 
   //Finally, it is possible to register any boost::function as a system function, in this 
   //way, we can, for instance add a bound member function to the system
-  chai.get_eval_engine().register_function(boost::function<void ()>(boost::bind(&System::do_callbacks, boost::ref(system), "Bound Test")), "do_callbacks");
+  chai.add(fun(&System::do_callbacks, boost::ref(system), "Bound Test"), "do_callbacks");
 
   //Call bound version of do_callbacks
-  chai.evaluate_string("do_callbacks()");
+  chai("do_callbacks()");
 
+  boost::function<void ()> caller = chai.functor<void ()>("fun() { system.do_callbacks(\"From Functor\"); }");
+  caller();
+
+
+  //If we would like a type-safe return value from all call, we can use
+  //the templated version of eval:
+  int i = chai.eval<int>("5+5");
+
+  std::cout << "5+5: " << i << std::endl;
+
+  //Add a new variable
+  chai("var scripti = 15");
+
+  //We can even get a handle to the variables in the system
+  int &scripti = chai.eval<int &>("scripti");
+
+  std::cout << "scripti: " << scripti << std::endl;
+  scripti *= 2;
+  std::cout << "scripti (updated): " << scripti << std::endl;
+  chai("print(\"Scripti from chai: \" + to_string(scripti))");
+
+  //To do: Add examples of handling Boxed_Values directly when needed
+
+  //Creating a functor on the stack and using it immediatly 
+  int x = chai.functor<int (int, int)>("fun (x, y) { return x + y; }")(5, 6);
+
+  log("Functor test output", boost::lexical_cast<std::string>(x));
+
+
+  //Ability to create our own container types when needed. std::vector and std::map are
+  //mostly supported currently
+  chai.add(bootstrap::vector_type<std::vector<int> >("IntVector"));
+
+
+  // Test ability to register a function that excepts a shared_ptr version of a type
+  chai("take_shared_ptr(\"Hello World as a shared_ptr\");");
+
+  chai.add(fun(&bound_log, std::string("Msg")), "BoundFun");
+
+  //Dynamic objects test
+  chai.add(chaiscript::Proxy_Function(new Dynamic_Object_Function("TestType", fun(&hello_world))), "hello_world");
+  chai.add(chaiscript::Proxy_Function(new Dynamic_Object_Constructor("TestType", fun(&hello_constructor))), "TestType");
+  chai.add(fun(boost::function<Boxed_Value (Dynamic_Object &)>(boost::bind(&Dynamic_Object_Attribute::func, "TestType", "attr", _1))), "attr");
+
+  chai.eval("var x = TestType()");
+  chai.eval("x.attr = \"hi\"");
+  chai.eval("print(x.attr)");
+  chai.eval("x.hello_world()");
 }
 

src/main.cpp

@@ -6,25 +6,51 @@
 
 #include <iostream>
 
+#include <list>
+
+#ifdef READLINE_AVAILABLE
+#include <readline/readline.h>
+#include <readline/history.h>
+#endif
+
 #include <chaiscript/chaiscript.hpp>
 
 void print_help() {
-    std::cout << "ChaiScript evaluator.  To evaluate and expression, type it and press <enter>." << std::endl;
+    std::cout << "ChaiScript evaluator.  To evaluate an expression, type it and press <enter>." << std::endl;
     std::cout << "Additionally, you can inspect the runtime system using:" << std::endl;
     std::cout << "  dump_system() - outputs all functions registered to the system" << std::endl;
     std::cout << "  dump_object(x) - dumps information about the given symbol" << std::endl;
 }
 
+std::string get_next_command() {
+#ifdef READLINE_AVAILABLE
+    char *input_raw;
+    input_raw = readline("eval> ");
+    add_history(input_raw);
+    return std::string(input_raw);
+#else
+    std::string retval;
+    std::cout << "eval> ";
+    std::getline(std::cin, retval);
+    return retval;
+#endif
+}
+
 int main(int argc, char *argv[]) {
     std::string input;
-    chaiscript::ChaiScript_Engine chai;
+    chaiscript::ChaiScript chai;
+
 
     if (argc < 2) {
-        std::cout << "eval> ";
-        std::getline(std::cin, input);
+        //std::cout << "eval> ";
+        //std::getline(std::cin, input);
+#ifdef READLINE_AVAILABLE
+        using_history();
+#endif
+        input = get_next_command();
         while (input != "quit") {
 
-            dispatchkit::Boxed_Value val;
+            chaiscript::Boxed_Value val;
 
             if (input == "help") {
                 print_help();
@@ -32,54 +58,31 @@ int main(int argc, char *argv[]) {
             else {
                 try {
                     //First, we evaluate it
-                    val = chai.evaluate_string(input);
+                    val = chai.eval(input);
 
                     //Then, we try to print the result of the evaluation to the user
-                    if (val.get_type_info().m_bare_type_info && *(val.get_type_info().m_bare_type_info) != typeid(void)) {
+                    if (!val.get_type_info().bare_equal(chaiscript::user_type<void>())) {
                         try {
-                            dispatchkit::dispatch(chai.get_eval_engine().get_function("print"), dispatchkit::Param_List_Builder() << val);
+                            chaiscript::dispatch(chai.get_eval_engine().get_function("print"), chaiscript::Param_List_Builder() << val);
                         }
                         catch (...) {
                             //If we can't, do nothing
                         }
                     }
                 }
-                catch (chaiscript::Parse_Error &pe) {
-                    std::cout << pe.reason << " in " << pe.filename << " at " << pe.position.line << ", " << pe.position.column << std::endl;
-                }
-                catch (chaiscript::Eval_Error &ee) {
-                    std::cout << ee.reason << std::endl;
-                }
                 catch (std::exception &e) {
                     std::cout << e.what() << std::endl;
                 }
             }
 
-            std::cout << "eval> ";
-            std::getline(std::cin, input);
+            input = get_next_command();
         }
     }
     else {
         for (int i = 1; i < argc; ++i) {
             std::string filename(argv[i]);
             try {
-              dispatchkit::Boxed_Value val = chai.evaluate_file(argv[i]);
-            }
-            catch (chaiscript::Parse_Error &pe) {
-                if (filename != std::string("__EVAL__")) {
-                    std::cout << pe.reason << " in " << pe.filename << " at " << pe.position.line << ", " << pe.position.column << std::endl;
-                }
-                else {
-                    std::cout << pe.reason << std::endl;
-                }
-            }
-            catch (chaiscript::Eval_Error &ee) {
-                if (filename != std::string("__EVAL__")) {
-                    std::cout << ee.reason << " in '" << ee.location->filename << "' at " << ee.location->start.line  << ", " << ee.location->start.column << std::endl;
-                }
-                else {
-                    std::cout << ee.reason << std::endl;
-                }
+              chaiscript::Boxed_Value val = chai.eval_file(argv[i]);
             }
             catch (std::exception &e) {
                 std::cout << e.what() << std::endl;

src/multithreaded.cpp

@@ -0,0 +1,38 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#include <iostream>
+
+#include <list>
+
+#include <chaiscript/chaiscript.hpp>
+#include <boost/thread.hpp>
+
+void do_work(chaiscript::ChaiScript &c)
+{
+//  c("use(\"work.chai\"); do_chai_work(num_iterations);");
+  c("use(\"work.chai\"); do_chai_work(10000);");
+}
+
+int main(int argc, char *argv[]) {
+    std::string input;
+    chaiscript::ChaiScript chai;
+
+    //chai.add_shared_object(chaiscript::Boxed_Value(10000), "num_iterations");
+
+    std::vector<boost::shared_ptr<boost::thread> > threads;
+
+    for (int i = 0; i < argc - 1; ++i)
+    {
+      threads.push_back(boost::shared_ptr<boost::thread>(new boost::thread(boost::bind(do_work, boost::ref(chai)))));
+    }
+
+    for (int i = 0; i < argc - 1; ++i)
+    {
+      threads[i]->join();
+    }
+}
+

src/stl_extra.cpp

@@ -0,0 +1,9 @@
+
+#include <chaiscript/chaiscript.hpp>
+#include <string>
+
+
+CHAISCRIPT_MODULE_EXPORT chaiscript::ModulePtr create_chaiscript_module_stl_extra()
+{
+  return chaiscript::bootstrap::list_type<std::list<chaiscript::Boxed_Value> >("List");
+}

src/test_module.cpp

@@ -0,0 +1,16 @@
+
+#include <chaiscript/chaiscript.hpp>
+#include <string>
+
+std::string hello_world()
+{
+  return "Hello World";
+}
+
+CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test()
+{
+  chaiscript::ModulePtr m(new chaiscript::Module());
+
+  m->add(chaiscript::fun(hello_world), "hello_world");
+  return m;
+}

src/work.chai

@@ -0,0 +1,10 @@
+def do_chai_work(num_iters)
+{
+  var i = 0;
+  for (var k = 0; k<num_iters * 10; ++k)
+  {
+    i += k;
+  }
+
+  print(i);
+}

unittests/block_start.chai

@@ -0,0 +1 @@
+{print("hello")}

unittests/block_start.txt

@@ -0,0 +1 @@
+hello

unittests/equ_shortform.chai

@@ -0,0 +1,4 @@
+var x=.5
+print(x)
+var y=-.5
+print(y)

unittests/equ_shortform.txt

@@ -0,0 +1,2 @@
+0.5
+-0.5

unittests/exception.chai

@@ -0,0 +1,9 @@
+var x = 1
+try {
+  throw(x)
+  x = 2
+}
+catch(e) {
+  x = e + 3
+}
+print(x)

unittests/exception.txt

@@ -0,0 +1 @@
+4

unittests/exception_finally.chai

@@ -0,0 +1,19 @@
+try {
+  throw(3)
+}
+catch(x) { 
+  print(x)
+}
+finally {
+  print("Finally #1")
+}
+
+try {
+  print("Safe")
+}
+catch {
+  print("Caught")
+}
+finally {
+  print("Finally #2")
+}

unittests/exception_finally.txt

@@ -0,0 +1,4 @@
+3
+Finally #1
+Safe
+Finally #2

unittests/exception_guards.chai

@@ -0,0 +1,28 @@
+for (var i = 2; i < 6; ++i) {
+  try {
+    throw(i)
+  }
+  catch(e) : e < 2 {
+    print("Catch 1: " + e.to_string())
+  }
+  catch(e) : e < 4 {
+    print("Catch 2: " + e.to_string())
+  }
+  catch(e) {
+    print("Catch 3: " + e.to_string())
+  }
+  catch {
+    print("This is never called")
+  }
+}
+
+try {
+  throw(3)
+}
+catch(e) : e < 3 
+{
+  print("Caught less than 3") 
+}
+catch {
+  print("Backup catch")
+}

unittests/exception_guards.txt

@@ -0,0 +1,5 @@
+Catch 2: 2
+Catch 2: 3
+Catch 3: 4
+Catch 3: 5
+Backup catch

unittests/float.chai

@@ -0,0 +1,2 @@
+print(1.2)
+print(.5)

unittests/float.txt

@@ -0,0 +1,2 @@
+1.2
+0.5

unittests/for_each_range.chai

@@ -0,0 +1,3 @@
+var v = [1,2,3];
+var r = range(v);
+for_each(r, print)

unittests/for_each_range.txt

@@ -0,0 +1,3 @@
+1
+2
+3

unittests/for_each_retro.chai

@@ -0,0 +1,3 @@
+var v = [1,2,3];
+var r = retro(range(v));
+for_each(r, print)

unittests/for_each_retro.txt

@@ -0,0 +1,3 @@
+3
+2
+1

unittests/function_reassignment.chai

@@ -0,0 +1,3 @@
+var x = `+`
+x = `-`
+print(x(5,4))

unittests/function_reassignment.txt

@@ -0,0 +1 @@
+1

unittests/if_elseif.chai

@@ -2,10 +2,10 @@ var i = 3
 if (i == 2) {
 	print("2")
 }
-elseif (i == 4) {
+else if (i == 4) {
 	print("4") 
 }
-elseif (i == 3) {
+else if (i == 3) {
 	print("3")
 }
 

unittests/if_elseif_else.chai

@@ -2,7 +2,7 @@ var i = 3
 if (i == 2) {
 	print("2")
 }
-elseif (i == 4) {
+else if (i == 4) {
 	print("4") 
 }
 else {

unittests/instring_eval.chai

@@ -0,0 +1,3 @@
+var bob = 5.5
+print("${bob}")
+print("val: ${5.5 + 2.5} and ${bob + 2.5}")

unittests/instring_eval.txt

@@ -0,0 +1,2 @@
+5.5
+val: 8 and 8

unittests/instring_eval_more.chai

@@ -0,0 +1,4 @@
+print("$ {4 + 5}")
+print("$${4+5}")
+print("Value: \${4 + 5}")
+print("Value: \$${4 + 5}")

unittests/instring_eval_more.txt

@@ -0,0 +1,4 @@
+$ {4 + 5}
+$9
+Value: ${4 + 5}
+Value: $9

unittests/invalid_function_assignment.chai

@@ -0,0 +1 @@
+clone = `-`

unittests/invalid_function_assignment.txt

@@ -0,0 +1 @@
+Error: "Mismatched types in equation" in 'unittests/invalid_function_assignment.chai' at (1, 7)

unittests/invalid_function_reassignment.chai

@@ -0,0 +1,2 @@
+var x = 5
+x = `-`

unittests/invalid_function_reassignment.txt

@@ -0,0 +1 @@
+Error: "Mismatched types in equation" in 'unittests/invalid_function_reassignment.chai' at (2, 3)

unittests/list_push_back.chai

@@ -0,0 +1,6 @@
+load_module("stl_extra")
+
+var x = List()
+x.push_back(3)
+x.push_back("A")
+print(x)

unittests/list_push_back.txt

@@ -0,0 +1 @@
+[3, A]

unittests/list_push_front.chai

@@ -0,0 +1,6 @@
+load_module("stl_extra")
+
+var x = List()
+x.push_front(3)
+x.push_front("A")
+print(x)

unittests/list_push_front.txt

@@ -0,0 +1 @@
+[A, 3]

unittests/load_module.chai

@@ -0,0 +1,2 @@
+load_module("test")
+print(hello_world())

unittests/load_module.txt

@@ -0,0 +1 @@
+Hello World

unittests/loop_inner_outer.chai

@@ -0,0 +1,10 @@
+var total = 0
+
+for (var i = 0; i < 10; ++i) {
+  for (var j = 0; j < 10; ++j) {
+    total += 1
+  }
+}
+
+print(total)
+    

unittests/loop_inner_outer.txt

@@ -0,0 +1 @@
+100

unittests/math_dec.chai

@@ -1 +1,2 @@
-print(--3)
+var i = 3
+print(--i)

unittests/math_inc.chai

@@ -1 +1,2 @@
-print(++3)
+var i = 3
+print(++i)

unittests/method_lambda.chai

@@ -0,0 +1,3 @@
+var addit = fun(x, y) { return x+y }
+
+print(3.addit(4))

unittests/method_lambda.txt

@@ -0,0 +1 @@
+7

unittests/multiline.chai

@@ -0,0 +1,7 @@
+var x = [1, 2,
+ 3, 4]
+
+print(x)
+
+print(map(x, 
+ fun(x) { x + 1 }))

unittests/multiline.txt

@@ -0,0 +1,2 @@
+[1, 2, 3, 4]
+[2, 3, 4, 5]

unittests/number_formats.chai

@@ -0,0 +1,2 @@
+print(012)
+print(0x1f)

unittests/number_formats.txt

@@ -0,0 +1,2 @@
+10
+31

unittests/object_attr.chai

@@ -0,0 +1,5 @@
+attr bob::z
+def bob::bob() { this.z = 10 }
+var x = bob()
+def bob::fred(x) { this.z - x }
+print(x.fred(3))

unittests/object_attr.txt

@@ -0,0 +1 @@
+7

unittests/object_clone.chai

@@ -0,0 +1,11 @@
+attr bob::z
+def bob::bob() { }
+
+var x = bob();
+x.z = 10;
+
+var y = clone(x);
+y.z = 20;
+
+print(x.z);
+print(y.z);

unittests/object_clone.txt

@@ -0,0 +1,2 @@
+10
+20

unittests/object_constructor_guards.chai

@@ -0,0 +1,5 @@
+def bob::bob(x) : x < 10 { print("constructed less than 10: " + x.to_string()) }
+def bob::bob(x) { print("constructed any old: " + x.to_string()) }
+
+var b = bob(12)
+var c = bob(3)

unittests/object_constructor_guards.txt

@@ -0,0 +1,2 @@
+constructed any old: 12
+constructed less than 10: 3

unittests/object_method_guards.chai

@@ -0,0 +1,7 @@
+def bob::bob() { }
+def bob::fred(e) : e < 10 { print("e less than 10") }
+def bob::fred(e) { print("e is some value") }
+
+var b = bob()
+b.fred(3)
+b.fred(12)

unittests/object_method_guards.txt

@@ -0,0 +1,2 @@
+e less than 10
+e is some value

unittests/operator_overload.chai

@@ -0,0 +1,8 @@
+def Bob::`+`(y) { this.x + y.x }
+def Bob::Bob() { }
+attr Bob::x
+var b = Bob()
+var c = Bob()
+b.x = 4
+c.x = 5
+print(b+c)

unittests/operator_overload.txt

@@ -0,0 +1 @@
+9

unittests/operator_overload2.chai

@@ -0,0 +1,8 @@
+def Bob::Bob() { }
+attr Bob::x
+def `-`(a, b) : is_type(a, "Bob") && is_type(b, "Bob") { a.x - b.x }
+var b = Bob()
+var c = Bob()
+b.x = 4
+c.x = 5
+print(b-c)

unittests/operator_overload2.txt

@@ -0,0 +1 @@
+-1

unittests/range.chai

@@ -0,0 +1,4 @@
+var x = [1, 2, 3, 4]
+var r = range(x)
+r.pop_front()
+print(r.front())

unittests/range.txt

@@ -0,0 +1 @@
+2

unittests/range_back.chai

@@ -0,0 +1,4 @@
+var x = [1, 2, 3, 4]
+var r = range(x)
+r.pop_back()
+print(r.back())

unittests/range_back.txt

@@ -0,0 +1 @@
+3

unittests/range_contains.chai

@@ -0,0 +1,5 @@
+var v = [1,2,"hi", "world", 5.5]
+print(v.contains(5.5));
+print(v.contains(0));
+print(v.contains(1, lt));
+print(v.contains(2, `==`));