Convert from #warning to #pragma message for notification of thread safety being disabled, so support more compilers portably

Strongly consider rolling this back when the issues are resolved between microsoft and boost. Also, needs to be tested across all platforms.

CMakeLists.txt

@@ -2,22 +2,44 @@ cmake_minimum_required(VERSION 2.6)
 
 project(chaiscript)
 
-SET (CMAKE_BUILD_TYPE gdb)
+FIND_LIBRARY(READLINE_LIBRARY NAMES readline PATH /usr/lib /usr/local/lib /opt/local/lib)
-SET (CMAKE_C_FLAGS_GDB " -Wall -ggdb")
-SET (CMAKE_CXX_FLAGS_GDB " -Wall -ggdb")
 
-#SET (CMAKE_BUILD_TYPE rel)
+MESSAGE(STATUS "Detecting readline support")
-#SET (CMAKE_C_FLAGS_REL " -Wall -O3")
+if (READLINE_LIBRARY)
-#SET (CMAKE_CXX_FLAGS_REL " -Wall -O3")
+    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

@@ -21,113 +21,13 @@
 #include "dispatchkit/bootstrap.hpp"
 #include "dispatchkit/bootstrap_stl.hpp"
 #include "dispatchkit/function_call.hpp"
-namespace chaiscript
+#include "dispatchkit/dynamic_object.hpp"
-{
-    /**
-     * 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 }; };
 
-    /**
+#ifdef  BOOST_HAS_DECLSPEC
-     * Helper lookup to get the name of each node type
+#define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)
-     */
+#else
-    const char *token_type_to_string(int tokentype) {
+#define CHAISCRIPT_MODULE_EXPORT extern "C" 
-        const char *token_types[] = { "Internal Parser Error", "Int", "Float", "Id", "Char", "Str", "Eol", "Fun_Call", "Arg_List", "Variable", "Equation", "Var_Decl",
+#endif
-            "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 during parsing or evaluation
-     */
-    struct Eval_Error : public std::runtime_error {
-        std::string reason;
-        File_Position 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), 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), position(where->start), 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) { }
-    };
-}
 
 #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
+#pragma message ("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,66 @@
+// 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(boost::mem_fn(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(boost::mem_fn(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, _));
+      }
+}
+
+#undef n
+#undef m
+
+#endif

include/chaiscript/dispatchkit/bootstrap.hpp

@@ -8,7 +8,9 @@
 #define __bootstrap_hpp__
 
 #include "dispatchkit.hpp"
+#include "dynamic_object.hpp"
 #include "register_function.hpp"
+#include "operators.hpp"
 
 namespace chaiscript 
 {
@@ -16,129 +18,6 @@ namespace chaiscript
   {
     namespace detail
     {
-      /**
-      * Set of helper functions for common operators
-      */
-      template<typename Ret, typename P1, typename P2>
-      Ret add(P1 p1, P2 p2)
-      {
-        return p1 + p2;
-      }
-
-      template<typename Ret, typename P1, typename P2>
-      Ret subtract(P1 p1, P2 p2)
-      {
-        return p1 - p2;
-      }
-
-      template<typename Ret, typename P1, typename P2>
-      Ret divide(P1 p1, P2 p2)
-      {
-        return p1 / p2;
-      }
-
-      template<typename Ret, typename P1, typename P2>
-      Ret multiply(P1 p1, P2 p2)
-      {
-        return p1 * p2;
-      }
-
-      template<typename Ret, typename P1, typename P2>
-      Ret modulus(P1 p1, P2 p2)
-      {
-        return p1 % p2;
-      }
-
-      template<typename P1, typename P2>
-      P1 &assign(P1 &p1, const P2 &p2)
-      {
-        return (p1 = p2);
-      }
-
-      template<typename P1, typename P2>
-      bool equals(P1 p1, P2 p2)
-      {
-        return p1 == p2;
-      }
-
-      template<typename P1, typename P2>
-      bool not_equals(P1 p1, P2 p2)
-      {
-        return p1 != p2;
-      }
-
-
-      template<typename P1, typename P2>
-      bool less_than(P1 p1, P2 p2)
-      {
-        return p1 < p2;
-      }
-
-      template<typename P1, typename P2>
-      bool greater_than(P1 p1, P2 p2)
-      {
-        return p1 > p2;
-      }
-
-      template<typename P1, typename P2>
-      bool less_than_equals(P1 p1, P2 p2)
-      {
-        return p1 <= p2;
-      }
-
-      template<typename P1, typename P2>
-      bool greater_than_equals(P1 p1, P2 p2)
-      {
-        return p1 >= p2;
-      }
-
-      template<typename P1, typename P2>
-      P1 &timesequal(P1 &p1, const P2 &p2)
-      {
-        return (p1 *= p2);
-      }
-
-      template<typename P1, typename P2>
-      P1 &dividesequal(P1 &p1, const P2 &p2)
-      {
-        return (p1 /= p2);
-      }
-
-      template<typename P1, typename P2>
-      P1 &addsequal(P1 &p1, const P2 &p2)
-      {
-        return (p1 += p2);
-      }
-
-      template<typename P1, typename P2>
-      P1 &subtractsequal(P1 &p1, const P2 &p2)
-      {
-        return (p1 -= p2);
-      }
-
-      template<typename P1>
-      P1 &prefixincrement(P1 &p1)
-      {
-        return (++p1);
-      }
-
-      template<typename P1>
-      P1 &prefixdecrement(P1 &p1)
-      {
-        return (--p1);
-      }
-
-      template<typename P1>
-      P1 &prefixnegate(P1 &p1)
-      {
-        return (p1);
-      }
-
-      template<typename P1>
-      P1 &prefixnot(P1 &p1)
-      {
-        return (p1);
-      }
 
       /* Special helpers for generating generic "POD" type operators
       * The POD operators are needed for general support of C++ POD
@@ -149,6 +28,7 @@ namespace chaiscript
       template<typename P1>
       P1 &assign_pod(P1 &p1, Boxed_POD_Value v)
       {
+
         if (v.m_isfloat)
         {
           return (p1 = P1(v.d));
@@ -169,7 +49,63 @@ namespace chaiscript
       }
 
       template<typename P1>
-      P1 &timesequal_pod(P1 &p1, Boxed_POD_Value r)
+      P1 &assign_bitwise_and_pod(P1 &p1, Boxed_POD_Value r)
+      {
+        if (!r.m_isfloat)
+        {
+          return p1 &= P1(r.i);
+        }
+
+        throw bad_boxed_cast("&= only valid for integer types");
+      }
+
+      template<typename P1>
+      P1 &assign_xor_pod(P1 &p1, Boxed_POD_Value r)
+      {
+        if (!r.m_isfloat)
+        {
+          return p1 ^= P1(r.i);
+        }
+
+        throw bad_boxed_cast("^= only valid for integer types");
+      }
+
+      template<typename P1>
+      P1 &assign_bitwise_or_pod(P1 &p1, Boxed_POD_Value r)
+      {
+        if (!r.m_isfloat)
+        {
+          return p1 |= P1(r.i);
+        }
+
+        throw bad_boxed_cast("&= only valid for integer types");
+      }
+
+      template<typename P1>
+      P1 &assign_difference_pod(P1 &p1, Boxed_POD_Value r)
+      {
+        if (r.m_isfloat)
+        {
+          return p1 -= P1(r.d);
+        } else {
+          return p1 -= P1(r.i);
+        }
+      }
+
+      template<typename P1>
+      P1 &assign_left_shift_pod(P1 &p1, Boxed_POD_Value r)
+      {
+        if (!r.m_isfloat)
+        {
+          return p1 <<= P1(r.i);
+        }
+
+        throw bad_boxed_cast("<<= only valid for integer types");
+      }
+
+
+      template<typename P1>
+      P1 &assign_product_pod(P1 &p1, Boxed_POD_Value r)
       {
         if (r.m_isfloat)
         {
@@ -180,7 +116,7 @@ namespace chaiscript
       }
 
       template<typename P1>
-      P1 &dividesequal_pod(P1 &p1, Boxed_POD_Value r)
+      P1 &assign_quotient_pod(P1 &p1, Boxed_POD_Value r)
       {
         if (r.m_isfloat)
         {
@@ -191,7 +127,31 @@ namespace chaiscript
       }
 
       template<typename P1>
-      P1 &addsequal_pod(P1 &p1, Boxed_POD_Value r)
+      P1 &assign_remainder_pod(P1 &p1, Boxed_POD_Value r)
+      {
+        if (!r.m_isfloat)
+        {
+          return p1 %= P1(r.i);
+        }
+
+        throw bad_boxed_cast("%= only valid for integer types");
+      }
+
+
+      template<typename P1>
+      P1 &assign_right_shift_pod(P1 &p1, Boxed_POD_Value r)
+      {
+        if (!r.m_isfloat)
+        {
+          return p1 >>= P1(r.i);
+        }
+
+        throw bad_boxed_cast(">>= only valid for integer types");
+      }
+
+
+      template<typename P1>
+      P1 &assign_sum_pod(P1 &p1, Boxed_POD_Value r)
       {
         if (r.m_isfloat)
         {
@@ -201,223 +161,66 @@ namespace chaiscript
         }
       }
 
-      template<typename P1>
-      P1 &subtractsequal_pod(P1 &p1, Boxed_POD_Value r)
-      {
-        if (r.m_isfloat)
-        {
-          return p1 -= P1(r.d);
-        } else {
-          return p1 -= P1(r.i);
-        }
-      }
     }
 
-    /**
-    * Add canonical form of "=" for type T
-    */
-    template<typename T>
-    ModulePtr oper_equals(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::equals<const T&, const T&>), "=");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "+" for type T
-    */
-    template<typename T>
-    ModulePtr oper_add(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::add<T, const T&, const T&>), "+");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "+=" for type T
-    */
-    template<typename T>
-    ModulePtr oper_add_equals(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::addsequal<T, T>), "+=");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "-" for type T
-    */
-    template<typename T>
-    ModulePtr oper_subtract(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::subtract<T, const T&, const T&>), "-");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "/" for type T
-    */
-    template<typename T>
-    ModulePtr oper_divide(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::divide<T, const T&, const T&>), "/");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "*" for type T
-    */
-    template<typename T>
-    ModulePtr oper_multiply(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::multiply<T, const T&, const T&>), "*");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "!=" for type T
-    */
-    template<typename T>
-    ModulePtr oper_not_equals(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::not_equals<const T&, const T&>), "!=");
-      return m;
-    }
-
-    /**
-    * Add user defined assignment operator for T = U
-    */
-    template<typename T, typename U>
-    ModulePtr oper_assign_overload(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::assign<T,U>), "=");
-      return m;
-    }
-
-
-    /**
-    * Add canonical form of "=" for type T
-    */
-    template<typename T>
-    ModulePtr oper_assign(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::assign<T,T>), "=");
-      return m;
-    }
-
-
-    /**
-    * Add assignment operator for T = POD.
-    */
-    template<typename T>
-    ModulePtr oper_assign_pod(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::assign_pod<T>), "=");
-      return m;
-    }
-
-
-    /**
-    * Add canonical form of "<" for type T
-    */
-    template<typename T>
-    ModulePtr oper_less_than(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::less_than<const T&, const T&>), "<");
-      return m;
-    }
-
-    /**
-    * Add canonical form of ">" for type T
-    */
-    template<typename T>
-    ModulePtr oper_greater_than(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::greater_than<const T&, const T&>), ">");
-      return m;
-    }
-
-    /**
-    * Add canonical form of "<=" for type T
-    */
-    template<typename T>
-    ModulePtr oper_less_than_equals(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::less_than_equals<const T&, const T&>), "<=");
-      return m;
-    }
-
-    /**
-    * Add canonical form of ">=" for type T
-    */
-    template<typename T>
-    ModulePtr oper_greater_than_equals(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::greater_than_equals<const T&, const T&>), ">=");
-      return m;
-    }
-
-    /**
-    * Add user defined comparison operators for T and R.
-    * Examples: T < R, T == R, etc.
-    */
-    template<typename T, typename R>
-    ModulePtr opers_comparison_overload(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::equals<const T&, const R&>), "==");
-      m->add(fun(&detail::not_equals<const T&, const R&>), "!=");
-      m->add(fun(&detail::less_than<const T&, const R&>), "<");
-      m->add(fun(&detail::greater_than<const T&, const R&>), ">");
-      m->add(fun(&detail::less_than_equals<const T&, const R&>), "<=");
-      m->add(fun(&detail::greater_than_equals<const T&, const R&>), ">=");
-      return m;
-    }
-
-    /**
-    * Add canonical forms of all comparison operators for type T
-    */
     template<typename T>
     ModulePtr opers_comparison(ModulePtr m = ModulePtr(new Module()))
     {
-      opers_comparison_overload<T, T>(m);
+      operators::equal<T>(m);
+      operators::greater_than<T>(m);
+      operators::greater_than_equal<T>(m);
+      operators::less_than<T>(m);
+      operators::less_than_equal<T>(m);
+      operators::not_equal<T>(m);
       return m;
     }
 
-    /**
-    * Add all arithmetic operators that return a type of Ret, taking
-    * a lhs of T and a rhs of R, when possible.
-    * examples: Ret = T + R;
-    * ++T
-    * T *= R;
-    */
-    template<typename Ret, typename T, typename R>
-    ModulePtr opers_arithmetic_overload(ModulePtr m = ModulePtr(new Module()))
-    {
-      m->add(fun(&detail::add<Ret, T, R>), "+");
-      m->add(fun(&detail::subtract<Ret, T, R>), "-");
-      m->add(fun(&detail::divide<Ret, T, R>), "/");
-      m->add(fun(&detail::multiply<Ret, T, R>), "*");
-      m->add(fun(&detail::timesequal<T, R>), "*=");
-      m->add(fun(&detail::dividesequal<T, R>), "/=");
-      m->add(fun(&detail::subtractsequal<T, R>), "-=");
-      m->add(fun(&detail::addsequal<T, R>), "+=");
-      m->add(fun(&detail::prefixincrement<T>), "++");
-      m->add(fun(&detail::prefixdecrement<T>), "--");
-      m->add(fun(&detail::prefixnegate<T>), "-");
-      m->add(fun(&detail::prefixnot<T>), "!");
-      return m;
-    }
-
-    /**
-    * Add arithmetic assign operators for POD types:
-    * example: POD *= T, POD /= T
-    */
     template<typename T>
-    ModulePtr opers_arithmetic_modify_pod(ModulePtr m = ModulePtr(new Module()))
+    ModulePtr opers_integer_arithmetic(ModulePtr m = ModulePtr(new Module()))
     {
-      m->add(fun(&detail::timesequal_pod<T>), "*=");
+      operators::assign_bitwise_and<T>(m);
-      m->add(fun(&detail::dividesequal_pod<T>), "/=");
+      operators::assign_xor<T>(m);
-      m->add(fun(&detail::subtractsequal_pod<T>), "-=");
+      operators::assign_bitwise_or<T>(m);
-      m->add(fun(&detail::addsequal_pod<T>), "+=");
+      operators::assign_difference<T>(m);
+      operators::assign_left_shift<T>(m);
+      operators::assign_product<T>(m);
+      operators::assign_quotient<T>(m);
+      operators::assign_remainder<T>(m);
+      operators::assign_right_shift<T>(m);
+      operators::assign_sum<T>(m);
+
+      operators::prefix_decrement<T>(m);
+      operators::prefix_increment<T>(m);
+      operators::addition<T>(m);
+      operators::unary_plus<T>(m);
+      operators::subtraction<T>(m);
+      operators::unary_minus<T>(m);
+      operators::bitwise_and<T>(m);
+      operators::bitwise_compliment<T>(m);
+      operators::bitwise_xor<T>(m);
+      operators::bitwise_or<T>(m);
+      operators::division<T>(m);
+      operators::left_shift<T>(m);
+      operators::multiplication<T>(m);
+      operators::remainder<T>(m);
+      operators::right_shift<T>(m);
+      return m;
+    }
+
+    template<typename T>
+    ModulePtr opers_float_arithmetic(ModulePtr m = ModulePtr(new Module()))
+    {
+      operators::assign_difference<T>(m);
+      operators::assign_product<T>(m);
+      operators::assign_quotient<T>(m);
+      operators::assign_sum<T>(m);
+
+      operators::addition<T>(m);
+      operators::unary_plus<T>(m);
+      operators::subtraction<T>(m);
+      operators::unary_minus<T>(m);
+      operators::division<T>(m);
+      operators::multiplication<T>(m);
       return m;
     }
 
@@ -463,16 +266,6 @@ namespace chaiscript
       return m;
     }
 
-    /**
-    * Add canonical forms of all arithmetic operators for type T
-    */
-    template<typename T>
-    ModulePtr opers_arithmetic(ModulePtr m = ModulePtr(new Module()))
-    {
-      opers_arithmetic_overload<T, T, T>(m);
-      return m;
-    }
-
     /**
     * to_string function for internal use. Uses ostream operator<<
     */
@@ -482,18 +275,6 @@ namespace chaiscript
       return boost::lexical_cast<std::string>(i);
     }
 
-    /**
-    * Boolean specialization of internal to_string function 
-    */
-    template<> std::string to_string(bool b)
-    {
-      if (b)
-      {
-        return "true";
-      } else {
-        return "false";
-      }
-    }
 
     /**
     * Internal function for converting from a string to a value
@@ -505,6 +286,17 @@ namespace chaiscript
       return boost::lexical_cast<Input>(i);
     }
 
+
+    /**
+     * Add assignment operator for T = POD.
+     */
+    template<typename T>
+      ModulePtr oper_assign_pod(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&detail::assign_pod<T>), "=");
+        return m;
+      }
+
     /**
     * Add all common functions for a POD type. All operators, and
     * common conversions
@@ -514,16 +306,52 @@ namespace chaiscript
     {
       m->add(user_type<T>(), name);
       basic_constructors<T>(name, m);
-      oper_assign<T>(m);
+      operators::assign<T>(m);
       oper_assign_pod<T>(m);
       construct_pod<T>(name, m);
-      opers_arithmetic<T>(m);
+
-      opers_arithmetic_modify_pod<T>(m);
+      m->add(fun(&detail::assign_sum_pod<T>), "+=");
+      m->add(fun(&detail::assign_difference_pod<T>), "-=");
+      m->add(fun(&detail::assign_product_pod<T>), "*=");
+      m->add(fun(&detail::assign_quotient_pod<T>), "/=");
+
       m->add(fun(&to_string<T>), "to_string");
       m->add(fun(&parse_string<T>), "to_" + name);
       return m;
     }
 
+    /**
+    * Add all common functions for a POD type. All operators, and
+    * common conversions
+    */
+    template<typename T>
+    ModulePtr bootstrap_integer_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
+    {
+      bootstrap_pod_type<T>(name, m);
+
+      m->add(fun(&detail::assign_bitwise_and_pod<T>), "&=");
+      m->add(fun(&detail::assign_xor_pod<T>), "^=");
+      m->add(fun(&detail::assign_bitwise_or_pod<T>), "|=");
+      m->add(fun(&detail::assign_left_shift_pod<T>), "<<=");
+      m->add(fun(&detail::assign_remainder_pod<T>), "%=");
+      m->add(fun(&detail::assign_right_shift_pod<T>), ">>=");
+
+      opers_integer_arithmetic<T>(m);
+      return m;
+    }
+
+    /**
+    * Add all common functions for a POD type. All operators, and
+    * common conversions
+    */
+    template<typename T>
+    ModulePtr bootstrap_float_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
+    {
+      bootstrap_pod_type<T>(name, m);
+      opers_float_arithmetic<T>(m);
+      return m;
+    }
+
     /**
     * "clone" function for a shared_ptr type. This is used in the case
     * where you do not want to make a deep copy of an object during cloning
@@ -532,22 +360,39 @@ namespace chaiscript
     * function variables.
     */
     template<typename Type>
-    boost::shared_ptr<Type> shared_ptr_clone(boost::shared_ptr<Type> f)
+    boost::shared_ptr<Type> shared_ptr_clone(const boost::shared_ptr<Type> &p)
     {
-      return f;
+      return p;
     }
 
+    /**
+     * Specific version of shared_ptr_clone just for Proxy_Functions
+     */
+    template<typename Type>
+    boost::shared_ptr<typename boost::remove_const<Type>::type> 
+        shared_ptr_unconst_clone(const boost::shared_ptr<typename boost::add_const<Type>::type> &p)
+    {
+      return boost::const_pointer_cast<typename boost::remove_const<Type>::type>(p);
+    }
+
+
+
     /**
     * Assignment function for shared_ptr objects, does not perform a copy of the
     * object pointed to, instead maintains the shared_ptr concept.
     * Similar to shared_ptr_clone. Used for Proxy_Function.
     */
     template<typename Type>
-    Boxed_Value ptr_assign(Boxed_Value lhs, boost::shared_ptr<Type> rhs)
+    Boxed_Value ptr_assign(Boxed_Value lhs, const boost::shared_ptr<typename boost::add_const<Type>::type> &rhs)
     {
-      lhs.assign(Boxed_Value(rhs));
+      if (lhs.is_undef() 
-
+          || (!lhs.get_type_info().is_const() && lhs.get_type_info().bare_equal(chaiscript::detail::Get_Type_Info<Type>::get())))
-      return lhs;
+      {
+        lhs.assign(Boxed_Value(rhs));
+        return lhs;
+      } else {
+        throw bad_boxed_cast("type mismatch in pointer assignment");
+      }
     }
 
     /**
@@ -562,7 +407,7 @@ namespace chaiscript
       */
       static Boxed_Value unknown_assign(Boxed_Value lhs, Boxed_Value rhs)
       {
-        if (lhs.is_unknown())
+        if (lhs.is_undef())
         {
           return (lhs.assign(rhs));
         } else {
@@ -580,28 +425,21 @@ namespace chaiscript
         std::cout << s << std::endl;
       }
 
-      /**
-      * Add all comparison operators for POD types
-      */
-      static void opers_comparison_pod(ModulePtr m = ModulePtr(new Module()))
-      {
-        m->add(fun(&detail::equals<Boxed_POD_Value, Boxed_POD_Value>), "==");
-        m->add(fun(&detail::not_equals<Boxed_POD_Value, Boxed_POD_Value>), "!=");
-        m->add(fun(&detail::less_than<Boxed_POD_Value, Boxed_POD_Value>), "<");
-        m->add(fun(&detail::greater_than<Boxed_POD_Value, Boxed_POD_Value>), ">");
-        m->add(fun(&detail::less_than_equals<Boxed_POD_Value, Boxed_POD_Value>), "<=");
-        m->add(fun(&detail::greater_than_equals<Boxed_POD_Value, Boxed_POD_Value>), ">=");
-      }
-
       /**
       * Add all arithmetic operators for PODs
       */
       static void opers_arithmetic_pod(ModulePtr m = ModulePtr(new Module()))
       {
-        m->add(fun(&detail::add<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "+");
+        m->add(fun(&operators::addition<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "+");
-        m->add(fun(&detail::subtract<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "-");
+        m->add(fun(&operators::subtraction<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "-");
-        m->add(fun(&detail::divide<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "/");
+        m->add(fun(&operators::bitwise_and<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "&");
-        m->add(fun(&detail::multiply<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "*");
+        m->add(fun(&operators::bitwise_xor<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "^");
+        m->add(fun(&operators::bitwise_or<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "|");
+        m->add(fun(&operators::division<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "/");
+        m->add(fun(&operators::left_shift<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "<<");
+        m->add(fun(&operators::multiplication<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "*");
+        m->add(fun(&operators::remainder<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "%");
+        m->add(fun(&operators::right_shift<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), ">>");
       }
 
       /**
@@ -616,9 +454,9 @@ namespace chaiscript
           throw arity_error(params.size(), 2);
         }
 
-        Proxy_Function f = boxed_cast<Proxy_Function >(params[0]);
+        Const_Proxy_Function f = boxed_cast<Const_Proxy_Function>(params[0]);
 
-        return Boxed_Value(Proxy_Function(new Bound_Function(f,
+        return Boxed_Value(Const_Proxy_Function(new Bound_Function(f,
           std::vector<Boxed_Value>(params.begin() + 1, params.end()))));
       }
 
@@ -633,17 +471,39 @@ namespace chaiscript
           throw arity_error(params.size(), 1);
         }
 
-        Proxy_Function f = boxed_cast<Proxy_Function >(params[0]);
+        Const_Proxy_Function f = boxed_cast<Const_Proxy_Function>(params[0]);
 
-        return Boxed_Value(f->types_match(std::vector<Boxed_Value>(params.begin() + 1, params.end())));
+        return Boxed_Value(f->call_match(std::vector<Boxed_Value>(params.begin() + 1, params.end())));
       }
 
+      static void throw_exception(const Boxed_Value &bv) {
+        throw bv;
+      }
+      
       static boost::shared_ptr<Dispatch_Engine> bootstrap2(boost::shared_ptr<Dispatch_Engine> e = boost::shared_ptr<Dispatch_Engine> (new Dispatch_Engine()))
       {
         e->add(user_type<void>(), "void");
         return e;
       }
 
+      static std::string what(const std::exception &e)
+      {
+        return e.what();
+      }
+
+      /**
+       * Boolean specialization of internal to_string function 
+       */
+      static std::string bool_to_string(bool b)
+      {
+        if (b)
+        {
+          return "true";
+        } else {
+          return "false";
+        }
+      }
+
     public:
       /**
       * perform all common bootstrap functions for std::string, void and POD types
@@ -655,25 +515,62 @@ namespace chaiscript
         m->add(user_type<Boxed_Value>(), "Object");
         m->add(user_type<Boxed_POD_Value>(), "PODObject");
         m->add(user_type<Proxy_Function>(), "function");
+        m->add(user_type<std::exception>(), "exception");
+
+        m->add(user_type<std::runtime_error>(), "runtime_error");
+        m->add(constructor<std::runtime_error (const std::string &)>(), "runtime_error");
+        m->add(fun(boost::function<std::string (const std::runtime_error &)>(&what)), "what");     
+
+        m->add(user_type<Dynamic_Object>(), "Dynamic_Object");
+        m->add(constructor<Dynamic_Object (const std::string &)>(), "Dynamic_Object");
+        m->add(fun(&Dynamic_Object::get_type_name), "get_type_name");
+        m->add(fun(&Dynamic_Object::get_attrs), "get_attrs");
+        m->add(fun(&Dynamic_Object::get_attr), "get_attr");
+        m->eval("def Dynamic_Object::clone() { var new_o := Dynamic_Object(this.get_type_name()); for_each(this.get_attrs(), bind(fun(new_o, x) { new_o.get_attr(x.first) = x.second; }, new_o, _) ); return new_o; }");
+
+        m->add(fun(&Boxed_Value::is_undef), "is_var_undef");
+        m->add(fun(&Boxed_Value::is_null), "is_var_null");
+        m->add(fun(&Boxed_Value::is_const), "is_var_const");
+        m->add(fun(&Boxed_Value::is_ref), "is_var_reference");
+        m->add(fun(&Boxed_Value::is_pointer), "is_var_pointer");
+        m->add(fun(&Boxed_Value::is_type), "is_type");
+
+        m->add(fun(&Boxed_Value::get_type_info), "get_type_info");
+        m->add(user_type<Type_Info>(), "Type_Info");
+
+
+        operators::equal<Type_Info>(m);
+
+        m->add(fun(&Type_Info::is_const), "is_type_const");
+        m->add(fun(&Type_Info::is_reference), "is_type_reference");
+        m->add(fun(&Type_Info::is_void), "is_type_void");
+        m->add(fun(&Type_Info::is_undef), "is_type_undef");
+        m->add(fun(&Type_Info::is_pointer), "is_type_pointer");
+        m->add(fun(&Type_Info::name), "cpp_name");
+        m->add(fun(&Type_Info::bare_name), "cpp_bare_name");
+        m->add(fun(&Type_Info::bare_equal), "bare_equal");
+
 
         basic_constructors<bool>("bool", m);
-        oper_assign<std::string>(m);
+        operators::assign<bool>(m);
-        oper_assign<bool>(m);
 
         m->add(fun(&to_string<const std::string &>), "internal_to_string");
-        m->add(fun(&to_string<bool>), "internal_to_string");
+        m->add(fun(&Bootstrap::bool_to_string), "internal_to_string");
         m->add(fun(&unknown_assign), "=");
+        m->add(fun(&throw_exception), "throw");
+        m->add(fun(&what), "what");
 
-        bootstrap_pod_type<double>("double", m);
+        bootstrap_float_type<double>("double", m);
-        bootstrap_pod_type<int>("int", m);
+        bootstrap_integer_type<int>("int", m);
-        bootstrap_pod_type<size_t>("size_t", m);
+        bootstrap_integer_type<size_t>("size_t", m);
-        bootstrap_pod_type<char>("char", m);
+        bootstrap_integer_type<char>("char", m);
-        bootstrap_pod_type<boost::int64_t>("int64_t", m);
+        bootstrap_integer_type<boost::int64_t>("int64_t", m);
 
-        opers_comparison_pod(m);
+        operators::logical_compliment<bool>(m);
+
+        opers_comparison<Boxed_POD_Value>(m);
         opers_arithmetic_pod(m);
 
-        m->add(fun(&detail::modulus<int, int, int>), "%");
 
         m->add(fun(&print), "print_string");
         m->add(fun(&println), "println_string");
@@ -681,7 +578,7 @@ namespace chaiscript
         m->add(Proxy_Function(new Dynamic_Proxy_Function(boost::bind(&bind_function, _1))), 
           "bind");
 
-        m->add(fun(&shared_ptr_clone<Proxy_Function_Base>), "clone");
+        m->add(fun(&shared_ptr_unconst_clone<Proxy_Function_Base>), "clone");
         m->add(fun(&ptr_assign<Proxy_Function_Base>), "=");
 
         m->add(Proxy_Function(new Dynamic_Proxy_Function(boost::bind(&call_exists, _1))), 

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -36,16 +36,6 @@ namespace chaiscript
       {
       }
 
-      Bidir_Range(typename Container::iterator itr)
-        : m_begin(itr), m_end(itr)
-      {
-      }
-
-      Bidir_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;
@@ -118,20 +108,10 @@ namespace chaiscript
     ModulePtr input_range_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
       m->add(user_type<Bidir_Range<ContainerType> >(), type + "_Range");
-      m->add(user_type<Retro<Bidir_Range<ContainerType> > >(), type + "_Retro_Range");
-      m->add(user_type<typename ContainerType::iterator>(), type+"_Iterator");
 
       copy_constructor<Bidir_Range<ContainerType> >(type + "_Range", m);
-      copy_constructor<Retro<Bidir_Range<ContainerType> > >(type + "_Retro_Range", m);
 
       m->add(constructor<Bidir_Range<ContainerType> (ContainerType &)>(), "range");
-      m->add(constructor<Bidir_Range<ContainerType> (typename ContainerType::iterator)>(), "range");
-
-      typedef std::pair<typename ContainerType::iterator, typename ContainerType::iterator> ItrPair;
-
-      m->add(constructor<Bidir_Range<ContainerType> (const ItrPair &)>(), "range");
-
-      m->add(user_type<ItrPair>(), type+"_Iterator_Pair");
 
       m->add(fun(&Bidir_Range<ContainerType>::empty), "empty");
       m->add(fun(&Bidir_Range<ContainerType>::pop_front), "pop_front");
@@ -139,45 +119,22 @@ namespace chaiscript
       m->add(fun(&Bidir_Range<ContainerType>::pop_back), "pop_back");
       m->add(fun(&Bidir_Range<ContainerType>::back), "back");
 
-      m->add(fun(&Retro<Bidir_Range<ContainerType> >::empty), "empty");
-      m->add(fun(&Retro<Bidir_Range<ContainerType> >::pop_front), "pop_front");
-      m->add(fun(&Retro<Bidir_Range<ContainerType> >::front), "front");
-      m->add(fun(&Retro<Bidir_Range<ContainerType> >::pop_back), "pop_back");
-      m->add(fun(&Retro<Bidir_Range<ContainerType> >::back), "back");
-
-      m->add(constructor<Retro<Bidir_Range<ContainerType> > (const Bidir_Range<ContainerType> &)>(), "retro");
-
-
-
       return m;
     } 
 
-    /**
-    * 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;
-    }
-
     /**
     * 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()))
+    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)>(indexoper(&ContainerType::at))), "[]");
+        fun(boost::function<typename ContainerType::reference (ContainerType *, int)>(boost::mem_fn(static_cast<indexoper>(&ContainerType::at)))), "[]");
-      m->add(
-        fun(boost::function<typename ContainerType::reference (ContainerType *, int)>(indexoper(&ContainerType::operator[]))), "at");
 
       return m;
     }
@@ -190,7 +147,7 @@ namespace chaiscript
     ModulePtr assignable_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
       basic_constructors<ContainerType>(type, m);
-      oper_assign<ContainerType>(m);
+      operators::assign<ContainerType>(m);
       return m;
     }
 
@@ -199,27 +156,11 @@ namespace chaiscript
     * http://www.sgi.com/tech/stl/Container.html
     */
     template<typename ContainerType>
-    ModulePtr container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    ModulePtr container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
     {
-      assignable_type<ContainerType>(type, m);
+      m->add(fun(boost::function<int (const ContainerType *)>(boost::mem_fn(&ContainerType::size))), "size");
-
+      m->add(fun<bool (ContainerType::*)() const>(&ContainerType::empty), "empty");
-      m->add(fun(&ContainerType::size), "size");
+      m->add(fun<void (ContainerType::*)()>(&ContainerType::clear), "clear");
-      m->add(fun(&ContainerType::max_size), "max_size");
-      m->add(fun(&ContainerType::empty), "empty");
-      m->add(fun(&ContainerType::clear), "clear");
-
-      return m;
-    }
-
-    /**
-    * 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;
     }
@@ -276,11 +217,8 @@ namespace chaiscript
     * http://www.sgi.com/tech/stl/Sequence.html
     */
     template<typename ContainerType>
-    ModulePtr sequence_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    ModulePtr sequence_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
     {
-      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))
       {
@@ -300,14 +238,11 @@ namespace chaiscript
     * 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()))
+    ModulePtr back_insertion_sequence_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
     {
-      sequence_type<ContainerType>(type, m);
-
-
       typedef typename ContainerType::reference (ContainerType::*backptr)();
 
-      m->add(fun(backptr(&ContainerType::back)), "back");
+      m->add(fun(static_cast<backptr>(&ContainerType::back)), "back");
 
       std::string push_back_name;
       if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
@@ -317,33 +252,33 @@ namespace chaiscript
         push_back_name = "push_back";
       }
 
-      m->add(fun(&ContainerType::push_back), push_back_name);
+ 	  typedef void (ContainerType::*pushback)(const typename ContainerType::value_type &);
+	  m->add(fun(static_cast<pushback>(&ContainerType::push_back)), push_back_name);
       m->add(fun(&ContainerType::pop_back), "pop_back");
       return m;
     }
 
-    /**
-    * 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()))
-    {
-      m->add(user_type<VectorType>(), type);
-      random_access_container_type<VectorType>(type, m);
-      back_insertion_sequence_type<VectorType>(type, m);
-      return m;
-    }
 
     /**
-    * Create a vector type with associated concepts
+     *Front insertion sequence
-    * http://www.sgi.com/tech/stl/Vector.html
+     *http://www.sgi.com/tech/stl/FrontInsertionSequence.html
-    */
+     */
     template<typename ContainerType>
-    ModulePtr associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+    ModulePtr front_insertion_sequence_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
-      forward_container_type<ContainerType>(type, m);
+      typedef typename ContainerType::reference (ContainerType::*frontptr)();
-      default_constructible_type<ContainerType>(type, m);
+
+      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;
     }
 
@@ -373,7 +308,6 @@ namespace chaiscript
     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;
@@ -384,40 +318,9 @@ namespace chaiscript
     * 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()))
+    ModulePtr unique_associative_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
     {
-      associative_container_type<ContainerType>(type, m);
+      m->add(fun(boost::function<int (const ContainerType *, const typename ContainerType::key_type &)>(boost::mem_fn(&ContainerType::count))), "count");
-      m->add(fun(&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 &);
-
-      reversible_container_type<ContainerType>(type, m);
-      associative_container_type<ContainerType>(type, m);
-      m->add(fun(eq_range(&ContainerType::equal_range)), "equal_range");
-
-      return m;
-    }
-
-    /**
-    * 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()))
-    {
-      sorted_associative_container_type<ContainerType>(type, m);
-      unique_associative_container_type<ContainerType>(type, m);
 
       return m;
     }
@@ -430,9 +333,55 @@ namespace chaiscript
     ModulePtr map_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
       m->add(user_type<MapType>(), type);
-      m->add(fun(&MapType::operator[]), "[]");
+
-      unique_sorted_associative_container_type<MapType>(type, m);
+	  typedef typename MapType::mapped_type &(MapType::*elemaccess)(const typename MapType::key_type &);
+      m->add(fun(static_cast<elemaccess>(&MapType::operator[])), "[]");
+
+      container_type<MapType>(type, m);
+      assignable_type<MapType>(type, m);
+      unique_associative_container_type<MapType>(type, m);
       pair_associative_container_type<MapType>(type, m);
+      input_range_type<MapType>(type, m);
+
+      return m;
+    }
+
+    /**
+     * 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()))
+    {
+      m->add(user_type<ListType>(), type);
+
+      front_insertion_sequence_type<ListType>(type, m);
+      back_insertion_sequence_type<ListType>(type, m);
+      sequence_type<ListType>(type, m);
+      container_type<ListType>(type, m);
+      default_constructible_type<ListType>(type, m);
+      assignable_type<ListType>(type, m);
+      input_range_type<ListType>(type, m);
+
+      return m;
+    }
+
+    /**
+    * 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()))
+    {
+      m->add(user_type<VectorType>(), type);
+
+      back_insertion_sequence_type<VectorType>(type, m);
+      sequence_type<VectorType>(type, m);
+      random_access_container_type<VectorType>(type, m);
+      container_type<VectorType>(type, m);
+      default_constructible_type<VectorType>(type, m);
+      assignable_type<VectorType>(type, m);
+      input_range_type<VectorType>(type, m);
 
       return m;
     }
@@ -445,11 +394,15 @@ namespace chaiscript
     ModulePtr string_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
     {
       m->add(user_type<String>(), type);
-      oper_add<String>(m);
+      operators::addition<String>(m);
-      oper_add_equals<String>(m);
+      operators::assign_sum<String>(m);
       opers_comparison<String>(m);
       random_access_container_type<String>(type, m);
       sequence_type<String>(type, m);
+      default_constructible_type<String>(type, m);
+      container_type<String>(type, m);
+      assignable_type<String>(type, m);
+      input_range_type<String>(type, m);
 
       //Special case: add push_back to string (which doesn't support other back_insertion operations
       std::string push_back_name;
@@ -461,13 +414,16 @@ namespace chaiscript
       }
       m->add(fun(&String::push_back), push_back_name);
 
-      typedef typename String::size_type (String::*find_func)(const String &, typename String::size_type) const;
+      typedef typename String::size_type (String::*find_func_ptr)(const String &, typename String::size_type) const;
-      m->add(fun(find_func(&String::find)), "find");
+
-      m->add(fun(find_func(&String::rfind)), "rfind");
+      typedef boost::function<int (const String *, const String &, int)> find_func;
-      m->add(fun(find_func(&String::find_first_of)), "find_first_of");
+
-      m->add(fun(find_func(&String::find_last_of)), "find_last_of");
+      m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::find)))), "find");
-      m->add(fun(find_func(&String::find_first_not_of)), "find_first_not_of");
+      m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::rfind)))), "rfind");
-      m->add(fun(find_func(&String::find_last_not_of)), "find_last_not_of");
+      m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::find_first_of)))), "find_first_of");
+      m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::find_last_of)))), "find_last_of");
+      m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::find_first_not_of)))), "find_first_not_of");
+      m->add(fun(find_func(boost::mem_fn(static_cast<find_func_ptr>(&String::find_last_not_of)))), "find_last_not_of");
 
       return m;
     }

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>
@@ -16,6 +17,7 @@
 #include <boost/bind.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/type_traits/add_const.hpp>
+#include <boost/integer_traits.hpp>
 
 namespace chaiscript 
 {
@@ -41,49 +43,27 @@ namespace chaiscript
        */
       struct Data
       {
-        /** 
-         * used to provide type-erased access to the internal boost::shared_ptr
-         * reference count information 
-         */
-        struct Shared_Ptr_Proxy
-        {
-          virtual ~Shared_Ptr_Proxy()
-          {
-          }
-
-          virtual bool unique(boost::any *) = 0;
-          virtual long use_count(boost::any *) = 0;
-        };
-
-        /** 
-         * Typed implementation of the Shared_Ptr_Proxy
-         */
         template<typename T>
-          struct Shared_Ptr_Proxy_Impl : Shared_Ptr_Proxy
+          static bool unique(boost::any *a)
-        {
-          virtual ~Shared_Ptr_Proxy_Impl()
-          {
-          }
-
-          virtual bool unique(boost::any *a)
           {
             boost::shared_ptr<T> *ptr = boost::any_cast<boost::shared_ptr<T> >(a);
             return ptr->unique();
           }
 
-          virtual long use_count(boost::any *a)
+        template<typename T>
+          static bool is_null(boost::any *a)
           {
             boost::shared_ptr<T> *ptr = boost::any_cast<boost::shared_ptr<T> >(a);
-            return ptr->use_count();
+            return ptr->get() == 0;
           }
-        };
 
         Data(const Type_Info &ti,
             const boost::any &to,
             bool tr,
-            const boost::shared_ptr<Shared_Ptr_Proxy> &t_proxy = boost::shared_ptr<Shared_Ptr_Proxy>())
+            const boost::function<bool (boost::any*)> &t_unique = boost::function<bool (boost::any*)>(),
+            const boost::function<bool (boost::any*)> &t_is_null = boost::function<bool (boost::any*)>())
           : m_type_info(ti), m_obj(to), 
-          m_is_ref(tr), m_ptr_proxy(t_proxy)
+          m_is_ref(tr), m_unique(t_unique), m_is_null(t_is_null)
         {
         }
 
@@ -92,20 +72,17 @@ namespace chaiscript
           m_type_info = rhs.m_type_info;
           m_obj = rhs.m_obj;
           m_is_ref = rhs.m_is_ref;
-          m_ptr_proxy = rhs.m_ptr_proxy;
+          m_unique = rhs.m_unique;
+          m_is_null = rhs.m_is_null;
 
           return *this;
         }
 
-        static bool get_false()
-        {
-          return false;
-        }
-
         Type_Info m_type_info;
         boost::any m_obj;
         bool m_is_ref;
-        boost::shared_ptr<Shared_Ptr_Proxy> m_ptr_proxy;
+        boost::function<bool (boost::any*)> m_unique;
+        boost::function<bool (boost::any*)> m_is_null;
       };
 
       /**
@@ -116,10 +93,15 @@ namespace chaiscript
        */
       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)
               );
@@ -134,21 +116,24 @@ namespace chaiscript
         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>()))
+                  &Data::unique<T>,
+                  &Data::is_null<T>)
                 );
 
-            std::map<const void *, Data>::iterator itr
+            std::map<std::pair<const void *, bool>, Data>::iterator itr
-              = m_ptrs.find(obj.get());
+              = 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;
@@ -163,14 +148,16 @@ namespace chaiscript
         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<const void *, Data >::iterator itr
+            std::map<std::pair<const void *, bool>, Data >::iterator itr
-              = m_ptrs.find(obj.get_pointer());
+              = m_ptrs.find(std::make_pair(obj.get_pointer(), b_const) );
 
             // 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
@@ -180,7 +167,7 @@ namespace chaiscript
             // 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.m_bare_type_info == data->m_type_info.m_bare_type_info)
+                && itr->second.m_type_info.bare_equal(data->m_type_info))
             {
               (*data) = (itr->second);
             } 
@@ -192,15 +179,16 @@ namespace chaiscript
           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>()))
+                  &Data::unique<T>,
+                  &Data::is_null<T>)
                 );
 
             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;
           }
 
@@ -217,15 +205,23 @@ namespace chaiscript
          * 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<const void *, Data >::iterator itr = m_ptrs.begin();
+          
+          ++m_cullcount;
+          if (force || m_cullcount % 20 != 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)
+            if (itr->second.m_unique(&itr->second.m_obj))
             {
-              std::map<const void *, Data >::iterator todel = itr;
+              std::map<std::pair<const void *, bool>, Data >::iterator todel = itr;
               ++itr;
               m_ptrs.erase(todel);
             } else {
@@ -234,7 +230,8 @@ namespace chaiscript
           }
         }
 
-        std::map<const void *, Data > m_ptrs;
+        std::map<std::pair<const void *, bool>, Data> m_ptrs;
+        int m_cullcount;
       };
 
     public:
@@ -268,14 +265,24 @@ namespace chaiscript
       {
       }
 
+      void swap(Boxed_Value &rhs)
+      {
+        std::swap(m_data, rhs.m_data);
+      }
+
       /**
        * Return a reference to the static global Object_Cache
        */
-      Object_Cache &get_object_cache()
+      static Object_Cache &get_object_cache()
       {
-        static Object_Cache oc;
+        static chaiscript::threading::Thread_Storage<Object_Cache> oc;
-        return oc;
+        return *oc;
-      }    
+      }   
+
+      static void clear_cache()
+      {
+        get_object_cache().m_ptrs.clear();
+      }
 
       /**
        * copy the values stored in rhs.m_data to m_data
@@ -292,7 +299,8 @@ namespace chaiscript
        */
       Boxed_Value &operator=(const Boxed_Value &rhs)
       {
-        m_data = rhs.m_data;
+        Boxed_Value temp(rhs);
+        swap(temp);
         return *this;
       }
 
@@ -304,9 +312,29 @@ namespace chaiscript
       /**
        * return true if the object is uninitialized
        */
-      bool is_unknown() const
+      bool is_undef() const
       {
-        return m_data->m_type_info.m_is_unknown;
+        return m_data->m_type_info.is_undef();
+      }
+
+      bool is_const() const
+      {
+        return m_data->m_type_info.is_const();
+      }
+
+      bool is_type(const Type_Info &ti) const
+      {
+        return m_data->m_type_info.bare_equal(ti);
+      }
+
+      bool is_null() const
+      {
+        if (m_data->m_is_null)
+        {
+          return m_data->m_is_null(&m_data->m_obj);
+        } else {
+          return false;
+        }
       }
 
       boost::any get() const
@@ -319,180 +347,242 @@ namespace chaiscript
         return m_data->m_is_ref;
       }
 
+      bool is_pointer() const
+      {
+        return !is_ref();
+      }
+
+
     private:
       boost::shared_ptr<Data> m_data;
   };
 
 
-  // Cast_Helper helper classes
+  namespace detail
+  {
+    // Cast_Helper helper classes
 
-  /**
+    /**
-   * Generic Cast_Helper, for casting to any type
+     * Generic Cast_Helper, for casting to any type
-   */
+     */
-  template<typename Result>
+    template<typename Result>
-    struct Cast_Helper
+      struct Cast_Helper
-    {
-      typedef typename boost::reference_wrapper<typename boost::add_const<Result>::type > Result_Type;
-
-      static Result_Type cast(const Boxed_Value &ob)
       {
-        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)
         {
-          if (!ob.get_type_info().m_is_const)
+          if (ob.is_ref())
           {
-            return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
+            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 {
-            return boost::any_cast<boost::reference_wrapper<const Result> >(ob.get());
+            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())));   
+            }
           }
-        } else {
-          return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));   
         }
-      }
+      };
-    };
 
-  /**
+    /**
-   * Cast_Helper for casting to a const & type
+     * Cast_Helper for casting to a const & type
-   */
+     */
-  template<typename Result>
+    template<typename Result>
-    struct Cast_Helper<const 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)
       {
-        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)
         {
-          if (!ob.get_type_info().m_is_const)
+          if (ob.is_ref())
           {
-            return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
+            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 {
-            return boost::any_cast<boost::reference_wrapper<const Result> >(ob.get());
+            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())));   
+            }
           }
-        } else {
-          return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));   
         }
-      }
+      };
-    };
 
-  /**
+    /**
-   * Cast_Helper for casting to a const * type
+     * Cast_Helper for casting to a const * type
-   */
+     */
-  template<typename Result>
+    template<typename Result>
-    struct Cast_Helper<const Result *>
+      struct Cast_Helper<const Result *>
-    {
-      typedef const Result * Result_Type;
-
-      static Result_Type cast(const Boxed_Value &ob)
       {
-        if (ob.is_ref())
+        typedef const Result * Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob)
         {
-          if (!ob.get_type_info().m_is_const)
+          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)
+        {
+          if (ob.is_ref())
           {
             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();
+            return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
           }
-        } else {
-          return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
         }
-      }
+      };
-    };
 
-  /**
+    /**
-   * Cast_Helper for casting to a * type
+     * Cast_Helper for casting to a & type
-   */
+     */
-  template<typename Result>
+    template<typename Result>
-    struct Cast_Helper<Result *>
+      struct Cast_Helper<Result &>
-    {
-      typedef Result * Result_Type;
-
-      static Result_Type cast(const Boxed_Value &ob)
       {
-        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())).get_pointer();
+          if (ob.is_ref())
-        } else {
+          {
-          return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
+            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 & type
+     * Cast_Helper for casting to a boost::shared_ptr<> type
-   */
+     */
-  template<typename Result>
+    template<typename Result>
-    struct Cast_Helper<Result &>
+      struct Cast_Helper<typename boost::shared_ptr<Result> >
-    {
-      typedef typename boost::reference_wrapper<Result> Result_Type;
-
-      static Result_Type cast(const Boxed_Value &ob)
       {
-        if (ob.is_ref())
+        typedef typename boost::shared_ptr<Result> Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob)
         {
-          return boost::any_cast<boost::reference_wrapper<Result> >(ob.get());
+          return boost::any_cast<boost::shared_ptr<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
+     * Cast_Helper for casting to a boost::shared_ptr<const> type
-   */
+     */
-  template<typename Result>
+    template<typename Result>
-    struct Cast_Helper<typename boost::shared_ptr<Result> >
+      struct Cast_Helper<typename boost::shared_ptr<const Result> >
-    {
-      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());
+        typedef typename boost::shared_ptr<const Result> Result_Type;
-      }
-    };
 
-  /**
+        static Result_Type cast(const Boxed_Value &ob)
-   * Cast_Helper for casting to a boost::shared_ptr<> type
+        {
-   */
+          if (!ob.get_type_info().is_const())
-  template<typename Result>
+          {
-    struct Cast_Helper<const boost::shared_ptr<Result> &>
+            return boost::const_pointer_cast<const Result>(boost::any_cast<boost::shared_ptr<Result> >(ob.get()));
-    {
+          } else {
-      typedef typename boost::shared_ptr<Result> Result_Type;
+            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 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 const boost::shared_ptr<const> & type
-   * Cast_Helper for casting to a Boxed_Value type
+     */
-   */
+    template<typename Result>
-  template<>
+      struct Cast_Helper<const boost::shared_ptr<const Result> &>
-    struct Cast_Helper<Boxed_Value>
-    {
-      typedef Boxed_Value Result_Type;
-
-      static Result_Type cast(const Boxed_Value &ob)
       {
-        return ob;    
+        typedef typename boost::shared_ptr<const Result> Result_Type;
-      }
-    };
 
-  /**
+        static Result_Type cast(const Boxed_Value &ob)
-   * Cast_Helper for casting to a const Boxed_Value & type
+        {
-   */
+          if (!ob.get_type_info().is_const())
-  template<>
+          {
-    struct Cast_Helper<const Boxed_Value &>
+            return boost::const_pointer_cast<const Result>(boost::any_cast<boost::shared_ptr<Result> >(ob.get()));
-    {
+          } else {
-      typedef Boxed_Value Result_Type;
+            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 Boxed_Value type
+     */
+    template<>
+      struct Cast_Helper<Boxed_Value>
       {
-        return ob;    
+        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,
@@ -502,7 +592,7 @@ namespace chaiscript
   {
     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")
       {
       }
 
@@ -517,7 +607,8 @@ namespace chaiscript
       {
         return m_what.c_str();
       }
-      const std::type_info *from;
+
+      Type_Info from;
       const std::type_info *to;
 
     private:
@@ -530,10 +621,10 @@ namespace chaiscript
    * 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));
     }
@@ -548,12 +639,12 @@ namespace chaiscript
     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_undef())
       {
         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))
       {
@@ -627,61 +718,153 @@ namespace chaiscript
     {
       if (!m_isfloat && !r.m_isfloat)
       {
-        return Boxed_Value(i + r.i);
+        return smart_size(i + r.i);
       }
 
       return Boxed_Value(((m_isfloat)?d:i) + ((r.m_isfloat)?r.d:r.i));
     }
 
-    Boxed_Value operator*(const Boxed_POD_Value &r) const
-    {
-      if (!m_isfloat && !r.m_isfloat)
-      {
-        return Boxed_Value(i * r.i);
-      }
-
-      return Boxed_Value(((m_isfloat)?d:i) * ((r.m_isfloat)?r.d:r.i));
-    }
-
-    Boxed_Value operator/(const Boxed_POD_Value &r) const
-    {
-      if (!m_isfloat && !r.m_isfloat)
-      {
-        return Boxed_Value(i / r.i);
-      }
-
-      return Boxed_Value(((m_isfloat)?d:i) / ((r.m_isfloat)?r.d:r.i));
-    }
-
     Boxed_Value operator-(const Boxed_POD_Value &r) const
     {
       if (!m_isfloat && !r.m_isfloat)
       {
-        return Boxed_Value(i - r.i);
+        return smart_size(i - r.i);
       }
 
       return Boxed_Value(((m_isfloat)?d:i) - ((r.m_isfloat)?r.d:r.i));
     }
 
+    Boxed_Value operator&(const Boxed_POD_Value &r) const
+    {
+      if (!m_isfloat && !r.m_isfloat)
+      {
+        return Boxed_Value(i & r.i);
+      }
+
+      throw bad_boxed_cast("& only valid for integer types");
+    }
+
+    Boxed_Value operator^(const Boxed_POD_Value &r) const
+    {
+      if (!m_isfloat && !r.m_isfloat)
+      {
+        return Boxed_Value(i ^ r.i);
+      }
+
+      throw bad_boxed_cast("^ only valid for integer types");
+    }
+
+    Boxed_Value operator|(const Boxed_POD_Value &r) const
+    {
+      if (!m_isfloat && !r.m_isfloat)
+      {
+        return Boxed_Value(i | r.i);
+      }
+
+      throw bad_boxed_cast("| only valid for integer types");
+    }
+
+    Boxed_Value operator/(const Boxed_POD_Value &r) const
+    {
+      if (!m_isfloat && !r.m_isfloat)
+      {
+        return smart_size(i / r.i);
+      }
+
+      return Boxed_Value(((m_isfloat)?d:i) / ((r.m_isfloat)?r.d:r.i));
+    }
+
+    Boxed_Value operator<<(const Boxed_POD_Value &r) const
+    {
+      if (!m_isfloat && !r.m_isfloat)
+      {
+        return smart_size(i << r.i);
+      }
+
+      throw bad_boxed_cast("<< only valid for integer types");
+    }
+
+
+    Boxed_Value operator*(const Boxed_POD_Value &r) const
+    {
+      if (!m_isfloat && !r.m_isfloat)
+      {
+        return smart_size(i * r.i);
+      }
+
+      return Boxed_Value(((m_isfloat)?d:i) * ((r.m_isfloat)?r.d:r.i));
+    }
+
+
+    Boxed_Value operator%(const Boxed_POD_Value &r) const
+    {
+      if (!m_isfloat && !r.m_isfloat)
+      {
+        return smart_size(i % r.i);
+      }
+
+      throw bad_boxed_cast("% only valid for integer types");
+    }
+
+    Boxed_Value operator>>(const Boxed_POD_Value &r) const
+    {
+      if (!m_isfloat && !r.m_isfloat)
+      {
+        return smart_size(i >> r.i);
+      }
+
+      throw bad_boxed_cast(">> only valid for integer types");
+    }
+
+    Boxed_Value smart_size(boost::int64_t i) const
+    {
+      if (i < boost::integer_traits<int>::const_min
+        || i > boost::integer_traits<int>::const_max)
+      {
+        return Boxed_Value(i);
+      } else {
+        return Boxed_Value(static_cast<int>(i));
+      }
+    }
+
+
+
     double d;
     boost::int64_t i;
 
     bool m_isfloat;
   };
 
-  /**
+  namespace detail
-   * Cast_Helper for converting from Boxed_Value to Boxed_POD_Value
+  {
-   */
+    /**
-  template<>
+     * Cast_Helper for converting from Boxed_Value to Boxed_POD_Value
-    struct Cast_Helper<Boxed_POD_Value>
+     */
-    {
+    template<>
-      typedef Boxed_POD_Value Result_Type;
+      struct Cast_Helper<Boxed_POD_Value>
-
-      static Result_Type cast(const Boxed_Value &ob)
       {
-        return Boxed_POD_Value(ob);
+        typedef Boxed_POD_Value Result_Type;
-      }
+
-    };
+        static Result_Type cast(const Boxed_Value &ob)
+        {
+          return Boxed_POD_Value(ob);
+        }
+      };
+
+    /**
+     * Cast_Helper for converting from Boxed_Value to Boxed_POD_Value
+     */
+    template<>
+      struct Cast_Helper<const Boxed_POD_Value &>
+      {
+        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)
@@ -689,15 +872,40 @@ namespace chaiscript
       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_Value's share the same internal type
+   * 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,6 +23,8 @@
 #include "type_info.hpp"
 #include "proxy_functions.hpp"
 #include "proxy_constructors.hpp"
+#include "dynamic_object.hpp"
+#include "../chaiscript_threading.hpp"
 
 namespace chaiscript
 {
@@ -40,16 +43,32 @@ namespace chaiscript
         return *this;
       }
 
-      template<typename T>
+
-        void apply(T &t) const
+      //Add a bit of chaiscript to eval during module implementation
+      Module &eval(const std::string &str)
+      {
+        m_evals.push_back(str);
+        return *this;
+      }
+
+      Module &add(const boost::shared_ptr<Module> &m)
+      {
+        m->apply(*this, *this);
+        return *m;
+      }
+
+      template<typename Eval, typename Engine>
+        void apply(Eval &t_eval, Engine &t_engine) const
         {
-          apply(m_typeinfos.begin(), m_typeinfos.end(), t);
+          apply(m_typeinfos.begin(), m_typeinfos.end(), t_engine);
-          apply(m_funcs.begin(), m_funcs.end(), t);
+          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
@@ -60,6 +79,18 @@ namespace chaiscript
             ++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;
@@ -73,7 +104,8 @@ namespace chaiscript
   {
     public:
       Dispatch_Function(const std::vector<std::pair<std::string, Proxy_Function > > &t_funcs)
-        : m_funcs(t_funcs)
+        : Proxy_Function_Base(std::vector<Type_Info>()),
+          m_funcs(t_funcs)
       {
       }
 
@@ -84,17 +116,17 @@ namespace chaiscript
 
       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, Proxy_Function > > function_vec;
 
@@ -103,7 +135,7 @@ namespace chaiscript
 
         while (begin != end)
         {
-          if (begin->second->types_match(types))
+          if (begin->second->call_match(vals))
           {
             return true;
           } else {
@@ -122,7 +154,37 @@ namespace chaiscript
     private:
       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() {}
+  };
+
+  /**
+   * Exception thrown in the case that a non-const object was added as a shared object
+   */
+  struct global_non_const : std::runtime_error
+  {
+    global_non_const() throw()
+      : std::runtime_error("a global object must be const")
+    {
+    }
+
+    virtual ~global_non_const() throw() {}
+  };
+
 
   /**
    * Main class for the dispatchkit. Handles management
@@ -133,12 +195,27 @@ namespace chaiscript
     public:
       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;
+
+      struct State
+      {
+        std::multimap<std::string, Proxy_Function> m_functions;
+        std::map<std::string, Boxed_Value> m_global_objects;
+        Type_Name_Map m_types;
+        std::set<std::string> m_reserved_words;
+      };
 
       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();
       }
 
       /**
@@ -146,15 +223,11 @@ namespace chaiscript
        */
       bool add(const Proxy_Function &f, const std::string &name)
       {
-        return add_function(f, name);
+        validate_object_name(name);
-      }
 
-      /**
+        StackData &stack = get_stack_data();
-       * Add a module's worth of registrations to the system
+        stack.get<0>().erase(name);
-       */
+        return add_function(f, name);
-      void add(const ModulePtr &m)
-      {
-        m->apply(*this);
       }
 
       /**
@@ -163,12 +236,16 @@ namespace chaiscript
        */
       void add(const Boxed_Value &obj, const std::string &name)
       {
-        for (int i = m_scopes.size()-1; i >= 0; --i)
+        validate_object_name(name);
+        StackData &stack = get_stack_data();
+
+        for (int i = stack.get<1>().size()-1; i >= 0; --i)
         {
-          std::map<std::string, Boxed_Value>::const_iterator itr = m_scopes[i].find(name);
+          std::map<std::string, Boxed_Value>::const_iterator itr = (stack.get<1>())[i].find(name);
-          if (itr != m_scopes[i].end())
+          if (itr != (stack.get<1>())[i].end())
           {
-            m_scopes[i][name] = Boxed_Value(obj);
+            stack.get<0>().erase(name);
+            (stack.get<1>())[i][name] = obj;
             return;
           }
         }
@@ -181,7 +258,31 @@ namespace chaiscript
        */
       void add_object(const std::string &name, const Boxed_Value &obj)
       {
-        m_scopes.back()[name] = 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 global shared object, between all the threads
+       */
+      void add_global_const(const Boxed_Value &obj, const std::string &name)
+      {
+        StackData &stack = get_stack_data();
+        validate_object_name(name);
+        if (!obj.is_const())
+        {
+          throw global_non_const();
+        }
+
+        stack.get<0>().erase(name);
+        
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::unique_lock<boost::shared_mutex> l(m_global_object_mutex);
+#endif
+
+        m_state.m_global_objects[name] = obj;
       }
 
       /**
@@ -189,7 +290,8 @@ namespace chaiscript
        */
       void new_scope()
       {
-        m_scopes.push_back(Scope());
+        StackData &stack = get_stack_data();
+        stack.get<1>().push_back(Scope());
       }
 
       /**
@@ -197,33 +299,58 @@ namespace chaiscript
        */
       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_state.m_functions;
+      }
+
       /**
        * Searches the current stack for an object of the given name
        * includes a special overload for the _ place holder object to
@@ -231,27 +358,57 @@ namespace chaiscript
        */
       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);
+          return itr->second;
-          if (itr != m_scopes[i].end())
+        }
+
+        // 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;
+          }
+        }
+
+        // Is the value we are looking for a global?
+        {
+#ifndef CHAISCRIPT_NO_THREADS
+          boost::shared_lock<boost::shared_mutex> l(m_global_object_mutex);
+#endif
+
+          itr = m_state.m_global_objects.find(name);
+          if (itr != m_state.m_global_objects.end())
+          {
+            cache[name] = itr->second;
             return itr->second;
           }
         }
 
-        std::vector<std::pair<std::string, std::multimap<std::string, 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(Proxy_Function(new Dispatch_Function(funcs)));
+          Boxed_Value f(Const_Proxy_Function(new Dispatch_Function(funcs)));
+          cache[name] = f;
+          return f;
         }
       }
 
@@ -260,7 +417,13 @@ namespace chaiscript
        */
       void add(const Type_Info &ti, const std::string &name)
       {
-        m_types.insert(std::make_pair(name, ti));
+        add_global_const(const_var(ti), name + "_type");
+       
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::unique_lock<boost::shared_mutex> l(m_mutex);
+#endif
+
+        m_state.m_types.insert(std::make_pair(name, ti));
       }
 
       /**
@@ -268,9 +431,13 @@ namespace chaiscript
        */
       Type_Info get_type(const std::string &name) const
       {
-        Type_Name_Map::const_iterator itr = m_types.find(name);
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::shared_lock<boost::shared_mutex> l(m_mutex);
+#endif
 
-        if (itr != m_types.end())
+        Type_Name_Map::const_iterator itr = m_state.m_types.find(name);
+
+        if (itr != m_state.m_types.end())
         {
           return itr->second;
         }
@@ -285,17 +452,21 @@ namespace chaiscript
        */
       std::string get_type_name(const Type_Info &ti) const
       {
-        for (Type_Name_Map::const_iterator itr = m_types.begin();
+#ifndef CHAISCRIPT_NO_THREADS
-             itr != m_types.end();
+        boost::shared_lock<boost::shared_mutex> l(m_mutex);
+#endif
+
+        for (Type_Name_Map::const_iterator itr = m_state.m_types.begin();
+             itr != m_state.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();
       }
 
       /**
@@ -303,7 +474,11 @@ namespace chaiscript
        */
       std::vector<std::pair<std::string, Type_Info> > get_types() const
       {
-        return std::vector<std::pair<std::string, Type_Info> >(m_types.begin(), m_types.end());
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::shared_lock<boost::shared_mutex> l(m_mutex);
+#endif
+
+        return std::vector<std::pair<std::string, Type_Info> >(m_state.m_types.begin(), m_state.m_types.end());
       }
 
       /**
@@ -312,46 +487,221 @@ namespace chaiscript
       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, Proxy_Function > > get_functions() const
       {
-        return std::vector<std::pair<std::string, 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_state.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);
+      }
+
+      Boxed_Value call_function(const std::string &t_name) const
+      {
+        return call_function(t_name, std::vector<Boxed_Value>());
+      }
+
+      Boxed_Value call_function(const std::string &t_name, const Boxed_Value &p1) const
+      {
+        std::vector<Boxed_Value> params;
+        params.push_back(p1);
+        return call_function(t_name, params);
+      }
+
+      Boxed_Value call_function(const std::string &t_name, const Boxed_Value &p1, const Boxed_Value &p2) const
+      {
+        std::vector<Boxed_Value> params;
+        params.push_back(p1);
+        params.push_back(p2);
+        return call_function(t_name, 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());
+      }
+
+      State get_state()
+      {
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::unique_lock<boost::shared_mutex> l(m_mutex);
+        boost::unique_lock<boost::shared_mutex> l2(m_global_object_mutex);
+#endif
+
+        return m_state;
+      }
+
+      void set_state(const State &t_state)
+      {
+#ifndef CHAISCRIPT_NO_THREADS
+        boost::unique_lock<boost::shared_mutex> l(m_mutex);
+        boost::unique_lock<boost::shared_mutex> l2(m_global_object_mutex);
+#endif
+
+        m_state = t_state;
+      }
+
+
     private:
       /**
-       * Implementation detail for searching for a function by name.
+       * Returns the current stack
-       * Looks for all registered global functions and optionally for an object
+       * make const/non const versions
-       * in scope with the same name
        */
-      std::vector<std::pair<std::string, std::multimap<std::string, Proxy_Function >::mapped_type> > 
+      StackData &get_stack_data() const
-        get_function_impl(const std::string &t_name, bool include_objects) const
       {
-        std::vector<std::pair<std::string, std::multimap<std::string, 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_state.m_reserved_words.find(name) != m_state.m_reserved_words.end())
         {
-          try {
+          throw reserved_word_error(name);
-            funcs.insert(funcs.end(), 
-              std::make_pair(
-                  t_name, 
-                  boxed_cast<std::multimap<std::string, Proxy_Function >::mapped_type>(get_object(t_name)))
-                );
-          } catch (const bad_boxed_cast &) {
-          } catch (const std::range_error &) {
-          }
         }
-
-        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);
-
-        funcs.insert(funcs.end(), range.first, range.second);
-        return funcs;
       }
 
       /**
@@ -361,8 +711,12 @@ namespace chaiscript
        */
       bool add_function(const Proxy_Function &f, const std::string &t_name)
       {
+#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);
+          = m_state.m_functions.equal_range(t_name);
 
         while (range.first != range.second)
         {
@@ -373,110 +727,38 @@ namespace chaiscript
           ++range.first;
         }
 
-        m_functions.insert(std::make_pair(t_name, f));
+        m_state.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_global_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;
+
+
+      State m_state;
 
-      std::multimap<std::string, Proxy_Function > m_functions;
-      Type_Name_Map m_types;
       Boxed_Value m_place_holder;
   };
 
-  /**
-   * Dump object info to stdout
-   */
-  void dump_object(Boxed_Value o, const Dispatch_Engine &e)
-  {
-    Type_Info ti = o.get_type_info();
-    std::cout << (ti.m_is_const?"const ":"") << e.get_type_name(ti) << std::endl;
-  }
-
-  /**
-   * Dump type info to stdout
-   */
-  void dump_type(const Type_Info &type, const Dispatch_Engine &e)
-  {
-    std::cout << (type.m_is_const?"const ":"") << e.get_type_name(type);
-  }
-
-  /**
-   * Dump function to stdout
-   */
-  void dump_function(const std::pair<const std::string, 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, Proxy_Function > > funcs = s.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, s);
-    }
-    std::cout << std::endl;
-  }
-
-  /**
-   * return true if the Boxed_Value matches the registered type by name
-   */
-  bool is_type(const Dispatch_Engine &e, const std::string &user_typename, Boxed_Value r)
-  {
-    try {
-      return e.get_type(user_typename) == r.get_type_info();
-    } catch (const std::range_error &) {
-      return false;
-    }
-  }
-
-  std::string type_name(const Dispatch_Engine &e, Boxed_Value obj)
-  {
-    return e.get_type_name(obj.get_type_info());
-  }
-
 }
 
 #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(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_hpp__
 #define __function_call_hpp__
 
@@ -20,50 +13,7 @@
 #include <string>
 #include <vector>
 #include "proxy_functions.hpp"
-
+#include "function_call_detail.hpp"
-namespace chaiscript
-{
-  /**
-   * 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, 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, 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 chaiscript
 {
@@ -80,7 +30,7 @@ namespace chaiscript
       functor(const std::vector<std::pair<std::string, Proxy_Function > > &funcs)
       {
         FunctionType *p=0;
-        return build_function_caller_helper(p, funcs);
+        return detail::build_function_caller_helper(p, funcs);
       }
 
   /**
@@ -118,39 +68,5 @@ namespace chaiscript
 
 }
 
-# endif
-#else
-# define n BOOST_PP_ITERATION()
-
-namespace chaiscript
-{
-  /**
-   * 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/function_call_detail.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
+
+#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, ~));
+      }
+
+  }
+}
+#undef n
+
+#endif
+

include/chaiscript/dispatchkit/handle_return.hpp

@@ -0,0 +1,127 @@
+// 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);
+      }
+    };
+  
+  template<typename Ret>
+    struct Handle_Return<const Ret &>
+    {
+      static Boxed_Value handle(const Ret &r)
+      {
+        return Boxed_Value(boost::cref(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));
+      }
+
+      static Boxed_Value handle(const Ret &r)
+      {
+        return Boxed_Value(boost::cref(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<const 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/operators.hpp

@@ -0,0 +1,442 @@
+#ifndef __CHAISCRIPT_OPERATORS_HPP__
+#define __CHAISCRIPT_OPERATORS_HPP__
+
+namespace chaiscript 
+{
+  namespace operators
+  {
+    template<typename Ret, typename L, typename R>
+      Ret assign(L l, R r)
+      {
+        return (l = r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret assign_bitwise_and(L l, R r)
+      {
+        return (l &= r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret assign_xor(L l, R r)
+      {
+        return (l ^= r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret assign_bitwise_or(L l, R r)
+      {
+        return (l |= r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret assign_difference(L l, R r)
+      {
+        return (l -= r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret assign_left_shift(L l, R r)
+      {
+        return (l <<= r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret assign_product(L l, R r)
+      {
+        return (l *= r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret assign_quotient(L l, R r)
+      {
+        return (l /= r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret assign_remainder(L l, R r)
+      {
+        return (l %= r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret assign_right_shift(L l, R r)
+      {
+        return (l >>= r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret assign_sum(L l, R r)
+      {
+        return (l += r);
+      }
+
+    template<typename Ret, typename L>
+      Ret prefix_decrement(L l)
+      {
+        return (--l);
+      }
+
+    template<typename Ret, typename L>
+      Ret prefix_increment(L l)
+      {
+        return (++l);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret equal(L l, R r)
+      {
+        return (l == r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret greater_than(L l, R r)
+      {
+        return (l > r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret greater_than_equal(L l, R r)
+      {
+        return (l >= r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret less_than(L l, R r)
+      {
+        return (l < r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret less_than_equal(L l, R r)
+      {
+        return (l <= r);
+      }
+
+    template<typename Ret, typename L>
+      Ret logical_compliment(L l)
+      {
+        return (!l);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret not_equal(L l, R r)
+      {
+        return (l != r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret addition(L l, R r)
+      {
+        return (l + r);
+      }
+
+    template<typename Ret, typename L>
+      Ret unary_plus(L l)
+      {
+        return (+l);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret subtraction(L l, R r)
+      {
+        return (l - r);
+      }
+
+    template<typename Ret, typename L>
+      Ret unary_minus(L l)
+      {
+        return (-l);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret bitwise_and(L l, R r)
+      {
+        return (l & r);
+      }
+
+    template<typename Ret, typename L>
+      Ret bitwise_compliment(L l)
+      {
+        return (~l);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret bitwise_xor(L l, R r)
+      {
+        return (l ^ r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret bitwise_or(L l, R r)
+      {
+        return (l | r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret division(L l, R r)
+      {
+        return (l / r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret left_shift(L l, R r)
+      {
+        return l << r;
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret multiplication(L l, R r)
+      {
+        return l * r;
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret remainder(L l, R r)
+      {
+        return (l % r);
+      }
+
+    template<typename Ret, typename L, typename R>
+      Ret right_shift(L l, R r)
+      {
+        return (l >> r);
+      }
+
+
+
+
+    template<typename T>
+      ModulePtr assign(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&assign<T &, T &, const T&>), "=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr assign_bitwise_and(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&assign_bitwise_and<T &, T &, const T&>), "&=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr assign_xor(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&assign_xor<T &, T &, const T&>), "^=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr assign_bitwise_or(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&assign_bitwise_or<T &, T &, const T&>), "|=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr assign_difference(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&assign_difference<T &, T &, const T&>), "-=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr assign_left_shift(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&assign_left_shift<T &, T &, const T&>), "<<=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr assign_product(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&assign_product<T &, T &, const T&>), "*=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr assign_quotient(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&assign_quotient<T &, T &, const T&>), "/=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr assign_remainder(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&assign_remainder<T &, T &, const T&>), "%=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr assign_right_shift(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&assign_right_shift<T &, T &, const T&>), ">>=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr assign_sum(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&assign_sum<T &, T &, const T&>), "+=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr prefix_decrement(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&prefix_decrement<T &, T &>), "--");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr prefix_increment(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&prefix_increment<T &, T &>), "++");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr equal(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&equal<bool, const T&, const T&>), "==");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr greater_than(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&greater_than<bool, const T&, const T&>), ">");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr greater_than_equal(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&greater_than_equal<bool, const T&, const T&>), ">=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr less_than(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&less_than<bool, const T&, const T&>), "<");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr less_than_equal(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&less_than_equal<bool, const T&, const T&>), "<=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr logical_compliment(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&logical_compliment<bool, const T &>), "!");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr not_equal(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&not_equal<bool, const T &, const T &>), "!=");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr addition(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&addition<T, const T &, const T &>), "+");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr unary_plus(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&unary_plus<T, const T &>), "+");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr subtraction(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&subtraction<T, const T &, const T &>), "-");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr unary_minus(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&unary_minus<T, const T &>), "-");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr bitwise_and(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&bitwise_and<T, const T &, const T &>), "&");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr bitwise_compliment(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&bitwise_compliment<T, const T &>), "~");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr bitwise_xor(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&bitwise_xor<T, const T &, const T &>), "^");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr bitwise_or(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&bitwise_or<T, const T &, const T &>), "|");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr division(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&division<T, const T &, const T &>), "/");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr left_shift(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&left_shift<T, const T &, const T &>), "<<");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr multiplication(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&multiplication<T, const T &, const T &>), "*");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr remainder(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&remainder<T, const T &, const T &>), "%");
+        return m;
+      }
+
+    template<typename T>
+      ModulePtr right_shift(ModulePtr m = ModulePtr(new Module()))
+      {
+        m->add(fun(&right_shift<T, const T &, const T &>), ">>");
+        return m;
+      }
+  }
+}
+
+#endif

include/chaiscript/dispatchkit/proxy_constructors.hpp

@@ -26,7 +26,7 @@ namespace chaiscript
     Proxy_Function constructor()
     {
       T *f = 0;
-      return (build_constructor_(f));
+      return (detail::build_constructor_(f));
     }
 }
 
@@ -35,29 +35,33 @@ namespace chaiscript
 
 namespace chaiscript
 {
-  /**
+  namespace detail
-   * A constructor function, used for creating a new object
+  {
-   * of a given type with a given set of params
+    /**
-   */
+     * A constructor function, used for creating a new object
-  template<typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
+     * of a given type with a given set of params
-    boost::shared_ptr<Class> constructor_( BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
+     */
-    {
+    template<typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param) >
-      return boost::shared_ptr<Class>(new Class( BOOST_PP_ENUM_PARAMS(n, p) ));
+      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
+     * Helper function for build a constructor function
-   * example:
+     * example:
-   * dispatchengine.register_function(build_constructor<MyClass, int, const std::string&>, "MyClass");
+     * 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
+     * \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) >
+    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)))
+      Proxy_Function build_constructor_(Class (*)(BOOST_PP_ENUM_PARAMS(n, Param)))
-    {
+      {
-      typedef boost::shared_ptr<Class> (sig)(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)>))));
+        return Proxy_Function(new Proxy_Function_Impl<sig>(boost::function<sig>(&(constructor_<Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param)>))));
-    }
+      }
+  }
 }
+#undef n
 
 #endif
 

include/chaiscript/dispatchkit/proxy_functions.hpp

@@ -4,109 +4,22 @@
 // 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) ,chaiscript::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) chaiscript::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/type_traits/add_reference.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <stdexcept>
 #include <vector>
+#include "proxy_functions_detail.hpp"
 
 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());
-      }
-    };
-
-  template<typename Ret>
-    struct Handle_Return<boost::shared_ptr<Ret> &>
-    {
-      Boxed_Value operator()(const boost::function<boost::shared_ptr<Ret> & ()> &f)
-      {
-        return Boxed_Value(f());
-      }
-    };
-
-  template<typename Ret>
-    struct Handle_Return<const boost::shared_ptr<Ret> &>
-    {
-      Boxed_Value operator()(const boost::function<const boost::shared_ptr<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<<
@@ -138,30 +51,6 @@ namespace chaiscript
     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 chaiscript
-{
   /**
    * Pure virtual base class for all Proxy_Function implementations
    * Proxy_Functions are a type erasure of type safe C++
@@ -174,14 +63,85 @@ namespace chaiscript
   {
     public:
       virtual ~Proxy_Function_Base() {}
-      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) = 0;
+      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const = 0;
-      virtual std::vector<Type_Info> get_param_types() const = 0;
+
+      std::vector<Type_Info> get_param_types() const { return m_types; }
+
       virtual bool operator==(const Proxy_Function_Base &) const = 0;
-      virtual bool types_match(const std::vector<Boxed_Value> &types) 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_undef() || vals[0].get_type_info().is_undef()
+                || 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
@@ -209,7 +169,8 @@ namespace chaiscript
           int t_arity=-1,
           const std::string &t_description = "",
           const Proxy_Function &t_guard = Proxy_Function())
-        : m_f(t_f), m_arity(t_arity), m_description(t_description), m_guard(t_guard)
+        : 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)
       {
       }
 
@@ -218,15 +179,15 @@ namespace chaiscript
         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))
+          return (m_arity < 0 || vals.size() == size_t(m_arity))
-            && test_guard(types);
+            && 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))
         {
@@ -243,23 +204,9 @@ namespace chaiscript
         } 
       }
 
-      virtual std::vector<Type_Info> get_param_types() const
+      virtual int get_arity() const
       {
-        std::vector<Type_Info> types;
+	return m_arity;
-
-        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;
       }
 
       virtual std::string annotation() const
@@ -284,6 +231,25 @@ namespace chaiscript
         }
       }
 
+      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;
@@ -307,9 +273,10 @@ namespace chaiscript
   class Bound_Function : public Proxy_Function_Base
   {
     public:
-      Bound_Function(const 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()))
       {
       }
 
@@ -320,13 +287,12 @@ namespace chaiscript
 
       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->call_match(build_param_list(vals));
-        return m_f->types_match(params);
       }
 
-      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));
       }
@@ -343,7 +309,7 @@ namespace chaiscript
         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;
@@ -356,7 +322,7 @@ namespace chaiscript
           }
 
           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;
           } 
@@ -369,9 +335,9 @@ namespace chaiscript
         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
@@ -380,8 +346,9 @@ namespace chaiscript
       }
 
     private:
-      Proxy_Function m_f;
+      Const_Proxy_Function m_f;
       std::vector<Boxed_Value> m_args;
+      int m_arity;
   };
 
   /**
@@ -394,7 +361,8 @@ namespace chaiscript
   {
     public:
       Proxy_Function_Impl(const boost::function<Func> &f)
-        : m_f(f)
+        : Proxy_Function_Base(build_param_type_list(static_cast<Func *>(0))),
+          m_f(f), m_dummy_func(0)
       {
       }
 
@@ -410,21 +378,25 @@ namespace chaiscript
         }
       }
  
-      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
       {
-        Func *f = 0;
+        return m_types.size() - 1;
-        return build_param_type_list(f);
       }
 
-      virtual bool types_match(const std::vector<Boxed_Value> &types) const
+
+      virtual bool call_match(const std::vector<Boxed_Value> &vals) const
       {
-        Func *f = 0;
+        if (int(vals.size()) != get_arity()) 
-        return compare_types(f, types);
+        {
+          return false;
+        }
+
+        return compare_types(m_types, vals) || compare_types_cast(m_dummy_func, vals);
       }
 
       virtual std::string annotation() const
@@ -434,6 +406,82 @@ namespace chaiscript
 
     private:
       boost::function<Func> m_f;
+      Func *m_dummy_func;
+  };
+
+  /**
+   * Attribute getter Proxy_Function implementation
+   */
+  template<typename T, typename Class>
+    class Attribute_Access : public Proxy_Function_Base
+  {
+    public:
+      Attribute_Access(T Class::* t_attr)
+        : Proxy_Function_Base(param_types()),
+          m_attr(t_attr)
+      {
+      }
+
+      virtual ~Attribute_Access() {}
+
+      virtual bool operator==(const Proxy_Function_Base &t_func) const
+      {
+        try {
+          const Attribute_Access<T, Class> &aa 
+            = dynamic_cast<const Attribute_Access<T, Class> &>(t_func);
+          return m_attr == aa.m_attr;
+        } catch (const std::bad_cast &) {
+          return false;
+        }
+      }
+ 
+      virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) const
+      {
+        if (params.size() == 1)
+        {
+          const Boxed_Value &bv = params[0];
+          if (bv.is_const())
+          {
+            const Class *o = boxed_cast<const Class *>(bv);
+            return Handle_Return<const typename boost::add_reference<T>::type>::handle(o->*m_attr);
+          } else {
+            Class *o = boxed_cast<Class *>(bv);
+            return Handle_Return<typename boost::add_reference<T>::type>::handle(o->*m_attr);
+          }
+        } else {
+          throw arity_error(params.size(), 1);
+        }       
+      }
+
+      virtual int get_arity() const
+      {
+        return 1;
+      }
+
+      virtual bool call_match(const std::vector<Boxed_Value> &vals) const
+      {
+        if (vals.size() != 1)
+        {
+          return false;
+        }
+
+        return vals[0].get_type_info().bare_equal(user_type<Class>());
+      }
+
+      virtual std::string annotation() const
+      {
+        return "";
+      }
+
+    private:
+      static std::vector<Type_Info> param_types()
+      {
+        std::vector<Type_Info> v;
+        v.push_back(user_type<T>());
+        v.push_back(user_type<Class>());
+        return v;
+      }
+      T Class::* m_attr;
   };
 
   /**
@@ -449,6 +497,11 @@ namespace chaiscript
     {
     }
 
+    dispatch_error(bool is_const) throw()
+      : std::runtime_error(std::string("No matching function to dispatch to") + (is_const?", parameter is const":""))
+      {
+      }
+
     virtual ~dispatch_error() throw() {}
   };
 
@@ -457,15 +510,17 @@ namespace chaiscript
    * 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, 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, Proxy_Function> >::const_iterator itr = funcs.begin();
+    while (begin != end)
-        itr != funcs.end();
-        ++itr)
     {
       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 &) {
@@ -474,75 +529,24 @@ namespace chaiscript
         //guard failed to allow the function to execute,
         //try again
       }
+      ++begin;
     }
-    throw dispatch_error();
+
+    throw dispatch_error(plist.empty()?false:plist[0].is_const());
+  }
+
+  /**
+   * 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 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(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(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,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
+
+#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;
+    }
+
+}
+
+#undef n
+
+#endif

include/chaiscript/dispatchkit/register_function.hpp

@@ -4,84 +4,91 @@
 // 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>
+#include <boost/function_types/is_member_object_pointer.hpp>
+#include <boost/function_types/is_member_function_pointer.hpp>
 
 namespace chaiscript
 {
+  namespace detail
+  {
+    template<bool Object, bool MemFn>
+      struct Fun_Helper
+      {
+        template<typename T>
+        static Proxy_Function go(T t)
+        {
+          return Proxy_Function(
+              new Proxy_Function_Impl<
+                  typename boost::function_types::function_type<boost::function_types::components<T> >::type> (
+                    boost::function< 
+                      typename boost::function_types::function_type<boost::function_types::components<T> >::type 
+                      >(t)));
+        }      
+      };
+
+    template<>
+      struct Fun_Helper<false, true>
+      {
+        template<typename T>
+        static Proxy_Function go(T t)
+        {
+          return Proxy_Function(
+              new Proxy_Function_Impl<
+                  typename boost::function_types::function_type<boost::function_types::components<T> >::type> (
+                    boost::function< 
+                      typename boost::function_types::function_type<boost::function_types::components<T> >::type 
+                    >(boost::mem_fn(t))));
+        }      
+      };
+
+
+    template<>
+      struct Fun_Helper<true, false>
+      {
+        template<typename T, typename Class>
+          static Proxy_Function go(T Class::* m)
+          {
+            return Proxy_Function(new Attribute_Access<T, Class>(m));
+          }
+      };
+
+  }
+
   template<typename T>
     Proxy_Function fun(const boost::function<T> &f)
     {
       return Proxy_Function(new Proxy_Function_Impl<T>(f));
     }
 
-
+  template<typename T>
-  /**
+    Proxy_Function fun(T t)
-   * Helper function for register_member function
-   */
-  template<typename T, typename Class>
-    T &get_member(T Class::* m, Class *obj)
     {
-      return (obj->*m);
+        return detail::Fun_Helper<boost::function_types::is_member_object_pointer<T>::value, boost::function_types::is_member_function_pointer<T>::value>::go(t);
     }
 
-  /**
+  template<typename T, typename Q>
-   * Automatically create a get_member helper function for an object 
+    Proxy_Function fun(T t, const Q &q)
-   * 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>
-    Proxy_Function fun(T Class::* m)
     {
-      return fun(boost::function<T& (Class *)>(boost::bind(&get_member<T, Class>, m, _1)));
+      return fun(bind_first(t, q));
     }
 
+  template<typename T, typename Q, typename R>
+    Proxy_Function fun(T t, const Q &q, const R &r)
+    {
+      return fun(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 chaiscript
-{
-  /**
-   * Register a global function of n parameters with name 
-   */
-  template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
-    Proxy_Function fun(Ret (*f)(BOOST_PP_ENUM_PARAMS(n, Param)))
-    {
-      return fun(boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))>(f));
-    }
-
-  /**
-   * 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)>
-    Proxy_Function fun(Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param)))
-    {
-      return fun(boost::function<Ret (Class* BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param))>(f));
-    }
-
-  /**
-   * 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)>
-    Proxy_Function fun(Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param))const)
-    {
-      return fun(boost::function<Ret (const Class* BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param))>(f));
-    }
-}
 
 #endif
 

include/chaiscript/dispatchkit/type_info.hpp

@@ -21,116 +21,171 @@ 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, 
+    public:
-        const std::type_info *t_ti, const std::type_info *t_bareti)
+      Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
-      : m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
+          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_type_info(t_ti), m_bare_type_info(t_bareti),
-      m_is_unknown(false)
+        m_is_undef(false)
-    {
+      {
-    }
+      }
 
-    Type_Info()
+      Type_Info()
-      : m_is_const(false), m_is_reference(false), m_is_pointer(false),
+        : 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_void(false), m_type_info(0), m_bare_type_info(0),
-      m_is_unknown(true)
+        m_is_undef(true)
-    {
+      {
-    }
+      }
 
-    Type_Info(const Type_Info &ti)
+      Type_Info(const Type_Info &ti)
-    : m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
+        : m_is_const(ti.m_is_const), m_is_reference(ti.m_is_reference), 
-      m_is_pointer(ti.m_is_pointer),
+        m_is_pointer(ti.m_is_pointer),
-      m_is_void(ti.m_is_void), m_type_info(ti.m_type_info), 
+        m_is_void(ti.m_is_void), m_type_info(ti.m_type_info), 
-      m_bare_type_info(ti.m_bare_type_info),
+        m_bare_type_info(ti.m_bare_type_info),
-      m_is_unknown(ti.m_is_unknown)
+        m_is_undef(ti.m_is_undef)
-    {
+      {
-    }
+      }
-    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;
-    }
 
-    bool operator==(const Type_Info &ti) const
+      Type_Info &operator=(const Type_Info &ti)
-    {
+      {
-      return ti.m_type_info == m_type_info;
+        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_undef = ti.m_is_undef;
+        return *this;
+      }
 
-    bool m_is_const;
+      bool operator<(const Type_Info &ti) const
-    bool m_is_reference;
+      {
-    bool m_is_pointer;
+        return m_type_info < ti.m_type_info;
-    bool m_is_void;
+      }
-    const std::type_info *m_type_info;
+
-    const std::type_info *m_bare_type_info;
+      bool operator==(const Type_Info &ti) const
-    bool m_is_unknown;
+      {
+        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_undef() const { return m_is_undef || m_bare_type_info == 0; }
+      bool is_pointer() const { return m_is_pointer; }
+
+      std::string name() const
+      {
+        if (m_type_info)
+        {
+          return m_type_info->name();
+        } else {
+          return "";
+        }
+      }
+
+      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_undef;
   };
 
-  /**
+  namespace detail
-   * Helper used to create a Type_Info object
+  {
-   */
+    /**
-  template<typename T>
+     * Helper used to create a Type_Info object
-    struct Get_Type_Info
+     */
-    {
+    template<typename T>
-      static Type_Info get()
+      struct Get_Type_Info
       {
-        return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
+        static Type_Info get()
-            boost::is_void<T>::value,
+        {
-            &typeid(T), 
+          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-            &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
+              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>
+    template<typename T>
-    struct Get_Type_Info<boost::shared_ptr<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, 
+        static Type_Info get()
-            boost::is_void<T>::value,
+        {
-            &typeid(boost::shared_ptr<T> ), 
+          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-            &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
+              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>
+    template<typename T>
-    struct Get_Type_Info<boost::reference_wrapper<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, 
+        static Type_Info get()
-            boost::is_void<T>::value,
+        {
-            &typeid(boost::reference_wrapper<T> ), 
+          return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, 
-            &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
+              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 Get_Type_Info<T>::get();
+    return detail::Get_Type_Info<T>::get();
   }
 
 
   template<typename T>
   Type_Info user_type()
   {
-    return Get_Type_Info<T>::get();
+    return detail::Get_Type_Info<T>::get();
   }
 
-
 }
 
 #endif

include/chaiscript/language/chaiscript_common.hpp

@@ -0,0 +1,137 @@
+// 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,
+        Comparison, Additive, Multiplicative, 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, Equality, Bitwise_And, Bitwise_Xor, Bitwise_Or, 
+        Logical_And, Logical_Or}; };
+
+    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",
+          "Comparison", "Additive", "Multiplicative", "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", "Equality", "Bitwise_And", "Bitwise_Xor", "Bitwise_Or", 
+          "Logical_And", "Logical_Or"};
+
+        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,33 +10,283 @@
 #include <exception>
 #include <fstream>
 
+#include <chaiscript/language/chaiscript_common.hpp>
 
-#include "chaiscript_prelude.hpp"
+#ifdef _POSIX_VERSION
-#include "chaiscript_parser.hpp"
+#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),
+            m_moduleptr(m_func.m_symbol())
+        {
+        }
+
+        DLModule m_dlmodule;
+        DLSym<Create_Module_Func> m_func;
+        ModulePtr m_moduleptr;
+    };
+#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),
+            m_moduleptr(m_func.m_symbol())
+        {
+        }
+
+        DLModule m_dlmodule;
+        DLSym<Create_Module_Func> m_func;
+        ModulePtr m_moduleptr;
+    };
+
+#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;
+        std::set<std::string> active_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 char *filename = "__EVAL__") {
+        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;
-            parser.clear_match_stack();
 
-            try {
+            // Keep a cache of all loaded filenames and use the char * from this cache to pass 
-                if (parser.parse(input, filename)) {
+            // to the parser. This is so that the parser does not have the overhead of passing 
-                    //parser.show_match_stack();
+            // around and copying strings
-                    value = eval_token<Eval_Engine>(engine, parser.ast());
+            // 
+            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;
                 }
             }
-            catch (const Return_Value &rv) {
+
-                value = rv.retval;
+            if (!internal)
+            {
+                engine.sync_cache();
             }
 
             return value;
@@ -45,16 +295,86 @@ namespace chaiscript
         /**
          * Evaluates the given boxed string, used during eval() inside of a script
          */
-        const Boxed_Value internal_eval(const std::vector<Boxed_Value> &vals) {
+        const Boxed_Value internal_eval(const std::string &e) {
-            return do_eval(boxed_cast<std::string>(vals.at(0)));
+            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_global_const(const Boxed_Value &bv, const std::string &name)
+        {
+            engine.add_global_const(bv, name);
+            return *this;
+        }
+
+        struct State
+        {
+            std::set<std::string> loaded_files;
+            typename Eval_Engine::State engine_state;
+            std::set<std::string> active_loaded_modules;
+        };
+
+        /**
+         * Returns a state object that represents the current
+         * set of loaded files, the set of global variables and
+         * the set of initialized functions
+         */
+        State get_state()
+        {
+#ifndef CHAISCRIPT_NO_THREADS
+            boost::lock_guard<boost::recursive_mutex> l(use_mutex);
+            boost::shared_lock<boost::shared_mutex> l2(mutex);
+#endif
+
+            State s;
+            s.loaded_files = loaded_files;
+            s.engine_state = engine.get_state();
+            s.active_loaded_modules = active_loaded_modules;
+            return s;
+        }
+
+        /**
+         * Restores the state from a saved State object.
+         */
+        void set_state(const State &t_state)
+        {
+#ifndef CHAISCRIPT_NO_THREADS
+            boost::lock_guard<boost::recursive_mutex> l(use_mutex);
+            boost::shared_lock<boost::shared_mutex> l2(mutex);
+#endif
+
+            loaded_files = t_state.loaded_files;
+            active_loaded_modules = t_state.active_loaded_modules;
+            engine.set_state(t_state.engine_state);
+        }
+
         /**
          * Adds an object to the system: type, function, object
          */
@@ -70,11 +390,65 @@ namespace chaiscript
          */
         ChaiScript_System &add(const ModulePtr &p)
         {
-            engine.add(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;
+                active_loaded_modules.insert(t_module_name);
+                add(lm->m_moduleptr);
+            } else if (active_loaded_modules.count(t_module_name) == 0) {
+                active_loaded_modules.insert(t_module_name);
+                add(loaded_modules[t_module_name]->m_moduleptr);
+            } else {
+                engine.sync_cache();
+            }
+        }
+
+
         /**
          * Helper for calling script code as if it were native C++ code
          * example:
@@ -117,12 +491,11 @@ namespace chaiscript
         /**
          * Helper function for loading a file
          */
-        std::string load_file(const char *filename) {
+        std::string load_file(const std::string &filename) {
-            std::ifstream infile (filename, std::ios::in | std::ios::ate);
+            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: " + filename);
-                throw std::runtime_error("Can not open: " + fname);
             }
 
             std::streampos size = infile.tellg();
@@ -141,23 +514,49 @@ namespace chaiscript
          */
         void build_eval_system() {
             using namespace bootstrap;
-            engine.add(Bootstrap::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.add(fun(boost::function<void ()>(boost::bind(&dump_system, boost::ref(engine)))), "dump_system");
+            add(Bootstrap::bootstrap());
-            engine.add(fun(boost::function<void (Boxed_Value)>(boost::bind(&dump_object, _1, boost::ref(engine)))), "dump_object");
-            engine.add(fun(boost::function<bool (Boxed_Value, const std::string &)>(boost::bind(&is_type, boost::ref(engine), _2, _1))),
-                "is_type");
 
-            engine.add(fun(boost::function<std::string (Boxed_Value)>(boost::bind(&chaiscript::type_name, boost::ref(engine), _1))),
+            engine.add(fun(&Eval_Engine::dump_system, boost::ref(engine)), "dump_system");
-                "type_name");
+            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");
 
-            engine.add(vector_type<std::vector<Boxed_Value> >("Vector"));
+            engine.add(fun(&Eval_Engine::get_type_name, boost::ref(engine)), "name");
-            engine.add(string_type<std::string>("string"));
+
-            engine.add(map_type<std::map<std::string, Boxed_Value> >("Map"));
+
-            engine.add(pair_type<std::pair<Boxed_Value, Boxed_Value > >("Pair"));
+            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");
 
-            engine.add(Proxy_Function(
-                  new Dynamic_Proxy_Function(boost::bind(&ChaiScript_System<Eval_Engine>::internal_eval, boost::ref(*this), _1), 1)), "eval");
 
             do_eval(chaiscript_prelude, "standard prelude");
         }
@@ -176,7 +575,7 @@ namespace chaiscript
         /**
          * Loads the file specified by filename, evaluates it, and returns the result
          */
-        Boxed_Value eval_file(const char *filename) {
+        Boxed_Value eval_file(const std::string &filename) {
             return do_eval(load_file(filename), filename);
         }
 
@@ -184,7 +583,7 @@ namespace chaiscript
          * Loads the file specified by filename, evaluates it, and returns the as the specified type
          */
         template<typename T>
-        T eval_file(const char *filename) {
+        T eval_file(const std::string &filename) {
             return boxed_cast<T>(do_eval(load_file(filename), filename));
         }
     };

include/chaiscript/language/chaiscript_prelude.hpp

@@ -9,277 +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 new(x) { eval(type_name(x))(); } \
+def lt(l, r) { if (call_exists(`<`, l, r)) { l < r } else { type_name(l) < type_name(r) } } \n\
-def clone(x) { eval(type_name(x))(x); } \
+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) { \
+def to_string(x) : call_exists(first, x) && call_exists(second, x) { \n\
-  "<" + x.first.to_string() + ", " + x.second.to_string() + ">"; \
+  "<" + 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"){ \
+def to_string(x) : call_exists(range, x) && !x.is_type("string"){ \n\
-  "[" + x.join(", ") + "]"; \
+  "[" + x.join(", ") + "]"; \n\
-}\
+}\n\
 # Basic to_string function\n\
-def to_string(x) { \
+def to_string(x) { \n\
-  internal_to_string(x); \
+  internal_to_string(x); \n\
-}\
+}\n\
 # Prints to console with no carriage return\n\
-def puts(x) { \
+def puts(x) { \n\
-  print_string(x.to_string()); \
+  print_string(x.to_string()); \n\
-} \
+} \n\
 # Prints to console with carriage return\n\
-def print(x) { \
+def print(x) { \n\
-  println_string(x.to_string()); \
+  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) : 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) {\
+def reverse(container) {\n\
-  var retval = new(container); \
+  var retval = new(container); \n\
-  var r = retro(range(container)); \
+  var r = range(container); \n\
-  while (!r.empty()) { \
+  while (!r.empty()) { \n\
-    retval.push_back(r.front()); \
+    retval.push_back(r.back()); \n\
-    r.pop_front(); \
+    r.pop_back(); \n\
-  } \
+  } \n\
-  retval; \
+  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) { \
+def for_each(container, func) : call_exists(range, container) { \n\
-  var range = range(container); \
+  var t_range = range(container); \n\
-  while (!range.empty()) { \
+  while (!t_range.empty()) { \n\
-    func(range.front()); \
+    func(t_range.front()); \n\
-    range.pop_front(); \
+    t_range.pop_front(); \n\
-  } \
+  } \n\
-} \
+} \n\
-def back_inserter(container) { \
+def back_inserter(container) { \n\
-  bind(push_back, container, _);     \
+  bind(push_back, container, _);     \n\
-}\
+}\n\
-\
+\n\
-def map(container, func, inserter) : call_exists(range, container) { \
+def contains(container, item, compare_func) : call_exists(range, container) { \n\
-  var range = range(container); \
+  var t_range = range(container); \n\
-  while (!range.empty()) { \
+  while (!t_range.empty()) { \n\
-    inserter(func(range.front())); \
+    if ( compare_func(t_range.front(), item) ) { return true; } \n\
-    range.pop_front(); \
+    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) { \
+def map(container, func) { \n\
-  var retval = new(container); \
+  var retval = new(container); \n\
-  map(container, func, back_inserter(retval));\
+  map(container, func, back_inserter(retval));\n\
-  retval;\
+  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){ \
+def foldl(container, func, initial) : call_exists(range, container){ \n\
-  var retval = initial; \
+  var retval = initial; \n\
-  var range = range(container); \
+  var range = range(container); \n\
-  while (!range.empty()) { \
+  while (!range.empty()) { \n\
-    retval = (func(range.front(), retval)); \
+    retval = (func(range.front(), retval)); \n\
-    range.pop_front(); \
+    range.pop_front(); \n\
-  } \
+  } \n\
-  retval; \
+  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) } \
+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) { \
+def concat(x, y) : call_exists(clone, x) { \n\
-  var retval = x; \
+  var retval = x; \n\
-  var len = y.size(); \
+  var len = y.size(); \n\
-  var i = 0; \
+  var i = 0; \n\
-  while (i < len) { \
+  while (i < len) { \n\
-    retval.push_back(y[i]); \
+    retval.push_back(y[i]); \n\
-    ++i; \
+    ++i; \n\
-  } \
+  } \n\
-  retval; \
+  retval; \n\
-} \
+} \n\
-def take(container, num, inserter) : call_exists(range, container) { \
+def take(container, num, inserter) : call_exists(range, container) { \n\
-  var r = range(container); \
+  var r = range(container); \n\
-  var i = num; \
+  var i = num; \n\
-  while ((i > 0) && (!r.empty())) { \
+  while ((i > 0) && (!r.empty())) { \n\
-    inserter(r.front()); \
+    inserter(r.front()); \n\
-    r.pop_front(); \
+    r.pop_front(); \n\
-    --i; \
+    --i; \n\
-  } \
+  } \n\
-} \
+} \n\
 # Returns a new container with the given number of elements taken from the container\n\
-def take(container, num) {\
+def take(container, num) {\n\
-  var retval = new(container); \
+  var retval = new(container); \n\
-  take(container, num, back_inserter(retval)); \
+  take(container, num, back_inserter(retval)); \n\
-  retval; \
+  retval; \n\
-}\
+}\n\
-def take_while(container, f, inserter) : call_exists(range, container) { \
+def take_while(container, f, inserter) : call_exists(range, container) { \n\
-  var r = range(container); \
+  var r = range(container); \n\
-  while ((!r.empty()) && f(r.front())) { \
+  while ((!r.empty()) && f(r.front())) { \n\
-    inserter(r.front()); \
+    inserter(r.front()); \n\
-    r.pop_front(); \
+    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) {\
+def take_while(container, f) {\n\
-  var retval = new(container); \
+  var retval = new(container); \n\
-  take_while(container, f, back_inserter(retval)); \
+  take_while(container, f, back_inserter(retval)); \n\
-  retval;\
+  retval;\n\
-}\
+}\n\
-def drop(container, num, inserter) : call_exists(range, container) { \
+def drop(container, num, inserter) : call_exists(range, container) { \n\
-  var r = range(container); \
+  var r = range(container); \n\
-  var i = num; \
+  var i = num; \n\
-  while ((i > 0) && (!r.empty())) { \
+  while ((i > 0) && (!r.empty())) { \n\
-    r.pop_front(); \
+    r.pop_front(); \n\
-    --i; \
+    --i; \n\
-  } \
+  } \n\
-  while (!r.empty()) { \
+  while (!r.empty()) { \n\
-    inserter(r.front()); \
+    inserter(r.front()); \n\
-    r.pop_front(); \
+    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) {\
+def drop(container, num) {\n\
-  var retval = new(container); \
+  var retval = new(container); \n\
-  drop(container, num, back_inserter(retval)); \
+  drop(container, num, back_inserter(retval)); \n\
-  retval; \
+  retval; \n\
-}\
+}\n\
-def drop_while(container, f, inserter) : call_exists(range, container) { \
+def drop_while(container, f, inserter) : call_exists(range, container) { \n\
-  var r = range(container); \
+  var r = range(container); \n\
-  while ((!r.empty())&& f(r.front())) { \
+  while ((!r.empty())&& f(r.front())) { \n\
-    r.pop_front(); \
+    r.pop_front(); \n\
-  } \
+  } \n\
-  while (!r.empty()) { \
+  while (!r.empty()) { \n\
-    inserter(r.front()); \
+    inserter(r.front()); \n\
-    r.pop_front(); \
+    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) {\
+def drop_while(container, f) {\n\
-  var retval = new(container); \
+  var retval = new(container); \n\
-  drop_while(container, f, back_inserter(retval)); \
+  drop_while(container, f, back_inserter(retval)); \n\
-  retval; \
+  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) { \
+def reduce(container, func) : container.size() >= 2 && call_exists(range, container) { \n\
-  var r = range(container); \
+  var r = range(container); \n\
-  var retval = r.front(); \
+  var retval = r.front(); \n\
-  r.pop_front(); \
+  r.pop_front(); \n\
-  retval = func(retval, r.front()); \
+  retval = func(retval, r.front()); \n\
-  r.pop_front(); \
+  r.pop_front(); \n\
-  while (!r.empty()) { \
+  while (!r.empty()) { \n\
-    retval = func(retval, r.front()); \
+    retval = func(retval, r.front()); \n\
-    r.pop_front(); \
+    r.pop_front(); \n\
-  } \
+  } \n\
-  retval; \
+  retval; \n\
-} \
+} \n\
 # Returns a string of the elements in container delimited by the second value string\n\
-def join(container, delim) { \
+def join(container, delim) { \n\
-  var retval = ""; \
+  var retval = ""; \n\
-  var range = range(container); \
+  var range = range(container); \n\
-  if (!range.empty()) { \
+  if (!range.empty()) { \n\
-    retval += to_string(range.front()); \
+    retval += to_string(range.front()); \n\
-    range.pop_front(); \
+    range.pop_front(); \n\
-    while (!range.empty()) { \
+    while (!range.empty()) { \n\
-      retval += delim; \
+      retval += delim; \n\
-      retval += to_string(range.front()); \
+      retval += to_string(range.front()); \n\
-      range.pop_front(); \
+      range.pop_front(); \n\
-    } \
+    } \n\
-  } \
+  } \n\
-  retval; \
+  retval; \n\
-} \
+} \n\
-def filter(container, f, inserter) : call_exists(range, container) { \
+def filter(container, f, inserter) : call_exists(range, container) { \n\
-  var r = range(container); \
+  var r = range(container); \n\
-  while (!r.empty()) { \
+  while (!r.empty()) { \n\
-    if (f(r.front())) { \
+    if (f(r.front())) { \n\
-      inserter(r.front()); \
+      inserter(r.front()); \n\
-    } \
+    } \n\
-    r.pop_front(); \
+    r.pop_front(); \n\
-  } \
+  } \n\
-} \
+} \n\
 # Returns a new Vector which match the second value function\n\
-def filter(container, f) { \
+def filter(container, f) { \n\
-  var retval = new(container); \
+  var retval = new(container); \n\
-  filter(container, f, back_inserter(retval));\
+  filter(container, f, back_inserter(retval));\n\
-  retval;\
+  retval;\n\
-}\
+}\n\
-def generate_range(x, y, inserter) { \
+def generate_range(x, y, inserter) { \n\
-  var i = x; \
+  var i = x; \n\
-  while (i <= y) { \
+  while (i <= y) { \n\
-    inserter(i); \
+    inserter(i); \n\
-    ++i; \
+    ++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) { \
+def generate_range(x, y) { \n\
-  var retval = Vector(); \
+  var retval = Vector(); \n\
-  generate_range(x,y,back_inserter(retval)); \
+  generate_range(x,y,back_inserter(retval)); \n\
-  retval; \
+  retval; \n\
-}\
+}\n\
 # Returns a new Vector with the first value to the second value as its elements\n\
-def collate(x, y) { \
+def collate(x, y) { \n\
-  [x, y]; \
+  [x, y]; \n\
-} \
+} \n\
-def zip_with(f, x, y, inserter) : call_exists(range, x) && call_exists(range, y) { \
+def zip_with(f, x, y, inserter) : call_exists(range, x) && call_exists(range, y) { \n\
-  var r_x = range(x); \
+  var r_x = range(x); \n\
-  var r_y = range(y); \
+  var r_y = range(y); \n\
-  while (!r_x.empty() && !r_y.empty()) { \
+  while (!r_x.empty() && !r_y.empty()) { \n\
-    inserter(f(r_x.front(), r_y.front())); \
+    inserter(f(r_x.front(), r_y.front())); \n\
-    r_x.pop_front(); \
+    r_x.pop_front(); \n\
-    r_y.pop_front(); \
+    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) { \
+def zip_with(f, x, y) { \n\
-  var retval = Vector(); \
+  var retval = Vector(); \n\
-  zip_with(f,x,y,back_inserter(retval)); \
+  zip_with(f,x,y,back_inserter(retval)); \n\
-  retval;\
+  retval;\n\
-}\
+}\n\
 # Returns a new Vector which joins matching elements of the first and second\n\
-def zip(x, y) { \
+def zip(x, y) { \n\
-  zip_with(collate, x, y); \
+  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) { \
+def string::find(substr) : is_type(substr, "string") { \n\
-  int(find(str, substr, size_t(0))); \
+  int(find(this, substr, 0)); \n\
-} \
+} \n\
 # Returns the position of last match of the second value string in the first value string\n\
-def rfind(str, substr) { \
+def string::rfind(substr) : is_type(substr, "string") { \n\
-  int(rfind(str, substr, size_t(-1))); \
+  int(rfind(this, substr, -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) { \
+def string::find_first_of(list) : is_type(list, "string") { \n\
-  int(find_first_of(str, list, size_t(0))); \
+  int(find_first_of(this, list, 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) { \
+def string::find_last_of(list) : is_type(list, "string") { \n\
-  int(find_last_of(str, list, size_t(-1))); \
+  int(find_last_of(this, list, -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) { \
+def string::find_first_not_of(list) : is_type(list, "string") { \n\
-  int(find_first_not_of(str, list, size_t(0))); \
+  int(find_first_not_of(this, list, 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) { \
+def string::find_last_not_of(list) : is_type(list, "string") { \n\
-  int(find_last_not_of(str, list, size_t(-1))); \
+  int(find_last_not_of(this, list, -1)); \n\
-} \
+} \n\
-def ltrim(str) { \
+def string::ltrim() { \n\
-  drop_while(str, fun(x) { x == ' ' || x == '\t' }); \
+  drop_while(this, fun(x) { x == ' ' || x == '\t' }); \n\
-} \
+} \n\
-def rtrim(str) { \
+def string::rtrim() { \n\
-  reverse(drop_while(reverse(str), fun(x) { x == ' ' || x == '\t' })); \
+  reverse(drop_while(reverse(this), fun(x) { x == ' ' || x == '\t' })); \n\
-} \
+} \n\
-def trim(str) { \
+def string::trim() { \n\
-  ltrim(rtrim(str)); \
+  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

@@ -42,7 +42,7 @@
 			<Tool
 				Name="VCCLCompilerTool"
 				Optimization="0"
-				AdditionalIncludeDirectories="C:\Programming\chaiscript\trunk\include"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
 				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
@@ -117,6 +117,7 @@
 				Name="VCCLCompilerTool"
 				Optimization="2"
 				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="&quot;$(ProjectDir)\..\..\include&quot;"
 				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
 				RuntimeLibrary="2"
 				EnableFunctionLevelLinking="true"

msvc/chaiscript/Boost.vsprops

@@ -6,7 +6,7 @@
 	>
 	<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"
@@ -14,6 +14,6 @@
 	/>
 	<Tool
 		Name="VCLinkerTool"
-		AdditionalLibraryDirectories="C:\Programming\Boost\lib"
+		AdditionalLibraryDirectories="C:\Boost\lib;C:\Programming\Boost\lib"
 	/>
 </VisualStudioPropertySheet>

msvc/chaiscript/chaiscript.sln

@@ -5,6 +5,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "chaiscript", "chaiscript.vc
 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
@@ -19,6 +21,10 @@ Global
 		{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"
@@ -189,6 +189,10 @@
 			Filter="h;hpp;hxx;hm;inl;inc;xsd"
 			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
 			>
+			<File
+				RelativePath="..\..\include\chaiscript\dispatchkit\bind_first.hpp"
+				>
+			</File>
 			<File
 				RelativePath="..\..\include\chaiscript\dispatchkit\bootstrap.hpp"
 				>
@@ -221,14 +225,34 @@
 				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\operators.hpp"
+				>
+			</File>
 			<File
 				RelativePath="..\..\include\chaiscript\dispatchkit\proxy_constructors.hpp"
 				>
@@ -237,6 +261,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/eval.chai

@@ -1,3 +1,2 @@
 var i = 1
 var j = eval("5 + 4")
-print(j)

samples/for.chai

@@ -2,11 +2,11 @@ for (var i = 0; i < 10; ++i) {
 	print(i)
 }
 
-for (i = 10; i >= 0; i -= 2) {
+for (var i = 10; i >= 0; i -= 2) {
 	print(i)
 }
 
-i = 0
+var i = 0
 
 for (; i < 5; ++i) {
 	print(i)

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,6 +22,22 @@ 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;
@@ -45,6 +61,10 @@ 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;
@@ -55,10 +75,15 @@ int main(int argc, char *argv[]) {
   System 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.
   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 
@@ -85,7 +110,7 @@ int main(int argc, char *argv[]) {
 
   //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.add(fun(boost::function<void ()>(boost::bind(&System::do_callbacks, boost::ref(system), "Bound Test"))), "do_callbacks");
+  chai.add(fun(&System::do_callbacks, boost::ref(system), std::string("Bound Test")), "do_callbacks");
 
   //Call bound version of do_callbacks
   chai("do_callbacks()");
@@ -118,10 +143,33 @@ int main(int argc, char *argv[]) {
 
   log("Functor test output", boost::lexical_cast<std::string>(x));
 
+  chai.add(var(boost::shared_ptr<int>()), "nullvar");
+  chai("print(\"This should be true.\"); print(nullvar.is_var_null())");
+
+  // test the global const action
+  chai.add_global_const(const_var(1), "constvar");
+  chai("def getvar() { return constvar; }");
+  chai("print( getvar() )");
+
 
   //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,22 +6,48 @@
 
 #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 chai;
 
+
     if (argc < 2) {
-        std::cout << "eval> ";
+        //std::cout << "eval> ";
-        std::getline(std::cin, input);
+        //std::getline(std::cin, input);
+#ifdef READLINE_AVAILABLE
+        using_history();
+#endif
+        input = get_next_command();
         while (input != "quit") {
 
             chaiscript::Boxed_Value val;
@@ -35,7 +61,7 @@ int main(int argc, char *argv[]) {
                     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 {
                             chaiscript::dispatch(chai.get_eval_engine().get_function("print"), chaiscript::Param_List_Builder() << val);
                         }
@@ -49,8 +75,7 @@ int main(int argc, char *argv[]) {
                 }
             }
 
-            std::cout << "eval> ";
+            input = get_next_command();
-            std::getline(std::cin, input);
         }
     }
     else {

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/classification.chai

@@ -0,0 +1,7 @@
+print(1.is_var_const());
+print(1.is_var_reference());
+print(1.is_var_pointer());
+print(1.is_var_null());
+print(1.is_var_undef());
+var i;
+print(i.is_var_undef());

unittests/classification.txt

@@ -0,0 +1,6 @@
+true
+false
+true
+false
+false
+true

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/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, lhs is const." 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/is_undef.chai

@@ -0,0 +1,4 @@
+var i;
+print(i.is_var_undef());
+i = 5;
+print(i.is_var_undef());

unittests/is_undef.txt

@@ -0,0 +1,2 @@
+true
+false

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