Update releasenotes.md

- Update copyrights to 2015
 - Set version to 5.6.0
 - Update release notes

.decent_ci-Linux.yaml

@@ -0,0 +1,25 @@
+compilers:
+  - name: "clang"
+    version: "3.5"
+    skip_packaging: true
+    cmake_extra_flags: -DUSE_LIBCXX:BOOL=OFF -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON
+  - name: "clang"
+    build_tag: AddressSanitizer
+    version: "3.5"
+    skip_packaging: true
+    cmake_extra_flags: -DUSE_LIBCXX:BOOL=OFF -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DENABLE_ADDRESS_SANITIZER:BOOL=ON
+  - name: "clang"
+    build_tag: ThreadSanitizer
+    version: "3.5"
+    skip_packaging: true
+    cmake_extra_flags: -DUSE_LIBCXX:BOOL=OFF -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DENABLE_THREAD_SANITIZER:BOOL=ON
+  - name: "gcc"
+    version: "4.8"
+    cmake_extra_flags: -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DBUILD_TESTING:BOOL=ON
+  - name: "gcc"
+    version: "4.6"
+    skip_packaging: true
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON
+  - name: cppcheck
+    compiler_extra_flags: --enable=all -I include --inline-suppr -Umax  --suppress="*:cmake*"
+

.decent_ci-MacOS.yaml

@@ -0,0 +1,9 @@
+compilers:
+  - name: clang
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=$COMMIT_SHA
+    build_package_generator: TBZ2
+  - name: clang
+    build_type: Debug
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=$COMMIT_SHA
+    skip_packaging: true
+

.decent_ci-Windows.yaml

@@ -0,0 +1,22 @@
+compilers:
+  - name: Visual Studio
+    version: 14
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=%COMMIT_SHA%
+    compiler_extra_flags: /analyze
+    skip_packaging: true
+  - name: Visual Studio
+    version: 14
+    architecture: Win64
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=%COMMIT_SHA%
+    compiler_extra_flags: /analyze
+    skip_packaging: true
+  - name: Visual Studio
+    version: 12
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=%COMMIT_SHA%
+    compiler_extra_flags: /analyze
+  - name: Visual Studio
+    version: 12
+    architecture: Win64
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=%COMMIT_SHA%
+    compiler_extra_flags: /analyze
+

.decent_ci.yaml

@@ -0,0 +1,4 @@
+results_repository : ChaiScript/ChaiScript-BuildResults
+results_path : _posts
+results_base_url : https://chaiscript.github.io/ChaiScript-BuildResults
+aging_pull_requests_notification: true

CMakeLists.txt

@@ -10,7 +10,7 @@ else()
 endif()
 
 
-option(BUILD_MODULES "Build Extra Modules (stl, reflection)" TRUE)
+option(BUILD_MODULES "Build Extra Modules (stl)" TRUE)
 option(BUILD_SAMPLES "Build Samples Folder" FALSE)
 
 
@@ -36,11 +36,38 @@ if(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
     set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=address")
   endif()
 
+  option(ENABLE_MEMORY_SANITIZER "Enable memory sanitizer testing in gcc/clang" FALSE)
+  if(ENABLE_MEMORY_SANITIZER)
+    add_definitions(-fsanitize=memory -g)
+    set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=memory")
+  endif()
+
   option(ENABLE_UNDEFINED_SANITIZER "Enable undefined behavior sanitizer testing in gcc/clang" FALSE)
   if(ENABLE_UNDEFINED_SANITIZER)
     add_definitions(-fsanitize=undefined -g)
     set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=undefined")
   endif()
+
+  option(ENABLE_LTO "Enable Link Time Optimization" FALSE)
+
+  if (ENABLE_LTO)
+    add_definitions(-flto)
+    set(LINKER_FLAGS "${LINKER_FLAGS} -flto")
+  endif()
+
+  option(PROFILE_GENERATE "Generate profile data" FALSE)
+  if (PROFILE_GENERATE)
+    add_definitions(-fprofile-generate)
+    set(LINKER_FLAGS "${LINKER_FLAGS} -fprofile-generate")
+  endif()
+
+  option(PROFILE_USE "Use profile data" FALSE)
+  if (PROFILE_USE)
+    add_definitions(-fprofile-use)
+    set(LINKER_FLAGS "${LINKER_FLAGS} -fprofile-use")
+  endif()
+
+
 endif()
 
 list(APPEND CPACK_SOURCE_IGNORE_FILES "${CMAKE_CURRENT_BINARY_DIR}")
@@ -54,8 +81,8 @@ set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/readme.md")
 set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/description.txt")
 
 set(CPACK_PACKAGE_VERSION_MAJOR 5)
-set(CPACK_PACKAGE_VERSION_MINOR 3)
-set(CPACK_PACKAGE_VERSION_PATCH 1)
+set(CPACK_PACKAGE_VERSION_MINOR 6)
+set(CPACK_PACKAGE_VERSION_PATCH 0)
 
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
 set(CPACK_PACKAGE_VENDOR "ChaiScript.com")
@@ -125,7 +152,13 @@ if(MSVC)
   # how to workaround or fix the error. So I'm disabling it globally.
   add_definitions(/wd4503)
 else()
-  add_definitions(-Wall -Wextra -Wshadow -Wnon-virtual-dtor -pedantic ${CPP11_FLAG})
+  add_definitions(-Wall -Wextra -Wshadow -Wnon-virtual-dtor -Wold-style-cast -Wcast-align -Wcast-qual -Woverloaded-virtual  -pedantic ${CPP11_FLAG})
+
+  if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    add_definitions(-Weverything -Wno-c++98-compat -Wno-documentation -Wno-switch-enum -Wno-weak-vtables -Wno-sign-conversion -Wno-missing-prototypes -Wno-padded -Wno-missing-noreturn)
+  else()
+    add_definitions(-Wnoexcept)
+  endif()
 
   if(APPLE)
     add_definitions(-Wno-sign-compare)
@@ -154,7 +187,7 @@ endif()
 include_directories(include)
 
 
-set(Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.chai include/chaiscript/language/chaiscript_prelude_docs.hpp include/chaiscript/utility/utility.hpp)
+set(Chai_INCLUDES include/chaiscript/chaiscript.hpp include/chaiscript/chaiscript_threading.hpp include/chaiscript/dispatchkit/bad_boxed_cast.hpp include/chaiscript/dispatchkit/bind_first.hpp include/chaiscript/dispatchkit/bootstrap.hpp include/chaiscript/dispatchkit/bootstrap_stl.hpp include/chaiscript/dispatchkit/boxed_cast.hpp include/chaiscript/dispatchkit/boxed_cast_helper.hpp include/chaiscript/dispatchkit/boxed_number.hpp include/chaiscript/dispatchkit/boxed_value.hpp include/chaiscript/dispatchkit/dispatchkit.hpp include/chaiscript/dispatchkit/type_conversions.hpp include/chaiscript/dispatchkit/dynamic_object.hpp include/chaiscript/dispatchkit/exception_specification.hpp include/chaiscript/dispatchkit/function_call.hpp include/chaiscript/dispatchkit/function_call_detail.hpp include/chaiscript/dispatchkit/handle_return.hpp include/chaiscript/dispatchkit/operators.hpp include/chaiscript/dispatchkit/proxy_constructors.hpp include/chaiscript/dispatchkit/proxy_functions.hpp include/chaiscript/dispatchkit/proxy_functions_detail.hpp include/chaiscript/dispatchkit/register_function.hpp include/chaiscript/dispatchkit/type_info.hpp include/chaiscript/language/chaiscript_algebraic.hpp include/chaiscript/language/chaiscript_common.hpp include/chaiscript/language/chaiscript_engine.hpp include/chaiscript/language/chaiscript_eval.hpp include/chaiscript/language/chaiscript_parser.hpp include/chaiscript/language/chaiscript_prelude.chai include/chaiscript/language/chaiscript_prelude_docs.hpp include/chaiscript/utility/utility.hpp)
 
 set_source_files_properties(${Chai_INCLUDES} PROPERTIES HEADER_FILE_ONLY TRUE)
 
@@ -203,6 +236,10 @@ if(BUILD_SAMPLES)
   target_link_libraries(example ${LIBS})
   add_executable(memory_leak_test samples/memory_leak_test.cpp)
   target_link_libraries(memory_leak_test ${LIBS})
+  add_executable(inheritance samples/inheritance.cpp)
+  target_link_libraries(inheritance ${LIBS})
+  add_executable(fun_call_performance samples/fun_call_performance.cpp)
+  target_link_libraries(fun_call_performance ${LIBS})
 endif()
 
 
@@ -210,9 +247,7 @@ if(BUILD_MODULES)
   add_library(stl_extra MODULE src/stl_extra.cpp)
   target_link_libraries(stl_extra ${LIBS})
 
-  add_library(reflection MODULE src/reflection.cpp)
-  target_link_libraries(reflection ${LIBS})
-  set(MODULES stl_extra reflection)
+  set(MODULES stl_extra)
 endif()
 
 file(GLOB UNIT_TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/unittests/ ${CMAKE_CURRENT_SOURCE_DIR}/unittests/*.chai ${CMAKE_CURRENT_SOURCE_DIR}/unittests/3.x/*.chai)
@@ -267,6 +302,10 @@ if(BUILD_TESTING)
     target_link_libraries(object_lifetime_test ${LIBS})
     add_test(NAME Object_Lifetime_Test COMMAND object_lifetime_test)
 
+    add_executable(object_lifetime_test2 unittests/object_lifetime_test2.cpp)
+    target_link_libraries(object_lifetime_test2 ${LIBS})
+    add_test(NAME Object_Lifetime_Test2 COMMAND object_lifetime_test2)
+
     add_executable(function_ordering_test unittests/function_ordering_test.cpp)
     target_link_libraries(function_ordering_test ${LIBS})
     add_test(NAME Function_Ordering_Test COMMAND function_ordering_test)
@@ -275,6 +314,10 @@ if(BUILD_TESTING)
     target_link_libraries(type_info_test ${LIBS})
     add_test(NAME Type_Info_Test COMMAND type_info_test)
 
+    add_executable(type_name_test unittests/type_name_test.cpp)
+    target_link_libraries(type_name_test ${LIBS})
+    add_test(NAME Type_Name_Test COMMAND type_name_test)
+
     add_executable(eval_catch_exception_test unittests/eval_catch_exception_test.cpp)
     target_link_libraries(eval_catch_exception_test ${LIBS})
     add_test(NAME Eval_Catch_Exception_Test COMMAND eval_catch_exception_test)

Doxyfile.in

@@ -40,7 +40,7 @@ PROJECT_NUMBER         = ${CHAI_VERSION}
 # for a project that appears at the top of each page and should give viewer
 # a quick idea about the purpose of the project. Keep the description short.
 
-PROJECT_BRIEF          = ${CMAKE_BINARY_DIR}/docs
+PROJECT_BRIEF          = "An easy to use embedded scripting language for C++."
 
 # With the PROJECT_LOGO tag one can specify an logo or icon that is
 # included in the documentation. The maximum height of the logo should not

contrib/codeanalysis/runcppcheck.sh

@@ -1,12 +1,12 @@
 #!/bin/bash
 
 pushd ..
-wget http://sourceforge.net/projects/cppcheck/files/cppcheck/1.64/cppcheck-1.65.tar.bz2
-tar -xvf cppcheck-1.65.tar.bz2
-cd cppcheck-1.65
-make -j2
+wget http://sourceforge.net/projects/cppcheck/files/cppcheck/1.66/cppcheck-1.66.tar.bz2
+tar -xvf cppcheck-1.66.tar.bz2
+cd cppcheck-1.66
+CXX=g++-4.8 make -j2
 popd
-../cppcheck-1.65/cppcheck --enable=all -I include --inline-suppr --std=c++11 --platform=unix64 src/main.cpp src/chai*.cpp --template ' - __{severity}__: [{file}:{line}](../blob/TRAVIS_COMMIT/{file}#L{line}) {message} ({id})'  2>output
+../cppcheck-1.66/cppcheck --enable=all -I include --inline-suppr --suppress=missingIncludeSystem --std=c++11 --platform=unix64 src/main.cpp src/chai*.cpp --template ' - __{severity}__: [{file}:{line}](../blob/TRAVIS_COMMIT/{file}#L{line}) {message} ({id})'  2>output
 sed -i "s/TRAVIS_COMMIT/${TRAVIS_COMMIT}/g" output
 echo -n '{ "body": " ' > output.json
 echo -n `awk '{printf "%s\\\\n", $0;}' output` >> output.json

include/chaiscript/chaiscript.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_HPP_
@@ -75,7 +75,7 @@
 ///
 /// @subsection compiling Compiling ChaiScript Applications
 ///
-/// ChaiScript is a header only library with only one dependecy: The
+/// ChaiScript is a header only library with only one dependency: The
 /// operating system provided dynamic library loader, which has to be specified on some platforms.
 /// 
 /// @subsubsection compilinggcc Compiling with GCC
@@ -112,7 +112,7 @@
 ///
 /// @subsubsection evalmethod Method 'eval'
 /// 
-/// The eval method is somewhat more verbose and can be used to get typesafely return values
+/// The eval method is somewhat more verbose and can be used to get type safely return values
 /// from the script.
 ///
 /// ~~~~~~~~{.cpp}
@@ -311,7 +311,7 @@
 /// As much as possible, ChaiScript attempts to convert between &, *, const &, const *, std::shared_ptr<T>,
 /// std::shared_ptr<const T>, std::reference_wrapper<T>, std::reference_wrapper<const T> and value types automatically.
 ///
-/// If a chaiscript::var object was created in C++ from a pointer, it cannot be convered to a shared_ptr (this would add invalid reference counting).
+/// If a chaiscript::var object was created in C++ from a pointer, it cannot be converted to a shared_ptr (this would add invalid reference counting).
 /// Const may be added, but never removed. 
 ///
 /// The take away is that you can pretty much expect function calls to Just Work when you need them to.
@@ -497,6 +497,21 @@
 /// print(rect.area())
 /// ~~~~~~~~~
 ///
+/// Since ChaiScript 5.4.0 it has been possible to use the "class" keyword to simplify this code.
+///
+/// ~~~~~~~~~
+/// class Rectangle {
+///   attr height
+///   attr width
+///   def Rectangle() { this.height = 10; this.width = 20 }
+///   def area() { this.height * this.width }
+/// }
+///
+/// var rect = Rectangle()
+/// rect.height = 30
+/// print(rect.area())
+/// ~~~~~~~~~
+///
 /// @sa @ref keywordattr
 /// @sa @ref keyworddef
 

include/chaiscript/chaiscript_defines.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DEFINES_HPP_
@@ -17,7 +17,7 @@
 #endif
 
 #if (defined(__GNUC__) && __GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
-/// Currently only g++>=4.8supports this natively
+/// Currently only g++>=4.8 supports this natively
 /// \todo Make this support other compilers when possible
 #define CHAISCRIPT_HAS_THREAD_LOCAL
 #endif
@@ -45,8 +45,8 @@
 
 namespace chaiscript {
   static const int version_major = 5;
-  static const int version_minor = 3;
-  static const int version_patch = 1;
+  static const int version_minor = 6;
+  static const int version_patch = 0;
 }
 
 #endif

include/chaiscript/chaiscript_stdlib.hpp

@@ -19,6 +19,11 @@
 #include "dispatchkit/bootstrap_stl.hpp"
 #include "dispatchkit/boxed_value.hpp"
 
+#ifndef CHAISCRIPT_NO_THREADS
+#include <future>
+#endif
+
+
 /// @file
 ///
 /// This file generates the standard library that normal ChaiScript usage requires.
@@ -40,6 +45,11 @@ namespace chaiscript
         lib->add(standard_library::map_type<std::map<std::string, Boxed_Value> >("Map"));
         lib->add(standard_library::pair_type<std::pair<Boxed_Value, Boxed_Value > >("Pair"));
 
+#ifndef CHAISCRIPT_NO_THREADS
+        lib->add(standard_library::future_type<std::future<chaiscript::Boxed_Value>>("future"));
+        lib->add(chaiscript::fun<std::future<Boxed_Value> (const std::function<chaiscript::Boxed_Value ()> &)>([](const std::function<chaiscript::Boxed_Value ()> &t_func){ return std::async(std::launch::async, t_func);}), "async");
+#endif
+
         return lib;
       }
 

include/chaiscript/chaiscript_threading.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_THREADING_HPP_
@@ -82,16 +82,27 @@ namespace chaiscript
               t().erase(m_key);
             }
 
-            inline T *operator->() const
+            inline const T *operator->() const
             {
               return &(t()[m_key]);
             }
 
-            inline T &operator*() const
+            inline const T &operator*() const
             {
               return t()[m_key];
             }
 
+            inline T *operator->()
+            {
+              return &(t()[m_key]);
+            }
+
+            inline T &operator*()
+            {
+              return t()[m_key];
+            }
+
+
             void *m_key;
 
           private:
@@ -117,12 +128,22 @@ namespace chaiscript
             {
             }
 
-            inline T *operator->() const
+            inline const T *operator->() const
             {
               return get_tls().get();
             }
 
-            inline T &operator*() const
+            inline const T &operator*() const
+            {
+              return *get_tls();
+            }
+
+            inline T *operator->()
+            {
+              return get_tls().get();
+            }
+
+            inline T &operator*()
             {
               return *get_tls();
             }

include/chaiscript/dispatchkit/any.hpp

@@ -26,9 +26,11 @@ namespace chaiscript {
           {
           }
 
+          bad_any_cast(const bad_any_cast &) = default;
+
           virtual ~bad_any_cast() CHAISCRIPT_NOEXCEPT {}
 
-          /// \brief Description of what error occured
+          /// \brief Description of what error occurred
           virtual const char * what() const CHAISCRIPT_NOEXCEPT CHAISCRIPT_OVERRIDE
           {
             return m_what.c_str();
@@ -44,17 +46,30 @@ namespace chaiscript {
       private:
         struct Data
         {
+          Data(const std::type_info &t_type) 
+            : m_type(t_type)
+          {
+          }
+
+          Data &operator=(const Data &) = delete;
+
           virtual ~Data() {}
+
           virtual void *data() = 0;
-          virtual const std::type_info &type() const = 0;
-          virtual std::shared_ptr<Data> clone() const = 0;
+          const std::type_info &type() const
+          {
+            return m_type;
+          }
+
+          virtual std::unique_ptr<Data> clone() const = 0;
+          const std::type_info &m_type;
         };
 
         template<typename T>
           struct Data_Impl : Data
           {
-            Data_Impl(T t_type)
-              : m_type(typeid(T)),
+            explicit Data_Impl(T t_type)
+              : Data(typeid(T)),
                 m_data(std::move(t_type))
             {
             }
@@ -66,23 +81,17 @@ namespace chaiscript {
               return &m_data;
             }
 
-            const std::type_info &type() const CHAISCRIPT_OVERRIDE
+            std::unique_ptr<Data> clone() const CHAISCRIPT_OVERRIDE
             {
-              return m_type;
-            }
-
-            std::shared_ptr<Data> clone() const CHAISCRIPT_OVERRIDE
-            {
-              return std::shared_ptr<Data>(new Data_Impl<T>(m_data));
+              return std::unique_ptr<Data>(new Data_Impl<T>(m_data));
             }
 
             Data_Impl &operator=(const Data_Impl&) = delete;
-              
-            const std::type_info &m_type;
+
             T m_data;
           };
 
-        std::shared_ptr<Data> m_data;
+        std::unique_ptr<Data> m_data;
 
       public:
         // construct/copy/destruct
@@ -98,12 +107,19 @@ namespace chaiscript {
           }
         }
 
-        template<typename ValueType> 
-        Any(const ValueType &t_value)
-          : m_data(std::shared_ptr<Data>(new Data_Impl<ValueType>(t_value)))
+#if !defined(_MSC_VER) || _MSC_VER  != 1800
+        Any(Any &&) = default;
+        Any &operator=(Any &&t_any) = default;
+#endif
+
+        template<typename ValueType,
+          typename = typename std::enable_if<!std::is_same<Any, typename std::decay<ValueType>::type>::value>::type>
+        explicit Any(ValueType &&t_value)
+          : m_data(std::unique_ptr<Data>(new Data_Impl<typename std::decay<ValueType>::type>(std::forward<ValueType>(t_value))))
         {
         }
 
+
         Any & operator=(const Any &t_any)
         {
           Any copy(t_any);
@@ -111,13 +127,6 @@ namespace chaiscript {
           return *this; 
         }
 
-        template<typename ValueType> 
-          Any & operator=(const ValueType &t_value)
-        {
-          m_data = std::shared_ptr<Data>(new Data_Impl<ValueType>(t_value));
-          return *this;
-        }
-
         template<typename ToType>
           ToType &cast() const
           {
@@ -127,7 +136,6 @@ namespace chaiscript {
             } else {
               throw chaiscript::detail::exception::bad_any_cast();
             }
- 
           }
 
 
@@ -138,9 +146,7 @@ namespace chaiscript {
         // modifiers
         Any & swap(Any &t_other)
         {
-          std::shared_ptr<Data> data = t_other.m_data;
-          t_other.m_data = m_data;
-          m_data = data;
+          std::swap(t_other.m_data, m_data);
           return *this;
         }
 

include/chaiscript/dispatchkit/bad_boxed_cast.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BAD_BOXED_CAST_HPP_
@@ -10,6 +10,7 @@
 #include <string>
 #include <typeinfo>
 
+#include "../chaiscript_defines.hpp"
 #include "type_info.hpp"
 
 namespace chaiscript {
@@ -28,14 +29,14 @@ namespace chaiscript
     class bad_boxed_cast : public std::bad_cast
     {
       public:
-        bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to,
+        bad_boxed_cast(Type_Info t_from, const std::type_info &t_to,
             std::string t_what) CHAISCRIPT_NOEXCEPT
-          : from(t_from), to(&t_to), m_what(std::move(t_what))
+          : from(std::move(t_from)), to(&t_to), m_what(std::move(t_what))
         {
         }
 
-        bad_boxed_cast(const Type_Info &t_from, const std::type_info &t_to) CHAISCRIPT_NOEXCEPT
-          : from(t_from), to(&t_to), m_what("Cannot perform boxed_cast")
+        bad_boxed_cast(Type_Info t_from, const std::type_info &t_to)
+          : from(std::move(t_from)), to(&t_to), m_what("Cannot perform boxed_cast")
         {
         }
 
@@ -44,9 +45,10 @@ namespace chaiscript
         {
         }
 
-        virtual ~bad_boxed_cast() CHAISCRIPT_NOEXCEPT {} 
+        bad_boxed_cast(const bad_boxed_cast &) = default;
+        virtual ~bad_boxed_cast() CHAISCRIPT_NOEXCEPT {}
 
-        /// \brief Description of what error occured
+        /// \brief Description of what error occurred
         virtual const char * what() const CHAISCRIPT_NOEXCEPT CHAISCRIPT_OVERRIDE
         {
           return m_what.c_str();

include/chaiscript/dispatchkit/bind_first.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BIND_FIRST_HPP_
@@ -14,79 +14,20 @@ namespace chaiscript
   namespace detail
   {
 
-    template<int>
-      struct Placeholder
-      {
-      };
-
-    template<>
-      struct Placeholder<1>
-      {
-        static decltype(std::placeholders::_1) value() { return std::placeholders::_1; }
-      };
-
-    template<>
-      struct Placeholder<2>
-      {
-        static decltype(std::placeholders::_2) value() { return std::placeholders::_2; }
-      };
-
-    template<>
-      struct Placeholder<3>
-      {
-        static decltype(std::placeholders::_3) value() { return std::placeholders::_3; }
-      };
-
-    template<>
-      struct Placeholder<4>
-      {
-        static decltype(std::placeholders::_4) value() { return std::placeholders::_4; }
-      };
-
-    template<>
-      struct Placeholder<5>
-      {
-        static decltype(std::placeholders::_5) value() { return std::placeholders::_5; }
-      };
-
-    template<>
-      struct Placeholder<6>
-      {
-        static decltype(std::placeholders::_6) value() { return std::placeholders::_6; }
-      };
-
-    template<>
-      struct Placeholder<7>
-      {
-        static decltype(std::placeholders::_7) value() { return std::placeholders::_7; }
-      };
-
-    template<>
-      struct Placeholder<8>
-      {
-        static decltype(std::placeholders::_8) value() { return std::placeholders::_8; }
-      };
-
-    template<>
-      struct Placeholder<9>
-      {
-        static decltype(std::placeholders::_9) value() { return std::placeholders::_9; }
-      };
-
-    template<>
-      struct Placeholder<10>
-      {
-        static decltype(std::placeholders::_10) value() { return std::placeholders::_10; }
-      };
-
+    struct Placeholder
+    {
+      static std::tuple<decltype(std::placeholders::_1),decltype(std::placeholders::_2),decltype(std::placeholders::_3),decltype(std::placeholders::_4),decltype(std::placeholders::_5),decltype(std::placeholders::_6),decltype(std::placeholders::_7),decltype(std::placeholders::_8),decltype(std::placeholders::_9),decltype(std::placeholders::_10)> placeholder() {
+        return std::tuple<decltype(std::placeholders::_1),decltype(std::placeholders::_2),decltype(std::placeholders::_3),decltype(std::placeholders::_4),decltype(std::placeholders::_5),decltype(std::placeholders::_6),decltype(std::placeholders::_7),decltype(std::placeholders::_8),decltype(std::placeholders::_9),decltype(std::placeholders::_10)>(std::placeholders::_1,std::placeholders::_2,std::placeholders::_3,std::placeholders::_4,std::placeholders::_5,std::placeholders::_6,std::placeholders::_7,std::placeholders::_8,std::placeholders::_9,std::placeholders::_10);
+      }
+    };
 
     template<int count, int maxcount, typename Sig>
       struct Bind_First
       {
         template<typename F, typename ... InnerParams>
-          static std::function<Sig> bind(F f, InnerParams ... innerparams)
+          static std::function<Sig> bind(F&& f, InnerParams ... innerparams)
           {
-            return Bind_First<count - 1, maxcount, Sig>::bind(f, innerparams..., Placeholder<maxcount - count + 1>::value());
+            return Bind_First<count - 1, maxcount, Sig>::bind(std::forward<F>(f), innerparams..., std::get<maxcount - count>(Placeholder::placeholder()));
           } 
       };
 
@@ -94,37 +35,42 @@ namespace chaiscript
       struct Bind_First<0, maxcount, Sig>
       {
         template<typename F, typename ... InnerParams>
-          static std::function<Sig> bind(F f, InnerParams ... innerparams)
+          static std::function<Sig> bind(F&& f, InnerParams ... innerparams)
           {
-            return std::bind(f, innerparams...);
+    return std::bind(std::forward<F>(f), innerparams...);
           }
       };
 
 
     template<typename O, typename Ret, typename P1, typename ... Param>
-      std::function<Ret (Param...)> bind_first(Ret (*f)(P1, Param...), O o)
+      std::function<Ret (Param...)> bind_first(Ret (*f)(P1, Param...), O&& o)
       {
-        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, o);
+        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, std::forward<O>(o));
       }
 
     template<typename O, typename Ret, typename Class, typename ... Param>
-      std::function<Ret (Param...)> bind_first(Ret (Class::*f)(Param...), O o)
+      std::function<Ret (Param...)> bind_first(Ret (Class::*f)(Param...), O&& o)
       {
-        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, o);
+        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, std::forward<O>(o));
       }
 
     template<typename O, typename Ret, typename Class, typename ... Param>
-      std::function<Ret (Param...)> bind_first(Ret (Class::*f)(Param...) const, O o)
+      std::function<Ret (Param...)> bind_first(Ret (Class::*f)(Param...) const, O&& o)
       {
-        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, o);
+        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, std::forward<O>(o));
       }
 
     template<typename O, typename Ret, typename P1, typename ... Param>
-      std::function<Ret (Param...)> bind_first(const std::function<Ret (P1, Param...)> &f, O o)
+      std::function<Ret (Param...)> bind_first(const std::function<Ret (P1, Param...)> &f, O&& o)
       {
-        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, o);
+        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(f, std::forward<O>(o));
       }
 
+    template<typename O, typename Ret, typename P1, typename ... Param>
+      std::function<Ret (Param...)> bind_first(std::function<Ret (P1, Param...)> &&f, O&& o)
+      {
+        return Bind_First<sizeof...(Param), sizeof...(Param), Ret (Param...)>::bind(std::move(f), std::forward<O>(o));
+      }
 
   }
 }

include/chaiscript/dispatchkit/bootstrap.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOOTSTRAP_HPP_
@@ -24,7 +24,7 @@
 #include "boxed_number.hpp"
 #include "boxed_value.hpp"
 #include "dispatchkit.hpp"
-#include "dynamic_cast_conversion.hpp"
+#include "type_conversions.hpp"
 #include "dynamic_object.hpp"
 #include "operators.hpp"
 #include "proxy_constructors.hpp"
@@ -32,6 +32,8 @@
 #include "proxy_functions_detail.hpp"
 #include "register_function.hpp"
 #include "type_info.hpp"
+#include "../utility/utility.hpp"
+#include "../language/chaiscript_common.hpp"
 
 namespace chaiscript 
 {
@@ -44,13 +46,9 @@ namespace chaiscript
       /// \param[in] v Boxed_Number to copy into the new object
       /// \returns The newly created object.
       template<typename P1>
-      std::shared_ptr<P1> construct_pod(Boxed_Number v)
+      std::shared_ptr<P1> construct_pod(const Boxed_Number &v)
       {
-        std::shared_ptr<P1> p(new P1());
-        Boxed_Value bv(p);
-        Boxed_Number nb(bv);
-        nb = v;
-        return p;
+        return std::make_shared<P1>(v.get_as<P1>());
       }
     }
 
@@ -111,9 +109,7 @@ namespace chaiscript
     }
 
 
-    /**
-     * to_string function for internal use. Uses ostream operator<<
-     */
+    /// to_string function for internal use. Uses ostream operator<<
     template<typename Input>
     std::string to_string(Input i)
     {
@@ -122,10 +118,8 @@ namespace chaiscript
       return ss.str();
     }
 
-    /**
-     * Internal function for converting from a string to a value
-     * uses ostream operator >> to perform the conversion
-     */
+    /// Internal function for converting from a string to a value
+    /// uses ostream operator >> to perform the conversion
     template<typename Input>
     Input parse_string(const std::string &i)
     {
@@ -134,12 +128,10 @@ namespace chaiscript
       ss >> t;
       return t;
     }
-      
-            
-    /**
-    * Add all common functions for a POD type. All operators, and
-    * common conversions
-    */
+
+
+    /// Add all common functions for a POD type. All operators, and
+    /// common conversions
     template<typename T>
     ModulePtr bootstrap_pod_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
     {
@@ -153,22 +145,18 @@ namespace chaiscript
     }
 
 
-    /**
-    * "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
-    * but want to instead maintain the shared_ptr. It is needed internally
-    * for handling of Proxy_Function object (that is,
-    * function variables.
-    */
+    /// "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
+    /// but want to instead maintain the shared_ptr. It is needed internally
+    /// for handling of Proxy_Function object (that is,
+    /// function variables.
     template<typename Type>
     std::shared_ptr<Type> shared_ptr_clone(const std::shared_ptr<Type> &p)
     {
       return p;
     }
 
-    /**
-     * Specific version of shared_ptr_clone just for Proxy_Functions
-     */
+    /// Specific version of shared_ptr_clone just for Proxy_Functions
     template<typename Type>
     std::shared_ptr<typename std::remove_const<Type>::type> 
         shared_ptr_unconst_clone(const std::shared_ptr<typename std::add_const<Type>::type> &p)
@@ -178,11 +166,9 @@ namespace chaiscript
 
 
 
-    /**
-    * 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.
-    */
+    /// 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, const std::shared_ptr<Type> &rhs)
     {
@@ -196,10 +182,8 @@ namespace chaiscript
       }
     }
 
-    /**
-    * Class consisting of only static functions. All default bootstrapping occurs
-    * from this class.
-    */
+    /// Class consisting of only static functions. All default bootstrapping occurs
+    /// from this class.
     class Bootstrap
     {
     private:
@@ -218,18 +202,16 @@ namespace chaiscript
 
       static void print(const std::string &s)
       {
-        std::cout << s;
+        fwrite(s.c_str(), 1, s.size(), stdout);
       }
 
       static void println(const std::string &s)
       {
-        std::cout << s << std::endl;
+        puts(s.c_str());
       }
 
 
-      /**
-      * Add all arithmetic operators for PODs
-      */
+      /// Add all arithmetic operators for PODs
       static void opers_arithmetic_pod(ModulePtr m = ModulePtr(new Module()))
       {
         m->add(fun(&Boxed_Number::equals), "==");
@@ -269,11 +251,8 @@ namespace chaiscript
 
      }
 
-      /**
-      * Create a bound function object. The first param is the function to bind
-      * the remaining parameters are the args to bind into the
-      * result
-      */
+      /// Create a bound function object. The first param is the function to bind
+      /// the remaining parameters are the args to bind into the result
       static Boxed_Value bind_function(const std::vector<Boxed_Value> &params)
       {
         if (params.size() < 2)
@@ -283,7 +262,7 @@ namespace chaiscript
 
         Const_Proxy_Function f = boxed_cast<Const_Proxy_Function>(params[0]);
 
-        return Boxed_Value(Const_Proxy_Function(new dispatch::Bound_Function(f,
+        return Boxed_Value(Const_Proxy_Function(std::make_shared<dispatch::Bound_Function>(f,
           std::vector<Boxed_Value>(params.begin() + 1, params.end()))));
       }
 
@@ -328,9 +307,7 @@ namespace chaiscript
         return e.what();
       }
 
-      /**
-       * Boolean specialization of internal to_string function 
-       */
+      /// Boolean specialization of internal to_string function
       static std::string bool_to_string(bool b)
       {
         if (b)
@@ -357,12 +334,44 @@ namespace chaiscript
           return vbv;
         }
 
+
+      static bool has_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
+      {
+        if (auto pf = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf))
+        {
+          if (pf->get_parse_tree())
+          {
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return false;
+        }
+      }
+
+      static chaiscript::AST_NodePtr get_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
+      {
+        if (auto pf = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf))
+        {
+          if (pf->get_parse_tree())
+          {
+            return pf->get_parse_tree();
+          } else {
+            throw std::runtime_error("Function does not have a parse tree");
+          }
+        } else {
+          throw std::runtime_error("Function does not have a parse tree");
+        }
+      }
+
       template<typename Function>
       static std::function<std::vector<Boxed_Value> (const dispatch::Proxy_Function_Base*)> return_boxed_value_vector(const Function &f)
       {
         return std::bind(&do_return_boxed_value_vector<Function>, f, std::placeholders::_1);
       }
 
+
     public:
       /// \brief perform all common bootstrap functions for std::string, void and POD types
       /// \param[in,out] m Module to add bootstrapped functions to
@@ -380,17 +389,16 @@ namespace chaiscript
         m->add(fun(&dispatch::Proxy_Function_Base::annotation), "get_annotation");
         m->add(fun(&dispatch::Proxy_Function_Base::operator==), "==");
 
-        
+
         m->add(fun(return_boxed_value_vector(&dispatch::Proxy_Function_Base::get_param_types)), "get_param_types");
         m->add(fun(return_boxed_value_vector(&dispatch::Proxy_Function_Base::get_contained_functions)), "get_contained_functions");
 
 
         m->add(user_type<std::runtime_error>(), "runtime_error");
         m->add(chaiscript::base_class<std::exception, std::runtime_error>());
- 
 
         m->add(constructor<std::runtime_error (const std::string &)>(), "runtime_error");
-        m->add(fun(std::function<std::string (const std::runtime_error &)>(&what)), "what");     
+        m->add(fun(std::function<std::string (const std::runtime_error &)>(&what)), "what");
 
         m->add(user_type<dispatch::Dynamic_Object>(), "Dynamic_Object");
         m->add(constructor<dispatch::Dynamic_Object (const std::string &)>(), "Dynamic_Object");
@@ -409,9 +417,12 @@ namespace chaiscript
         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_attr), "get_var_attr");
+        m->add(fun(&Boxed_Value::copy_attrs), "copy_var_attrs");
 
         m->add(fun(&Boxed_Value::get_type_info), "get_type_info");
         m->add(user_type<Type_Info>(), "Type_Info");
+        m->add(constructor<Type_Info (const Type_Info &)>(), "Type_Info");
 
 
         operators::equal<Type_Info>(m);
@@ -431,8 +442,8 @@ namespace chaiscript
         operators::assign<bool>(m);
         operators::equal<bool>(m);
 
-        m->add(fun(&to_string<const std::string &>), "internal_to_string");
-        m->add(fun(&Bootstrap::bool_to_string), "internal_to_string");
+        m->add(fun<std::string (const std::string &t_ss)>([](const std::string &s) -> std::string { return s; }), "to_string");
+        m->add(fun(&Bootstrap::bool_to_string), "to_string");
         m->add(fun(&unknown_assign), "=");
         m->add(fun(&throw_exception), "throw");
         m->add(fun(&what), "what");
@@ -463,8 +474,7 @@ namespace chaiscript
         m->add(fun(&print), "print_string");
         m->add(fun(&println), "println_string");
 
-        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(std::bind(&bind_function, std::placeholders::_1))), 
-          "bind");
+        m->add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(&bind_function)), "bind");
 
         m->add(fun(&shared_ptr_unconst_clone<dispatch::Proxy_Function_Base>), "clone");
         m->add(fun(&ptr_assign<std::remove_const<dispatch::Proxy_Function_Base>::type>), "=");
@@ -472,6 +482,73 @@ namespace chaiscript
 
         m->add(fun(&Boxed_Value::type_match), "type_match");
 
+
+        m->add(chaiscript::fun(&has_parse_tree), "has_parse_tree");
+        m->add(chaiscript::fun(&get_parse_tree), "get_parse_tree");
+
+        m->add(chaiscript::user_type<chaiscript::exception::eval_error>(), "eval_error");
+        m->add(chaiscript::base_class<std::runtime_error, chaiscript::exception::eval_error>());
+
+        m->add(chaiscript::user_type<chaiscript::exception::arithmetic_error>(), "arithmetic_error");
+        m->add(chaiscript::base_class<std::runtime_error, chaiscript::exception::arithmetic_error>());
+
+
+//        chaiscript::bootstrap::standard_library::vector_type<std::vector<std::shared_ptr<chaiscript::AST_Node> > >("AST_NodeVector", m);
+
+
+        chaiscript::utility::add_class<chaiscript::exception::eval_error>(*m,
+            "eval_error",
+            { },
+            { {fun(&chaiscript::exception::eval_error::reason), "reason"},
+            {fun(std::function<std::vector<Boxed_Value> (const chaiscript::exception::eval_error &t_eval_error)>([](const chaiscript::exception::eval_error &t_eval_error) -> std::vector<Boxed_Value> { 
+                std::vector<Boxed_Value> retval;
+                std::transform(t_eval_error.call_stack.begin(), t_eval_error.call_stack.end(),
+                               std::back_inserter(retval),
+                               &chaiscript::var<std::shared_ptr<const chaiscript::AST_Node>>);
+                return retval;
+              })), "call_stack"} }
+            );
+
+
+        chaiscript::utility::add_class<chaiscript::File_Position>(*m,
+            "File_Position",
+            { constructor<File_Position()>(),
+              constructor<File_Position(int, int)>() },
+            { {fun(&File_Position::line), "line"},
+              {fun(&File_Position::column), "column"} }
+            );
+
+
+        chaiscript::utility::add_class<AST_Node>(*m, 
+            "AST_Node",
+            {  },
+            { {fun(&AST_Node::text), "text"},
+              {fun(&AST_Node::identifier), "identifier"},
+              {fun(&AST_Node::filename), "filename"},
+              {fun(&AST_Node::start), "start"},
+              {fun(&AST_Node::end), "end"},
+              {fun(&AST_Node::to_string), "to_string"},
+              {fun(std::function<std::vector<Boxed_Value> (const chaiscript::AST_Node &t_node)>([](const chaiscript::AST_Node &t_node) -> std::vector<Boxed_Value> { 
+                std::vector<Boxed_Value> retval;
+                std::transform(t_node.children.begin(), t_node.children.end(),
+                               std::back_inserter(retval),
+                               &chaiscript::var<std::shared_ptr<chaiscript::AST_Node>>);
+                return retval;
+              })), "children"},
+              {fun(&AST_Node::replace_child), "replace_child"}
+            }
+            );
+
+
+        chaiscript::utility::add_class<parser::ChaiScript_Parser>(*m,
+            "ChaiScript_Parser",
+            { constructor<parser::ChaiScript_Parser ()>() },
+            { {fun(&parser::ChaiScript_Parser::parse), "parse"},
+              {fun(&parser::ChaiScript_Parser::ast), "ast"} }
+            );
+
+
+
         return m;
       }
     };

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 /// \file
@@ -185,7 +185,7 @@ namespace chaiscript
 
             copy_constructor<Bidir_Type>(type + "_Range", m);
 
-            m->add(constructor<Bidir_Type (typename Bidir_Type::container_type &)>(), "range");
+            m->add(constructor<Bidir_Type (typename Bidir_Type::container_type &)>(), "range_internal");
 
             m->add(fun(&Bidir_Type::empty), "empty");
             m->add(fun(&Bidir_Type::pop_front), "pop_front");
@@ -246,6 +246,7 @@ namespace chaiscript
       template<typename ContainerType>
         ModulePtr random_access_container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
+          // cppcheck-suppress syntaxError
           typedef typename ContainerType::reference(ContainerType::*indexoper)(size_t);
           typedef typename ContainerType::const_reference(ContainerType::*constindexoper)(size_t) const;
 
@@ -278,9 +279,9 @@ namespace chaiscript
       template<typename ContainerType>
         ModulePtr container_type(const std::string &/*type*/, ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun( std::function<size_t (const ContainerType *)>( [](const ContainerType *a) { return a->size(); } ) ), "size");
-          m->add(fun( std::function<bool (const ContainerType *)>( [](const ContainerType *a) { return a->empty(); } ) ), "empty");
-          m->add(fun( std::function<void (ContainerType *)>( [](ContainerType *a) { a->clear(); } ) ), "clear");
+          m->add(fun<size_t (const ContainerType *)>([](const ContainerType *a) { return a->size(); } ), "size");
+          m->add(fun<bool (const ContainerType *)>([](const ContainerType *a) { return a->empty(); } ), "empty");
+          m->add(fun<void (ContainerType *)>([](ContainerType *a) { a->clear(); } ), "clear");
           return m;
         }
 
@@ -348,10 +349,12 @@ namespace chaiscript
         ModulePtr front_insertion_sequence_type(const std::string &, ModulePtr m = ModulePtr(new Module()))
         {
           typedef typename ContainerType::reference (ContainerType::*frontptr)();
+          typedef typename ContainerType::const_reference (ContainerType::*constfrontptr)() const;
           typedef void (ContainerType::*pushptr)(typename ContainerType::const_reference);
           typedef void (ContainerType::*popptr)();
 
           m->add(fun(static_cast<frontptr>(&ContainerType::front)), "front");
+          m->add(fun(static_cast<constfrontptr>(&ContainerType::front)), "front");
 
           std::string push_front_name;
           if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
@@ -475,7 +478,10 @@ namespace chaiscript
           m->add(user_type<VectorType>(), type);
 
           typedef typename VectorType::reference (VectorType::*frontptr)();
+          typedef typename VectorType::const_reference (VectorType::*constfrontptr)() const;
+
           m->add(fun(static_cast<frontptr>(&VectorType::front)), "front");
+          m->add(fun(static_cast<constfrontptr>(&VectorType::front)), "front");
 
 
           back_insertion_sequence_type<VectorType>(type, m);
@@ -488,24 +494,26 @@ namespace chaiscript
 
           if (typeid(VectorType) == typeid(std::vector<Boxed_Value>))
           {
-            m->eval("def Vector::`==`(rhs) : type_match(rhs, this) { \
-                       if ( rhs.size() != this.size() ) {    \
-                         return false;  \
-                       } else {  \
-                         auto r1 = range(this); \
-                         auto r2 = range(rhs);  \
-                         while (!r1.empty()) \
-                         {  \
-                           if (!eq(r1.front(), r2.front())) \
-                           {  \
-                             return false; \
-                           } \
-                           r1.pop_front(); \
-                           r2.pop_front(); \
-                         } \
-                       return true; \
-                     } \
-                   }");
+            m->eval(R"(
+                    def Vector::`==`(rhs) : type_match(rhs, this) {
+                       if ( rhs.size() != this.size() ) {
+                         return false;
+                       } else {
+                         auto r1 = range(this);
+                         auto r2 = range(rhs);
+                         while (!r1.empty())
+                         {
+                           if (!eq(r1.front(), r2.front()))
+                           {
+                             return false;
+                           }
+                           r1.pop_front();
+                           r2.pop_front();
+                         }
+                         true;
+                       }
+                   } )"
+                 );
           } 
 
           return m;
@@ -557,6 +565,25 @@ namespace chaiscript
 
           return m;
         }
+
+
+
+      /// Add a MapType container
+      /// http://www.sgi.com/tech/stl/Map.html
+      template<typename FutureType>
+        ModulePtr future_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
+        {
+          m->add(user_type<FutureType>(), type);
+
+          m->add(fun<bool (const FutureType &)>([](const FutureType &t) { return t.valid(); }), "valid");
+          m->add(fun(&FutureType::get), "get");
+          m->add(fun(&FutureType::wait), "wait");
+
+          return m;
+        }
+
+
+
     }
   }
 }

include/chaiscript/dispatchkit/boxed_cast.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOXED_CAST_HPP_
@@ -14,11 +14,11 @@
 #include "bad_boxed_cast.hpp"
 #include "boxed_cast_helper.hpp"
 #include "boxed_value.hpp"
-#include "dynamic_cast_conversion.hpp"
+#include "type_conversions.hpp"
 #include "type_info.hpp"
 
 namespace chaiscript {
-class Dynamic_Cast_Conversions;
+class Type_Conversions;
 namespace detail {
 namespace exception {
 class bad_any_cast;
@@ -72,7 +72,7 @@ namespace chaiscript
   /// assert(i == 5);
   /// \endcode
   template<typename Type>
-  typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv, const Dynamic_Cast_Conversions *t_conversions = nullptr)
+  typename detail::Cast_Helper<Type>::Result_Type boxed_cast(const Boxed_Value &bv, const Type_Conversions *t_conversions = nullptr)
   {
     try {
       return detail::Cast_Helper<Type>::cast(bv, t_conversions);
@@ -86,18 +86,18 @@ namespace chaiscript
 #pragma warning(disable : 4127)
 #endif
 
-      if (std::is_polymorphic<typename detail::Stripped_Type<Type>::type>::value && t_conversions)
+      if (t_conversions && t_conversions->convertable_type<Type>())
       {
         try {
-          // std::cout << "trying an up conversion " << typeid(Type).name() << std::endl;
+          // std::cout << "trying an up conversion " << typeid(Type).name() << '\n';
           // We will not catch any bad_boxed_dynamic_cast that is thrown, let the user get it
           // either way, we are not responsible if it doesn't work
-          return detail::Cast_Helper<Type>::cast(t_conversions->boxed_dynamic_cast<Type>(bv), t_conversions);
+          return detail::Cast_Helper<Type>::cast(t_conversions->boxed_type_conversion<Type>(bv), t_conversions);
         } catch (...) {
           try {
-          //  std::cout << "trying a down conversion " << typeid(Type).name() << std::endl;
+          //  std::cout << "trying a down conversion " << typeid(Type).name() << '\n';
             // try going the other way - down the inheritance graph
-            return detail::Cast_Helper<Type>::cast(t_conversions->boxed_dynamic_down_cast<Type>(bv), t_conversions);
+            return detail::Cast_Helper<Type>::cast(t_conversions->boxed_type_down_conversion<Type>(bv), t_conversions);
           } catch (const chaiscript::detail::exception::bad_any_cast &) {
             throw exception::bad_boxed_cast(bv.get_type_info(), typeid(Type));
           }

include/chaiscript/dispatchkit/boxed_cast_helper.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOXED_CAST_HELPER_HPP_
@@ -17,37 +17,32 @@
 
 namespace chaiscript 
 {
-  class Dynamic_Cast_Conversions;
+  class Type_Conversions;
 
   namespace detail
   {
     // Cast_Helper_Inner helper classes
 
-    /**
-     * Generic Cast_Helper_Inner, for casting to any type
-     */
+    template<typename T>
+      T* throw_if_null(T *t)
+      {
+        if (t) return t;
+        throw std::runtime_error("Attempted to dereference null Boxed_Value");
+      }
+
+    /// Generic Cast_Helper_Inner, for casting to any type
     template<typename Result>
       struct Cast_Helper_Inner
       {
         typedef typename std::reference_wrapper<typename std::add_const<Result>::type > Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
-          if (ob.is_ref())
+          if (ob.get_type_info().bare_equal_type_info(typeid(Result)))
           {
-            if (!ob.get_type_info().is_const())
-            {
-              return std::cref((ob.get().cast<std::reference_wrapper<Result> >()).get());
-            } else {
-              return ob.get().cast<std::reference_wrapper<const Result> >();
-            }
+            return *(static_cast<const Result *>(throw_if_null(ob.get_const_ptr())));
           } else {
-            if (!ob.get_type_info().is_const())
-            {
-              return std::cref(*(ob.get().cast<std::shared_ptr<Result> >()));   
-            } else {
-              return std::cref(*(ob.get().cast<std::shared_ptr<const Result> >()));   
-            }
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
@@ -57,23 +52,18 @@ namespace chaiscript
       {
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a const & type
-     */
+    /// Cast_Helper_Inner for casting to a const & type
     template<typename Result>
       struct Cast_Helper_Inner<const Result &> : Cast_Helper_Inner<Result>
       {
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a const * type
-     */
+    /// Cast_Helper_Inner for casting to a const * type
     template<typename Result>
       struct Cast_Helper_Inner<const Result *>
       {
         typedef const Result * Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
           if (ob.is_ref())
           {
@@ -94,15 +84,12 @@ namespace chaiscript
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a * type
-     */
+    /// Cast_Helper_Inner for casting to a * type
     template<typename Result>
       struct Cast_Helper_Inner<Result *>
       {
         typedef Result * Result_Type;
-
-        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
           if (ob.is_ref())
           {
@@ -113,49 +100,43 @@ namespace chaiscript
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a & type
-     */
+
+    /// Cast_Helper_Inner for casting to a & type
     template<typename Result>
       struct Cast_Helper_Inner<Result &>
       {
         typedef Result& Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
-          if (ob.is_ref())
+          if (!ob.get_type_info().is_const() && ob.get_type_info().bare_equal_type_info(typeid(Result)))
           {
-            return ob.get().cast<std::reference_wrapper<Result> >();
+            return *(static_cast<Result *>(throw_if_null(ob.get_ptr())));
           } else {
-            Result &r = *(ob.get().cast<std::shared_ptr<Result> >());
-            return r;
+            throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a std::shared_ptr<> type
-     */
+    /// Cast_Helper_Inner for casting to a std::shared_ptr<> type
     template<typename Result>
       struct Cast_Helper_Inner<typename std::shared_ptr<Result> >
       {
         typedef typename std::shared_ptr<Result> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
           return ob.get().cast<std::shared_ptr<Result> >();
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a std::shared_ptr<const> type
-     */
+    /// Cast_Helper_Inner for casting to a std::shared_ptr<const> type
     template<typename Result>
       struct Cast_Helper_Inner<typename std::shared_ptr<const Result> >
       {
         typedef typename std::shared_ptr<const Result> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
           if (!ob.get_type_info().is_const())
           {
@@ -166,9 +147,7 @@ namespace chaiscript
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a const std::shared_ptr<> & type
-     */
+    /// Cast_Helper_Inner for casting to a const std::shared_ptr<> & type
     template<typename Result>
       struct Cast_Helper_Inner<const std::shared_ptr<Result> > : Cast_Helper_Inner<std::shared_ptr<Result> >
       {
@@ -180,9 +159,7 @@ namespace chaiscript
       };
 
 
-    /**
-     * Cast_Helper_Inner for casting to a const std::shared_ptr<const> & type
-     */
+    /// Cast_Helper_Inner for casting to a const std::shared_ptr<const> & type
     template<typename Result>
       struct Cast_Helper_Inner<const std::shared_ptr<const Result> > : Cast_Helper_Inner<std::shared_ptr<const Result> >
       {
@@ -195,23 +172,32 @@ namespace chaiscript
 
 
 
-    /**
-     * Cast_Helper_Inner for casting to a Boxed_Value type
-     */
+    /// Cast_Helper_Inner for casting to a Boxed_Value type
     template<>
       struct Cast_Helper_Inner<Boxed_Value>
       {
         typedef const Boxed_Value & Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
-          return ob;    
+          return ob;
         }
       };
 
-    /**
-     * Cast_Helper_Inner for casting to a const Boxed_Value & type
-     */
+    /// Cast_Helper_Inner for casting to a Boxed_Value & type
+    template<>
+      struct Cast_Helper_Inner<Boxed_Value &>
+      {
+        typedef Boxed_Value& Result_Type;
+
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
+        {
+          return const_cast<Boxed_Value &>(ob);
+        }
+      };
+
+
+    /// Cast_Helper_Inner for casting to a const Boxed_Value & type
     template<>
       struct Cast_Helper_Inner<const Boxed_Value> : Cast_Helper_Inner<Boxed_Value>
       {
@@ -223,9 +209,7 @@ namespace chaiscript
       };
 
 
-    /**
-     * Cast_Helper_Inner for casting to a std::reference_wrapper type
-     */
+    /// Cast_Helper_Inner for casting to a std::reference_wrapper type
     template<typename Result>
       struct Cast_Helper_Inner<std::reference_wrapper<Result> > : Cast_Helper_Inner<Result &>
       {
@@ -256,15 +240,13 @@ namespace chaiscript
       {
       };
 
-    /**
-     * The exposed Cast_Helper object that by default just calls the Cast_Helper_Inner
-     */
+    /// The exposed Cast_Helper object that by default just calls the Cast_Helper_Inner
     template<typename T>
       struct Cast_Helper
       {
         typedef typename Cast_Helper_Inner<T>::Result_Type Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *t_conversions)
         {
           return Cast_Helper_Inner<T>::cast(ob, t_conversions);
         }

include/chaiscript/dispatchkit/boxed_number.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOXED_NUMERIC_HPP_
@@ -19,9 +19,22 @@
 #include "type_info.hpp"
 
 namespace chaiscript {
-class Dynamic_Cast_Conversions;
+class Type_Conversions;
 }  // namespace chaiscript
 
+namespace chaiscript
+{
+  namespace exception
+  {
+    struct arithmetic_error : public std::runtime_error
+    {
+      arithmetic_error(const std::string& reason) : std::runtime_error("Arithmetic error: " + reason) {}
+      arithmetic_error(const arithmetic_error &) = default;
+      virtual ~arithmetic_error() CHAISCRIPT_NOEXCEPT {}
+    };
+  }
+}
+
 namespace chaiscript 
 {
 
@@ -33,16 +46,37 @@ namespace chaiscript
 #pragma warning(disable : 4244 4018 4389 4146 4365)
 #endif
 
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
   /// \brief Represents any numeric type, generically. Used internally for generic operations between POD values
   class Boxed_Number
   {
     private:
+      template<typename T>
+      static void check_divide_by_zero(T t, typename std::enable_if<std::is_integral<T>::value>::type* = 0)
+      {
+#ifndef CHAISCRIPT_NO_PROTECT_DIVIDEBYZERO
+        if (t == 0) {
+          throw chaiscript::exception::arithmetic_error("divide by zero");
+        }
+#endif
+      }
+
+      template<typename T>
+      static void check_divide_by_zero(T, typename std::enable_if<std::is_floating_point<T>::value>::type* = 0)
+      {
+      }
+
       struct boolean
       {
 
-#ifdef __GNUC__
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#endif
         template<typename T, typename U>
         static Boxed_Value go(Operators::Opers t_oper, const T &t, const U &u, const Boxed_Value &)
         {
@@ -61,7 +95,7 @@ namespace chaiscript
             case Operators::not_equal:
               return const_var(t != u);
             default:
-              throw chaiscript::detail::exception::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
@@ -89,13 +123,14 @@ namespace chaiscript
               t += u;
               break;
             case Operators::assign_quotient:
+              check_divide_by_zero(u);
               t /= u;
               break;
             case Operators::assign_difference:
               t -= u;
               break;
             default:
-              throw chaiscript::detail::exception::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();
           }
 
           return t_lhs;
@@ -122,13 +157,14 @@ namespace chaiscript
               t >>= u;
               break;
             case Operators::assign_remainder:
+              check_divide_by_zero(u);
               t %= u;
               break;
             case Operators::assign_bitwise_xor:
               t ^= u;
               break;
             default:
-              throw chaiscript::detail::exception::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();
           }
           return t_lhs;
         }
@@ -146,6 +182,7 @@ namespace chaiscript
             case Operators::shift_right:
               return const_var(t >> u);
             case Operators::remainder:
+              check_divide_by_zero(u);
               return const_var(t % u);
             case Operators::bitwise_and:
               return const_var(t & u);
@@ -156,7 +193,7 @@ namespace chaiscript
             case Operators::bitwise_complement:
               return const_var(~t);
             default:
-              throw chaiscript::detail::exception::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
@@ -171,6 +208,7 @@ namespace chaiscript
             case Operators::sum:
               return const_var(t + u);
             case Operators::quotient:
+              check_divide_by_zero(u);
               return const_var(t / u);
             case Operators::product:
               return const_var(t * u);
@@ -181,7 +219,7 @@ namespace chaiscript
             case Operators::unary_plus:
               return const_var(+t);
             default:
-              throw chaiscript::detail::exception::bad_any_cast();        
+              throw chaiscript::detail::exception::bad_any_cast();
           }
         }
       };
@@ -233,7 +271,7 @@ namespace chaiscript
       template<typename LHS, bool Float>
         static Boxed_Value oper_rhs(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
         {
-          const Type_Info &inp_ = t_rhs.get_type_info();
+          const auto &inp_ = t_rhs.get_type_info();
 
           if (inp_ == typeid(int)) {
             return Go<LHS, int, Float>::go(t_oper, t_lhs, t_rhs);
@@ -327,19 +365,25 @@ namespace chaiscript
           return oss.str();
         }
 
-      
     public:
       Boxed_Number()
         : bv(Boxed_Value(0))
       {
       }
 
-      Boxed_Number(const Boxed_Value &v)
-        : bv(v)
+      Boxed_Number(Boxed_Value v)
+        : bv(std::move(v))
       {
-        validate_boxed_number(v);
+        validate_boxed_number(bv);
       }
 
+      Boxed_Number(const Boxed_Number &) = default;
+
+#if !defined(_MSC_VER) || _MSC_VER  != 1800
+      Boxed_Number(Boxed_Number &&) = default;
+      Boxed_Number& operator=(Boxed_Number &&) = default;
+#endif
+
       template<typename T> explicit Boxed_Number(T t)
         : bv(Boxed_Value(t))
       {
@@ -547,6 +591,7 @@ namespace chaiscript
         }
       }
 
+      // cppcheck-suppress operatorEq
       Boxed_Number operator=(const Boxed_Value &v)
       {
         validate_boxed_number(v);
@@ -554,6 +599,7 @@ namespace chaiscript
         return *this;
       }
 
+      // cppcheck-suppress operatorEq
       Boxed_Number operator=(const Boxed_Number &t_rhs) const
       {
         return oper(Operators::assign, this->bv, t_rhs.bv);
@@ -826,37 +872,35 @@ namespace chaiscript
 
   namespace detail
   {
-    /**
-     * Cast_Helper for converting from Boxed_Value to Boxed_Number
-     */
+    /// Cast_Helper for converting from Boxed_Value to Boxed_Number
     template<>
       struct Cast_Helper<Boxed_Number>
       {
         typedef Boxed_Number Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *)
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
         {
           return Boxed_Number(ob);
         }
       };
 
-    /**
-     * Cast_Helper for converting from Boxed_Value to Boxed_Number
-     */
+    /// Cast_Helper for converting from Boxed_Value to Boxed_Number
     template<>
       struct Cast_Helper<const Boxed_Number &> : Cast_Helper<Boxed_Number>
       {
       };
-      
-    /**
-     * Cast_Helper for converting from Boxed_Value to Boxed_Number
-     */
+
+    /// Cast_Helper for converting from Boxed_Value to Boxed_Number
     template<>
       struct Cast_Helper<const Boxed_Number> : Cast_Helper<Boxed_Number>
       {
-      };  
+      };
   }
 
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
 #ifdef CHAISCRIPT_MSVC
 #pragma warning(pop)
 #endif

include/chaiscript/dispatchkit/boxed_value.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_BOXED_VALUE_HPP_
@@ -13,6 +13,7 @@
 #include <type_traits>
 
 #include "../chaiscript_threading.hpp"
+#include "../chaiscript_defines.hpp"
 #include "any.hpp"
 #include "type_info.hpp"
 
@@ -35,10 +36,10 @@ namespace chaiscript
       struct Data
       {
         Data(const Type_Info &ti,
-            const chaiscript::detail::Any &to,
+            chaiscript::detail::Any to,
             bool tr,
             const void *t_void_ptr)
-          : m_type_info(ti), m_obj(to), m_data_ptr(ti.is_const()?nullptr:const_cast<void *>(t_void_ptr)), m_const_data_ptr(t_void_ptr),
+          : m_type_info(ti), m_obj(std::move(to)), m_data_ptr(ti.is_const()?nullptr:const_cast<void *>(t_void_ptr)), m_const_data_ptr(t_void_ptr),
             m_is_ref(tr)
         {
         }
@@ -51,17 +52,27 @@ namespace chaiscript
           m_data_ptr = rhs.m_data_ptr;
           m_const_data_ptr = rhs.m_const_data_ptr;
 
+          if (rhs.m_attrs)
+          {
+            m_attrs = std::unique_ptr<std::map<std::string, Boxed_Value>>(new std::map<std::string, Boxed_Value>(*rhs.m_attrs));
+          }
+
           return *this;
         }
 
-        ~Data()
-        {
-        }
+        Data(const Data &) = delete;
+
+#if !defined(__APPLE__) && (!defined(_MSC_VER) || _MSC_VER != 1800)
+        Data(Data &&) = default;
+        Data &operator=(Data &&rhs) = default;
+#endif
+
 
         Type_Info m_type_info;
         chaiscript::detail::Any m_obj;
         void *m_data_ptr;
         const void *m_const_data_ptr;
+        std::unique_ptr<std::map<std::string, Boxed_Value>> m_attrs;
         bool m_is_ref;
       };
 
@@ -94,32 +105,53 @@ namespace chaiscript
                 );
           }
 
+        template<typename T>
+          static std::shared_ptr<Data> get(std::shared_ptr<T> &&obj)
+          {
+            auto ptr = obj.get();
+            return std::make_shared<Data>(
+                  detail::Get_Type_Info<T>::get(), 
+                  chaiscript::detail::Any(std::move(obj)), 
+                  false,
+                  ptr
+                );
+          }
+
         template<typename T>
           static std::shared_ptr<Data> get(T *t)
           {
             return get(std::ref(*t));
           }
 
+        template<typename T>
+          static std::shared_ptr<Data> get(const T *t)
+          {
+            return get(std::cref(*t));
+          }
+
+
         template<typename T>
           static std::shared_ptr<Data> get(std::reference_wrapper<T> obj)
           {
+            auto p = &obj.get();
             return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(),
-                  chaiscript::detail::Any(obj),
+                  chaiscript::detail::Any(std::move(obj)),
                   true,
-                  &obj.get()
+                  p
                 );
           }
 
         template<typename T>
-          static std::shared_ptr<Data> get(const T& t)
+          static std::shared_ptr<Data> get(T t)
           {
-            auto p = std::make_shared<T>(t);
+            auto p = std::make_shared<T>(std::move(t));
+            auto ptr = p.get();
             return std::make_shared<Data>(
                   detail::Get_Type_Info<T>::get(), 
-                  chaiscript::detail::Any(p), 
+                  chaiscript::detail::Any(std::move(p)),
                   false,
-                  p.get()
+                  ptr
                 );
           }
 
@@ -137,27 +169,26 @@ namespace chaiscript
 
     public:
       /// Basic Boxed_Value constructor
-      template<typename T>
-        explicit Boxed_Value(T t)
-        : m_data(Object_Data::get(t))
+        template<typename T,
+          typename = typename std::enable_if<!std::is_same<Boxed_Value, typename std::decay<T>::type>::value>::type>
+        explicit Boxed_Value(T &&t)
+          : m_data(Object_Data::get(std::forward<T>(t)))
         {
         }
 
-      /// Copy constructor - each copy shares the same data pointer
-      Boxed_Value(const Boxed_Value &t_so)
-        : m_data(t_so.m_data)
-      {
-      }
-
       /// Unknown-type constructor
       Boxed_Value()
         : m_data(Object_Data::get())
       {
       }
 
-      ~Boxed_Value()
-      {
-      }
+#if !defined(_MSC_VER) || _MSC_VER != 1800
+      Boxed_Value(Boxed_Value&&) = default;
+      Boxed_Value& operator=(Boxed_Value&&) = default;
+#endif
+
+      Boxed_Value(const Boxed_Value&) = default;
+      Boxed_Value& operator=(const Boxed_Value&) = default;
 
       void swap(Boxed_Value &rhs)
       {
@@ -172,67 +203,79 @@ namespace chaiscript
         return *this;
       }
 
-      /// shared data assignment, same as copy construction
-      Boxed_Value &operator=(const Boxed_Value &rhs)
-      {
-        Boxed_Value temp(rhs);
-        swap(temp);
-        return *this;
-      }
-
-      const Type_Info &get_type_info() const
+      const Type_Info &get_type_info() const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_type_info;
       }
 
       /// return true if the object is uninitialized
-      bool is_undef() const
+      bool is_undef() const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_type_info.is_undef();
       }
 
-      bool is_const() const
+      bool is_const() const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_type_info.is_const();
       }
 
-      bool is_type(const Type_Info &ti) const
+      bool is_type(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_type_info.bare_equal(ti);
       }
 
-      bool is_null() const
+      bool is_null() const CHAISCRIPT_NOEXCEPT
       {
         return (m_data->m_data_ptr == nullptr && m_data->m_const_data_ptr == nullptr);
       }
 
-      const chaiscript::detail::Any & get() const
+      const chaiscript::detail::Any & get() const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_obj;
       }
 
-      bool is_ref() const
+      bool is_ref() const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_is_ref;
       }
 
-      bool is_pointer() const
+      bool is_pointer() const CHAISCRIPT_NOEXCEPT
       {
         return !is_ref();
       }
 
-      void *get_ptr() const
+      void *get_ptr() const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_data_ptr;
       }
 
-      const void *get_const_ptr() const
+      const void *get_const_ptr() const CHAISCRIPT_NOEXCEPT
       {
         return m_data->m_const_data_ptr;
       }
 
+      Boxed_Value get_attr(const std::string &t_name)
+      {
+        if (!m_data->m_attrs)
+        {
+          m_data->m_attrs = std::unique_ptr<std::map<std::string, Boxed_Value>>(new std::map<std::string, Boxed_Value>());
+        }
+
+        return (*m_data->m_attrs)[t_name];
+      }
+
+      Boxed_Value &copy_attrs(const Boxed_Value &t_obj)
+      {
+        if (t_obj.m_data->m_attrs)
+        {
+          m_data->m_attrs = std::unique_ptr<std::map<std::string, Boxed_Value>>(new std::map<std::string, Boxed_Value>(*t_obj.m_data->m_attrs));
+        }
+        return *this;
+      }
+
+
       /// \returns true if the two Boxed_Values share the same internal type
-      static bool type_match(Boxed_Value l, Boxed_Value r)
+      static bool type_match(const Boxed_Value &l, const Boxed_Value &r) CHAISCRIPT_NOEXCEPT
       {
         return l.get_type_info() == r.get_type_info();
       }
@@ -269,7 +312,7 @@ namespace chaiscript
     template<typename T>
       Boxed_Value const_var_impl(const T &t)
       {
-        return Boxed_Value(std::shared_ptr<typename std::add_const<T>::type >(new T(t)));
+        return Boxed_Value(std::make_shared<typename std::add_const<T>::type >(t));
       }
 
     /// \brief Takes a pointer to a value, adds const to the pointed to type and returns an immutable Boxed_Value.

include/chaiscript/dispatchkit/dynamic_cast_conversion.hpp

@@ -1,294 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-#ifndef CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
-#define CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
-
-#include <memory>
-#include <set>
-#include <stdexcept>
-#include <string>
-#include <type_traits>
-#include <typeinfo>
-
-#include "../chaiscript_threading.hpp"
-#include "bad_boxed_cast.hpp"
-#include "boxed_cast_helper.hpp"
-#include "boxed_value.hpp"
-#include "type_info.hpp"
-
-namespace chaiscript
-{
-  namespace exception
-  {
-    class bad_boxed_dynamic_cast : public bad_boxed_cast
-    {
-      public:
-        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to,
-            const std::string &t_what) CHAISCRIPT_NOEXCEPT
-          : bad_boxed_cast(t_from, t_to, t_what)
-        {
-        }
-
-        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to) CHAISCRIPT_NOEXCEPT
-          : bad_boxed_cast(t_from, t_to)
-        {
-        }
-
-        bad_boxed_dynamic_cast(const std::string &w) CHAISCRIPT_NOEXCEPT
-          : bad_boxed_cast(w)
-        {
-        }
-
-        virtual ~bad_boxed_dynamic_cast() CHAISCRIPT_NOEXCEPT {}
-    };
-  }
-
-  namespace detail
-  {
-    class Dynamic_Conversion
-    {
-      public:
-        virtual Boxed_Value convert(const Boxed_Value &derived) const = 0;
-        virtual Boxed_Value convert_down(const Boxed_Value &base) const = 0;
-
-        const Type_Info &base() const
-        {
-          return m_base;
-        }
-        const Type_Info &derived() const
-        {
-          return m_derived;
-        }
-
-      protected:
-        Dynamic_Conversion(const Type_Info &t_base, const Type_Info &t_derived)
-          : m_base(t_base), m_derived(t_derived)
-        {
-        }
-
-        virtual ~Dynamic_Conversion() {} 
-
-      private:
-        Type_Info m_base;
-        Type_Info m_derived;
-
-    };
-
-    template<typename From, typename To> 
-      class Dynamic_Caster
-      {
-        public: 
-          static Boxed_Value cast(const Boxed_Value &t_from)
-          {
-            if (t_from.get_type_info().bare_equal(user_type<From>()))
-            {
-              if (t_from.is_pointer())
-              {
-                // Dynamic cast out the contained boxed value, which we know is the type we want
-                if (t_from.is_const())
-                {
-                  std::shared_ptr<const To> data
-                    = std::dynamic_pointer_cast<const To>(detail::Cast_Helper<std::shared_ptr<const From> >::cast(t_from, nullptr));
-                  if (!data)
-                  {
-                    throw std::bad_cast();
-                  }
-
-                  return Boxed_Value(data);
-                } else {
-                  std::shared_ptr<To> data
-                    = std::dynamic_pointer_cast<To>(detail::Cast_Helper<std::shared_ptr<From> >::cast(t_from, nullptr));
-
-                  if (!data)
-                  {
-                    throw std::bad_cast();
-                  }
-
-                  return Boxed_Value(data);
-                }
-              } else {
-                // Pull the reference out of the contained boxed value, which we know is the type we want
-                if (t_from.is_const())
-                {
-                  const From &d = detail::Cast_Helper<const From &>::cast(t_from, nullptr);
-                  const To &data = dynamic_cast<const To &>(d);
-                  return Boxed_Value(std::cref(data));
-                } else {
-                  From &d = detail::Cast_Helper<From &>::cast(t_from, nullptr);
-                  To &data = dynamic_cast<To &>(d);
-                  return Boxed_Value(std::ref(data));
-                }
-              }
-            } else {
-              throw chaiscript::exception::bad_boxed_dynamic_cast(t_from.get_type_info(), typeid(To), "Unknown dynamic_cast_conversion");
-            }
-          }
-      };
-
-    template<typename Base, typename Derived>
-      class Dynamic_Conversion_Impl : public Dynamic_Conversion
-    {
-      public:
-        Dynamic_Conversion_Impl()
-          : Dynamic_Conversion(user_type<Base>(), user_type<Derived>())
-        {
-        }
-
-        virtual Boxed_Value convert_down(const Boxed_Value &t_base) const CHAISCRIPT_OVERRIDE
-        {
-          return Dynamic_Caster<Base, Derived>::cast(t_base);
-        }
-
-        virtual Boxed_Value convert(const Boxed_Value &t_derived) const CHAISCRIPT_OVERRIDE
-        {
-          return Dynamic_Caster<Derived, Base>::cast(t_derived);
-        }
-    };
-  }
-
-  class Dynamic_Cast_Conversions
-  {
-    public:
-      Dynamic_Cast_Conversions()
-      {
-      }
-
-      Dynamic_Cast_Conversions(const Dynamic_Cast_Conversions &t_other)
-        : m_conversions(t_other.get_conversions())
-      {
-      }
-
-      void add_conversion(const std::shared_ptr<detail::Dynamic_Conversion> &conversion)
-      {
-        chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-        m_conversions.insert(conversion);
-      }
-
-      template<typename Base, typename Derived>
-        bool dynamic_cast_converts() const
-        {
-          return dynamic_cast_converts(user_type<Base>(), user_type<Derived>());
-        }
-
-      bool dynamic_cast_converts(const Type_Info &base, const Type_Info &derived) const
-      {
-        return has_conversion(base, derived) || has_conversion(derived, base);
-      }
-
-      template<typename Base>
-        Boxed_Value boxed_dynamic_cast(const Boxed_Value &derived) const
-        {
-          try {
-            return get_conversion(user_type<Base>(), derived.get_type_info())->convert(derived);
-          } catch (const std::out_of_range &) {
-            throw exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "No known conversion");
-          } catch (const std::bad_cast &) {
-            throw exception::bad_boxed_dynamic_cast(derived.get_type_info(), typeid(Base), "Unable to perform dynamic_cast operation");
-          }
-        }
-
-      template<typename Derived>
-        Boxed_Value boxed_dynamic_down_cast(const Boxed_Value &base) const
-        {
-          try {
-            return get_conversion(base.get_type_info(), user_type<Derived>())->convert_down(base);
-          } catch (const std::out_of_range &) {
-            throw exception::bad_boxed_dynamic_cast(base.get_type_info(), typeid(Derived), "No known conversion");
-          } catch (const std::bad_cast &) {
-            throw exception::bad_boxed_dynamic_cast(base.get_type_info(), typeid(Derived), "Unable to perform dynamic_cast operation");
-          }
-        }
-
-
-      bool has_conversion(const Type_Info &base, const Type_Info &derived) const
-      {
-        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-        return find(base, derived) != m_conversions.end();
-      }
-
-      std::shared_ptr<detail::Dynamic_Conversion> get_conversion(const Type_Info &base, const Type_Info &derived) const
-      {
-        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-        auto itr =
-          find(base, derived);
-
-        if (itr != m_conversions.end())
-        {
-          return *itr;
-        } else {
-          throw std::out_of_range("No such conversion exists from " + derived.bare_name() + " to " + base.bare_name());
-        }
-      }
-
-    private:
-      std::set<std::shared_ptr<detail::Dynamic_Conversion> >::const_iterator find(
-          const Type_Info &base, const Type_Info &derived) const
-      {
-        for (auto itr = m_conversions.begin();
-            itr != m_conversions.end();
-            ++itr)
-        {
-          if ((*itr)->base().bare_equal(base) && (*itr)->derived().bare_equal(derived))
-          {
-            return itr;
-          }
-        }
-
-        return m_conversions.end();
-      }
-
-      std::set<std::shared_ptr<detail::Dynamic_Conversion> > get_conversions() const
-      {
-        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
-
-        return m_conversions;
-      }
-
-      mutable chaiscript::detail::threading::shared_mutex m_mutex;
-      std::set<std::shared_ptr<detail::Dynamic_Conversion> > m_conversions;
-  };
-
-  typedef std::shared_ptr<chaiscript::detail::Dynamic_Conversion> Dynamic_Cast_Conversion;
-
-  /// \brief Used to register a base / parent class relationship with ChaiScript. Necessary if you
-  ///        want automatic conversions up your inheritance hierarchy.
-  ///
-  /// Create a new base class registration for applying to a module or to the chaiscript engine
-  /// Currently, due to limitations in module loading on Windows, and for the sake of portability,
-  /// if you have a type that is introduced in a loadable module and is used by multiple modules
-  /// (through a tertiary dll that is shared between the modules, static linking the new type
-  /// into both loadable modules would not be portable), you need to register the base type
-  /// relationship in all modules that use the newly added type in a polymorphic way.
-  ///
-  /// Example:
-  /// \code
-  /// class Base
-  /// {};
-  /// class Derived : public Base
-  /// {};
-  ///
-  /// chaiscript::ChaiScript chai;
-  /// chai.add(chaiscript::base_class<Base, Derived>());
-  /// \endcode
-  /// 
-  template<typename Base, typename Derived>
-  Dynamic_Cast_Conversion base_class()
-  {
-    //Can only be used with related polymorphic types
-    //may be expanded some day to support conversions other than child -> parent
-    static_assert(std::is_base_of<Base,Derived>::value, "Classes are not related by inheritance");
-    static_assert(std::is_polymorphic<Base>::value, "Base class must be polymorphic");
-    static_assert(std::is_polymorphic<Derived>::value, "Derived class must be polymorphic");
-
-    return std::shared_ptr<detail::Dynamic_Conversion>(new detail::Dynamic_Conversion_Impl<Base, Derived>());
-  }
-
-}
-
-
-#endif

include/chaiscript/dispatchkit/dynamic_object.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_DYNAMIC_OBJECT_HPP_
@@ -19,11 +19,10 @@
 #include "boxed_cast.hpp"
 #include "boxed_cast_helper.hpp"
 #include "boxed_value.hpp"
-#include "proxy_functions.hpp"
 #include "type_info.hpp"
 
 namespace chaiscript {
-class Dynamic_Cast_Conversions;
+class Type_Conversions;
 namespace dispatch {
 class Proxy_Function_Base;
 }  // namespace dispatch
@@ -62,234 +61,6 @@ namespace chaiscript
         std::map<std::string, Boxed_Value> m_attrs;
     };
 
-    namespace detail
-    {
-      /**
-       * 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(
-              std::string t_type_name,
-              const Proxy_Function &t_func)
-            : Proxy_Function_Base(t_func->get_param_types()),
-            m_type_name(std::move(t_type_name)), m_func(t_func), m_doti(user_type<Dynamic_Object>())
-          {
-            assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
-                && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
-          }
-
-          Dynamic_Object_Function(
-              std::string t_type_name,
-              const Proxy_Function &t_func,
-              const Type_Info &t_ti)
-            : Proxy_Function_Base(build_param_types(t_func->get_param_types(), t_ti)),
-              m_type_name(std::move(t_type_name)), m_func(t_func), m_ti(new Type_Info(t_ti)), m_doti(user_type<Dynamic_Object>())
-          {
-            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() {}
-
-          Dynamic_Object_Function &operator=(const Dynamic_Object_Function) = delete;
-
-          virtual bool operator==(const Proxy_Function_Base &f) const CHAISCRIPT_OVERRIDE
-          {
-            const Dynamic_Object_Function *df = dynamic_cast<const Dynamic_Object_Function *>(&f);
-            if (df)
-            {
-              return df->m_type_name == m_type_name && (*df->m_func) == (*m_func);
-            } else {
-              return false;
-            }
-          }
-
-          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
-          {
-            if (dynamic_object_typename_match(vals, m_type_name, m_ti, t_conversions))
-            {
-              return m_func->call_match(vals, t_conversions);
-            } else {
-              return false;
-            }
-          }    
-
-          virtual std::vector<Const_Proxy_Function> get_contained_functions() const CHAISCRIPT_OVERRIDE
-          {
-            return {m_func};
-          }
-
-
-          virtual int get_arity() const CHAISCRIPT_OVERRIDE
-          {
-            return m_func->get_arity();
-          }
-
-          virtual std::string annotation() const CHAISCRIPT_OVERRIDE
-          {
-            return m_func->annotation();
-          }
-
-
-        protected:
-          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
-          {
-            if (dynamic_object_typename_match(params, m_type_name, m_ti, t_conversions))
-            {
-              return (*m_func)(params, t_conversions);
-            } else {
-              throw exception::guard_error();
-            } 
-          }
-
-          virtual bool compare_first_type(const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
-          {
-            return dynamic_object_typename_match(bv, m_type_name, m_ti, t_conversions);
-          }
-
-        private:
-          static std::vector<Type_Info> build_param_types(
-              const std::vector<Type_Info> &t_inner_types, const Type_Info& t_objectti)
-          {
-            std::vector<Type_Info> types(t_inner_types);
-
-            assert(types.size() > 1);
-            assert(types[1].bare_equal(user_type<Boxed_Value>()));
-            types[1] = t_objectti;
-            return types;
-          }
-
-          bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
-              const std::shared_ptr<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions) const
-          {
-            if (bv.get_type_info().bare_equal(m_doti))
-            {
-              try {
-                const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv, &t_conversions);
-                return name == "Dynamic_Object" || d.get_type_name() == name;
-              } catch (const std::bad_cast &) {
-                return false;
-              } 
-            } else {
-              if (ti)
-              {
-                return bv.get_type_info().bare_equal(*ti);
-              } else {
-                return false;
-              }
-            }
-
-          }
-
-          bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
-              const std::shared_ptr<Type_Info> &ti, const Dynamic_Cast_Conversions &t_conversions) const
-          {
-            if (bvs.size() > 0)
-            {
-              return dynamic_object_typename_match(bvs[0], name, ti, t_conversions);
-            } else {
-              return false;
-            }
-          }
-
-          std::string m_type_name;
-          Proxy_Function m_func;
-          std::shared_ptr<Type_Info> m_ti;
-          const Type_Info m_doti;
-
-
-      };
-
-
-      /**
-       * 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(
-              std::string t_type_name,
-              const Proxy_Function &t_func)
-            : Proxy_Function_Base(build_type_list(t_func->get_param_types())),
-              m_type_name(std::move(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)
-          {
-            auto begin = tl.begin();
-            auto 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 CHAISCRIPT_OVERRIDE
-          {
-            const Dynamic_Object_Constructor *dc = dynamic_cast<const Dynamic_Object_Constructor*>(&f);
-            if (dc)
-            {
-              return dc->m_type_name == m_type_name && (*dc->m_func) == (*m_func);
-            } else {
-              return false;
-            }
-          }
-
-          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
-          {
-            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, t_conversions);
-          }    
-
-
-          virtual int get_arity() const CHAISCRIPT_OVERRIDE
-          {
-            // "this" is not considered part of the arity
-            return m_func->get_arity() - 1; 
-          }
-
-          virtual std::string annotation() const CHAISCRIPT_OVERRIDE
-          {
-            return m_func->annotation();
-          }
-
-        protected:
-          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
-          {
-            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, t_conversions);
-
-            return bv;
-          }
-
-        private:
-          std::string m_type_name;
-          Proxy_Function m_func;
-
-      };
-    }
   }
 }
 #endif

include/chaiscript/dispatchkit/dynamic_object_detail.hpp

@@ -0,0 +1,251 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_DYNAMIC_OBJECT_DETAIL_HPP_
+#define CHAISCRIPT_DYNAMIC_OBJECT_DETAIL_HPP_
+
+#include <cassert>
+#include <map>
+#include <memory>
+#include <string>
+#include <typeinfo>
+#include <utility>
+#include <vector>
+
+#include "../chaiscript_defines.hpp"
+#include "boxed_cast.hpp"
+#include "boxed_cast_helper.hpp"
+#include "boxed_value.hpp"
+#include "proxy_functions.hpp"
+#include "type_info.hpp"
+#include "dynamic_object.hpp"
+
+namespace chaiscript {
+class Type_Conversions;
+namespace dispatch {
+class Proxy_Function_Base;
+}  // namespace dispatch
+}  // namespace chaiscript
+
+namespace chaiscript
+{
+  namespace dispatch
+  {
+    namespace detail
+    {
+      /// 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(
+              std::string t_type_name,
+              const Proxy_Function &t_func)
+            : Proxy_Function_Base(t_func->get_param_types(), t_func->get_arity()),
+            m_type_name(std::move(t_type_name)), m_func(t_func), m_doti(user_type<Dynamic_Object>())
+          {
+            assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
+                && "Programming error, Dynamic_Object_Function must have at least one parameter (this)");
+          }
+
+          Dynamic_Object_Function(
+              std::string t_type_name,
+              const Proxy_Function &t_func,
+              const Type_Info &t_ti)
+            : Proxy_Function_Base(build_param_types(t_func->get_param_types(), t_ti), t_func->get_arity()),
+              m_type_name(std::move(t_type_name)), m_func(t_func), m_ti(new Type_Info(t_ti)), m_doti(user_type<Dynamic_Object>())
+          {
+            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() {}
+
+          Dynamic_Object_Function &operator=(const Dynamic_Object_Function) = delete;
+          Dynamic_Object_Function(Dynamic_Object_Function &) = delete;
+
+          virtual bool operator==(const Proxy_Function_Base &f) const CHAISCRIPT_OVERRIDE
+          {
+            if (const auto *df = dynamic_cast<const Dynamic_Object_Function *>(&f))
+            {
+              return df->m_type_name == m_type_name && (*df->m_func) == (*m_func);
+            } else {
+              return false;
+            }
+          }
+
+          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+          {
+            if (dynamic_object_typename_match(vals, m_type_name, m_ti, t_conversions))
+            {
+              return m_func->call_match(vals, t_conversions);
+            } else {
+              return false;
+            }
+          }
+
+          virtual std::vector<Const_Proxy_Function> get_contained_functions() const CHAISCRIPT_OVERRIDE
+          {
+            return {m_func};
+          }
+
+          virtual std::string annotation() const CHAISCRIPT_OVERRIDE
+          {
+            return m_func->annotation();
+          }
+
+
+        protected:
+          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+          {
+            if (dynamic_object_typename_match(params, m_type_name, m_ti, t_conversions))
+            {
+              return (*m_func)(params, t_conversions);
+            } else {
+              throw exception::guard_error();
+            } 
+          }
+
+          virtual bool compare_first_type(const Boxed_Value &bv, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+          {
+            return dynamic_object_typename_match(bv, m_type_name, m_ti, t_conversions);
+          }
+
+        private:
+          static std::vector<Type_Info> build_param_types(
+              const std::vector<Type_Info> &t_inner_types, const Type_Info& t_objectti)
+          {
+            std::vector<Type_Info> types(t_inner_types);
+
+            assert(types.size() > 1);
+            //assert(types[1].bare_equal(user_type<Boxed_Value>()));
+            types[1] = t_objectti;
+            return types;
+          }
+
+          bool dynamic_object_typename_match(const Boxed_Value &bv, const std::string &name,
+              const std::unique_ptr<Type_Info> &ti, const Type_Conversions &t_conversions) const
+          {
+            if (bv.get_type_info().bare_equal(m_doti))
+            {
+              try {
+                const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv, &t_conversions);
+                return name == "Dynamic_Object" || d.get_type_name() == name;
+              } catch (const std::bad_cast &) {
+                return false;
+              } 
+            } else {
+              if (ti)
+              {
+                return bv.get_type_info().bare_equal(*ti);
+              } else {
+                return false;
+              }
+            }
+
+          }
+
+          bool dynamic_object_typename_match(const std::vector<Boxed_Value> &bvs, const std::string &name,
+              const std::unique_ptr<Type_Info> &ti, const Type_Conversions &t_conversions) const
+          {
+            if (bvs.size() > 0)
+            {
+              return dynamic_object_typename_match(bvs[0], name, ti, t_conversions);
+            } else {
+              return false;
+            }
+          }
+
+          std::string m_type_name;
+          Proxy_Function m_func;
+          std::unique_ptr<Type_Info> m_ti;
+          const Type_Info m_doti;
+
+
+      };
+
+
+      /**
+       * 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(
+              std::string t_type_name,
+              const Proxy_Function &t_func)
+            : Proxy_Function_Base(build_type_list(t_func->get_param_types()), t_func->get_arity() - 1),
+              m_type_name(std::move(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)
+          {
+            auto begin = tl.begin();
+            auto 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 CHAISCRIPT_OVERRIDE
+          {
+            const Dynamic_Object_Constructor *dc = dynamic_cast<const Dynamic_Object_Constructor*>(&f);
+            if (dc)
+            {
+              return dc->m_type_name == m_type_name && (*dc->m_func) == (*m_func);
+            } else {
+              return false;
+            }
+          }
+
+          virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+          {
+            std::vector<Boxed_Value> new_vals{Boxed_Value(Dynamic_Object(m_type_name))};
+            new_vals.insert(new_vals.end(), vals.begin(), vals.end());
+
+            return m_func->call_match(new_vals, t_conversions);
+          }    
+
+          virtual std::string annotation() const CHAISCRIPT_OVERRIDE
+          {
+            return m_func->annotation();
+          }
+
+        protected:
+          virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+          {
+            auto bv = var(Dynamic_Object(m_type_name));
+            std::vector<Boxed_Value> new_params{bv};
+            new_params.insert(new_params.end(), params.begin(), params.end());
+
+            (*m_func)(new_params, t_conversions);
+
+            return bv;
+          }
+
+        private:
+          std::string m_type_name;
+          Proxy_Function m_func;
+
+      };
+    }
+  }
+}
+#endif
+

include/chaiscript/dispatchkit/exception_specification.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_EXCEPTION_SPECIFICATION_HPP_
@@ -23,6 +23,7 @@ namespace chaiscript
 {
   namespace detail
   {
+    /// \todo make this a variadic template
     struct Exception_Handler_Base
     {
       virtual void handle(const Boxed_Value &bv, const Dispatch_Engine &t_engine) = 0;

include/chaiscript/dispatchkit/function_call.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_FUNCTION_CALL_HPP_
@@ -18,7 +18,7 @@
 
 namespace chaiscript {
 class Boxed_Value;
-class Dynamic_Cast_Conversions;
+class Type_Conversions;
 namespace detail {
 template <typename T> struct Cast_Helper;
 }  // namespace detail
@@ -28,66 +28,56 @@ namespace chaiscript
 {
   namespace dispatch
   {
-    /**
-     * Build a function caller that knows how to dispatch on a set of functions
-     * example: 
-     * std::function<void (int)> f = 
-     *      build_function_caller(dispatchkit.get_function("print"));
-     * \returns A std::function object for dispatching
-     * \param[in] funcs the set of functions to dispatch on.
-     */
+    /// Build a function caller that knows how to dispatch on a set of functions
+    /// example:
+    /// std::function<void (int)> f =
+    ///      build_function_caller(dispatchkit.get_function("print"));
+    /// \returns A std::function object for dispatching
+    /// \param[in] funcs the set of functions to dispatch on.
     template<typename FunctionType>
       std::function<FunctionType>
-      functor(const std::vector<Const_Proxy_Function> &funcs, const Dynamic_Cast_Conversions *t_conversions)
+      functor(const std::vector<Const_Proxy_Function> &funcs, const Type_Conversions *t_conversions)
       {
         FunctionType *p=nullptr;
         return detail::build_function_caller_helper(p, funcs, t_conversions);
       }
 
-    /**
-     * Build a function caller for a particular Proxy_Function object
-     * useful in the case that a function is being pass out from scripting back
-     * into code
-     * example: 
-     * void my_function(Proxy_Function f)
-     * {
-     *   std::function<void (int)> local_f = 
-     *      build_function_caller(f);
-     * }
-     * \returns A std::function object for dispatching
-     * \param[in] func A function to execute.
-     */
+    /// Build a function caller for a particular Proxy_Function object
+    /// useful in the case that a function is being pass out from scripting back
+    /// into code
+    /// example:
+    /// void my_function(Proxy_Function f)
+    /// {
+    ///   std::function<void (int)> local_f =
+    ///      build_function_caller(f);
+    /// }
+    /// \returns A std::function object for dispatching
+    /// \param[in] func A function to execute.
     template<typename FunctionType>
       std::function<FunctionType>
-      functor(Const_Proxy_Function func, const Dynamic_Cast_Conversions *t_conversions)
+      functor(Const_Proxy_Function func, const Type_Conversions *t_conversions)
       {
-        std::vector<Const_Proxy_Function> funcs;
-        funcs.push_back(func);
-        return functor<FunctionType>(funcs, t_conversions);
+        return functor<FunctionType>(std::vector<Const_Proxy_Function>({func}), t_conversions);
       }
 
-    /**
-     * Helper for automatically unboxing a Boxed_Value that contains a function object
-     * and creating a typesafe C++ function caller from it.
-     */
+    /// Helper for automatically unboxing a Boxed_Value that contains a function object
+    /// and creating a typesafe C++ function caller from it.
     template<typename FunctionType>
       std::function<FunctionType>
-      functor(const Boxed_Value &bv, const Dynamic_Cast_Conversions *t_conversions)
+      functor(const Boxed_Value &bv, const Type_Conversions *t_conversions)
       {
         return functor<FunctionType>(boxed_cast<Const_Proxy_Function >(bv, t_conversions), t_conversions);
       }
   }
 
   namespace detail{
-    /**
-     * Cast helper to handle automatic casting to const std::function &
-     */
+    /// Cast helper to handle automatic casting to const std::function &
     template<typename Signature>
       struct Cast_Helper<const std::function<Signature> &>
       {
         typedef std::function<Signature> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
@@ -98,15 +88,13 @@ namespace chaiscript
         }
       };
 
-    /**
-     * Cast helper to handle automatic casting to std::function
-     */
+    /// Cast helper to handle automatic casting to std::function
     template<typename Signature>
       struct Cast_Helper<std::function<Signature> >
       {
         typedef std::function<Signature> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {
@@ -117,15 +105,13 @@ namespace chaiscript
         }
       };
 
-    /**
-     * Cast helper to handle automatic casting to const std::function
-     */
+    /// Cast helper to handle automatic casting to const std::function
     template<typename Signature>
       struct Cast_Helper<const std::function<Signature> >
       {
         typedef std::function<Signature> Result_Type;
 
-        static Result_Type cast(const Boxed_Value &ob, const Dynamic_Cast_Conversions *t_conversions)
+        static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *t_conversions)
         {
           if (ob.get_type_info().bare_equal(user_type<Const_Proxy_Function>()))
           {

include/chaiscript/dispatchkit/function_call_detail.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_FUNCTION_CALL_DETAIL_HPP_
@@ -17,7 +17,7 @@
 #include "boxed_cast.hpp"
 #include "boxed_number.hpp"
 #include "boxed_value.hpp"
-#include "dynamic_cast_conversion.hpp"
+#include "type_conversions.hpp"
 #include "proxy_functions.hpp"
 
 namespace chaiscript
@@ -26,15 +26,13 @@ namespace chaiscript
   {
     namespace detail
     {
-      /**
-       * Internal helper class for handling the return
-       * value of a build_function_caller
-       */
+      /// Internal helper class for handling the return
+      /// value of a build_function_caller
       template<typename Ret, bool is_arithmetic>
         struct Function_Caller_Ret
         {
           static Ret call(const std::vector<Const_Proxy_Function> &t_funcs, 
-              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+              const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
           {
             return boxed_cast<Ret>(dispatch::dispatch(t_funcs, params, t_conversions));
           }
@@ -47,7 +45,7 @@ namespace chaiscript
         struct Function_Caller_Ret<Ret, true>
         {
           static Ret call(const std::vector<Const_Proxy_Function> &t_funcs, 
-              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+              const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
           {
             return Boxed_Number(dispatch::dispatch(t_funcs, params, t_conversions)).get_as<Ret>();
           }
@@ -61,7 +59,7 @@ namespace chaiscript
         struct Function_Caller_Ret<void, false>
         {
           static void call(const std::vector<Const_Proxy_Function> &t_funcs, 
-              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+              const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
           {
             dispatch::dispatch(t_funcs, params, t_conversions);
           }
@@ -73,7 +71,7 @@ namespace chaiscript
       template<typename Ret, typename ... Param>
         struct Build_Function_Caller_Helper
         {
-          Build_Function_Caller_Helper(std::vector<Const_Proxy_Function> t_funcs, const Dynamic_Cast_Conversions &t_conversions)
+          Build_Function_Caller_Helper(std::vector<Const_Proxy_Function> t_funcs, const Type_Conversions &t_conversions)
             : m_funcs(std::move(t_funcs)),
               m_conversions(t_conversions)
           {
@@ -81,7 +79,7 @@ namespace chaiscript
 
           Ret operator()(Param...param)
           {
-            return Function_Caller_Ret<Ret, std::is_arithmetic<Ret>::value>::call(m_funcs, { 
+            return Function_Caller_Ret<Ret, std::is_arithmetic<Ret>::value && !std::is_same<Ret, bool>::value>::call(m_funcs, { 
                 (std::is_reference<Param>::value&&!(std::is_same<chaiscript::Boxed_Value, typename std::remove_const<typename std::remove_reference<Param>::type>::type>::value))?Boxed_Value(std::ref(param)):Boxed_Value(param)... 
                 }, m_conversions
 
@@ -90,13 +88,13 @@ namespace chaiscript
           }
 
           std::vector<Const_Proxy_Function> m_funcs;
-          Dynamic_Cast_Conversions m_conversions;
+          Type_Conversions m_conversions;
         };
 
 
 
       template<typename Ret, typename ... Params>
-        std::function<Ret (Params...)> build_function_caller_helper(Ret (Params...), const std::vector<Const_Proxy_Function> &funcs, const Dynamic_Cast_Conversions *t_conversions)
+        std::function<Ret (Params...)> build_function_caller_helper(Ret (Params...), const std::vector<Const_Proxy_Function> &funcs, const Type_Conversions *t_conversions)
         {
           if (funcs.size() == 1)
           {
@@ -112,7 +110,7 @@ namespace chaiscript
             // we cannot make any other guesses or assumptions really, so continuing
           }
 
-          return std::function<Ret (Params...)>(Build_Function_Caller_Helper<Ret, Params...>(funcs, t_conversions?*t_conversions:Dynamic_Cast_Conversions()));
+          return std::function<Ret (Params...)>(Build_Function_Caller_Helper<Ret, Params...>(funcs, t_conversions?*t_conversions:Type_Conversions()));
         }
     }
   }

include/chaiscript/dispatchkit/handle_return.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_HANDLE_RETURN_HPP_
@@ -37,6 +37,11 @@ namespace chaiscript
           {
             return const_var(r);
           }
+
+          static Boxed_Value handle(Ret &&r)
+          {
+            return Boxed_Value(std::move(r));
+          }
         };
 
       template<typename Ret>
@@ -48,6 +53,15 @@ namespace chaiscript
           }
         };
 
+      template<typename Ret>
+        struct Handle_Return<const Ret *>
+        {
+          static Boxed_Value handle(const Ret *p)
+          {
+            return Boxed_Value(p);
+          }
+        };
+
       template<typename Ret>
         struct Handle_Return<std::shared_ptr<Ret> &>
         {

include/chaiscript/dispatchkit/operators.hpp

@@ -1,13 +1,14 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_OPERATORS_HPP_
 #define CHAISCRIPT_OPERATORS_HPP_
 
 #include "../chaiscript_defines.hpp"
+#include "register_function.hpp"
 
 namespace chaiscript 
 {
@@ -15,442 +16,446 @@ namespace chaiscript
   {
     namespace operators
     {
-      template<typename Ret, typename L, typename R>
-        Ret assign(L l, R r)
-        {
-          return (l = r);
-        }
+      namespace detail
+      {
+        /// \todo make this return a decltype once we drop gcc 4.6
+        template<typename L, typename R>
+          auto assign(L l, R r) -> L&
+          {
+            return (l = r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_bitwise_and(L l, R r)
-        {
-          return (l &= r);
-        }
+        template<typename L, typename R>
+          auto assign_bitwise_and(L l, R r) -> decltype((l &= r))
+          {
+            return (l &= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_xor(L l, R r)
-        {
-          return (l ^= r);
-        }
+        template<typename L, typename R>
+          auto assign_xor(L l, R r) -> decltype((l^=r))
+          {
+            return (l ^= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_bitwise_or(L l, R r)
-        {
-          return (l |= r);
-        }
+        template<typename L, typename R>
+          auto assign_bitwise_or(L l, R r) -> decltype((l |= r))
+          {
+            return (l |= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_difference(L l, R r)
-        {
-          return (l -= r);
-        }
+        template<typename L, typename R>
+          auto assign_difference(L l, R r) -> decltype(( l -= r))
+          {
+            return (l -= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_left_shift(L l, R r)
-        {
-          return (l <<= r);
-        }
+        template<typename L, typename R>
+          auto assign_left_shift(L l, R r) -> decltype(( l <<= r))
+          {
+            return (l <<= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_product(L l, R r)
-        {
-          return (l *= r);
-        }
+        template<typename L, typename R>
+          auto assign_product(L l, R r) -> decltype(( l *= r ))
+          {
+            return (l *= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_quotient(L l, R r)
-        {
-          return (l /= r);
-        }
+        template<typename L, typename R>
+          auto assign_quotient(L l, R r) -> decltype(( l /= r ))
+          {
+            return (l /= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_remainder(L l, R r)
-        {
-          return (l %= r);
-        }
+        template<typename L, typename R>
+          auto assign_remainder(L l, R r) -> decltype(( l %= r ))
+          {
+            return (l %= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_right_shift(L l, R r)
-        {
-          return (l >>= r);
-        }
+        template<typename L, typename R>
+          auto assign_right_shift(L l, R r) -> decltype(( l >>= r))
+          {
+            return (l >>= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret assign_sum(L l, R r)
-        {
-          return (l += r);
-        }
+        /// \todo make this return a decltype once we drop gcc 4.6
+        template<typename L, typename R>
+          auto assign_sum(L l, R r) -> L&
+          {
+            return (l += r);
+          }
 
-      template<typename Ret, typename L>
-        Ret prefix_decrement(L l)
-        {
-          return (--l);
-        }
+        template<typename L>
+          auto prefix_decrement(L l) -> decltype(( --l ))
+          {
+            return (--l);
+          }
 
-      template<typename Ret, typename L>
-        Ret prefix_increment(L l)
-        {
-          return (++l);
-        }
+        template<typename L>
+          auto prefix_increment(L l) -> decltype(( ++l ))
+          {
+            return (++l);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret equal(L l, R r)
-        {
-          return (l == r);
-        }
+        template<typename L, typename R>
+          auto equal(L l, R r) -> decltype(( l == r ))
+          {
+            return (l == r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret greater_than(L l, R r)
-        {
-          return (l > r);
-        }
+        template<typename L, typename R>
+          auto greater_than(L l, R r) -> decltype(( l > r ))
+          {
+            return (l > r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret greater_than_equal(L l, R r)
-        {
-          return (l >= r);
-        }
+        template<typename L, typename R>
+          auto greater_than_equal(L l, R r) -> decltype(( l >= r ))
+          {
+            return (l >= r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret less_than(L l, R r)
-        {
-          return (l < r);
-        }
+        template<typename L, typename R>
+          auto less_than(L l, R r) -> decltype(( l < r ))
+          {
+            return (l < r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret less_than_equal(L l, R r)
-        {
-          return (l <= r);
-        }
+        template<typename L, typename R>
+          auto less_than_equal(L l, R r) -> decltype(( l <= r ))
+          {
+            return (l <= r);
+          }
 
-      template<typename Ret, typename L>
-        Ret logical_compliment(L l)
-        {
-          return (!l);
-        }
+        template<typename L>
+          auto logical_compliment(L l) -> decltype(( !l ))
+          {
+            return (!l);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret not_equal(L l, R r)
-        {
-          return (l != r);
-        }
+        template<typename L, typename R>
+          auto not_equal(L l, R r) -> decltype(( l != r ))
+          {
+            return (l != r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret addition(L l, R r)
-        {
-          return (l + r);
-        }
+        template<typename L, typename R>
+          auto addition(L l, R r) -> decltype(( l + r ))
+          {
+            return (l + r);
+          }
 
-      template<typename Ret, typename L>
-        Ret unary_plus(L l)
-        {
-          return (+l);
-        }
+        template<typename L>
+          auto unary_plus(L l) -> decltype(( +l ))
+          {
+            return (+l);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret subtraction(L l, R r)
-        {
-          return (l - r);
-        }
+        template<typename L, typename R>
+          auto subtraction(L l, R r) -> decltype(( l - r ))
+          {
+            return (l - r);
+          }
 
-      template<typename Ret, typename L>
-        Ret unary_minus(L l)
-        {
+        template<typename L>
+          auto unary_minus(L l) -> decltype(( -l ))
+          {
 #ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
 #pragma warning(disable : 4146)
-          return (-l);
+            return (-l);
 #pragma warning(pop)
 #else
-          return (-l);
+            return (-l);
 #endif
-        }
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret bitwise_and(L l, R r)
-        {
-          return (l & r);
-        }
+        template<typename L, typename R>
+          auto bitwise_and(L l, R r) -> decltype(( l & r ))
+          {
+            return (l & r);
+          }
 
-      template<typename Ret, typename L>
-        Ret bitwise_compliment(L l)
-        {
-          return (~l);
-        }
+        template<typename L>
+          auto bitwise_compliment(L l) -> decltype(( ~l ))
+          {
+            return (~l);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret bitwise_xor(L l, R r)
-        {
-          return (l ^ r);
-        }
+        template<typename L, typename R>
+          auto bitwise_xor(L l, R r) -> decltype(( l ^ r ))
+          {
+            return (l ^ r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret bitwise_or(L l, R r)
-        {
-          return (l | r);
-        }
+        template<typename L, typename R>
+          auto bitwise_or(L l, R r) -> decltype(( l | r ))
+          {
+            return (l | r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret division(L l, R r)
-        {
-          return (l / r);
-        }
+        template<typename L, typename R>
+          auto division(L l, R r) -> decltype(( l / r ))
+          {
+            return (l / r);
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret left_shift(L l, R r)
-        {
-          return l << r;
-        }
+        template<typename L, typename R>
+          auto left_shift(L l, R r) -> decltype(( l << r ))
+          {
+            return l << r;
+          }
 
-      template<typename Ret, typename L, typename R>
-        Ret multiplication(L l, R r)
-        {
-          return l * r;
-        }
+        template<typename L, typename R>
+          auto multiplication(L l, R r) -> decltype(( l * 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 L, typename R>
+          auto remainder(L l, R r) -> decltype(( l % r ))
+          {
+            return (l % r);
+          }
 
+        template<typename L, typename R>
+          auto right_shift(L l, R r) -> decltype(( l >> r ))
+          {
+            return (l >> r);
+          }
+      }
 
 
 
       template<typename T>
         ModulePtr assign(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&assign<T &, T &, const T&>), "=");
+          m->add(chaiscript::fun(&detail::assign<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&>), "&=");
+          m->add(chaiscript::fun(&detail::assign_bitwise_and<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&>), "^=");
+          m->add(chaiscript::fun(&detail::assign_xor<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&>), "|=");
+          m->add(chaiscript::fun(&detail::assign_bitwise_or<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&>), "-=");
+          m->add(chaiscript::fun(&detail::assign_difference<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&>), "<<=");
+          m->add(chaiscript::fun(&detail::assign_left_shift<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&>), "*=");
+          m->add(chaiscript::fun(&detail::assign_product<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&>), "/=");
+          m->add(chaiscript::fun(&detail::assign_quotient<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&>), "%=");
+          m->add(chaiscript::fun(&detail::assign_remainder<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&>), ">>=");
+          m->add(chaiscript::fun(&detail::assign_right_shift<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&>), "+=");
+          m->add(chaiscript::fun(&detail::assign_sum<T &, const T&>), "+=");
           return m;
         }
 
       template<typename T>
         ModulePtr prefix_decrement(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&prefix_decrement<T &, T &>), "--");
+          m->add(chaiscript::fun(&detail::prefix_decrement<T &>), "--");
           return m;
         }
 
       template<typename T>
         ModulePtr prefix_increment(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&prefix_increment<T &, T &>), "++");
+          m->add(chaiscript::fun(&detail::prefix_increment<T &>), "++");
           return m;
         }
 
       template<typename T>
         ModulePtr equal(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&equal<bool, const T&, const T&>), "==");
+          m->add(chaiscript::fun(&detail::equal<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&>), ">");
+          m->add(chaiscript::fun(&detail::greater_than<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&>), ">=");
+          m->add(chaiscript::fun(&detail::greater_than_equal<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&>), "<");
+          m->add(chaiscript::fun(&detail::less_than<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&>), "<=");
+          m->add(chaiscript::fun(&detail::less_than_equal<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 &>), "!");
+          m->add(chaiscript::fun(&detail::logical_compliment<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 &>), "!=");
+          m->add(chaiscript::fun(&detail::not_equal<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 &>), "+");
+          m->add(chaiscript::fun(&detail::addition<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 &>), "+");
+          m->add(chaiscript::fun(&detail::unary_plus<const T &>), "+");
           return m;
         }
 
       template<typename T>
         ModulePtr subtraction(ModulePtr m = ModulePtr(new Module()))
         {
-          m->add(fun(&subtraction<T, const T &, const T &>), "-");
+          m->add(chaiscript::fun(&detail::subtraction<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 &>), "-");
+          m->add(chaiscript::fun(&detail::unary_minus<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 &>), "&");
+          m->add(chaiscript::fun(&detail::bitwise_and<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 &>), "~");
+          m->add(chaiscript::fun(&detail::bitwise_compliment<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 &>), "^");
+          m->add(chaiscript::fun(&detail::bitwise_xor<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 &>), "|");
+          m->add(chaiscript::fun(&detail::bitwise_or<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 &>), "/");
+          m->add(chaiscript::fun(&detail::division<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 &>), "<<");
+          m->add(chaiscript::fun(&detail::left_shift<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 &>), "*");
+          m->add(chaiscript::fun(&detail::multiplication<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 &>), "%");
+          m->add(chaiscript::fun(&detail::remainder<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 &>), ">>");
+          m->add(chaiscript::fun(&detail::right_shift<const T &, const T &>), ">>");
           return m;
         }
     }

include/chaiscript/dispatchkit/proxy_constructors.hpp

@@ -1,13 +1,15 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 
 #ifndef CHAISCRIPT_PROXY_CONSTRUCTORS_HPP_
 #define CHAISCRIPT_PROXY_CONSTRUCTORS_HPP_
 
+#include "proxy_functions.hpp"
+
 namespace chaiscript
 {
   namespace dispatch
@@ -21,7 +23,7 @@ namespace chaiscript
       template<typename Class, typename ... Params>
         std::shared_ptr<Class> constructor_(Params ... params)
         {
-          return std::shared_ptr<Class>(new Class(params...));
+          return std::make_shared<Class>(params...);
         }
 
       template<typename Class, typename ... Params  >

include/chaiscript/dispatchkit/proxy_functions.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 
@@ -24,9 +24,10 @@
 #include "boxed_value.hpp"
 #include "proxy_functions_detail.hpp"
 #include "type_info.hpp"
+#include "dynamic_object.hpp"
 
 namespace chaiscript {
-class Dynamic_Cast_Conversions;
+class Type_Conversions;
 namespace exception {
 class bad_boxed_cast;
 struct arity_error;
@@ -42,6 +43,95 @@ namespace chaiscript
 
   namespace dispatch
   {
+    class Param_Types
+    {
+      public:
+        Param_Types()
+          : m_has_types(false),
+            m_doti(user_type<Dynamic_Object>())
+        {}
+
+        Param_Types(std::vector<std::pair<std::string, Type_Info>> t_types)
+          : m_types(std::move(t_types)),
+            m_has_types(false),
+            m_doti(user_type<Dynamic_Object>())
+        {
+          update_has_types();
+        }
+
+        void push_front(std::string t_name, Type_Info t_ti)
+        {
+          m_types.emplace(m_types.begin(), std::move(t_name), std::move(t_ti));
+          update_has_types();
+        }
+
+        bool operator==(const Param_Types &t_rhs) const
+        {
+          return m_types == t_rhs.m_types;
+        }
+
+        bool match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const
+        {
+          if (!m_has_types) return true;
+          if (vals.size() != m_types.size()) return false;
+
+          for (size_t i = 0; i < vals.size(); ++i)
+          {
+            const auto &name = m_types[i].first;
+            if (!name.empty()) {
+              const auto &bv = vals[i];
+
+              if (bv.get_type_info().bare_equal(m_doti))
+              {
+                try {
+                  const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv, &t_conversions);
+                  return name == "Dynamic_Object" || d.get_type_name() == name;
+                } catch (const std::bad_cast &) {
+                  return false;
+                } 
+              } else {
+                const auto &ti = m_types[i].second;
+                if (!ti.is_undef())
+                {
+                  if (!bv.get_type_info().bare_equal(ti)) {
+                    return false;
+                  }
+                } else {
+                  return false;
+                }
+              }
+            }
+          }
+
+          return true;
+        }
+
+        const std::vector<std::pair<std::string, Type_Info>> &types() const
+        {
+          return m_types;
+        }
+
+      private:
+        void update_has_types()
+        {
+          for (const auto &type : m_types)
+          {
+            if (!type.first.empty())
+            {
+              m_has_types = true;
+              return;
+            }
+          }
+
+          m_has_types = false;
+        }
+
+        std::vector<std::pair<std::string, Type_Info>> m_types;
+        bool m_has_types;
+        Type_Info m_doti;
+
+    };
+
     /**
      * Pure virtual base class for all Proxy_Function implementations
      * Proxy_Functions are a type erasure of type safe C++
@@ -55,7 +145,7 @@ namespace chaiscript
       public:
         virtual ~Proxy_Function_Base() {}
 
-        Boxed_Value operator()(const std::vector<Boxed_Value> &params, const chaiscript::Dynamic_Cast_Conversions &t_conversions) const
+        Boxed_Value operator()(const std::vector<Boxed_Value> &params, const chaiscript::Type_Conversions &t_conversions) const
         {
           Boxed_Value bv = do_call(params, t_conversions);
           return bv;
@@ -63,12 +153,12 @@ namespace chaiscript
 
         /// Returns a vector containing all of the types of the parameters the function returns/takes
         /// if the function is variadic or takes no arguments (arity of 0 or -1), the returned
-        /// value containes exactly 1 Type_Info object: the return type
+        /// value contains exactly 1 Type_Info object: the return type
         /// \returns the types of all parameters. 
         const std::vector<Type_Info> &get_param_types() const { return m_types; }
 
         virtual bool operator==(const Proxy_Function_Base &) const = 0;
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const = 0;
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const = 0;
 
         bool has_arithmetic_param() const 
         {
@@ -82,15 +172,13 @@ namespace chaiscript
 
         //! Return true if the function is a possible match
         //! to the passed in values
-        bool filter(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const
+        bool filter(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const
         {
-          int arity = get_arity();
-
-          if (arity < 0)
+          if (m_arity < 0)
           {
             return true;
-          } else if (size_t(arity) == vals.size()) {
-            if (arity == 0)
+          } else if (size_t(m_arity) == vals.size()) {
+            if (m_arity == 0)
             {
               return true;
             } else {
@@ -102,11 +190,14 @@ namespace chaiscript
         }
 
         /// \returns the number of arguments the function takes or -1 if it is variadic
-        virtual int get_arity() const = 0;
+        int get_arity() const
+        {
+          return m_arity;
+        }
 
         virtual std::string annotation() const = 0;
 
-        static bool compare_type_to_param(const Type_Info &ti, const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions)
+        static bool compare_type_to_param(const Type_Info &ti, const Boxed_Value &bv, const Type_Conversions &t_conversions)
         {
           if (ti.is_undef() 
               || ti.bare_equal(user_type<Boxed_Value>())
@@ -114,7 +205,7 @@ namespace chaiscript
                 && (ti.bare_equal(user_type<Boxed_Number>())
                   || ti.bare_equal(bv.get_type_info())
                   || bv.get_type_info().bare_equal(user_type<std::shared_ptr<const Proxy_Function_Base> >())
-                  || t_conversions.dynamic_cast_converts(ti, bv.get_type_info()) 
+                  || t_conversions.converts(ti, bv.get_type_info()) 
                   )
                 )
              )
@@ -125,10 +216,10 @@ namespace chaiscript
           }
         }
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const = 0;
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const = 0;
 
-        Proxy_Function_Base(std::vector<Type_Info> t_types)
-          : m_types(std::move(t_types)), m_has_arithmetic_param(false)
+        Proxy_Function_Base(std::vector<Type_Info> t_types, int t_arity)
+          : m_types(std::move(t_types)), m_arity(t_arity), m_has_arithmetic_param(false)
         {
           for (size_t i = 1; i < m_types.size(); ++i)
           {
@@ -141,7 +232,7 @@ namespace chaiscript
 
         }
 
-        virtual bool compare_first_type(const Boxed_Value &bv, const Dynamic_Cast_Conversions &t_conversions) const
+        virtual bool compare_first_type(const Boxed_Value &bv, const Type_Conversions &t_conversions) const
         {
           const std::vector<Type_Info> &types = get_param_types();
 
@@ -174,15 +265,15 @@ namespace chaiscript
         }
 
         std::vector<Type_Info> m_types;
+        int m_arity;
         bool m_has_arithmetic_param;
-
     };
   }
 
   /// \brief Common typedef used for passing of any registered function in ChaiScript
   typedef std::shared_ptr<dispatch::Proxy_Function_Base> Proxy_Function;
 
-  /// \brief Const version of Proxy_Function chaiscript. Points to a const Proxy_Function. This is how most registered functions
+  /// \brief Const version of Proxy_Function. Points to a const Proxy_Function. This is how most registered functions
   ///        are handled internally.
   typedef std::shared_ptr<const dispatch::Proxy_Function_Base> Const_Proxy_Function;
 
@@ -196,6 +287,8 @@ namespace chaiscript
           : std::runtime_error("Guard evaluation failed")
         { }
 
+        guard_error(const guard_error &) = default;
+
         virtual ~guard_error() CHAISCRIPT_NOEXCEPT
         { }
     };
@@ -214,10 +307,13 @@ namespace chaiscript
             std::function<Boxed_Value (const std::vector<Boxed_Value> &)> t_f, 
             int t_arity=-1,
             AST_NodePtr t_parsenode = AST_NodePtr(),
+            Param_Types t_param_types = Param_Types(),
             std::string t_description = "",
             Proxy_Function t_guard = Proxy_Function())
-          : Proxy_Function_Base(build_param_type_list(t_arity)),
-            m_f(std::move(t_f)), m_arity(t_arity), m_description(std::move(t_description)), m_guard(std::move(t_guard)), m_parsenode(std::move(t_parsenode))
+          : Proxy_Function_Base(build_param_type_list(t_param_types), t_arity),
+            m_param_types(std::move(t_param_types)),
+            m_guard(std::move(t_guard)), m_parsenode(std::move(t_parsenode)), m_description(std::move(t_description)), 
+            m_f(std::move(t_f))
         {
         }
 
@@ -230,20 +326,17 @@ namespace chaiscript
           return this == &rhs
             || (prhs
                 && this->m_arity == prhs->m_arity
-                && !this->m_guard && !prhs->m_guard);
+                && !this->m_guard && !prhs->m_guard
+                && this->m_param_types == prhs->m_param_types);
         }
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
-          return (m_arity < 0 || vals.size() == size_t(m_arity))
+          return (m_arity < 0 || (vals.size() == size_t(m_arity) && m_param_types.match(vals, t_conversions)))
             && test_guard(vals, t_conversions);
-        }    
-
-        virtual int get_arity() const CHAISCRIPT_OVERRIDE
-        {
-          return m_arity;
         }
 
+
         Proxy_Function get_guard() const
         {
           return m_guard;
@@ -260,12 +353,11 @@ namespace chaiscript
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           if (m_arity < 0 || params.size() == size_t(m_arity))
           {
-
-            if (test_guard(params, t_conversions))
+            if (call_match(params, t_conversions) && test_guard(params, t_conversions))
             {
               return m_f(params);
             } else {
@@ -278,7 +370,7 @@ namespace chaiscript
         }
 
       private:
-        bool test_guard(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const
+        bool test_guard(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const
         {
           if (m_guard)
           {
@@ -294,29 +386,30 @@ namespace chaiscript
           }
         }
 
-        static std::vector<Type_Info> build_param_type_list(int arity)
+        static std::vector<Type_Info> build_param_type_list(const Param_Types &t_types)
         {
           std::vector<Type_Info> types;
 
           // For the return type
           types.push_back(chaiscript::detail::Get_Type_Info<Boxed_Value>::get());
 
-          if (arity > 0)
+          for (const auto &t : t_types.types())
           {
-            for (int i = 0; i < arity; ++i)
-            {
+            if (t.second.is_undef()) {
               types.push_back(chaiscript::detail::Get_Type_Info<Boxed_Value>::get());
+            } else {
+              types.push_back(t.second);
             }
           }
 
           return types;
         }
 
-        std::function<Boxed_Value (const std::vector<Boxed_Value> &)> m_f;
-        int m_arity;
-        std::string m_description;
+        Param_Types m_param_types;
         Proxy_Function m_guard;
         AST_NodePtr m_parsenode;
+        std::string m_description;
+        std::function<Boxed_Value (const std::vector<Boxed_Value> &)> m_f;
     };
 
     /**
@@ -338,8 +431,8 @@ namespace chaiscript
       public:
         Bound_Function(const Const_Proxy_Function &t_f, 
             const std::vector<Boxed_Value> &t_args)
-          : Proxy_Function_Base(build_param_type_info(t_f, t_args)),
-            m_f(t_f), m_args(t_args), m_arity(t_f->get_arity()<0?-1:static_cast<int>(get_param_types().size())-1)
+          : Proxy_Function_Base(build_param_type_info(t_f, t_args), (t_f->get_arity()<0?-1:static_cast<int>(build_param_type_info(t_f, t_args).size())-1)),
+            m_f(t_f), m_args(t_args)
         {
           assert(m_f->get_arity() < 0 || m_f->get_arity() == static_cast<int>(m_args.size()));
         }
@@ -351,7 +444,7 @@ namespace chaiscript
 
         virtual ~Bound_Function() {}
 
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           return m_f->call_match(build_param_list(vals), t_conversions);
         }
@@ -395,11 +488,6 @@ namespace chaiscript
           return args;
         }
 
-        virtual int get_arity() const CHAISCRIPT_OVERRIDE
-        {
-          return m_arity;
-        }
-
         virtual std::string annotation() const CHAISCRIPT_OVERRIDE
         {
           return "Bound: " + m_f->annotation();
@@ -429,7 +517,7 @@ namespace chaiscript
           return retval;
         }
 
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           return (*m_f)(build_param_list(params), t_conversions);
         }
@@ -437,7 +525,34 @@ namespace chaiscript
       private:
         Const_Proxy_Function m_f;
         std::vector<Boxed_Value> m_args;
-        int m_arity;
+    };
+
+    class Proxy_Function_Impl_Base : public Proxy_Function_Base
+    {
+      public:
+        Proxy_Function_Impl_Base(const std::vector<Type_Info> &t_types)
+          : Proxy_Function_Base(t_types, static_cast<int>(t_types.size()) - 1)
+        {
+        }
+
+        virtual ~Proxy_Function_Impl_Base() {}
+
+        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
+        {
+          return "";
+        }
+
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        {
+          if (int(vals.size()) != get_arity()) 
+          {
+            return false;
+          }
+
+          return compare_types(m_types, vals) || compare_types_with_cast(vals, t_conversions);
+        }
+
+        virtual bool compare_types_with_cast(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const = 0;
     };
 
     /**
@@ -446,41 +561,25 @@ namespace chaiscript
      * type checking of Boxed_Value parameters, in a type safe manner
      */
     template<typename Func>
-      class Proxy_Function_Impl : public Proxy_Function_Base
+      class Proxy_Function_Impl : public Proxy_Function_Impl_Base
     {
       public:
         Proxy_Function_Impl(std::function<Func> f)
-          : Proxy_Function_Base(detail::build_param_type_list(static_cast<Func *>(nullptr))),
-          m_f(std::move(f)), m_dummy_func(nullptr)
+          : Proxy_Function_Impl_Base(detail::build_param_type_list(static_cast<Func *>(nullptr))),
+            m_f(std::move(f)), m_dummy_func(nullptr)
         {
         }
 
         virtual ~Proxy_Function_Impl() {}
 
+        virtual bool compare_types_with_cast(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        {
+          return detail::compare_types_cast(m_dummy_func, vals, t_conversions);
+        }
+
         virtual bool operator==(const Proxy_Function_Base &t_func) const CHAISCRIPT_OVERRIDE
         {
-          const Proxy_Function_Impl *pimpl = dynamic_cast<const Proxy_Function_Impl<Func> *>(&t_func);
-          return pimpl != nullptr;
-        }
-
-        virtual int get_arity() const CHAISCRIPT_OVERRIDE
-        {
-          return static_cast<int>(m_types.size()) - 1;
-        }
-
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
-        {
-          if (int(vals.size()) != get_arity()) 
-          {
-            return false;
-          }
-
-          return compare_types(m_types, vals) || detail::compare_types_cast(m_dummy_func, vals, t_conversions);
-        }
-
-        virtual std::string annotation() const CHAISCRIPT_OVERRIDE
-        {
-          return "";
+          return dynamic_cast<const Proxy_Function_Impl<Func> *>(&t_func) != nullptr;
         }
 
         std::function<Func> internal_function() const
@@ -489,7 +588,7 @@ namespace chaiscript
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const
         {
           return detail::Do_Call<typename std::function<Func>::result_type>::go(m_f, params, t_conversions);
         }
@@ -507,8 +606,8 @@ namespace chaiscript
     {
       public:
         Attribute_Access(T Class::* t_attr)
-          : Proxy_Function_Base(param_types()),
-          m_attr(t_attr)
+          : Proxy_Function_Base(param_types(), 1),
+            m_attr(t_attr)
         {
         }
 
@@ -526,13 +625,7 @@ namespace chaiscript
           }
         }
 
-
-        virtual int get_arity() const CHAISCRIPT_OVERRIDE
-        {
-          return 1;
-        }
-
-        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Dynamic_Cast_Conversions &) const CHAISCRIPT_OVERRIDE
+        virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &) const CHAISCRIPT_OVERRIDE
         {
           if (vals.size() != 1)
           {
@@ -548,7 +641,7 @@ namespace chaiscript
         }
 
       protected:
-        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
+        virtual Boxed_Value do_call(const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
         {
           if (params.size() == 1)
           {
@@ -563,7 +656,7 @@ namespace chaiscript
             }
           } else {
             throw exception::arity_error(static_cast<int>(params.size()), 1);
-          }       
+          }
         }
 
       private:
@@ -592,6 +685,7 @@ namespace chaiscript
         {
         }
 
+        dispatch_error(const dispatch_error &) = default;
         virtual ~dispatch_error() CHAISCRIPT_NOEXCEPT {}
 
         std::vector<Boxed_Value> parameters;
@@ -605,7 +699,7 @@ namespace chaiscript
     {
       template<typename FuncType>
         bool types_match_except_for_arithmetic(const FuncType &t_func, const std::vector<Boxed_Value> &plist,
-            const Dynamic_Cast_Conversions &t_conversions)
+            const Type_Conversions &t_conversions)
         {
           if (t_func->get_arity() != static_cast<int>(plist.size()))
           {
@@ -633,7 +727,7 @@ namespace chaiscript
 
       template<typename InItr>
         Boxed_Value dispatch_with_conversions(InItr begin, const InItr &end, const std::vector<Boxed_Value> &plist, 
-            const Dynamic_Cast_Conversions &t_conversions)
+            const Type_Conversions &t_conversions)
         {
           InItr orig(begin);
 
@@ -695,17 +789,42 @@ 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
      */
-    template<typename InItr>
-      Boxed_Value dispatch(InItr begin, const InItr &end,
-          const std::vector<Boxed_Value> &plist, const Dynamic_Cast_Conversions &t_conversions)
+    template<typename Funcs>
+      Boxed_Value dispatch(const Funcs &funcs,
+          const std::vector<Boxed_Value> &plist, const Type_Conversions &t_conversions)
       {
-        InItr orig(begin);
-        while (begin != end)
+
+        std::multimap<size_t, const Proxy_Function_Base *> ordered_funcs;
+
+        for (const auto &func : funcs)
+        {
+          size_t numdiffs = 0;
+          const auto arity = func->get_arity();
+
+          if (arity == -1)
+          {
+            numdiffs = plist.size();
+          } else if (arity == static_cast<int>(plist.size())) {
+            for (size_t i = 0; i < plist.size(); ++i)
+            {
+              if (!func->get_param_types()[i+1].bare_equal(plist[i].get_type_info()))
+              {
+                ++numdiffs;
+              }
+            }
+          } else {
+            continue;
+          }
+
+          ordered_funcs.insert(std::make_pair(numdiffs, func.get()));
+        }
+
+        for (const auto &func : ordered_funcs )
         {
           try {
-            if ((*begin)->filter(plist, t_conversions))
+            if (func.second->filter(plist, t_conversions))
             {
-              return (*(*begin))(plist, t_conversions);
+              return (*(func.second))(plist, t_conversions);
             }
           } catch (const exception::bad_boxed_cast &) {
             //parameter failed to cast, try again
@@ -715,22 +834,9 @@ namespace chaiscript
             //guard failed to allow the function to execute,
             //try again
           }
-          ++begin;
         }
 
-        return detail::dispatch_with_conversions(orig, end, plist, t_conversions);
-      }
-
-    /**
-     * 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, const Dynamic_Cast_Conversions &t_conversions)
-      {
-        return dispatch::dispatch(funcs.begin(), funcs.end(), plist, t_conversions);
+        return detail::dispatch_with_conversions(funcs.cbegin(), funcs.cend(), plist, t_conversions);
       }
   }
 }

include/chaiscript/dispatchkit/proxy_functions_detail.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
@@ -20,7 +20,7 @@
 #include "type_info.hpp"
 
 namespace chaiscript {
-class Dynamic_Cast_Conversions;
+class Type_Conversions;
 namespace exception {
 class bad_boxed_cast;
 }  // namespace exception
@@ -42,6 +42,8 @@ namespace chaiscript
       {
       }
 
+      arity_error(const arity_error &) = default;
+
       virtual ~arity_error() CHAISCRIPT_NOEXCEPT {}
 
       int got;
@@ -53,29 +55,6 @@ namespace chaiscript
   {
     namespace detail
     {
-      template<typename ... Rest>
-      struct Build_Param_Type_List;
-
-      template<typename Param, typename ... Rest>
-      struct Build_Param_Type_List<Param, Rest...>
-      {
-        static void build(std::vector<Type_Info> &t_params)
-        {
-          t_params.push_back(chaiscript::detail::Get_Type_Info<Param>::get());
-          Build_Param_Type_List<Rest...>::build(t_params);
-        }
-      };
-
-      // 0th case
-      template<>
-      struct Build_Param_Type_List<>
-      {
-        static void build(std::vector<Type_Info> &)
-        {
-        }
-      };
-
-
       /**
        * Used by Proxy_Function_Impl to return a list of all param types
        * it contains.
@@ -83,12 +62,8 @@ namespace chaiscript
       template<typename Ret, typename ... Params>
         std::vector<Type_Info> build_param_type_list(Ret (*)(Params...))
         {
-          /// \todo this code was previously using { chaiscript::detail::Get_Type_Info<Ret>::get()... }
-          ///       but this seems to indicate another bug with MSVC's uniform initializer lists
-          std::vector<Type_Info> params;
-          params.push_back(chaiscript::detail::Get_Type_Info<Ret>::get());
-          Build_Param_Type_List<Params...>::build(params);
-          return params;
+          /// \note somehow this is responsible for a large part of the code generation
+          return { user_type<Ret>(), user_type<Params>()... };
         }
 
 
@@ -99,7 +74,7 @@ namespace chaiscript
       template<typename Param, typename ... Rest>
         struct Try_Cast<Param, Rest...>
         {
-          static void do_try(const std::vector<Boxed_Value> &params, int generation, const Dynamic_Cast_Conversions &t_conversions)
+          static void do_try(const std::vector<Boxed_Value> &params, size_t generation, const Type_Conversions &t_conversions)
           {
             boxed_cast<Param>(params[generation], &t_conversions);
             Try_Cast<Rest...>::do_try(params, generation+1, t_conversions);
@@ -110,7 +85,7 @@ namespace chaiscript
       template<>
         struct Try_Cast<>
         {
-          static void do_try(const std::vector<Boxed_Value> &, int, const Dynamic_Cast_Conversions &)
+          static void do_try(const std::vector<Boxed_Value> &, size_t, const Type_Conversions &)
           {
           }
         };
@@ -118,12 +93,12 @@ namespace chaiscript
 
       /**
        * Used by Proxy_Function_Impl to determine if it is equivalent to another
-       * Proxy_Function_Impl object. This function is primarly used to prevent
+       * Proxy_Function_Impl object. This function is primarily used to prevent
        * registration of two functions with the exact same signatures
        */
       template<typename Ret, typename ... Params>
         bool compare_types_cast(Ret (*)(Params...),
-             const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+             const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
        {
           try {
             Try_Cast<Params...>::do_try(params, 0, t_conversions);
@@ -140,7 +115,7 @@ namespace chaiscript
 
           template<typename ... InnerParams>
           static Ret do_call(const std::function<Ret (Params...)> &f,
-              const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions, InnerParams &&... innerparams)
+              const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions, InnerParams &&... innerparams)
           {
             return Call_Func<Ret, count - 1, Params...>::do_call(f, params, t_conversions, std::forward<InnerParams>(innerparams)..., params[sizeof...(Params) - count]);
           } 
@@ -155,7 +130,7 @@ namespace chaiscript
 #endif
           template<typename ... InnerParams>
             static Ret do_call(const std::function<Ret (Params...)> &f,
-                const std::vector<Boxed_Value> &, const Dynamic_Cast_Conversions &t_conversions, InnerParams &&... innerparams)
+                const std::vector<Boxed_Value> &, const Type_Conversions &t_conversions, InnerParams &&... innerparams)
             {
               return f(boxed_cast<Params>(std::forward<InnerParams>(innerparams), &t_conversions)...);
             }
@@ -166,13 +141,13 @@ namespace chaiscript
 
       /**
        * Used by Proxy_Function_Impl to perform typesafe execution of a function.
-       * The function attempts to unbox each paramter to the expected type.
+       * The function attempts to unbox each parameter 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, typename ... Params>
         Ret call_func(const std::function<Ret (Params...)> &f,
-            const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+            const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
         {
           if (params.size() == sizeof...(Params))
           {
@@ -198,7 +173,7 @@ namespace chaiscript
       struct Do_Call
       {
         template<typename Fun>
-          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
           {
             return Handle_Return<Ret>::handle(call_func(fun, params, t_conversions));
           }
@@ -208,7 +183,7 @@ namespace chaiscript
       struct Do_Call<void>
       {
         template<typename Fun>
-          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Dynamic_Cast_Conversions &t_conversions)
+          static Boxed_Value go(const std::function<Fun> &fun, const std::vector<Boxed_Value> &params, const Type_Conversions &t_conversions)
           {
             call_func(fun, params, t_conversions);
             return Handle_Return<void>::handle();

include/chaiscript/dispatchkit/register_function.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_REGISTER_FUNCTION_HPP_

include/chaiscript/dispatchkit/type_conversions.hpp

@@ -0,0 +1,453 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#ifndef CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
+#define CHAISCRIPT_DYNAMIC_CAST_CONVERSION_HPP_
+
+#include <atomic>
+#include <memory>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+
+#include "../chaiscript_threading.hpp"
+#include "bad_boxed_cast.hpp"
+#include "boxed_cast_helper.hpp"
+#include "boxed_value.hpp"
+#include "type_info.hpp"
+
+namespace chaiscript
+{
+  namespace exception
+  {
+    class bad_boxed_dynamic_cast : public bad_boxed_cast
+    {
+      public:
+        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to,
+            const std::string &t_what) CHAISCRIPT_NOEXCEPT
+          : bad_boxed_cast(t_from, t_to, t_what)
+        {
+        }
+
+        bad_boxed_dynamic_cast(const Type_Info &t_from, const std::type_info &t_to) CHAISCRIPT_NOEXCEPT
+          : bad_boxed_cast(t_from, t_to)
+        {
+        }
+
+        bad_boxed_dynamic_cast(const std::string &w) CHAISCRIPT_NOEXCEPT
+          : bad_boxed_cast(w)
+        {
+        }
+
+        bad_boxed_dynamic_cast(const bad_boxed_dynamic_cast &) = default;
+
+        virtual ~bad_boxed_dynamic_cast() CHAISCRIPT_NOEXCEPT {}
+    };
+
+    class bad_boxed_type_cast : public bad_boxed_cast
+    {
+      public:
+        bad_boxed_type_cast(const Type_Info &t_from, const std::type_info &t_to,
+            const std::string &t_what) CHAISCRIPT_NOEXCEPT
+          : bad_boxed_cast(t_from, t_to, t_what)
+        {
+        }
+
+        bad_boxed_type_cast(const Type_Info &t_from, const std::type_info &t_to) CHAISCRIPT_NOEXCEPT
+          : bad_boxed_cast(t_from, t_to)
+        {
+        }
+
+        bad_boxed_type_cast(const std::string &w) CHAISCRIPT_NOEXCEPT
+          : bad_boxed_cast(w)
+        {
+        }
+
+        bad_boxed_type_cast(const bad_boxed_type_cast &) = default;
+
+        virtual ~bad_boxed_type_cast() CHAISCRIPT_NOEXCEPT {}
+    };
+  }
+
+
+  namespace detail
+  {
+    class Type_Conversion_Base
+    {
+      public:
+        virtual Boxed_Value convert(const Boxed_Value &from) const = 0;
+        virtual Boxed_Value convert_down(const Boxed_Value &to) const = 0;
+
+        const Type_Info &to() const
+        {
+          return m_to;
+        }
+        const Type_Info &from() const
+        {
+          return m_from;
+        }
+
+      protected:
+        Type_Conversion_Base(const Type_Info &t_to, const Type_Info &t_from)
+          : m_to(t_to), m_from(t_from)
+        {
+        }
+
+        virtual ~Type_Conversion_Base() {} 
+
+      private:
+        Type_Info m_to;
+        Type_Info m_from;
+
+    };
+
+    template<typename From, typename To> 
+      class Dynamic_Caster
+      {
+        public: 
+          static Boxed_Value cast(const Boxed_Value &t_from)
+          {
+            if (t_from.get_type_info().bare_equal(chaiscript::user_type<From>()))
+            {
+              if (t_from.is_pointer())
+              {
+                // Dynamic cast out the contained boxed value, which we know is the type we want
+                if (t_from.is_const())
+                {
+                  std::shared_ptr<const To> data
+                    = std::dynamic_pointer_cast<const To>(detail::Cast_Helper<std::shared_ptr<const From> >::cast(t_from, nullptr));
+                  if (!data)
+                  {
+                    throw std::bad_cast();
+                  }
+
+                  return Boxed_Value(data);
+                } else {
+                  std::shared_ptr<To> data
+                    = std::dynamic_pointer_cast<To>(detail::Cast_Helper<std::shared_ptr<From> >::cast(t_from, nullptr));
+
+                  if (!data)
+                  {
+                    throw std::bad_cast();
+                  }
+
+                  return Boxed_Value(data);
+                }
+              } else {
+                // Pull the reference out of the contained boxed value, which we know is the type we want
+                if (t_from.is_const())
+                {
+                  const From &d = detail::Cast_Helper<const From &>::cast(t_from, nullptr);
+                  const To &data = dynamic_cast<const To &>(d);
+                  return Boxed_Value(std::cref(data));
+                } else {
+                  From &d = detail::Cast_Helper<From &>::cast(t_from, nullptr);
+                  To &data = dynamic_cast<To &>(d);
+                  return Boxed_Value(std::ref(data));
+                }
+              }
+            } else {
+              throw chaiscript::exception::bad_boxed_dynamic_cast(t_from.get_type_info(), typeid(To), "Unknown dynamic_cast_conversion");
+            }
+          }
+      };
+
+    template<typename Base, typename Derived>
+      class Dynamic_Conversion_Impl : public Type_Conversion_Base
+    {
+      public:
+        Dynamic_Conversion_Impl()
+          : Type_Conversion_Base(chaiscript::user_type<Base>(), chaiscript::user_type<Derived>())
+        {
+        }
+
+        virtual Boxed_Value convert_down(const Boxed_Value &t_base) const CHAISCRIPT_OVERRIDE
+        {
+          return Dynamic_Caster<Base, Derived>::cast(t_base);
+        }
+
+        virtual Boxed_Value convert(const Boxed_Value &t_derived) const CHAISCRIPT_OVERRIDE
+        {
+          return Dynamic_Caster<Derived, Base>::cast(t_derived);
+        }
+    };
+
+
+    template<typename Callable>
+    class Type_Conversion_Impl : public Type_Conversion_Base
+    {
+      public:
+        Type_Conversion_Impl(Type_Info t_from, Type_Info t_to, Callable t_func)
+          : Type_Conversion_Base(std::move(t_to), std::move(t_from)),
+            m_func(std::move(t_func))
+        {
+        }
+
+        virtual Boxed_Value convert_down(const Boxed_Value &) const CHAISCRIPT_OVERRIDE
+        {
+          throw chaiscript::exception::bad_boxed_type_cast("No conversion exists");
+        }
+
+        virtual Boxed_Value convert(const Boxed_Value &t_from) const CHAISCRIPT_OVERRIDE
+        {
+          /// \todo better handling of errors from the conversion function
+          return m_func(t_from);
+        }
+
+      private:
+        Callable m_func;
+    };
+
+  }
+
+  class Type_Conversions
+  {
+    public:
+      struct Less_Than
+      {
+        bool operator()(const std::type_info *t_lhs, const std::type_info *t_rhs) const
+        {
+          return *t_lhs != *t_rhs && t_lhs->before(*t_rhs);
+        }
+      };
+
+      Type_Conversions()
+        : m_mutex(),
+          m_conversions(),
+          m_convertableTypes(),
+          m_num_types(0),
+          m_thread_cache(this),
+          m_conversion_saves(this)
+      {
+      }
+
+      Type_Conversions(const Type_Conversions &t_other)
+        : m_mutex(),
+          m_conversions(t_other.get_conversions()),
+          m_convertableTypes(),
+          m_num_types(m_conversions.size()),
+          m_thread_cache(this),
+          m_conversion_saves(this)
+
+      {
+      }
+
+      const std::set<const std::type_info *, Less_Than> &thread_cache() const
+      {
+        auto &cache = *m_thread_cache;
+        if (cache.size() != m_num_types)
+        {
+          chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+          cache = m_convertableTypes;
+        }
+
+        return cache;
+      }
+
+      void add_conversion(const std::shared_ptr<detail::Type_Conversion_Base> &conversion)
+      {
+        chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+        /// \todo error if a conversion already exists
+        m_conversions.insert(conversion);
+        m_convertableTypes.insert({conversion->to().bare_type_info(), conversion->from().bare_type_info()});
+        m_num_types = m_convertableTypes.size();
+      }
+
+      template<typename T>
+        bool convertable_type() const
+        {
+          return thread_cache().count(user_type<T>().bare_type_info()) != 0;
+        }
+
+      template<typename To, typename From>
+        bool converts() const
+        {
+          return converts(user_type<To>(), user_type<From>());
+        }
+
+      bool converts(const Type_Info &to, const Type_Info &from) const
+      {
+        const auto &types = thread_cache();
+        if (types.count(to.bare_type_info()) != 0 && types.count(from.bare_type_info()) != 0)
+        {
+          return has_conversion(to, from) || has_conversion(from, to);
+        } else {
+          return false;
+        }
+
+      }
+
+      template<typename To>
+        Boxed_Value boxed_type_conversion(const Boxed_Value &from) const
+        {
+          try {
+            Boxed_Value ret = get_conversion(user_type<To>(), from.get_type_info())->convert(from);
+            if (m_conversion_saves->enabled) m_conversion_saves->saves.push_back(ret);
+            return ret;
+          } catch (const std::out_of_range &) {
+            throw exception::bad_boxed_dynamic_cast(from.get_type_info(), typeid(To), "No known conversion");
+          } catch (const std::bad_cast &) {
+            throw exception::bad_boxed_dynamic_cast(from.get_type_info(), typeid(To), "Unable to perform dynamic_cast operation");
+          }
+        }
+
+      template<typename From>
+        Boxed_Value boxed_type_down_conversion(const Boxed_Value &to) const
+        {
+          try {
+            Boxed_Value ret = get_conversion(to.get_type_info(), user_type<From>())->convert_down(to);
+            if (m_conversion_saves->enabled) m_conversion_saves->saves.push_back(ret);
+            return ret;
+          } catch (const std::out_of_range &) {
+            throw exception::bad_boxed_dynamic_cast(to.get_type_info(), typeid(From), "No known conversion");
+          } catch (const std::bad_cast &) {
+            throw exception::bad_boxed_dynamic_cast(to.get_type_info(), typeid(From), "Unable to perform dynamic_cast operation");
+          }
+        }
+
+      void enable_conversion_saves(bool t_val) 
+      {
+        m_conversion_saves->enabled = t_val;
+      }
+
+      std::vector<Boxed_Value> take_saves()
+      {
+        std::vector<Boxed_Value> ret;
+        std::swap(ret, m_conversion_saves->saves);
+        return ret;
+      }
+
+      bool has_conversion(const Type_Info &to, const Type_Info &from) const
+      {
+        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+        return find(to, from) != m_conversions.end();
+      }
+
+      std::shared_ptr<detail::Type_Conversion_Base> get_conversion(const Type_Info &to, const Type_Info &from) const
+      {
+        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+        auto itr = find(to, from);
+
+        if (itr != m_conversions.end())
+        {
+          return *itr;
+        } else {
+          throw std::out_of_range("No such conversion exists from " + from.bare_name() + " to " + to.bare_name());
+        }
+      }
+
+    private:
+      std::set<std::shared_ptr<detail::Type_Conversion_Base> >::const_iterator find(
+          const Type_Info &to, const Type_Info &from) const
+      {
+        return std::find_if(m_conversions.begin(), m_conversions.end(),
+              [&to, &from](const std::shared_ptr<detail::Type_Conversion_Base> &conversion)
+              {
+                return conversion->to().bare_equal(to) && conversion->from().bare_equal(from);
+              }
+        );
+      }
+
+      std::set<std::shared_ptr<detail::Type_Conversion_Base>> get_conversions() const
+      {
+        chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
+
+        return m_conversions;
+      }
+
+
+      struct Conversion_Saves
+      {
+        Conversion_Saves()
+          : enabled(false)
+        {}
+
+        bool enabled;
+        std::vector<Boxed_Value> saves;
+      };
+
+      mutable chaiscript::detail::threading::shared_mutex m_mutex;
+      std::set<std::shared_ptr<detail::Type_Conversion_Base>> m_conversions;
+      std::set<const std::type_info *, Less_Than> m_convertableTypes;
+      std::atomic_size_t m_num_types;
+      mutable chaiscript::detail::threading::Thread_Storage<std::set<const std::type_info *, Less_Than>> m_thread_cache;
+      mutable chaiscript::detail::threading::Thread_Storage<Conversion_Saves> m_conversion_saves;
+  };
+
+  typedef std::shared_ptr<chaiscript::detail::Type_Conversion_Base> Type_Conversion;
+
+  /// \brief Used to register a to / parent class relationship with ChaiScript. Necessary if you
+  ///        want automatic conversions up your inheritance hierarchy.
+  ///
+  /// Create a new to class registration for applying to a module or to the ChaiScript engine
+  /// Currently, due to limitations in module loading on Windows, and for the sake of portability,
+  /// if you have a type that is introduced in a loadable module and is used by multiple modules
+  /// (through a tertiary dll that is shared between the modules, static linking the new type
+  /// into both loadable modules would not be portable), you need to register the type
+  /// relationship in all modules that use the newly added type in a polymorphic way.
+  ///
+  /// Example:
+  /// \code
+  /// class Base
+  /// {};
+  /// class Derived : public Base
+  /// {};
+  ///
+  /// chaiscript::ChaiScript chai;
+  /// chai.add(chaiscript::to_class<Base, Derived>());
+  /// \endcode
+  /// 
+  template<typename Base, typename Derived>
+  Type_Conversion base_class()
+  {
+    //Can only be used with related polymorphic types
+    //may be expanded some day to support conversions other than child -> parent
+    static_assert(std::is_base_of<Base,Derived>::value, "Classes are not related by inheritance");
+    static_assert(std::is_polymorphic<Base>::value, "Base class must be polymorphic");
+    static_assert(std::is_polymorphic<Derived>::value, "Derived class must be polymorphic");
+
+    return std::make_shared<detail::Dynamic_Conversion_Impl<Base, Derived>>();
+  }
+
+  template<typename Callable>
+    Type_Conversion type_conversion(const Type_Info &t_from, const Type_Info &t_to, 
+        const Callable &t_func)
+    {
+      return std::make_shared<detail::Type_Conversion_Impl<Callable>>(t_from, t_to, t_func);
+    }
+
+  template<typename From, typename To, typename Callable>
+    Type_Conversion type_conversion(const Callable &t_function)
+    {
+      auto func = [t_function](const Boxed_Value &t_bv) -> Boxed_Value {
+            // not even attempting to call boxed_cast so that we don't get caught in some call recursion
+            return chaiscript::Boxed_Value(t_function(detail::Cast_Helper<const From &>::cast(t_bv, nullptr)));
+          };
+
+      return std::make_shared<detail::Type_Conversion_Impl<decltype(func)>>(user_type<From>(), user_type<To>(), func);
+    }
+
+  template<typename From, typename To>
+    Type_Conversion type_conversion()
+    {
+      static_assert(std::is_convertible<From, To>::value, "Types are not automatically convertible");
+      auto func = [](const Boxed_Value &t_bv) -> Boxed_Value {
+            // not even attempting to call boxed_cast so that we don't get caught in some call recursion
+            auto &&from =  detail::Cast_Helper<From>::cast(t_bv, nullptr);
+            To to(from);
+            return chaiscript::Boxed_Value(to);
+          };
+
+      return std::make_shared<detail::Type_Conversion_Impl<decltype(func)>>(user_type<From>(), user_type<To>(), func);
+    }
+
+}
+
+
+#endif

include/chaiscript/dispatchkit/type_info.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_TYPE_INFO_HPP_
@@ -25,6 +25,7 @@ namespace chaiscript
       };
   }
 
+
   /// \brief Compile time deduced information about a type
   class Type_Info
   {
@@ -38,7 +39,7 @@ namespace chaiscript
       {
       }
 
-      Type_Info()
+      CHAISCRIPT_CONSTEXPR Type_Info()
         : m_type_info(nullptr), m_bare_type_info(nullptr),
         m_is_const(false), m_is_reference(false), m_is_pointer(false),
         m_is_void(false), m_is_arithmetic(false), 
@@ -46,63 +47,49 @@ namespace chaiscript
       {
       }
 
-      Type_Info(const Type_Info &ti)
-        : m_type_info(ti.m_type_info), 
-        m_bare_type_info(ti.m_bare_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_is_arithmetic(ti.m_is_arithmetic),
-        m_is_undef(ti.m_is_undef)
-      {
-      }
+#if !defined(_MSC_VER) || _MSC_VER != 1800
+      Type_Info(Type_Info&&) = default;
+      Type_Info& operator=(Type_Info&&) = default;
+#endif
 
-      Type_Info &operator=(const Type_Info &ti)
-      {
-        m_type_info = ti.m_type_info;
-        m_bare_type_info = ti.m_bare_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_is_arithmetic = ti.m_is_arithmetic;
-        m_is_undef = ti.m_is_undef;
-        return *this;
-      }
+      Type_Info(const Type_Info&) = default;
+      Type_Info& operator=(const Type_Info&) = default;
 
-      bool operator<(const Type_Info &ti) const
+
+      CHAISCRIPT_CONSTEXPR bool operator<(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
       {
         return m_type_info < ti.m_type_info;
       }
 
-      bool operator==(const Type_Info &ti) const
+      CHAISCRIPT_CONSTEXPR bool operator==(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
       {
         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
+      CHAISCRIPT_CONSTEXPR bool operator==(const std::type_info &ti) const CHAISCRIPT_NOEXCEPT
       {
         return m_type_info != nullptr && (*m_type_info) == ti;
       }
 
-      bool bare_equal(const Type_Info &ti) const
+      CHAISCRIPT_CONSTEXPR bool bare_equal(const Type_Info &ti) const CHAISCRIPT_NOEXCEPT
       {
         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 bare_equal_type_info(const std::type_info &ti) const
+      CHAISCRIPT_CONSTEXPR bool bare_equal_type_info(const std::type_info &ti) const CHAISCRIPT_NOEXCEPT
       {
         return m_bare_type_info != nullptr 
           && (*m_bare_type_info) == ti;
       }
 
-      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_arithmetic() const { return m_is_arithmetic; }
-      bool is_undef() const { return m_is_undef || m_bare_type_info == nullptr; }
-      bool is_pointer() const { return m_is_pointer; }
+      CHAISCRIPT_CONSTEXPR bool is_const() const CHAISCRIPT_NOEXCEPT { return m_is_const; }
+      CHAISCRIPT_CONSTEXPR bool is_reference() const CHAISCRIPT_NOEXCEPT { return m_is_reference; }
+      CHAISCRIPT_CONSTEXPR bool is_void() const CHAISCRIPT_NOEXCEPT { return m_is_void; }
+      CHAISCRIPT_CONSTEXPR bool is_arithmetic() const CHAISCRIPT_NOEXCEPT { return m_is_arithmetic; }
+      CHAISCRIPT_CONSTEXPR bool is_undef() const CHAISCRIPT_NOEXCEPT { return m_is_undef || m_bare_type_info == nullptr; }
+      CHAISCRIPT_CONSTEXPR bool is_pointer() const CHAISCRIPT_NOEXCEPT { return m_is_pointer; }
 
       std::string name() const
       {
@@ -114,7 +101,7 @@ namespace chaiscript
         }
       }
 
-      std::string bare_name() const
+      std::string bare_name() const 
       {
         if (m_bare_type_info)
         {
@@ -124,6 +111,11 @@ namespace chaiscript
         }
       }
 
+      CHAISCRIPT_CONSTEXPR const std::type_info *bare_type_info() const
+      {
+        return m_bare_type_info;
+      }
+
     private:
       const std::type_info *m_type_info;
       const std::type_info *m_bare_type_info;
@@ -215,11 +207,6 @@ namespace chaiscript
         }
       };
 
-    template<typename T>
-      struct Stripped_Type
-      {
-        typedef typename Bare_Type<typename detail::Get_Type_Info<T>::type>::type type;
-      };
   }
 
   /// \brief Creates a Type_Info object representing the type passed in

include/chaiscript/language/chaiscript_algebraic.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_ALGEBRAIC_HPP_

include/chaiscript/language/chaiscript_common.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_COMMON_HPP_
@@ -37,7 +37,7 @@ namespace chaiscript
                 Comparison, Addition, Subtraction, Multiplication, Division, Modulus, Array_Call, Dot_Access, Quoted_String, Single_Quoted_String,
                 Lambda, Block, Def, While, If, For, Inline_Array, Inline_Map, Return, File, Prefix, Break, Continue, 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, Reference, Switch, Case, Default, Ternary_Cond, Noop
+                Logical_And, Logical_Or, Reference, Switch, Case, Default, Ternary_Cond, Noop, Class, Binary, Arg
     };
   };
 
@@ -50,7 +50,7 @@ namespace chaiscript
                                     "Comparison", "Addition", "Subtraction", "Multiplication", "Division", "Modulus", "Array_Call", "Dot_Access", "Quoted_String", "Single_Quoted_String",
                                     "Lambda", "Block", "Def", "While", "If", "For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Continue", "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", "Reference", "Switch", "Case", "Default", "Ternary Condition", "Noop"};
+                                    "Logical_And", "Logical_Or", "Reference", "Switch", "Case", "Default", "Ternary Condition", "Noop", "Class", "Binary", "Arg"};
 
       return ast_node_types[ast_node_type];
     }
@@ -69,6 +69,7 @@ namespace chaiscript
 
   /// \brief Typedef for pointers to AST_Node objects. Used in building of the AST_Node tree
   typedef std::shared_ptr<AST_Node> AST_NodePtr;
+  typedef std::shared_ptr<const AST_Node> AST_NodePtr_Const;
 
 
   /// \brief Classes which may be thrown during error cases when ChaiScript is executing.
@@ -82,7 +83,7 @@ namespace chaiscript
       File_Position end_position;
       std::string filename;
       std::string detail;
-      std::vector<AST_NodePtr> call_stack;
+      std::vector<AST_NodePtr_Const> call_stack;
 
       eval_error(const std::string &t_why, const File_Position &t_where, const std::string &t_fname,
           const std::vector<Boxed_Value> &t_parameters, const std::vector<chaiscript::Const_Proxy_Function> &t_functions,
@@ -111,25 +112,27 @@ namespace chaiscript
         reason(t_why) 
       {}
 
+      eval_error(const eval_error &) = default;
+
       std::string pretty_print() const
       {
         std::ostringstream ss;
 
         ss << what();
         if (call_stack.size() > 0) {
-          ss << "during evaluation at (" << fname(call_stack[0]) << " " << startpos(call_stack[0]) << ")" << std::endl;
-          ss << std::endl << detail << std::endl;
+          ss << "during evaluation at (" << fname(call_stack[0]) << " " << startpos(call_stack[0]) << ")\n";
+          ss << '\n' << detail << '\n';
           ss << "  " << fname(call_stack[0]) << " (" << startpos(call_stack[0]) << ") '" << pretty(call_stack[0]) << "'";
           for (size_t j = 1; j < call_stack.size(); ++j) {
             if (id(call_stack[j]) != chaiscript::AST_Node_Type::Block
                 && id(call_stack[j]) != chaiscript::AST_Node_Type::File)
             {
-              ss << std::endl;
+              ss << '\n';
               ss << "  from " << fname(call_stack[j]) << " (" << startpos(call_stack[j]) << ") '" << pretty(call_stack[j]) << "'";
             }
           }
         }
-        ss << std::endl;
+        ss << '\n';
         return ss.str();
       }
 
@@ -263,13 +266,13 @@ namespace chaiscript
         std::stringstream ss;
         if (t_functions.size() == 1)
         {
-          ss << "  Expected: " << format_types(t_functions[0], t_dot_notation, t_ss) << std::endl;
+          ss << "  Expected: " << format_types(t_functions[0], t_dot_notation, t_ss) << '\n';
         } else {
-          ss << "  " << t_functions.size() << " overloads available:" << std::endl;
+          ss << "  " << t_functions.size() << " overloads available:\n";
 
           for (const auto & t_function : t_functions)
           {
-            ss << "      " << format_types((t_function), t_dot_notation, t_ss) << std::endl;
+            ss << "      " << format_types((t_function), t_dot_notation, t_ss) << '\n';
           }
 
         }
@@ -394,6 +397,7 @@ namespace chaiscript
         : std::runtime_error("File Not Found: " + t_filename)
       { }
 
+      file_not_found_error(const file_not_found_error &) = default;
       virtual ~file_not_found_error() CHAISCRIPT_NOEXCEPT {}
     };
 
@@ -425,23 +429,19 @@ namespace chaiscript
 
 
       /// Prints the contents of an AST node, including its children, recursively
-      std::string to_string(const std::string &t_prepend = "") {
+      std::string to_string(const std::string &t_prepend = "") const {
         std::ostringstream oss;
 
         oss << t_prepend << "(" << ast_node_type_to_string(this->identifier) << ") "
-            << this->text << " : " << this->start.line << ", " << this->start.column << std::endl;
-        
+            << this->text << " : " << this->start.line << ", " << this->start.column << '\n';
+
         for (size_t j = 0; j < this->children.size(); ++j) {
           oss << this->children[j]->to_string(t_prepend + "  ");
         }
         return oss.str();
       }
 
-      std::string internal_to_string() {
-        return to_string();
-      }
-
-      Boxed_Value eval(chaiscript::detail::Dispatch_Engine &t_e) 
+      Boxed_Value eval(chaiscript::detail::Dispatch_Engine &t_e) const
       {
         try {
           return eval_internal(t_e);
@@ -470,7 +470,7 @@ namespace chaiscript
 
       virtual ~AST_Node() {}
 
-      virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &)
+      virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &) const
       {
         throw std::runtime_error("Undispatched ast_node (internal error)");
       }
@@ -510,6 +510,9 @@ namespace chaiscript
       /// Creates a new scope then pops it on destruction
       struct Scope_Push_Pop
       {
+        Scope_Push_Pop(const Scope_Push_Pop &) = delete;
+        Scope_Push_Pop& operator=(const Scope_Push_Pop &) = delete;
+
         Scope_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
           : m_de(t_de)
         {
@@ -523,9 +526,6 @@ namespace chaiscript
 
 
         private:
-        // explicitly unimplemented copy and assignment
-        Scope_Push_Pop(const Scope_Push_Pop &);
-        Scope_Push_Pop& operator=(const Scope_Push_Pop &);
 
         chaiscript::detail::Dispatch_Engine &m_de;
       };
@@ -533,6 +533,9 @@ namespace chaiscript
       /// Creates a new function call and pops it on destruction
       struct Function_Push_Pop
       {
+        Function_Push_Pop(const Function_Push_Pop &) = delete;
+        Function_Push_Pop& operator=(const Function_Push_Pop &) = delete;
+
         Function_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
           : m_de(t_de)
         {
@@ -549,11 +552,13 @@ namespace chaiscript
           m_de.save_function_params(t_params);
         }
 
+        void save_params(std::initializer_list<Boxed_Value> t_params)
+        {
+          m_de.save_function_params(std::move(t_params));
+        }
+
 
         private:
-        // explicitly unimplemented copy and assignment
-        Function_Push_Pop(const Function_Push_Pop &);
-        Function_Push_Pop& operator=(const Function_Push_Pop &);
 
         chaiscript::detail::Dispatch_Engine &m_de;
       };
@@ -561,6 +566,9 @@ namespace chaiscript
       /// Creates a new scope then pops it on destruction
       struct Stack_Push_Pop
       {
+        Stack_Push_Pop(const Stack_Push_Pop &) = delete;
+        Stack_Push_Pop& operator=(const Stack_Push_Pop &) = delete;
+
         Stack_Push_Pop(chaiscript::detail::Dispatch_Engine &t_de)
           : m_de(t_de)
         {
@@ -574,9 +582,6 @@ namespace chaiscript
 
 
         private:
-        // explicitly unimplemented copy and assignment
-        Stack_Push_Pop(const Stack_Push_Pop &);
-        Stack_Push_Pop& operator=(const Stack_Push_Pop &);
 
         chaiscript::detail::Dispatch_Engine &m_de;
       };

include/chaiscript/language/chaiscript_engine.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_ENGINE_HPP_
@@ -26,7 +26,7 @@
 #include "../dispatchkit/boxed_cast_helper.hpp"
 #include "../dispatchkit/boxed_value.hpp"
 #include "../dispatchkit/dispatchkit.hpp"
-#include "../dispatchkit/dynamic_cast_conversion.hpp"
+#include "../dispatchkit/type_conversions.hpp"
 #include "../dispatchkit/proxy_functions.hpp"
 #include "chaiscript_common.hpp"
 
@@ -61,9 +61,8 @@ namespace chaiscript
       {
       }
 
-      virtual ~load_module_error() CHAISCRIPT_NOEXCEPT
-      {
-      }
+      load_module_error(const load_module_error &) = default;
+      virtual ~load_module_error() CHAISCRIPT_NOEXCEPT {}
     };
   }
 
@@ -282,7 +281,7 @@ namespace chaiscript
           return Boxed_Value();
         }
       }
-      catch (const chaiscript::eval::detail::Return_Value &rv) {
+      catch (chaiscript::eval::detail::Return_Value &rv) {
         return rv.retval;
       }
     }
@@ -330,6 +329,7 @@ namespace chaiscript
       m_engine.add_reserved_word("break");
       m_engine.add_reserved_word("true");
       m_engine.add_reserved_word("false");
+      m_engine.add_reserved_word("class");
       m_engine.add_reserved_word("_");
 
       if (t_lib)
@@ -344,12 +344,21 @@ namespace chaiscript
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::function_exists, std::ref(m_engine)), "function_exists");
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_function_objects, std::ref(m_engine)), "get_functions");
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_scripting_objects, std::ref(m_engine)), "get_objects");
-      m_engine.add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(std::bind(&chaiscript::detail::Dispatch_Engine::call_exists, std::ref(m_engine), std::placeholders::_1))), 
-          "call_exists");
+      m_engine.add(Proxy_Function(new dispatch::Dynamic_Proxy_Function(
+              [this](const std::vector<Boxed_Value> &t_params) {
+                return m_engine.call_exists(t_params);
+              })), "call_exists");
       m_engine.add(fun<Boxed_Value (const dispatch::Proxy_Function_Base *, const std::vector<Boxed_Value> &)>(std::bind(&chaiscript::dispatch::Proxy_Function_Base::operator(), std::placeholders::_1, std::placeholders::_2, std::ref(m_engine.conversions()))), "call");
 
       m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type_name, std::ref(m_engine)), "name");
 
+      m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type, std::ref(m_engine)), "type");
+      m_engine.add(fun<void (const Type_Info &, const Type_Info &, const std::function<Boxed_Value (const Boxed_Value &)> &)> ( 
+            [=](const Type_Info &t_from, const Type_Info &t_to, const std::function<Boxed_Value (const Boxed_Value &)> &t_func) {
+              m_engine.add(chaiscript::type_conversion(t_from, t_to, t_func));
+            }
+          ), "add_type_conversion");
+
 
       typedef std::string (ChaiScript::*load_mod_1)(const std::string&);
       typedef void (ChaiScript::*load_mod_2)(const std::string&, const std::string&);
@@ -361,10 +370,10 @@ namespace chaiscript
       m_engine.add(fun(&ChaiScript::internal_eval, this), "eval");
       m_engine.add(fun(&ChaiScript::internal_eval_ast, this), "eval");
 
-      m_engine.add(fun(&ChaiScript::version_major, this), "version_major");
-      m_engine.add(fun(&ChaiScript::version_minor, this), "version_minor");
-      m_engine.add(fun(&ChaiScript::version_patch, this), "version_patch");
-      m_engine.add(fun(&ChaiScript::version, this), "version");
+      m_engine.add(fun(&ChaiScript::version_major), "version_major");
+      m_engine.add(fun(&ChaiScript::version_minor), "version_minor");
+      m_engine.add(fun(&ChaiScript::version_patch), "version_patch");
+      m_engine.add(fun(&ChaiScript::version), "version");
 
       m_engine.add(fun(&ChaiScript::add_global_const, this), "add_global_const");
       m_engine.add(fun(&ChaiScript::add_global, this), "add_global");
@@ -381,7 +390,7 @@ namespace chaiscript
         throw chaiscript::exception::file_not_found_error(t_filename);
       }
 
-      std::streampos size = infile.tellg();
+      const auto size = infile.tellg();
       infile.seekg(0, std::ios::beg);
 
       assert(size >= 0);
@@ -390,7 +399,7 @@ namespace chaiscript
       {
         return std::string();
       } else {
-        std::vector<char> v(static_cast<unsigned int>(size));
+        std::vector<char> v(static_cast<size_t>(size));
         infile.read(&v[0], size);
         return std::string(v.begin(), v.end());
       }
@@ -454,9 +463,9 @@ namespace chaiscript
       memset( &rInfo, 0, sizeof(rInfo) ); 
       cast_union u;
       u.in_ptr = &ChaiScript::use;
-      if ( dladdr((void*)(u.out_ptr), &rInfo) && rInfo.dli_fname ) { 
+      if ( dladdr(static_cast<void*>(u.out_ptr), &rInfo) && rInfo.dli_fname ) { 
         std::string dllpath(rInfo.dli_fname);
-        size_t lastslash = dllpath.rfind('/');
+        const size_t lastslash = dllpath.rfind('/');
         if (lastslash != std::string::npos)
         {
           dllpath.erase(lastslash);
@@ -464,15 +473,15 @@ namespace chaiscript
 
         // Let's see if this is a link that we should expand
         std::vector<char> buf(2048);
-        size_t pathlen = readlink(dllpath.c_str(), &buf.front(), buf.size());
+        const size_t pathlen = readlink(dllpath.c_str(), &buf.front(), buf.size());
         if (pathlen > 0 && pathlen < buf.size())
         {
           dllpath = std::string(&buf.front(), pathlen);
         }
 
         m_modulepaths.insert(m_modulepaths.begin(), dllpath+"/");
-      } 
-#endif    
+      }
+#endif
 
 
       // attempt to load the stdlib
@@ -481,28 +490,40 @@ namespace chaiscript
       build_eval_system(ModulePtr());
     }
 
-    int version_major() const
+    static int version_major()
     {
       return chaiscript::version_major;
     }
 
-    int version_minor() const
+    static int version_minor()
     {
       return chaiscript::version_minor;
     }
 
-    int version_patch() const
+    static int version_patch()
     {
       return chaiscript::version_patch;
     }
 
-    std::string version() const
+    static std::string version()
     {
       std::stringstream ss;
       ss << version_major() << "." << version_minor() << "." << version_patch();
       return ss.str();
     }
 
+    std::string get_type_name(const Type_Info &ti) const
+    {
+      return m_engine.get_type_name(ti);
+    }
+
+    template<typename T>
+    std::string get_type_name() const
+    {
+      return get_type_name(user_type<T>());
+    }
+
+
     /// \brief Loads and parses a file. If the file is already, it is not reloaded
     /// The use paths specified at ChaiScript construction time are searched for the 
     /// requested file.
@@ -510,10 +531,10 @@ namespace chaiscript
     /// \param[in] t_filename Filename to load and evaluate
     void use(const std::string &t_filename)
     {
-      for (size_t i = 0; i < m_usepaths.size(); ++i)
+      for (const auto &path : m_usepaths)
       {
         try {
-          const std::string appendedpath = m_usepaths[i] + t_filename;
+          const auto appendedpath = path + t_filename;
 
           chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::recursive_mutex> l(m_use_mutex);
           chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l2(m_mutex);
@@ -528,14 +549,12 @@ namespace chaiscript
 
           return; // return, we loaded it, or it was already loaded
         } catch (const exception::file_not_found_error &) {
-           if (i == m_usepaths.size() - 1)
-          {
-            throw exception::file_not_found_error(t_filename);
-          }
-
           // failed to load, try the next path
         }
       }
+
+      // failed to load by any name
+      throw exception::file_not_found_error(t_filename);
     }
 
     /// \brief Adds a constant object that is available in all contexts and to all threads
@@ -561,6 +580,8 @@ namespace chaiscript
     }
 
     /// \brief Represents the current state of the ChaiScript system. State and be saved and restored
+    /// \warning State object does not contain the user defined type conversions of the engine. They
+    ///          are left out due to performance considerations involved in tracking the state
     /// \sa ChaiScript::get_state
     /// \sa ChaiScript::set_state
     struct State
@@ -583,7 +604,7 @@ namespace chaiscript
     /// chaiscript::ChaiScript chai;
     /// chaiscript::ChaiScript::State s = chai.get_state(); // represents bootstrapped initial state
     /// \endcode
-    State get_state()
+    State get_state() const
     {
       chaiscript::detail::threading::lock_guard<chaiscript::detail::threading::recursive_mutex> l(m_use_mutex);
       chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l2(m_mutex);
@@ -666,7 +687,7 @@ namespace chaiscript
     /// chaiscript::ChaiScript chai;
     /// chai.add(chaiscript::base_class<std::runtime_error, chaiscript::dispatch_error>());
     /// \endcode
-    ChaiScript &add(const Dynamic_Cast_Conversion &d)
+    ChaiScript &add(const Type_Conversion &d)
     {
       m_engine.add(d);
       return *this;
@@ -686,7 +707,7 @@ namespace chaiscript
     /// \param[in] t_module_name Name of the module to load
     ///
     /// The module is searched for in the registered module path folders (chaiscript::ChaiScript::ChaiScript)
-    /// and with standard prefixes and postfixes: ("lib"|"")\<t_module_name\>(".dll"|".so"|"").
+    /// and with standard prefixes and postfixes: ("lib"|"")\<t_module_name\>(".dll"|".so"|".bundle"|"").
     ///
     /// Once the file is located, the system looks for the symbol "create_chaiscript_module_\<t_module_name\>".
     /// If no file can be found matching the search criteria and containing the appropriate entry point 
@@ -703,15 +724,9 @@ namespace chaiscript
         version_stripped_name.erase(version_pos);
       }
 
-      std::vector<std::string> prefixes;
-      prefixes.push_back("lib");
-      prefixes.push_back("cyg");
-      prefixes.push_back("");
+      std::vector<std::string> prefixes{"lib", "cyg", ""};
 
-      std::vector<std::string> postfixes;
-      postfixes.push_back(".dll");
-      postfixes.push_back(".so");
-      postfixes.push_back("");
+      std::vector<std::string> postfixes{".dll", ".so", ".bundle", ""};
 
       for (auto & elem : m_modulepaths) 
       {
@@ -720,12 +735,12 @@ namespace chaiscript
           for (auto & postfix : postfixes)
           {
             try {
-              std::string name = elem + prefix + t_module_name + postfix;
-              // std::cerr << "trying location: " << name << std::endl;
+              const auto name = elem + prefix + t_module_name + postfix;
+              // std::cerr << "trying location: " << name << '\n';
               load_module(version_stripped_name, name);
               return name;
             } catch (const chaiscript::exception::load_module_error &e) {
-              // std::cerr << "error: " << e.what() << std::endl;
+              // std::cerr << "error: " << e.what() << '\n';
               errors.push_back(e);
               // Try next set
             }
@@ -832,7 +847,7 @@ namespace chaiscript
     ///
     /// \param[in] t_input Script to execute
     /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions
-    /// \param[in] t_filename Optional filename to report to the user for where the error occured. Useful
+    /// \param[in] t_filename Optional filename to report to the user for where the error occurred. Useful
     ///                       in special cases where you are loading a file internally instead of using eval_file
     ///
     /// \return result of the script execution
@@ -866,7 +881,7 @@ namespace chaiscript
       }
     }
 
-    /// \brief Loads the file specified by filename, evaluates it, and returns the typesafe result.
+    /// \brief Loads the file specified by filename, evaluates it, and returns the type safe result.
     /// \tparam T Type to extract from the result value of the script execution
     /// \param[in] t_filename File to load and parse.
     /// \param[in] t_handler Optional Exception_Handler used for automatic unboxing of script thrown exceptions

include/chaiscript/language/chaiscript_prelude.chai

@@ -40,9 +40,9 @@ def new(x) {
   eval(type_name(x))(); 
 } 
 
-def clone(x) : function_exists(type_name(x)) && call_exists(eval(type_name(x)), x)  
-{ 
-  eval(type_name(x))(x); 
+def clone(x) : function_exists(type_name(x)) && call_exists(eval(type_name(x)), x)
+{
+  eval(type_name(x))(x).copy_var_attrs(x);
 }
 
 
@@ -56,11 +56,6 @@ def to_string(x) : call_exists(range, x) && !x.is_type("string"){
   "[" + x.join(", ") + "]"; 
 }
 
-# Basic to_string function
-def to_string(x) { 
-  internal_to_string(x); 
-}
-
 # Prints to console with no carriage return
 def puts(x) { 
   print_string(x.to_string()); 
@@ -136,8 +131,8 @@ def insert_at(container, pos, x)
 
 # Returns the reverse of the given container
 def reverse(container) {
-  auto retval = new(container); 
-  auto r = range(container); 
+  auto retval := new(container); 
+  auto r := range(container); 
   while (!r.empty()) { 
     retval.push_back(r.back()); 
     r.pop_back(); 
@@ -147,10 +142,16 @@ def reverse(container) {
 
 # Return a range from a range 
 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); 
+{
+  clone(r);
 }
 
+def range(r) : call_exists(range_internal, r)
+{
+  var ri := range_internal(r);
+  ri.get_var_attr("internal_obj") := r;
+  ri;
+}
 
 # The retro attribute that contains the underlying range 
 attr retro::m_range; 
@@ -200,19 +201,19 @@ def retro::empty()
 
 # Performs the second value function over the container first value
 def for_each(container, func) : call_exists(range, container) { 
-  var t_range = range(container); 
+  var t_range := range(container); 
   while (!t_range.empty()) { 
     func(t_range.front()); 
     t_range.pop_front(); 
   } 
 } 
 
-def back_inserter(container) { 
-  bind(push_back, container, _);     
+def back_inserter(container) {
+  bind(push_back, container, _);
 }
 
 def contains(container, item, compare_func) : call_exists(range, container) { 
-  auto t_range = range(container); 
+  auto t_range := range(container); 
   while (!t_range.empty()) { 
     if ( compare_func(t_range.front(), item) ) { 
       return true; 
@@ -220,15 +221,15 @@ def contains(container, item, compare_func) : call_exists(range, container) {
 
     t_range.pop_front(); 
   } 
-  return false; 
+  false; 
 } 
 
 def contains(container, item) { 
-  return contains(container, item, eq) 
+  contains(container, item, eq) 
 } 
 
 def map(container, func, inserter) : call_exists(range, container) { 
-  auto range = range(container); 
+  auto range := range(container); 
   while (!range.empty()) { 
     inserter(func(range.front())); 
     range.pop_front(); 
@@ -237,7 +238,7 @@ def map(container, func, inserter) : call_exists(range, container) {
 
 # Performs the second value function over the container first value. Creates a new container with the results
 def map(container, func) { 
-  auto retval = new(container); 
+  auto retval := new(container); 
   map(container, func, back_inserter(retval));
   retval;
 }
@@ -245,7 +246,7 @@ def map(container, func) {
 # Performs the second value function over the container first value. Starts with initial and continues with each element.
 def foldl(container, func, initial) : call_exists(range, container){ 
   auto retval = initial; 
-  auto range = range(container); 
+  auto range := range(container); 
   while (!range.empty()) { 
     retval = (func(range.front(), retval)); 
     range.pop_front(); 
@@ -266,8 +267,8 @@ def product(container) {
 # Returns a new container with the elements of the first value concatenated with the elements of the second value
 def concat(x, y) : call_exists(clone, x) { 
   auto retval = x; 
-  auto inserter = back_inserter(retval); 
-  auto range = range(y); 
+  auto inserter := back_inserter(retval); 
+  auto range := range(y); 
   while (!range.empty()) { 
     inserter(range.front()); 
     range.pop_front(); 
@@ -277,7 +278,7 @@ def concat(x, y) : call_exists(clone, x) {
 
 
 def take(container, num, inserter) : call_exists(range, container) { 
-  auto r = range(container); 
+  auto r := range(container); 
   auto i = num; 
   while ((i > 0) && (!r.empty())) { 
     inserter(r.front()); 
@@ -289,14 +290,14 @@ def take(container, num, inserter) : call_exists(range, container) {
 
 # Returns a new container with the given number of elements taken from the container
 def take(container, num) {
-  auto retval = new(container); 
+  auto retval := new(container); 
   take(container, num, back_inserter(retval)); 
   retval; 
 }
 
 
 def take_while(container, f, inserter) : call_exists(range, container) { 
-  auto r = range(container); 
+  auto r := range(container); 
   while ((!r.empty()) && f(r.front())) { 
     inserter(r.front()); 
     r.pop_front(); 
@@ -306,14 +307,14 @@ def take_while(container, f, inserter) : call_exists(range, container) {
 
 # Returns a new container with the given elements match the second value function
 def take_while(container, f) {
-  auto retval = new(container); 
+  auto retval := new(container); 
   take_while(container, f, back_inserter(retval)); 
   retval;
 }
 
 
 def drop(container, num, inserter) : call_exists(range, container) { 
-  auto r = range(container); 
+  auto r := range(container); 
   auto i = num; 
   while ((i > 0) && (!r.empty())) { 
     r.pop_front(); 
@@ -328,14 +329,14 @@ def drop(container, num, inserter) : call_exists(range, container) {
 
 # Returns a new container with the given number of elements dropped from the given container 
 def drop(container, num) {
-  auto retval = new(container); 
+  auto retval := new(container); 
   drop(container, num, back_inserter(retval)); 
   retval; 
 }
 
 
 def drop_while(container, f, inserter) : call_exists(range, container) { 
-  auto r = range(container); 
+  auto r := range(container); 
   while ((!r.empty())&& f(r.front())) { 
     r.pop_front(); 
   } 
@@ -348,7 +349,7 @@ def drop_while(container, f, inserter) : call_exists(range, container) {
 
 # Returns a new container with the given elements dropped that match the second value function
 def drop_while(container, f) {
-  auto retval = new(container); 
+  auto retval := new(container); 
   drop_while(container, f, back_inserter(retval)); 
   retval; 
 }
@@ -356,7 +357,7 @@ def drop_while(container, f) {
 
 # Applies the second value function to the container. Starts with the first two elements. Expects at least 2 elements.
 def reduce(container, func) : container.size() >= 2 && call_exists(range, container) { 
-  auto r = range(container); 
+  auto r := range(container); 
   auto retval = r.front(); 
   r.pop_front(); 
   retval = func(retval, r.front()); 
@@ -372,7 +373,7 @@ def reduce(container, func) : container.size() >= 2 && call_exists(range, contai
 # Returns a string of the elements in container delimited by the second value string
 def join(container, delim) { 
   auto retval = ""; 
-  auto range = range(container); 
+  auto range := range(container); 
   if (!range.empty()) { 
     retval += to_string(range.front()); 
     range.pop_front(); 
@@ -387,7 +388,7 @@ def join(container, delim) {
 
 
 def filter(container, f, inserter) : call_exists(range, container) { 
-  auto r = range(container); 
+  auto r := range(container); 
   while (!r.empty()) { 
     if (f(r.front())) { 
       inserter(r.front()); 
@@ -399,7 +400,7 @@ def filter(container, f, inserter) : call_exists(range, container) {
 
 # Returns a new Vector which match the second value function
 def filter(container, f) { 
-  auto retval = new(container); 
+  auto retval := new(container); 
   filter(container, f, back_inserter(retval));
   retval;
 }
@@ -416,7 +417,7 @@ def generate_range(x, y, inserter) {
 
 # Returns a new Vector which represents the range from the first value to the second value
 def generate_range(x, y) { 
-  auto retval = Vector(); 
+  auto retval := Vector(); 
   generate_range(x,y,back_inserter(retval)); 
   retval; 
 }
@@ -429,8 +430,8 @@ def collate(x, y) {
 
 
 def zip_with(f, x, y, inserter) : call_exists(range, x) && call_exists(range, y) { 
-  auto r_x = range(x); 
-  auto r_y = range(y); 
+  auto r_x := range(x); 
+  auto r_y := range(y); 
   while (!r_x.empty() && !r_y.empty()) { 
     inserter(f(r_x.front(), r_y.front())); 
     r_x.pop_front(); 
@@ -441,7 +442,7 @@ def zip_with(f, x, y, inserter) : call_exists(range, x) && call_exists(range, y)
 
 # Returns a new Vector which joins matching elements of the second and third value with the first value function
 def zip_with(f, x, y) { 
-  auto retval = Vector(); 
+  auto retval := Vector(); 
   zip_with(f,x,y,back_inserter(retval)); 
   retval;
 }
@@ -454,37 +455,37 @@ def zip(x, y) {
 
 
 # Returns the position of the second value string in the first value string
-def string::find(substr) : is_type(substr, "string") { 
+def string::find(string substr) { 
   find(this, substr, size_t(0)); 
 }
 
 
 # Returns the position of last match of the second value string in the first value string
-def string::rfind(substr) : is_type(substr, "string") { 
+def string::rfind(string substr) { 
   rfind(this, substr, size_t(-1)); 
 }
 
 
 # Returns the position of the first match of elements in the second value string in the first value string
-def string::find_first_of(list) : is_type(list, "string") { 
+def string::find_first_of(string list) { 
   find_first_of(this, list, size_t(0)); 
 } 
 
 
 # Returns the position of the last match of elements in the second value string in the first value string
-def string::find_last_of(list) : is_type(list, "string") { 
+def string::find_last_of(string list) {
   find_last_of(this, list, size_t(-1)); 
 } 
 
 
 # Returns the position of the first non-matching element in the second value string in the first value string
-def string::find_first_not_of(list) : is_type(list, "string") { 
+def string::find_first_not_of(string list) { 
   find_first_not_of(this, list, size_t(0)); 
 } 
 
 
 # Returns the position of the last non-matching element in the second value string in the first value string
-def string::find_last_not_of(list) : is_type(list, "string") { 
+def string::find_last_not_of(string list) { 
   find_last_not_of(this, list, size_t(-1)); 
 } 
 
@@ -504,8 +505,8 @@ def string::trim() {
 }
 
 
-def find(container, value, compare_func) : call_exists(range, container) && is_type(compare_func, "Function") { 
-  auto range = range(container); 
+def find(container, value, Function compare_func) : call_exists(range, container) { 
+  auto range := range(container); 
   while (!range.empty()) { 
     if (compare_func(range.front(), value)) { 
       return range; 
@@ -513,12 +514,12 @@ def find(container, value, compare_func) : call_exists(range, container) && is_t
       range.pop_front(); 
     } 
   } 
-  return range; 
+  range; 
 } 
 
 
 def find(container, value) { 
-  return find(container, value, eq) 
+  find(container, value, eq) 
 } 
 
 

include/chaiscript/language/chaiscript_prelude_docs.hpp

@@ -112,7 +112,7 @@ class Map
 };
 
 
-/// \brief A concept implemented by string, Vector and Map. It is convertable to Range, default constructable and back_insertable
+/// \brief A concept implemented by string, Vector and Map. It is convertible to Range, default constructable and back_insertable
 class Container
 {
   public:
@@ -153,10 +153,10 @@ void print(Object o);
 
 /// \brief ChaiScript representation of std::string. It is an std::string but only some member are exposed to ChaiScript.
 /// 
-/// Because the ChaiScript string object is an std::string, it is directly convertable to and from std::string
+/// Because the ChaiScript string object is an std::string, it is directly convertible to and from std::string
 /// using the chaiscript::boxed_cast and chaiscript::var functions.
 ///
-/// With the exception of string::trim, string::rtrim, string::ltrim, all members are direct passthroughs to the
+/// With the exception of string::trim, string::rtrim, string::ltrim, all members are direct pass-throughs to the
 /// std::string of the same name. 
 ///
 /// \note Object and function notations are equivalent in ChaiScript. This means that
@@ -519,7 +519,7 @@ class Function
     /// \brief Returns a vector of Type_Info objects that represent the param types for this function.
     ///        The first value in the list is the return type.
     /// 
-    /// If this function is a conglomeration of several functions (get_contained_values().size() > 0)
+    /// If this function is a conglomerate of several functions (get_contained_values().size() > 0)
     /// then the function returns as many Type_Info objects as it can. If the functions contained all have
     /// the same arity, then it represents the arity. If they have different arities, it returns only
     /// one value - the return type. 
@@ -534,7 +534,7 @@ class Function
     /// \endcode
     Vector get_param_types() const;
 
-    /// \brief Returns true if the function has a guard to it. Always returns falls for a conglomerate function
+    /// \brief Returns true if the function has a guard to it. Always returns false for a conglomerate function
     bool has_guard() const;
 
     /// \brief Calls the function with the given set of parameters and returns the value;

include/chaiscript/utility/utility.hpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #ifndef CHAISCRIPT_UTILITY_UTILITY_HPP_
@@ -21,8 +21,29 @@ namespace chaiscript
   namespace utility
   {
 
-    /// \todo Use of this utility, and uniform initializer lists, is causing memory errors in MSVC
-    
+    /// Single step command for registering a class with ChaiScript
+    /// 
+    /// \param[in,out] t_module Model to add class to
+    /// \param[in] t_class_name Name of the class being registered
+    /// \param[in] t_constructors Vector of constructors to add
+    /// \param[in] t_funcs Vector of methods to add
+    ///
+    /// \example Adding a basic class to ChaiScript in one step
+    /// 
+    /// \code
+    /// chaiscript::utility::add_class<test>(*m,
+    ///      "test",
+    ///      { constructor<test ()>(),
+    ///        constructor<test (const test &)>() },
+    ///      { {fun(&test::function), "function"},
+    ///        {fun(&test::function2), "function2"},
+    ///        {fun(&test::function3), "function3"},
+    ///        {fun(static_cast<std::string(test::*)(double)>(&test::functionoverload)), "functionoverload" },
+    ///        {fun(static_cast<std::string(test::*)(int)>(&test::functionoverload)), "functionoverload" },
+    ///        {fun(static_cast<test & (test::*)(const test &)>(&test::operator=)), "=" }
+    ///        }
+    ///      );
+    /// 
     template<typename Class, typename ModuleType>
       void add_class(ModuleType &t_module,
           const std::string &t_class_name,
@@ -36,13 +57,11 @@ namespace chaiscript
           t_module.add(ctor, t_class_name);
         }
 
-        for(auto fun: t_funcs)
+        for(const auto &fun: t_funcs)
         {
           t_module.add(fun.first, fun.second);
         }
-        
       }
-      
   }
 }
 

license.txt

@@ -1,4 +1,4 @@
-Copyright 2009-2014 Jason Turner
+Copyright 2009-2015 Jason Turner
 Copyright 2009-2012 Jonathan Turner. 
 
 All Rights Reserved.

readme.md

@@ -8,7 +8,7 @@ ChaiScript
 http://www.chaiscript.com
 
 (c) 2009-2012 Jonathan Turner
-(c) 2009-2014 Jason Turner
+(c) 2009-2015 Jason Turner
 
 Release under the BSD license, see "license.txt" for details.
 
@@ -16,6 +16,8 @@ Release under the BSD license, see "license.txt" for details.
 Introduction
 ============
 
+[![Gitter](https://badges.gitter.im/Join Chat.svg)](https://gitter.im/ChaiScript/ChaiScript?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
 ChaiScript is one of the only embedded scripting language designed from the 
 ground up to directly target C++ and take advantage of modern C++ development 
 techniques, working with the developer like he expects it to work.  Being a 
@@ -33,9 +35,10 @@ Requirements
 ============
 
 ChaiScript requires a C++11 compiler to build with support for variadic 
-templates.  It has been tested with gcc 4.7 and clang 3.1 (with libcxx). MacOS 
+templates.  It has been tested with gcc 4.6 and clang 3.1 (with libcxx). MacOS 
 10.8 (Mountain Lion) is also known to support the C++11 build with Apple's 
-clang 4.0.
+clang 4.0. MSVC 2013 or newer is supports also. For more information see the build 
+[dashboard](http://chaiscript.com/ChaiScript-BuildResults/index.html).
 
 Usage
 =====

releasenotes.md

@@ -1,6 +1,55 @@
 Notes:
 =======
-Current Version: 5.3.1
+Current Version: 5.6.0
+
+### Changes since 5.5.1
+* Throw exception on integer divide by 0
+* Add optional type specification to function declarations
+   
+  ```
+  def func(int i, j, double k) {
+    // i must be an int.
+    // j can be anything
+    // k must be a double
+    // normal conversion rules still apply
+  }
+   ```
+* Many minor fixes for compiler warnings
+* Add support for `std::future` and `std::async`
+  ```
+  var f := async(someFunction);
+  var f2 := async(someFunction2);
+
+  // someFunction and someFunction2 are running in parallel now
+  f.get();
+  f2.get();
+  ```
+* Fully support r-value returns, supporting move-only objects and reducing object copies
+
+
+### Changes since 5.5.0
+* 30% performance increase
+* Fix handling of object stack, resulting in greatly reduced memory usage
+* Code cleanups
+
+### Changes since 5.4.0
+* 2x performance increase
+* Significant code cleanups
+* Throw exception if user attempts to call function on null object
+* Allow user defined type conversions
+* Fix object lifetime for nested function calls made at the global scope
+* Fix returning of boolean values from function calls
+
+
+### Changes since 5.3.1
+* Decreased compile time and build size
+* Make "reflection" module built in (losing some of the time / build size gains)
+* Add new "class" syntax for ChaiScript defined methods and attributes see: [unittests/class.chai](unittests/class.chai) for examples
+* Minor performance enhancements
+* major to_string performance enhancements
+* Provide API for retrieving registered type name #124
+* Added strong reference to container to range object #132
+
 
 ### Changes since 5.3.0
 * Add automatic conversion of arithmetic return types, following the same

samples/example.cpp

@@ -13,12 +13,12 @@
 
 void log(const std::string &msg)
 {
-  std::cout << "[" << time(nullptr) << "] " << msg << std::endl;
+  std::cout << "[" << time(nullptr) << "] " << msg << '\n';
 }
 
 void log(const std::string &module, const std::string &msg)
 {
-  std::cout << "[" << time(nullptr) << "] <" << module << "> " << msg << std::endl;
+  std::cout << "[" << time(nullptr) << "] <" << module << "> " << msg << '\n';
 }
 
 void bound_log(const std::string &msg)
@@ -28,12 +28,12 @@ void bound_log(const std::string &msg)
 
 void hello_world(const chaiscript::Boxed_Value & /*o*/)
 {
-  std::cout << "Hello World" << std::endl;
+  std::cout << "Hello World\n";
 }
 
 void hello_constructor(const chaiscript::Boxed_Value & /*o*/)
 {
-  std::cout << "Hello Constructor" << std::endl;
+  std::cout << "Hello Constructor\n";
 }
 
 
@@ -62,7 +62,7 @@ struct System
 
 void take_shared_ptr(const std::shared_ptr<const std::string> &p)
 {
-  std::cout << *p << std::endl;
+  std::cout << *p << '\n';
 }
 
 int main(int /*argc*/, char * /*argv*/[]) {
@@ -122,7 +122,7 @@ int main(int /*argc*/, char * /*argv*/[]) {
   //the templated version of eval:
   int i = chai.eval<int>("5+5");
 
-  std::cout << "5+5: " << i << std::endl;
+  std::cout << "5+5: " << i << '\n';
 
   //Add a new variable
   chai("var scripti = 15");
@@ -130,9 +130,9 @@ int main(int /*argc*/, char * /*argv*/[]) {
   //We can even get a handle to the variables in the system
   int &scripti = chai.eval<int &>("scripti");
 
-  std::cout << "scripti: " << scripti << std::endl;
+  std::cout << "scripti: " << scripti << '\n';
   scripti *= 2;
-  std::cout << "scripti (updated): " << scripti << std::endl;
+  std::cout << "scripti (updated): " << scripti << '\n';
   chai("print(\"Scripti from chai: \" + to_string(scripti))");
 
   //To do: Add examples of handling Boxed_Values directly when needed

samples/fun_call_performance.chai

@@ -0,0 +1,4 @@
+for (var i = 0; i < 1000; ++i) {
+  puts(helloWorld("Bob12345"))
+}
+

samples/fun_call_performance.cpp

@@ -0,0 +1,405 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
+// http://www.chaiscript.com
+
+#include <iostream>
+#include <list>
+#include <regex>
+
+#ifdef _MSC_VER
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <chaiscript/chaiscript.hpp>
+#include <chaiscript/chaiscript_stdlib.hpp>
+
+#ifdef READLINE_AVAILABLE
+#include <readline/readline.h>
+#include <readline/history.h>
+#else
+
+char *mystrdup(const char *s) {
+  size_t len = strlen(s); // Space for length plus nul
+  char *d = static_cast<char*>(malloc(len + 1));
+  if (d == nullptr) return nullptr;          // No memory
+#ifdef CHAISCRIPT_MSVC
+  strcpy_s(d, len + 1, s);                        // Copy the characters
+#else
+  strncpy(d, s, len);                        // Copy the characters
+#endif
+  d[len] = '\0';
+  return d;                            // Return the new string
+}
+
+char* readline(const char* p)
+{
+  std::string retval;
+  std::cout << p;
+  std::getline(std::cin, retval);
+  return std::cin.eof() ? nullptr : mystrdup(retval.c_str());
+}
+
+
+void add_history(const char*){}
+void using_history(){}
+#endif
+
+
+
+void *cast_module_symbol(std::vector<std::string>(*t_path)())
+{
+  union cast_union
+  {
+    std::vector<std::string>(*in_ptr)();
+    void *out_ptr;
+  };
+
+  cast_union c;
+  c.in_ptr = t_path;
+  return c.out_ptr;
+}
+
+std::vector<std::string> default_search_paths()
+{
+  std::vector<std::string> paths;
+
+#ifdef CHAISCRIPT_WINDOWS  // force no unicode
+  CHAR path[4096];
+  int size = GetModuleFileNameA(0, path, sizeof(path) - 1);
+
+  std::string exepath(path, size);
+
+  size_t lastslash = exepath.rfind('\\');
+  size_t secondtolastslash = exepath.rfind('\\', lastslash - 1);
+  if (lastslash != std::string::npos)
+  {
+    paths.push_back(exepath.substr(0, lastslash));
+  }
+
+  if (secondtolastslash != std::string::npos)
+  {
+    return{ exepath.substr(0, secondtolastslash) + "\\lib\\chaiscript\\" };
+  }
+#else
+
+  std::string exepath;
+
+  std::vector<char> buf(2048);
+  ssize_t size = -1;
+
+  if ((size = readlink("/proc/self/exe", &buf.front(), buf.size())) != -1)
+  {
+    exepath = std::string(&buf.front(), size);
+  }
+
+  if (exepath.empty())
+  {
+    if ((size = readlink("/proc/curproc/file", &buf.front(), buf.size())) != -1)
+    {
+      exepath = std::string(&buf.front(), size);
+    }
+  }
+
+  if (exepath.empty())
+  {
+    if ((size = readlink("/proc/self/path/a.out", &buf.front(), buf.size())) != -1)
+    {
+      exepath = std::string(&buf.front(), size);
+    }
+  }
+
+  if (exepath.empty())
+  {
+    Dl_info rInfo;
+    memset(&rInfo, 0, sizeof(rInfo));
+    if (!dladdr(cast_module_symbol(&default_search_paths), &rInfo) || !rInfo.dli_fname) {
+      return paths;
+    }
+
+    exepath = std::string(rInfo.dli_fname);
+  }
+
+  size_t lastslash = exepath.rfind('/');
+
+  size_t secondtolastslash = exepath.rfind('/', lastslash - 1);
+  if (lastslash != std::string::npos)
+  {
+    paths.push_back(exepath.substr(0, lastslash));
+  }
+
+  if (secondtolastslash != std::string::npos)
+  {
+    paths.push_back(exepath.substr(0, secondtolastslash) + "/lib/chaiscript/");
+  }
+#endif
+
+  return paths;
+}
+
+void help(int n) {
+  if (n >= 0) {
+    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;
+  }
+  else {
+    std::cout << "usage : chai [option]+" << std::endl;
+    std::cout << "option:" << std::endl;
+    std::cout << "   -h | --help" << std::endl;
+    std::cout << "   -i | --interactive" << std::endl;
+    std::cout << "   -c | --command cmd" << std::endl;
+    std::cout << "   -v | --version" << std::endl;
+    std::cout << "   -    --stdin" << std::endl;
+    std::cout << "   filepath" << std::endl;
+  }
+}
+
+std::string helloWorld(const std::string &t_name)
+{
+  return "Hello " + t_name + "!";
+}
+
+bool throws_exception(const std::function<void()> &f)
+{
+  try {
+    f();
+  }
+  catch (...) {
+    return true;
+  }
+
+  return false;
+}
+
+chaiscript::exception::eval_error get_eval_error(const std::function<void()> &f)
+{
+  try {
+    f();
+  }
+  catch (const chaiscript::exception::eval_error &e) {
+    return e;
+  }
+
+  throw std::runtime_error("no exception throw");
+}
+
+std::string get_next_command() {
+  std::string retval("quit");
+  if (!std::cin.eof()) {
+    char *input_raw = readline("eval> ");
+    if (input_raw) {
+      add_history(input_raw);
+
+      std::string val(input_raw);
+      size_t pos = val.find_first_not_of("\t \n");
+      if (pos != std::string::npos)
+      {
+        val.erase(0, pos);
+      }
+      pos = val.find_last_not_of("\t \n");
+      if (pos != std::string::npos)
+      {
+        val.erase(pos + 1, std::string::npos);
+      }
+
+      retval = val;
+
+      ::free(input_raw);
+    }
+  }
+  if (retval == "quit"
+      || retval == "exit"
+      || retval == "help"
+      || retval == "version")
+  {
+    retval += "(0)";
+  }
+  return retval;
+}
+
+// We have to wrap exit with our own because Clang has a hard time with
+// function pointers to functions with special attributes (system exit being marked NORETURN)
+void myexit(int return_val) {
+  exit(return_val);
+}
+
+void interactive(chaiscript::ChaiScript& chai)
+{
+  using_history();
+
+  for (;;) {
+    std::string input = get_next_command();
+    try {
+      // evaluate input
+      chaiscript::Boxed_Value val = chai.eval(input);
+
+      //Then, we try to print the result of the evaluation to the user
+      if (!val.get_type_info().bare_equal(chaiscript::user_type<void>())) {
+        try {
+          std::cout << chai.eval<std::function<std::string(const chaiscript::Boxed_Value &bv)> >("to_string")(val) << std::endl;
+        }
+        catch (...) {} //If we can't, do nothing
+      }
+    }
+    catch (const chaiscript::exception::eval_error &ee) {
+      std::cout << ee.what();
+      if (ee.call_stack.size() > 0) {
+        std::cout << "during evaluation at (" << ee.call_stack[0]->start.line << ", " << ee.call_stack[0]->start.column << ")";
+      }
+      std::cout << std::endl;
+    }
+    catch (const std::exception &e) {
+      std::cout << e.what();
+      std::cout << std::endl;
+    }
+  }
+}
+
+int main(int argc, char *argv[])
+{
+
+  // Disable deprecation warning for getenv call.
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+
+  const char *usepath = getenv("CHAI_USE_PATH");
+  const char *modulepath = getenv("CHAI_MODULE_PATH");
+
+#ifdef CHAISCRIPT_MSVC
+#pragma warning(pop)
+#endif
+
+  std::vector<std::string> usepaths;
+  usepaths.push_back("");
+  if (usepath)
+  {
+    usepaths.push_back(usepath);
+  }
+
+  std::vector<std::string> modulepaths;
+  std::vector<std::string> searchpaths = default_search_paths();
+  modulepaths.insert(modulepaths.end(), searchpaths.begin(), searchpaths.end());
+  modulepaths.push_back("");
+  if (modulepath)
+  {
+    modulepaths.push_back(modulepath);
+  }
+
+  //chaiscript::ChaiScript chai(modulepaths, usepaths);
+  chaiscript::ChaiScript chai(chaiscript::Std_Lib::library(), usepaths);
+
+  chai.add(chaiscript::fun(&myexit), "exit");
+  chai.add(chaiscript::fun(&myexit), "quit");
+  chai.add(chaiscript::fun(&help), "help");
+  chai.add(chaiscript::fun(&throws_exception), "throws_exception");
+  chai.add(chaiscript::fun(&get_eval_error), "get_eval_error");
+
+  chai.add(chaiscript::fun(&helloWorld), "helloWorld");
+
+  clock_t begin = clock();
+
+  for (int i = 0; i < 1000; i++)
+  {
+    std::string str = helloWorld("Bob12345");
+    fwrite(str.c_str(), 1, str.size(), stdout);
+  }
+
+  clock_t end = clock();
+  double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
+
+  //begin = clock();
+
+  ////for (int i = 0; i < 1000; i++)
+  ////{
+  ////	chai.eval("puts(helloWorld(\"Bob12345\"));");
+  ////}
+  //chai.eval_file("E:\\C++\\ChaiScript - 5.4.0\\samples\forx.chai");
+
+  //end = clock();
+  //elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
+  //printf("**MyProgram::time= %lf\n", elapsed_secs);
+
+  for (int i = 0; i < argc; ++i) {
+    if (i == 0 && argc > 1) {
+      ++i;
+    }
+
+    std::string arg(i ? argv[i] : "--interactive");
+
+    enum {
+      eInteractive
+        , eCommand
+        , eFile
+    } mode = eCommand;
+
+    if (arg == "-c" || arg == "--command") {
+      if ((i + 1) >= argc) {
+        std::cout << "insufficient input following " << arg << std::endl;
+        return EXIT_FAILURE;
+      }
+      else {
+        arg = argv[++i];
+      }
+    }
+    else if (arg == "-" || arg == "--stdin") {
+      arg = "";
+      std::string line;
+      while (std::getline(std::cin, line)) {
+        arg += line + '\n';
+      }
+    }
+    else if (arg == "-v" || arg == "--version") {
+      arg = "version()";
+    }
+    else if (arg == "-h" || arg == "--help") {
+      arg = "help(-1)";
+    }
+    else if (arg == "-i" || arg == "--interactive") {
+      mode = eInteractive;
+    }
+    else if (arg.find('-') == 0) {
+      std::cout << "unrecognised argument " << arg << std::endl;
+      return EXIT_FAILURE;
+    }
+    else {
+      mode = eFile;
+    }
+
+    chaiscript::Boxed_Value val;
+    try {
+      switch (mode) {
+        case eInteractive: interactive(chai); break;
+        case eCommand: val = chai.eval(arg); break;
+        case eFile: {
+                      begin = clock();
+
+                      val = chai.eval_file(arg);
+
+                      end = clock();
+                      double elapsed_secs1 = double(end - begin) / CLOCKS_PER_SEC;
+                      printf("**C++::time= %.10f\n", elapsed_secs);
+                      printf("**ChaiScript::time= %.10f\n", elapsed_secs1);
+                      break;
+                    }
+
+      }
+    }
+    catch (const chaiscript::exception::eval_error &ee) {
+      std::cout << ee.pretty_print();
+      std::cout << std::endl;
+      return EXIT_FAILURE;
+    }
+    catch (std::exception &e) {
+      std::cout << e.what() << std::endl;
+      return EXIT_FAILURE;
+    }
+  }
+
+  return EXIT_SUCCESS;
+}
+

samples/inheritance.cpp

@@ -0,0 +1,136 @@
+#include <chaiscript/chaiscript.hpp>
+#include <chaiscript/chaiscript_stdlib.hpp>
+
+class BaseClass
+{
+  public:
+    BaseClass()
+    {
+    }
+
+    BaseClass(const BaseClass &) = default;
+
+    virtual ~BaseClass() {}
+
+    virtual std::string doSomething(float, double) const = 0;
+
+
+    void setValue(const std::string &t_val) {
+      if (validateValue(t_val))
+      {
+        m_value = t_val;
+      }
+    }
+
+    std::string getValue() const {
+      return m_value;
+    }
+
+  protected:
+    virtual bool validateValue(const std::string &t_val) = 0;
+
+  private:
+    std::string m_value;
+};
+
+class ChaiScriptDerived : public BaseClass
+{
+  public:
+    ChaiScriptDerived(const std::vector<chaiscript::Boxed_Value> &t_funcs)
+    {
+      // using the range-checked .at() methods to give us an exception
+      // instead of a crash if the user passed in too-few params
+      tie(t_funcs.at(0), m_doSomethingImpl);
+      tie(t_funcs.at(1), m_validateValueImpl);
+    }
+
+    std::string doSomething(float f, double d) const CHAISCRIPT_OVERRIDE
+    {
+      assert(m_doSomethingImpl);
+      return m_doSomethingImpl(*this, f, d);
+    }
+
+  protected:
+    bool validateValue(const std::string &t_val) CHAISCRIPT_OVERRIDE
+    {
+      assert(m_validateValueImpl);
+      return m_validateValueImpl(*this, t_val);
+    }
+
+  private:
+    template<typename Param>
+    void tie(const chaiscript::Boxed_Value &t_func, Param &t_param)
+    {
+      t_param = chaiscript::boxed_cast<Param>(t_func);
+    }
+
+    std::function<std::string (const ChaiScriptDerived&, float, double)> m_doSomethingImpl;
+    std::function<bool (ChaiScriptDerived&, const std::string &t_val)> m_validateValueImpl;
+};
+
+int main()
+{
+  chaiscript::ChaiScript chai(chaiscript::Std_Lib::library());
+  chai.add(chaiscript::fun(&BaseClass::doSomething), "doSomething");
+  chai.add(chaiscript::fun(&BaseClass::setValue), "setValue");
+  chai.add(chaiscript::fun(&BaseClass::getValue), "getValue");
+  chai.add(chaiscript::constructor<ChaiScriptDerived (const std::vector<chaiscript::Boxed_Value> &)>(), "ChaiScriptDerived");
+  chai.add(chaiscript::base_class<BaseClass, ChaiScriptDerived>());
+  chai.add(chaiscript::user_type<BaseClass>(), "BaseClass");
+  chai.add(chaiscript::user_type<ChaiScriptDerived>(), "ChaiScriptDerived");
+
+  std::string script = R""(
+    def MakeDerived() {
+      return ChaiScriptDerived(
+          // create a dynamically created array and pass it in to the constructor
+          [
+          fun(this, f, d) {
+            // see here that we are calling back into the 'this' pointer
+            return "${this.getValue()}${f * d}";
+          },
+
+          fun(this, new_val) {
+            if (new_val.size() < 5) {
+              true;
+            } else {
+              print("String ${new_val} is too long");
+              false;
+            }
+          }
+          ]
+          );
+    }
+
+    var myderived := MakeDerived(); // avoid a copy by using reference assignment :=
+
+    )"";
+
+  chai.eval(script);
+  
+  BaseClass &myderived = chai.eval<ChaiScriptDerived&>("myderived");
+
+  // at this point in the code myderived is both a ChaiScript variable and a C++ variable. In both cases
+  // it is a derivation of BaseClass, and the implementation is provided via ChaiScript functors
+  // assigned in the MakeDerived() factory function
+  //
+  // Notice that our validateValue() function has a requirement that the new string be < 5 characters long
+
+  myderived.setValue("1234");
+  assert(myderived.getValue() == "1234");
+
+  // chaiscript defined function will print out an error message and refuse to allow the setting
+  myderived.setValue("12345");
+  assert(myderived.getValue() == "1234");
+
+
+  chai.eval("myderived.setValue(\"new\")"); // set the value via chaiscript
+  assert(myderived.getValue() == "new");
+
+  // call the other derived method via chaiscript and return the value to c++ land:
+  std::string retval = chai.eval<std::string>("myderived.doSomething(2,4.3)");
+  assert(retval == "new8.6");
+
+  // The whole process is fully orthogonal
+}
+
+

samples/memory_leak_test.cpp

@@ -54,7 +54,7 @@ class test
       chaiscript::Boxed_Value val = chai.eval_file(sFile);
     }
     catch (std::exception &e) {
-      std::cout << e.what() << std::endl;
+      std::cout << e.what() << '\n';
     }
   }
 
@@ -70,12 +70,12 @@ int main(int /*argc*/, char * /*argv*/[]) {
   std::string command = "";
 
   //
-  // this loop increases memoryusage, if RunFile is not called (just hitting enter)
+  // this loop increases memory usage, if RunFile is not called (just hitting enter)
   // as soon RunFile gets called, memory will be freed.
   //
-  // scenario1 - RunFile gets called every Loop: memoryusage does not change
-  // scenario2 - RunFile gets never called (just hitting enter): memoryusage increases every loop
-  // scenario3 - RunFile gets in changing intervals: memoryusage goes up and down, but never as 
+  // scenario1 - RunFile gets called every Loop: memory usage does not change
+  // scenario2 - RunFile gets never called (just hitting enter): memory usage increases every loop
+  // scenario3 - RunFile gets in changing intervals: memory usage goes up and down, but never as
   //            low as in case 1 scenario3 :
 
   while(command != "quit")

src/main.cpp

@@ -1,14 +1,17 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <iostream>
 #include <list>
 #include <regex>
 
+#ifdef _MSC_VER
 #define _CRT_SECURE_NO_WARNINGS
+#endif
+
 #include <chaiscript/chaiscript.hpp>
 
 #ifdef READLINE_AVAILABLE
@@ -17,15 +20,15 @@
 #else
 
 char *mystrdup (const char *s) {
-  size_t len = strlen(s) + 1; // Space for length plus nul
-  char *d = static_cast<char*>(malloc (len));   
+  size_t len = strlen(s); // Space for length plus nul
+  char *d = static_cast<char*>(malloc (len+1));
   if (d == nullptr) return nullptr;          // No memory
 #ifdef CHAISCRIPT_MSVC
   strcpy_s(d, len, s);                        // Copy the characters
 #else
   strncpy(d,s,len);                        // Copy the characters
-  d[len] = '\0';
 #endif
+  d[len] = '\0';
   return d;                            // Return the new string
 }
 
@@ -136,26 +139,22 @@ std::vector<std::string> default_search_paths()
 
 void help(int n) {
   if ( n >= 0 ) {
-    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::cout << "ChaiScript evaluator.  To evaluate an expression, type it and press <enter>.\n";
+    std::cout << "Additionally, you can inspect the runtime system using:\n";
+    std::cout << "  dump_system() - outputs all functions registered to the system\n";
+    std::cout << "  dump_object(x) - dumps information about the given symbol\n";
   } else {
-    std::cout << "usage : chai [option]+" << std::endl;
-    std::cout << "option:"                << std::endl;
-    std::cout << "   -h | --help"         << std::endl;
-    std::cout << "   -i | --interactive"  << std::endl;
-    std::cout << "   -c | --command cmd"  << std::endl;
-    std::cout << "   -v | --version"      << std::endl;
-    std::cout << "   -    --stdin"        << std::endl;
-    std::cout << "   filepath"            << std::endl;
+    std::cout << "usage : chai [option]+\n";
+    std::cout << "option:"                << '\n';
+    std::cout << "   -h | --help"         << '\n';
+    std::cout << "   -i | --interactive"  << '\n';
+    std::cout << "   -c | --command cmd"  << '\n';
+    std::cout << "   -v | --version"      << '\n';
+    std::cout << "   -    --stdin"        << '\n';
+    std::cout << "   filepath"            << '\n';
   }
 }
 
-void version(int){
-  std::cout << "chai: compiled " << __TIME__ << " " << __DATE__ << std::endl;
-}
-
 bool throws_exception(const std::function<void ()> &f)
 {
   try {
@@ -231,7 +230,7 @@ void interactive(chaiscript::ChaiScript& chai)
       //Then, we try to print the result of the evaluation to the user
       if (!val.get_type_info().bare_equal(chaiscript::user_type<void>())) {
         try {
-          std::cout << chai.eval<std::function<std::string (const chaiscript::Boxed_Value &bv)> >("to_string")(val) << std::endl;
+          std::cout << chai.eval<std::function<std::string (const chaiscript::Boxed_Value &bv)> >("to_string")(val) << '\n';
         }
         catch (...) {} //If we can't, do nothing
       }
@@ -241,11 +240,11 @@ void interactive(chaiscript::ChaiScript& chai)
       if (ee.call_stack.size() > 0) {
         std::cout << "during evaluation at (" << ee.call_stack[0]->start.line << ", " << ee.call_stack[0]->start.column << ")";
       }
-      std::cout << std::endl;
+      std::cout << '\n';
     }
     catch (const std::exception &e) {
       std::cout << e.what();
-      std::cout << std::endl;
+      std::cout << '\n';
     }
   }
 }
@@ -287,7 +286,6 @@ int main(int argc, char *argv[])
   chai.add(chaiscript::fun(&myexit), "exit");
   chai.add(chaiscript::fun(&myexit), "quit");
   chai.add(chaiscript::fun(&help), "help");
-  chai.add(chaiscript::fun(&version), "version");
   chai.add(chaiscript::fun(&throws_exception), "throws_exception");
   chai.add(chaiscript::fun(&get_eval_error), "get_eval_error");
 
@@ -305,7 +303,7 @@ int main(int argc, char *argv[])
 
     if  ( arg == "-c" || arg == "--command" ) {
       if ( (i+1) >= argc ) {
-        std::cout << "insufficient input following " << arg << std::endl;
+        std::cout << "insufficient input following " << arg << '\n';
         return EXIT_FAILURE;
       } else {
         arg = argv[++i];
@@ -317,13 +315,13 @@ int main(int argc, char *argv[])
         arg += line + '\n' ;
       }
     } else if ( arg == "-v" || arg == "--version" ) {
-      arg = "version(0)" ;
+      arg = "version()" ;
     } else if ( arg == "-h" || arg == "--help" ) {
       arg = "help(-1)";
     } else if ( arg == "-i" || arg == "--interactive" ) {
       mode = eInteractive ;
     } else if ( arg.find('-') == 0 ) {
-      std::cout << "unrecognised argument " << arg << std::endl;
+      std::cout << "unrecognised argument " << arg << '\n';
       return EXIT_FAILURE;
     } else {
       mode = eFile;
@@ -332,19 +330,23 @@ int main(int argc, char *argv[])
     chaiscript::Boxed_Value val ;
     try {
       switch ( mode ) {
-        case eInteractive : interactive(chai); break;
-        case eCommand     : val = chai.eval(arg); break;
-        case eFile        : val = chai.eval_file(arg); break;
-        default           : std::cout << "Unrecognized execution mode" << std::endl; return EXIT_FAILURE;
+        case eInteractive:
+          interactive(chai);
+          break;
+        case eCommand:
+          val = chai.eval(arg);
+          break;
+        case eFile:
+          val = chai.eval_file(arg);
       }
     }
     catch (const chaiscript::exception::eval_error &ee) {
       std::cout << ee.pretty_print();
-      std::cout << std::endl;
+      std::cout << '\n';
       return EXIT_FAILURE;
     }
     catch (std::exception &e) {
-      std::cout << e.what() << std::endl;
+      std::cout << e.what() << '\n';
       return EXIT_FAILURE;
     }
   }

src/reflection.cpp

@@ -1,129 +0,0 @@
-// This file is distributed under the BSD License.
-// See "license.txt" for details.
-// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
-// http://www.chaiscript.com
-
-
-#include <chaiscript/chaiscript.hpp>
-#include <chaiscript/dispatchkit/bootstrap.hpp>
-#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
-#include <chaiscript/utility/utility.hpp>
-#include <string>
-
-
-// MSVC doesn't like that we are using C++ return types from our C declared module
-// but this is the best way to do it for cross platform compatibility
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4190)
-#endif
-
-
-bool has_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
-{
-  std::shared_ptr<const chaiscript::dispatch::Dynamic_Proxy_Function> pf
-    = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
-  if (pf)
-  {
-    if (pf->get_parse_tree())
-    {
-      return true;
-    } else {
-      return false;
-    }
-  } else {
-    return false;
-  }
-}
-
-chaiscript::AST_NodePtr get_parse_tree(const chaiscript::Const_Proxy_Function &t_pf)
-{
-  std::shared_ptr<const chaiscript::dispatch::Dynamic_Proxy_Function> pf 
-    = std::dynamic_pointer_cast<const chaiscript::dispatch::Dynamic_Proxy_Function>(t_pf);
-  if (pf)
-  {
-    if (pf->get_parse_tree())
-    {
-      return pf->get_parse_tree();
-    } else {
-      throw std::runtime_error("Function does not have a parse tree");
-    }
-  } else {
-    throw std::runtime_error("Function does not have a parse tree");
-  }
-}
-
-
-#ifdef __llvm__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
-#endif
-
-
-CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_reflection()
-{
-  chaiscript::ModulePtr m(new chaiscript::Module());
-
-  m->add(chaiscript::fun(&has_parse_tree), "has_parse_tree");
-  m->add(chaiscript::fun(&get_parse_tree), "get_parse_tree");
-
-  m->add(chaiscript::base_class<std::exception, chaiscript::exception::eval_error>());
-
-  chaiscript::bootstrap::standard_library::vector_type<std::vector<std::shared_ptr<chaiscript::AST_Node> > >("AST_NodeVector", m);
-
-  using namespace chaiscript;
-  
-  chaiscript::utility::add_class<chaiscript::exception::eval_error>(*m,
-      "eval_error",
-      { },
-      { {fun(&chaiscript::exception::eval_error::reason), "reason"},
-        {fun(&chaiscript::exception::eval_error::call_stack), "call_stack"} }
-      );
-      
-  
-  chaiscript::utility::add_class<chaiscript::File_Position>(*m,
-      "File_Position",
-      { constructor<File_Position()>(),
-        constructor<File_Position(int, int)>() },
-      { {fun(&File_Position::line), "line"},
-        {fun(&File_Position::column), "column"} }
-      );
-      
-  
-  chaiscript::utility::add_class<AST_Node>(*m, 
-  "AST_Node",
-  {  },
-  { {fun(&AST_Node::text), "text"},
-    {fun(&AST_Node::identifier), "identifier"},
-    {fun(&AST_Node::filename), "filename"},
-    {fun(&AST_Node::start), "start"},
-    {fun(&AST_Node::end), "end"},
-    {fun(&AST_Node::internal_to_string), "internal_to_string"},
-    {fun(&AST_Node::children), "children"},
-    {fun(&AST_Node::replace_child), "replace_child"}
-  }
-  );
-  
-  
-  chaiscript::utility::add_class<parser::ChaiScript_Parser>(*m,
-      "ChaiScript_Parser",
-      { constructor<parser::ChaiScript_Parser ()>() },
-      { {fun(&parser::ChaiScript_Parser::parse), "parse"},
-        {fun(&parser::ChaiScript_Parser::ast), "ast"} }
-      );
-      
-
-
-  return m;
-}
-
-#ifdef __llvm__
-#pragma clang diagnostic pop
-#endif
-
-
-
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(pop)
-#endif

src/stl_extra.cpp

@@ -1,7 +1,7 @@
 // This file is distributed under the BSD License.
 // See "license.txt" for details.
 // Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
-// Copyright 2009-2014, Jason Turner (jason@emptycrate.com)
+// Copyright 2009-2015, Jason Turner (jason@emptycrate.com)
 // http://www.chaiscript.com
 
 #include <chaiscript/chaiscript.hpp>

src/test_module.cpp

@@ -2,12 +2,15 @@
 #include <chaiscript/chaiscript.hpp>
 #include <string>
 
+
+
 class TestBaseType
 {
   public:
     TestBaseType() : val(10), const_val(15) { }
     TestBaseType(int) : val(10), const_val(15) {}
-    TestBaseType(int *) : val(10), const_val(15) {}
+    TestBaseType(int *) : val(10), const_val(15) { }
+    TestBaseType(const TestBaseType &) = default;
     virtual ~TestBaseType() {}
     virtual int func() { return 0; }
 
@@ -22,6 +25,30 @@ class TestBaseType
     TestBaseType &operator=(const TestBaseType &);
 };
 
+class Type2
+{
+  public:
+    Type2(TestBaseType t_bt)
+      : m_bt(std::move(t_bt)),
+        m_str("Hello World")
+    {
+    }
+
+    int get_val() const
+    {
+      return m_bt.val;
+    }
+
+    const char *get_str() const
+    {
+      return m_str.c_str();
+    }
+
+  private:
+    TestBaseType m_bt;
+    std::string m_str;
+};
+
 enum TestEnum
 {
   TestValue1 = 1
@@ -36,6 +63,8 @@ class TestDerivedType : public TestBaseType
 {
   public:
     virtual ~TestDerivedType() {}
+    TestDerivedType(const TestDerivedType &) = default;
+    TestDerivedType() = default;
     virtual int func() CHAISCRIPT_OVERRIDE { return 1; }
     int derived_only_func() { return 19; }
 
@@ -46,17 +75,24 @@ class TestDerivedType : public TestBaseType
 class TestMoreDerivedType : public TestDerivedType
 {
   public:
+    TestMoreDerivedType(const TestMoreDerivedType &) = default;
+    TestMoreDerivedType() = default;
     virtual ~TestMoreDerivedType() {}
 };
 
 std::shared_ptr<TestBaseType> derived_type_factory()
 {
-  return std::shared_ptr<TestBaseType>(new TestDerivedType());
+  return std::make_shared<TestDerivedType>();
 }
 
 std::shared_ptr<TestBaseType> more_derived_type_factory()
 {
-  return std::shared_ptr<TestBaseType>(new TestMoreDerivedType());
+  return std::make_shared<TestMoreDerivedType>();
+}
+
+std::shared_ptr<TestBaseType> null_factory()
+{
+  return std::shared_ptr<TestBaseType>();
 }
 
 std::string hello_world()
@@ -64,9 +100,11 @@ std::string hello_world()
   return "Hello World";
 }
 
+static int global_i = 1;
+
 int *get_new_int()
 {
-  return new int(1);
+  return &global_i;
 }
 
 // MSVC doesn't like that we are using C++ return types from our C declared module
@@ -90,6 +128,7 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
   m->add(chaiscript::user_type<TestBaseType>(), "TestBaseType");
   m->add(chaiscript::user_type<TestDerivedType>(), "TestDerivedType");
   m->add(chaiscript::user_type<TestMoreDerivedType>(), "TestMoreDerivedType");
+  m->add(chaiscript::user_type<Type2>(), "Type2");
 
   m->add(chaiscript::constructor<TestBaseType ()>(), "TestBaseType");
 //  m->add(chaiscript::constructor<TestBaseType (int)>(), "TestBaseType");
@@ -111,6 +150,7 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
 
   m->add(chaiscript::fun(&derived_type_factory), "derived_type_factory");
   m->add(chaiscript::fun(&more_derived_type_factory), "more_derived_type_factory");
+  m->add(chaiscript::fun(&null_factory), "null_factory");
 
   m->add(chaiscript::fun(&TestDerivedType::func), "func");
 
@@ -129,6 +169,12 @@ CHAISCRIPT_MODULE_EXPORT  chaiscript::ModulePtr create_chaiscript_module_test_mo
   m->add(chaiscript::fun(&to_int), "to_int");
   m->add(chaiscript::fun(&TestBaseType::constMe), "constMe");
 
+  m->add(chaiscript::type_conversion<TestBaseType, Type2>([](const TestBaseType &t_bt) { return Type2(t_bt); }));
+
+  m->add(chaiscript::fun(&Type2::get_val), "get_val");
+  m->add(chaiscript::fun(&Type2::get_str), "get_str");
+  m->add(chaiscript::type_conversion<const char *, std::string>());
+  m->add(chaiscript::constructor<Type2 (const TestBaseType &)>(), "Type2");
 
   return m;
 }

unittests/3.x/eval_error.chai

@@ -1,4 +1,3 @@
-load_module("reflection")
 
 def deep()
 {

unittests/3.x/reflection_test.chai

@@ -1,4 +1,3 @@
-load_module("reflection")
 var parser := ChaiScript_Parser()
 var parse_success = parser.parse("3 + 4", "INPUT")
 var a := parser.ast()

unittests/boxed_cast_test.cpp

@@ -15,16 +15,16 @@ bool run_test_type_conversion(const Boxed_Value &bv, bool expectedpass)
     use(ret);
   } catch (const chaiscript::exception::bad_boxed_cast &/*e*/) {
     if (expectedpass) {
-//      std::cerr << "Failure in run_test_type_conversion: " << e.what() << std::endl;
+//      std::cerr << "Failure in run_test_type_conversion: " << e.what() << '\n';
       return false;
     } else {
       return true;
     }
   } catch (const std::exception &e) {
-    std::cerr << "Unexpected standard exception when attempting cast_conversion: " << e.what() << std::endl;
+    std::cerr << "Unexpected standard exception when attempting cast_conversion: " << e.what() << '\n';
     return false;
   } catch (...) {
-    std::cerr << "Unexpected unknown exception when attempting cast_conversion." << std::endl;
+    std::cerr << "Unexpected unknown exception when attempting cast_conversion.\n";
     return false;
   }
  
@@ -47,7 +47,7 @@ bool test_type_conversion(const Boxed_Value &bv, bool expectedpass)
       << (bv.is_const()?(std::string("const ")):(std::string())) << bv.get_type_info().name() 
       << " To: "  
       << (std::is_const<To>::value?(std::string("const ")):(std::string())) << typeid(To).name() 
-      << " test was expected to " << ((expectedpass)?(std::string("succeed")):(std::string("fail"))) << " but did not" << std::endl;
+      << " test was expected to " << ((expectedpass)?(std::string("succeed")):(std::string("fail"))) << " but did not\n";
   }
 
   return ret;
@@ -264,21 +264,26 @@ bool pointer_test(const T& default_value, const T& new_value)
 
 
     if (p != (*result) ) { 
-      std::cerr << "Pointer passed in different than one returned" << std::endl;
+      std::cerr << "Pointer passed in different than one returned\n";
+      delete p;
       return false;
     }
 
     if (*p != *(*result) ) {
-      std::cerr << "Somehow dereferenced pointer values are not the same?" << std::endl;
+      std::cerr << "Somehow dereferenced pointer values are not the same?\n";
+      delete p;
       return false;
     }
 
+    delete p;
     return true;
   } catch (const exception::bad_boxed_cast &) {
-    std::cerr << "Bad boxed cast performing ** to ** test" << std::endl;
+    std::cerr << "Bad boxed cast performing ** to ** test\n";
+    delete p;
     return false;
   } catch (...) {
-    std::cerr << "Unknown exception performing ** to ** test" << std::endl;
+    std::cerr << "Unknown exception performing ** to ** test\n";
+    delete p;
     return false;
   }
 

unittests/class.chai

@@ -0,0 +1,27 @@
+
+class Vector3
+{
+  // you can use attr, auto or var in this context
+  attr x
+  auto y
+  var z
+
+  def Vector3(x,y,z)
+  {
+    this.x = x
+    this.y = y
+    this.z = z
+  }
+
+  def doSomething(mult)
+  {
+    return this.x * this.y * this.z * mult
+  }
+
+}
+
+
+auto v = Vector3(1,2,3)
+assert_equal(1, v.x)
+assert_equal(v.doSomething(2), 12)
+

unittests/divide_by_zero_protection.chai

@@ -0,0 +1,9 @@
+try {
+  3/0
+  assert_true(false); // should never get here
+} catch (e) {
+  assert_equal("Arithmetic error: divide by zero", e.what())
+}
+
+assert_equal(3/0.0, Infinity)
+

unittests/dynamic_object_test.cpp

@@ -8,7 +8,7 @@ void assert_equal(const LHS &lhs, const RHS &rhs)
   {
     return;
   } else {
-    std::cout << "Got: " << lhs << " expected " << rhs << std::endl;
+    std::cout << "Got: " << lhs << " expected " << rhs << '\n';
     exit(EXIT_FAILURE);
   }
 }

unittests/eval_catch_exception_test.cpp

@@ -16,7 +16,7 @@ int test_generic()
     }
   }
 
-  std::cout << "test_generic failed" << std::endl;
+  std::cout << "test_generic failed\n";
   return EXIT_FAILURE;
 }
 
@@ -33,7 +33,7 @@ int test_1()
     }
   }
 
-  std::cout << "test_1 failed" << std::endl;
+  std::cout << "test_1 failed\n";
   return EXIT_FAILURE;
 }
 
@@ -50,7 +50,7 @@ int test_2()
     }
   }
 
-  std::cout << "test_2 failed" << std::endl;
+  std::cout << "test_2 failed\n";
   return EXIT_FAILURE;
 }
 
@@ -61,22 +61,22 @@ int test_5()
   try {
     chai.eval("throw(runtime_error(\"error\"))", chaiscript::exception_specification<int, double, float, const std::string &, const std::exception &>());
   } catch (const double) {
-    std::cout << "test_5 failed with double" << std::endl;
+    std::cout << "test_5 failed with double\n";
     return EXIT_FAILURE;
   } catch (int) {
-    std::cout << "test_5 failed with int" << std::endl;
+    std::cout << "test_5 failed with int\n";
     return EXIT_FAILURE;
   } catch (float) {
-    std::cout << "test_5 failed with float" << std::endl;
+    std::cout << "test_5 failed with float\n";
     return EXIT_FAILURE;
   } catch (const std::string &) {
-    std::cout << "test_5 failed with string" << std::endl;
+    std::cout << "test_5 failed with string\n";
     return EXIT_FAILURE;
   } catch (const std::exception &) {
     return EXIT_SUCCESS;
   }
 
-  std::cout << "test_5 failed" << std::endl;
+  std::cout << "test_5 failed\n";
   return EXIT_FAILURE;
 }
 
@@ -87,22 +87,22 @@ int test_unhandled()
   try {
     chai.eval("throw(\"error\")", chaiscript::exception_specification<int, double, float, const std::exception &>());
   } catch (double) {
-    std::cout << "test_unhandled failed with double" << std::endl;
+    std::cout << "test_unhandled failed with double\n";
     return EXIT_FAILURE;
   } catch (int) {
-    std::cout << "test_unhandled failed with int" << std::endl;
+    std::cout << "test_unhandled failed with int\n";
     return EXIT_FAILURE;
   } catch (float) {
-    std::cout << "test_unhandled failed with float" << std::endl;
+    std::cout << "test_unhandled failed with float\n";
     return EXIT_FAILURE;
   } catch (const std::exception &) {
-    std::cout << "test_unhandled failed with std::exception" << std::endl;
+    std::cout << "test_unhandled failed with std::exception\n";
     return EXIT_FAILURE;
   } catch (const chaiscript::Boxed_Value &) {
     return EXIT_SUCCESS;
   }
 
-  std::cout << "test_unhandled failed" << std::endl;
+  std::cout << "test_unhandled failed\n";
   return EXIT_FAILURE;
 }
 

unittests/eval_error.chai

@@ -1,4 +1,3 @@
-load_module("reflection")
 
 def deep()
 {

unittests/exception_typed.chai

@@ -0,0 +1,21 @@
+auto x = 1
+try {
+  throw(x)
+  x = 2
+}
+catch(int e) {
+  x = e + 3
+}
+assert_equal(4, x);
+
+x = 1
+try {
+  throw(x)
+  x = 2
+}
+catch(string e) {
+}
+catch(e) {
+  x = e + 4
+}
+assert_equal(5, x);

unittests/exception_typed_2.chai

@@ -0,0 +1,34 @@
+auto results = [];
+
+for (auto i = 2; i < 6; ++i) {
+  try {
+    throw(i)
+  }
+  catch(int e) : e < 2 {
+    results.push_back("c1: " + e.to_string());
+  }
+  catch(int e) : e < 4 {
+    results.push_back("c2: " + e.to_string());
+  }
+  catch(e) {
+    results.push_back("c3: " + e.to_string());
+  }
+  catch {
+    // Should never get called
+    assert_equal(false, true)
+  }
+}
+
+try {
+  throw(3)
+}
+catch(int e) : e < 3 
+{
+  // Should never get called
+  assert_equal(false, true);
+}
+catch {
+  results.push_back("defaultcatch");
+}
+
+assert_equal(["c2: 2", "c2: 3", "c3: 4", "c3: 5", "defaultcatch"], results);

unittests/functor_cast_test.cpp

@@ -1,6 +1,6 @@
 #include <chaiscript/utility/utility.hpp>
 
-double test_call(const std::function<double (int)> &f, int val)
+int test_call(const std::function<int (int)> &f, int val)
 {
   return f(val);
 }
@@ -9,15 +9,15 @@ int main()
 {
 
   chaiscript::ChaiScript chai;
-  
+
   chai.add(chaiscript::fun(&test_call), "test_call");
 
-  chai.eval("def func(i) { return i * 3.5; };");
-  double d = chai.eval<double>("test_call(func, 3)");
-  
-  if (d == 3 * 3.5)
+  chai.eval("def func(i) { return i * 6; };");
+  int d = chai.eval<int>("test_call(func, 3)");
+
+  if (d == 3 * 6)
   {
-    return EXIT_SUCCESS;  
+    return EXIT_SUCCESS;
   } else {
     return EXIT_FAILURE;
   }

unittests/future.chai

@@ -0,0 +1,15 @@
+var func = fun(){
+  var ret = 0;
+  for (var i = 0; i < 50000; ++i) {
+    ret += i;
+  }
+  return ret;
+}
+
+
+var fut1 := async(func);
+var fut2 := async(func);
+
+// simply executing without crashing is good enough for this test
+
+print(" ${fut1.get()} ${fut2.get()} ")

unittests/integer_literal_test.cpp

@@ -7,7 +7,7 @@ bool test_literal(T val, const std::string &str)
 {
   chaiscript::ChaiScript chai;
   T val2 = chai.eval<T>(str);
-  std::cout << "Comparing : " << val << " " << val2 << std::endl;
+  std::cout << "Comparing : " << val << " " << val2 << '\n';
   return val == val2;
 }
 

unittests/null_object_access.chai

@@ -0,0 +1,13 @@
+load_module("test_module")
+
+auto o := null_factory();
+
+try {
+  o.func();
+} catch (e) {
+  exit(0);
+}
+
+assert_true(false);
+
+

unittests/object_lifetime_test2.cpp

@@ -0,0 +1,70 @@
+#include <chaiscript/chaiscript.hpp>
+#include <chaiscript/chaiscript_stdlib.hpp>
+
+template<typename T>
+struct Vector2
+{
+  Vector2() : x(0), y(0) {}
+  Vector2(T px, T py) : x(px), y(py) {}
+  Vector2(const Vector2& cp) : x(cp.x), y(cp.y) {}
+
+  Vector2& operator+=(const Vector2& vec_r)
+  {
+    x += vec_r.x;
+    y += vec_r.y;
+    return *this;
+  }
+
+  Vector2 operator+(const Vector2& vec_r)
+  {
+    return Vector2(*this += vec_r);
+  }
+
+  Vector2 &operator=(const Vector2& ver_r)
+  {
+    x = ver_r.x;
+    y = ver_r.y;
+    return *this;
+  }
+
+
+  T x;
+  T y;
+};
+
+Vector2<float> GetValue()
+{
+  return Vector2<float>(10,15);
+}
+
+int main()
+{
+  chaiscript::ChaiScript _script(chaiscript::Std_Lib::library());
+
+  //Registering stuff
+  _script.add(chaiscript::user_type<Vector2<float>>(), "Vector2f");
+  _script.add(chaiscript::constructor<Vector2<float> ()>(), "Vector2f");
+  _script.add(chaiscript::constructor<Vector2<float> (float, float)>(), "Vector2f");
+  _script.add(chaiscript::constructor<Vector2<float> (const Vector2<float>&)>(), "Vector2f");
+  _script.add(chaiscript::fun(&Vector2<float>::x), "x");
+  _script.add(chaiscript::fun(&Vector2<float>::y), "y");
+  _script.add(chaiscript::fun(&Vector2<float>::operator +), "+");
+  _script.add(chaiscript::fun(&Vector2<float>::operator +=), "+=");
+  _script.add(chaiscript::fun(&Vector2<float>::operator =), "=");
+  _script.add(chaiscript::fun(&GetValue), "getValue");
+
+  _script.eval(R"(
+    var test = 0.0
+    var test2 = Vector2f(10,10)
+
+    test = getValue().x
+    print(test)
+    print(test2.x)
+    )");
+
+  if (_script.eval<std::string>("to_string(test)") != "10") { return EXIT_FAILURE; }
+  if (_script.eval<std::string>("to_string(test2.x)") != "10") { return EXIT_FAILURE; }
+
+
+  //_script.eval_file("object_lifetime_test2.inc");
+}

unittests/operator_scoping.chai

@@ -1,4 +1,3 @@
-load_module("reflection")
 
 try {
   eval("def `+`(x, y) \n { \n print(i); \n } \n \n var i = 10; \n \"1\" + 1;\n")

unittests/range.chai

@@ -2,3 +2,9 @@ auto x = [1, 2, 3, 4]
 auto r = range(x)
 r.pop_front()
 assert_equal(2, r.front());
+
+// test with temporary vector for range
+auto q = range([1, 2, 3, 4])
+q.pop_front()
+assert_equal(2, q.front());
+

unittests/reflection_test.chai

@@ -1,4 +1,3 @@
-load_module("reflection")
 auto& parser = ChaiScript_Parser()
 auto parse_success = parser.parse("3 + 4", "INPUT")
 auto& a = parser.ast()

unittests/type_info_test.cpp

@@ -2,6 +2,7 @@
 
 #include <chaiscript/chaiscript_defines.hpp>
 #include <chaiscript/dispatchkit/type_info.hpp>
+#include <iostream>
 #include <cstdlib>
 
 void test_type(const chaiscript::Type_Info &ti, bool t_is_const, bool t_is_pointer, bool t_is_reference, bool t_is_void,
@@ -30,5 +31,7 @@ int main()
   test_type(chaiscript::user_type<const int *>(), true, true, false, false, false);
   test_type(chaiscript::Type_Info(), false, false, false, false, true);
 
+  std::cout << "Size of Type_Info " << sizeof(chaiscript::Type_Info) << '\n';
+
   return EXIT_SUCCESS;
 }

unittests/type_name_test.cpp

@@ -0,0 +1,22 @@
+// Tests to make sure that the order in which function dispatches occur is correct
+
+#include <chaiscript/chaiscript.hpp>
+#include <cstdlib>
+
+class MyClass
+{
+};
+
+int main()
+{
+  chaiscript::ChaiScript chai;
+  auto type = chaiscript::user_type<MyClass>();
+  chai.add(type, "MyClass");
+
+  if (chai.get_type_name(type) == "MyClass" && chai.get_type_name<MyClass>() == "MyClass")
+  {
+    return EXIT_SUCCESS;
+  } else {
+    return EXIT_FAILURE;
+  }
+}

unittests/user_defined_conversions.chai

@@ -0,0 +1,11 @@
+
+add_type_conversion(type("string"), type("Type_Info"), fun(s) { return type(s); });
+
+// This looks simple, but it takes the string "string" and using the registered
+// conversion above, automatically converts that into a Type_Info object, which then
+// allows the Type_Info.name() function to be called
+
+assert_equal("string".name(), "string");
+
+
+

unittests/user_defined_conversions_2.chai

@@ -0,0 +1,27 @@
+load_module("test_module")
+
+auto t := TestBaseType();
+
+// This uses the TestBaseType to Type2 user type
+// conversion which was added in the module and then calls
+// "get_val()" which exists on the Type2 type
+//assert_equal(t.get_val(), 10);
+//print("Made it past test 1");
+
+var t2 := Type2(t);
+var str = string(get_str(t2));
+
+assert_equal("Hello World", str);
+print("Made it past test 2");
+
+assert_equal(11, size(get_str(t2)));
+print("Made it past test 3");
+
+
+assert_equal(11, t2.get_str().size());
+print("Made it past test 4");
+
+assert_equal(11, t.get_str().size());
+print("Made it past test 5");
+
+